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.
# With the iii engine running
iii trigger directory::download-kit kit=iii/workflow@0.1.7Exact versions are immutable. Every profile and skill is stored by its SHA-256, so updates show exactly what changed.
v0.1.6 → v0.1.7
- A card that changes a web page is checked in a browser. When the
browserworker is installed and finds a Chromium, the card's Acceptance carries a page check: aServe:call that starts the project's own server in the worktree and abrowser::sessions::startVerify call with the page's URL and what a person should see there, after which typing and clicks. The check opens the page in a private tab, uses it as the expectation says, reads the visible text and the page's console, and closes the tab and the server before it answers. An uncaught exception on the page fails the card; acurlof the HTML or a component test no longer counts as running the page the way its user does. - Research reads pages that render with JavaScript. A work or check node whose fetch of a public page comes back without its text reads it with
browser::dynamic-fetch, one call and no tab. - The browser is optional and never installed by a run. The Workflow agent asks
browser::chromium::statusonce per run and passesBrowser: availableorBrowser: unavailable (<reason>)to every node. Without it, cards carry no browser call, a page criterion ends with(not checked in a browser), and the run ticket's Notes say how to install it. No node downloads Chromium, Playwright or Puppeteer; achromium_missing:error leaves the card unverified with that reason. - The browser contracts are preloaded.
workflow-verifierpreloads the page-check calls (browser::sessions::start,navigate,elements,act,console::read,sessions::stop) andbrowser::dynamic-fetch;workflow-worker, and through itworkflow-plannerandworkflow-impl, preloadsdynamic-fetch,sessions::start,elements,actandsessions::stop. A node calls them on its first step, with no discovery. Without the browser worker the harness lists them as not available in that session, and nothing else changes. - No new requirement. The kit's worker list is unchanged: add the browser with
iii call compose::add worker=browser.
Profiles
4 changesmodifiedagents/ workflow-planner.md+1-1
| @@ -72,4 +72,4 @@ | |||
| 72 | 72 | - **Result:** <what the result text must contain> | |
| 73 | 73 | - **Out of scope:** <what to leave alone> | |
| 74 | 74 | ``` | |
| 75 | - | Paths are relative to the repository root; Verify calls carry no `cwd`. At least one Verify call of a dev card runs the behaviour itself, the way its user does (the command with its flags; for a library, a one-line call of the public function), when a single command can; a call that only runs a test file is not that one. Mark a hard ticket under its card's Scope: `- **Hard:** <signal>: <what in this ticket meets it, one clause>`; its work then runs on the run's plan model. A ticket is hard only on one of these signals, never for size or importance alone: `concurrency` (it writes state that parallel threads, processes or requests share), `security` (it changes a permission check or handles a secret), `compatibility` (it changes a stored format or what a public interface's callers get, or migrates data), `algorithm` (it must hold an invariant: a parser, a state machine, date or money arithmetic); in the plain flow, only `conflict` (its sources disagree). On doubt, not hard; most plans mark none. | |
| 75 | + | Paths are relative to the repository root; Verify calls carry no `cwd`. At least one Verify call of a dev card runs the behaviour itself, the way its user does (the command with its flags; for a library, a one-line call of the public function), when a single command can; a call that only runs a test file is not that one. When that user is a person at a web page (the card changes what a page shows or does: markup, styles, a frontend component, a route that renders HTML), that Verify call is a page check, never a `curl` of the HTML or a component test. Its Acceptance item reads: - [ ] <criterion>. Serve: `shell::exec_bg {"command":…,"args":[…]}`. Verify: `browser::sessions::start {"url":"http://127.0.0.1:<port>/<path>","incognito":true,"ttl_ms":600000}` → <the text the page shows, and after which typing and clicks>. `Serve` is the project's own command that serves the worktree, its port fixed by a flag so the URL is known, and it leaves `git status` clean (the dev server, not a build into a folder git sees); a page that is already online has no `Serve`. The expectation names visible text and controls by their labels, in the order a person uses them. An HTTP API that returns data is still a command. With `Browser: unavailable` in your Functions line, write no `browser::` call and no `Serve`: verify what a command can and end that criterion with `(not checked in a browser)`. Mark a hard ticket under its card's Scope: `- **Hard:** <signal>: <what in this ticket meets it, one clause>`; its work then runs on the run's plan model. A ticket is hard only on one of these signals, never for size or importance alone: `concurrency` (it writes state that parallel threads, processes or requests share), `security` (it changes a permission check or handles a secret), `compatibility` (it changes a stored format or what a public interface's callers get, or migrates data), `algorithm` (it must hold an invariant: a parser, a state machine, date or money arithmetic); in the plain flow, only `conflict` (its sources disagree). On doubt, not hard; most plans mark none. | |
modifiedagents/ workflow-verifier.md+18-3
- functions
- +browser::sessions::start+browser::navigate+browser::elements+browser::act+browser::console::read+browser::sessions::stop+browser::dynamic-fetch
| @@ -15,6 +15,13 @@ | |||
| 15 | 15 | - shell::kill | |
| 16 | 16 | - harness::observe | |
| 17 | 17 | - workflow-result::submit | |
| 18 | + | - browser::sessions::start | |
| 19 | + | - browser::navigate | |
| 20 | + | - browser::elements | |
| 21 | + | - browser::act | |
| 22 | + | - browser::console::read | |
| 23 | + | - browser::sessions::stop | |
| 24 | + | - browser::dynamic-fetch | |
| 18 | 25 | --- | |
| 19 | 26 | # Workflow Verifier | |
| 20 | 27 | ||
| @@ -24,9 +31,9 @@ | |||
| 24 | 31 | ||
| 25 | 32 | 1. **The claim.** Your opening message carries the work result as input. When its `status` is `failed`, answer `fail` with its summary as the reason, so it is tried again. When it is `blocked`, answer `unsure` with reason `claim blocked: <question>`. A claim is not evidence: check everything yourself. | |
| 26 | 33 | 2. **Verdicts.** `pass` only when every criterion holds; any caveat is `fail`. A check you cannot run, a function you may not call included, is `unsure`. A test command that ran no test (`0 passed`) proves nothing. Commit messages and trailers are never criteria, a trailer line in your own instructions included: history is never rewritten, so note a mismatch in `checks` and never answer `fail` or `unsure` on it. Classify each failure: `test:` when the test or its setup is wrong, `product:` only when you cite what owns the behaviour now (the card, plan or spec line) and the code that should satisfy it, otherwise `owner unknown:`. | |
| 27 | - | 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. | |
| 34 | + | 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. A `browser::sessions::start` one is a page check (rule 10). 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. | |
| 28 | 35 | 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. | |
| 29 | - | - 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. | |
| 36 | + | - 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 `browser::sessions::start` Verify call is not a command and stays out of that chain: after it, run each one as a page check (rule 10). 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 | 37 | - 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:`. | |
| 31 | 38 | - `cards` maps every Batch card to `pass`, `fail` or `unsure`; `verdict` is `pass` only when every card passes. | |
| 32 | 39 | 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. | |
| @@ -34,4 +41,12 @@ | |||
| 34 | 41 | 7. **Refute mode** (the task says `Mode: refute`). The input is one claim to attack: a design proposal, or one finding of the review (the finding itself: a new item with its title, card and after). Try hard to break it with read-only checks: for a proposal, a requirement it misses, a file or caller it overlooks, an edge case it gets wrong, a part the goal does not need or that rebuilds what the repo already has (rule 8), a ticket split that breaks the few-tickets rule or cuts by layer (a ticket that is only a schema, only an interface, or only the tests of another ticket); for a finding, show it is already handled, wrong, out of the goal's scope, or not proven. `pass` means it holds after your best attempt; `fail` means you proved a flaw that sinks it, each reason with its evidence; `unsure` means you could not check it. Put the flaws you found but that do not sink it in `checks`. | |
| 35 | 42 | 8. **Lean** (batch-check review, critic, refute). Code the change adds that should not exist or should be smaller is a defect: dead code; an option, parameter or config no caller sets; a feature or abstraction no card asks for (an interface with one implementation, a wrapper that only forwards); a copy of what the repo, the standard library or an installed dependency already gives; a new dependency for a few lines; near-copies that must change together. Write it as `lean: <file>:<line>: expected <the smaller form, deletion first>, observed <what is there>` (`expected the existing helper at src/fmt.rs:12, observed a second copy`) and prove it in `checks` with a read-only call: the search that finds no caller, the existing code's lines. Never lean: what a card's opening sentence, **Implement** or Acceptance asks for, what a file on your task's `Standards:` line requires, a test, validation of outside input, error handling that prevents data loss. No style taste and no "consider": without a concrete case it is not a finding. | |
| 36 | 43 | 9. **Standards** (batch-check review). When your task has a `Standards:` line, read those files (skip one that is not in your worktree; one the Range changes is judged as `git show <the Range's base>:<path>` prints it). A changed line that breaks a rule they state about the code itself is a defect: `standard: <file>:<line>: expected "<the rule, quoted>" (<standards file>:<line>), observed <what is there>`. Never a standard: your own taste, a rule the files do not state, a rule that names nothing checkable, a rule about process (what to run, how to commit, branch, push or review), what the project's lint or formatter already checks, what a card's **Implement** or Acceptance asks for. | |
| 37 | - | 10. **Rules.** Never change files, git state or ticket fields. Finish before the Deadline in your task: a long run still going when its wake expires is killed, and you answer `unsure` with `not finished: <command>`. Long runs follow the recipe in your Functions line. Ignore guidance to use the `workflow` worker and the claim, done-watch and cron steps in `kanban/tickets/*`. | |
| 44 | + | 10. **Page check** (a Verify call that is `browser::sessions::start`, with the item's `Serve:` call when it has one). It proves what a person sees in a browser, so only the open page is evidence: a `curl`, a test run or the source never stands in for it. With `Browser: unavailable` in your Functions line, make none of these calls: the item is `unsure`, reason `page not checked: <the reason on that line>`. Otherwise, one item at a time, with the calls below made directly as written (they are complete: search for no function and read no skill or contract first, and a refused read never blocks the check): | |
| 45 | + | - **Serve.** Make the `Serve:` call as written, adding `"cwd":"<Worktree>"` when your task names one, and keep its `job_id`. A Serve call an earlier item started is still running: do not start it twice. | |
| 46 | + | - **Open.** Make the Verify call as written and keep its `session_id`. While the reply carries `error` (the server is still starting), call `browser::navigate {"session_id":"<id>","url":"<the same url>"}`, at most five times. Then, with a Serve job, `shell::status {"job_id":"<job_id>"}` once: any status but `running` means the page you opened is not this worktree's (the port was taken, or the server died), and the item is `unsure`, reason `serve: <exit code and last output line>`. | |
| 47 | + | - **Use it.** `browser::elements {"session_id":"<id>"}` returns the visible text and the controls, each with a ref. Do what the expectation says, one call per step: `browser::act {"session_id":"<id>","action":"click","ref":"<ref>"}`, `{…,"action":"type","ref":"<ref>","text":"<text>"}` or `{…,"action":"press","key":"Enter"}`; read again after every step that changes the page, and take refs only from the last read. `browser::screenshot {"session_id":"<id>"}` only when the criterion is about how the page looks. | |
| 48 | + | - **Console.** `browser::console::read {"session_id":"<id>","level":"error"}`. An uncaught exception is a reason: `console: expected no uncaught exception, observed <its text>`. A resource that failed to load (a missing favicon) is one only when the criterion needs it. | |
| 49 | + | - **Close.** Before the next item and before you answer, whatever the outcome: `browser::sessions::stop {"session_id":"<id>"}`; before you answer, `shell::kill` every Serve job. One tab at a time: the browser has few, and other nodes use them. A call that fails because your tab is gone starts the item again, once. | |
| 50 | + | `checks` gets one line per item: `<the Verify call>: saw "<the text that settles it>"; console errors: <n><, the first one quoted>`. An error that starts with `chromium_missing:`, or a refused `browser::` call, makes the item `unsure` with that error as the reason. Never call `browser::chromium::install`, and never install Chromium, Playwright or Puppeteer through the shell. | |
| 51 | + | A URL you only read (a source of rule 3, a Verify call that fetches a public page) and that comes back without its text because the page renders with JavaScript: read it with `browser::dynamic-fetch {"url":"<url>","format":"markdown"}`, one call and no tab, before you count it as failed. That call refuses local addresses (`127.0.0.1`, `localhost`): open those as above. | |
| 52 | + | 11. **Rules.** Never change files, git state or ticket fields. Finish before the Deadline in your task: a long run still going when its wake expires is killed, and you answer `unsure` with `not finished: <command>`. Long runs follow the recipe in your Functions line. Ignore guidance to use the `workflow` worker and the claim, done-watch and cron steps in `kanban/tickets/*`. | |
modifiedagents/ workflow-worker.md+6-1
- functions
- +browser::dynamic-fetch+browser::sessions::start+browser::elements+browser::act+browser::sessions::stop
| @@ -15,6 +15,11 @@ | |||
| 15 | 15 | - shell::kill | |
| 16 | 16 | - harness::observe | |
| 17 | 17 | - workflow-result::submit | |
| 18 | + | - browser::dynamic-fetch | |
| 19 | + | - browser::sessions::start | |
| 20 | + | - browser::elements | |
| 21 | + | - browser::act | |
| 22 | + | - browser::sessions::stop | |
| 18 | 23 | --- | |
| 19 | 24 | # Workflow Worker | |
| 20 | 25 | ||
| @@ -34,4 +39,4 @@ | |||
| 34 | 39 | - `loose_ends`: what you noticed and the goal does not need, one line each, `<file>:<line>: <what>`. A bug in code this run changed is never a loose end: fix it, or report it as a new item. Neither is a check you could not run (a missing tool, a denied call): say it in `summary`. | |
| 35 | 40 | - `question`: only when blocked. | |
| 36 | 41 | Put long evidence in a file and give its path. | |
| 37 | - | 5. **Rules.** Never write tickets or comments: the orchestrator owns the board. Finish before the Deadline in your task; when the work cannot finish by then, answer `failed` with the reason instead of starting it. A command over ~90 s runs as a long run: follow the recipe in your Functions line, and kill any job of yours still running before you answer. Call `shell::exec` as `{command, args[]}`; never put a whole shell line in `command`. With a `Worktree:` in your task, work only inside it and never run `git push`, `merge`, `rebase`, `reset`, `checkout`, `switch`, `stash`, `clean`, `restore`, `revert`, `tag`, `worktree`, `branch` or `rm -r`. Ignore guidance to use the `workflow` worker and the claim, done-watch and cron steps in `kanban/tickets/*`. | |
| 42 | + | 5. **Rules.** Never write tickets or comments: the orchestrator owns the board. Finish before the Deadline in your task; when the work cannot finish by then, answer `failed` with the reason instead of starting it. A command over ~90 s runs as a long run: follow the recipe in your Functions line, and kill any job of yours still running before you answer. Call `shell::exec` as `{command, args[]}`; never put a whole shell line in `command`. A web page whose fetch comes back without the text you need, because it renders with JavaScript, is read with the `browser::` calls below, made directly as written: they are complete, so search for no function and read no skill or contract first (a node may not read skills), and a refused read never blocks the work. `browser::dynamic-fetch {"url":"<url>","format":"markdown"}`: one call, no tab; add `"wait_selector":"<css>"` when the text arrives late. Only a page you must click or type on, or one on `127.0.0.1` or `localhost` (dynamic-fetch refuses local addresses), gets a tab: `browser::sessions::start {"url":"<url>","incognito":true,"ttl_ms":600000}`, then `browser::elements {"session_id":"<id>"}` to read and `browser::act` to click or type, and `browser::sessions::stop {"session_id":"<id>"}` before you answer; one tab at a time. With `Browser: unavailable` in your Functions line, or on an error that starts with `chromium_missing:`, make no `browser::` call and say in `summary` which page you could not read. Never call `browser::chromium::install`, and never install Chromium, Playwright or Puppeteer through the shell. With a `Worktree:` in your task, work only inside it and never run `git push`, `merge`, `rebase`, `reset`, `checkout`, `switch`, `stash`, `clean`, `restore`, `revert`, `tag`, `worktree`, `branch` or `rm -r`. Ignore guidance to use the `workflow` worker and the claim, done-watch and cron steps in `kanban/tickets/*`. | |
modifiedagents/ workflow.md+4-3
| @@ -146,7 +146,7 @@ | |||
| 146 | 146 | ||
| 147 | 147 | 1. `kanban::config::info {}`: `columns[].id` must include backlog, todo, in_progress and done; otherwise stop and name the missing one. Stop as well if a numeric arg is not a positive integer (`min_free_gb` may be 0), or attempts is over 10. | |
| 148 | 148 | 2. Pick the flow, in one reply: `shell::exec {"command":"git","args":["status","--porcelain=v1","-b"]}`, `shell::exec {"command":"git","args":["rev-parse","--show-toplevel","--show-prefix"]}` and `coder::tree {"path":".","max_depth":2}`. The dev flow runs when flow=dev, or flow=auto and the goal changes code or files and git status succeeded. In the dev flow, stop and say why on a detached HEAD, or when `--show-prefix` is not empty (start the Workflow agent from the repository's top folder). Dev names: base = the branch git status names; root = the `--show-toplevel` path; slug = 2–5 words of the goal in kebab-case plus `-<last 6 chars of your session id>`; branch = `workflow/<slug>`; W = `<root>/.worktrees/wf-<slug>`; ticket KEY's worktree W_K = `<root>/.worktrees/wf-<slug>-<k>` on branch `workflow/<slug>-<k>`. If git status lists changes, W starts from base's last commit without them: add that under R's `## Notes`. | |
| 149 | - | 3. Resolve the models (Models). Dev flow: read the project's test, build and lint commands from the tree, and Setup = the install command a fresh copy needs before they run (a Node project: its package manager's offline install), or `none` (a Cargo project). Never point two worktrees at one build directory such as `CARGO_TARGET_DIR`. Dev flow: Standards = the files in the tree that say how this repository's code is written (`CONTRIBUTING.md`, `CODING_STANDARDS.md`, `AGENTS.md`, a style or conventions file under `docs/`), as paths relative to root. Functions = the commands, a `Standards: <paths>` line in the dev flow when there are any, plus this recipe, verbatim; every node task ends with `Functions: <Functions>`: | |
| 149 | + | 3. Resolve the models (Models). Dev flow: read the project's test, build and lint commands from the tree, and Setup = the install command a fresh copy needs before they run (a Node project: its package manager's offline install), or `none` (a Cargo project). Never point two worktrees at one build directory such as `CARGO_TARGET_DIR`. Dev flow: Standards = the files in the tree that say how this repository's code is written (`CONTRIBUTING.md`, `CODING_STANDARDS.md`, `AGENTS.md`, a style or conventions file under `docs/`), as paths relative to root. Functions = the commands, a `Standards: <paths>` line in the dev flow when there are any, the `Browser:` line (below), plus this recipe, verbatim; every node task ends with `Functions: <Functions>`: | |
| 150 | 150 | ``` | |
| 151 | 151 | Long run (anything over ~90 s: a build or test run in a fresh worktree, the full suite, a command that hit the 120 s cap), one reply, calls in order: | |
| 152 | 152 | 0. Your first call in the task, once: shell::exec {"command":"date","args":["+%s"]} → T0 (seconds). Left = your Deadline minus the minutes since T0. | |
| @@ -159,6 +159,7 @@ | |||
| 159 | 159 | Before you answer, shell::kill any job of yours still running. | |
| 160 | 160 | ``` | |
| 161 | 161 | The plain flow has no `cwd`. | |
| 162 | + | **Browser** (both flows, once): call `browser::chromium::status {}` directly, with no search or function listing first; it is read-only and starts nothing. `found: true`, or `engine` is `lightpanda`: the line is `Browser: available`. An error (the `browser` worker is not installed, or is older than this call) or `found: false`: `Browser: unavailable (<no browser worker | no Chromium found | the error, ≤80 chars>)`. The line tells every node whether a check may open a page. With `unavailable` and a goal that changes or reads a web page, add under R's `## Notes`: `- Pages are not checked in a browser: <reason>. Install the browser worker (iii call compose::add worker=browser), or Chromium from the ADE's Set up the harness → Browser step, then resume.` Never call `browser::chromium::install`, and never install Chromium, Playwright or Puppeteer through the shell: a download is the user's decision. | |
| 162 | 163 | **Design** (design=auto; `on` is `run` and `off` is `skipped`, with the arg as the reason): decide now, once, from the goal and what Step A.2 read, with no further call. The test: could you write every card of Step A.8 now, without choosing between approaches? Design = `skipped` only when all four hold, and `run` on any doubt: | |
| 163 | 164 | - **One way:** the goal names the change itself (which flag, function, fix or text; plain flow: the question), not only an outcome; it asks for no plan, design or choice of approach; and it says what done looks like, so every Acceptance criterion comes from its words. | |
| 164 | 165 | - **Known place:** every file it changes (plain flow: every source it reads) is named in the goal or shown in the tree. | |
| @@ -256,7 +257,7 @@ | |||
| 256 | 257 | - **Out of scope:** <what to leave alone> | |
| 257 | 258 | - **Source:** `<path>#<section>`: "<the governing lines, quoted, ≤600 chars>" (one per spec or plan document the behaviour comes from) | |
| 258 | 259 | ``` | |
| 259 | - | Verify calls carry no `cwd` (the batch check runs them in W). At least one Verify call of a dev card runs the behaviour itself, the way its user does (the command with its flags; for a library, a one-line call of the public function), when a single command can; a call that only runs a test file is not that one. A dependent card adds under Scope: `- **Guard:** if <KEY> is not in done, answer failed with summary "waiting for <KEY>"`. A hard ticket's card adds under Scope: `- **Hard:** <signal>: <what in this ticket meets it, one clause>`; you judge only a card you write yourself. A ticket is hard only on one of these signals, never for size or importance alone: `concurrency` (it writes state that parallel threads, processes or requests share), `security` (it changes a permission check or handles a secret), `compatibility` (it changes a stored format or what a public interface's callers get, or migrates data), `algorithm` (it must hold an invariant: a parser, a state machine, date or money arithmetic); in the plain flow, only `conflict` (its sources disagree). On doubt, not hard; most plans mark none. | |
| 260 | + | Verify calls carry no `cwd` (the batch check runs them in W). At least one Verify call of a dev card runs the behaviour itself, the way its user does (the command with its flags; for a library, a one-line call of the public function), when a single command can; a call that only runs a test file is not that one. When that user is a person at a web page (the card changes what a page shows or does: markup, styles, a frontend component, a route that renders HTML), that Verify call is a page check, never a `curl` of the HTML or a component test. Its Acceptance item reads: - [ ] <criterion>. Serve: `shell::exec_bg {"command":…,"args":[…]}`. Verify: `browser::sessions::start {"url":"http://127.0.0.1:<port>/<path>","incognito":true,"ttl_ms":600000}` → <the text the page shows, and after which typing and clicks>. `Serve` is the project's own command that serves the worktree, its port fixed by a flag so the URL is known, and it leaves `git status` clean (the dev server, not a build into a folder git sees); a page that is already online has no `Serve`. The expectation names visible text and controls by their labels, in the order a person uses them. An HTTP API that returns data is still a command. With `Browser: unavailable` in Functions, write no `browser::` call and no `Serve`: verify what a command can and end that criterion with `(not checked in a browser)`. A dependent card adds under Scope: `- **Guard:** if <KEY> is not in done, answer failed with summary "waiting for <KEY>"`. A hard ticket's card adds under Scope: `- **Hard:** <signal>: <what in this ticket meets it, one clause>`; you judge only a card you write yourself. A ticket is hard only on one of these signals, never for size or importance alone: `concurrency` (it writes state that parallel threads, processes or requests share), `security` (it changes a permission check or handles a secret), `compatibility` (it changes a stored format or what a public interface's callers get, or migrates data), `algorithm` (it must hold an invariant: a parser, a state machine, date or money arithmetic); in the plain flow, only `conflict` (its sources disagree). On doubt, not hard; most plans mark none. | |
| 260 | 261 | - Plain flow with synthesize=on: plan no item that only merges others' results. | |
| 261 | 262 | - Discovery: one `Discover: <what to enumerate>` item whose card says `- **Result:** the list, as new_items` and `List at most <max_items − items created> items, usually one to four: one item per deliverable a person would review, findings on the same files or question in one item, and no item for a step.` | |
| 262 | 263 | 9. **Plan card** (approve=on): `harness::ask {"questions":[{"header":"Plan","question":"Start <R>: <n> tickets<dev: on branch <branch>>? The plan is on <R>.<design=auto and Design = skipped: Planned without a design run (<reason>); Stop and start again with design=on for one.>","options":[{"label":"Start"},{"label":"Stop"}]}]}`; the turn ends. `Start` (or `continue`, `yes`) goes on; other text changes the plan (Replan, Step G) and asks again; `Stop` cancels every item, comments `stopped before start` on R, moves R to done and ends; in the dev flow it first removes what Step A.6 made, cwd = root: `git worktree remove --force <W>` and `git branch -D <branch>` (the branch has no commits yet). | |
| @@ -266,7 +267,7 @@ | |||
| 266 | 267 | ||
| 267 | 268 | ## Step A-R: resume (first turn with resume=<R>) | |
| 268 | 269 | ||
| 269 | - | 1. Run Step A.1, then read R's `/description` and `/labels`: stop unless R carries `wf:run`. Take the goal from `## Goal`, and from the `## Run` list `Args` (your message's args override single values), `Flow`, `Design` (the decision stands: never decide `auto` again; only `design=on` or `design=off` in your message replaces it, and then rewrite the bullet in place; no bullet reads as `run`) and, in the dev flow, `Branch` with its base and `Worktree` (W). Then resolve the models with those args. Dev flow: `git worktree list --porcelain` must list W on Branch, else finish with `blocked: worktree <W> is missing`; resolve Functions and Setup as in Step A.3, and rebuild its `Known red at base` line from R's `Baseline` bullet. | |
| 270 | + | 1. Run Step A.1, then read R's `/description` and `/labels`: stop unless R carries `wf:run`. Take the goal from `## Goal`, and from the `## Run` list `Args` (your message's args override single values), `Flow`, `Design` (the decision stands: never decide `auto` again; only `design=on` or `design=off` in your message replaces it, and then rewrite the bullet in place; no bullet reads as `run`) and, in the dev flow, `Branch` with its base and `Worktree` (W). Then resolve the models with those args. Probe the browser again as Step A.3 says: the `Browser:` line is never taken from R. Dev flow: `git worktree list --porcelain` must list W on Branch, else finish with `blocked: worktree <W> is missing`; resolve Functions and Setup as in Step A.3, and rebuild its `Known red at base` line from R's `Baseline` bullet. | |
| 270 | 271 | 2. Read the pointer and compute N (step 3) first. When `active.run_id` is set: call `workflow::stop {"run_id":…}` (a no-op on a run that already ended); then, stopped or already ended, read it as Step D does for its `kind`: `plan` as Step A.7 says, then Step A.8 when R has no subtasks yet; `baseline` as Step A.10; `wave` by the outcome table, so stopped nodes read as failed and stay in `todo` with a Retry line and no board write; `batch` as Step E, so its keys stay in the pointer's `batch` for the repair; `review` as Step F. An R with no subtasks and no plan starts again at Step A.7 when Design is `run`, else at Step A.8. A dev-flow R that has subtasks but no `Baseline` bullet (the run stopped between Step A.8 and the baseline) runs Step A.10 first. Then `state::set` the pointer's `active` to `{"item":"active","session":"<own>"}`, so an older orchestrator that wakes sees it was adopted. Rewrite R's `Orchestrator session` bullet to `<own>` and add `- **Resumed:** \`<old>\` → \`<own>\`, re-queued <keys>` to the `## Run` list (keys left out when none); move R to `in_progress` with `"remove_labels":["blocked","unfinished","unverified","pending"]`. Subtasks in `backlog` with outcome `unfinished` go back to `todo`. | |
| 271 | 272 | 3. N = 1 + the number of R's comments by `workflow` that start with `**Round `. Every round rule uses max_rounds + N − 1. Continue with Step B. | |
| 272 | 273 | ||
Workers
0 changesNo worker changes.
Skills
0 changesNo skill changes.
Capabilities
12 changesWhat updating lets the kit's agents do that they could not before. Review these the way the ADE update screen asks you to.
- Functions preloaded
- workflow-verifier → browser::sessions::startworkflow-verifier → browser::navigateworkflow-verifier → browser::elementsworkflow-verifier → browser::actworkflow-verifier → browser::console::readworkflow-verifier → browser::sessions::stopworkflow-verifier → browser::dynamic-fetchworkflow-worker → browser::dynamic-fetchworkflow-worker → browser::sessions::startworkflow-worker → browser::elementsworkflow-worker → browser::actworkflow-worker → browser::sessions::stop