task-pipeline-skill 1.85.2 → 1.86.3

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

@@ -15,7 +15,7 @@ coming back to the operator.
 ## Contents
 
 - Phase 1 — harvest before you ask
-- Phase 2 — the loop
+- Phase 2 — the gap check, then the loop
 - Domain awareness
 - The autonomy sweep
 - The design destination — one file, decided here, never invented later
@@ -42,11 +42,28 @@ Everything below runs against that harvest. An answer you can't check against a
 source is a recollection, and the whole loop exists to stop the run from building
 on one.
 
-## Phase 2 — the loop
-
-Interview the operator relentlessly about every aspect of the task until you reach
-a **shared understanding**. Walk down each branch of the decision tree, resolving
-dependencies between decisions one by one.
+## Phase 2 — the gap check, then the loop
+
+**Phase 2 opens with a verdict, not a question.** Walk the decision tree against
+the harvest and the request FIRST and mark every branch: **answered** (the
+request, the code, an ADR, a past brief or the wiki already decides it — record
+the source, do not re-ask), **immaterial** (either answer ships the same work —
+decide it yourself and note it), or **material unknown** (the answer changes
+what gets built, is expensive to reverse, or would stop the run later). Only the
+third kind earns a question. **A complete brief yields zero intake questions**
+— the grill's output is then the brief itself, and going around the loop anyway
+is re-negotiating what is already decided, which costs a human round and buys
+nothing.
+
+**A material unknown the operator cannot answer now** does not hold the whole
+intake open: it becomes **one bounded decision task** — a named node in the
+plan with the question, the options, the recommendation and the latest date it
+can be decided without rework — and the run proceeds on the branches that do
+not depend on it.
+
+Where material unknowns remain, interview the operator about THOSE until you
+reach a **shared understanding**. Walk down each unresolved branch of the
+decision tree, resolving dependencies between decisions one by one.
 
 1. **One question per turn.** Never bundle. Wait for the answer before the next.
 2. **Recommend an answer with every question** (+ a one-line rationale). "What do
@@ -58,8 +75,10 @@ dependencies between decisions one by one.
    decisions first, so later answers don't invalidate earlier ones.
 5. **Reconcile contradictions immediately**, and chase dodges: "we'll decide
    later" → "what's the latest you can decide and still ship?"
-6. **Cover the autonomy sweep** (below). An unasked question is not neutral — it
-   is a scheduled interruption at stage 6.
+6. **Cover the autonomy sweep** (below). An unasked MATERIAL question is not
+   neutral — it is a scheduled interruption at stage 6. An answered or
+   immaterial one asked anyway is not neutral either — it is a human round
+   spent confirming what the sources already said.
 
 **Stop** when a re-scan surfaces no new branches. Don't grill past diminishing
 returns: genuinely reversible calls can be deferred with a note.

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

