task-pipeline-skill 1.96.0 → 1.98.0

package/plugins/task-pipeline/skills/task-pipeline/references/iteration.md

@@ -159,28 +159,25 @@ its slowest node before checking its fastest.
 
 **The number of rounds follows the node's risk class.** The class is recorded on the node
 as `risk` (R1–R3, [`work-graph.md`](work-graph.md)), computed from what the node touches.
-It is never lowered to save time. **A round is the three blind tiers of
-[`certification.md`](certification.md) plus one fix cycle**, and the first round is always
-the full three tiers — there is no lighter first reading. The class sets how many rounds
-the node owes:
-
-| Class | Touches | Rounds |
-|---|---|---|
-| R1 | docs, config, a mechanical change, one isolated file | 1: that first round |
-| R2 | an ordinary feature or fix inside one module | 2: the first round, then a second over the fix diff with its regression tests |
-| R3 | security, cryptography, money, a data migration, a public contract, a seam across repositories, concurrency | 3, one of them recorded adversarial — a round that plants defects and tries abuse cases, on another model where one is available |
-
-- Each round's fix cycle stays inside [`loop-guard.md`](loop-guard.md)'s caps. A finding
-  that cannot be fixed in the node is parked with a board row.
-- `graph.py close` refuses a node until its owed rounds have passed, and an R3 node until
-  one of them was recorded adversarial ([`certification.md`](certification.md) → *Rounds
-  owed by risk class*, which also says what a round after a clean one reads and how the
-  adversarial round is run).
-- Every owed round runs, and every round re-runs all three tiers: a tier that passed in an
-  earlier round read a tree the fix has since moved ([`certification.md`](certification.md)
-  → a passing tier is re-run). A clean round does not cancel the next one, and only passing
-  rounds count. R3's adversarial round asks a different question — it hunts for a planted
-  defect — and always runs; it counts only when it passes.
+It is never lowered to save time. **A round is the blind tiers the class owes, plus one
+fix cycle** ([`certification.md`](certification.md)), and a clean round ends the node
+unless the class is R3 or the surface is flagship:
+
+| Class | Touches | Tiers | Rounds |
+|---|---|---|---|
+| R1 | docs, config, a mechanical change, one isolated file | one | 1 |
+| R2 | an ordinary feature or fix inside one module | three | 1 |
+| R3 | security, cryptography, money, a data migration, a public contract, a seam across repositories, concurrency | three | 2: one blind, one adversarial (plants defects, tries abuse cases, on another model where one is available) |
+
+A flagship surface owes four tiers and two rounds, one adversarial, whatever its class.
+
+- Each round's fix cycle stays inside [`loop-guard.md`](loop-guard.md)'s caps, and the
+  certification ceiling stops the node: it is parked with its evidence and a board row.
+- `graph.py close` refuses a node until its owed rounds have passed, and an R3 or
+  flagship node until one of them was recorded adversarial
+  ([`certification.md`](certification.md) → *Rounds owed by risk class*).
+- A round after a fix re-runs every tier the class owes; a round on an unchanged tree is
+  refused unless it is the other kind. Only passing rounds count.
 - Readers stay blind ([`certification.md`](certification.md) → *Blind*). Each reads the
   diff, the packet and the contract, never the builder's reasoning.
 
@@ -384,7 +381,7 @@ release run performs, not unrelated deployments, messages or human-only actions.
 |---|---|
 | "This bug is tiny, fix it now" | Tiny fixes are what move a seam twice. It joins the inventory, or it is one of the hotfix lane's five entries |
 | "Wait for the whole wave, then verify" | A barrier idles every finished node. Each node is certified when it lands |
-| "R3 found nothing in round 2, skip the adversarial round" | The adversarial round, in any position, asks a different question: it hunts for a planted defect. A clean blind round does not answer it |
+| "R3 found nothing in its blind round, skip the adversarial round" | The adversarial round, in any position, asks a different question: it hunts for a planted defect. A clean blind round does not answer it |
 | "Ask the operator now, it is quick" | Each question is a human round. Queue it and take another node |
 | "The agent hit a rate limit, start it again" | Resume it with its context. Relaunching pays for the same reading twice |
 | "No Observatory here, so no learning loop" | The project retro and learned.md are the loop's first layer, and every install has them |

package/plugins/task-pipeline/skills/task-pipeline/references/knowledge-sources.md

@@ -51,7 +51,7 @@ makes the grill's answers *checkable* instead of merely confident.
 | 4b | **The task register, for its *state*** | `docs/ROADMAP.md`, a board, a backlog, the tracker `CLAUDE.md` names | **what is open right now** — read with a command, never from memory; see *Carried-in claims* |
 | 5 | **Product/UX docs** | `docs/ux/` (super-ux chain), `README`, runbooks | user-facing behavior that is already specified |
 | 6 | **Pipeline history** | `<artifacts>/specs/`, `plans/`, past `-carryover.md` | what a previous run of this pipeline decided or deferred |
