@azure-id/orc 0.55.0

package/templates/skills/orc-diy/references/blocks/mock-example.md

@@ -0,0 +1,22 @@
+## Phase: Mock example (after a green verify, before ship)
+
+<!-- diy:when mock_example=off -->
+The mock-example phase is DISABLED in this flow. Skip silently.
+<!-- /diy:when -->
+<!-- diy:when mock_example=ask -->
+After the verify/smoke gate is GREEN and BEFORE any ship action, the offer is
+MANDATORY (never silently skipped, never silently run): follow
+`.claude/skills/_shared/drift-recovery.md` — build
+`mock-examples/<change-slug>/` (EXAMPLE.md + one minimal runnable mocked
+artifact) only on a yes. After the user runs it, ask the one drift question;
+on drift run the `DRIFT-FROM` recovery loop (hard cap 2, then an honest
+unresolved report). `mock-examples/` is NEVER staged by the ship phase.
+<!-- /diy:when -->
+<!-- diy:when mock_example=on -->
+After the verify/smoke gate is GREEN and BEFORE any ship action, build the
+mocked example without asking, per
+`.claude/skills/_shared/drift-recovery.md`: `mock-examples/<change-slug>/`
+(EXAMPLE.md + one minimal runnable mocked artifact; mocked inputs only). Then
+ask the one drift question; on drift run the `DRIFT-FROM` recovery loop (hard
+cap 2). `mock-examples/` is NEVER staged by the ship phase.
+<!-- /diy:when -->

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

@@ -0,0 +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 -->

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

@@ -0,0 +1,34 @@
+## Phase: Planning
+
+<!-- diy:when planning=auto -->
+Route planning exactly as the full lane does — Superpowers plan, OpenSpec
+change, or ORC's own planner, chosen by what exists in the project. Follow
+`.claude/skills/orc/subskills/orc-planner/SKILL.md` for the own-planner path
+and validate the planning output against
+`.claude/skills/orc/schemas/planning-output.md`.
+<!-- /diy:when -->
+<!-- diy:when planning=own-planner -->
+Always use ORC's own Requirement Planner, even when Superpowers/OpenSpec
+artifacts exist: follow `.claude/skills/orc/subskills/orc-planner/SKILL.md`
+and validate the planning output against
+`.claude/skills/orc/schemas/planning-output.md`.
+<!-- /diy:when -->
+<!-- diy:when planning=superpowers -->
+Plan via Superpowers: require a Superpowers-written plan as planning input
+(ask the user to produce one if absent), then convert it to ORC planning
+output validated against `.claude/skills/orc/schemas/planning-output.md` —
+same conversion the full lane applies on its Superpowers route.
+<!-- /diy:when -->
+<!-- diy:when planning=openspec -->
+Plan via OpenSpec: require an OpenSpec change as planning input (ask the user
+to produce one if absent), then convert it to ORC planning output validated
+against `.claude/skills/orc/schemas/planning-output.md` — same conversion the
+full lane applies on its OpenSpec route.
+<!-- /diy:when -->
+<!-- diy:when tdd=on -->
+TDD is ON for this flow: the plan must carry a `tdd_spec` per requirement
+(given/when/then + a runnable skeleton in the project's test framework, or
+`tdd: exempt — <reason>`; schema in
+`.claude/skills/orc/schemas/planning-output.md`). No test runner in the
+project → whole-run exemption, stated once at preflight.
+<!-- /diy:when -->

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

