@azure-id/orc 1.9.2 → 2.1.0

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

@@ -11,10 +11,10 @@ description: >
 # ORC-MINI
 
 A trimmed orchestrator for when you want speed over the full quality pipeline.
-Everything in the main spine (`../orc/SKILL.md`) applies EXCEPT the differences
-below. Load its references and schemas by path — the HOT-PATH essentials
-(dispatch names, return-contract fields, artifact path) are inlined here so
-nothing is reconstructed from "full minus deltas."
+The full lane's behaviour applies EXCEPT the differences below. **Never load
+`../orc/SKILL.md`** — this spine is self-contained. Load the shared phase files
+and schemas it names, by path; the HOT-PATH essentials (dispatch names,
+return-contract fields, artifact path) are inlined here.
 
 Run as **Opus 4.8 high**, or Opus 5.5 / Fable 5 at medium+ (as full; never downgrade).
 **You never implement — you spawn.** The one exception is the **smoke gate**: a
@@ -30,7 +30,7 @@ read-only build+test run, not implementation — you still never write code.
    scoring table** — a **one-line complexity read** replaces it (mini-ok? or
    recommend switching to full); log that line, never render the matrix.
 3. **No dispatch-style and no batch-pause questions** — one subagent makes both
-   meaningless; never ask them.
+   meaningless.
 4. **Lighter intake.** Only the **Always + medium tier** (Q1–Q4 in
    `../_shared/phases/intake.md`); no high tier (Q5/Q6). Step 3.5 runs at
    NAMES-ONLY depth: confirm the names the draft cites with ONE `orc graph ctx
@@ -41,12 +41,13 @@ read-only build+test run, not implementation — you still never write code.
 5. **Still write tests** when the project has a test setup (the executor does it
    inside its task).
 6. **Everything else is identical:** run folder + intent-spec, planning,
-   checkpoint, stop sequence, usage reminder, ship flow.
+   checkpoint, stop sequence (H `any.stop.where`), usage reminder, ship flow.
 
 ## Mini flow (the phase set)
 
 ```
 Phase 0  intake (Q1–Q4, soft sign-off) + run folder + intent-spec
+         · `habits{}` in lane config → print `habits.line`, read ../_shared/habits.md
 Phase 1  planning (dispatch orc-planner-mini; analyst first only on real docs)
          → one-line complexity read (mini-ok? or recommend switch-to-full)
 Phase 3  dispatch ONE executor (orc-executor-sonnet-5-high) — slice carries the
@@ -56,9 +57,8 @@ Phase 3  dispatch ONE executor (orc-executor-sonnet-5-high) — slice carries th
 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)
-Phase 8  ship (commit / push / PR — never stages mock-examples/)
+Phase 8  ship (commit / push / PR — never stages mock-examples/) (H `mini.phase-8.ship`)
 ```
-(No Phase 2 scoring table, no dispatch-style/batch-pause asks, no full review/verify/summary.)
 **Postgres query grounding.** Data-access task on a Postgres project → probe
 `orc pattern status postgres` (`../_shared/detecting-artifacts.md`, never an
 ad-hoc `find`). HIT → inject the pattern LITERALLY into the slice (conventions +
@@ -78,67 +78,57 @@ Never skipped. Every call carries `--if-enabled`: exit 3 = off → print `graph:
 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 ship summary. It is an estimate with a range; never restate it as a saving.
+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.
 
 ## Phase M — Smoke gate (build + test; blocks ship on red)
 
-After the executor return validates (`../_shared/return-validation.md` — including `done` with non-empty `unmet[]` = partial, and §6's worktree delta: a path changed outside `declared_files` is a violation whatever the return said), YOU run the smoke gate
+After the executor return validates (`../_shared/return-validation.md` §1–§3 + each injected field's §; `done` + non-empty `unmet[]` = partial; §6's worktree delta: a path outside `declared_files` is a violation whatever the return said), YOU run the smoke gate
 per `../_shared/smoke-gate.md`: read-only build+test, with **the affected tests
 FIRST** (code-graph step 5; a runner that takes no file list → one line saying
-so), then build and suite once each, then the blast radius from the same
-`changes` answer, `risk` never without its `why`:
-`blast radius   2 symbols touched · callers 3 in 2 files · tests reach 2 · risk medium: <symbol> (fan-in 3, no test reaches it)`.
+so), then build and suite once each, then the `blast_line`, `risk` never without its `why`.
 **GREEN** → code-graph step 6 → test-authoring ask, then ship. **RED** → never
