task-pipeline-skill 1.97.1 → 1.99.0

package/CHANGELOG.md

@@ -1,3 +1,286 @@
+## v1.99.0 (2026-10-21)
+
+Guards: 448 → **530**; property checks 15 → **15**. There are 82 new negatives in
+`lessons.py`. Each one plants a revert, and the suite must catch it:
+
+- the whole-scan refusal put back;
+- the carry-forward removed;
+- status computed without carried origins;
+- prune on every run;
+- git worktrees no longer discovered;
+- memory ids keyed by retro anchor;
+- one memory id left on two class keys;
+- problems attributed by path prefix;
+- `emit`/`record` ignoring the origin that holds the memory id;
+- memory ids compared together with their `@revision`;
+- a stranger at the same path not recognised;
+- `record` putting one memory id on two class keys;
+- an origin removed on its own;
+- a memory id moved to another project's origin;
+- an origin carried as `checkout holds another project` counted;
+- a project key taken from the checked-out branch;
+- a stranger called on a key alone, though the origin's commit resolves;
+- `record` taking another project's id;
+- `record` writing an id the loader refuses;
+- a title carrying a Unicode line separator;
+- the index split on Unicode line breaks;
+- a rebuild printing absolute paths;
+- `--prune-carried-reason` accepted alone, or taking any string, or offering a reason that
+  never occurs;
+- merged duplicate lines dropping an id silently;
+- `add` counting a phantom project after a re-init;
+- a shallow check trusted when it times out;
+- an index line accepted with `mem:x@0` or with an unknown `carried` reason;
+- an origin v1.95.0 wrote kept as a second project, by `rebuild` or by `add`;
+- that re-key made for an origin with provenance, between two candidate repositories, or
+  merging two memory ids (in `rebuild` and in `add`);
+- `record` re-attaching an id from another checkout;
+- one memory id left on two live projects, or kept by the later holder;
+- a project key skipping the main worktree's HEAD or `init.defaultBranch`;
+- redaction replacing a relative name, or inside a longer name;
+- a session note, a newer-format notice or a refusal printing an absolute path;
+- a stage id carrying a line break or a path;
+- a same-revision duplicate decided by the order of lines;
+- a re-key taking a commit from a merged history, ignoring the key v1.95.0 would compute, or
+  moving a project read this run;
+- `add` leaving one id on two live projects; the id kept by the smaller key instead of the
+  earlier holder;
+- a rebuild asking git the same question again;
+- `query`, an `add` refusal or the repository top printing an absolute path;
+- an index set aside for a stage id v1.95.0 accepted, or one normalised past 32 characters;
+- the schema admitting a blank stage id;
+- a partial rebuild or an `add` moving an origin of a project the index already knows;
+- an origin carried as `checkout holds another project` counted as a live holder of its id;
+- a re-key that does not record where the id came from, in `rebuild` or `add`, or loses that
+  source on a repeated `add` or a rebuild;
+- `rebuild`, `add` or `record` never giving a re-keyed id back to its source project, or
+  giving it back while leaving it on the other project too, or over that project's own id;
+- an index line accepted with an impossible `rekeyedFrom`;
+- an id dropped by the one-project or the one-class rule keeping its `rekeyedFrom`, a re-key
+  source given to every project holding that id, a reclaim to a project never read, the main
+  worktree's HEAD keying the repository before `init.defaultBranch`, and `save` writing a line
+  the loader refuses;
+- `record --replace` keeping the replaced id's `rekeyedFrom`, and an `add` or rebuild re-key
+  giving a twin's own id a source it never had.
+
+These are the fixes from verification rounds 6 to 18 of release iteration 1.
+
+- **A replaced id takes its source with it** (round 18). `record --replace` gave the origin a
+  new id but kept the `rekeyedFrom` of the re-keyed id it replaced, so the next read of that
+  source project took X's own record, and X's later record of it was refused. An origin given
+  another id now drops the source. A re-key whose legacy origin held no id no longer tags the
+  twin's own id with the legacy project as its source.
+
+- **No write leaves a line the loader refuses; only a read project reclaims** (round 17).
+  When the one-project or the one-class rule took a memory id off an origin, `rekeyedFrom`
+  stayed behind; the loader refuses a source beside no id, so the next command set the whole
+  index aside as `.corrupt-<date>` and every lesson in it left the live index. The source now
+  leaves with the id, and it follows the (id, project) it was recorded for: another project
+  holding the same id is never given one. `save` reads every line back as the loader does and
+  refuses to write one it would refuse, the previous index intact. A re-keyed id goes back
+  only to a project actually read (an origin with provenance, not carried), never to a
+  v1.95.0 origin that could not be re-keyed in the same run. `init.defaultBranch` now keys
+  the repository before the main worktree's HEAD, so a main worktree on an orphan branch does
+  not move the key. Known, not fixed here, each with a backlog row: a `git replace --graft`
+  moves the key (B-141); a v1.95.0 origin with no twin still counts as a second project
+  (B-142); the known-project set is index-wide (B-143); a case-insensitive path read twice
+  (B-144).
+
+- **Ownership is recoverable, not predicted** (round 16). A re-key can only judge the projects
+  it has already seen, so an `add` in X, or a rebuild of X's root alone, could take an id
+  from a repository Y that had never been read. A re-key now records its source key on the
+  origin (`rekeyedFrom`). The first time Y is read with an origin of that class key, by
+  `add` or `rebuild`, or Y records the id, the id moves back to Y, is dropped from X, and a
+  `reclaimed:` line names it. Whichever verb runs first, the final owner is the project
+  whose key the legacy store used. When Y already holds its own id for that class, nothing
+  moves, and that is said. Each lesson plant now requires its own expected failure line, not
+  any non-zero exit. Known, not fixed here: the known-project set is index-wide, not per
+  class key.
+
+- **Ownership no longer depends on verb order** (round 15). The live-project rule now covers
+  every project the previous index records with provenance, not only the projects this run
+  read: an `add` in a repository, or a rebuild over its root alone, never re-keys another
+  known project's origin, and a later full rebuild agrees. That rule subsumes the separate
+  "no re-key with provenance" check (an origin with provenance names a known project), so the
+  check and its plant (492) are retired; the F1c test stays. Known limit, not fixed here: on a
+  case-insensitive file system one checkout reached by two spellings of its path is read
+  twice (real paths do not fold case), which can count a phantom second project; no memory
+  id ends on two projects.
+
+- **The re-key and the one-project rule, closed** (round 14).
+  - A provenance-less origin is re-keyed only when, in the checkout that re-derived its anchor,
+    its commit descends from the root the new key names (so it resolves there) and v1.95.0
+    would have computed its key there. Round 13's separate "commit resolves" plant (490) is
+    retired: the roots check subsumes it, so reverting it alone changes nothing. So is its
+    "own key re-derived" plant (493): an origin whose own key is re-derived belongs to a project
+    read this run, which the next rule already keeps. A monorepo that merged another repository's history keeps
+    its hands off that repository's origin and memory id.
+  - An origin whose project key any checkout read this run holds is never re-keyed, whatever
+    its anchor.
+  - `add` keeps one memory id on one live project, against the index as it read it.
+  - The M/M2 fixtures put the earlier holder's key above the later one, so "the smaller key"
+    fails every run.
+  - One `cat-file` per (checkout, commit) in a run.
+  - Every verb's messages name files, the index home-relative; `path` alone prints a path.
+  - A stage id v1.95.0 accepted that lesson/1 now refuses is normalised on read and said, so no
+    line and no memory id goes to the corrupt file. The schema's string stage ids are not blank.
+  - The pre-tag admission packet cites the v1.94.0 commit, not the tag object, which a clone
+    without tags does not hold.
+
+- **Upgrade and ownership in `lessons.py`** (round 13).
+  - An index written by v1.95.0 (keyed on the smallest root of HEAD, no provenance) no longer
+    turns a repository that merged an unrelated history into two projects. An origin with no
+    provenance whose `retro#anchor` this run re-derives under exactly one other key, and whose
+    commit resolves in that checkout, is re-keyed: its memory id follows, and `emit` and
+    `record` keep using it. `add` does the same for its own checkout. Never with provenance,
+    never when its own key is re-derived, never between two candidates, never merging two ids.
+  - `record` re-attaches an id held by an origin carried as `checkout holds another project`
+    only from a checkout in that origin's provenance (a re-init at the same path).
+  - A rebuild never leaves one memory id on two live projects: the earlier holder keeps it,
+    and the other origin is named and keeps its place without it.
+  - Without `origin/HEAD`, `main` or `master`, the project key is the main worktree's HEAD,
+    then `init.defaultBranch`, so a linked worktree on an orphan branch is the same project.
+  - Redaction replaces only absolute paths, as whole path components (`--roots .` deleted every
+    dot), and stderr (the session's notes, the newer-format notice, a refusal) is redacted
+    like stdout (in `rebuild`; every verb since round 14).
+  - A stage id given as a string gets the text checks: one line, at most 32 characters, no
+    path or credential shape.
+  - Two copies of one origin at the same revision keep the lexically smaller id, whatever the
+    order of the lines.
+
+- **Identity and safety in `lessons.py`** (round 12).
+  - The project key is the repository's: the first-parent root of its default branch, once
+    per git common dir. A worktree on a branch that merged an unrelated history, or a checkout
+    on an orphan `gh-pages`, is still its project.
+  - `checkout holds another project` applies only when the origin's own commit does not
+    resolve in that checkout. `add` applies the same rule to its checkout's old-key origin, so
+    a re-init never counts a phantom project, even before the next rebuild.
+  - `record` refuses an id another project's origin holds, naming the project (exit 1), and an
+    id the loader would refuse (exit 2).
+  - lesson/1 text (a string stage id too, since round 13) refuses every line separator,
+    including U+2028, U+2029 and U+0085. The index
+    is split on `\n` only, so a value can never make it read as corrupt.
+  - Rebuild messages name checkouts and files, never an absolute path.
+  - `--prune-carried-reason` needs `--prune-carried` and offers only the reasons a rebuild
+    produces; otherwise it is a usage error, exit 2.
+  - Merged duplicate lines name the id they drop and keep the higher revision.
+  - A shallow check that does not answer is refused: no source, and a problem named.
+
+- **`lessons.py rebuild` never removes or moves anything on its own** (round 11, narrowed
+  under the loop guard).
+  - Every previous origin the run does not re-derive is carried with everything recorded on
+    it, its memory id included, and marked `carried: <reason>`.
+  - `--prune-carried`, optionally narrowed by `--prune-carried-reason <reason>`, is the only way
+    an origin leaves the index.
+  - Nothing supersedes and nothing moves: a memory id stays on the origin that holds it, and is
+    re-attached only to the same `(project, classKey)`.
+  - The reasons are `checkout not read`, `retro file not read`, `no checkout read holds it`
+    (the checkout read the file and the entry is gone), `commit does not resolve`,
+    `retro cites a commit that does not resolve`, `lesson refused`, `no provenance` and
+    `checkout holds another project`. The last one is kept but not counted in `seen`,
+    `projects` and `status`; the others count as temporary unavailabilities. So no phantom
+    project appears, and an unreadable root never demotes a lesson.
+  - A shallow clone is never a source: a problem owned by its checkout, with nothing derived
+    under its unstable key. `add`, `emit-observatory` and `record` refuse there, exit 1, and say
+    to deepen it.
+  - Known limit: a project whose root commit changes (re-init, unshallow) starts new store
+    records. The operator re-attaches by `record`-ing the old id on the new origin of the same
+    class key.
+  - `record` over a different id the origin already holds needs `--replace`. It also refuses an
+    id another class key holds and a revision older than the one held.
+  - Each origin records its provenance, `checkouts`, the real paths it was derived from. It
+    decides only the carried reason; it stays in the local index, is never emitted, and `show`
+    omits it. A path is not an identity.
+  - Git worktrees of every checkout found are discovered, including those under
+    `.worktrees/` and `.claude/worktrees/`. Problems carry a structural owner and are printed by
+    name, never by absolute path or prefix match.
+  - Retro files are stamped when read and again under the lock. A file that changed in
+    between, such as an `add` landing mid-run, leaves its checkout not read for that run.
+  - Memory ids follow `(project, classKey)`, compare on the part before `@`, start at revision
+    1, and keep the highest revision everywhere. One id is never on two class keys, and the run
+    refuses to write if an id would vanish other than by `--prune-carried`.
+  - Index lines are re-derived from their origins on every read: `seen`, `projects`, `status`
+    and the rest are never trusted from disk, and duplicate origins and duplicate lines merge.
+    A line with wrong types, an origin lesson that fails lesson/1, a `carried` outside the
+    enum, or `mem:…@0` is a corrupt line. It is salvaged around and never causes a traceback.
+    A memory id that only a bad line held is named in the output.
+  - Exit 1 means nothing could be read: every root was missing or unreadable. A readable empty
+    root, or one holding only a shallow clone, exits 0.
+
+- **`lessons.py rebuild` never loses what it cannot re-derive.** Round 6's narrowed refusal
+  dropped an origin and its memory id while a project's root was unreadable. It also still
+  refused the routine case: an indexed lesson whose commit was pruned after a squash merge.
+  Rebuild now derives every lesson it can read. Every previous origin whose source it could
+  not re-derive is carried forward with everything recorded on it, marked `carried`, and
+  named. That covers a root not read or outside the scan, a commit that no longer resolves,
+  and a refused entry. Carried origins count toward `seen`, `projects` and `status`. They are
+  re-derived and un-marked when the source reads again, and are removed only by the new
+  `--prune-carried`. Rebuild exits 0 whenever anything was read, and exits 1, touching
+  nothing, only when nothing could be read. The loss guard and `--force` are gone.
+  `templates/lesson.schema.json` declares the `carried` field.
+- The merge notice no longer says "read both" when the family index was corrupt and set aside.
+- Docs: `continuity.md` names `graph.py next` exit `6` beside `4`, pinned by
+  `continuity_doc_test.py`, and `waves.md` lists `6` for `next --wave N`. The `graph.py`
+  docstring says exit `3` counts parked nodes as finished. In `stages.md` and `README.md`,
+  `checks` mode puts the release run on a watcher. The release-authority rule has one home,
+  `deploy-targets.md`, and `pipeline.schema.json` points to it.
+- Lessons of this run, now doctrine: `iteration.md` checks for parallel work on the same
+  nodes before each cycle, across every tool's branch prefixes. `build.md` adds a
+  command-hygiene block that every background dispatch carries.
+
+## v1.98.0 (2026-10-20)
+
+Guards: 448 → **448**; property checks 15 → **15**.
+
+A cheaper run that stops looping, and the operators' retro insights in the retro doctrine.
+Measured on 2026-10-20: before any code a run was told to read about 236 KB of doctrine
+(the command 14 KB restating `SKILL.md` 21 KB, plus companion-skills, model-tiering,
+continuity, stages, stage 0, grill, knowledge-sources and gates.md "at every stage"); a
+small fix met eleven stages because the short path was only proposed and silence took the
+full flow; every node closed through three blind tiers, R2 owed two rounds, the
+certification ceiling only measured, the review loop ran to five rounds; and the retro
+floor stage 0 reads in full ran up to ~76k tokens in one project, 27 620 bytes here.
+
+**A. Proportional run.** Stage 0's short-path triage now decides instead of proposing:
+when the gap check leaves no material unknown and the change is R1, at most five files,
+no public contract, no user-facing change and no deploy, the run takes the short path and
+says so in one line (brief in the run ledger, build with tests, one verification, docs
+and handoff, a retro entry only for a new lesson). `scripts/short_path.py` computes it.
+The example's gates at stages 0, 2, 3, 7 and 10 are `auto`; the operator's answer or the
+standing authorization recorded in the brief is the go, and a project that wants the wait
+sets a gate `manual` in its own `pipeline.json`.
+
+**B. Reading diet.** At entry a run reads `SKILL.md` only (its stage table is the index);
+each stage's section of `stages.md` and its detail load when the stage starts; grill,
+knowledge-sources, companion-skills, continuity, model-tiering and gates.md load on named
+triggers. The command is a 1.5 KB pointer. Measured, the floor before code on the short
+path is 35 KB (was 236 KB; 80 KB when the grill and knowledge-sources triggers fire);
+`SKILL.md` is 16.2 KB, 3 753 cl100k tokens of body (was 4 709, cap 5 000). The three descriptions are 386, 399 and 395 characters; every trigger phrase
+they dropped moved verbatim into a `## Triggers` section of the same `SKILL.md`.
+
+**C. Anti-loop.** `graph.py certify`: an R1 node certifies with one blind tier; R2 owes one
+passing round, R3 two (one blind, one adversarial), a flagship surface two with one
+adversarial; a round of the same kind on an unchanged tree is refused; at the ceiling the
+node is parked with its evidence (exit 7) instead of measured. `waves.py finish
+--clean-rounds` (default 1; 2 for an R3 or flagship iteration). The fix loop and the
+review loop cap at three rounds and stop.
+
+**D. Retro doctrine.** The floor (standing instructions plus run stamps) has a 12 000-byte
+budget, a standing row at most 600 characters, a stamp at most 300; stage 0 prints the
+bytes and bytes/4 tokens, gate 10 fails over budget. `scripts/retro_budget.py`
+(`check`, `migrate --write`, `verify`) moves narrative to the archive verbatim with a
+sha256 per block; this repository's floor went from 27 620 to 6 532 bytes that way. Each
+entry names its Class (13 classes) and Cost; a standing row is searched against
+`learned.md` and the lesson index first; a lesson standing in two projects goes upstream
+in the same run. `learned.md` gains rules 33 to 39 from the 2026-10-20 audit of ~54
+retrospectives. evidence-docs' 34.7 KB copy of the retro doctrine is now a pointer.
+
+Tests: `graph_test.py` 171 → 173 cases (tier count by risk, unchanged-input refusal,
+ceiling stops), `waves_test.py` 135 cases with `--clean-rounds`,
+`test/audit_regressions/diet_retro_budget.py` (9 cases, over-budget plants must fail) and
+`diet_proportional.py` (6 cases). Twelve negative plants retargeted to the new wording
+(stage 0 and 10 gates name their authorization and the hand-back instead of `manual`).
+
 ## v1.97.1 — 2026-10-17
 
 The same source as v1.97.0, plus its release declaration. The v1.97.0 tag failed its own release run

package/HOW-IT-WORKS.md

@@ -28,11 +28,12 @@ you asked for.
 ## 1. How a request finds the pipeline
 
 An agent choosing skills sees exactly one thing: the `description` field in
-`SKILL.md`. It is capped at **1024 characters** and currently uses **1008** — that
-headroom is the budget every future addition pays from, which is why it is
-tracked as a board row rather than left to be discovered.
+`SKILL.md`. It is capped at **1024 characters**, and since 1.98.0 it is the short
+form (`B-001` on the board tracks the measured length): every host preloads it into
+every session. The full trigger list, unchanged, sits under `## Triggers` in the same
+file, where the family's routing hook and this repository's checks read it.
 
-It is written in three parts, and the middle one was learned the hard way:
+That list is written in three parts, and the middle one was learned the hard way:
 
 - **Work that changes the repository** — a feature, fix, refactor, migration,
   integration, rewrite, adoption or hardening, in English and Russian both.
@@ -125,23 +126,26 @@ it has been forgotten.
 | | Stage | What must be true to leave it | Gate |
 |---|---|---|---|
 | 1 | Docs study | every contract the design will lock is grounded on **fetched** docs, not recall | auto |
-| 2 | Brainstorm + decompose | design approved, every REQ answered by it. A platform is cut into modules, **walking skeleton first**, every REQ in exactly one module | manual |
-| 3 | Spec | contracts locked. User-facing work runs three tracks — what it **does**, how it **sounds**, how it **looks**. A declined track is recorded, never silent | manual |
+| 2 | Brainstorm + decompose | design approved, every REQ answered by it. A platform is cut into modules, **walking skeleton first**, every REQ in exactly one module | auto |
+| 3 | Spec | contracts locked. User-facing work runs three tracks — what it **does**, how it **sounds**, how it **looks**. A declined track is recorded, never silent | auto |
 | 4 | Plan | the REQ set-comparison holds: brief REQs == union of `Implements:` | auto |
 | 5 | Build | TDD per task, a review after each, findings fixed or parked **with a ruling** | auto |
 | 6 | Tests | the **full** suite green; a web surface checked in a browser, not in the diff | auto |
-| 7 | Lint + deploy | the authorization is specific, and the CI verdict is **read** before any tag | manual |
+| 7 | Lint + deploy | the authorization is specific, and the CI verdict is **read** before any tag | auto |
 | 8 | Post-deploy | the verification trio, not one of three; a verification row per shipped REQ | auto |
 | 9 | Docs + wiki | **three** artifacts — module docs, the wiki, and the code graph | auto |
-| 10 | Acceptance | the ladder walk first, then the table, then the retrospective | manual |
+| 10 | Acceptance | the ladder walk first, then the table, then the retrospective | auto |
 
-### Why the manual gates are where they are
+### Why every gate ships `auto`
 
 `auto` means the agent verifies the check itself and proceeds. `manual` means it
-waits for an explicit go. The four manual gates sit at the four places where a
-wrong turn is expensive and hard to reverse: **what we are building** (2), **the
-contracts** (3), **the outside world** (7), and **whether it is done** (10).
-Everywhere else, stopping to ask costs more than it saves.
+waits for an explicit go. Until 1.98.0 the example made stages 0, 2, 3, 7 and 10
+manual, the places where a wrong turn is expensive: **the brief**, **what we are
+building**, **the contracts**, **the outside world** and **whether it is done**. Under an
+operator's standing "decide and act" instruction each of them was a pause nobody
+answered, so the example ships them `auto`: the approval they name is read from the
+operator's answer or the standing authorization recorded in the brief, and a project
+that wants the wait sets the gate `manual` in its own `pipeline.json`.
 
 ---
 

package/README.md

@@ -182,7 +182,7 @@ and the inline fallback satisfy the same [provider contract](plugins/task-pipeli
 | 3 Spec | [`spec.md`](plugins/task-pipeline/skills/task-pipeline/references/spec.md) — UX-track order, locked contracts, global constraints, self-review |
 | 4 Plan | [`planning.md`](plugins/task-pipeline/skills/task-pipeline/references/planning.md) — zero-context tasks, parallel groups, no placeholders |
 | the queue | [`work-graph.md`](plugins/task-pipeline/skills/task-pipeline/references/work-graph.md) — a script walks the graph so the model never reads it: 400 nodes and 4 print the same 27-byte frontier |
-| closing a node | [`certification.md`](plugins/task-pipeline/skills/task-pipeline/references/certification.md) — three blind readings at escalating visibility (the changed code, what reaches it, the product around it), all three required to pass — and a fourth, `verifier-visual`, on a flagship or product surface, which reads the contact sheet against the director record; a failing round records itself and the node stays open |
+| closing a node | [`certification.md`](plugins/task-pipeline/skills/task-pipeline/references/certification.md) — three blind readings at escalating visibility (the changed code, what reaches it, the product around it), all three required to pass (one on an R1 node; a clean round ends a node unless it is R3 or flagship) — and a fourth, `verifier-visual`, on a flagship or product surface, which reads the contact sheet against the director record; a failing round records itself and the node stays open, and at the ceiling the node is parked with its evidence |
 | 5 Build | [`build.md`](plugins/task-pipeline/skills/task-pipeline/references/build.md) + [`review.md`](plugins/task-pipeline/skills/task-pipeline/references/review.md) — isolation, ledger, subagent loop, review rubric, fix loop |
 | 5–6 TDD | [`tdd.md`](plugins/task-pipeline/skills/task-pipeline/references/tdd.md) — the iron law, red/green/refactor, the suite gate |
 | 5, 6, 8 The browser | [`browser.md`](plugins/task-pipeline/skills/task-pipeline/references/browser.md) — the ref model both channels share, the four commands the look is made of, sessions, and the three different things *"tested in a browser"* means |
@@ -201,7 +201,7 @@ and the inline fallback satisfy the same [provider contract](plugins/task-pipeli
 | 3 + 4 · every spec and plan | the self-review reads its rules back — is every named check real, does anything contradict a locked decision or a rejected option, and what does this cost now versus at design time. Answers land as a committed `## Self-review` of computed numbers |
 | 6–10 + any check you write | [`gates.md`](plugins/task-pipeline/skills/task-pipeline/references/gates.md) — the three axes, the promotion ladder, gate anatomy, the probe recipe, ratchet floors |
 | any agent-time enforcement | [`hooks.md`](plugins/task-pipeline/skills/task-pipeline/references/hooks.md) — the `PreToolUse` contract, the fail-open hazard, the Claude-Code-only limit |
-| 7 · the tag | [`deploy-targets.md`](plugins/task-pipeline/skills/task-pipeline/references/deploy-targets.md) → *When the release waits for an approval* — `pipeline.json` → `release.approval`: `checks` (tag, watch the run selected by the tag, report) or `reviewers` (the direct link to the run that is `waiting`) |
+| 7 · the tag | [`deploy-targets.md`](plugins/task-pipeline/skills/task-pipeline/references/deploy-targets.md) → *When the release waits for an approval* — `pipeline.json` → `release.approval`: `checks` (push the tag, put the run selected by the tag on a watcher, take independent work until it reports) or `reviewers` (the direct link to the run that is `waiting`) |
 | between stages | [`continuity.md`](plugins/task-pipeline/skills/task-pipeline/references/continuity.md) Part 3 — workflow memory through Observatory, a planned handoff (`stage_checkpoint.py handoff` / `accept`), and `hooks/memory-nudge.sh`, which reminds once when a gate returned with no memory line after it — unless the run recorded memory unavailable with `--for-run` |
 
 **Ported, not depended on.** Stage 0 is adapted from
@@ -221,9 +221,11 @@ Before any technical work, task-pipeline closes every question the codebase and
 project's records can answer, then asks you the rest in **one batch**, ordered by
 dependency, each with a recommended answer — one at a time only where the answers
 depend on each other or you ask for it — until every decision branch is resolved and
-locked into a **task brief**. There is
-no "clear enough task" exemption: no stage-1 work starts without a committed,
-confirmed brief.
+locked into a **task brief**. The depth is proportional: a small change (R1, at
+most five files, no public contract, no user-facing change, no deploy) takes the
+**short path** by default, printed in one line: the brief in the run ledger, build
+with tests, one verification, docs and handoff. Anything larger starts stage 1 only
+on a committed, confirmed brief.
 
 **Domain awareness.** While exploring, the grill reads the project's own
 `CONTEXT.md` / `docs/adr/` and holds you to them — calling out terms that conflict
@@ -482,9 +484,9 @@ iteration runs in this order:
 - the survey;
 - module dossiers written in parallel, laid onto one canvas until a pass changes nothing;
 - questions asked in rounds, never one at a time, while agents keep working;
-- a parallel build, each node checked the moment it lands: one round of three blind
-  readings for every node, and two or three passing rounds by its risk class (R2, R3 — one
-  of the three recorded adversarial);
+- a parallel build, each node checked the moment it lands: one clean round ends it (one
+  blind reading on R1, three on R2), and an R3 or flagship node owes a second, adversarial
+  round;
 - one release, checked as released;
 - the next pool, handed to you grouped by module.
 
@@ -506,7 +508,8 @@ every repeat pass logs one line per touched file with **the reason that forced i
 
 It trips on revert-oscillation, a file edited twice for the same reason, a
 resurrected finding, a third entry into one stage, or two loops editing one file —
-plus hard caps (5 fix rounds per task, 2 re-entries per stage, 3 passes per module).
+plus hard caps that stop (3 fix rounds per task, 3 review rounds, 3 failing certification
+rounds per node, 2 re-entries per stage, 3 passes per module).
 On a trip the run **stops editing**, names shape A and shape B with their evidence,
 escalates to the layer that owns the conflict (rubric → operator → plan → spec →
 module map), re-plans the check as an ordered checklist with one verification
@@ -638,7 +641,7 @@ must say so.
 ### Held to Anthropic's own Skill authoring guidance
 
 Audited against the four Agent Skills pages. Most of it already held — `name`
-13/64 chars, `description` 887/1024 chars, `SKILL.md` 275/500 lines, all 53 references
+13/64 chars, `description` 386/1024 chars, `SKILL.md` 207/500 lines, all 53 references
 reachable from `SKILL.md` through explicit reference routes, and the bundle far under the 30 MB ceiling. What
 did not, now does:
 

package/SKILL-CARD.md

@@ -12,7 +12,7 @@ harmless.
 |---|---|
 | **Purpose** | Runs a substantial task through ten gated delivery stages — intake grill, docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs+registers, acceptance — refusing to advance until each gate passes |
 | **Owner** | ssheleg ([github.com/ssheleg/task-pipeline](https://github.com/ssheleg/task-pipeline)) |
-| **Version** | 1.97.1 |
+| **Version** | 1.99.0 |
 | **Surface** | Claude Code (filesystem skill + plugin) and the vercel `skills` CLI. **Not** uploaded to the Skills API; custom Skills do not sync across surfaces |
 | **Dependencies** | None required. Optional: `context7` (MCP), `figma` (MCP), super-ux, agent-sync, graphify, obsidian-wiki, and **one of two browser channels** — `playwright` (CLI or MCP) or `chrome-devtools` (MCP); either satisfies the browser step and neither is required. The engine is WebKit (Safari) first; `chrome-devtools` is Chrome-only, a stated exception. Every stage's doctrine ships in-repo; user-facing stage 3 requires a valid scenario artifact; super-ux is preferred, with equivalent-provider and inline-fallback paths under the provider contract |
 | **Evaluation status** | Suite authored, 5 categories. One recorded run, **self-observed by the author**; **zero blind runs on zero of three models** — the split, and the numbers, live in [`evals/RESULTS.md`](evals/RESULTS.md) and are computed by `evals/run.py` |

package/cursor/rules/task-pipeline.mdc

@@ -67,9 +67,14 @@ event, not the end of the run — what loses work is crossing it mid-item.
 
 ## Stage 0 — intake grill (MANDATORY, do this FIRST)
 
-Never skipped, and nothing to install — the grill is part of this rule. No "the
-task was already clear" exemption, no starting stage 1 while the user thinks. A
-one-line task ("build feature X") is not enough to finish autonomously.
+Never skipped, and nothing to install: the grill is part of this rule. Its depth is
+proportional. **A small change takes the short path by default** when the gap check
+leaves no material unknown and the change is R1 risk, at most five files, no public
+contract, no user-facing change and no deploy: say so in one line, write the brief and
+its REQ rows into the run ledger, build with tests, run one verification, update the
+docs and handoff, and write a retro entry only for a new lesson. Anything larger runs
+the full flow, and a one-line task ("build feature X") is not enough to finish it
+autonomously.
 
 **Phase 1 — harvest the sources BEFORE the first question.** Find what the project
 already knows about this task and read it: the code; **the code graph if one is
@@ -98,7 +103,8 @@ like any other source, and it **points while the code decides** — never the
 tiebreaker.
 **Read `docs/evidence/retro.md` in full if it exists** — its *standing
 instructions* are what previous runs of this pipeline got wrong in this project, and
-they bind this run (they are capped at ten, so reading them all is cheap). Stamp
+they bind this run (ten rows, ten stamps, and a 12 000-byte budget for the two, so
+reading them all is cheap; say the byte count). Stamp
 each one the moment it fires: that date is the only evidence behind the
 cold-retirement rule at stage 10.
 If no wiki is installed, recommend it once and continue:
@@ -199,7 +205,7 @@ not authorize an outward, irreversible action — stage 7 stops and asks.
 ## Stages 1→10
 
 1. **Docs study** (auto) — ground every external lib/API on current docs, not recall.
-2. **Brainstorm + decompose** (manual) — read the brief, explore the code, then 2–3
+2. **Brainstorm + decompose** (auto; the brief's standing authorization is the go) — read the brief, explore the code, then 2–3
    approaches with a recommendation, YAGNI applied, design presented in sections and
    approved. **Hard gate: no code, no scaffolding before that approval** — including
    on "obviously simple" tasks. Record whether the task touches a user-facing surface
@@ -222,11 +228,12 @@ not authorize an outward, irreversible action — stage 7 stops and asks.
    re-measure, re-cut — and 9–10 close the release. No wave builds a shape a later
    wave undoes. **Around the waves runs the release iteration** ("release iteration" /
    "итерация релиза"): module dossiers integrated into one canvas, questions in batches,
-   each node verified as it lands in one to three rounds by its risk class (R1–R3), a
+   each node verified as it lands, one clean round ending it unless it is R3 or a
+   flagship surface (R1 on one blind tier; the ceiling parks a churning node), a
    wave's stage 7 integrated without tagging, one release gated and verified as
    released, the next pool handed back; a finding made mid-iteration joins the
    inventory rather than being fixed alone.
-3. **Spec** (manual) — write and commit the design; lock every shared contract
+3. **Spec** (auto; the brief's standing authorization is the go) — write and commit the design; lock every shared contract
    (types, schemas, signatures, file layout) plus a **Global Constraints** block of
    exact values every later task inherits. Self-review it for placeholders,
    contradictions, ambiguity and scope before showing it. For UI tasks, run the UX
@@ -284,7 +291,7 @@ not authorize an outward, irreversible action — stage 7 stops and asks.
    analysed rather than only recorded — said with the reason; a look taken only there
    is reported as "checked in Chromium", never "tested in a browser". Never a gate. A CLI, a
    library or a backend service is never offered either.
-7. **Lint + deploy** (manual) — lint clean AND suite green before deploy; deploy is
+7. **Lint + deploy** (auto; the brief's standing authorization is the go) — lint clean AND suite green before deploy; deploy is
    outward → explicit user go, or the specific standing authorization recorded in
    the stage-0 brief.
 8. **Post-deploy** (auto) — tail logs / health-check; clean boot or an honest
@@ -320,7 +327,7 @@ not authorize an outward, irreversible action — stage 7 stops and asks.
     propose the edit and get an explicit go, or carry it over with the exact change
     written down. A doc that was worth reading at stage 0 and is wrong now is the
     next run's false premise.
-10. **Acceptance** (manual) — the closing stage, in two halves.
+10. **Acceptance** (auto; the brief's standing authorization is the go) — the closing stage, in two halves.
     **First the ladder walk**, because the REQ table only finds what was named and
     lost: a comparison needs two sides and **an absence has one**. Walk each REQ
     bottom-up through its rungs — recorded decision → spec section → contract *and
@@ -418,9 +425,10 @@ not authorize an outward, irreversible action — stage 7 stops and asks.
     of the next run reads those standing instructions **in full**, which is why the
     cap is not negotiable and the prune is a gate item, not a good intention.
     Gate: ladder walk ran, no REQ `unknown`, no ledger row without
-    a home, every repository clean/pushed/pointed-at, user signs off, **and the
-    retro is written — stamped first, then pruned before anything was added, at or
-    under its cap, every deletion logged, and the counts printed beside this verdict**.
+    a home, every repository clean/pushed/pointed-at, the hand-back written, **and the
+    retro is written: stamped first, then pruned before anything was added, at or
+    under its cap and its byte budget, every deletion logged, and the counts printed
+    beside this verdict**.
 
 Cross-cutting: answer from the brief's autonomy section rather than re-asking, log every deferral in the ledger, never narrow the task silently, track
 tasks, conventional commits, honest degradation (never claim a failed/skipped step
@@ -436,8 +444,8 @@ file, the pass, and the reason that forced it — a finding id or a failed gate
 "Cleanup" is not a reason. **Stop immediately** when: an edit undoes what an earlier
 pass in this run deliberately did (A→B→A); the same file is edited twice for the
 same reason; a finding already fixed or parked comes back; a stage is entered a
-third time for one artifact; two loops edit one file. Hard caps: 5 fix rounds per
-task, 2 re-entries per stage, 3 passes per module. On a stop: name shape A and shape
+third time for one artifact; two loops edit one file. Hard caps, each a stop: 3 fix
+rounds per task, 2 re-entries per stage, 3 passes per module. On a stop: name shape A and shape
 B with their evidence and who asks for each; escalate to the layer that owns the
 conflict (two findings → the review rubric; finding vs plan → the user; plan vs spec
 → back to planning; ambiguous spec → back to spec; two modules claiming one file →

package/evals/task-pipeline.evals.json

@@ -476,9 +476,9 @@
       ],
       "query": "wave 1 of a release iteration has two nodes: N-001 (R1: fix two wrong links in docs/README.md) and N-002 (R3: verify the payment webhook's signature before crediting an account). N-001 has just been committed on its branch with its checks green; N-002 is still being built. Continue.",
       "expected_behavior": [
-        "Starts N-001's certification now, without waiting for N-002 or the end of the wave: one round — the three blind tiers plus one fix cycle — and N-001 is closable after that round passes",
-        "Keeps N-002's risk class at R3 (money, a security check) and never lowers it to save time; it owes three passing rounds, one of them recorded adversarial (`certify --kind adversarial`), planting a defect and trying abuse cases, on another model where one is available",
-        "Runs every owed round in full even when round 2 comes back clean — the adversarial round asks a different question and always runs",
+        "Starts N-001's certification now, without waiting for N-002 or the end of the wave: one round on one blind tier (R1) plus one fix cycle, and N-001 is closable after that round passes",
+        "Keeps N-002's risk class at R3 (money, a security check) and never lowers it to save time; it owes two passing rounds, one blind and one recorded adversarial (`certify --kind adversarial`), planting a defect and trying abuse cases, on another model where one is available",
+        "Runs the adversarial round even when the blind round comes back clean, because it asks a different question, and never re-runs a blind round on the unchanged tree",
         "Treats `graph.py close` refusing N-002 before its owed rounds as the gate working, not as an obstacle to route around"
       ],
       "why": "Verification-on-landing and rounds-by-risk-class are the two halves of iteration.md → Verification starts when a node lands. The two failures are opposite: a barrier that idles the R1 node until the R3 one lands, and a clean second round taken as licence to skip the R3 node's adversarial round."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.97.1",
+  "version": "1.99.0",
   "description": "Full-cycle delivery pipeline for coding agents: a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine ships inside the skill — no companion plugin required. This package is the installer CLI.",
   "bin": {
     "task-pipeline": "bin/task-pipeline.js"

package/plugins/task-pipeline/.claude-plugin/plugin.json

@@ -2,8 +2,8 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "task-pipeline",
   "displayName": "Task Pipeline",
-  "description": "Runs a substantial task through a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine is built into the skill — no companion plugin required — with typed auto/judgment/manual gates, a frozen requirement spine that closes with evidence, a work board and a verification ledger that outlive a run, an exposure line naming what shipped unconfirmed, a progress rail computed from the project's own config, a loop guard whose review ceiling measures rather than stops, and stage-3 tracks for what a product does, how it sounds and how it looks. Two modes need no task: `checkup` (what is unverified) and `setup` (audit existing docs); a third, `waves`, takes the whole board and closes it in waves that each finish in one pass. Retro insights can publish upstream as issues, opt-in and redacted.",
-  "version": "1.97.1",
+  "description": "Runs a substantial task through a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine is built into the skill — no companion plugin required — with typed auto/judgment/manual gates, a frozen requirement spine that closes with evidence, a work board and a verification ledger that outlive a run, an exposure line naming what shipped unconfirmed, a progress rail computed from the project's own config, a proportional short path for small changes, a loop guard whose ceilings stop and record a blocker, and stage-3 tracks for what a product does, how it sounds and how it looks. Two modes need no task: `checkup` (what is unverified) and `setup` (audit existing docs); a third, `waves`, takes the whole board and closes it in waves that each finish in one pass. Retro insights can publish upstream as issues, opt-in and redacted.",
+  "version": "1.99.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"