-| 7 | **The retro, in force** | `<artifacts>/retro.md` ([`retrospective.md`](retrospective.md)) | what previous runs got wrong here — **read in full**: standing instructions (capped at ten) and run stamps (one line each), both bounded by construction; the *Recent log* is **queried** by the task's nouns, like the archive — nothing caps it |
+| 7 | **The retro, in force** | `<artifacts>/retro.md` ([`retrospective.md`](retrospective.md)) | what previous runs got wrong here — **read in full**: standing instructions (capped at ten) and run stamps (one line each), both under the floor's 12 000-byte budget, whose bytes and bytes/4 tokens `scripts/retro_budget.py check` prints into this row; the *Recent log* is **queried** by the task's nouns, like the archive — nothing caps it |
 | 7a | **The retro archive** | `<artifacts>/retro/YYYY-QN.md` | *have we been bitten by this class before?* — **queried** by the task's nouns, never read end to end |
 | 7b | **Lessons from other projects** | the local index every install has (`scripts/lessons.py query`), and a shared lesson store only where the session lists one — an Observatory — detected by its tools, never by a path ([`iteration.md`](iteration.md) → *The learning loop*, the read recipe) | *what did other projects' agents learn about this class?* — **queried** by the task's 3–6 nouns, at most ten lines from both; a lesson that fires is cited `[lesson L-…]` or `[lesson mem:…]`. The ledger names each layer's state: `local lessons: N match | absent | unavailable (no python3)`; `shared lessons: N match | 0 match (filter unknown) | unfilterable | absent`, where the first `observatory_search` call is the probe — and nothing else changes |
 | 8 | **The knowledge wiki** | see below | distilled cross-project knowledge, prior sessions, why decisions were made |
@@ -79,8 +79,10 @@ Rules for the list:
 
 `<artifacts>/retro.md` ([`retrospective.md`](retrospective.md)) is the one
 harvested source whose binding part is **read in full rather than queried**: the
-standing instructions are capped at ten precisely so that this is cheap, and the run
-stamps are one line each. Its narrative log is queried, not read — an uncapped section
+standing instructions are capped at ten rows of at most 600 characters, the run stamps
+at ten lines of at most 300, and the two together at 12 000 bytes
+([`retrospective.md`](retrospective.md) → *The floor has a byte budget*), precisely so
+that this is cheap. Its narrative log is queried, not read — an uncapped section
 inside a source that binds is how the capped part stops being read. They are what
 previous runs of this pipeline got wrong *in this project* — the rules no check
 could decide — and they bind this run.

package/plugins/task-pipeline/skills/task-pipeline/references/learned.md

@@ -58,6 +58,13 @@ to be enforced and is not is the same failure as a gate that prints `FAIL` and e
 | 30 | **A gate scoped by exclusion judges every newcomer silently** | any lint, format or check configured with an ignore list rather than an include list | scope by what it COVERS; where the tool has no such switch, assert the covered set and fail on additions, deriving the allowlist by measuring the tool's own reach | the failure message names the intruder and the remedy, because the operator meets it mid-release |
 | 31 | **A gate needs a third verdict — could not measure** | any check that can time out, lose a dependency, or run on a contended machine | distinguish *failed* from *could not measure* with different exit codes, and say which; neither is a verdict about the code | the refusal names its remedy, and a test that waits for a DURATION rather than an event is treated as a defect in the test |
 | 32 | **A test whose assertion is implied by compilation is not a test** | any test whose name promises a behaviour | delete the subject: if that is a type or import error rather than a red test, the test is decoration | removing one asks what the name PROMISED and whether anything checks it — four of five such cases here were covered elsewhere and the fifth was a real gap only visible because the name was read as a claim |
+| 33 | **Snapshot before you undo** | any `git checkout`, `git restore`, `git stash` or `reset` in a tree that may hold uncommitted work you did not write | copy the affected files first (to a dated folder, or `git diff > <file>.patch`) and restore from that copy, never from git | the run names the copy it took before the first destructive command |
+| 34 | **One answer for inputs that should differ is a broken instrument** | any shell measurement, zsh above all | quote every expansion (`"$var"`, `'*.py'`), read data from files rather than inline literals, and feed it two inputs that should answer differently | the two answers differ, or the instrument is rewritten before its answer is used |
+| 35 | **Release the tree you tested** | any tag or release | run the release workflow's own suite on the exact commit the tag will name, and select the CI run by that tag, never by branch | the run the tag triggered is green and its head SHA is the tagged commit |
+| 36 | **A fix after a passing review is unreviewed** | any change made after a review or verifier passed | re-read the delta (`git diff <reviewed>..HEAD`) before merge | the merge names the reviewed SHA and who read the delta |
+| 37 | **Call the real service once before writing its fake** | any mock, stub or fixture of an external API, CLI or service | make one real call, or read a recorded real response, and shape the fake from it | the fake cites the response it was shaped from |
+| 38 | **Close blockers yourself; park only human gates** | any blocker about to be handed back | try every route the run holds (an API, a CLI, a credential door) first; park only a sign-in, consent, payment, typed secret or recorded operator decision | every handed-back item is a human gate, listed in one block with the route that failed |
+| 39 | **Never retry an unchanged failing action** | any failed command, check or approach | change the input or the approach before trying again; after two failed approaches, change approach or record a blocker | no identical retry in the run ledger, and a third attempt names what changed |
 
 ---
 
@@ -163,6 +170,17 @@ that document is checked. This one governs a fact that crossed a **session bound
 reported as current — the case where there is no document to check, only a memory that reads like
 one.
 