@@ -129,8 +129,13 @@ machine, and the first surprising denial is debugged in the wrong project.
 ```
 
 - a tool-name pattern (`Edit|Write|…`), or `"*"` for every call;
-- for a specific shell command, add `"if": "Bash(git commit *)"` beside
-  `"matcher": "Bash"`.
+- for a specific shell command, add `"if": "Bash(git commit *)"` **inside the
+  handler object**, beside `"type"` and `"command"` — never beside `"matcher"`.
+  A matcher group is only `matcher` + `hooks`; a key Claude Code does not know
+  there is ignored, and from 2.1.270 announced at every session start as
+  `hooks.json: unknown key "if" … ignored`. This skill's own template carried it
+  at group level until v1.86.2, so its gate filtered nothing and ran on every
+  Bash call.
 
 `if` uses **permission-rule syntax** (`Bash(git *)`, `Edit(*.ts)`) and is evaluated
 **only on tool events** — `PreToolUse`, `PostToolUse`, `PostToolUseFailure`,
@@ -177,9 +182,9 @@ the project's `.claude/settings.json`.
 
 ```json
 { "hooks": { "PreToolUse": [
-  { "matcher": "Bash", "if": "Bash(git commit *)",
-    "hooks": [{ "type": "command", "shell": "bash", "timeout": 60,
-      "command": "bash scripts/check-docs.sh >&2 || exit 2" }] } ] } }
+  { "matcher": "Bash",
+    "hooks": [{ "type": "command", "if": "Bash(git commit *)", "shell": "bash",
+      "timeout": 60, "command": "bash scripts/check-docs.sh >&2 || exit 2" }] } ] } }
 ```
 
 `|| exit 2` is the contract, not a flourish: without it the gate's own `exit 1`

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

@@ -30,6 +30,25 @@ even be on the same provider. So:
   environment has no Opus-class model, the best available one is the right answer —
   say which one you settled on and keep going.
 
+## The operator's explicit choice is inherited, verbatim
+
+**Advice and choice are different things, and the second wins.** The
+recommendation above is ADVICE — printed once at preflight. A model or effort
+the operator has set explicitly (`/model`, `/fast`, a config entry, an answer
+at preflight) is the CHOICE, and the plan, every stage and every subagent
+inherit it unchanged. **Task size is not a basis for switching**: a large task
+does not upgrade the model, a mechanical stage does not downgrade it — the only
+thing that changes the model mid-run is an override the operator RECORDED, with
+its basis, in the per-stage map. A switch nobody recorded is a defect, whatever
+it saved.
+
+**An unsupported capability is its own line, never a silent swap.** When the
+confirmed model cannot do what a stage needs — vision it lacks, a context
+window the material exceeds, a tool the tier does not offer — the run states
+that limitation by NAME, records it in the brief, and asks (or proceeds with
+the gap named). Substituting a different model to cover the gap without the
+operator's say-so is the same defect as the silent downgrade.
+
 ## Mechanic — confirm at preflight, then stop asking
 
 Once, as part of the preflight (before stage 0):

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

@@ -19,7 +19,11 @@ Built into this skill; nothing to install.
 - No placeholders
 - Self-review — before handing off
 - This stage settles nothing — and that is a rule, not an omission
+- The UI handoff annex — a packet an executor can build without re-deriving
+- Pre-dispatch — the last gate before a claim
+- The leaf compiler — a slice survives a cold reader or it does not dispatch
 - GATE (auto)
+- Execution packets
 
 ## Audience
 
@@ -28,6 +32,12 @@ this toolset, has questionable taste, and will read **only their own task**.
 Everything they need is in that task: exact paths, complete code, exact commands,
 expected output. DRY. YAGNI. TDD. Frequent commits.
 
+For independently dispatched agents, "that task" includes the resolved context
+packet in [Execution packets](#execution-packets): relevant program/module
+constraints, versioned interfaces, decisions and source digests travel with it.
+Do not assume the executor has read a plan header or inherited the planning chat.
+Planning may hand off at plan-ready without claiming implementation is complete.
+
 Path: `<artifacts>/plans/YYYY-MM-DD-<topic>.md` — same `<topic>` slug as the
 brief and the spec.
 
@@ -52,24 +62,26 @@ what each one owns. This is where decomposition gets locked in:
 into **parallel groups** in topological order, and tag each task
 `depends: [task ids]`.
 
-**Then run the fake-edge test over what you just drew.** An edge is a dependency
-that carries data — not two tasks that happen to be written one after the other.
-Six steps, five minutes, and it is the difference between a graph and a list:
+**Then run the fake-edge test over what you just drew.** Keep dependencies that
+carry data, an enforceable control condition, or resource ordering. Mere sequence
+is not enough. Test each edge before assigning a parallel group:
 
 1. Write every task as a box.
 2. Draw an arrow between each pair you were about to order.
-3. For each arrow ask: **does output from A actually enter B?** Not *"does B come
-   after A"* — does B consume a file, a signature, a decision or a value that A
-   produced?
-4. Yes → keep it, and **write the payload in the `Carries` cell**.
-5. No → delete it. That wait was free to give away, and you were paying for it.
-6. Everything left with no incoming arrow is group A and starts at once.
-
-**The payload is the test, not the answer to it.** An arrow whose `Carries` cell
-you cannot fill is a fake edge, and the empty cell is what makes that visible to
-a reviewer instead of leaving an arrow in place because it looked orderly. Expect
-two or three per plan; the classic is *"review file A, then review file B"*,
-which reads as a sequence and never once passes anything between them.
+3. Ask what fails if B starts before A: missing output, unmet approval/control
+   condition, or conflicting ownership of a mutable resource?
+4. Keep a justified edge and write its kind plus concrete payload/condition in
+   the `Carries` cell: `data: schema v2`, `control: review accepted`, or
+   `resource: release write lease on shared registry`.
+5. Remove an edge only if none of those reasons applies. No data payload alone
+   does not make an edge fake. Do not remove approval or ownership constraints.
+6. Nodes without incoming dependencies are candidates for group A; capability
+   and resource checks still determine whether they can start together.
+
+**The stated dependency is reviewable.** An empty `Carries` cell requests a reason,
+not automatic deletion. Keep a justified dependency, remove accidental ordering,
+and leave an unresolved dependency blocked until its condition is understood.
+There is no target number of edges to remove.
 
 **File ownership is exclusive within a group.** No two tasks in the same parallel
 group write the same file — that is the rule that makes stage-5 fan-out safe.
@@ -140,15 +152,15 @@ verbatim from the spec. Every task's requirements implicitly include this sectio
 | Group | Tasks | Runs after | Carries |
 |---|---|---|---|
 | A | 1, 2 | — | — |
-| B | 3 | A | <what crosses this edge: the file, signature, decision or value B consumes> |
+| B | 3 | A | <kind: payload, control condition or resource ordering B requires> |
 
 ---
 ```
 