@@ -0,0 +1,18 @@
+## Phase: Review
+
+<!-- diy:when review=off -->
+Code review is DISABLED in this flow. Say so in the run summary line ("review
+skipped by flow config") — never imply the work was reviewed.
+<!-- /diy:when -->
+<!-- diy:when review=on -->
+Dispatch the reviewer exactly as the full lane does — follow the review half
+of `.claude/skills/orc/subskills/orc-review-verify/SKILL.md` (reviewer agent
+`orc-reviewer-opus-5-med`; findings ride the severity ladder from the
+locked rules, blocking and advisory findings both surfaced).
+<!-- /diy:when -->
+<!-- diy:when review=blocking-only -->
+Dispatch the reviewer exactly as the full lane does — follow the review half
+of `.claude/skills/orc/subskills/orc-review-verify/SKILL.md` — but only
+P0/P1 findings gate anything; P2/P3 findings are listed once in the summary
+and never re-offered as fix-up tasks.
+<!-- /diy:when -->

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

@@ -0,0 +1,16 @@
+## Phase: Task scoring → executor selection
+
+<!-- diy:when scoring=on -->
+Score each task 0–100 with the full lane's rubric (see the scoring section of
+`.claude/skills/orc/SKILL.md`), then dispatch the executor agent from THIS
+compiled table — it is already clipped to this flow's session tier; never
+substitute a preset from `config.md`:
+
+{{score_table}}
+<!-- /diy:when -->
+<!-- diy:when scoring=off -->
+Scoring is DISABLED in this flow. Skip the rubric entirely: EVERY execution
+task dispatches to **{{fixed_executor}}**. Wave grouping, declared-files
+conflict rules, and slice construction are unchanged — scoring off changes
+model selection only, never scheduling.
+<!-- /diy:when -->

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

@@ -0,0 +1,25 @@
+## Phase: Security pass
+
+<!-- diy:when security=off -->
+The security pass is OFF in this flow — skip silently.
+<!-- /diy:when -->
+<!-- diy:when security=ask -->
+When at least one task scored at or above the risk floor (70), ask the user
+once after review whether to run the security pass; on yes, run it exactly as
+the full lane's Phase 5.5 (reviewer re-dispatched with the checklist from
+`.claude/skills/orc/references/security-checklist.md`, sweeping only the
+run's changed files).
+<!-- /diy:when -->
+<!-- diy:when security=on -->
+When at least one task scored at or above the risk floor (70), dispatch the
+security pass without asking — the full lane's Phase 5.5 with the checklist
+from `.claude/skills/orc/references/security-checklist.md`, sweeping only the
+run's changed files.
+<!-- /diy:when -->
+<!-- diy:when security=always -->
+Dispatch the security pass on EVERY run of this flow, regardless of task
+scores — the full lane's Phase 5.5 with the checklist from
+`.claude/skills/orc/references/security-checklist.md`, sweeping only the
+run's changed files. (This flow removes the risk-floor trigger, not the
+pass's mechanics.)
+<!-- /diy:when -->

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

@@ -0,0 +1,25 @@
+## Phase: Ship
+
+State the current branch and the change summary BEFORE any git action, and
+never ship on a red build (locked rule).
+
+<!-- diy:when ship_mode=ask -->
+Ask the user how to ship: commit, PR (via
+`.claude/skills/orc/subskills/orc-pr/SKILL.md`), or leave the working tree
+as-is. Default when auto-accepted by autonomy: leave as-is and report.
+<!-- /diy:when -->
+<!-- diy:when ship_mode=commit -->
+Commit the run's changes on a green gate without asking (branch first if on
+the default branch; conventional message from the intent). PRs only if the
+user asks afterwards.
+<!-- /diy:when -->
+<!-- diy:when ship_mode=pr -->
+On a green gate, create the PR without asking via
+`.claude/skills/orc/subskills/orc-pr/SKILL.md` (branch + commit + push + PR
+body from the run artifacts).
+<!-- /diy:when -->
+<!-- diy:when ship_mode=report-only -->
+NEVER commit or push in this flow. Leave the working tree modified, and end
+with the change report + suggested commit message the user can apply
+themselves.
+<!-- /diy:when -->

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

@@ -0,0 +1,18 @@
+## Phase: Summary
+
+<!-- diy:when summary=off -->
+No summary phase: end after ship with a single line (tasks done / gate color
+/ ship action taken) plus usage, and note which phases this flow skipped.
+<!-- /diy:when -->
+<!-- diy:when summary=short -->
+Short summary: one paragraph — what was built, gate results, ship action,
+skipped phases, and usage. No per-task breakdown.
+<!-- /diy:when -->
+<!-- diy:when summary=full -->
+Full summary exactly as the full lane's final phase: per-task outcomes with
+models used, findings outcomes, verify results, ship action, skipped
+phases, and usage.
+<!-- /diy:when -->
+
+Always name the phases this flow skipped by config — the user must never
+mistake a DIY run for a full-lane run.

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