+**33 to 39 · The 2026-10-20 retro audit.** Read across ~54 retrospectives from ~50
+projects, the same lessons recurred under different words, each in at least the number
+of runs given: uncommitted work overwritten by a checkout, restore or stash with no copy
+taken (17); a zsh glob or `=` left unquoted, so a command failed or a loop printed one
+count for every file (8; this release's own run hit both); a tag cut from a tree the
+release suite never ran on, or a CI run picked by branch rather than by tag (24, with
+immutable tags burned); a fix landed after the review passed and merged unread; a fake
+shaped from documentation that the real service contradicted (11); a hand-back listing
+steps the agent could have done itself (12); and the same failing action retried
+unchanged, round after round. None of them was new to the project that hit it again.
+
 ---
 
 ## The two that are not in the table, and why
@@ -214,6 +232,11 @@ answer would have exposed it in a minute.
 | any command run to establish a fact — 6 Tests · 9 Docs · 10 Acceptance · 5 review | 19 — the output asserted non-empty and shaped as expected, and **quoted** rather than concluded from, [`audit.md`](audit.md) → *Silence is not a reading*; the reviewer's half is in [`review.md`](review.md) |
 | 0 Harvest · 10 Acceptance | 20 — the **consumer** read to learn which copy ships, never the copies compared against each other, [`audit.md`](audit.md) → *Two copies, and which one wins*; asked as row `0 Duplicates` of [`grill.md`](grill.md) → *The autonomy sweep* |
 | 10 Retro · **any gate or check you order** | 21 — each input traced to the step that writes it, and that step proven upstream, [`retrospective.md`](retrospective.md) → *Stamp first, then prune, then write* |
+| any stage · a destructive git command · a shell measurement | 33, 34 |
+| 7 Release · 5 Dev after review | 35, 36 |
+| 5 Dev · 6 Tests · a fake of an external service | 37 |
+| 10 Acceptance · the hand-back | 38 |
+| every stage · any retry | 39, [`loop-guard.md`](loop-guard.md) |
 
 **This file is the shipped list; a project keeps its own.** Every rule in the table
 above was earned on someone else's build and travels with the skill. The lessons *your*
@@ -276,7 +299,7 @@ evidence that something left, and the log below says what.
 
 ### Retired
 
-**Numbers issued so far: 32.** This is the high-water mark, and it is the only number
+**Numbers issued so far: 39.** This is the high-water mark, and it is the only number
 this file states about itself — deliberately, because the gap that proves a rule left
 cannot be computed from the table alone: **deleting the highest-numbered rule shrinks
 the maximum with it, and no gap ever opens.** That false negative shipped in the first

package/plugins/task-pipeline/skills/task-pipeline/references/loop-guard.md

@@ -22,7 +22,7 @@ searches.
 
 - Bookkeeping — the thing that makes detection mechanical
 - Detection — any one of these trips the guard
-- The review loop — a cap that measures rather than stops
+- The review loop: a cap that stops, and says why
 - The re-render loop — a budget of one, two at most
 - The break protocol
 - When to stop and hand back
@@ -66,12 +66,20 @@ stage's gate — which is the whole difference between a rule and a rule that ru
    loop (another task, another module) already closed in this run — two owners for
    one file.
 
-Caps that trip the guard by themselves: **5 fix rounds** per task
+Caps that trip the guard by themselves: **3 fix rounds** per task
 ([`build.md`](build.md)), **2 re-entries** per stage per artifact, **3 passes** per
-module in the program loop, and **3 review rounds** per artifact — which is not a stop
-but a measurement, below.
+module in the program loop, **3 review rounds** per artifact, and **3 failing
+certification rounds** per node ([`certification.md`](certification.md)). Each one
+**stops**: the remaining findings become blocker rows with their evidence and the run
+moves on (since 1.98.0; the review cap used to measure only).
 
-## The review loop — a cap that measures rather than stops
+**Two rules hold under every cap.** Never retry an unchanged failing action: the same
+command on the same input gives the same answer, so a retry is a loop with no
+information in it. After two failed approaches to one problem, change the approach or
+record a blocker; a third attempt of the same shape is the loop this file exists to
+end ([`learned.md`](learned.md) rule 39).
+
+## The review loop: a cap that stops, and says why
 
 The caps above govern loops that **edit**. A review loop does both: the reader finds,
 the run fixes, the reader reads again. It had no cap at all until 2026-08-10, and this
@@ -98,8 +106,10 @@ review cap reached — 3 rounds — artifact: test/validate.py
 - **Self-inflicted ≥ new** — the axis is exhausted ([`audit.md`](audit.md) → *Every
   pass changes the axis*). Stop. Every remaining finding becomes a board row with its
   evidence ([`backlog.md`](backlog.md)); none is dropped.
-- **New > self-inflicted** — the reader is still paying. Continuing is then the
-  operator's call, made with the numbers in hand rather than out of fatigue.
+- **New > self-inflicted** — the reader is still paying, and the loop still stops: the
+  open findings become board rows with the numbers beside them. A further round runs
+  only on the operator's explicit request, which is read when given and never waited
+  for.
 
 At the level of a whole iteration only new **blocking** findings argue for continuing; a
 deferred or noise finding is paid for on the board, not with another round

package/plugins/task-pipeline/skills/task-pipeline/references/retrospective.md

@@ -18,7 +18,7 @@ justifies reading it protects one section while the file below it doubles.
 
 | Artifact | Parts | How it is read |
 |---|---|---|
-| `docs/evidence/retro.md` — **one per project** | **Standing instructions** (max **10**) · **Run stamps** (max **10**, oldest rotate out) | stage 0, **in full** — both are bounded by a **cap**, which *one line each* never was |
+| `docs/evidence/retro.md` — **one per project** | **Standing instructions** (max **10**) · **Run stamps** (max **10**, oldest rotate out) | stage 0, **in full**: both are bounded by a **cap** and, since 1.98.0, by a **byte budget** (*The floor has a byte budget*) |
 | the same file's **Recent log** | narrative entries, **uncapped by design** — the heading said *entries from the last five run stamps* until 2026-08-20 while the section held 25 going back nine days, a bound in a heading that nothing enforced | stage 0, **queried** by the task's nouns. It said *in full* until 2026-08-10, when it measured **74%** of the file: an uncapped section inside a binding source is what makes the capped part get skimmed |
 | `docs/evidence/retro/YYYY-QN.md` — the archive | every entry and every retirement ever written, append-only | **queried** by the task's nouns; never read end to end |
 
@@ -35,6 +35,8 @@ file exists to stop.
 - Never amend a commit a record already names
 - A release stamp names the TAG, and the merge commit — never the branch's own SHA
 - The stamp table is capped at ten, and *one line per run* was never a cap
+- The floor has a byte budget
+- Before a standing row: search, cite, send upstream
 - `publish:` is a line in the verdict, not a silence
 - Rotation — the archive is how pruning stops losing things
 - Three grades of fix — take the highest one that can work
@@ -66,8 +68,16 @@ Required fields, and none of them is optional:
 | **Root cause** | why the pipeline permitted it. "The agent was careless" is not a cause — it is the absence of one, and it produces no fix |
 | **Fix** | one of the three grades below |
 | **The check** | what would have caught this the first time. If the honest answer is "nothing yet", that is the fix, and it is grade 1 |
+| **Class** | one of: `exit-code`, `unwatched-check`, `release`, `collision`, `destructive-undo`, `claim-by-say-so`, `stale-doc`, `wrong-copy`, `sibling`, `truncated-output`, `shell-instrument`, `handback`, `loop`. **Recurrence is counted by class**, so a class seen before is named as such |
+| **Cost** | what it cost: rounds, burned tags, time. An entry with no cost cannot be weighed against the check that would prevent it |
 | **Commit** | the short SHA of the change that fixed it |
 
+The classes come from the 2026-10-20 audit of ~54 retrospectives across ~50 projects,
+where the same lessons recurred under different words: a gate's exit code read through
+a pipe (≥26 runs), a check trusted before it was seen failing (≥26), a tag cut from a
+tree the release suite never ran on (≥24), a shared checkout (≥20), uncommitted work
+overwritten (≥17). Words hid the recurrence; a class key makes it a count.
+
 ## Every lesson carries its commit
 
 A standing instruction carries **two** SHAs — `Commit` (the change that introduced
@@ -177,6 +187,38 @@ like every other rotation. **The count is printed at the prune**, beside the sta
 instructions' own count, so a table that stops rotating is visible rather than merely
 large.
 
+## The floor has a byte budget
+
+A cap of ten rows never bounded their **size**. Measured 2026-10-20 across ~50
+projects, the floor stage 0 reads in full (standing instructions plus run stamps) ran
+from ~3k to **~76k tokens**; one floor was 304 KB, and this repository's own was
+27 620 bytes. A row that carries its incident and a stamp that carries its release
+narrative are how a capped list grows anyway.
+
+- **Budget:** the floor stays under **12 000 bytes**. A standing row is at most **600
+  characters**: the rule, why (one clause), the retire-when trigger and the id; the
+  story lives in the archive. A run stamp is **one line of at most 300 characters**.
+- **Stage 0 prints it:** `python3 scripts/retro_budget.py check` gives the floor's bytes
+  and bytes/4 tokens, beside the source ledger's retro row.
+- **Gate 10 fails over budget.** Before the new entry is written, `retro_budget.py
+  migrate --write` moves the narrative (an over-long stamp's verdict, a standing row's
+  `Because`) **verbatim** into the quarter's archive, each block carrying the sha256 of
+  its text, and leaves a pointer; `retro_budget.py verify` proves every pointer. An
+  instruction still over 600 characters after its story moved is rewritten by hand.
+- **A prune that retires nothing writes its count into the stamp row**, as
+  `prune: 0 retired`, and no paragraph. Repeated "nothing to prune" notes were a
+  measured share of the floor.
+
+## Before a standing row: search, cite, send upstream
+
+- **Search first:** `references/learned.md` and the lesson index
+  (`scripts/lessons.py query`, by the class key and the nouns). A rule already there is
+  **cited by its number** (`learned.md` rule 22), never restated in a row.
+- **A lesson standing in two projects goes upstream in the same run:** the entry gets
+  its `**Lesson:**` line and `scripts/lessons.py add`, and a universal rule is proposed
+  for `learned.md` (*Publishing the insight*, below). Two projects holding one rule is
+  a fork nobody named.
+
 ## `publish:` is a line in the verdict, not a silence
 
 Reported from another project, and the report is about this file: an operator asked, after
@@ -265,6 +307,10 @@ computable, which is why it goes first:
 printf '%s · %s\n' "$(date +%F)" "$(git rev-parse --short HEAD)" >> docs/evidence/retro.md
 ```
 
+**The budget runs between the prune and the entry:** stamp, prune, `retro_budget.py
+check` (and `migrate --write` when it fails), then write. An entry written onto a floor
+already over budget is the growth the budget exists to stop.
+
 ## The prune — mandatory, and it runs after the stamp
 
 A lesson that lands in a cluttered file is a lesson nobody will reach — so the prune still runs

package/plugins/task-pipeline/skills/task-pipeline/references/spec.md

@@ -18,7 +18,7 @@ Writing the approved design down so a zero-context implementer — human or suba
 - Module dossier — when the run is one brick of a platform
 - Self-review — before showing it
 - Locked contracts are decisions — the register, not only the spec
-- GATE (manual)
+- GATE (auto)
 
 ## Order of operations
 
@@ -280,13 +280,14 @@ spec section instead of restating the reasoning there.
 and the next one supersedes it; an id survives. If this stage settled something and
 no entry names it, the run has agreed to decide it again later.
 
-## GATE (manual)
+## GATE (auto)
 
 > "Spec written and committed to `<path>`. Review it and tell me if anything should
 > change before I write the implementation plan."
 
-Wait for the operator. Changes requested → apply, re-run the self-review, ask
-again.
+Where the brief records a standing authorization (the default gate is `auto` since
+1.98.0), an independent reader reviews the spec and the run continues; otherwise wait
+for the operator. Changes requested → apply, re-run the self-review, and review again.
 
 The gate is not only the operator's word: **every section carries `covers: REQ-…`
 and every REQ in the brief appears in at least one section.** For UI tasks it

package/plugins/task-pipeline/skills/task-pipeline/references/stage-00-intake.md

@@ -7,13 +7,13 @@ The full gate and freedom level remain in [stages.md](stages.md).
 - 0 — Intake grill — MANDATORY
 
 ## 0 — Intake grill — MANDATORY
-- **Stage 0 is not optional and not skippable.** There is no "small enough task"
-  exemption, no "the request was already clear" exemption, no starting stage 1
-  "while the operator thinks". The only sanctioned bypass is the
-  entry-from-super-ux short-circuit below, and even that still requires a scope
-  confirmation and a record of what was adopted vs skipped. A run that reaches
-  stage 1 without a committed, operator-confirmed brief is a **failed run** —
-  stop and go back.
+- **Stage 0 always runs, and its depth is proportional.** The gap check, the
+  harvest and the brief are never skipped; the interview, the committed brief file
+  and stages 1-4 are what a small change does without (Phase 1d below, the
+  *proportional run*). A run that starts building without a brief and its REQ rows
+  (in the brief file, or on the short path in the run ledger) is a **failed run**:
+  stop and go back. The entry-from-super-ux short-circuit below is the other
+  sanctioned shortening.
 - **Entry-from-super-ux short-circuit (check FIRST).** task-pipeline is often
   launched *from* super-ux — its `/ux` action menu offers "execute autonomously
   via the task-pipeline plugin" once the UX chain (and often a
@@ -40,8 +40,9 @@ The full gate and freedom level remain in [stages.md](stages.md).
   `affected` / `god-nodes` answer *reach*, which is what grep cannot), `CLAUDE.md`,
   `CONTEXT.md`/ADRs, `docs/` + `docs/ux/`, past pipeline briefs and carry-over
   ledgers, **the retro's standing instructions and run stamps** (`<artifacts>/retro.md`,
-  read **in full** — ten standing rows and ten stamps, both bounded **by a cap**, and they bind this
-  run; stamp each instruction as it fires. Its *Recent log* is **queried** by the
+  read **in full**: ten standing rows and ten stamps, bounded by a cap and by a byte
+  budget; print `scripts/retro_budget.py check` first, which states the floor's bytes and
+  bytes/4 tokens. They bind this run; stamp each instruction as it fires. Its *Recent log* is **queried** by the
   task's nouns, not read: uncapped narrative inside a binding source is what makes the
   capped part get skimmed, [`retrospective.md`](retrospective.md)), **lessons from other
   projects** (source 7b, [`knowledge-sources.md`](knowledge-sources.md): `scripts/lessons.py
@@ -81,30 +82,43 @@ The full gate and freedom level remain in [stages.md](stages.md).
   or they genuinely disagree and that is a decision. There is no fourth option, and
   starting on an unresolved divergence means building against a system that does
   not exist.
-- **Phase 1d — the short-path triage: printed, proposed, never taken silently.** This
-  pipeline's own boundary exempts a typo, a one-line fix and a mechanical rename — and
-  nothing measured that until 2026-08-10, so the exemption depended on an agent
-  remembering it while eleven stages and four manual gates stood in front of a
-  one-paragraph edit. Three questions, each with something behind it:
+- **Phase 1d — the short-path triage, and the proportional run: a small change
+  takes the short path by default.** This pipeline's boundary exempts a typo and a one-line edit; until 1.98.0
+  the next size up still met eleven stages and five manual gates, because the short
+  path was only *proposed* and silence took the full flow. Under a standing "decide and
+  act" instruction silence is the normal answer, so a proposal was the full flow every
+  time. The triage now **decides**, from five answers with something behind each:
 
   ```
-  1. files the request names, resolved        git ls-files -- <paths>       -> N
+  1. files the change touches, resolved      git ls-files -- <paths>       -> N
   2. any of them a public contract            the surfaces the host's release
                                               syncs, its schema or config
                                               contracts, a shipped command,
                                               its README                    -> yes/no
-  3. behaviour a user or a caller observes changes                          -> yes/no
+  3. behaviour a user observes changes        a UI, a message, an output    -> yes/no
+  4. a deploy target in the brief             stage 7's target exists       -> yes/no
+  5. risk class                               work-graph.md R1-R3           -> R1/R2/R3
   ```
 
-  Few files, no contract, no observable change ⇒ **propose** the short path: stages 1,
-  2, 3 and 4 marked `⊘` with the triage answer as the reason, and 5→10 running
-  unchanged. **Propose, never take.** The answer goes in the brief's autonomy sweep and
-  silence takes the full flow — the same floor deploy authorization uses. The glyph is
-  what makes it safe: a skipped stage is printed on the rail **with its reason**
-  ([`progress.md`](progress.md)), and a skip nobody can see is indistinguishable from a
-  stage that was never entered.
-- **How it runs: [`grill.md`](grill.md)** — the full doctrine, built into this
-  skill (nothing to install). In short: close what the sources can, then ONE batch
+  **Small** means all of: the gap check left zero material unknowns, N ≤ 5, no public
+  contract, no user-observable change, no deploy, and risk **R1**. Small ⇒ the run takes
+  the short path and prints one line:
+  `short path: R1 · N files · no contract · no user-facing change · no deploy`.
+  `scripts/short_path.py` computes the decision from the five answers (exit 0 short,
+  3 full) and prints that line.
+  The short path is: the brief and its REQ rows written into the run ledger (no grill,
+  no committed brief file) → stage 5, build with tests → stage 6, the suite plus **one**
+  verification (one blind tier, [`certification.md`](certification.md)) → stage 9, the
+  docs the change makes false and the handoff → stage 10, the hand-back and a run stamp;
+  a retro entry only when the run taught a new lesson. Stages 1-4, 7 and 8 print `⊘`
+  with the triage line as their reason ([`progress.md`](progress.md)).
+  **Triggers that bring a skipped stage back:** a deploy target appears (7, 8); a wiki or
+  code graph exists and the change touched what it indexes (9 in full); a check reveals a
+  contract or a user-facing effect (leave the short path, resume at stage 2); the
+  operator asks for the full cycle. Any answer outside *small* takes the full flow,
+  printed the same way with the failing answer as its reason.
+- **How it runs: [`grill.md`](grill.md)**, read only when the gap check leaves a
+  material unknown (a complete brief asks nothing). In short: close what the sources can, then ONE batch
   of the material unknowns, ordered by dependency, a recommended answer with each —
   one at a time only where answers depend on each other or the operator asks;
   contradictions reconciled on the spot; **every answer that touches

package/plugins/task-pipeline/skills/task-pipeline/references/stage-05-dev.md

@@ -7,7 +7,7 @@ The full gate and freedom level remain in [stages.md](stages.md).
   workspace (native worktree tool first, git fallback, baseline tests), keep a
   ledger under `.task-pipeline/build/<plan>/` so a compacted context can resume,
   then one fresh implementer subagent per task with a file-based brief and report,
-  a review after every task ([`review.md`](review.md)), and a five-round fix loop
+  a review after every task ([`review.md`](review.md)), and a three-round fix loop
   with an explicit breaker. TDD per task ([`tdd.md`](tdd.md)): failing test →
   watch it fail → minimal impl → watch it pass → commit. Pin subagents to the
   run's confirmed model (`model-tiering.md`). The plan's parallel groups fan out
@@ -19,8 +19,8 @@ The full gate and freedom level remain in [stages.md](stages.md).
   contradiction that exists only between two of them.
 - **Web front end? The task's own surface is checked in a browser, not in the diff.**
   Where a browser channel is connected — `playwright` **or** `chrome-devtools`, either
-  one, whichever answers first (**how**: [`browser.md`](browser.md); which:
-  [`companion-skills.md`](companion-skills.md)): after a
+  one, on WebKit first with Chromium a stated exception (**how**, and the engine order:
+  [`browser.md`](browser.md); which: [`companion-skills.md`](companion-skills.md)): after a
   task that changes a rendered surface, load it, take a snapshot and read the
   console and the network log **before the task is marked DONE** — a component can be
   correct and land under a fixed header, and a review of the diff cannot see that.

package/plugins/task-pipeline/skills/task-pipeline/references/stage-08-post-deploy.md

@@ -13,8 +13,9 @@ The full gate and freedom level remain in [stages.md](stages.md).
 - **A deployed web target is opened, not curled.** A `200` proves the server
   answered; it says nothing about whether the page rendered, whether a bundle 404'd,
   or whether the console filled with errors on load — all three ship green past a
-  health check. Where a browser channel is connected — `playwright` **or**
-  `chrome-devtools`, either one ([`browser.md`](browser.md)) — load the deployed URL and read
+  health check. Where a browser channel is connected — `playwright` on WebKit first
+  **or** `chrome-devtools` as the stated Chromium exception, and a Chromium-only look
+  is reported as such; either one ([`browser.md`](browser.md)) — load the deployed URL and read
   the console and the network log; quote what you read, not that you looked
   ([`companion-skills.md`](companion-skills.md)). Absent → say the check was an HTTP
   response only, which is the honest name for it.

package/plugins/task-pipeline/skills/task-pipeline/references/stages.md

@@ -1,9 +1,10 @@
 # Stages — detail & gates
 
-For the selected **default profile**, read this spine at entry, then the one detail
-linked in the current stage before work on every entry or resume, including wave
-iterations and approved short paths. Do not preload all stage details. Missing or
-unreadable detail means stop that stage and repair its route, never guess. A custom
+For the selected **default profile**, read **one stage section of this file when that
+stage starts** (the stage table in `SKILL.md` is the index), then the one detail it
+links, on every entry or resume, including wave iterations and approved short paths
+(the triage approves the short path itself since 1.98.0). Never read this file end to
+end. Do not preload all stage details. Missing or unreadable detail means stop that stage and repair its route, never guess. A custom
 profile uses its own declared doctrine and stages; numeric ids do not select these
 default details, and the kernel still applies.
 
@@ -14,7 +15,10 @@ orchestrator verifies the check itself, pass/fail), `judgment` (a named judge
 rules where no complete deterministic check exists — [`gates.md`](gates.md) →
 *The judgment gate*) or `manual` (requires the operator's explicit go, including a
 specific standing authorization naming the act, cited with its source and scope;
-otherwise wait). These stages (0 intake + 1→10) are the plugin's
+otherwise wait). **This example ships every gate `auto`** (since 1.98.0): where it
+names an approval, the operator's answer or the standing authorization recorded in the
+brief satisfies it without a pause. A project makes a gate `manual` in its own
+`pipeline.json`. These stages (0 intake + 1→10) are the plugin's
 **example** flow, encoded in `pipeline.example.json` against the universal contract
 `pipeline.schema.json`; a host project replaces it with its own
 stages/agents/types (see SKILL.md → *Bring your own skills*).
