@azure-id/orc 2.1.1 → 2.2.0

package/templates/skills/orc-boundary/references/gate.md

@@ -1,113 +1,113 @@
-# Reference — the boundary gate inside `/orc` (`boundary_gate`)
-
-Loaded by the spine at Phase 1. This is the CONSUMER half: `/orc` reads cards, it
-never writes one.
-
-`boundary_gate: off | warn | block` — default **`warn`**.
-
-| Mode | What changes |
-|---|---|
-| `off` | nothing. Cards are ignored entirely. |
-| `warn` | the preflight line, plus a per-task verdict printed before each wave. No dispatch changes. |
-| `block` | additionally: a REFUSE task is LIFTED OUT of its wave and never dispatched. |
-
-`block` changes dispatch behaviour on upgrade, which is why it is not the default.
-Print the active mode whenever a verdict is shown — a gate whose mode is invisible
-gets blamed for things it did not do.
-
-## Phase 1 — preflight, one line
-
-`orc boundary status --json` with the other probes. Print the `line` field
-VERBATIM:
-
-```
-bound : 9 execute · 2 escalate · 1 refuse (2 stale)
-```
-
-Never re-word it, never compute the counts. No cards at all:
-
-```
-bound : none — /orc-boundary writes them; no card means an area is UNKNOWN, not safe
-```
-
-## Phase 3 — per wave
-
-Before dispatching wave W, resolve each task's area by matching its
-`declared_files` against every card's `anchored_files` (longest match wins), then:
-
-**EXECUTE** — dispatch normally. Nothing printed beyond the wave table.
-
-**ESCALATE** — dispatch normally, and record the named human on the task. **Ship
-is gated on that sign-off**, using the EXISTING pause machinery — the stop sequence
-at the wave boundary, with the escalation named in the stop reason. No new stop
-mechanic, no new config key.
-
-**REFUSE** —
-
-- `warn`: print the verdict and its checklist, then dispatch anyway. The user was
-  told; the run is theirs.
-- `block`: **lift that ONE task out of the wave. The wave proceeds with the
-  rest.** Blocking the whole wave punishes the tasks that were fine, and a gate
-  that costs a wave gets switched off. Print:
-
-```
-boundary → wave 2: T04 lifted out (REFUSE · src/payments)
-  the wave runs with T03, T05.
-  T04 comes back when:
-    □ add a test runner to this package
-    □ cover the idempotency path            → /orc-pattern
-  Not blocked for you — say "do T04 anyway" and it dispatches.
-```
-
-That last line is required. The gate constrains ORC, not the user.
-
-A lifted task's dependents are **requeued, not cancelled**: the existing
-`REPLAN wave=<n>` path already handles a task that did not land, and this is that
-case with a different cause.
-
-**A task in an area with NO card** is dispatched normally and reported as
-`boundary: unknown` on its dispatch line. Unknown is not REFUSE — refusing
-everything uncarded would make the first run after install useless.
-
-### Extra — a REFUSE area never goes foreign, in either mode
-
-A task whose area is **REFUSE never routes to a non-Claude worker** whatever the
-route table says (`extra_enabled`, `../../_shared/extra-dispatch.md`), and this
-holds in `warn` mode too — where the task still dispatches, but to Claude. It is
-the second hard hold-back beside the cited-risk one, and it is deliberately
-*wider* than the `block` mode it sits next to.
-
-The reason is that the two verdicts are answering different questions. `block`
-decides whether ORC should attempt the task at all, and `warn` says the user
-accepted that risk. Neither of them asked whether the work should leave the
-machine — and a REFUSE is, by construction, an area where ORC **cannot verify
-its own output** (that is one of the four questions the verdict is derived from).
-Handing exactly that work to the executor with the weakest fence and no
-`actual_model` line compounds the one condition the card was written about.
-
-Print it with the verdict, and name it in the `extra:` preflight's held-back
-count. **A card that caused a hold-back must say so on its own card**, so the
-next reader learns it from the boundary lane rather than from a routing table
-they were not looking at. `unknown` is not REFUSE here either — an uncarded area
-routes by the ordinary rules.
-
-## `/orc-route`
-
-A plan with any REFUSE task **cannot route to `/orc-fast`**: fast has one executor
-and no wave to lift anything out of, so the gate has nowhere to act. Report it in
-the not-possible column with the verdict named, exactly like the other blocking
-conditions.
-
-## `/orc-ultra`
-
-The implementation judge may score against the area's card: an implementation that
-did the REFUSE-listed thing anyway is a blocking finding with an anchor
-(`.claude/orc/boundary/<area>.md`) and a consequence already written down.
-
-## The trace verb
-
-`BOUNDARY <verdict> task=<id> :: <area>` per gated task, and
-`BOUNDARY lift task=<id> :: <area>` when `block` removes one. Carried in the phase
-packet like every other verb — handed to `orc-trace-writer-haiku-4-5`, never
-written directly. `/orc-retro` reads them to answer the question this whole lane
-exists for: how much work did we stop attempting, and was that right?
+# Reference — the boundary gate inside `/orc` (`boundary_gate`)
+
+Loaded by the spine at Phase 1. This is the CONSUMER half: `/orc` reads cards, it
+never writes one.
+
+`boundary_gate: off | warn | block` — default **`warn`**.
+
+| Mode | What changes |
+|---|---|
+| `off` | nothing. Cards are ignored entirely. |
+| `warn` | the preflight line, plus a per-task verdict printed before each wave. No dispatch changes. |
+| `block` | additionally: a REFUSE task is LIFTED OUT of its wave and never dispatched. |
+
+`block` changes dispatch behaviour on upgrade, which is why it is not the default.
+Print the active mode whenever a verdict is shown — a gate whose mode is invisible
+gets blamed for things it did not do.
+
+## Phase 1 — preflight, one line
+
+`orc boundary status --json` with the other probes. Print the `line` field
+VERBATIM:
+
+```
+bound : 9 execute · 2 escalate · 1 refuse (2 stale)
+```
+
+Never re-word it, never compute the counts. No cards at all:
+
+```
+bound : none — /orc-boundary writes them; no card means an area is UNKNOWN, not safe
+```
+
+## Phase 3 — per wave
+
+Before dispatching wave W, resolve each task's area by matching its
+`declared_files` against every card's `anchored_files` (longest match wins), then:
+
+**EXECUTE** — dispatch normally. Nothing printed beyond the wave table.
+
+**ESCALATE** — dispatch normally, and record the named human on the task. **Ship
+is gated on that sign-off**, using the EXISTING pause machinery — the stop sequence
+at the wave boundary, with the escalation named in the stop reason. No new stop
+mechanic, no new config key.
+
+**REFUSE** —
+
+- `warn`: print the verdict and its checklist, then dispatch anyway. The user was
+  told; the run is theirs.
+- `block`: **lift that ONE task out of the wave. The wave proceeds with the
+  rest.** Blocking the whole wave punishes the tasks that were fine, and a gate
+  that costs a wave gets switched off. Print:
+
+```
+boundary → wave 2: T04 lifted out (REFUSE · src/payments)
+  the wave runs with T03, T05.
+  T04 comes back when:
+    □ add a test runner to this package
+    □ cover the idempotency path            → /orc-pattern
+  Not blocked for you — say "do T04 anyway" and it dispatches.
+```
+
+That last line is required. The gate constrains ORC, not the user.
+
+A lifted task's dependents are **requeued, not cancelled**: the existing
+`REPLAN wave=<n>` path already handles a task that did not land, and this is that
+case with a different cause.
+
+**A task in an area with NO card** is dispatched normally and reported as
+`boundary: unknown` on its dispatch line. Unknown is not REFUSE — refusing
+everything uncarded would make the first run after install useless.
+
+### Extra — a REFUSE area never goes foreign, in either mode
+
+A task whose area is **REFUSE never routes to a non-Claude worker** whatever the
+route table says (`extra_enabled`, `../../_shared/extra-dispatch.md`), and this
+holds in `warn` mode too — where the task still dispatches, but to Claude. It is
+the second hard hold-back beside the cited-risk one, and it is deliberately
+*wider* than the `block` mode it sits next to.
+
+The reason is that the two verdicts are answering different questions. `block`
+decides whether ORC should attempt the task at all, and `warn` says the user
+accepted that risk. Neither of them asked whether the work should leave the
+machine — and a REFUSE is, by construction, an area where ORC **cannot verify
+its own output** (that is one of the four questions the verdict is derived from).
+Handing exactly that work to the executor with the weakest fence and no
+`actual_model` line compounds the one condition the card was written about.
+
+Print it with the verdict, and name it in the `extra:` preflight's held-back
+count. **A card that caused a hold-back must say so on its own card**, so the
+next reader learns it from the boundary lane rather than from a routing table
+they were not looking at. `unknown` is not REFUSE here either — an uncarded area
+routes by the ordinary rules.
+
+## `/orc-route`
+
+A plan with any REFUSE task **cannot route to `/orc-fast`**: fast has one executor
+and no wave to lift anything out of, so the gate has nowhere to act. Report it in
+the not-possible column with the verdict named, exactly like the other blocking
+conditions.
+
+## `/orc-ultra`
+
+The implementation judge may score against the area's card: an implementation that
+did the REFUSE-listed thing anyway is a blocking finding with an anchor
+(`.claude/orc/boundary/<area>.md`) and a consequence already written down.
+
+## The trace verb
+
+`BOUNDARY <verdict> task=<id> :: <area>` per gated task, and
+`BOUNDARY lift task=<id> :: <area>` when `block` removes one. Carried in the phase
+packet like every other verb — handed to `orc-trace-writer-haiku-5-high`, never
+written directly. `/orc-retro` reads them to answer the question this whole lane
+exists for: how much work did we stop attempting, and was that right?

