@azure-id/orc 1.9.2 → 2.1.0

package/templates/skills/orc-analyze/schemas/report-audit.md

@@ -1,7 +1,8 @@
 # Template — Analyst Report (AUDIT mode)
 
 Human-readable source of truth. You review and confirm this; the machine spec
-is derived from it. Written to analyst_report/{analysis-name}/report.md.
+is derived from it. Written to `<analyzer_dir>/{analysis-name}/report.md`;
+COPIED to `<report_out_dir>/{analysis-name}/` only on the stop-here branch.
 
 ```markdown
 # Analysis Report — {analysis-name}

package/templates/skills/orc-analyze/schemas/report-prose.md

@@ -1,6 +1,7 @@
 # Template — Analyst Report (PROSE mode)
 
-Human-readable source of truth. Written to analyst_report/{analysis-name}/report.md.
+Human-readable source of truth. Written to `<analyzer_dir>/{analysis-name}/report.md`;
+COPIED to `<report_out_dir>/{analysis-name}/` only on the stop-here branch.
 
 ```markdown
 # Analysis Report — {analysis-name}

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

@@ -1,19 +1,12 @@
 ---
 name: orc-analyze-mini
 description: >
-  Fast-lane System Analyst for ORC-MINI (Sonnet 5, high effort). Turns a
-  requirement — a document (PDF by path or pasted) OR a plain-language request —
-  into a scope-bounded, code-grounded requirement report + derived spec: bounds
-  the deliverable to exactly the asked scope (other scopes never become tasks),
-  maps each requirement to real files with quote-anchored file:line evidence —
-  or marks it an ASSUMPTION and turns it into a question — and challenges the
-  user with recommended options. Use for "/orc-analyze-mini", "quickly analyze
-  this doc", "fast doc analysis", "quick requirement check", "fast requirement
-  analysis", or when orc-mini meets a document or an ambiguous requirement.
-  Distinct from /orc-analyze: ALWAYS single-pass — NO deep mode, NO scouts —
-  trading depth for speed and tokens; switch to /orc-analyze (deep) when you
-  need a wider code sweep, verify-every-claim, or alternatives with trade-offs.
-  The orchestrator dispatches this to a subagent — it never analyzes itself.
+  Fast-lane System Analyst for ORC-MINI (Sonnet 5, high effort). Use for
+  "/orc-analyze-mini", "quickly analyze this doc", "fast doc analysis", "quick
+  requirement check", "fast requirement analysis", or when orc-mini meets a
+  document or an ambiguous requirement. Writes a scope-bounded requirement
+  report with file:line evidence. ALWAYS single-pass — NO deep mode, NO scouts;
+  use /orc-analyze for depth.
 ---
 
 # ORC-ANALYZE-MINI
@@ -39,48 +32,37 @@ for the formats; this skill does not duplicate them.
   silently dropped.
 - **No deep mode, no scouts.** Always single-pass.
 - **Concrete escalation thresholds** (recommend the full `/orc-analyze`, Opus
-  4.8 high, and let the user choose — the boundary is not self-assessed vibes):
+  5.5 high, and let the user choose — the boundary is not self-assessed vibes):
   source doc > ~10 pages, OR > 12 in-scope requirements, OR > 3 conflict rows,
   OR audit mode with > 5 stale-premise rows.
 - **Model:** Sonnet 5, high effort.
 
 ## What's identical
 
+The full analyst's **hard rules 2, 3, 3a, 4a, 5 and 6** apply unchanged
+(`../orc-analyze/SKILL.md` §Hard rules): quote-anchored evidence-or-mark with
+`searched:` on absence claims, the read ladder (`../_shared/read-ladder.md`),
+recommended-option challenges, two perimeters with the **Additional context (do
+not build)** section, and a spec derived from the confirmed report (with the Evidence column and the
+Assumptions & Open Questions section). Anchored context is self-read (no
+scouts). Also the same:
+
 - **Doc-optional intake:** auto-detect + confirm mode — prose / audit