-offer commit/ship; one repair re-dispatch, second red → STOP and surface.
+offer commit/ship; the flaky check, then one repair re-dispatch, second red → STOP and surface.
 Docs-only → gate N/A, say so. `orc run inflight` FIRST — exit 2 REFUSES, because
 `a lane that re-dispatches over a live attempt` has broken the contract
-(`../_shared/return-validation.md` §0). **A `risk: high` row adds ONE option,
-never a phase:** an exported symbol with fan-in 3+ that no test reaches adds one
+(`return-validation.md` §0). **A `risk: high` row adds ONE option,
+never a phase** (H `mini.phase-m.risk-high`): an exported symbol with fan-in 3+ that no test reaches adds one
 option to the EXISTING end-of-run batch (mock example · test authoring · ship)
-— *a. dispatch `orc-reviewer-opus-5-med` on the diff (P0/P1 block the commit
+— *a. dispatch `orc-reviewer-opus-5-low` with `../_shared/review-slice.md`* (H `any.ship.review-before-push`) *(P0/P1 block the commit
 offer once) · b. write a test in Phase T · c. ship anyway*. No new user turn;
 mini still skips full review.
 
 ## Phase X — Mock example + drift recovery (config `mock_example`, default ask)
 
-Canonical: `../_shared/drift-recovery.md` — load it when the phase fires. After
-a GREEN Phase M, before ship: `ask` → MANDATORY offer (never silently
-skipped/run) · `on` → build · `off` → skip. Deliverable
-`mock-examples/<change-slug>/` at project root — **never committed, never
-staged**. Drift → `DRIFT-FROM` handoff, hard cap 2 loops, then an honest
-unresolved report. Trace: `PHASE mock-example`, `DRIFT loop=<n>`.
+After a GREEN Phase M, before ship (H `mini.phase-x.mock`): follow `../_shared/drift-recovery.md` (load it
+when the phase fires) — the `mock-examples/<change-slug>/` deliverable, the
+`DRIFT-FROM` loop and its cap. Trace: `PHASE mock-example`, `DRIFT loop=<n>`.
 
 ## Phase T — Test-authoring ask (opt-in; writes tests, never runs them)
 
 Same opt-in as full Phase 6.5 — mini **only asks** (never gates the ship).
 Default from `config.generate_tests`; at the end of a GREEN run ask whether to
-author test cases (files + TEST-PLAN.md + a curl bundle for HTTP APIs), saying
+author test cases (H `mini.phase-t.testgen`; files + TEST-PLAN.md + a curl bundle for HTTP APIs), saying
 they are never run. Yes → dispatch `orc-test-author-opus-5-med` (subskill
-`../orc/subskills/orc-testgen/`) with `actual_files`, the definition-of-done,
-touched flows, constraints and stack; the manual deliverables land in
-**`test-generator/<change-slug>/` at the project root**. Validate that the
-returned `test_plan_path`/`curl_bundle_path` sit under that folder (else
-malformed → re-dispatch) and state the exact path. No → ship; either way this
-NEVER runs tests.
+`../orc/subskills/orc-testgen/`) exactly as `../_shared/phases/testgen.md` (`full`
+layer) says: the deliverables land in **`test-generator/<change-slug>/` at the
+project root**, the returned paths are validated, and you state the exact path.
+No → ship; either way this NEVER runs tests. Every end — ship or a red
+STOP — prints the card (`../_shared/phases/summary.md` §End-of-run card).
 
 ## Behavior trace (always on)
 
-`../_shared/phases/trace.md` (`core`, at run start; `orc lane phases` names the
-file and the layers). Lane token `mini`, tier **Build lanes** — per phase,
-batched to **3 packets** (intake+plan · execution · ship), each paired with the
-next phase's first dispatch. At run start write `log_dir/.current` =
-`run-mini-<slug>-<DDMMYY>-<HHMMSS>.txt` AND `touch the trace file` of that name
-in the SAME step. Nothing else about the protocol is restated here; a phase that
-ends with `zero new trace lines is a protocol violation`. Mini does NOT drop the
-trace. `OUTCOME … band=mini` per task.
+`../_shared/phases/trace.md` (`core`, at run start; `orc lane phases orc-mini --json` →
+`trace_grammar` gives the verbs). Lane token `mini`, tier
+**Build lanes** — batched to **3 packets** (intake+plan · execution ·
+ship). At run start: `.current` = `run-mini-<slug>-…` AND `touch the trace file`, SAME step. Pipe each packet to `orc trace write --packet -`. A phase that ends with `zero new trace lines is a protocol violation`.
+Mini does NOT drop the trace. `OUTCOME … band=mini` per task.
 
 ## Complexity read (replaces the scoring table) — `references/complexity.md`
 
 ONE line before dispatch, carrying its own NUMBERS. **The CLI computes it** —