-**The `Carries` cell is required on every edge and empty only on group A.** A cell
-you cannot fill means the arrow carries nothing, which means it is a fake edge:
-delete it and let the task start in the earlier group. This is the fake-edge test
-made a column, so its result is committed rather than remembered.
+**The `Carries` cell is required on every edge and empty only on group A.**
+Record `data`, `control` or `resource` and its concrete condition. An unexplained
+edge blocks dispatch until justified or removed after review; never delete an
+approval/resource edge merely because it carries no file or value.
 
 ## Task structure — required
 
@@ -240,9 +252,9 @@ A checklist you run yourself, inline. No subagent:
    `clearFullLayers()` in Task 7 is a bug, not a style difference.
 5. **Parallel safety and the fake-edge test:** no two tasks in the same group write
    the same file **or share any other mutable target**; every `depends:` points at a
-   task that really produces what's consumed, and every edge's `Carries` cell is
-   filled. Count the edges you deleted — that number is the line below, and a plan
-   that deletes none on its first pass has almost certainly not run the test.
+   task that produces the input or establishes the required condition, and every edge's `Carries` cell is
+   filled. Count retained edges by kind and record removed edges with reasons.
+   Zero removals is valid when every original dependency is justified.
 6. **DoD present and verifiable** on every task.
 7. **Every command, path and file a DoD names resolves.** Walk each task's
    *Definition of done* and its steps and check the targets exist — a DoD that says
@@ -270,7 +282,7 @@ before the gate; every line a **computed number, not a tick**.
 - Decisions: checked against <the brief's D-table> and <stage 2's rejected options> — <verdict>
 - Cost: <surfaces>/<guards>/<REQ> now, <…> at stage 2 — <proportionate | grown, and why>
 - Hygiene: <n> checks, <n> findings, <n> open