-  (documents) or **requirement** (NO doc; the user's request is the source of
-  truth, reconciled against code).
-- **Evidence-or-mark, quote-anchored:** every code claim / interpretation is
-  grounded with `file:line — "verbatim snippet"` (a ref with no quote
-  auto-downgrades to `UNVERIFIED`), OR tagged `ASSUMPTION`/`UNVERIFIED` and
-  turned into a question — never a silent guess. **Absence claims**
-  (missing/buildable) carry `searched:` — the concrete globs/greps run.
-- **The read ladder:** locate → outline → range → full, escalating only as far as
-  the question needs (`../_shared/read-ladder.md`). Trimmed depth is not a lower
-  evidence floor — it is fewer wasted full reads reaching the same anchors.
-- **Recommended-option challenges:** each challenge is a 2–3 option set with one
-  flagged recommended option + reason (blocking one at a time, advisory batched).
-- Two perimeters: the deliverable stays scope X (Y/Z never become tasks), but
-  anchored, non-actionable adjacent context is gathered when an in-scope item
-  depends on it — touchpoint-bounded, self-read (no scouts), each item anchored to
-  the requirement it serves + labeled "do not build". Same **Additional context
-  (do not build)** section in report + spec. Unanchored context is dropped.
-- Two artifacts, spec derived from the confirmed report, same folder
-  `orc/analyzer/{analysis-name}/` (internal; copied out only on report-only),
-  including the Evidence column and Assumptions & Open Questions section. The
-  spec is stamped with `git_head` + `dirty` for plan-time staleness detection.
+  (documents) or **requirement** (NO doc; the request is the source of truth).
+- Same folder `orc/analyzer/{analysis-name}/` (internal; copied out only on
+  report-only). The spec is stamped with `git_head` + `dirty` for plan-time
+  staleness detection.
 - Same branch: report-only, or take into build (hand both files to orc-mini,
-  which continues with the mini planner) — orc-mini runs the same evidence
-  spot-check + derivation lint gates as the full lane before building.
+  which continues with the mini planner and runs the same evidence spot-check +
+  derivation lint gates).
 
 ## Behavior trace (always on)
 
-`../_shared/phases/trace.md` (`core`, at run start; `orc lane phases` names
-the file and the layers). Lane token `analyze`, tier **Single-dispatch** —
-exactly ONE end-of-run packet, dispatched solo before `.current` is deleted.
-At run start write `log_dir/.current` = `run-analyze-<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-analyze-mini --json` →
+`trace_grammar` gives the verbs). Lane token `analyze`, tier
+**Single-dispatch**. At run start write `log_dir/.current` =
+`run-analyze-<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`.
 
 ## Workflow checkpoint (gate before deriving the spec)
 
@@ -108,29 +90,12 @@ survived. Return exactly:
 
 Never build or spawn.
 