-`complexity.line` from the Phase 1 call, printed VERBATIM. The four thresholds,
-the `(graph off)` form and why each number is that number: `references/complexity.md`.
-`complexity: mini-ok — 3 files · confident callers 4 in 2 files · tests reach 2 · risk none · cochange none`
-It is an OFFER: *1. switch to /orc (recommended — <the reason>) · 2. continue in
+`complexity.line` from the Phase 1 call, printed VERBATIM. Thresholds, the
+`(graph off)` form and their reasons: that reference.
+It is an OFFER (H `mini.phase-1.complexity`): *1. switch to /orc (recommended — <the reason>) · 2. continue in
 mini*. Continuing writes the NUMBERS into the decision log, so `/orc-retro` can
 move a threshold instead of anyone arguing about it. Trace: `GATE complexity :: <the line>`.
 
@@ -160,51 +150,31 @@ mini skipped. Record the switch in the decision log.
 
 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`).
 
-**Extra (`extra_enabled`, `../_shared/extra-dispatch.md`):** mini's ONE executor may run off Claude. It has no score, so resolve the pinned executor's **BAND, both edges, and require them to agree** — a partially covering row keeps the run 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`); dispatch via `orc extra dispatch --task <file> --json` with the IDENTICAL slice; validate with `return-validation.md` **§2b, not §2** (⛔ SUBSTITUTION replaces the downgrade check); a failure runs `orc extra reconcile <task_id>` FIRST — a worktree that moved is RESUMED, never re-done — then falls back to the pinned Claude agent, announced. A cited-risk change never leaves Claude (`extra_risk_tasks`, default `off`) — and mini's complexity read is not a substitute for 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 — the complexity read never replaces that gate.
 
 | Role | Agent (dispatch this) | Model / effort | When `opus5_only` |
 |------|-----------------------|----------------|-------------------|
-| mini analysis (docs only) | `orc-analyze-mini-sonnet-5-high` | claude-sonnet-5 / high | `orc-analyze-mini-opus-5-med` |
-| mini planning | `orc-planner-mini-sonnet-5-high` | claude-sonnet-5 / high | `orc-planner-mini-opus-5-med` |
-| mini execution | `orc-executor-sonnet-5-high` | claude-sonnet-5 / high | `orc-executor-opus-5-low` |
+| mini analysis (docs only) | `orc-analyze-mini-sonnet-5-high` | claude-sonnet-5-5 / high | `orc-analyze-mini-opus-5-med` |
+| mini planning | `orc-planner-mini-sonnet-5-high` | claude-sonnet-5-5 / high | `orc-planner-mini-opus-5-med` |
+| mini execution | `orc-executor-sonnet-5-high` | claude-sonnet-5-5 / high | `orc-executor-opus-5-low` |
 | test authoring (opt-in) | `orc-test-author-opus-5-med` | claude-opus-5-5 / medium | unchanged |
 