package/templates/skills/orc-brainstorm/SKILL.md

@@ -363,22 +363,22 @@ preflight line and has no gate to honour.
 ## Calls
 
 **ONE catalogue, and it is not you:** `orc lane calls orc-brainstorm --json` names every
-CLI call this lane makes, each with its exit-code contract, its cost, when to run
+SHARED CLI call this lane makes, each with its exit-code contract, its cost, when to run
 it, and what an EMPTY answer means. Never invent a spelling, never re-word an
 exit code, and never re-derive a state word — the CLI's state words are the only
 state words, and **an exit code is an ANSWER wherever that contract says so, not
-a failure**. A call the answer does not name is a call this lane does not make.
+a failure**. A call that neither it nor this skill names is a call this lane does not make.
 Exit ≠ 0 from the catalogue itself → say the CLI is unavailable and name the
-command you are about to run, out loud, before running it.
-
-## Rules — the anti-slop card (`../_shared/phases/rules.md`)
-
-`orc rules slice --lane orc-brainstorm --json` is the ONLY assembler; never build
-the card here. It rides under the house rules and above the task —
-**house rules > your project's rules > ORC's own packs** — and its `line` prints
-VERBATIM at preflight. Returns gain `rules_applied[]`, `rules_conflicts[]` (a gap,
-never a silent choice) and `rules_overridden[]`.
-## Waiting mid-run (`/orc-wait`)
-
-Canonical: `../_shared/wait.md`. **`a lane that waits without a hand-back` has broken this contract.**
-Checkpoint **snapshot** · safe point **phase edge**. `soft` FORCES that checkpoint and does NOT stop if the write fails; `hard` skips it and can lose an in-flight return. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.
+command you are about to run, out loud, before running it.
+
+## Rules — the anti-slop card (`../_shared/phases/rules.md`)
+
+`orc rules slice --lane orc-brainstorm --json` is the ONLY assembler; never build
+the card here. It rides under the house rules and above the task —
+**house rules > your project's rules > ORC's own packs** — and its `line` prints
+VERBATIM at preflight. Returns gain `rules_applied[]`, `rules_conflicts[]` (a gap,
+never a silent choice) and `rules_overridden[]`.
+## Waiting mid-run (`/orc-wait`)
+
+Canonical: `../_shared/wait.md`. **`a lane that waits without a hand-back` has broken this contract.**
+Checkpoint **snapshot** · safe point **phase edge**. `soft` FORCES that checkpoint and does NOT stop if the write fails; `hard` skips it and can lose an in-flight return. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.

