task-pipeline-skill 1.78.4 → 1.80.0

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

@@ -30,13 +30,9 @@ elsewhere and is not restated here:
 - False success — when a mechanism reports a win it never checked
 - Anatomy of a project gate
 - Writing the check itself
-- Probing — plant, run, restore
-- A probe rots, and every way it rots reports green
 - A ratchet prices the rule, not the exception
 - Run the whole suite locally before you push the tag
-- The neighbour probe — plant the evidence outside the subject
 - A ratchet's matcher is itself a check, and it needs a near-miss
-- A green probe is evidence only if the mutation is known to have landed
 - The false-positive budget
 - Ratchets
 - The result is the goal; the check is how you know
@@ -107,6 +103,15 @@ Gate assignment is the operator's call and the framework fixes none — so shipp
 reclassified stage list would contradict the sentence above it. The type exists; the
 project chooses where it applies.
 
+**The rubric steers the builder before it judges the work.** A judgment gate's
+criteria are read twice — by the judge at the gate, and earlier by whoever builds
+toward it — and the second reading is absorbed as direction: Anthropic reports
+agents converging on one aesthetic because a rubric's adjective ("museum
+quality") was obeyed as a target rather than weighed as a bar (read 2026-08-30).
+So write criteria as the direction you want taken, not only as the bar to clear;
+the words will be obeyed either way, and a rubric written carelessly is an
+instruction issued accidentally.
+
 | Rationalization | Why it is wrong |
 |---|---|
 | *"The reviewer approved it, so the gate passed."* | It did — as a judgement. Type it as one, or the table claims a machine agreed |
@@ -191,7 +196,10 @@ Four preconditions. Skipping any of them turns a run into a claim.
    added to an already-red base passes for the wrong reason and proves nothing.
 2. **The check has been probed.** Green from a check nobody has watched fail is
    worth nothing. If you did not plant the defect, you do not know what the green
-   means.
+   means. How to plant, what a probe owes, and every way one rots is
+   [`probing.md`](probing.md) — the harness is `test/probe.py`
+   (`npm run test:probe`), and hand-rolling a fourth copy of its loop is how
+   three probes in one day proved the wrong guard.
 3. **You have read its scope header** and know what it does **not** cover. A gate
    is evidence for exactly the surface it walks; quoting it beyond that is how
    "the gate is green" becomes a false statement made in good faith.
@@ -338,89 +346,6 @@ exit 0
 
 ---
 