@@ -0,0 +1,17 @@
+## Phase: Test authoring
+
+<!-- diy:when testgen=off -->
+Test authoring is OFF in this flow — skip silently.
+<!-- /diy:when -->
+<!-- diy:when testgen=ask -->
+After verify (or after execution when verify is off), offer test authoring
+once; on yes, run the full lane's Phase 6.5 via
+`.claude/skills/orc/subskills/orc-testgen/SKILL.md` — it WRITES test cases
+and a test plan, never runs them, and never gates the ship.
+<!-- /diy:when -->
+<!-- diy:when testgen=on -->
+After verify (or after execution when verify is off), run the full lane's
+Phase 6.5 without asking via
+`.claude/skills/orc/subskills/orc-testgen/SKILL.md` — it WRITES test cases
+and a test plan, never runs them, and never gates the ship.
+<!-- /diy:when -->

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

@@ -0,0 +1,28 @@
+<!-- GENERATED SOURCE BLOCK — stitched by `orc diy compile`. Edit the block
+     template in skills/orc-diy/references/blocks/, never the compiled file. -->
+## Behavior trace (PERMANENT — always on, no flow key)
+
+Tracing is NOT composable: every ORC run traces, this one included. Follow
+`.claude/skills/orc/references/trace-protocol.md` (load it at run start) — this
+block is stitched into every compiled flow so a user-composed pipeline can never
+be the one lane that runs blind.
+
+**Run start:** create `log_dir`, write `log_dir/.current` =
+`run-diy-<slug>-<DDMMYY>-<HHMMSS>.txt` AND `touch the trace file` of that name
+in the SAME step (a pointer naming a file that does not exist reads as dangling —
+the hook rotates away from it and the run splits across two files), then store
+`trace_path` in the checkpoint. The lane token is `diy`, whatever the flow is
+named.
+
+**Narration is dispatched, never remembered:** record each event with its REAL
+timestamp into a phase packet (`PHASE`, `DISPATCH`/`VERIFY` per spawn —
+`actual_model`/`actual_effort` vs expected, surface any ⛔ DOWNGRADE to the user
+— `SCORE`, `OUTCOME`, `GATE`, `FINDING`/`VERDICT` for whichever gates this flow
+enabled, `FINISH`, plus `decisions` = the WHY), then dispatch
+`orc-trace-writer-haiku-4-5` with it, PAIRED with the next phase's first
+dispatch. **One packet per ENABLED phase group, minimum 2** — the flow shape is
+composed, so the packet count is too; a phase this flow turned OFF owes nothing.
+A phase ending with `zero new trace lines is a protocol violation`.
+
+**Run end:** the `FINISH` packet goes out and RETURNS, then delete
+`log_dir/.current`.

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

@@ -0,0 +1,25 @@
+## Phase: Verify
+
+<!-- diy:when verify=off -->
+Verification is DISABLED in this flow. The build+test evidence in each
+executor return is the only green signal; say "verify skipped by flow
+config" in the summary. Never claim criteria were verified.
+<!-- /diy:when -->
+<!-- diy:when verify=smoke -->
+Run a SMOKE verify only: dispatch the verifier
+(`orc-verifier-opus-5-med`) with an explicitly narrowed scope — build +
+full test suite, red/green verdict, NO per-criterion definition-of-done
+sweep. Red blocks ship exactly as a full verify would.
+<!-- /diy:when -->
+<!-- diy:when verify=full -->
+Dispatch verification exactly as the full lane does — follow the verify half
+of `.claude/skills/orc/subskills/orc-review-verify/SKILL.md` (build + tests +
+every acceptance criterion checked against the definition of done).
+<!-- /diy:when -->
+<!-- diy:when tdd=on -->
+TDD gate (rides the verify slot): the verifier slice carries the plan's
+`tdd_suite[]`; green is the definition-of-done for non-exempt requirements,
+red → the repair loop capped at `tdd_loop_max` (cap hit → STOP + honest red
+report). The adversarial half of the verify pass applies as the full lane
+defines it.
+<!-- /diy:when -->

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

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

package/templates/skills/orc-diy/references/compile.md