package/templates/skills/orc-budget/SKILL.md

@@ -234,22 +234,22 @@ preflight line and has no gate to honour.
 ## Calls
 
 **ONE catalogue, and it is not you:** `orc lane calls orc-budget --json` names every
-CLI call this lane makes, each with its exit-code contract, its cost, when to run
+SHARED CLI call this lane makes, each with its exit-code contract, its cost, when to run
 it, and what an EMPTY answer means. Never invent a spelling, never re-word an
 exit code, and never re-derive a state word — the CLI's state words are the only
 state words, and **an exit code is an ANSWER wherever that contract says so, not
-a failure**. A call the answer does not name is a call this lane does not make.
+a failure**. A call that neither it nor this skill names is a call this lane does not make.
 Exit ≠ 0 from the catalogue itself → say the CLI is unavailable and name the
-command you are about to run, out loud, before running it.
-
-## Rules — the anti-slop card (`../_shared/phases/rules.md`)
-
-`orc rules slice --lane orc-budget --json` is the ONLY assembler; never build
-the card here. It rides under the house rules and above the task —
-**house rules > your project's rules > ORC's own packs** — and its `line` prints
-VERBATIM at preflight. Returns gain `rules_applied[]`, `rules_conflicts[]` (a gap,
-never a silent choice) and `rules_overridden[]`.
-## Waiting mid-run (`/orc-wait`)
-
-Canonical: `../_shared/wait.md`. **`a lane that waits without a hand-back` has broken this contract.**
-Checkpoint **none** · safe point **read-only, seconds long**. Nothing here to checkpoint, so all three modes behave identically — say so rather than asking. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.
+command you are about to run, out loud, before running it.
+
+## Rules — the anti-slop card (`../_shared/phases/rules.md`)
+
+`orc rules slice --lane orc-budget --json` is the ONLY assembler; never build
+the card here. It rides under the house rules and above the task —
+**house rules > your project's rules > ORC's own packs** — and its `line` prints
+VERBATIM at preflight. Returns gain `rules_applied[]`, `rules_conflicts[]` (a gap,
+never a silent choice) and `rules_overridden[]`.
+## Waiting mid-run (`/orc-wait`)
+
+Canonical: `../_shared/wait.md`. **`a lane that waits without a hand-back` has broken this contract.**
+Checkpoint **none** · safe point **read-only, seconds long**. Nothing here to checkpoint, so all three modes behave identically — say so rather than asking. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.