-## Config
-
-**ONE resolver, and it is not you:** `orc lane config orc-mini --json`. Obey
-`effective`, print every line in `announce[]` VERBATIM at preflight, and honour
-`stops[]` before wave 1. Never re-derive a value, a precedence or an inertness
-from `.claude/orc.config.yaml` — a key this lane does not read is not in the
-answer, and a key another key shadows comes back already marked. Exit ≠ 0 → say
-the CLI is unavailable and fall back to `../_shared/config-precedence.md`'s
-documented defaults, out loud. Priorities and families:
-`../_shared/config-precedence.md`. Wave, scoring and scout keys never apply to
-mini and are not in the answer, so there is nothing to render or ask.
-
-## Rules — the anti-slop card (`../_shared/phases/rules.md`)
-
-`orc rules slice --lane orc-mini --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[]`.
-## Calls
-
-**ONE catalogue, and it is not you:** `orc lane calls orc-mini --json` names every
-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.
-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.
+## 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.
+- **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`).
+- **Rules:** `orc rules slice --lane orc-mini --json` is the ONLY assembler
+  (`../_shared/phases/rules.md`). Its `line` prints VERBATIM at preflight.
 
 ## TDD (ONE intake question — mini's whole TDD policy)
 
-At intake ask once:
+At intake ask once (H `mini.intake.tdd`):
 *"Anchor this in plan-time acceptance tests (TDD — red tests first, implement
 to green)? [yes/no]"*. Yes → the planner slice carries `tdd: on` (the mini
-planner authors `tdd_spec` per requirement, **scoped by the same `disposition` set the full lane uses** — `new-surface | behavior-change | covered-by-existing | no-behavior | no-runner`, derived from the `facets`, same safety floor: a cited `risk[]` is never scoped out, so a constant or a translation string gets no test but an auth change always does). Mini keeps its SINGLE executor — no paired TDD task; that executor materializes the failing tests FIRST, then implements to green
+planner authors `tdd_spec` per requirement, **scoped by the full lane's `disposition` set** — `new-surface | behavior-change | covered-by-existing | no-behavior | no-runner`, from the `facets`; a cited `risk[]` is never scoped out). Mini keeps its SINGLE executor — no paired TDD task; that executor materializes the failing tests FIRST, then implements to green
 (implement→test→repair, cap `tdd_loop_max`; emit `TDD-RED`/`TDD-GREEN` per
 iteration; cap hit → STOP + honest red report), and Phase M's smoke gate runs
 the TDD suite as part of build+test. Scoped-out requirements are named with their
@@ -215,9 +185,8 @@ reason at preflight — never silent. No → skip entirely; never re-ask.
 orc-mini dispatches the FAST variants (Sonnet 5 high): `orc-analyze-mini` and
 `orc-planner-mini`. The mini analyst is **doc-optional**: on real doc input it
 runs first, then the mini planner; on a merely ambiguous request, prefer one
-inline clarifying question over a cold analyst spawn. Always single-pass — **no
-deep mode, no scouts**; it escalates to `/orc-analyze` deep on its concrete
-thresholds and the user chooses. You never analyze or plan yourself.
+inline clarifying question over a cold analyst spawn (single-pass, its own
+escalation thresholds). You never analyze or plan yourself.
 
 **The planner slice carries `graph_facts`** — `map`, `impact`, `cochange` and
 the `generation`, or `null` when the graph is off (shape:
@@ -231,45 +200,28 @@ mini-analyst return: evidence spot-check + derivation lint; refuse
 take-into-build on open `UNVERIFIED`/missing `scope_closed`; `git_head` ≠
 HEAD at plan time → re-run the spot-check first. On mini-planner return: confirm
 every `disposition: exists` path with `orc graph ctx <paths> --if-enabled
---json --brief`, FIVE at a time — exit 0 confirms, exit 4 or an unindexed path falls
+--json --brief`, FIVE at a time — exit 4 or an unindexed path falls
 back to a Glob. Then recompute coverage (no orphan requirements), cycle +
 collision checks. Any miss → bounce (one retry, then escalate). At dispatch,
 append the task's `spec_invariants` to the slice's `constraints[]` verbatim.
 
 ## Wiki consult (if present)
 