-- Edges: <n> declared, <n> carry data, <n> removed
+- Edges: <n> declared, <n> data, <n> control, <n> resource, <n> removed with reasons
 - Placeholders: <n> · Ambiguity: <n> found, <n> resolved inline
 ```
 
@@ -287,6 +299,52 @@ back to stage 3 and is recorded there; a scope question goes back to the operato
 A decision first made while sequencing tasks is a decision nothing downstream will
 ever find, because nobody reads a plan after the build.
 
+## The UI handoff annex — a packet an executor can build without re-deriving
+
+A packet whose work is a screen carries a UI ANNEX beside its context: the
+state IDs it touches, the components it reuses and the props they take, the
+tokens and content strings, the accessibility requirements, and the exact
+asset versions. With it, an executor implements the fixture without going
+back to re-derive the visual spec; without it, the same work is re-decided
+per session and drifts. The annex ADDS to the task context — it never
+replaces the scheduler's claim or fence (that is `agent-sync`'s job, not the
+packet's), and a stale visual spec (an asset version or a token that moved
+under the plan) triggers a packet REVISION exactly as a moved source input
+does, never a silent dispatch against old pixels.
+
+The annex is a DOMAIN annex, optional by domain: a screen packet carries it,
+a migration or a CLI packet does not — a non-UI task owes no visual spec,
+and demanding one would be the mirror of the omission it fixes.
+
+## Pre-dispatch — the last gate before a claim
+
+Before a compiled leaf is claimed and worked
+(`scripts/context_packets.py predispatch`), it passes one final check: every
+input's digest is re-verified against the bytes on disk NOW (source drift
+blocks — the plan was made against other bytes), each data prerequisite's
+output must be materialized, the PRIMARY context must fit its budget (a
+breach BLOCKS and is never a silent truncation — the budget cuts appendix,
+never primary), and the declared capability and coordination claim must be
+present. Any failure blocks the claim and names itself; nothing is trimmed
+to fit.
+
+## The leaf compiler — a slice survives a cold reader or it does not dispatch
+
+Where the plan is compiled into execution packets
+(`scripts/context_packets.py compile-leaf`), each outcome slice carries its
+resolved decisions (bound by address+digest — an unresolved decision
+dispatches NO leaf), its exact scope, its mapping onto the parent's
+acceptance, and its material split into budgeted primary vs appendix — a
+budget cuts appendix only and records the cut, never acceptance. The test of
+a compiled packet is the **cold reader**: with no author history, the packet
+alone answers eight questions — goal, inputs, decisions, scope, outputs,
+acceptance, guards, resume (`readiness`); a missing version or output
+contract fails readiness. Acceptance names at least one positive and one
+negative case. A slice is selected by its explicit id, never by mtime; and
+neither a design flow nor a `.design/TASKS.md` becomes a parallel plan
+authority — leaves come from the plan through the compiler or they are not
+leaves.
+
 ## GATE (auto)
 
 **Set equality first:** the REQ ids in the brief equal the union of `Implements:`
@@ -298,6 +356,125 @@ Then: every spec requirement maps to a task; no placeholders; names and types
 consistent across tasks; parallel-group tasks share no files **or other mutable
 target**; each task has a verifiable DoD. **Every edge in the *Execution order*
 table has a non-empty `Carries` cell, and the `Edges:` line of the self-review is
-computed** — an unfillable cell is a fake edge and the gate does not pass with one
-left in the table. UI tasks carry their scenario IDs and `SCR-` screens. Verify all
+computed** — each retained edge names data, control or resource semantics. An
+unexplained edge blocks the gate until justified or safely removed. UI tasks carry their scenario IDs and `SCR-` screens. Verify all
 of it yourself and stop on failure — this gate has no operator in it.
+
+## Execution packets
+
+Size independent-executor tasks with [`decomposition.md`](decomposition.md) →
+Executor-sized tasks and context. Keep parent findings/features as containers;
+dispatch only leaves with resolved material decisions and budgeted primary context.
+
+
+Use this contract when research, intake, specification and planning happen in one
+agent, while other agents execute individual tasks, or when a host pipeline owns
+dispatch. It is an artifact and workflow contract. It does not claim that the
+bundled graph CLI is a distributed scheduler or that it implements the fields
+below as commands.
+
+### Roles and boundaries
+
+The planning agent harvests sources, resolves material decisions, produces the
+program/module model, specifications, task packets and their dependencies. It may
+finish at **plan-ready**. That state means the plan is available for execution;
+it does not mean the requested product is implemented.
+
+An executor receives one task and its resolved context. It does not restart
+intake or independently redesign settled interfaces. If the packet conflicts with
+source reality, it returns a change proposal with evidence to the planner rather
+than silently editing a shared plan. A reviewer evaluates the produced artifact;
+an integrator reconciles compatible outputs and owns the final delivery boundary.
+These are roles, not hardcoded models or host-specific subagent names.
+
+### The context closure a task must carry
+
+Persist a program brief and decisions, a module/interface map, shared contracts,
+and one task packet per independently reviewable deliverable. Each packet names:
+
+- Stable task, program and module IDs; its requirement and finding IDs.
+- The relevant program constraints and module boundaries, as explicit inputs.
+- Decisions with provenance, rationale, rejected alternatives and change triggers.
+- Every consumed/produced interface, including its version and responsible task.
+- Source repository, base revision and digests for the files/inputs it relies on.
+- Files to read, files permitted to change, new files explicitly marked Create,
+  and shared mutable resources. A directory name is not a complete ownership claim.
+- Concrete implementation sequence, invariants and edge cases; exact code where
+  a signature or algorithm must be settled, without pretending speculative code
+  was tested against a future tree.
+- Acceptance checks, required evidence type, scope exclusions and rollback.
+- Output/return format, reviewer/integrator destination and context budget.
+
+A linked file is useful only if the receiving agent can fetch it at the recorded
+revision. Resolve required links before dispatch; a missing required contract
+blocks dispatch, while optional context is labelled optional. Do not silently
+truncate required constraints to fit a token budget. Produce a smaller coherent
+task or move background material to retrievable references.
+
+Priority, dependency readiness, context completeness and implementation status
+are separate fields. An urgent row can be blocked; a detailed packet can still
+depend on an unfinished contract. Never translate either into "ready" by prose.
+
+### Dispatch, retries and changed inputs
+
+Before dispatch, verify the packet's inputs and predecessor outputs against their
+current digests. Changed relevant input makes the packet stale until it is
+reconciled; an unrelated file change need not invalidate the whole program.
+Record a new packet revision rather than rewriting the executor's historical input.
+
+The host adapter must establish one execution attempt: task ID, packet revision,
+attempt ID, owner, resource scope, expiry/heartbeat when applicable, and a fencing
+token for takeover. A file lock protecting JSON writes is not an execution lease.
+If the host cannot provide this boundary, serialize execution and state the
+limitation; do not run independent workers that merely read the same ready list.
+
+An executor returns output artifacts, changed-file digests, base/produced revisions,
+checks with PASS/FAIL/NOT_RUN/TEST_ERROR, remaining risks and the attempt token.
+Completion is accepted only for the current attempt and expected input revision.
+Duplicate results are idempotent; a late stale worker cannot close a newer attempt.
+Do not equate an agent's final message with an accepted business result.
+
+Dependencies may carry data, a control/approval condition, or a resource ordering
+constraint. Name the kind and reason. A dependency cannot be discarded solely
+because it has no data payload. Dispatch a task only after all its declared
+prerequisites are satisfied, and check overlapping write sets separately.
+
+### Portable host integration
+
+Keep the packet independent of Claude Code, Codex or any provider's conversation
+format. Each adapter maps dispatch, artifact access, cancellation, progress and
+result receipts to actual host capabilities. Record the capabilities used.
+Fresh agents and resumed agents receive the same required context closure.
+
+For an external platform, map both schemas explicitly: a stage list is not a work
+graph, a handoff message is not an execution lease, and an artifact path is not
+proof that a remote worker can read it. Until the adapter and its failure tests
+exist, label integration proposed/manual rather than supported.
+
+### UI task annex
+
+For a UI outcome, attach the scenario/screen/state IDs, selected flow and visual
+direction revision, component reuse/modify/create decisions, semantic token roles,
+approved or explicitly provisional content, keyboard/accessibility expectations,
+responsive/native behavior, and local asset provenance. Include only the portion
+needed for this leaf. A non-UI task does not need this annex.
+
+Keep behavior, its visual presentation and relevant states together when they
+form one independently verifiable outcome. Do not split every screen into HTML,
+CSS and interaction jobs. A changed flow, component contract or design revision
+refreshes the affected packets; the executor does not guess which screenshot or
+style discussion was authoritative. Preserve the existing family artifact paths.
+
+### Audit to executable backlog
+
+Every finding has a disposition and a task or a recorded reason for not acting.
+Separate common enabling contracts from per-finding repairs; link each task to
+the program/module/interface context it consumes. Build the graph, verify its
+closure, and partition runnable tasks by disjoint write sets. Include input drift,
+missing context, duplicate dispatch, late completion, multiple prerequisites,
+cancellation and failure recovery in acceptance. A cold reader must understand
+why the change exists and how its result fits the system without the original chat.
+
+Store the packet set with the plan. Planning is complete when the declared scope
+is covered, required inputs resolve, dependencies are acyclic and readiness is
+reported honestly. Delivery remains a separate state with its own evidence.

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

@@ -41,6 +41,7 @@ a row pointing outside the bundle is the defect this file exists to catch.
 |---|---|
 | The stage list, ids, names, gate types | `pipeline.example.json` |
 | Per-stage criteria, freedom levels, the run checklist | `references/stages.md` |
+| Which reference owns which stage (the doctrine map) | `references/doctrine-map.md` |
 | What the intake grill asks, and the autonomy sweep | `references/grill.md` |
 | **The escalation boundary** — what an agent may settle alone | `references/grill.md` |
 | The knowledge harvest and its source ledger | `references/knowledge-sources.md` |

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

@@ -269,15 +269,31 @@ printf '%s · %s\n' "$(date +%F)" "$(git rev-parse --short HEAD)" >> docs/eviden
 A lesson that lands in a cluttered file is a lesson nobody will reach — so the prune still runs
 before the entry is written. It runs *after* the stamp, because it reads it.
 
-Every row carries its own trigger in a **`Retire when`** column, written at birth —
-a rule whose retirement condition is decided later is a rule the prune can only
-argue about. Check **every** standing instruction against three triggers:
+Every row carries its own trigger in a **`Retire when`** column AND a **class**,
+both written at birth — a rule whose retirement condition is decided later is a
+rule the prune can only argue about. Three classes, because coldness means
+three different things:
+
+- **permanent** — a safety invariant, a contract, a recovery procedure. The
+  absence of the rare event it guards is not absence of value: **coldness never
+  retires a permanent rule** — only *became a check* or *surface gone* do.
+- **situational** — fires when a named EXPOSURE occurs (a payment run, a
+  migration, a release). Its row names the exposure, and the prune counts
+  **exposure opportunities, not raw runs**: five runs that never touched
+  payments say nothing about a payment rule.
+- **temporary** — a workaround with a **TTL** and the replacing mechanism named
+  at birth. TTL only exists on this class.
+
+Check **every** standing instruction against three triggers:
 
 | Trigger | Test | Then |
 |---|---|---|
 | **It became a check** | the rule is now enforced by a test, lint, gate or hook | delete it — the check is the memory, and keeping both means it is read twice and obeyed once |
 | **Its surface is gone** | resolve every path, command, stage and tool it names; any that no longer exists | delete it — it now describes a system nobody is running |
-| **It went cold** | it has not fired in the last **five run stamps** — **or** in the last **sixty days**, whichever comes first | delete it: five runs without firing is the evidence it was situational, and the calendar is the unit that still moves when the stamp counter has stopped |
+| **It went cold** | *situational only*: it fired in none of the last **five exposure opportunities** — or no exposure occurred in **sixty days** | mark **review-needed** and put the question to the operator with the exposure counts — cold is evidence worth reviewing, never an automatic deletion. *temporary*: TTL expired → archive it **once the replacing mechanism is verified present** (its check resolves and runs); an expired workaround whose replacement is absent is a live defect, not a retirement. *permanent*: not applicable |
+
+Every removal stays explainable: the archive line names the class, the trigger
+and the evidence (the exposure counts, or the replacing mechanism's check).
 
 **Each trigger is a command, not a judgement.** A retirement condition nobody can run is a
 condition nobody applies, which is how a list reaches ten and stops being read:
@@ -297,10 +313,12 @@ tail -n 200 docs/evidence/retro.md | grep -c "$RULE_ID"
 git log -1 --format=%cd --date=short -S"$RULE_ID" -- docs/evidence/retro.md
 ```
 