@@ -84,7 +88,11 @@ never that the work was skipped quietly.
 
 **On entry or resume:** read [stage-00-intake.md](stage-00-intake.md) before stage work.
 
-- **GATE (manual):** shared understanding reached — **the source ledger is written
+- **On the short path** (`stage-00-intake.md` → Phase 1d) this gate
+  is: the triage line printed, the brief and its REQ rows in the run ledger, the retro
+  floor read with its byte count, and the source ledger. Everything else below applies
+  to the full flow.
+- **GATE (auto):** shared understanding reached — **the source ledger is written
   (every source consulted, or an explicit "none found")** and **its `Contradictions:`
   line is written under it** — the harvest is a fan-out that converges on one brief, and
   nothing else compares the sources *with each other*; `Contradictions: none` is the
@@ -107,8 +115,8 @@ never that the work was skipped quietly.
   is filled — objective, exit checks on the artefact the operator uses, scope, budget and
   base** ([`finish-line.md`](finish-line.md)), the carry-over ledger is
   seeded, **`.task-pipeline/run.md` exists and the header block has been printed**
-  ([`progress.md`](progress.md)), the model decision is recorded, and the operator
-  confirms the brief. Stop when a
+  ([`progress.md`](progress.md)), the model decision is recorded, and the brief is
+  confirmed: the operator's answer, or the standing authorization recorded in it. Stop when a
   re-scan surfaces no new branches (don't grill past diminishing returns;
   reversible calls can be deferred with a note). Only then start stage 1.
 - **The verification ledger is read.** `<artifacts>/verification.md` — the harvest