-Same rule as the full skill — load `../_shared/phases/wiki-consult.md` at the
-planning/complexity-read step: compute the FRESH / `AGING` / STALE tier from
-`.claude/orc/wiki-meta.json` and `orc wiki status --json`, then **select PATHS,
-never bodies**. From `wiki/INDEX.md` pick 1–3 page paths by keyword
-(cross-cutting maps like `orc-reference-api-surface` when their domain applies)
-and put the PATHS in the planner and executor slices with *"Read these first:
-the TL;DR for orientation, `Contracts & shapes` for specifics"* plus
-`code > fresh wiki > stale wiki (hints) > model priors`. **You never read a page
-body into your own context.** **Emit `WIKI-CONSULT <tier> :: docs=<paths>`**. Crosslink: a task touching a
-boundary in `.claude/orc/crosslink/needs.json` gets the cached contract injected
-per that reference — advisory, never blocking. Mini never generates the wiki;
-after a code-changing run apply the passive stale-flag note only.
-
-**`none` is an answer — record it, never drop it.** `wiki_used: none` and
-`graph_used: none` from ANY return go into the checkpoint and the ship line
-(`knowledge: wiki 2 pages offered · used none · graph card 2 targets · used
-none`). Two runs in a row with `wiki_used: none` on FRESH pages → one line:
-`wiki: the selected pages were not used in 2 runs — check their TL;DRs
-(/orc-wiki)`. A signal, never a gate, never dropped for looking null.
-
-## Shared artifacts, and what mini still enforces
-
-Mini writes to the SAME location as the full skill (`.claude/orc/run/`
-`{run-slug}/`), so a switch needs no migration. From the main hard rules: never
-implement yourself (the smoke gate is read-only) · every RUN-STATE artifact in
-the run subfolder, never the project root (the one exception is the opt-in
-`test-generator/<change-slug>/` deliverable, at the project root by design) ·
-validate every subagent return (malformed = failure) · report the dispatch log
-and remind the user to run `/usage` (never yourself) · **never offer commit on a
-red build** (Phase M enforces it).
+Load `../_shared/phases/wiki-consult.md` at the planning/complexity-read step. It
+owns the tier (`orc wiki status --json` → `.tier`), the ladder
+`code > fresh wiki > stale wiki (hints) > model priors`, the lane delta
+(select PATHS, never bodies: 1–3 from `wiki/INDEX.md`), `WIKI-CONSULT`, the crosslink injection,
+the passive stale-flag and `wiki_used: none` / `graph_used: none` (§Step 5, the mini paragraph).
+**You never read a page body into your own context.** Mini never generates the wiki.
+
+## Shared artifacts
+
+All RUN STATE stays in `.claude/orc/run/{run-slug}/` (as full, so a switch needs no migration), never the project root —
+only the opt-in `test-generator/<change-slug>/` and `mock-examples/`
+deliverables sit there. Report the dispatch log and remind the user to run
+`/usage` (never yourself).
 
 ## Waiting mid-run (`/orc-wait`)
 
 Canonical: `../_shared/wait.md`. **`a lane that waits without a hand-back` has broken this contract.**