-## Probing — plant, run, restore
-
-The law is [`audit.md`](audit.md)'s exit criterion. The procedure is this, and it is
-not optional for a check you intend to trust:
-
-```bash
-cp -R . /tmp/probe && cd /tmp/probe
-python3 - <<'PY'                       # plant IN PYTHON, never sed -i
-p = "docs/DECISIONS.md"
-s = open(p).read().replace("DEC-0001", "DEC-9999", 1)
-open(p, "w").write(s)
-PY
-bash scripts/check-docs.sh; echo "planted -> exit=$?"   # MUST be non-zero
-cd - && bash scripts/check-docs.sh; echo "clean -> exit=$?"  # MUST be 0
-```
-
-**Assert on `$?`, not on a `FAIL` line in the output.** A line on stdout is a
-decoration; the exit code is what CI reads.
-
-**Doubt the probe before you doubt the check.** On the project this comes from,
-**four of five** silent probes were the probe's fault: one added a *definition*
-where the check looks for an unresolved *reference*; one edited a string whose
-whitespace did not match; one hit the first prose mention instead of the table row;
-one flipped a row whose cell was already empty, so nothing was planted. A silent
-check is a claim about two things, and the probe is the one to doubt first — prove
-your edit landed in the text the check actually parses.
-
-**Three assertions, and the third is the one hand-rolled probes keep missing.** A
-plant that trips some *other* check has proved that other check works. Three probes
-in one day passed that way: one removed 1 of 3 identical lines and left the shape
-intact; one decremented a number inside an **already-released** section; one deleted
-the shouted spelling of a phrase and left the lowercase one. Each landed somewhere
-real and demonstrated nothing about the guard it was written for. So:
-
-1. **the substitution landed** — `replace` matching nothing returns the string
-   unchanged and raises nothing;
-2. **the exit code is non-zero** — not a `FAIL` line on stdout;
-3. **the message that fired belongs to the guard under test** — named up front, not
-   recognised afterwards.
-
-`test/probe.py` does all three (`npm run test:probe` self-tests the harness, including
-its own failure branches, because a harness whose failure path has never executed is
-the thing it exists to stop). Declare the plant as `Plant(label, path, old, new,
-expect=<the guard's own words>)` rather than hand-rolling a fourth copy of the loop.
-
-**Record the probe.** One line per section, in the change that ships the check.
-Otherwise the next reader has to redo it to know whether it was ever done.
-
----
-
-## A probe rots, and every way it rots reports green
-
-The three assertions above prove a probe works **today**. They say nothing about the
-day after, and a probe is uniquely exposed: the thing it guards is the thing that moves
-it. Four rotted in one release on 2026-08-22, and none of them failed loudly — two
-reported `caught`, two reported nothing at all.
-
-**1. The anchor is a literal the guarded thing moves.** A probe pinned to *"the bundle
-is N reference files"* stops landing the day a reference file is added — on the release
-that changes the very number it guards. Same for a version, a count word, a phrase a
-release rewrites. **Derive the anchor**: read whatever the text currently says and make
-*that* wrong. A probe that computes `wrong = stated - 1` never needs maintaining.
-
-**2. The precondition is inherited from the tree rather than created.** This is the
-subtle one, because it is triggered by the system working correctly. A probe that
-narrows a declared gap to expose *releases after the newest run stamp* has nothing to
-expose the moment a release writes an honest stamp — the newest release is now the
-newest stamp. A probe requiring an `## Unreleased` section has none the moment a release
-absorbs it. **Both landed. Both proved nothing.** A probe must construct the state it
-needs: remove the stamp, write the section, then plant the defect.
-
-**3. The document quotes the form the probe removes.** Covered as
-[`documentation.md`](documentation.md) canon 2's second half, and it belongs here too
-because the probe is where it surfaces: prose describing the wrong shape *with real
-values in it* is a second instance of the shape. The probe deletes the real one, the
-narrative still matches, the guard is silent.
-
-**How to see it before CI does.** Ask one question per probe: *what does this probe
-LOOK FOR, and who is allowed to change it?* Where the answer is "the thing it guards",
-it is rotting already. A repository-wide sweep is one grep — a two-digit literal inside
-a needle, an `assert` or a `replace` — and the triage is: the number a probe **writes**
-is correct, the number it **looks for** is the defect.
-
 ## A ratchet prices the rule, not the exception
 
 A floor that counts assertions is a floor that can be lowered by improving the code, if
@@ -477,61 +402,11 @@ the tag-ancestry check, the version-sync check and the run-stamp check have no e
 opportunity to fire. Locally, run them the way the release does — against the tree you are
 about to tag, with the suite the release claims.
 