-Anything the first two print is a deletion; a zero from the third **or** a last-fired date more
-than sixty days old is a deletion. What survives all three stays, and the run states the counts
-rather than the conclusion (`learned.md` rule 19 — an empty result and an unrun command look
-identical).
+Anything the first two print is a deletion. A zero from the third — counted against
+**exposure opportunities** for a situational rule (`grep -c "$EXPOSURE_MARK"` over the same
+stamps, so the denominator is runs that COULD have fired it) — marks **review-needed**, and the
+run states the counts rather than the conclusion (`learned.md` rule 19 — an empty result and an
+unrun command look identical). Only the operator's answer, or a temporary rule's verified
+replacement, turns review-needed into a removal.
 
 **Why the cold trigger needs two units, and it is not belt-and-braces.** A run stamp is written by
 a run *of this pipeline*. Where a project ships some of its work another way, the stamp counter

package/plugins/task-pipeline/skills/task-pipeline/references/work-graph.md

@@ -38,7 +38,7 @@ turn of every loop.
 | `goal_clauses` | release work no requirement names. Enumerated, never matched against the goal's prose: substring-matching a sentence produces confidence without correctness |
 | `nodes[].owner` | which role does it. A node nobody can dispatch never leaves the frontier and nothing says why |
 | `nodes[].serves` | the REQ or goal clause it exists for. A node serving neither is **parked with that as the reason** |