-Checkpoint **full** · safe point **after the executor returns**. `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.
+Checkpoint **full** · safe point **after the executor returns**.

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

@@ -31,10 +31,10 @@ O: GATE complexity :: complexity: mini-ok — 2 files · confident callers 1 in
 
 ## Phase 3 — Execute (ONE subagent)
 O: graph: --for-slice card (2 files) · wiki: 1 path (pointer, body never read here)
-O: → claude-sonnet-5 / high :: DISPATCH orc-executor-sonnet-5-high :: add --json flag
+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/high ✅ MATCH · evidence present ✓
+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)
@@ -60,5 +60,7 @@ O: Self-QA plan: test-generator/report-json-flag/TEST-PLAN.md (committed on ship
 O: Current branch: feat/report-json. Commit? Push? PR?
 U: commit
 O: knowledge: wiki 1 page offered · used tests/test_report.py note · graph used 1 target
+   (risk none → no review option, so no `orc gotcha observe` call. A risk-high run
+   that took option a records each finding with it, `run` included.)
 O: [commits] Done. Usage: dispatch log below + run /usage for your limits.
    (Switch to full flow any time — the run folder + checkpoint are shared.)

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

@@ -1,16 +1,13 @@
 ---
 name: orc-pattern
 description: >
-  Learn and cache a project's real code conventions per language so ORC executors
-  write code that MATCHES the existing codebase instead of a generic template.
-  Use for "/orc-pattern", "learn my code pattern", "codify conventions", or when
-  ORC detects frontend/backend work with no cached pattern. Reconciles a generic
-  best-practice playbook against the project's actual most-recently-modified files:
-  the project's CONVENTIONS win, security/correctness INVARIANTS are always kept,
-  conflicts are flagged. Writes .claude/orc/patterns/<lang>-pattern.md, reused by
-  every future run. EXPENSIVE scan → consent-gated inside /orc (config
-  pattern_findings), always allowed on explicit /orc-pattern. The orchestrator
-  dispatches the codifier subagent — it never codifies itself.
+  Learn and cache a project's real code conventions per language, so ORC
+  executors write code that MATCHES the existing codebase. Use for
+  "/orc-pattern", "learn my code pattern", "codify conventions", or when ORC
+  detects frontend/backend work with no cached pattern. The project's
+  CONVENTIONS win; security/correctness INVARIANTS are always kept. Writes
+  .claude/orc/patterns/<lang>-pattern.md. EXPENSIVE scan: consent-gated inside
+  /orc.
 ---
 
 # ORC-PATTERN (code-pattern codifier)
@@ -65,21 +62,17 @@ Reconciliation is therefore cheap: you only ever override the *soft* half.
 
 ## Behavior trace (always on)
 
-`../_shared/phases/trace.md` (`core`, at run start; `orc lane phases` names
-the file and the layers). Lane token `pattern`, tier **Single-dispatch** —
-exactly ONE end-of-run packet, dispatched solo before `.current` is deleted.
-At run start write `log_dir/.current` = `run-pattern-<slug>-<DDMMYY>-<HHMMSS>.txt` AND
-`touch the trace file` of that name in the SAME step.
-Nothing else about the protocol is restated here; a phase that ends with
-`zero new trace lines is a protocol violation`.
+`../_shared/phases/trace.md` (`core`, at run start; `orc lane phases orc-pattern --json` →
+`trace_grammar` gives the verbs). Lane token `pattern`, tier
+**Single-dispatch**. At run start write `log_dir/.current` =
+`run-pattern-<slug>-<DDMMYY>-<HHMMSS>.txt` AND `touch the trace file` of that name
+in the SAME step. A phase that ends with `zero new trace lines is a protocol violation`.
 
 ## Phases
 
-`orc lane phases orc-pattern --json` is this lane's pipeline: the ordered list, where
-each phase lives, and how much of it to read. **The CLI owns the order** — never
-derive it from the headings below, and never renumber or rename one without the
-manifest, because a `read: section` pointer names a HEADING and a renamed heading
-is a pointer into nothing.
+`orc lane phases orc-pattern --json` is this lane's pipeline. **The CLI owns the order**:
+never derive it from the headings below, and never rename or renumber one
+without the manifest (`../_shared/lane-contract.md` §Phases).
 
 ## Phase 0 — Entry & auto-branch (on /orc-pattern)
 
@@ -126,29 +119,15 @@ the executor applies the playbook **invariants** (still blocking) and imitates t
 1–2 neighboring files it already reads for its slice. Cheap by construction,
 persists nothing. See `../orc/config.md`.
 
-## Config
-
-**ONE resolver, and it is not you:** `orc lane config orc-pattern --json`. Obey
-`effective`, print every line in `announce[]` VERBATIM at preflight, and honour
-`stops[]` before wave 1. Never re-derive a value, a precedence or an inertness
-from `.claude/orc.config.yaml` — a key this lane does not read is not in the
-answer, and a key another key shadows comes back already marked. Exit ≠ 0 → say
-the CLI is unavailable and fall back to `../_shared/config-precedence.md`'s
-documented defaults, out loud. Priorities and families:
-`../_shared/config-precedence.md`.
-
-## Calls
-
-**ONE catalogue, and it is not you:** `orc lane calls orc-pattern --json` names every
-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.
-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.
-
-## 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 **single dispatch**. 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.
+## 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.
+- **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`).
+
+## 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 **single dispatch**.

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

@@ -1,20 +1,12 @@
 ---
 name: orc-poly
 description: >
-  Poly-repo planning lane — plan ONE change that spans two or more repos
-  (BE endpoint + FE UI, service + its gRPC consumer, etc.) without drift. Use
-  for "/orc-poly", "plan this across both repos", "coordinate a change over
-  these repos". Runs in the HOST repo (where you are); you paste the path of
-  each PEER repo. It peeks at every repo's wiki + crosslink (read-only) — or,
-  when a wiki is missing, asks you which folders/files to dig — gathers the
-  cross-repo context by asking questions until intent is pinned, then writes
-  a source-of-truth doc set (poly-context.md, interface-contract.md,
-  poly-spec.md) into poly-repo-implementation/<slug>/. Each iteration offers:
-  pass to orc-plan (splits ONE plan per repo, each written into its repo,
-  all pinned to the frozen interface contract) · stop & chat · add more
-  context. PEER source is READ-ONLY; the only peer write is the handoff plan.
-  It never builds — it plans the split so each repo's later /orc run stays on
-  contract.
+  Poly-repo planning lane — plan ONE change that spans two or more repos (BE
+  endpoint + FE UI, a service + its gRPC consumer) without drift. Use for
+  "/orc-poly", "plan this across both repos", "coordinate a change over these
+  repos". Runs in the HOST repo; you paste each PEER repo path. Writes the doc
+  set into poly-repo-implementation/<slug>/ and can split ONE plan per repo.
+  PEER source is READ-ONLY. It never builds.
 ---
 
 # ORC-POLY (poly-repo planning)
