@azure-id/orc 2.1.0 → 2.2.0

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

@@ -62,11 +62,11 @@ Behavior-trace logging is permanent (always on). Resolve `log_dir`
 `../_shared/phases/trace.md`; the marker set is in "Behavior trace"
 below. Weave the **Trace:** steps in as each event happens.
 
-1. **Topic pick (wiki-first).** Read `wiki/INDEX.md` +
-   `.claude/orc/wiki-meta.json` and compute the freshness tier
-   (`../orc-wiki/references/staleness.md` — computed on read, never stored).
-   **Trace:** `WIKI-CONSULT tier=<FRESH|AGING|STALE|none> :: topic-pick`
-   (emitted even when the wiki is absent, with `none`).
+1. **Topic pick (wiki-first).** Read the tier from `orc wiki status --json`
+   (`state`, then `tier`) — the CLI is its only executor; never compute it from
+   `.claude/orc/wiki-meta.json` yourself. Then read `wiki/INDEX.md`.
+   **Trace:** `WIKI-CONSULT <fresh|aging|stale|absent> :: docs=<topic doc|none>`
+   (emitted even when the wiki is absent, with `absent`).
    - Wiki FRESH/AGING → present its feature areas as a pick-list; the chosen
      area's `covers` globs seed the writer's file set.
    - No wiki / STALE / topic not covered → ask the user to point at the
@@ -83,7 +83,7 @@ below. Weave the **Trace:** steps in as each event happens.
    `wiki_tier`, `focus_hint|null`, and the paths to
    `references/deepen.md`, `references/template-learning.md`,
    `references/template-knowledge.md`. **Trace:**
-   `DISPATCH orc-learn-writer :: init <slug> expect=opus-5/low` just
+   `DISPATCH orc-learn-writer :: init <slug> expect=opus-5-5/low` just
    before the spawn (the hook adds `SPAWN`/`RETURN` on its own).
 4. On return, check `actual_model`/`actual_effort` against the pinned tier —
    mismatch → prepend a tier-downgrade warning to the report. **Trace:**
@@ -108,9 +108,9 @@ below. Weave the **Trace:** steps in as each event happens.
    selected → stop, no writes.
 4. **Trace:** write `log_dir/.current` = `run-learn-<slug>-<DDMMYY>-<HHMMSS>.txt`. For each
    selected feature, spawn the writer with `mode=refresh` and that feature's
-   slice (re-deepen just that feature; a FRESH/AGING wiki may again seed the
-   boundary — emit one `WIKI-CONSULT tier=<tier> :: refresh` when the wiki is
-   read). One `DISPATCH`/`VERIFY` pair per feature, same markers as INIT.
+   slice (re-deepen just that feature; a FRESH/AGING tier from
+   `orc wiki status --json` may again seed the boundary — emit one
+   `WIKI-CONSULT <tier> :: docs=<doc|none>` when the wiki is read). One `DISPATCH`/`VERIFY` pair per feature, same markers as INIT.
 5. The (last) writer re-derives `learning-docs/INDEX.md` from all current
    feature headers. Relay the combined report. **Trace:**
    `FINISH :: refresh <n> features`, then delete `log_dir/.current`.
