@azure-id/orc 1.9.2 → 2.0.2

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

@@ -2,16 +2,11 @@
 name: orc-analyze
 description: >
   System Analyst for ORC. Use for "/orc-analyze", "analyze this doc for scope
-  X", or "analyze this requirement against the code" — turning a requirement (a
-  document, PDF by path or pasted, OR a plain-language request) into a precise,
-  code-grounded requirement set BEFORE any planning. Bounds the deliverable to
-  exactly the asked scope, pulls related adjacent scopes in only as anchored
-  "do not build" context, maps each requirement to real files with
-  quote-anchored file:line evidence, and challenges the user with recommended
-  options. Opt-in DEEP mode adds a scout-driven code sweep, verify-every-claim,
-  and alternatives + risks. Also auto-triggers inside /orc on a doc or
-  ambiguous requirement. The orchestrator dispatches this to a subagent — it
-  never analyzes itself.
+  X", or "analyze this requirement against the code". Turns a document (PDF by
+  path or pasted) or a plain-language request into a scope-bounded,
+  code-grounded requirement set with quote-anchored file:line evidence BEFORE
+  any planning, and challenges the user with recommended options. Opt-in DEEP
+  mode adds a scout-driven code sweep. Also auto-triggers inside /orc on a doc.
 ---
 
 # ORC-ANALYZE (System Analyst)
@@ -79,24 +74,20 @@ the user meant.
 
 ## 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 --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`.
 
 `context-combiner` is a PHASE of this run, not a lane: its `DISPATCH`/`RETURN`,
 its Phase D verdicts and its conservation-gate result fold into THIS packet.
 
 ## Phases
 
-`orc lane phases orc-analyze --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-analyze --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 A — Ingest & detect source mode
 
@@ -133,12 +124,11 @@ offer wording, the auto-consume back here: `references/thin-input.md`.
 
 ## Phase A′ — Standard vs Deep gate (default STANDARD)
 
-Before reconciliation, offer the depth choice (config `default_analysis_depth`
-presets the default; the run still confirms): deep = wider sweep, verify every
-claim, more questions, alternatives with trade-offs, noticeably more tokens;
-standard = faster, verifies the stated floor (hard rule 4). Mention the
-zero-token default switch `orc config set default_analysis_depth deep`. Deep
-requires explicit consent — never auto-escalates — and is **two-pass with
+Before reconciliation, offer the depth choice (H `any.analysis.depth`). Config
+`default_analysis_depth` presets it; mention the free switch `orc config set
+default_analysis_depth deep`. Deep = wider sweep, verify every claim, more
+questions, alternatives, more tokens; standard = faster, the hard rule 4 floor.
+Deep needs explicit consent EVERY run (never auto) and is **two-pass with
 scouts**: load `references/deep-mode.md`. Standard is single-pass.
 
 ## Phase B — Bound scope
@@ -216,44 +206,18 @@ another RELATED doc (multi-analyze loop → combiner once 2+ related analyses
 exist). Menu rules, relatedness gate, combiner handling:
 `references/branching.md`.
 
-## Mini variant
-
-For the fast lane, `orc-analyze-mini` (Sonnet 5 high) does a shallower version
-of the same flow: doc-optional intake, the same evidence-or-mark + floor (a)+(b)
-+ triage rules — but **no deep mode and no scouts** (always single-pass), and
-concrete escalation thresholds to the full analyst. Used by orc-mini. Same
-artifacts, same output contract; trimmed depth. See that skill.
-
-## Config
-
-**ONE resolver, and it is not you:** `orc lane config orc-analyze --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-analyze --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 --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 --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 --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:** `habits{}` in that answer → `../_shared/habits.md`; else ignore `(H …)`.
+- **Rules:** `orc rules slice --lane orc-analyze --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 **full** · safe point **after the analyst 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 analyst returns**.

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-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)
@@ -59,65 +57,23 @@ 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`.
+## 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:** `habits{}` in the config answer → read `../_shared/habits.md`. No
+  `habits{}` → ignore every `(H …)` mark.
+- **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 -->