@@ -0,0 +1,59 @@
+# ORC-DIY — Compile procedure
+
+Compilation turns the CLI-written config into a runnable flow. It is
+**deterministic and CLI-owned**: `orc diy compile` does pure file stitching
+with zero model tokens. `/orc-diy compile` in a session is a thin wrapper —
+it runs the same CLI command via Bash and reports the result; there is no
+second implementation, and the skill never stitches the flow itself.
+
+## What the compiler does (implemented in `bin/cli.js`)
+
+1. **Validate.** Load `.claude/orc-diy.config.yaml`; run the full cross-key
+   validation from `flow-schema.md`. Any hard error aborts the compile.
+2. **Resolve sources.** Block templates come from the installed stub
+   (`.claude/skills/orc-diy/references/blocks/`). Cherry-picked orc material
+   is REFERENCED in place, never copied: the compiler verifies that every
+   orc file a chosen variant points at actually exists under
+   `.claude/skills/` (project first, `~/.claude/skills/` fallback for a
+   global orc install) and aborts naming the missing file if orc is absent
+   or incomplete.
+3. **Stitch.** Concatenate in fixed order — this list and the `order` array in
+   `bin/cli.js` are ONE contract; change them together (a golden test compares
+   them, because the drift is grammar-shaped and the contract lint cannot see
+   it, which is how `mock-example` went missing here for a whole release):
+
+   `header` → `locked-blocks.md` (verbatim) → `trace` → `wiki` → `analyze` →
+   `planning` → `pattern` → `scoring` → `extra` → `execution` → `review` →
+   `security` → `verify` → `testgen` → `mock-example` → `ship` → `summary`.
+
+   `trace` is UNCONDITIONAL — behavior tracing is permanent and is not a flow
+   key, so every compiled flow carries the protocol (lane token `diy`) whatever
+   the user composed. **`tdd` is NOT a block** — it composes into `planning`,
+   `execution` and `verify` through `diy:when tdd=on` markers, so there is no
+   `tdd.md` to stitch and none should be added.
+
+   Inside each block, keep text outside markers, and keep a
+   `<!-- diy:when key=value -->…<!-- /diy:when -->` section only when the
+   config's `key` equals one of the listed values (`|`-separated).
+4. **Substitute placeholders.** `{{flow_name}}`, `{{config_hash}}`,
+   `{{orc_version}}`, `{{compiled_at}}`, `{{tier_model}}`, `{{tier_effort}}`,
+   `{{max_wave_tasks}}`, `{{batch_pause_every}}`, `{{fixed_executor}}`,
+   `{{score_table}}`. The score table is the shipped preset for the config's
+   `rubric_bands`, CLIPPED to `session_tier` at compile time (bands above the
+   tier collapse into the highest allowed executor) — the compiled flow never
+   clips at runtime.
+5. **Write + lock.** Emit `.claude/orc/diy/FLOW-COMPILED.md`, then finalize
+   `flow.lock.json`: `compiled_hash` (sha256 of the emitted file),
+   `compiled_at`, `orc_version` (from the installed payload stamp
+   `hooks/orc-version.json`, package version fallback), `session_tier`.
+   Print the gate status (should now be READY).
+
+## Recompile triggers
+
+Any of these flips `orc diy status` to STALE until the user recompiles:
+- the config changed (`config_hash` mismatch — every `orc diy set` does this),
+- orc was updated (`orc_version` mismatch — `orc update`/`orc upgrade`),
+- `FLOW-COMPILED.md` was edited or deleted (`compiled_hash` mismatch).
+
+The stub skill NEVER runs a stale flow — it surfaces the reason and the fix
+(`orc diy compile`), then offers the plain `/orc` fallback.

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