-| `nodes[].blocked_by` | what must close first. This is what the frontier obeys |
+| `nodes[].blocked_by` | what must PRODUCE first. The frontier obeys a satisfaction predicate, and only `done` satisfies — a PARKED producer blocks its consumer, because a park is a decision not to produce, not a production. `next` names each held consumer with the park's reason; a valid alternative producer is an explicit, versioned edge change, never an implicit unblock |
 | `nodes[].touches` | what it **mutates**. Two runnable nodes writing one file is the false parallelism [`planning.md`](planning.md) refuses — *distinct is not the same as independent, and the check is what they touch, never what they are called* |
 | `nodes[].check` | **how this node will be closed** — one command, or the named judgement where no command can decide it. Required on every node except a `parked` one. The certification's `unit` tier runs it and reports its output as the evidence row ([`certification.md`](certification.md) — three blind tiers close a node, not one reader); before this field existed that instruction pointed at an absence, leaving a verifier the two things it forbids — invent a check, or run everything (B-080) |
 | `nodes[].evidence` | required when `status` is `done`. A node called done by assertion is what evidence exists to prevent |
@@ -63,6 +63,12 @@ conditional on the code, never merely sequenced after it.**
 | `close` | the goal, the new frontier count, and what was not verified | `0` · `1` refused **or the verdict stops the run** |
 | `producer` | what produced this proof — actor, model, runtime, skill, config, commit, trace | `0` |
 | `doctrine` | how many of the bundle's reference files this run opened | `0` |