-## The neighbour probe — plant the evidence outside the subject
-
-A probe proves a guard rejects **the phrasing its author had in mind**. That is less than
-it looks, and the gap has one shape: **a check answered by text that is not its subject.**
-
-Measured on one project in one session, six times, each found by a reader planting a
-defect and watching `PASS`:
-
-| The check's subject | The text that answered it instead |
-|---|---|
-| stage 2 names the loop's arming | *"it **arms** the UX track"*, present since an earlier release |
-| the section states the authorization floor | the same phrase in a Rationalizations row, and in a section written twenty-nine releases before |
-| the run stamps have a cap | the **standing instructions'** `max 10`, in the same table cell — and, once the check was narrowed past it, the same cap moved to the other side of the `·` |
-| a section read in full stays capped | rows under **one** heading, while a second heading in the same file held forty more |
-
-Every one of those guards had a probe. Every probe fired. The probes and the guards were
-written in the same hour from the same reading, so they shared the same blind spot.
-
-**So a guard that reads a scoped span owes a second probe, and it plants in two places at
-once:**
-
-1. **break the subject** — remove the thing the guard is about;
-2. **plant the guard's own evidence next door** — in a sibling section, an adjacent table
-   cell, a rationalizations row, the other side of a separator;
-3. require the guard to **still fail**.
-
-A guard that passes step 3 is reading its subject. A guard that goes green is reading the
-neighbourhood, and the ordinary probe cannot tell the difference — which is why this one
-is separate rather than a stricter version of it.
-
-**Step 2 means the literal the predicate matches *today*, read out of the guard.** The
-first three neighbour probes written against this section got that wrong on their first
-run: one planted the needles of two **retired** predicates, which proves the guards that
-used to exist were neighbour-answerable and says nothing about the one that does. A
-neighbour probe keyed to a needle the guard no longer reads is the same defect it was
-written to catch, one level up.
-
-**A probe that only deletes is not a neighbour probe.** It may still be a correct probe —
-but if it relies on copies that already sit next door, it must **assert they are there**.
-Otherwise a later edit removes them and the probe quietly becomes a delete-only test that
-still passes, having stopped testing the thing it is named for.
-
-**Positional narrowing is not scoping.** Three of the six were "fixed" by cutting the
-search down to a row, then to everything after a phrase, and fell each time to text that
-was still inside the cut. Scope by *what the span is about*: split to the cell, then to
-the item, then match on flattened text so an emphasis marker cannot hide the boundary.
-
-**And state the span in the guard.** One line above the predicate — *what it reads, and
-where that ends*. It costs nothing and it is the only part of a check a later reader can
-disagree with before the defect arrives.
-
 ## A ratchet's matcher is itself a check, and it needs a near-miss
 
-Reported from another project through `retro.publish`, and it is the neighbour probe's
-own class arrived at independently — which is the strongest evidence either has.
+Reported from another project through `retro.publish`, and it is the neighbour
+probe's own class ([`probing.md`](probing.md) → *The neighbour probe*) arrived at
+independently — which is the strongest evidence either has.
 
 A run built a ratchet to hold a coverage debt: a list of units with no test, a guard that
 fails when the list grows, a count printed at the gate. Exactly the shape
@@ -558,49 +433,6 @@ the reason.** In the reporting project the corrected count was *identical* to th
 and the composition was not: rows credited falsely came back in as rows genuinely paid off
 went out. A single number with no delta reads as a run where nothing happened.
 
-## A green probe is evidence only if the mutation is known to have landed
-
-Also reported from another project, three times in one day, each caught only because the
-result was too good:
-
-1. a scripted substitution missed on indentation — the file was unchanged and the probe
-   measured nothing;
-2. an assertion written against a bare identifier kept matching the **import line** after
-   the field it guarded was deleted;
-3. a file-extension alternation matched the longer extension as though it were the
-   shorter, reporting nine live files as missing.
-
-In all three the observable was identical to success. *"See it fail once"* has an unstated
-precondition — **that the thing you changed is the thing the check reads** — and a planted
-defect that did not land produces the same green as a check that cannot fail.
-
-**So a probe that mutates an existing file asserts its plant landed, in the same breath as
-planting it.** A probe that writes a whole file has no such question: the file exists or
-the command failed. This repository measured itself while writing this section and got the
-number wrong three times. A hand-rolled classifier said *206 of 206 already carry it*.
-The guard written from the rule said **22 did not** — and was itself too narrow, matching
-one spelling of the assertion, so six probes that already had it in lower case were
-called defective. A sweep then "fixed" those six and **corrupted five**, splitting live
-statements. The true figure was **16**, and it took the guard, a compile check and a
-restore from git to find it.
-
-Two things are worth keeping from that. **The check corrected the measurement that
-motivated it** — which is the argument for writing checks rather than counting by hand.
-And **a check keyed to one spelling of a rule is the class two sections above**: it
-reported as defective the probes that obeyed the rule in different words. **Every**
-mutating probe carries the assertion now — the figure is deliberately not
-written here. A first draft said *201*, which was true of the branch point and false in
-the same commit, because the twelve probes added for this release are themselves mutating
-probes. The guard computes it; a number in prose beside a check that can count is the
-class this bundle calls restating instead of computing. Probes that write a whole file
-need none: the file exists or the command
-failed.
-
-**Prefer an assertion that names the construct over one that names a substring of it.** A
-guard written against a bare identifier survives the deletion of everything it guarded,
-because the identifier still appears in an import. That is case 2 above and it is the same
-class as the section before this one, one level down.
-
 ## The false-positive budget
 
 Run a new heuristic over the **real corpus** before shipping it and count the false