@@ -0,0 +1,100 @@
+# ORC-DIY — Flow config schema
+
+The single source of intent is `.claude/orc-diy.config.yaml`, written ONLY by
+the `orc diy` CLI (never by hand, never in a Claude session). Every write
+regenerates `.claude/orc/diy/flow.md` (the human-readable spec) and updates
+`.claude/orc/diy/flow.lock.json`, invalidating any previous compile.
+
+**Project-scoped only.** The config, lock, and compiled flow live in the
+project's `.claude/` — there is no global variant; `orc diy` rejects
+`--global`. One flow per project; `flow_name` is a display label, never a
+selector.
+
+## Keys (all set via `orc diy set <key> <value>`)
+
+| Key | Values (default first) | Meaning |
+|---|---|---|
+| `analyze` | `auto` / `off` / `mini` / `full` | Doc-intake analyst routing |
+| `planning` | `auto` / `own-planner` / `superpowers` / `openspec` | Planning route |
+| `pattern` | `ask` / `off` / `on` | Code-pattern gate on a cache miss |
+| `scoring` | `on` / `off` | Rubric scoring; `off` needs `fixed_executor` |
+| `fixed_executor` | (none) — an executor agent name | Used for every task when `scoring: off` |
+| `extra` | `off` / `on` | May this flow dispatch an executor to a non-Claude worker (`_shared/extra-dispatch.md`)? It decides WHETHER; `orc extra resolve` still decides WHERE, per task, at run time — route rows are NOT baked into the compiled flow, because the lock's staleness triggers cannot see the ledger change. `off` makes a globally-enabled Extra **INERT here**, announced once, so turning it on globally never silently changes a compiled flow |
+| `review` | `on` / `off` / `blocking-only` | Review phase strictness |
+| `security` | `off` / `ask` / `on` / `always` | Security pass; `always` drops the risk-floor trigger |
+| `verify` | `full` / `off` / `smoke` | Verify depth |
+| `testgen` | `off` / `ask` / `on` | Test-authoring phase |
+| `mock_example` | `ask` / `on` / `off` | Post-verify mocked example + drift recovery (`mock-examples/<slug>/`, never committed) |
+| `tdd` | `on` / `off` | TDD-anchored planning: plan-time `tdd_spec` (scoped by `disposition`), paired TDD tasks for the red proof, TDD gate in the verify slot |
+| `gotchas` | `on` / `off` | Repair memory: inject scope-matching gotchas into slices, record one when a repair loop goes red → green (`_shared/gotchas.md`) |
+| `wiki_gate` | `notice` / `off` / `hard` | Wiki freshness handling at preflight |
+| `post_ship_wiki_ask` | `on` / `off` | Post-ship wiki refresh offer on big runs |
+| `summary` | `full` / `off` / `short` | Summary depth |
+| `autonomy` | `interactive` / `semi` / `hands-off` | Who answers routine asks |
+| `ship_mode` | `ask` / `commit` / `pr` / `report-only` | Terminal ship behavior |
+| `session_tier` | `sonnet-4-6-{med,high}` / `opus-4-7-{med,high}` / `opus-4-8-{med,high,xhigh,max}` / `opus-5-{med,high,xhigh,max}` / `fable-5-{med,high,xhigh,max}` | Required main-session model+effort (default `opus-4-8-high`) |
+| `max_wave_tasks` | `3` (integer ≥ 1) | Wave hard cap |
+| `batch_pause_every` | `2` (integer ≥ 1) | Waves between pauses |
+| `rubric_bands` | `5` (2–8) | Scoring granularity (`scoring: on` only) |
+| `flow_name` | `my-flow` (slug) | Display label for traces/statusline |
+
+## Cross-key validation (CLI `orc diy validate`; also runs on every write)
+
+Hard errors (config not written):
+- `scoring: off` without a `fixed_executor`.
+- `fixed_executor` or any agent choice above `session_tier` (tier order:
+  haiku-4-5 < sonnet-4-6 < sonnet-5 < opus-4-7 < opus-4-8 < opus-5 < fable-5 —
+  subagents cannot exceed the main session; effort medium < high < xhigh < max).
+  A tier below `opus-5-high` clips the `[90,100]` band to the highest agent it
+  allows, at compile time.
+- `review: off` with `security` not `off` (the security pass reuses the
+  reviewer).
+- Anything that would disable a locked rule (see `locked-blocks.md`).
+
+Warnings (written, reported):
+- `scoring: off` with `rubric_bands` overridden (ignored).
+- `testgen` on/ask with `verify: off` (testgen normally follows verify).
+- `tdd: on` with `verify: off` (the TDD gate runs in the verify slot; plan-time
+  tests are authored but never gate the ship).
+- `autonomy: hands-off` with `ship_mode: commit` or `pr` (fully unattended
+  git actions).
+- `session_tier` below `opus-5-med` with `review`/`verify` on: the pinned
+  Opus 5 reviewer/verifier agents will silently run at the session's model —
+  the flow still works, honesty-checked by the tier-honesty locked rule.
+
+## `flow.lock.json` (machine state — written by the CLI only)
+
+```json
+{
+  "flow_name": "my-flow",
+  "session_tier": "opus-4-8-high",
+  "config_hash": "sha256 of orc-diy.config.yaml",
+  "flow_hash": "sha256 of flow.md",
+  "compiled_hash": "sha256 of FLOW-COMPILED.md (null until compiled)",
+  "compiled_at": "ISO timestamp or null",
+  "orc_version": "installed orc payload version at compile time, or null"
+}
+```
+
+Gate status (computed by `orc diy status`, consumed by the stub skill and
+`orc doctor`; the effort guard does NOT read it — it keys on `flow.lock.json` +
+`session_tier` directly, and the statusline reads the lock, not this verb):
+
+**The exit code IS the contract** (v0.34.7), same convention as the sibling
+`orc pattern status <lang>` in `_shared/detecting-artifacts.md`:
+
+| Exit | State | Meaning |
+|---|---|---|
+| 0 | READY | everything matches; `/orc-diy` may run the compiled flow |
+| 1 | STALE | see the triggers below — the flow must be recompiled first |
+| 1 | UNCONFIGURED | no config file (or empty) |
+
+It used to exit 0 in all three states, so anything branching on it treated a
+hard-blocked flow as runnable — the direct inverse of its own sibling.
+
+STALE triggers (**all live ones are reported, joined by `;`** — not just the
+first): no lock / never compiled / `config_hash` mismatch (config changed since
+compile) / `orc_version` mismatch (orc was updated) / compiled file missing or
+`compiled_hash` mismatch (artifact modified). Reporting only the first meant a
+flow stale ONLY because `orc update` bumped the payload said "config changed",
+which contradicts a user who knows they never touched their config.

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