@@ -61,21 +53,17 @@ conflict, HOST wins — the same rule extended across the repository boundary.
 
 ## Behavior trace (always on)
 
-`../_shared/phases/trace.md` (`core`, at run start; `orc lane phases` names
-the file and the layers). Lane token `poly`, tier **Single-dispatch** —
-exactly ONE end-of-run packet, dispatched solo before `.current` is deleted.
-At run start write `log_dir/.current` = `run-poly-<slug>-<DDMMYY>-<HHMMSS>.txt` AND
-`touch the trace file` of that name in the SAME step.
-Nothing else about the protocol is restated here; a phase that ends with
-`zero new trace lines is a protocol violation`.
+`../_shared/phases/trace.md` (`core`, at run start; `orc lane phases orc-poly --json` →
+`trace_grammar` gives the verbs). Lane token `poly`, tier
+**Single-dispatch**. At run start write `log_dir/.current` =
+`run-poly-<slug>-<DDMMYY>-<HHMMSS>.txt` AND `touch the trace file` of that name
+in the SAME step. A phase that ends with `zero new trace lines is a protocol violation`.
 
 ## Phases
 
-`orc lane phases orc-poly --json` is this lane's pipeline: the ordered list, where
-each phase lives, and how much of it to read. **The CLI owns the order** — never
-derive it from the headings below, and never renumber or rename one without the
-manifest, because a `read: section` pointer names a HEADING and a renamed heading
-is a pointer into nothing.
+`orc lane phases orc-poly --json` is this lane's pipeline. **The CLI owns the order**:
+never derive it from the headings below, and never rename or renumber one
+without the manifest (`../_shared/lane-contract.md` §Phases).
 
 ## Phase P0 — Intake (identify HOST + PEERs + the change)
 
@@ -117,11 +105,10 @@ stops the chat and never falls back to another lane.
 
 - **HOST wiki:** probe existence with `orc wiki status` — the deterministic CLI
   in `../_shared/detecting-artifacts.md`, never an ad-hoc `find` (`.claude` is
-  hidden). Present → compute the tier from `.claude/orc/wiki-meta.json` per
-  `../orc-wiki/references/staleness.md` (FRESH/AGING/STALE).
-- **PEER wiki:** the `orc` CLI is CWD-scoped, so for a peer at another path read
-  its `wiki/INDEX.md` + `wiki-meta.json` **directly at the peer path** (compute
-  the tier the same way). Absent there → treat as no wiki.
+  hidden). Present → read the tier from `orc wiki status --json` → `.tier`
+  (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.
 
@@ -217,33 +204,17 @@ builds.
 - Reminder: to see usage limits, tell the user to run `/usage` (never invoke it
   programmatically).
 
-## Config
-
-Resolve with `orc lane config orc-poly --json` and obey `effective`. Never merge
-`.claude/orc.config.yaml` yourself, and never re-derive a precedence. Exit ≠ 0 →
-say so and use `../_shared/config-precedence.md`'s documented defaults, out
-loud. Nothing this lane reads is contested, gated or a stop, so it owes no
-preflight line and has no gate to honour.
-
-## Calls
-
-**ONE catalogue, and it is not you:** `orc lane calls orc-poly --json` names every
-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.
-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-poly --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 **docset** · safe point **after a per-repo plan is written**. `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.
+## 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.
+- **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.
+- **Rules:** `orc rules slice --lane orc-poly --json` is the ONLY assembler
+  (`../_shared/phases/rules.md`). Its `line` prints VERBATIM at preflight.
+
+## Waiting mid-run (`/orc-wait`)
+
+Canonical: `../_shared/wait.md`. **`a lane that waits without a hand-back` has broken this contract.**
+Checkpoint **docset** · safe point **after a per-repo plan is written**.