+| `claim` | **external mode** — arbitrate one runnable node to a single owner through the durable coordinator (`scripts/execution_authority.py`); prints the grant. `next` says what COULD run, `claim` says who MAY | `0` won · `5` lost the race · `4` not runnable · `1` authority unavailable — **and `1` means no work starts** (fail-closed) |
+| `release` | give back a hold this run owns, matching its fence; a mismatch is a no-op, never a way to steal a live node | `0` released · `5` not held at that fence · `1` authority unavailable |
+| `recover` | **external mode** — reclaim an EXPIRED node for a new owner, minting a higher fence; a still-live claim is not recoverable (that is stealing a working node) | `0` recovered · `5` still live · `1` authority unavailable |
+| `complete` | **external mode** — record completion from the CURRENT fence-holder only; a late/superseded worker (stale fence) is refused, and the current holder completing twice is idempotent | `0` completed · `5` not the current holder · `1` authority unavailable |
+| `waive` | record an AUTHORIZED EXCEPTION — reason + identity, its own disposition: the node is never marked certified, a failed certification stays visible, and `close` stamps the exception into the evidence | `0` waived · `1` refused (no reason, no identity, unknown node) |
+| `invalidate` | a REQ/interface/brief change supersedes one node: a superseding revision is recorded, and the node plus every `done` DESCENDANT resets to pending with its evidence/proof/certification cleared — a proof certified against a contract that moved is a proof about a tree that no longer exists. Unrelated nodes keep their proofs; invalidation flows downstream only | `0` invalidated · `1` refused (no `--why`, unknown node, or the write would break the graph) |
 
 **`next` is ordered by what each node unblocks, transitively, and the number is computed.**
 A `priority` field is something somebody typed once and nobody revisits; this one moves when