@@ -0,0 +1,37 @@
+# ORC-DIY — Locked rules (compiled verbatim into EVERY flow)
+
+These are the boundaries cherry-picked from the full orchestrator. The
+compiler injects this file into every compiled flow unchanged; the CLI
+validator hard-errors on any config that would violate one. No flow choice —
+including hands-off autonomy — ever overrides a locked rule.
+
+## LOCKED (never configurable)
+
+1. **You NEVER implement. You coordinate.** All execution, review, verify,
+   and analysis work is done by spawned subagents — even the smallest task.
+2. **Disk is truth; conversation is a cache.** On any resume, fresh session,
+   or suspected compaction: re-read the run's `state-of-play.md` then the
+   checkpoint BEFORE acting. All run artifacts live in
+   `.claude/orc/run/{run-slug}/` — never the project root.
+3. **No two tasks with overlapping `declared_files` share a wave.** A task
+   without declared files cannot be waved.
+4. **Severity ladder (P0–P3).** P0 (objective breakage) → auto-fix ONCE;
+   second failure → STOP and surface. P1 (correctness/security risk) → gates
+   ship; dispatching the fix needs the user (autonomy may auto-accept the
+   ask, never skip the gate). P2/P3 → advisory, never auto-fixed. **Quote
+   spot-check before acting on any P0/P1:** read the cited `file:line`,
+   confirm the verbatim quote; mismatch → demote to P3 and tell the user.
+5. **You alone write the checkpoint and state-of-play.** Workers never touch
+   them. Validate every subagent return against its contract — malformed =
+   failure (requeue with reason). Record the failure reason, never just
+   "failed".
+6. **Never announce a stop before the checkpoint write is confirmed. Never
+   offer commit on a red build.**
+7. **Slices are constructed by you, never pulled by workers.** A worker
+   needing more context uses the `needs_context` return (cap: 2 per task).
+8. **Tier honesty.** Every dispatched agent's return carries its claimed
+   model + effort; flag a silent downgrade to the user instead of hiding it.
+9. **Keep the user informed before acting** — dispatch plan, counts, current
+   branch before any git action, every escalation, usage at every stop and
+   at run completion. Autonomy profiles change who answers routine asks,
+   never what gets reported.