-## Config
-
-Resolve with `orc lane config orc-analyze-mini --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-analyze-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.
-
-## Rules — the anti-slop card (`../_shared/phases/rules.md`)
-
-`orc rules slice --lane orc-analyze-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[]`.
+## Lane contract (`../_shared/lane-contract.md` — read it ONLY when a call exits ≠ 0)
+
+- **Calls:** `orc lane calls orc-analyze-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-analyze-mini --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-analyze-mini --json` is the ONLY assembler
+  (`../_shared/phases/rules.md`). Its `line` prints VERBATIM at preflight.

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

@@ -10,7 +10,7 @@ description: >
   template the user fills in themself. Refresh regenerates ONLY stale sections
   and bumps the file version by 0.0.1. Never trims user-authored content;
   never touches the orc-wiki pointer block. The skill dispatches the pinned
-  orc-claude-writer-opus-4-8-high agent — it never writes the file itself.
+  orc-claude-writer-opus-5-low agent — it never writes the file itself.
 ---
 
 # ORC-CLAUDE (standalone)
@@ -20,11 +20,11 @@ The target is ALWAYS `<repo root>/CLAUDE.md` of the current working directory
 never `~/.claude/CLAUDE.md`, even if ORC is installed globally.
 
 **Dispatch, don't do.** Whatever model this chat runs on, the skill itself only
-selects the mode and spawns `orc-claude-writer-opus-4-8-high` (the pinned
-engine) — so the scan + writing always run at Opus 4.8 high regardless of the
-caller's tier. When `opus5_only: true` the engine is
-`orc-claude-writer-opus-5-med` instead (that mode FORCES it — see
-`../_shared/opus5-only.md`), and it then needs an Opus 5.5 main session.
+selects the mode and spawns `orc-claude-writer-opus-5-low` (the pinned
+engine) — so the scan + writing always run at Opus 5.5 low regardless of the
+caller's tier. `opus5_only` does not change this role. The writer is already
+Opus 5.5 low, so that mode has nothing to flip (see `../_shared/opus5-only.md`).
+The writer needs an Opus 5.5 main session in both modes.
 The one exception: the skill also writes the
 trace pointer + a few markers around that spawn (behavior-trace logging is
 permanent; see "Behavior trace"); that
@@ -70,18 +70,18 @@ set in "Behavior trace").
    `touch the trace file` of that name in the SAME step, BEFORE the spawn (a
    pointer to a file that does not exist reads as dangling — the hook rotates
    away from it and the run splits across two files).
-2. Spawn `orc-claude-writer-opus-4-8-high` — or `orc-claude-writer-opus-5-med`
-   when `opus5_only` — with: `mode`, `repo_root`,
+2. Spawn `orc-claude-writer-opus-5-low` (also under `opus5_only` — that mode
+   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-4-8/high` just before the
-   spawn (`expect=opus-5/medium` under `opus5_only` — 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).
+   `DISPATCH orc-claude-writer :: <mode> expect=opus-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).
 3. On return, check `actual_model`/`actual_effort` against the pinned tier —
    mismatch → prepend a tier-downgrade warning to the report. **Trace:** emit
    `VERIFY writer actual=<model>/<effort> ✅ MATCH` (or
-   `⛔ DOWNGRADE expected=opus-4-8/high`).
+   `⛔ DOWNGRADE expected=opus-5/low`).
 4. Relay the Phase-3 report verbatim. **Trace:** emit
    `FINISH :: <mode_ran> CLAUDE.md v<X.Y.Z>` (mode_ran may be `noop`), then
    delete `log_dir/.current`. Then stop. The skill NEVER writes CLAUDE.md
@@ -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-4-8/high` before the spawn (the mode
+orc-claude-writer :: <mode> expect=opus-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.

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

@@ -1,65 +1,65 @@
-# Worked example — orc-claude runs (mock; orient only, never execute from this)
-
-## Run 1 — UPDATE (existing hand-written CLAUDE.md, 610 lines)
-
-U: /orc-claude
-C: CLAUDE.md exists, no orc-claude:meta header → UPDATE mode. Spawns
-   orc-claude-writer-opus-4-8-high (the skill never writes the file itself).
-W: Scans: pnpm monorepo (3 workspaces), turbo, eslint+prettier, vitest,
-   Postgres migrations under `packages/db/migrations`.
-W: Copies CLAUDE.md → CLAUDE.md.bak. Injects meta header (v0.0.1, 12-07-2026,
-   line-budget: 400) + P0 placeholder at top, appends fenced sections:
-   commands, layout (ownership map), conventions, boundaries, workflow,
-   decisions, patterns, gotchas placeholder, testing, environment, glossary
-   placeholder. Skips `adr` (nothing scannable). Existing 610 lines: untouched.
-
-```
-ORC-CLAUDE — update → CLAUDE.md v0.0.1 (12-07-2026)
-Sections written: p0*, commands, layout, conventions, boundaries, workflow,
-decisions, patterns, gotchas*, testing, environment, glossary*   (*=fill yourself)
-Skipped (empty scan): adr, pointers
-Preserved untouched: user content (610 lines), no wiki block found
-Conflicts flagged (NOT auto-edited):
-  - existing line 42 says "run yarn test" — repo uses pnpm (pnpm test)
-Backup: CLAUDE.md.bak written (add it to .gitignore)
-NOTE: file is 802 lines total (budget covers generated content only) — trim
-unused user content yourself for better instruction-following.
-```
-
-## Run 2 — REFRESH, one stale section
-
-U: /orc-claude   (weeks later; `test` script renamed to `test:unit` + `test:e2e`)
-C: Header found → REFRESH → spawns the writer.
-W: Recomputes fingerprints: only `commands` differs (e3f1a2 → 8c04b1). Writes
-   .bak, replaces the commands fence interior, bumps 0.0.1 → 0.0.2,
-   updated: 03-08-2026. User's edits outside fences + the wiki block:
-   byte-identical. Returns actual_model=claude-opus-4-8, actual_effort=high.
-
-## Run 3 — REFRESH, noop
-
-U: /orc-claude
-W: All fingerprints match →
-   `CLAUDE.md up to date (v0.0.2, 03-08-2026)` — no write, no bump, no bak.
-
-## Run 4 — behavior trace (permanent, always on)
-
-Same dispatch as any run, plus the minimal one-dispatch trace. The skill writes
-the run pointer (`run-claude-<slug>-<DDMMYY>-<HHMMSS>.txt` into `log_dir`)
-FIRST, records these events as they happen, and — as a 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):
-
-```
-[120726 09:14:02.110] writer   DISPATCH orc-claude-writer :: refresh expect=opus-4-8/high
-[120726 09:14:02.230] hook     SPAWN orc-claude-writer-opus-4-8-high
-[120726 09:15:47.900] hook     RETURN
-[120726 09:15:48.010] writer   VERIFY writer actual=claude-opus-4-8/high ✅ MATCH
-[120726 09:15:48.120] writer   FINISH :: refresh CLAUDE.md v0.0.3
-```
-
-Then the writer packet returns and the run pointer is deleted (in that order).
-A noop refresh traces the same shape, ending
-`FINISH :: noop`. No phase/score/gate/finding/verdict markers — orc-claude
-runs none of those phases (they live inside the writer). The `orc-trace.js` hook
-bootstraps the pointer on the writer dispatch, so the SPAWN/RETURN skeleton is
-captured even if the skill's run-start step is skipped.
+# Worked example — orc-claude runs (mock; orient only, never execute from this)
+
+## Run 1 — UPDATE (existing hand-written CLAUDE.md, 610 lines)
+
+U: /orc-claude
+C: CLAUDE.md exists, no orc-claude:meta header → UPDATE mode. Spawns
+   orc-claude-writer-opus-5-low (the skill never writes the file itself).
+W: Scans: pnpm monorepo (3 workspaces), turbo, eslint+prettier, vitest,
+   Postgres migrations under `packages/db/migrations`.
+W: Copies CLAUDE.md → CLAUDE.md.bak. Injects meta header (v0.0.1, 12-07-2026,
+   line-budget: 400) + P0 placeholder at top, appends fenced sections:
+   commands, layout (ownership map), conventions, boundaries, workflow,
+   decisions, patterns, gotchas placeholder, testing, environment, glossary
+   placeholder. Skips `adr` (nothing scannable). Existing 610 lines: untouched.
+
+```
+ORC-CLAUDE — update → CLAUDE.md v0.0.1 (12-07-2026)
+Sections written: p0*, commands, layout, conventions, boundaries, workflow,
+decisions, patterns, gotchas*, testing, environment, glossary*   (*=fill yourself)
+Skipped (empty scan): adr, pointers
+Preserved untouched: user content (610 lines), no wiki block found
+Conflicts flagged (NOT auto-edited):
+  - existing line 42 says "run yarn test" — repo uses pnpm (pnpm test)
+Backup: CLAUDE.md.bak written (add it to .gitignore)
+NOTE: file is 802 lines total (budget covers generated content only) — trim
+unused user content yourself for better instruction-following.
+```
+
+## Run 2 — REFRESH, one stale section
+
+U: /orc-claude   (weeks later; `test` script renamed to `test:unit` + `test:e2e`)
+C: Header found → REFRESH → spawns the writer.
+W: Recomputes fingerprints: only `commands` differs (e3f1a2 → 8c04b1). Writes
+   .bak, replaces the commands fence interior, bumps 0.0.1 → 0.0.2,
+   updated: 03-08-2026. User's edits outside fences + the wiki block:
+   byte-identical. Returns actual_model=claude-opus-4-8, actual_effort=high.
+
+## Run 3 — REFRESH, noop
+
+U: /orc-claude
+W: All fingerprints match →
+   `CLAUDE.md up to date (v0.0.2, 03-08-2026)` — no write, no bump, no bak.
+
+## Run 4 — behavior trace (permanent, always on)
+
+Same dispatch as any run, plus the minimal one-dispatch trace. The skill writes
+the run pointer (`run-claude-<slug>-<DDMMYY>-<HHMMSS>.txt` into `log_dir`)
+FIRST, records these events as they happen, and — as a 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):
+
+```
+[120726 09:14:02.110] writer   DISPATCH orc-claude-writer :: refresh expect=opus-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
+[120726 09:15:48.120] writer   FINISH :: refresh CLAUDE.md v0.0.3
+```
+
+Then the writer packet returns and the run pointer is deleted (in that order).
+A noop refresh traces the same shape, ending
+`FINISH :: noop`. No phase/score/gate/finding/verdict markers — orc-claude
+runs none of those phases (they live inside the writer). The `orc-trace.js` hook
+bootstraps the pointer on the writer dispatch, so the SPAWN/RETURN skeleton is
+captured even if the skill's run-start step is skipped.

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