package/templates/skills/orc-challenge/README.md

@@ -135,7 +135,7 @@ one.
 
 ## Reading order for a new maintainer
 
-`../_shared/phases/intake.md` (it defines what every later file grades against) →
+`references/intake.md` (it defines what every later file grades against) →
 `council.md` → `sealed-slice.md` → `rubric.md` → `conservation.md` →
 `cycle-state.md` → `fix-brief.md`. Then `examples/tsd-two-iterations.md` for the
 whole thing end to end, and `examples/council-full-roster.md` for a run where

package/templates/skills/orc-challenge/SKILL.md

@@ -115,7 +115,7 @@ themselves are this lane's own and stay here.
 ## C1 — Intake (ONE round, ASK — never guess)
 
 Full field list, the round format and the "I don't know yet" exit:
-`../_shared/phases/intake.md`. It ends by running `orc challenge init`, which **freezes
+`references/intake.md`. It ends by running `orc challenge init`, which **freezes
 `goals.md`, `template.md` and the COUNCIL ROSTER**.
 
 **Question 7 is the P0 council ask**, rendered from `orc challenge roles --kind
@@ -284,22 +284,22 @@ documented defaults, out loud. Priorities and families:
 ## Calls
 
 **ONE catalogue, and it is not you:** `orc lane calls orc-challenge --json` names every
-CLI call this lane makes, each with its exit-code contract, its cost, when to run
+SHARED CLI call this lane makes, each with its exit-code contract, its cost, when to run
 it, and what an EMPTY answer means. Never invent a spelling, never re-word an
 exit code, and never re-derive a state word — the CLI's state words are the only
 state words, and **an exit code is an ANSWER wherever that contract says so, not
-a failure**. A call the answer does not name is a call this lane does not make.
+a failure**. A call that neither it nor this skill names is a call this lane does not make.
 Exit ≠ 0 from the catalogue itself → say the CLI is unavailable and name the
-command you are about to run, out loud, before running it.
-
-## Rules — the anti-slop card (`../_shared/phases/rules.md`)
-
-`orc rules slice --lane orc-challenge --json` is the ONLY assembler; never build
-the card here. It rides under the house rules and above the task —
-**house rules > your project's rules > ORC's own packs** — and its `line` prints
-VERBATIM at preflight. Returns gain `rules_applied[]`, `rules_conflicts[]` (a gap,
-never a silent choice) and `rules_overridden[]`.
-## Waiting mid-run (`/orc-wait`)
-
-Canonical: `../_shared/wait.md`. **`a lane that waits without a hand-back` has broken this contract.**
-Checkpoint **cycle** · safe point **after a cycle records**. `soft` FORCES that checkpoint and does NOT stop if the write fails; `hard` skips it and can lose an in-flight return. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.
+command you are about to run, out loud, before running it.
+
+## Rules — the anti-slop card (`../_shared/phases/rules.md`)
+
+`orc rules slice --lane orc-challenge --json` is the ONLY assembler; never build
+the card here. It rides under the house rules and above the task —
+**house rules > your project's rules > ORC's own packs** — and its `line` prints
+VERBATIM at preflight. Returns gain `rules_applied[]`, `rules_conflicts[]` (a gap,
+never a silent choice) and `rules_overridden[]`.
+## Waiting mid-run (`/orc-wait`)
+
+Canonical: `../_shared/wait.md`. **`a lane that waits without a hand-back` has broken this contract.**
+Checkpoint **cycle** · safe point **after a cycle records**. `soft` FORCES that checkpoint and does NOT stop if the write fails; `hard` skips it and can lose an in-flight return. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.

package/templates/skills/orc-challenge/examples/council-full-roster.md

@@ -15,7 +15,7 @@ for a PRD includes the two lenses that never block.
 > /orc-challenge docs/prd-self-serve.md
 ```
 