@@ -130,8 +130,8 @@ Dispatch-only lane: emit ONLY the markers it can truthfully witness — no
 `PHASE`/`SCORE`/`FINDING`/`VERDICT`, because deepening and writing happen
 inside the writer, which self-traces nothing and returns only
 `actual_model`/`actual_effort`. The marker set, in order (actor `orc`, plus the
-hook's `SPAWN`/`RETURN`): `WIKI-CONSULT tier=<tier> :: <topic-pick|refresh>` at
-every wiki read · `DISPATCH orc-learn-writer :: <mode> <slug> expect=opus-5/low`
+hook's `SPAWN`/`RETURN`): `WIKI-CONSULT <tier> :: docs=<doc|none>` at
+every wiki read · `DISPATCH orc-learn-writer :: <mode> <slug> expect=opus-5-5/low`
 per spawn (REFRESH runs one per selected feature) · `VERIFY writer
 actual=<model>/<effort>` · `FINISH :: <init <slug>|refresh <n> features>`.
 `decisions` carries which feature was picked and why, plus the user's answer
@@ -167,11 +167,11 @@ preflight line and has no gate to honour.
 ## Calls
 
 **ONE catalogue, and it is not you:** `orc lane calls orc-learn --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-learn/examples/learn-run-mock.md

@@ -47,8 +47,8 @@ single-dispatch lane — dispatches the trace writer ONCE at run end to append
 them (`SPAWN`/`RETURN` come from the `orc-trace.js` hook as they occur):
 
 ```
-[170726 10:02:01.050] writer   WIKI-CONSULT tier=FRESH :: topic-pick
-[170726 10:02:44.310] writer   DISPATCH orc-learn-writer :: init orders expect=opus-5/low
+[170726 10:02:01.050] writer   WIKI-CONSULT fresh :: docs=orders
+[170726 10:02:44.310] writer   DISPATCH orc-learn-writer :: init orders expect=opus-5-5/low
 [170726 10:02:44.420] hook     SPAWN orc-learn-writer-opus-5-low
 [170726 10:06:12.900] hook     RETURN
 [170726 10:06:13.010] writer   VERIFY writer actual=claude-opus-5-5/low ✅ MATCH

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

@@ -53,7 +53,7 @@ Phase 1  planning (dispatch orc-planner-mini; analyst first only on real docs)
 Phase 3  dispatch ONE executor (orc-executor-sonnet-5-high) — slice carries the
          standing `house_rules` card (../_shared/phases/house-rules.md, literal) +
          the `rules_card` under it (`orc rules slice` → `text`, verbatim) + the cached
-         `postgres` pattern (HIT only) + the --for-slice card + wiki PATHS
+         `postgres` pattern (HIT only) + graph_anchors (inline) + wiki PATHS
 Phase M  SMOKE GATE — run build+test → GREEN proceed · RED block ship + surface
 Phase X  MOCK EXAMPLE (config mock_example) — offer/build after a GREEN gate
 Phase T  TEST-AUTHORING ASK (opt-in) — offer to write test cases (never run them)
@@ -72,13 +72,13 @@ returned `gotcha_recorded` YOURSELF. `.claude/orc/gotchas.md` and the mechanics:
 
 ## Code graph cache — consult, build, use, update (`../_shared/code-graph.md` §0)
 
-Never skipped. Every call carries `--if-enabled`: exit 3 = off → print `graph: off` once, make no other graph call. Print each JSON `line` in chat; put each `trace` in the next packet VERBATIM.
-1. **Preflight, with the probes, before the planner:** `orc graph status --if-enabled --heal --json --brief` — it builds or updates the cache itself.
-2. **Phase 0, before the tiered round:** `orc graph map --focus "<3–6 words from the request>" --budget 800 --if-enabled --json --brief`. Its ranked files pre-fill Q4's `➡️` recommendation. Never ask what the map already answered.
-3. **Phase 1, ONE call:** `orc graph impact <declared_files> --complexity --risk=<facets.risk[] as class[@file:line],…> --if-enabled --json --brief`. Its `complexity.line` IS the complexity line — print it VERBATIM (`risk not given` → append the classes yourself); its `facts{}` IS `graph_facts` — paste it, then set `facts.map` to the `map --focus` card you already hold. No `complexity` in the answer (an older CLI) → count as `references/complexity.md` §2 says.
-4. **Phase 3 slice:** ONE `orc graph ctx <declared_files> --for-slice --if-enabled --json --brief` → its `card` is the `graph` block, the OUTSIDE view. No card when the change stays inside one named file with no signature change (`../_shared/code-graph.md` §7). The return carries `graph_used`.
-5. **Phase M, before the suite:** `orc graph changes --files=<actual_files> --if-enabled --json --brief` — print its `tests_line`, run the files its `tests[]` names first, then the suite, then its `blast_line` VERBATIM. The CLI attaches every `risk` word's `why`.
-6. **Phase M GREEN:** `orc graph update --notes-pending --files <actual_files> --if-enabled --json --brief` — ONE call for the update AND the notes batch (§6) — then `orc graph gain --run <this run> --if-enabled --json --brief`, `line` copied VERBATIM into the card's `graph` row.
+Never skipped. Every call carries `--if-enabled`. Exit 3 (`off` or `semi`) → print the probe line once, make no other graph call. Print each JSON `line` in chat; put each `trace` in the next packet VERBATIM.
+1. **Consult — preflight, before the planner:** print `probes["graph-status"].line` from `orc lane config orc-mini --json`. Run `orc graph status --if-enabled --heal --json --brief` only when `heal_needed` is true.
+2. **Orient — Phase 0, before the tiered round:** `orc graph map --focus=<3–6 words from the request> --budget 800 --if-enabled --json --brief`, ONCE. Its ranked files pre-fill Q4's `➡️` pick. Never re-ask it.
+3. **Phase 1, ONE call:** `orc graph impact <declared_files> --complexity --risk=<facets.risk[] as class[@file:line],…> --if-enabled --json --brief`. Its `complexity.line` IS the complexity line — print it VERBATIM (`risk not given` → append the classes yourself); its `facts{}` IS `graph_facts` — paste it, then set `facts.map` to the map card you already hold. No `complexity` in the answer → count as `references/complexity.md` §2 says.
+4. **Anchors — Phase 3 slice:** `orc graph ctx --for-slice <declared_files> --focus=<same words> [--refs=<task.precedent>] --anchors --if-enabled --json --brief`. Print its `line`; its WHOLE `card` (`read all:` + code) goes VERBATIM in the slice as `graph_anchors`. With `graph_anchors` in the slice, list at most ONE wiki page path (the one about the feature's intent), not 1–3. Exit 3/4, or one named file, no outside change → none; the return carries `graph_used`.
+5. **Affected tests — Phase M, before the suite:** `orc graph changes --files=<actual_files> --if-enabled --json --brief` — print its `tests_line`, run the files its `tests[]` names first, then the suite, then its `blast_line` VERBATIM. The CLI attaches every `risk` word's `why`.
+6. **Phase M GREEN:** `orc graph update --notes-pending --files <actual_files> --if-enabled --json --brief` ONLY when `probes["graph-status"].update_step` is `lane`. Else none; never a gain call.
 
 ## Phase M — Smoke gate (build + test; blocks ship on red)
 
@@ -148,9 +148,9 @@ mini skipped. Record the switch in the decision log.
 
 ## Dispatch via named agents (canonical name-map — dispatch BY these names)
 
-Models pinned in `.claude/agents/`; look one up here, never reconstruct a name (agent = skill-name + model-effort suffix). See `.claude/agents/MODEL-MAPPING.md`. `opus5_only: true` FORCES the right column and needs an Opus 5.5 main session — mini's cheap-lane premise is off while it is on (`../_shared/opus5-only.md`).
+Models pinned in `.claude/agents/`; never reconstruct a name. See `.claude/agents/MODEL-MAPPING.md`. `opus5_only: true` FORCES the right column and needs an Opus 5.5 main session (`../_shared/opus5-only.md`).
 
-**Extra (`extra_enabled`, `../_shared/extra-dispatch.md` — the procedure):** mini's ONE executor may run off Claude. Resolve the pinned executor's **BAND, both edges, and require them to agree** — else the run stays on Claude and the preflight says so. Print the `extra:` line at intake whenever the gate is on (P0: `a lane that sends work off Claude without saying so`). The IDENTICAL slice goes via `orc extra dispatch --task <file> --json`; validate with `return-validation.md` **§2b, not §2** (⛔ SUBSTITUTION); a failure runs `orc extra reconcile <task_id>` FIRST (a moved worktree is RESUMED, never re-done), then the pinned Claude agent, announced. `extra_risk_tasks` still keeps a cited-risk change on Claude — the complexity read never replaces that gate.
+**Extra (`extra_enabled`, `../_shared/extra-dispatch.md` — the procedure):** mini's ONE executor may run off Claude. Resolve the pinned executor's **BAND, both edges, and require them to agree** — else the run stays on Claude and the preflight says so. Print the `extra:` line at intake whenever the gate is on (P0: `a lane that sends work off Claude without saying so`). The IDENTICAL slice goes via `orc extra dispatch --task <file> --json`; validate with `return-validation.md` **§2b, not §2** (⛔ SUBSTITUTION); a failure runs `orc extra reconcile <task_id>` FIRST (a moved worktree is RESUMED, never re-done), then the pinned Claude agent, announced. `extra_risk_tasks` still keeps a cited-risk change on Claude.
 
 | Role | Agent (dispatch this) | Model / effort | When `opus5_only` |
 |------|-----------------------|----------------|-------------------|
@@ -161,8 +161,8 @@ Models pinned in `.claude/agents/`; look one up here, never reconstruct a name (
 
 ## Lane contract (`../_shared/lane-contract.md` — read it ONLY when a call exits ≠ 0)
 
-- **Calls:** `orc lane calls orc-mini --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-mini --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-mini --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-mini/examples/mini-run-mock.md

@@ -10,7 +10,7 @@ U: /orc-mini add a `--json` flag to the `report` CLI command
 O: Creates run folder run/report-json-flag/ FIRST.
    [reads repo: Python/poetry/pytest — asks nothing about stack]
    graph: FRESH — 6 files · 8 symbols
-   GRAPH-MAP :: focus="report json flag" budget=800 → cli/report.py, tests/test_report.py
+   GRAPH-MAP focused :: files=6/6 focus=cli/report.py,tests/test_report.py gen=7 → cli/report.py, tests/test_report.py
    Batched round (medium tier): 1) What should exist? 2) Out of scope?
    3) How do we know it's done? 4) Patterns/files to avoid?
    [Q4's ➡️ already names cli/report.py and tests/test_report.py — the map
@@ -30,21 +30,20 @@ O: GATE complexity :: complexity: mini-ok — 2 files · confident callers 1 in
     3+ co-commits would have made this "recommend /orc" — an offer, never a switch.)
 
 ## Phase 3 — Execute (ONE subagent)
-O: graph: --for-slice card (2 files) · wiki: 1 path (pointer, body never read here)
+O: graph: graph_anchors (2 files) · wiki: 1 path (pointer, body never read here)
 O: → claude-sonnet-5-5 / high :: DISPATCH orc-executor-sonnet-5-high :: add --json flag
    [executor edits cli/report.py + updates tests, returns actual_files + actual_model
    + evidence {`pytest tests/test_report.py`, exit 0, tail quoted} + empty unmet[]]
 O: VERIFY actual=claude-sonnet-5-5/high ✅ MATCH · evidence present ✓
 
 ## Phase M — Smoke gate (build + test; blocks ship on red)
-O: GRAPH-CHANGES → tests reached 1 file (call 1)
+O: GRAPH-CHANGES found :: symbols=1 high=0 medium=0 low=1 gen=7 → tests reached 1 file (call 1)
    [runs `pytest tests/test_report.py` FIRST]  ⛔ RED — 1 failure: JSON missing trailing key.
    Not offering commit. Auto-fix ONCE → re-dispatch executor with the failure output.
    [re-run] ✅ GREEN — tests reached 1 file → 4 passed · suite 12 passed · build ok.
    blast radius   1 symbol touched · callers 1 in 1 file · tests reach 1 · risk none
    VERDICT pass
-O: GRAPH-UPDATE :: gen 8 · 2 files · 1 note pending → noter batch dispatched
-   graph gain: paid 0.8K tokens · avoided an estimated 2–5K · measured: not yet (N=1)
+O: graph update: none — update_step is `hook` (the graph hook updates the index)
 
 ## Phase T — Test-authoring ask (opt-in; writes, never runs)
 O: Write test cases for these changes? (I author them — files + TEST-PLAN.md — but

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

@@ -241,22 +241,22 @@ preflight line and has no gate to honour.
 ## Calls
 
 **ONE catalogue, and it is not you:** `orc lane calls orc-pact --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-pact --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-pact --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-pact/references/gate.md

@@ -1,70 +1,70 @@
-# Reference — the pact gate inside `/orc` (`pact_gate`)
-
-Loaded by the spine at Phase 1. This is the CONSUMER half: `/orc` reads the
-ledger, it never writes one. Writing is `/orc-pact`'s alone.
-
-`pact_gate: off | warn` — default `warn`. **There is no `block`.** A promise is
-advice with a receipt; a run it stops is a run that learns to switch it off.
-
-## Phase 1 — preflight, one line
-
-Run `orc pact status --json` with the other preflight probes. Print the `line`
-field VERBATIM:
-
-```
-pact  : 11 holding · 2 drifted · 3 uncheckable
-```
-
-Never re-word it and never compute the counts yourself — one wording, one engine.
-Exit 3 (no ledger) prints:
-
-```
-pact  : none — /orc-pact harvests one from this run's spec_invariants[]
-```
-
-## Phase 2 — planning injection (the payoff)
-
-After the plan exists and before the exit gate:
-
-1. Take every entry whose state is `DRIFTED` or `BROKEN`.
-2. Intersect its `anchors` (file part only) with the union of every task's
-   `declared_files`.
-3. For each hit, append the entry's `statement` VERBATIM to that task's
-   `constraints[]` — the same channel `spec_invariants[]` uses, so no new
-   plumbing and no new slice field.
-4. Print what was injected, per task. An injected constraint the user never saw is
-   a constraint the run cannot be held to.
-
-```
-pact → plan: 1 promise constrains this plan
-  T04 (src/payments/ledger.ts)  PACT-014 DRIFTED
-      "A payment is never written to the ledger twice for one idempotency key."
-```
-
-**HOLDING entries are NOT injected.** Injecting all of them would put the whole
-ledger in every slice, which is how a slice stops being read. The signal is
-"this promise is already in doubt AND you are about to touch it".
-
-## Phase 6 — verify recheck (`pact_recheck_on_verify`, default `true`)
-
-After the verifier returns GREEN, run `orc pact check` **scoped to the promises
-the change touched** — the same intersection as Phase 2, computed against the
-run's actual changed files rather than the plan's declared ones.
-
-- A promise that flips to BROKEN here is a **P1 finding**, not a ship blocker by
-  itself: it is reported with its check output and the user decides. The run broke
-  something it had promised not to; that is worth stopping to look at, and it is
-  not worth an automatic abort on a check the ledger may simply have outgrown.
-- A promise that re-anchors (pass at the new HEAD) prints one line and nothing
-  else. That is the ordinary outcome.
-
-## Ship
-
-If any promise went BROKEN during the run, name it in the summary and offer
-`/orc-pact` to reconcile. Never edit the ledger from the spine.
-
-## The trace verb
-
-`PACT <state> :: <ids>` at the preflight point, and `PACT recheck <pass|fail> ::
-<ids>` at Phase 6. Carried in the phase packet like every other verb — the
-orchestrator hands it to `orc-trace-writer-haiku-4-5`, never writes it directly.
+# Reference — the pact gate inside `/orc` (`pact_gate`)
+
+Loaded by the spine at Phase 1. This is the CONSUMER half: `/orc` reads the
+ledger, it never writes one. Writing is `/orc-pact`'s alone.
+
+`pact_gate: off | warn` — default `warn`. **There is no `block`.** A promise is
+advice with a receipt; a run it stops is a run that learns to switch it off.
+
+## Phase 1 — preflight, one line
+
+Run `orc pact status --json` with the other preflight probes. Print the `line`
+field VERBATIM:
+
+```
+pact  : 11 holding · 2 drifted · 3 uncheckable
+```
+
+Never re-word it and never compute the counts yourself — one wording, one engine.
+Exit 3 (no ledger) prints:
+
+```
+pact  : none — /orc-pact harvests one from this run's spec_invariants[]
+```
+
+## Phase 2 — planning injection (the payoff)
+
+After the plan exists and before the exit gate:
+
+1. Take every entry whose state is `DRIFTED` or `BROKEN`.
+2. Intersect its `anchors` (file part only) with the union of every task's
+   `declared_files`.
+3. For each hit, append the entry's `statement` VERBATIM to that task's
+   `constraints[]` — the same channel `spec_invariants[]` uses, so no new
+   plumbing and no new slice field.
+4. Print what was injected, per task. An injected constraint the user never saw is
+   a constraint the run cannot be held to.
+
+```
+pact → plan: 1 promise constrains this plan
+  T04 (src/payments/ledger.ts)  PACT-014 DRIFTED
+      "A payment is never written to the ledger twice for one idempotency key."
+```
+
+**HOLDING entries are NOT injected.** Injecting all of them would put the whole
+ledger in every slice, which is how a slice stops being read. The signal is
+"this promise is already in doubt AND you are about to touch it".
+
+## Phase 6 — verify recheck (`pact_recheck_on_verify`, default `true`)
+
+After the verifier returns GREEN, run `orc pact check` **scoped to the promises
+the change touched** — the same intersection as Phase 2, computed against the
+run's actual changed files rather than the plan's declared ones.
+
+- A promise that flips to BROKEN here is a **P1 finding**, not a ship blocker by
+  itself: it is reported with its check output and the user decides. The run broke
+  something it had promised not to; that is worth stopping to look at, and it is
+  not worth an automatic abort on a check the ledger may simply have outgrown.
+- A promise that re-anchors (pass at the new HEAD) prints one line and nothing
+  else. That is the ordinary outcome.
+
+## Ship
+
+If any promise went BROKEN during the run, name it in the summary and offer
+`/orc-pact` to reconcile. Never edit the ledger from the spine.
+
+## The trace verb
+
+`PACT <state> :: <ids>` at the preflight point, and `PACT recheck <pass|fail> ::
+<ids>` at Phase 6. Carried in the phase packet like every other verb — the
+orchestrator hands it to `orc-trace-writer-haiku-5-high`, never writes it directly.

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

@@ -54,7 +54,7 @@ Reconciliation is therefore cheap: you only ever override the *soft* half.
 
 1. **Lazy** — the `/orc` dispatch step, on a cache miss (governed by config
    `pattern_findings: ask | on | off`, default `ask`; see `../orc/config.md`).
-2. **Eager** — invoked by `orc-wiki` when `orc_wiki_pattern_findings: on`: codify
+2. **Eager** — invoked by `orc-wiki` when `orc_wiki_pattern_findings: true`: codify
    ALL detected languages as a byproduct of the wiki's full scan (rides under the
    wiki's existing scan-consent — no separate ask).
 3. **Manual** — `/orc-pattern` (all detected langs, or a named one),
@@ -121,8 +121,8 @@ persists nothing. See `../orc/config.md`.
 
 ## Lane contract (`../_shared/lane-contract.md` — read it ONLY when a call exits ≠ 0)
 
-- **Calls:** `orc lane calls orc-pattern --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-pattern --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-pattern --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-poly/SKILL.md

@@ -109,8 +109,8 @@ stops the chat and never falls back to another lane.
   (FRESH/AGING/STALE; the CLI computes it — never by hand).
 - **PEER wiki:** the same call with `--dir <peer>`; then read its
   `wiki/INDEX.md` at the peer path. `state: none` there → treat as no wiki.
-- `WIKI-CONSULT tier=<FRESH|AGING|STALE|none> :: <repo>` on every read (emit
-  even for `none`). `GATE knowledge <repo>=<wiki|ask>` per repo.
+- `WIKI-CONSULT <fresh|aging|stale|absent> :: repo=<repo>` on every read (emit
+  even for `absent`). `GATE knowledge <repo>=<wiki|ask>` per repo.
 
 **Both/all repos have a usable wiki** → read the relevant feature/reference
 pages, and read the **crosslink boundary tags** each repo publishes under its
@@ -206,8 +206,8 @@ builds.
 
 ## Lane contract (`../_shared/lane-contract.md` — read it ONLY when a call exits ≠ 0)
 
-- **Calls:** `orc lane calls orc-poly --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-poly --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-poly --json`. Obey `effective`. Never merge
   `.claude/orc.config.yaml` yourself (`../_shared/config-precedence.md`). Nothing
   here is contested, gated or a stop: no preflight line, no gate to honour.

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

@@ -1,51 +1,51 @@
-# orc-poly — worked example (orient only; never execute from this)
-
-A mock run to show the shape of a poly-repo plan. Values are illustrative.
-
-**Setup.** The user is in `C:\dev\shop-api` (HOST, backend). The change: *add a
-"saved carts" feature* — a new `GET /carts/saved` endpoint (BE) and a new
-"Saved carts" screen (FE) that lists them. They run `/orc-poly` and paste the
-PEER path `C:\dev\shop-web`.
-
-**P0 — Intake.** HOST = `shop-api` (owns the endpoint). PEER = `shop-web` (owns
-the screen, consumes the endpoint). Slug = `saved-carts`.
-
-**P1 — Knowledge gate.**
-- `orc wiki status` in HOST → present, FRESH. `WIKI-CONSULT tier=FRESH ::
-  shop-api`.
-- Reads `C:\dev\shop-web\wiki\wiki-meta.json` directly → AGING.
-  `WIKI-CONSULT tier=AGING :: shop-web`. `GATE knowledge shop-api=wiki
-  shop-web=wiki`.
-- Both have wikis → reads each repo's crosslink boundary tags: shop-web already
-  consumes `GET /carts` from shop-api, so the new endpoint extends a known seam.
-
-**P2 — Recon + gather.** Reads `shop-api/src/routes/carts.ts` and
-`shop-web/src/features/cart/` (read-only). Open questions asked in one batch:
-response pagination? (yes, cursor) · empty state? (FE shows "No saved carts")
-· auth? (same bearer token as `/carts`) · does `saved` reuse the `Cart` type?
-(yes, plus a `savedAt` field). All pinned.
-
-**P3 — Doc set** written to `shop-api/poly-repo-implementation/saved-carts/`:
-- `poly-context.md` — the change, both repos' roles + touch points, decisions.
-- `interface-contract.md` — froze `GET /carts/saved`: request (bearer,
-  `?cursor`), response (`{ items: Cart[] & { savedAt }, nextCursor }`), `401`
-  unauth, `200` empty → `{ items: [], nextCursor: null }`. Additive, no
-  breaking change.
-- `poly-spec.md` — `orc-poly:spec v1`, `repos[]` = shop-api (host, R1: add the
-  endpoint) + shop-web (peer, R2: add the screen), each `contract_ref` pointing
-  at the frozen response shape.
-
-**P4 — Iterate.** User picks **1) Pass to orc-plan**.
-
-**P5 — Split.** `DISPATCH orc-planner :: poly saved-carts`. The planner emits:
-- `shop-api/poly-repo-implementation/saved-carts/shop-api-implementation-plan.md`
-- `shop-web/poly-repo-implementation/saved-carts/shop-web-implementation-plan.md`
-  (written INTO the peer — the only peer write)
-
-both embedding the frozen `interface-contract.md`. `VERIFY planner
-actual=opus-5/medium ✅ MATCH`. `FINISH`.
-
-**Handoff.** orc-poly tells the user: open `shop-api` and run `/orc` on its
-plan; separately open `shop-web` in a fresh session and run `/orc` on its plan.
-Both plans pin the same contract, so the FE screen and the BE endpoint fit on
-the first try. orc-poly built nothing itself.
+# orc-poly — worked example (orient only; never execute from this)
+
+A mock run to show the shape of a poly-repo plan. Values are illustrative.
+
+**Setup.** The user is in `C:\dev\shop-api` (HOST, backend). The change: *add a
+"saved carts" feature* — a new `GET /carts/saved` endpoint (BE) and a new
+"Saved carts" screen (FE) that lists them. They run `/orc-poly` and paste the
+PEER path `C:\dev\shop-web`.
+
+**P0 — Intake.** HOST = `shop-api` (owns the endpoint). PEER = `shop-web` (owns
+the screen, consumes the endpoint). Slug = `saved-carts`.
+
+**P1 — Knowledge gate.**
+- `orc wiki status` in HOST → present, FRESH. `WIKI-CONSULT fresh ::
+  repo=shop-api`.
+- Reads `C:\dev\shop-web\wiki\wiki-meta.json` directly → AGING.
+  `WIKI-CONSULT aging :: repo=shop-web`. `GATE knowledge shop-api=wiki
+  shop-web=wiki`.
+- Both have wikis → reads each repo's crosslink boundary tags: shop-web already
+  consumes `GET /carts` from shop-api, so the new endpoint extends a known seam.
+
+**P2 — Recon + gather.** Reads `shop-api/src/routes/carts.ts` and
+`shop-web/src/features/cart/` (read-only). Open questions asked in one batch:
+response pagination? (yes, cursor) · empty state? (FE shows "No saved carts")
+· auth? (same bearer token as `/carts`) · does `saved` reuse the `Cart` type?
+(yes, plus a `savedAt` field). All pinned.
+
+**P3 — Doc set** written to `shop-api/poly-repo-implementation/saved-carts/`:
+- `poly-context.md` — the change, both repos' roles + touch points, decisions.
+- `interface-contract.md` — froze `GET /carts/saved`: request (bearer,
+  `?cursor`), response (`{ items: Cart[] & { savedAt }, nextCursor }`), `401`
+  unauth, `200` empty → `{ items: [], nextCursor: null }`. Additive, no
+  breaking change.
+- `poly-spec.md` — `orc-poly:spec v1`, `repos[]` = shop-api (host, R1: add the
+  endpoint) + shop-web (peer, R2: add the screen), each `contract_ref` pointing
+  at the frozen response shape.
+
+**P4 — Iterate.** User picks **1) Pass to orc-plan**.
+
+**P5 — Split.** `DISPATCH orc-planner :: poly saved-carts`. The planner emits:
+- `shop-api/poly-repo-implementation/saved-carts/shop-api-implementation-plan.md`
+- `shop-web/poly-repo-implementation/saved-carts/shop-web-implementation-plan.md`
+  (written INTO the peer — the only peer write)
+
+both embedding the frozen `interface-contract.md`. `VERIFY planner
+actual=opus-5/medium ✅ MATCH`. `FINISH`.
+
+**Handoff.** orc-poly tells the user: open `shop-api` and run `/orc` on its
+plan; separately open `shop-web` in a fresh session and run `/orc` on its plan.
+Both plans pin the same contract, so the FE screen and the BE endpoint fit on
+the first try. orc-poly built nothing itself.

package/templates/skills/orc-pr-driver/SKILL.md

@@ -85,7 +85,8 @@ without the manifest (`../_shared/lane-contract.md` §Phases).
 The change already exists in the worktree, so **preserve it before touching
 branches** — `references/orc-run-split.md` is the exact procedure: commit the
 whole change to a scratch snapshot branch, verify the snapshot contains every
-changed path from `git status --short`, and only then move to the trunk. Every
+changed path from `git status --short`, and only then move to the trunk, which
+must be an ancestor of the snapshot. Every
 layer is later materialized with `git checkout <snapshot> -- <that layer's
 files>`; deletions are applied as `git rm`. The snapshot branch stays until the
 last layer merges — it is the undo button.
@@ -169,8 +170,8 @@ answers verbatim).
 
 ## Lane contract (`../_shared/lane-contract.md` — read it ONLY when a call exits ≠ 0)
 
-- **Calls:** `orc lane calls orc-pr-driver --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-pr-driver --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-pr-driver --json`. Obey `effective`. Never merge
   `.claude/orc.config.yaml` yourself (`../_shared/config-precedence.md`). Nothing
   here is contested, gated or a stop: no preflight line, no gate to honour.