@@ -98,6 +98,37 @@ installed orc skill, stitches `.claude/orc/diy/FLOW-COMPILED.md`, and stamps
 `orc diy compile`, and offers the regular `/orc` lane for the request at
 hand. `/orc-diy compile` in a session just runs the same CLI compiler.
 
+### Where the compiled flow comes from (maintainer view)
+
+You never read these; `orc diy compile` does, once, and stitches the result
+into `FLOW-COMPILED.md`. The table is here so a maintainer can see the
+provenance of a compiled phase without reading the compiler — `orc lane phases
+orc-diy --json` is the authoritative version and marks every row below
+`when: compile-time`.
+
+Eleven phases come from the shared library, as that file's `composed` LAYER —
+NOT its `full` layer, which is `/orc`'s procedure for the same phase:
+`../_shared/phases/trace.md` · `../_shared/phases/planning.md` ·
+`../_shared/phases/scoring.md` · `../_shared/phases/execution.md` ·
+`../_shared/phases/review.md` · `../_shared/phases/security.md` ·
+`../_shared/phases/verify.md` · `../_shared/phases/testgen.md` ·
+`../_shared/phases/mock-example.md` · `../_shared/phases/ship.md` ·
+`../_shared/phases/summary.md`.
+
+Five have no counterpart anywhere else in the payload and stay this lane's own:
+`references/blocks/header.md` (the tier self-gate), `wiki.md`, `analyze.md`,
+`pattern.md` and `extra.md`. They are composition prose about a decision only a
+composed flow makes, so there is nothing to share them WITH.
+
+Four more are pointed at from inside those stitched layers rather than stitched
+themselves: `../_shared/phases/intake.md`,
+`../_shared/phases/wave-grouping.md`,
+`../_shared/phases/security-checklist.md` and
+`../_shared/phases/stop-resume.md`.
+
+The stitch ORDER is the compiler's `order` array and is documented in
+`references/compile.md`; a golden test holds the three lists together.
+
 ## 4. Run
 
 ```

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

@@ -1,14 +1,12 @@
 ---
 name: orc-diy
 description: >
-  User-composable ORC lane. Use for "/orc-diy" or "run my custom orc flow".
-  The pipeline shape (analyze/review/verify/security/testgen on-off, scoring
-  or a fixed executor, autonomy, ship mode, session tier) is configured
-  ENTIRELY through the `orc diy` CLI and compiled into a flow file —
-  never configured in-session. HARD-GATED: no config or a stale compile →
-  this skill never runs the custom flow; it explains the CLI steps and offers
-  plain /orc instead. "/orc-diy compile" re-runs the deterministic CLI
-  compiler. See references/flow-schema.md and references/compile.md.
+  User-composable ORC lane. Use for "/orc-diy" or "run my custom orc flow". The
+  pipeline shape is configured ENTIRELY through the `orc diy` CLI and compiled
+  into a flow file — never configured in-session. HARD-GATED: no config or a
+  stale compile → this skill never runs the custom flow; it explains the CLI
+  steps and offers plain /orc instead. "/orc-diy compile" re-runs the
+  deterministic CLI compiler.
 ---
 
 # ORC-DIY (stub — gate + dispatcher)
@@ -51,73 +49,31 @@ unavailable, apply the same checks manually from
 
 ## Step 2 — dispatch the compiled flow
 
+First `orc lane config orc-diy --json`. **`habits{}` in it → print `habits.line`,
+read `../_shared/habits.md` NOW**; none → ignore every `(H …)`. Then:
 Read `.claude/orc/diy/FLOW-COMPILED.md` and follow it as your orchestrator
 spine for this run — it is self-contained: tier self-check, locked rules,
 phase sequence, and the references it cherry-picks from the installed orc
 skill. Honor its generated header: if its own self-gate fails, stop exactly
-as it says. Do not consult this stub again for the rest of the run, and do
-not load orc's SKILL.md as a spine (the compiled flow already references the
-exact orc subskills and schemas it needs).
-
-## Where the compiled flow comes from
-
-You never read these; `orc diy compile` does, once, and stitches the result
-into `FLOW-COMPILED.md`. The table is here so a maintainer can see the
-provenance of a compiled phase without reading the compiler — `orc lane phases
-orc-diy --json` is the authoritative version and marks every row below
-`when: compile-time`.
-
-Eleven phases come from the shared library, as that file's `composed` LAYER —
-NOT its `full` layer, which is `/orc`'s procedure for the same phase:
-`../_shared/phases/trace.md` · `../_shared/phases/planning.md` ·
-`../_shared/phases/scoring.md` · `../_shared/phases/execution.md` ·
-`../_shared/phases/review.md` · `../_shared/phases/security.md` ·
-`../_shared/phases/verify.md` · `../_shared/phases/testgen.md` ·
-`../_shared/phases/mock-example.md` · `../_shared/phases/ship.md` ·
-`../_shared/phases/summary.md`.
-
-Five have no counterpart anywhere else in the payload and stay this lane's own:
-`references/blocks/header.md` (the tier self-gate), `wiki.md`, `analyze.md`,
-`pattern.md` and `extra.md`. They are composition prose about a decision only a
-composed flow makes, so there is nothing to share them WITH.
-
-Four more are pointed at from inside those stitched layers rather than stitched
-themselves: `../_shared/phases/intake.md`,
-`../_shared/phases/wave-grouping.md`,
-`../_shared/phases/security-checklist.md` and
-`../_shared/phases/stop-resume.md`.
-
-The stitch ORDER is the compiler's `order` array and is documented in
-`references/compile.md`; a golden test holds the three lists together.
-
-
-## Config
-
-**ONE resolver, and it is not you:** `orc lane config orc-diy --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`.
+as it says. Never consult this stub again this run, and never load orc's
+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.
+- **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`).
+- **Habits:** Step 2, first.
+- **Rules:** `orc rules slice --lane orc-diy --json` is the ONLY assembler
+  (`../_shared/phases/rules.md`). Its `line` prints VERBATIM at preflight.
 
 The flow SHAPE is not in that answer: it is compile-owned and lives in
 `flow.lock.json`. The resolver answers for everything else this lane still
 reads, and `extra` is the same split — the flow decides WHETHER, the resolver
 still decides WHERE.
 