-The first six questions are unchanged (`../../_shared/phases/intake.md`). Question 7 is
+The first six questions are unchanged (`references/intake.md`). Question 7 is
 rendered from `orc challenge roles --kind prd --json` — **the skill never
 hand-lists the lenses**:
 

package/templates/skills/orc-claude/SKILL.md

@@ -74,7 +74,7 @@ set in "Behavior trace").
    does not change this role) with: `mode`, `repo_root`,
    `budget` (from a `budget=N` argument, else null), and the paths to
    `references/template.md` + `references/refresh.md`. **Trace:** emit
-   `DISPATCH orc-claude-writer :: <mode> expect=opus-5/low` just before the
+   `DISPATCH orc-claude-writer :: <mode> expect=opus-5-5/low` just before the
    spawn (the expectation is derived from the agent NAME you actually
    dispatched, never from this line's default; the hook then adds
    `SPAWN`/`RETURN` on its own).
@@ -175,7 +175,7 @@ Dispatch-only lane: emit ONLY the markers it can truthfully witness — **not**
 `PHASE`/`SCORE`/`FINDING`/`VERDICT`, because scan/generate/report run INSIDE
 the writer sub-agent and there is no scoring or review here. The marker set, in
 order (actor `orc`, plus the hook's `SPAWN`/`RETURN`): `DISPATCH
-orc-claude-writer :: <mode> expect=opus-5/low` before the spawn (the mode
+orc-claude-writer :: <mode> expect=opus-5-5/low` before the spawn (the mode
 rides in this tail and in `FINISH`, so no separate mode marker) · `VERIFY writer
 actual=<model>/<effort>` · `FINISH :: <mode_ran> CLAUDE.md v<X.Y.Z>`, where
 `mode_ran` may be `noop`. A noop refresh still traces the full cycle.
@@ -207,11 +207,11 @@ documented defaults, out loud. Priorities and families:
 ## Calls
 
 **ONE catalogue, and it is not you:** `orc lane calls orc-claude --json` names every
-CLI call this lane makes, each with its exit-code contract, its cost, when to run
+SHARED CLI call this lane makes, each with its exit-code contract, its cost, when to run
 it, and what an EMPTY answer means. Never invent a spelling, never re-word an
 exit code, and never re-derive a state word — the CLI's state words are the only
 state words, and **an exit code is an ANSWER wherever that contract says so, not
-a failure**. A call the answer does not name is a call this lane does not make.
+a failure**. A call that neither it nor this skill names is a call this lane does not make.
 Exit ≠ 0 from the catalogue itself → say the CLI is unavailable and name the
 command you are about to run, out loud, before running it.
 

package/templates/skills/orc-claude/examples/claude-run-mock.md

@@ -50,7 +50,7 @@ dispatches the trace writer ONCE at run end to append them (`SPAWN`/`RETURN`
 come from the `orc-trace.js` hook as they occur):
 
 ```
-[120726 09:14:02.110] writer   DISPATCH orc-claude-writer :: refresh expect=opus-5/low
+[120726 09:14:02.110] writer   DISPATCH orc-claude-writer :: refresh expect=opus-5-5/low
 [120726 09:14:02.230] hook     SPAWN orc-claude-writer-opus-5-low
 [120726 09:15:47.900] hook     RETURN
 [120726 09:15:48.010] writer   VERIFY writer actual=claude-opus-5-5/low ✅ MATCH

package/templates/skills/orc-diy/SKILL.md

@@ -60,8 +60,8 @@ SKILL.md as a spine — the flow names every subskill and schema it needs.
 
 ## Lane contract (`../_shared/lane-contract.md` — read it ONLY when a call exits ≠ 0)
 
-- **Calls:** `orc lane calls orc-diy --json` names every call and its exit codes.
-  **An exit code is an ANSWER where it says so, not a failure.** Make no other call.
+- **Calls:** `orc lane calls orc-diy --json` names shared calls and exit codes.
+  **An exit code is an ANSWER where it says so, not a failure.** Own calls are here; make no other.
 - **Config:** `orc lane config orc-diy --json`. Obey `effective`, print every line
   in `announce[]` VERBATIM at preflight, and honour `stops[]` before wave 1.
   Never merge `.claude/orc.config.yaml` yourself (`../_shared/config-precedence.md`).

package/templates/skills/orc-diy/references/blocks/wiki.md

@@ -1,26 +1,26 @@
-## Wiki gate
-
-<!-- diy:when wiki_gate=off -->
-Skip the wiki freshness check entirely for this flow. If a project wiki
-exists, executors may still receive wiki page pointers, but freshness is
-never computed and never surfaced.
-<!-- /diy:when -->
-<!-- diy:when wiki_gate=notice -->
-Compute the wiki freshness tier exactly as the full lane does (follow the
-read-side procedure in `.claude/skills/orc-wiki/references/staleness.md`).
-Fresh → use silently; aging → one-line notice, continue; stale → warn the
-user that wiki hints may be outdated, continue. Never block on it.
-<!-- /diy:when -->
-<!-- diy:when wiki_gate=hard -->
-Compute the wiki freshness tier exactly as the full lane does (follow the
-read-side procedure in `.claude/skills/orc-wiki/references/staleness.md`).
-Fresh or aging → proceed. Stale or missing → STOP and ask the user: refresh
-the wiki first (recommended), or continue anyway with hints demoted. Respect
-the precedence rule from that reference in every consumer slice.
-<!-- /diy:when -->
-
-<!-- diy:when post_ship_wiki_ask=on -->
-After a successful ship on a big run, offer the post-ship wiki refresh ask
-exactly as the full lane defines it in the orc skill (guarded on a non-empty
-wiki; judged by final task/file counts at ship time).
-<!-- /diy:when -->
+## Wiki gate
+
+<!-- diy:when wiki_gate=off -->
+Skip the wiki freshness check entirely for this flow. If a project wiki
+exists, executors may still receive wiki page pointers, but freshness is
+never computed and never surfaced.
+<!-- /diy:when -->
+<!-- diy:when wiki_gate=notice -->
+Read the wiki freshness tier from `orc wiki status --json` (`state`, then
+`tier`) — the CLI is its only executor; never compute it yourself.
+Fresh → use silently; aging → one-line notice, continue; stale → warn the
+user that wiki hints may be outdated, continue. Never block on it.
+<!-- /diy:when -->
+<!-- diy:when wiki_gate=hard -->
+Read the wiki freshness tier from `orc wiki status --json` (`state`, then
+`tier`) — the CLI is its only executor; never compute it yourself.
+Fresh or aging → proceed. Stale or missing → STOP and ask the user: refresh
+the wiki first (recommended), or continue anyway with hints demoted. Respect
+the precedence rule from that reference in every consumer slice.
+<!-- /diy:when -->
+
+<!-- diy:when post_ship_wiki_ask=on -->
+After a successful ship on a big run, offer the post-ship wiki refresh ask
+exactly as the full lane defines it in the orc skill (guarded on a non-empty
+wiki; judged by final task/file counts at ship time).
+<!-- /diy:when -->

package/templates/skills/orc-diy/references/flow-schema.md

@@ -27,7 +27,7 @@ selector.
 | `mock_example` | `ask` / `on` / `off` | Post-verify mocked example + drift recovery (`mock-examples/<slug>/`, never committed) |
 | `tdd` | `on` / `off` | TDD-anchored planning: plan-time `tdd_spec` (scoped by `disposition`), paired TDD tasks for the red proof, TDD gate in the verify slot |
 | `gotchas` | `on` / `off` | Repair memory: inject scope-matching gotchas into slices, record one when a repair loop goes red → green (`_shared/gotchas.md`) |
-| `code_graph` | `on` (default) / `off` | Code-graph cache steps: `orc graph status --heal` at preflight, `orc graph ctx` cards in slices, `orc graph map` then `orc graph impact` + `orc graph cochange` at planning, `orc graph changes` at review, `orc graph coverage` on demand, `orc graph update` after every wave and at ship, one `orc graph notes` batch per wave when notes are on. `on` compiles them in and the global `code_graph` key decides at run time (every call carries `--if-enabled`); `off` removes them (`_shared/code-graph.md`) |
+| `code_graph` | `on` (default) / `off` | The four graph touchpoints: consult at preflight (print the probe line; `orc graph status --heal` only when `heal_needed`), orient at planning (`orc graph map --focus=` once, then `orc graph impact` + `orc graph cochange`), ONE `orc graph ctx --for-slice … --anchors` per writing slice (`graph_anchors`, inline), `orc graph changes --files=` once at review; `orc graph update --notes-pending` only when `update_step` is `lane`; no gain step. `on` compiles them in and the global `code_graph` key decides at run time (every call carries `--if-enabled`); `off` removes them (`_shared/code-graph.md`) |
 | `wiki_gate` | `notice` / `off` / `hard` | Wiki freshness handling at preflight |
 | `post_ship_wiki_ask` | `on` / `off` | Post-ship wiki refresh offer on big runs |
 | `summary` | `full` / `off` / `short` | Summary depth |
@@ -44,7 +44,7 @@ selector.
 Hard errors (config not written):
 - `scoring: off` without a `fixed_executor`.
 - `fixed_executor` or any agent choice above `session_tier` (tier order:
-  haiku-4-5 < sonnet-4-6 < sonnet-5 < opus-4-7 < opus-4-8 < opus-5 < fable-5 —
+  haiku-5 < sonnet-4-6 < sonnet-5 < opus-4-7 < opus-4-8 < opus-5 < fable-5 —
   subagents cannot exceed the main session; effort medium < high < xhigh < max).
   A tier below `opus-5-high` clips the `[90,100]` band to the highest agent it
   allows, at compile time.

package/templates/skills/orc-doc/README.md

@@ -13,7 +13,7 @@ explaining anything twice.
 
 That is why a 900-line TSD does not end a session. Nothing that holds context
 ever holds the document: each writer owns exactly ONE file, each checker reads
-ONE bounded part, and the orchestrator holds a map.
+only the bounded part files of its slice, and the orchestrator holds a map.
 
 And since v0.49.0 there is a second sentence:
 
@@ -159,7 +159,7 @@ orc doc parts my-prd                       # what is written, and what is not
 orc doc compile my-prd [--partial]         # sections/ -> document.md. FREE
 orc doc lint my-prd                        # the free check (0 clean / 1 findings)
 orc doc map my-prd                         # fresh line numbers, never stored
-orc doc plan my-prd --role check --json    # one bounded part file per checker
+orc doc plan my-prd --role check --json    # bounded part files per checker slice
 orc doc split my-prd --section 04-design --by-heading   # store a big section in parts
 orc doc split my-prd                       # recover sections/ from document.md
 orc doc status my-prd                      # 0 nothing to do / 1 something to do / 2 unknown