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.1 → v0.1.2

Release notes · v0.1.2
  • A refused interview card covers only open decisions. Answers already given stay; only a card refused because no human can answer turns the open decisions into assumptions, and a card refused for its shape is fixed and asked again.
  • Changing an existing interface stays consequential. A new command, input form or output format can be assumed when nobody can answer; a change to an existing one is a compatibility decision and blocks.
  • A Design card answer reaches the tickets. The plan's cards are rewritten where the answer changed them, so no ticket describes the rejected choice.

Profiles

1 change
modifiedagents/workflow.md+2-2
@@ -157,7 +157,7 @@
157157 Keep the reason as one clause: the condition that failed, or what made all four hold. A wrong `skipped` costs one round of a small ticket, which its check and the review catch; a wrong `run` costs only the design run.
158158 **Interview** (before anything is created, so a card nobody answers leaves nothing behind). List the decisions the plan hangs on that only the user can make, as a tree: a decision waits for the ones it depends on. A decision is a choice about what the goal delivers or risks: what its user sees or uses (a command, an interface, its inputs, outputs and formats), what is in or out of scope, compatibility, security, data loss, external cost. A goal that names an outcome but leaves what its user sees open has open decisions; the design run never settles them, it designs inside them. Never ask what Autonomy rules out, nor how it is built inside (modules, libraries, data structures, the order of the work): that is the design run's. A fact is never a question: what the goal, the repository's rules or a read-only call can tell you, look up (`coder::read-file`, `coder::tree`, `shell::exec` with `git grep -n` or `git log`; at most ten calls, the explore nodes read deeper). No open decision: ask nothing and go to Step A.4.
159159 Ask in rounds, at most three. A round is one `harness::ask` with every open decision whose prerequisites are settled, at most four (over four: the ones most others wait for; the rest go next round): one question each, with a distinct `header` of one to three words, two to four options and your recommendation first, marked `(Recommended)`, so a plain yes accepts it. The turn ends on the card. Its answer is the next message, one line per question (`<header>: <answer>`); R and the pointer do not exist yet, so skip Step D's pointer read. Then ask the next round, or go on when nothing is open. A decision still open after round three takes your recommendation, as an assumption under R's `## Notes`.
160- Keep each answer as one English statement. Step A.4 writes them under R's `## Goal`, and from there they are part of the goal for every step and every node that reads it (board=off: they follow the goal wherever a task carries `Goal:`). A refused card means nobody can answer (another session started yours): every decision takes your recommendation, as an assumption under R's `## Notes`, and you go on to Step A.4. Only a decision that meets the consequential-ambiguity rule of Arguments (scope, compatibility, security, data loss, external cost) ends the run instead, with `blocked: needs a decision`, the questions and your recommendations as the final message, and nothing created (Step G does not run). What the user sees or how they call it (a command, an input form, an output format) is not consequential. A resume never interviews.
160+ Keep each answer as one English statement. Step A.4 writes them under R's `## Goal`, and from there they are part of the goal for every step and every node that reads it (board=off: they follow the goal wherever a task carries `Goal:`). A card refused because no human can answer (another session started yours) means every open decision takes your recommendation, as an assumption under R's `## Notes`, and you go on to Step A.4; a card refused for its shape is fixed and asked again. Only a decision that meets the consequential-ambiguity rule of Arguments (scope, compatibility, security, data loss, external cost) ends the run instead, with `blocked: needs a decision`, the questions and your recommendations as the final message, and nothing created (Step G does not run). A new command, input form or output format is not consequential; a change to an existing one is a compatibility decision. A resume never interviews.
161161 4. Gate: create nothing while the interview has an open decision. Every decision it found is answered (for R's `Decided by the user` list) or assumed (for R's `## Notes`, when nobody can answer, after a refused card or round three). A Design reason that names what the user sees (an interface, a behaviour, the scope) is such a decision: interview it first. Then, unless `project` is set, `kanban::project::create {"name":"workflow: <goal, ≤48 chars> · <last 6 chars of your session id>","description":"Workflow kit run. Goal: <goal, ≤200 chars>. Orchestrator session: <own>.","lead":"workflow","color":"green"}` (on a name clash, retry once with ` · 2`; any other refusal: go on without one and add it under R's `## Notes`). Then create R, passing `"project"` when the run has one:
162162 ```json
163163 kanban::ticket::create {"title":"workflow: <goal, ≤70 chars>","description":"<R description>","status":"in_progress","assignee":"workflow","labels":["wf:run"],"project":"<when set>","actor":"workflow","compact":true}
@@ -208,7 +208,7 @@
208208 - one plan node, phase `plan`: `"plan":{"profile":"workflow-planner","model":"<plan model>","schema":PLAN,"reads":["design-minimal","design-robust","design-fit","refute-minimal","refute-robust","refute-fit"],"task":"Mode: plan. Run ticket <R>. Flow: <dev or plain>. Tickets: at most <max_items>.\nDeadline: <deadline_min> min.\nFunctions: <Functions>","label":"plan","phase":"plan",…}`;
209209 and `"output":[<dev: "baseline",>"plan"]`. Its longest chain is 3 × deadline_min + verify_deadline_min + 8. End the turn on it.
210210 When it ends (Step D): read the baseline as Step A.10 says. With a `plan` result, rewrite R's `## Plan` as its `approach` sentence and its `plan` bullets, add a `## Considered` section with its `considered` bullets after it, and put its `risks` under `## Notes`. With `questions`: under approve=on ask them all, under approve=auto only those that meet the consequential-ambiguity rule of Arguments, in one `harness::ask` with `"header":"Design"` and your recommendation first, marked `(Recommended)`; the turn ends on the card; add its answer to R's `Decided by the user` list, and it constrains Step A.8. Record every question you answered yourself, with the answer, under `## Notes`. Without a plan (null, or the run failed), add `- design run: <the node error>` under `## Notes` and plan the tickets yourself. Then Step A.8.
211-8. **Tickets.** With a plan from Step A.7, its `tickets` are the items: hold them to the rules below (merge any that break them, add a missing **Files** bullet from the plan), turn each `depends_on` title into the key that ticket got, keep the plan's card text, and set every ticket's assignee to the flow's tier (dev: `workflow-impl`, plain: `workflow-worker`), rewriting a card that has the other shape. With Design = `skipped`, or without a plan, write them yourself from the goal and what Step A.2 read. **Plan few tickets.** A ticket is one deliverable a person would review on its own: a feature with its tests, a fix, a section of a report. Most goals need one to four. Split only when the parts are independent and each is worth its own review, or when one ticket would not fit in deadline_min. Never split one function, file, question or change and its tests into several tickets, never make a ticket for a step (setup, a test run, a check, a summary), and in the dev flow keep work on the same files in one ticket: tickets that share files cannot run in the same wave. Follow the goal when it says how to split.
211+8. **Tickets.** With a plan from Step A.7, its `tickets` are the items: hold them to the rules below (merge any that break them, add a missing **Files** bullet from the plan), turn each `depends_on` title into the key that ticket got, keep the plan's card text except what a Design card answer changed (rewrite those bullets and Acceptance items from R's `Decided by the user` list), and set every ticket's assignee to the flow's tier (dev: `workflow-impl`, plain: `workflow-worker`), rewriting a card that has the other shape. With Design = `skipped`, or without a plan, write them yourself from the goal and what Step A.2 read. **Plan few tickets.** A ticket is one deliverable a person would review on its own: a feature with its tests, a fix, a section of a report. Most goals need one to four. Split only when the parts are independent and each is worth its own review, or when one ticket would not fit in deadline_min. Never split one function, file, question or change and its tests into several tickets, never make a ticket for a step (setup, a test run, a check, a summary), and in the dev flow keep work on the same files in one ticket: tickets that share files cannot run in the same wave. Follow the goal when it says how to split.
212212 Create the items, one call each, at most max_items, layer by layer: first every item that needs no other item's output, in one reply; then each later layer in a reply of its own, with a `- **Depends on:** <keys>` bullet on its card:
213213 ```json
214214 kanban::ticket::create {"title":"<what it delivers, ≤70 chars>","parent":"<R>","description":"<card>","status":"todo","assignee":"<workflow-worker or workflow-impl>","project":"<when set>","actor":"workflow","compact":true}

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.