@@ -772,7 +604,7 @@ of is deleted in the next refactor by someone who assumed it was dead.
 
 ## Cross-cutting, at every stage
 
-5. Cross-cutting, every stage: **when anything is settled — scope, a contract, a
+**When anything is settled — scope, a contract, a
    name, a policy, a vocabulary — run the Doc Loop
    (`references/documentation.md`) before the run moves on**: reserve the id,
    record it, resolve the question it answers, propagate by the matrix, commit

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

@@ -50,7 +50,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), run stamps and the recent-log window, all bounded by construction |
+| 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 |
 | 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 |
 | 8 | **The knowledge wiki** | see below | distilled cross-project knowledge, prior sessions, why decisions were made |
 | 9 | **Other doc repos the project names** | a docs repo URL or submodule in `CLAUDE.md`/`README`, a sibling checkout, a `docs/` monorepo package | specs, contracts and runbooks that live outside this repo |

package/plugins/task-pipeline/skills/task-pipeline/references/model-tiering.md

@@ -63,3 +63,16 @@ and no silent downgrade to a cheaper tier.
 The recommendation is a **reminder, not a block**. If the recommended tier isn't
 available, keep the current model, state plainly which one is in use, and run. The
 pipeline never stalls on a model it can't get.
+
+## A harness clause encodes a model's weakness — stress-test it per generation
+
+Every fixed control in this pipeline — a cap, a mandatory checkpoint, a fix-loop
+ceiling — encodes an assumption about what the confirmed model cannot yet do
+reliably, and those assumptions expire: Anthropic reports removing an entire
+construct from its own long-running harness when a newer model generation stopped
+needing it (*Harness design for long-running agents*,
+anthropic.com/engineering, read 2026-08-30). So when the confirmed tier moves a
+generation, re-test the clauses that exist to compensate the old one instead of
+carrying them as doctrine — a control the model has outgrown is not free, it is a
+stop nobody can name the reason for. The retro's cold-retirement trigger is the
+same rule applied to standing instructions; this is it applied to the harness.

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

@@ -57,11 +57,13 @@ a row pointing outside the bundle is the defect this file exists to catch.
 | **The run mode** — item-by-item pacing, default off, what it never collapses | `references/continuity.md` |
 | **The context budget** — the evidence rule and what a flush actually updates | `references/continuity.md` |
 | **The board** — the work-list between runs, its computed priority, and the ledger seam it resolves | `references/backlog.md` |
+| **The order** — the impact ladder, confidence and ease, research before scoring, and where the human goes | `references/prioritisation.md` |
 | **The verification ledger** — what shipped, and whether a human ever confirmed it | `references/verification.md` |
 | **Exposure** — the unconfirmed count as a named vector, never a probability, and the `checkup` mode | `references/exposure.md` |
 | The retro: prune, cap, commits, archive | `references/retrospective.md` |
 | Rules earned by failure | `references/learned.md` |
 | **The routing default and its boundary** | `templates/routing-rule.md` |