@@ -140,7 +148,8 @@ never that the work was skipped quietly.
 
 **On entry or resume:** read [stage-02-brainstorm.md](stage-02-brainstorm.md) before stage work.
 
-- **GATE (manual):** the user approves the design, the UI verdict is recorded, **the
+- **GATE (auto):** the design is approved (the operator's go, or the brief's standing
+  authorization), the UI verdict is recorded, **the
   queue is an artifact rather than a recollection** — where it is a work graph,
   `graph.py validate` exits 0 and `graph.py coverage` names any requirement no node serves,
   **every REQ is answered by the design** — a requirement the design doesn't
@@ -156,10 +165,11 @@ never that the work was skipped quietly.
 
 **On entry or resume:** read [stage-03-spec.md](stage-03-spec.md) before stage work.
 
-- **GATE (manual):** the **`## Self-review` section written and committed with
+- **GATE (auto):** the **`## Self-review` section written and committed with
   computed values** — every check the spec names resolving or marked `review`, the
   brief's decisions and stage 2's rejected options read back with no unresolved
-  contradiction, and the cost delta printed; spec committed **and** user-reviewed; **every section carries
+  contradiction, and the cost delta printed; spec committed **and** reviewed (by the
+  operator, or under the brief's standing authorization by an independent reader); **every section carries
   `covers: REQ-…` and every REQ appears in at least one section**; for UI tasks
   additionally: the super-ux chain (foundation → flows → screens → scenarios) is
   designed, validated and approved; scenarios validated in `docs/ux/scenarios.md`;
@@ -254,8 +264,9 @@ never that the work was skipped quietly.
   page rendered — a component can be correct and land under a fixed header, a request
   can 404 while every unit test mocks it, and a console error costs nothing at test
   time. Where a browser channel is connected — `playwright` **or** `chrome-devtools`,
-  either one ([`browser.md`](browser.md) is the four commands this sentence means;
-  [`companion-skills.md`](companion-skills.md) is which channel):
+  either one, on WebKit first with Chromium a stated exception
+  ([`browser.md`](browser.md) is the four commands this sentence means and the engine
+  order; [`companion-skills.md`](companion-skills.md) is which channel):
   load the surface, take a snapshot, and read **the console and the network log**
   before calling it green. Absent, say the surface was verified **by reading the
   diff** — that is a weaker claim and the close-out records it as one, rather than
@@ -298,10 +309,10 @@ never that the work was skipped quietly.
 
 **On entry or resume:** read [stage-07-lint-deploy.md](stage-07-lint-deploy.md) before stage work.
 
-- **GATE (manual):** lint clean (host linter **and**, for UI projects, the super-ux
+- **GATE (auto):** lint clean (host linter **and**, for UI projects, the super-ux
   linter) **and** suite green **before** deploy, **and no REQ is still `open`** — a
   `partial` ships only with the operator's explicit acceptance. A gap is cheapest to
-  close before it ships, and the operator is already present at this gate. **The
+  close before it ships. **The
   carry-over count is printed beside this verdict.** Deploy is outward → explicit
   operator go, or a specific standing authorization naming that act, cited with its source
   and scope. Authorization to release does not silently authorize a separate deploy. If
@@ -375,7 +386,7 @@ never that the work was skipped quietly.
 
 **On entry or resume:** read [stage-10-acceptance.md](stage-10-acceptance.md) before stage work.
 
-- **GATE (manual):** the ladder walk ran and its absences became REQ rows before
+- **GATE (auto):** the ladder walk ran and its absences became REQ rows before
   the table was written; **the hand-back is written** — the request quoted as it was
   GIVEN, where the run stands against it, what was solved with its evidence, what
   surfaced that nobody asked for, every decision still waiting **asked here with
@@ -421,10 +432,11 @@ never that the work was skipped quietly.
   carries evidence; every `partial` names what's missing and where it's tracked;
   every `deferred`/`dropped` has the operator's agreement and, for `deferred`, a
   tracker entry; no carry-over row left `unresolved`, and the ledger's counts are
-  printed with the verdict; the operator answers the
-  closing question and signs off. Manual by design — an automated check can prove
-  the table is well-formed, only the person who asked can confirm it is what they
-  asked for.
+  printed with the verdict; the hand-back asks the closing question and carries
+  the answer the operator can give at any time. `auto` by default since 1.98.0: a
+  check proves the table well-formed, and only the person who asked can confirm it is
+  what they asked for, so the run hands that question back rather than waiting on it.
+  A project that wants the wait sets this gate `manual`.
 
 ## The program loop — a platform, one brick at a time
 
@@ -485,8 +497,8 @@ cycle.
   a feeling, and the ledger is what survives compaction.
 - **Trips on:** revert-oscillation (A→B→A); the same file edited twice for the same
   reason; a finding already ADDRESSED or parked coming back; a stage entered a third
-  time for one artifact; two loops editing one file. Hard caps: 5 fix rounds per
-  task, 2 re-entries per stage per artifact, 3 passes per module.
+  time for one artifact; two loops editing one file. Hard caps, each a stop: 3 fix
+  rounds per task, 2 re-entries per stage per artifact, 3 passes per module.
 - **On a trip: stop editing.** Name shapes A and B with their evidence, escalate to
   the layer that owns the conflict (rubric → operator → plan → spec → module map),
   re-plan the check as an ordered one-item-per-line checklist, then go through it in

package/plugins/task-pipeline/skills/task-pipeline/references/tdd.md

@@ -102,8 +102,9 @@ database created ten seconds ago" are different claims, and only the second one
   code does what its assertions say; it cannot see a component that renders correctly
   and lands under a fixed header, a request that 404s while every unit test mocks it,
   or a console error that costs nothing at test time. Where a browser channel is
-  connected — `playwright` **or** `chrome-devtools`, either one
-  ([`companion-skills.md`](companion-skills.md)) — open the surface and read
+  connected — `playwright` **or** `chrome-devtools`, either one, on WebKit first with
+  Chromium a stated exception ([`companion-skills.md`](companion-skills.md);
+  [`browser.md`](browser.md) → *Engine order*) — open the surface and read
   the console and the network log before calling it done — and **quote what you read**,
   not that you looked. Absent, the honest sentence is *"verified by reading the diff"*,
   which is a weaker claim and is recorded as one. Same family as a test that passes

package/plugins/task-pipeline/skills/task-pipeline/references/waves.md

@@ -57,10 +57,12 @@ on real agents, tasks and users rather than on the first guess.
 | 5–8 Build → post-deploy | per wave, then the close pass. A wave's stage 7 integrates to the main branch **without tagging**; the release's tag, its approval mode and its go are stage 7's full gate, run once at the release ([`iteration.md`](iteration.md) → *The cycle*, step 10), and stage 8's trio follows on what was released (step 11) |
 | 9 Docs + wiki · 10 Acceptance | once, to close the release, over everything the waves shipped |
 
-**One planning gate, not three prompts.** The manual gates of stages 0, 2 and 3 are
-presented together at the end of planning: the brief, the canvas, the wave plan and the
-question batch in one message. Each gate's criteria are still checked and printed; the
-operator is asked once, and the go names the gates it closes. Silence closes none.
+**One planning gate, not three prompts.** The gates of stages 0, 2 and 3 are presented
+together at the end of planning: the brief, the canvas, the wave plan and the question
+batch in one message. Each gate's criteria are still checked and printed. They are `auto`
+by default (since 1.98.0): the standing authorization recorded in the brief closes them
+and the run continues; where the project made them `manual`, the operator is asked once,
+the go names the gates it closes, and silence closes none.
 
 ## Wave 0 — the survey and the inventory