-## Calls
-
-**ONE catalogue, and it is not you:** `orc lane calls orc-diy --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.
-
 ## Hard rules
 
 1. The compiled flow is a build artifact — NEVER edit
@@ -126,16 +82,9 @@ command you are about to run, out loud, before running it.
    `orc diy set` + `orc diy compile`, both run by the user.
 2. Fail closed: any gate ambiguity = STALE, with the reason shown.
 3. The fallback ask is ONE question with two outcomes (`/orc` or stop) —
-   never a menu, never a silent fallback.
-
-## Rules — the anti-slop card (`../_shared/phases/rules.md`)
-
-`orc rules slice --lane orc-diy --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 **full** · safe point **compiled 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.
+   never a menu, never a silent fallback.
+
+## 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 **compiled phase edge**.

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

@@ -1,18 +1,18 @@
-## Phase: Code-pattern findings
-
-<!-- diy:when pattern=off -->
-Code-pattern codification is OFF: executors run language-agnostic (security/
-correctness invariants still enforced; conventions imitate neighbor files).
-Never prompt about patterns. A cached pattern under `.claude/orc/patterns/`
-is still injected if present — cache hits are always silent.
-<!-- /diy:when -->
-<!-- diy:when pattern=ask -->
-On an FE/BE pattern-cache miss at dispatch time, ask the user once: learn the
-house style via the `.claude/skills/orc-pattern/SKILL.md` flow, or proceed
-language-agnostic. Cache hits are used silently.
-<!-- /diy:when -->
-<!-- diy:when pattern=on -->
-On an FE/BE pattern-cache miss at dispatch time, auto-codify without asking:
-run the `.claude/skills/orc-pattern/SKILL.md` flow, then inject the cached
-pattern literally into executor slices. Cache hits are used silently.
-<!-- /diy:when -->
+## Phase: Code-pattern findings
+
+<!-- diy:when pattern=off -->
+Code-pattern codification is OFF: executors run language-agnostic (security/
+correctness invariants still enforced; conventions imitate neighbor files).
+Never prompt about patterns. A cached pattern under `.claude/orc/patterns/`
+is still injected if present — cache hits are always silent.
+<!-- /diy:when -->
+<!-- diy:when pattern=ask -->
+On an FE/BE pattern-cache miss at dispatch time, ask the user once (H `orc.phase-3.pattern`): learn the
+house style via the `.claude/skills/orc-pattern/SKILL.md` flow, or proceed
+language-agnostic. Cache hits are used silently.
+<!-- /diy:when -->
+<!-- diy:when pattern=on -->
+On an FE/BE pattern-cache miss at dispatch time, auto-codify without asking:
+run the `.claude/skills/orc-pattern/SKILL.md` flow, then inject the cached
+pattern literally into executor slices. Cache hits are used silently.
+<!-- /diy:when -->