+| **Probing** — plant, run, restore; how a probe rots; the neighbour probe; the landed-mutation rule | `references/probing.md` |
 | The seeded doc map, registers and gate | `templates/docmap.md`, `templates/decisions.md`, `templates/open-questions.md`, `templates/docgate.sh` |
 | Which agent-introduced defects are found, and that the agent fixes them rather than the script | `templates/hygiene.sh`, `references/build.md` |
 | What a stage-3/4 self-review must read back, and that its trace is computed numbers | `references/spec.md`, `references/planning.md`, `references/learned.md` |

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

@@ -0,0 +1,165 @@
+# Prioritisation — what to do next, and why that and not the other thing
+
+**Load this when** the task was not named, when the next row comes off the backlog, when
+the operator asks what to work on, or when a run is about to spend a day on something and
+nobody has checked that it is the most valuable day available.
+
+`backlog.md` owns the **board** — what a row is, where it lives, how it closes. This owns
+the **order** the rows come off it.
+
+## Contents
+
+- The default, and its one exception
+- 1. The impact ladder
+- 2. Confidence and Ease
+- 3. The order, and why it is not a product
+- 4. Research before scoring, not after
+- 5. Where the human goes
+- 6. Two models in one family, and why both are right
+
+## The default, and its one exception
+
+**Every run assumes a backlog exists and that this task competes with it.** A task arriving
+with no stated priority is not priority-free; it is unranked, which is a different and
+worse thing.
+
+**The exception is the operator, and it is absolute.** When they name the task, that is the
+task. The most this file authorises is **one line** — *"`BL-14` scores higher: a checkout
+error affecting paying users. Say the word and I switch; otherwise starting yours now"* —
+and then starting theirs. Not a second ask, not a hedge, not a silent substitution. An
+operator who knows what they are doing is the most reliable prioritiser in the system, and
+an agent that argues with them twice has made itself expensive to use.
+
+## 1. The impact ladder
+
+Impact is the rung, not a feeling. The ladder exists so a bug and a feature can be compared
+at all — without it, "impact" is scored per-item by whoever is looking, and every item is
+somebody's priority.
+
+| Rung | What it means | Test |
+|---|---|---|
+| **I5** | the product does not work for someone **right now** | data loss, an outage, a broken purchase, a blocked signup |
+| **I4** | a product or business metric moves | revenue, activation, retention, traffic, conversion |
+| **I3** | it works, and the experience degrades | crash-free rate, error rate, latency, a rough edge people hit |
+| **I2** | our own speed | debt, tooling, tests, anything that changes how fast the next thing ships |
+| **I1** | polish | nobody's metric moves; it is better and that is all |
+
+Two rules that carry most of the value:
+
+- **An unmeasured claim of I4 is I3 until it is measured.** "This will lift conversion" is
+  a hypothesis; the rung is what the evidence supports, and the gap goes in Confidence.
+- **Blocking is not a rung, it is a multiplier on someone else.** A task nobody can proceed
+  past inherits the highest rung it blocks. State whose work it blocks, or it is not
+  blocking — it is just old.
+
+## 2. Confidence and Ease
+
+Both are 1–3, both are judgement, and both are written down **as** judgement — small
+integers a reader can disagree with, in the row, next to the rung.
+
+**Confidence** — how sure are we that doing this produces the effect claimed?
+
+| | |
+|---|---|
+| **C3** | measured, or the mechanism is obvious and the change is local |
+| **C2** | reasoned from something real — a trace, a ticket, one user |
+| **C1** | a guess we believe. Fine to hold, not fine to hide |
+
+**Ease** — how cheap is it, including the parts nobody counts?
+
+| | |
+|---|---|
+| **E3** | within a run, one surface, reversible |
+| **E2** | a few surfaces, or one that needs coordination |
+| **E1** | crosses repositories, needs a migration or a credential, or cannot be undone cheaply |
+
+Ease counts the **whole** cost: the migration, the review, the rollback, the second
+repository. An E3 that turns out to need a credential from a person who is asleep was an E1
+and the estimate was the defect.
+
+## 3. The order, and why it is not a product
+
+```
+sort by   I    descending          the ladder dominates
+then by   C × E descending          1..9 within the rung
+then by   age  descending           the tie-break, oldest first
+```
+
+**Classic ICE multiplies I × C × E, and this deliberately does not.** Multiplying lets a
+trivial certain easy win outrank a hard uncertain critical one — `I1×C3×E3 = 9` beats
+`I5×C1×E1 = 5` — and shipping the 9 while the 5 waits is precisely the failure this file
+exists to prevent. It is also the failure that feels most productive from inside: a
+stream of small completed things while the thing that matters sits.
+
+So the ladder is a **gate**, not a factor. `C × E` orders within a rung and never across
+one.
+
+**What age may and may not do.** It breaks ties, and past **30 days** the row is reported
+as one the queue has been lying about — surfaced in the run's output, not silently
+promoted. Age never lifts a row across a rung: a polish item that has waited a year is
+still polish, and letting it climb is how a queue ends up sorted by patience.
+
+**`prio` in `backlog.md` is not replaced.** That formula (`sev × blast + age_bonus`) ranks
+*findings against each other* and stays the board's own column. This file's ordering is
+what runs when findings and product work compete in **one** list — the finding's rung comes
+from the ladder above, and `sev × blast` is evidence for it, not a substitute.
+
+## 4. Research before scoring, not after
+
+**A row is scored from what it touches, never from its title.** "Fix the login redirect"
+is E3 by its name and E1 once you find it crosses an auth library, a cookie domain and a
+cached edge rule. Scoring first and discovering second produces an order that was wrong
+before the first task started.
+
+So, before an order is emitted:
+
+1. **Fan out one researcher per candidate row** — same rules as `build.md` §4.2: fresh
+   context each, given the row and nothing else, no shared working tree because they write
+   nothing.
+2. **Each returns four things and no opinion**: what it touches (`file:line`, services,
+   external systems), what it depends on and what depends on it, what is already
+   *measured* about the claimed effect, and what would have to be true for it to be wrong.
+3. **Score after they return.** The rung comes from the evidence, `C` from what the
+   researcher could and could not confirm, `E` from the surfaces they found.
+4. **Emit the ordered list once**, with the three numbers and one line of why per row.
+
+A researcher that comes back with "seems fine, medium effort" has returned nothing. The
+four fields are the contract; anything else is a subagent that spent context to guess.
+
+**Do not fan out to score two rows.** The dispatch costs more than reading them.
+
+## 5. Where the human goes
+
+The operator is a **scarce, high-value input**, and the failure mode is spending them one
+question at a time.
+
+- **Ask at the start, or in a batch at a boundary. Never after each task.** If the whole
+  queue needs one decision, ask it before the queue starts.
+- **A blocked row does not stop the run.** When something needs a person: first satisfy
+  yourself that you are actually right and it is actually blocked — most "I need input"
+  is an unread file — then write the question **into the row**, mark it `needs-operator`,
+  and take the next row that is not blocked by the same answer.
+- **The question in the row is answerable without context.** What was tried, what is
+  needed, and what happens under each answer. A question that requires re-reading the run
+  to understand is a question that waits another day.
+- **Batch the answers back.** The operator returns to a list of questions with their
+  consequences, not to a transcript.
+
+The measure of this section: **how much of the queue moved while nobody was watching**, and
+whether the things that stopped genuinely could not proceed.
+
+## 6. Two models in one family, and why both are right
+
+`seo-aeo-audit` triages on impact, irreversibility, uncertainty and coordination, and states
+that **effort is recorded and never ranks**.
+This file makes Ease rank. That is not a contradiction and the difference is the queue:
+
+| | an **audit** | a **backlog** |
+|---|---|---|
+| the list is | everything that is wrong | everything that could be done |
+| letting effort rank means | a blocker gets skipped for being hard, and the audit lies by omission | the queue self-selects toward value per day |
+| so effort | is recorded and never ranks | ranks, inside the rung |
+
+An audit must be complete before it is ordered; a backlog is ordered because it will never
+be complete. Reach for the wrong one and the symptom is recognisable: an audit that
+quietly dropped its hardest finding, or a backlog where nothing small ever ships.