Skip to content
Sign in

workflow

Multi-agent work on the kanban board, one workflow run per wave: the ticket strategy of iii/deepwork (a run ticket, subtask cards, bounded rounds, independent verification) with every phase as a workflow node, each one with its own profile and model, retried by the run's check loop. Code goals get one worktree per ticket, one tests-and-check run per integrated wave and a kept branch. Installs beside iii/deepwork.

InstallLatest

# With the iii engine running

iii trigger directory::download-kit kit=iii/workflow
6Installs
6Last 7 days
0Today
30 days

Exact versions are immutable. Every profile and skill is stored by its SHA-256, so updates show exactly what changed.

v0.1.4 → v0.1.5

Release notes · v0.1.5
  • The batch check finds an already verified card's fallout by its landed commit. Since 0.1.4 commits carry no ticket key, so the In range: line now gives each card's landed sha and the check looks it up with git log --format=%H.
  • An empty plan_model takes a given check_model before the model list, as the arguments table says.
  • The automatic choice no longer skips past the next size down. It finds the size right below the orchestrator's first, and stays on the orchestrator's model when that size is the smallest or has a smaller context window.
  • A model a start refuses does not use up the start's three sends while its cell has another id, so every listed model gets a try.

Profiles

2 changes
modifiedagents/workflow-verifier.md+1-1
@@ -27,7 +27,7 @@
2727 3. **Plain mode** (the task says `Mode: check`). Read the ticket with `kanban::ticket::get` first (a `Card:` block in the task is the card itself: read no ticket): its Acceptance items with their Verify calls, and comments by authors other than `workflow`, are the criteria. Run every Verify call as its own call with its literal function id and args. Then attack what the claim admits: each "not verified" the card's opening sentence or **Result** needs gets one read-only call. Then its sources: with read-only calls, open the source of up to three claims of the result that the card's opening sentence or **Result** bullet needs most; a claim with neither a source nor an `(unsourced)` mark, or whose source does not say it, is a reason: `source: expected <the claim> in <source>, observed <what the source says>`. A file another ticket owns proves nothing: siblings run at the same time.
2828 4. **Batch mode** (the task says `Mode: batch-check`). Read every `Batch:` card, comments included (cards given in the task are read there). In the Worktree, run `git rev-parse HEAD` and `git rev-parse --verify <the claim's commit>^{commit}`: they must print the same sha (a short claim counts). Put HEAD's sha in your `commit`. A claim commit that does not resolve, or resolves to another commit, is `fail` with the reason `commit: report what git rev-parse HEAD prints, observed <HEAD>`; never ask for history to be rewritten or a commit to be recreated.
2929 - Verify: run each distinct command once, every card's Verify calls and the project's test, build and lint commands from Functions together, chained in one long run by the recipe (`cmd; echo "cmd=$?"` per command, never after a pipe). A failure listed under `Known red at base` is not this batch's unless the batch made it worse. Every Acceptance line must hold.
30- - Review: read `git diff <Range>`. On a repeated pass, `loop_previous` in your opening message is your own last verdict: first check that each of its reasons is fixed. For a card its `cards` marks `pass`, review only what `git diff <its commit>..HEAD` changes in its paths; every other card in full. Every changed path must be in the union of the Batch cards' **Files** and **Tests** paths, or be fallout of a Batch card's change (recorded in `checks` as `fallout: <path>: <KEY>: <cause>`), or belong to an `In range:` card and be unchanged since the sha it was verified at (`git diff <sha>..HEAD -- <path>` prints nothing): one of its **Files** or **Tests** paths, or its fallout (`git log --format=%s <Range> -- <path>` lists a commit ending in ` (<its KEY>)`). Those cards are already verified: review nothing else of them. Each card's required tests must exist, assert its Acceptance through the entry point its **Tests** bullet names (none named: the one its opening sentence describes), with no expected value computed by a copy of the implementation and no assertion that cannot fail, and not be weakened, skipped or deleted. The changes must implement every card's opening sentence and **Implement** bullet and carry no debug leftover, TODO, ticket key in a comment or test name, secret, swallowed error, silenced check no card asks for (a lint or type ignore, a looser check config, a sleep or retry added so a test passes), lean defect (rule 8) or broken standard (rule 9). Ground each finding as `<file>:<line>: <problem>`; prefix missing coverage with `test:`.
30+ - Review: read `git diff <Range>`. On a repeated pass, `loop_previous` in your opening message is your own last verdict: first check that each of its reasons is fixed. For a card its `cards` marks `pass`, review only what `git diff <its commit>..HEAD` changes in its paths; every other card in full. Every changed path must be in the union of the Batch cards' **Files** and **Tests** paths, or be fallout of a Batch card's change (recorded in `checks` as `fallout: <path>: <KEY>: <cause>`), or belong to an `In range:` card and be unchanged since the sha it was verified at (`git diff <sha>..HEAD -- <path>` prints nothing): one of its **Files** or **Tests** paths, or its fallout (`git log --format=%H <Range> -- <path>` lists its landed sha from the `In range:` line). Those cards are already verified: review nothing else of them. Each card's required tests must exist, assert its Acceptance through the entry point its **Tests** bullet names (none named: the one its opening sentence describes), with no expected value computed by a copy of the implementation and no assertion that cannot fail, and not be weakened, skipped or deleted. The changes must implement every card's opening sentence and **Implement** bullet and carry no debug leftover, TODO, ticket key in a comment or test name, secret, swallowed error, silenced check no card asks for (a lint or type ignore, a looser check config, a sleep or retry added so a test passes), lean defect (rule 8) or broken standard (rule 9). Ground each finding as `<file>:<line>: <problem>`; prefix missing coverage with `test:`.
3131 - `cards` maps every Batch card to `pass`, `fail` or `unsure`; `verdict` is `pass` only when every card passes.
3232 5. **Baseline mode** (the task says `Mode: baseline`). Run the task's `Run first:` command when it is not `none` (a failure is `unsure` with `setup failed: <error>`), then the commands it lists, chained in one long run, and answer `pass` when every one exits 0, else `fail` with one reason per failing command and the failures from its output. The setup command is the only thing allowed to write.
3333 6. **Critic mode** (the task says `Mode: critic`). Read the goal as the task says. List what the goal still needs as `new_items`, as few as a person would review: one item per deliverable, every finding in the same files or on the same question in one item, at most the count in your task. Each `card` is a full card: a one-sentence summary; in a dev run, then `## Change` with **Files**, **Implement**, **Tests** and **Commit** bullets; then `## Acceptance` with `- [ ]` items, each with its `Verify:` call; then `## Scope`. What the goal does not need goes to `loose_ends`, one line each; a check you could not run (a missing tool, a denied call) is not a loose end: put it in `checks`. With nothing missing, answer `pass`, else `fail`. In a dev run, run the full suite and the linter once and review `git diff <Range>`: a defect in code this run committed, a lean defect (rule 8) included, goes into a `new_item` with a dev card, grouped with the other defects in its files, never a loose end, whatever its severity. Prove each one with the failing output of a check you ran, or add `- **Not proven:** <why>` under its `## Scope`.
modifiedagents/workflow.md+4-4
@@ -131,11 +131,11 @@
131131
132132 ## Models
133133
134-At Step A, read your own model from `harness::metrics {"session_id":"<own>","omit_context":true}` (your session's `by_model` row) and, once, `router::models::list {}` (the catalog). For each tier (`workflow-worker`, `workflow-impl`, `workflow-verifier`, `workflow-planner`) call `directory::agents::get {"id":"<tier>"}`: a non-null `model` is a pin, so that tier's nodes pass no `model`. Otherwise its nodes pass `"model":"<the model id>"` (the templates write it as `"model":"<work model>"`, `<check model>` or `<plan model>`; leave the pair out for a pinned tier): `work_model` for the work tiers and the explore nodes, `check_model` for the verifier, `plan_model` for the design, refute and plan nodes, else the stage's listed model, else your own model; with no `work_model` and no row for your provider, `<work model>` is the auto model. A model you pass must be the `id` of a row of `router::models::list` with tools; otherwise stop and say so. Write the result as the `- **Models:**` bullet of R's `## Run` list (Step A.4): plan, check and work, each `<m>` (pin, given, list, auto or own); on a resume, rewrite that bullet in place.
134+At Step A, read your own model from `harness::metrics {"session_id":"<own>","omit_context":true}` (your session's `by_model` row) and, once, `router::models::list {}` (the catalog). For each tier (`workflow-worker`, `workflow-impl`, `workflow-verifier`, `workflow-planner`) call `directory::agents::get {"id":"<tier>"}`: a non-null `model` is a pin, so that tier's nodes pass no `model`. Otherwise its nodes pass `"model":"<the model id>"` (the templates write it as `"model":"<work model>"`, `<check model>` or `<plan model>`; leave the pair out for a pinned tier): `work_model` for the work tiers and the explore nodes, `check_model` for the verifier, `plan_model` (empty: `check_model`) for the design, refute and plan nodes, else the stage's listed model, else your own model; with no `work_model` and no row for your provider, `<work model>` is the auto model. A model you pass must be the `id` of a row of `router::models::list` with tools; otherwise stop and say so. Write the result as the `- **Models:**` bullet of R's `## Run` list (Step A.4): plan, check and work, each `<m>` (pin, given, list, auto or own); on a resume, rewrite that bullet in place.
135135
136136 **Listed models** (models=own: none). Also call `directory::agents::get {"id":"workflow-models"}`: its `system_prompt` holds a table with one row per provider and a `plan`, `check` and `work` cell of model ids, best first, for `<plan model>`, `<check model>` and `<work model>`. Your row is the one named as the `provider` of your model's catalog row. A stage's listed model is the first id of its cell that is the `id` of a catalog row with tools and is not in `skip_models`; the others are skipped, never an error. With a row, only the row counts: a stage whose cell has no such id is on your own model, and there is no auto model. A failed call, no table or no row: no listed models.
137137
138-**Auto model** (no row for your provider; models=own, or an auto model in `skip_models`: your own model). One model for the run: the next size down in your provider's line-up. Find your model's row in the catalog. Of the rows with its `provider`, tools, thinking and a `context_window` no smaller than its own, keep the newest version of each size. Only the sizes below yours matter, and a size you cannot place is left out: the auto model is the largest of them, by `pricing` where the rows carry it, else by what you know of their names, and never the smallest size of the line-up. An older version or a speed variant is never a smaller size. No size below yours, or doubt about which one is right below yours: your own model. Never guess.
138+**Auto model** (no row for your provider; models=own, or an auto model in `skip_models`: your own model). One model for the run: the next size down in your provider's line-up. Find your model's row in the catalog. Of the rows with its `provider`, tools and thinking, keep the newest version of each size. Only the sizes below yours matter, and a size you cannot place is left out: the auto model is the largest of them, by `pricing` where the rows carry it, else by what you know of their names; when that one is the smallest size of the line-up or has a smaller `context_window` than yours, your own model. An older version or a speed variant is never a smaller size. No size below yours, or doubt about which one is right below yours: your own model. Never guess.
139139
140140 **It gets one round.** A node that would pass the listed or auto work model passes `<plan model>` instead, in every round, when it is the `<k>-work` or `<k>-code` node of a ticket whose card has a `Hard` bullet (Step A.8). Any other one passes `<check model>` instead (your own when the verifier is pinned) when it is the synth node (nothing checks it), when its task carries a `Retry:` line, or when it is a wave or batch node of the last round (N ≥ max_rounds). A `node_timeout` on that work model is a retry, never a sign the work needs longer.
141141
@@ -285,7 +285,7 @@
285285 `"<k>-check":{"profile":"workflow-verifier","model":"<check model>","schema":VERDICT,"reads":"<k>-work","task":"Mode: check. Ticket <KEY>, run <run>, round <N>. The input is the claim.\nDeadline: <verify_deadline_min> min.\nFunctions: <Functions>","label":"verify:<KEY>","phase":"verify","timeout_ms":…,"loop":<the check loop on <k>-work>}`.
286286 - **Dev flow**, per ticket: `"<k>-code":{"profile":"workflow-impl","model":"<work model>","schema":CODE,"filesystem_root":"<W_K>","task":"Mode: code. Ticket <KEY>, run <run>, round <N>.\nWorktree: <W_K>. Branch: workflow/<slug>-<k>.\nDeadline: <deadline_min> min.\n<Retry: <reasons>.\n>Functions: <Functions>","label":"<KEY> · <title>","phase":"implement","timeout_ms":…}`. Tests and checks run once per wave, in Step E.
287287
288-A refused start: fix what the error names and send it again while each refusal names a different problem, at most 3 sends in all (the key returns a run that did start). Still refused: move the wave's tickets back to `todo` and finish with `blocked: workflow::start: <error>`.
288+A refused start: fix what the error names and send it again while each refusal names a different problem, at most 3 sends in all (the key returns a run that did start); a refused model is not one of them while its cell has another id (Models). Still refused: move the wave's tickets back to `todo` and finish with `blocked: workflow::start: <error>`.
289289
290290 ## Step D: on a wake
291291
@@ -322,7 +322,7 @@
322322
323323 B = the integrated cards of the wave (wave 0: the pointer's `batch.keys`). First write the pointer's `batch` = `{"item":"batch","keys":<B keys>,"scope":<B keys; wave 0: the stored scope>,"base":"<the wave's base sha: W's HEAD before its first cherry-pick; wave 0: the stored base>","verified":"<wave 0: the stored verified; otherwise the base>","reasons":<wave 0: the stored reasons; otherwise []>}`, then check the disk as in Step A.6 (under min_free_gb: finish with `blocked: disk`; B stays for a resume). Start the batch run (label `r<N>-w<b>-batch`), `"output":"batch-check"`, with two nodes:
324324 - `"batch-work":{"profile":"workflow-impl","model":"<work model>","schema":CODE,"filesystem_root":"<W>","task":"Mode: batch. Run ticket <R>, round <N>.\nBatch: <B keys>\nRange: <base>..<branch>\n<wave 0, when the pointer's batch.scope has keys outside B: In range: <those keys> (already verified: their changes in the Range are not this batch's)\n>Code results: <KEY>: <summary> (landed <sha>) …\nCommit: test(<the first B card's Commit scope>): cover <the B cards' Commit summaries, comma-separated, ≤60 chars>\nWorktree: <W>. Branch: <branch>.\nDeadline: <deadline_min> min.\n<wave 0: Retry: <the pointer's batch.reasons>. The cards are already integrated on <branch>: write the coverage still missing and repair tests or code within their Files; never re-implement them.\n>Functions: <Functions>","label":"verify:tests r<N>w<b>","phase":"verify","timeout_ms":…}`
325-- `"batch-check":{"profile":"workflow-verifier","model":"<check model>","schema":VERDICT,"filesystem_root":"<W>","reads":"batch-work","task":"Mode: batch-check. Run ticket <R>, round <N>. The input is the claim.\nBatch: <B keys>\nRange: <base>..<branch>\n<wave 0, when the pointer's batch.scope has keys outside B: In range: <those keys> (verified at <the pointer's batch.verified>: their changes up to it are not this batch's)\n>Worktree: <W>.\nDeadline: <verify_deadline_min> min.\nFunctions: <Functions>","label":"verify:check r<N>w<b>","phase":"verify","timeout_ms":…,"loop":<the check loop on batch-work>}`
325+- `"batch-check":{"profile":"workflow-verifier","model":"<check model>","schema":VERDICT,"filesystem_root":"<W>","reads":"batch-work","task":"Mode: batch-check. Run ticket <R>, round <N>. The input is the claim.\nBatch: <B keys>\nRange: <base>..<branch>\n<wave 0, when the pointer's batch.scope has keys outside B: In range: <those keys, each with (landed <its sha>) from its terminal comment> (verified at <the pointer's batch.verified>: their changes up to it are not this batch's)\n>Worktree: <W>.\nDeadline: <verify_deadline_min> min.\nFunctions: <Functions>","label":"verify:check r<N>w<b>","phase":"verify","timeout_ms":…,"loop":<the check loop on batch-work>}`
326326
327327 When it ends, cwd = W: `git rev-parse HEAD` and `git status --porcelain=v1`. The batch passed when the verdict is `pass`, its `commit` equals HEAD and the status is empty: every B card goes to `done`, `verified`, with its terminal comment (landed: its sha; batch: the verdict's commit), and the pointer's `batch` loses its keys. Otherwise, when the verdict's `commit` equals HEAD and the status is empty, a card whose `cards` entry is `pass`, and whose `Files` and `Tests` share no path with a card that did not pass, is `verified` the same way; the rest (every B card when the commit or status check fails) stay in `todo` while N < max_rounds, with the pointer's `batch` = those keys, the same `scope` and `base`, `verified` = HEAD's sha when this check verified a card (else the stored one), and as `reasons` the verdict's reasons (no verdict: the node error) plus, for a failed check, `commit: verdict <commit>, HEAD <sha>` or `uncommitted: <status paths>`, and the round closes (Step F; round N+1 repairs them first). At N ≥ max_rounds they go to `backlog`, `unverified`. Their commits stay on the run branch either way: never re-integrate or re-queue them. Keep `batch r<N>w<b>: <outcome> at <sha>` for the round comment. Then go to Next (Step D).
328328

Workers

0 changes

No worker changes.

Skills

0 changes

No skill changes.

Capabilities

0 changes

This update grants no new capabilities.

Search the registry

Find workers, kits and executables, or jump to a page.