@azure-id/orc 0.55.0

package/templates/commands/orc-pact.md

@@ -0,0 +1,44 @@
+---
+description: The invariant ledger — the promises your project makes, and which ones are in doubt right now
+---
+
+Use the **orc-pact** skill. Standalone — no scan, no plan, no build, no code
+written.
+
+`/orc-grill` and `/orc-brainstorm` already settle constraints, and a plan already
+carries them into every executor slice. Then the run ends and they evaporate. This
+is the ledger that outlives the run.
+
+Four states, and every one is **computed on read**, never stored:
+
+- **HOLDING** — its check passed at a commit that still covers the files it anchors.
+- **DRIFTED** — commits since then touched those files. Coverage-relative: a promise
+  about payments does not fall into doubt because the README changed.
+- **UNCHECKABLE** — nothing cheap proves it. **This is the honest state and the
+  point of the lane**, and it never counts as a failure.
+- **BROKEN** — the check ran and failed.
+
+How it runs:
+
+1. **Harvest** — pull constraints out of a run's `spec_invariants[]`, a grill doc, a
+   brainstorm doc, or a frozen poly-repo contract. Each one arrives quoted verbatim
+   with an origin recorded. **It never invents a promise.**
+2. **Recheck** — `orc pact check` runs the cheap proofs for the drifted ones only,
+   and re-anchors what passes. No model judges what a test can answer.
+3. **Reconcile** — one promise at a time. ORC brings the facts (which commits
+   touched it, what the check returned, whether this already went wrong before);
+   **you** decide whether the promise still stands. It recommends, then waits.
+4. **Write** — the ledger, plus a committed, PM-readable `PACT.md` at the project
+   root, rendered by the CLI from the ledger so the two can never disagree.
+
+**It never retires a promise on its own.** Retirement is your decision and records
+your reason, and a retired promise stays visible struck through.
+
+Inside `/orc` (`pact_gate`, default `warn`): one preflight line, and — the payoff —
+a drifted promise whose files a plan is about to touch is injected into the planner
+as a constraint. Last month's decision constrains this month's plan, automatically.
+It never blocks a run.
+
+Read it back any time without this lane: `orc pact status`.
+
+What you want to do (harvest / review / add — or nothing, and it will ask): $ARGUMENTS

package/templates/commands/orc-pattern.md

@@ -0,0 +1,15 @@
+---
+description: Learn & cache the project's real code conventions per language — reconciles a generic playbook against your actual files so ORC executors match your house style
+---
+
+Use the **orc-pattern** skill. Start at Phase 0: detect the project's
+frontend/backend languages, then branch per language (cache miss → codify; cache
+hit + no drift → report and skip; cache hit + drift → auto-refresh). Dispatch the
+`orc-pattern-codifier-sonnet-5-high` subagent (`orc-pattern-codifier-opus-5-med`
+when `opus5_only` is set) to reconcile the generic playbook
+against the most-recently-modified real files (project conventions win; invariants
+always kept; conflicts flagged), then write `.claude/orc/patterns/<lang>-pattern.md`.
+Never run tests or change project code. Follow the skill's SKILL.md exactly.
+
+Optional: a language name to codify just that one, or `--refresh` to force
+re-codification. $ARGUMENTS

package/templates/commands/orc-plan.md

@@ -0,0 +1,22 @@
+---
+description: Requirement Planner — turn a detailed request or analyst spec into a grounded task plan (plan only)
+---
+
+Use the **orc-planner** subskill via the orchestrator. Take the input (a
+detailed request, or a System Analyst requirement-spec) and produce a grounded,
+right-sized, dependency-checked plan in orc's planning-output format. If the
+request is below the plannable floor (an observable outcome + an identifiable
+repo area), do not plan — recommend `/orc-analyze` requirement mode instead.
+Ground declared files from the repo/wiki when run standalone; trust the analyst
+spec when chained. If the input is an orc-poly `poly-spec.md` (first line
+`orc-poly:spec`), the planner switches to **poly-repo split mode** — one plan
+per repo in its `repos[]` block, each written into its own repo and each pinned
+to the frozen `interface-contract.md` (see the planner agent). Every declared path carries a grounding attestation
+(exists|new + evidence), every task a sliced source-cited acceptance[] plus the
+requirements[] it implements — the orchestrator spot-checks grounding AND
+recomputes coverage (an orphan requirement bounces the plan), plus cycle and
+same-file collision checks. Show the plan once for approval/edits (task
+breakdown/approach only), then offer to take it into a build or save it as
+plan-{name}.md and stop. The orchestrator dispatches the planning to a subagent.
+
+Request / spec: $ARGUMENTS

package/templates/commands/orc-poly.md

@@ -0,0 +1,21 @@
+---
+description: Poly-repo planning — plan ONE change across 2+ repos, freeze the shared interface contract, split into one plan per repo (no drift)
+---
+
+Run the **orc-poly** skill. You are in the HOST repo; paste the path of each
+PEER repo the change also touches (one or many — FE→BE, BE→another service's
+gRPC, …). orc-poly peeks at every repo's wiki + crosslink read-only (or, when a
+wiki is missing, asks you which folders/files to dig — never a blind scan),
+gathers the cross-repo context by asking questions until the shared boundary is
+pinned with no guesses, then writes a source-of-truth doc set
+(`poly-context.md`, `interface-contract.md`, `poly-spec.md`) into
+`poly-repo-implementation/<slug>/`. Each iteration it offers three choices: pass
+to orc-plan · stop & chat · add more context (another repo path or pasted
+knowledge). On "pass to orc-plan" the shared planner self-activates poly mode on
+the `orc-poly:spec` marker and splits ONE plan per repo — the HOST plan into
+this repo, each PEER plan written into that peer repo — every plan pinned to the
+frozen `interface-contract.md`. You then build each repo later, in its own
+session, with plain `/orc`, and no repo drifts. PEER source is READ-ONLY (the
+only peer write is its plan file); orc-poly never builds.
+
+Change / peer path(s): $ARGUMENTS

package/templates/commands/orc-pr-driver.md

@@ -0,0 +1,30 @@
+---
+description: Stacked-PR driver — execute a stack plan: one branch per layer, mandatory per-layer green gate, gh stack submit, then sync/rebase/bottom-up merge
+---
+
+Run the **orc-pr-driver** skill. It takes an approved stack plan and makes the
+layers real: `gh stack init` → per layer `gh stack add`, only that layer's files,
+the **mandatory green-gate ladder** (build → tests → lint scoped to *that layer's
+own base* → the repo's own pre-commit hooks, never `--no-verify`) → commit →
+`gh stack submit`, PR bodies filled from the resolved template, then the ongoing
+`gh stack sync` / `rebase --upstack` / `modify` care and the bottom-up merge.
+
+**Three ways in — all read the same file** (`stacked-pr/<slug>/stack-plan.md`,
+probed with `orc pr stack status`):
+
+1. `/orc-pr-setup` planned it (the normal path),
+2. ORC's ship phase handed it over (`stacked-pr/<slug>/STACK-FROM.md`),
+3. **you wrote the plan yourself** — run `orc pr stack template` for the skeleton,
+   fill it in, and start here. No planner run required.
+
+It **refuses to run** — naming the exact missing field — on a plan with an
+unanswered uncertain seam, a missing ticket, a layer with no purpose or value
+class, a FOUNDATION layer that names no consumer, fewer than 2 layers, or a red
+build. It never fills a field in for you.
+
+When the change already exists in the worktree, your work is snapshotted to a
+scratch branch BEFORE any branch surgery, every layer is materialized from that
+snapshot file-by-file, and a completeness gate proves the union of the layers
+equals the snapshot exactly before anything is submitted.
+
+Slug / plan path / stack action: $ARGUMENTS

package/templates/commands/orc-pr-setup.md

@@ -0,0 +1,31 @@
+---
+description: Stacked-PR planner — decide where the PR cut lines go, prove each layer stands alone, write stacked-pr/<slug>/stack-plan.md (plans only, never touches git)
+---
+
+Run the **orc-pr-setup** skill. It plans a **stack of pull requests** for a
+change that is too big to review as one PR: ordered layers, each with a one-line
+purpose, a value class (`USER | OPERATOR | CONTRACT | FOUNDATION`), an explicit
+file list, measured LoC/file budgets and a dependency reason — written to
+`stacked-pr/<slug>/stack-plan.md`.
+
+It **plans only**: no branches, no commits, no pushes, no PRs. That is
+`/orc-pr-driver`.
+
+Two entry modes, auto-detected: **greenfield** (nothing written yet — a spec or
+ticket) and **orc-run** (the change already exists in the worktree, e.g. ORC just
+built it — the split is file-granular; hunk surgery is forbidden). A ticket
+number is required. The PR-description template is resolved from the ORC template,
+then the project (`.github/`, `docs/`), then a `CLAUDE.md` section — and if none
+exists you get three recommended options to pick from; declining them all means
+the stack is skipped and the change ships as one regular PR.
+
+**P0 hard gate:** every uncertain boundary STOPS the lane and asks you, one
+decision at a time, with the LoC/file/CI cost of each option and a recommendation
+— and records your answer under `## Decisions`. Same-tier files, shared helpers,
+refactor mixed with behavior change, ordering ambiguity and oversize atoms are all
+uncertain by definition. It never guesses a seam.
+
+When the plan is written it shows the layer table, states that nothing has been
+created yet, and hands off to `/orc-pr-driver`.
+
+Ticket / change / spec: $ARGUMENTS

package/templates/commands/orc-quick.md

@@ -0,0 +1,33 @@
+---
+description: Quick lane for almost anything — look, ask once, dispatch. Always asks which agent. Saves every request as a numbered entry in orc-quick/<slug>/quick-context.md
+---
+
+Use the **orc-quick** skill. It is standalone — not part of the `/orc` pipeline,
+and no config key can change how it dispatches.
+
+Three steps per request, one user turn:
+
+1. **LOOK** (silent) — check the wiki and code-pattern if they exist (never a
+   blocker), find the files, read the PR comments if this is PR work, and note
+   anything the user already decided.
+2. **ASK** (one turn) — up to 3 grounded questions *plus* the dispatch gate in
+   the same turn. **The gate is hard: always ask which agent to dispatch.**
+   Code work offers `orc-executor-sonnet-4-6-med` or `orc-executor-opus-5-low`;
+   read-only work offers an ad-hoc model + effort.
+3. **DO** — dispatch, check the return, run build/tests if they exist, write the
+   numbered entry to `orc-quick/<slug>/quick-context.md`, then offer tests /
+   review / commit.
+
+Not only for code: a quick context dig, a defect hunt, a dependency bump, or
+fixing PR review comments all run the same way. A request that turns out too big
+gets an **offer** of `/orc-mini` — never a forced fallback.
+
+No smoke gate. A red build starts a repair loop (2 rounds reuse the executor,
+round 3 asks again, then it asks what to do). Red tests stop the commit offer but
+never loop. No test suite means no check at all.
+
+`gh` is read + push only — never a comment, never a resolve, never a merge.
+
+Ask for a new request any time and it becomes entry 2, 3, 4 … in the same doc.
+
+Request (or `pr <n>`, `thread=<name>`): $ARGUMENTS

package/templates/commands/orc-retro.md

@@ -0,0 +1,17 @@
+---
+description: Mine the ORC behavior traces — per-band calibration, downgrades, pipeline leaks (read-only report)
+---
+
+Use the **orc-retro** skill. **P0 preflight first:** verify a delivery channel
+exists — the gh CLI (authed) or a GitHub MCP server; if NEITHER is available,
+do not run the retro at all (the report must land upstream or it's pointless).
+Then: read the persistent behavior traces in `log_dir` (behavior-trace logging is
+permanent — every run writes one), dispatch the retro miner subagent to aggregate
+per-band outcomes (retries, requeues, needs_context, unmet), tier downgrades,
+and pipeline leaks, write the AI-readable calibration report to
+`log_dir/retro/`, and DELIVER it to the ORC repo (`retro_repo` config, default
+azure-id/orc) as a PR — issue fallback — showing the created URL. Never edits
+the rubric, skills, or code locally. If no traces exist yet (no runs have
+happened), say so and stop.
+
+Optional trace subset / date range: $ARGUMENTS

package/templates/commands/orc-route.md

@@ -0,0 +1,41 @@
+---
+description: You have a plan — this says which lane should build it, with the numbers it decided from. Plan-only: it refuses a request in words rather than guess
+---
+
+Use the **orc-route** skill. Zero agents, nothing is built.
+
+**It routes a PLAN, and only a plan** — pasted ORC planning-output, a
+`plan-<name>.md` path, or a saved `orc/planner/<name>/` checkpoint (the same
+definition `references/plan-handoff.md` already uses). A plan carries real
+numbers: tasks, files per task, dependencies, facets, scores. Routing from those
+is arithmetic; routing from a sentence is guessing, so a request in words gets a
+refusal and a pointer to `/orc-plan`, not a guess.
+
+It reads the plan plus ORC's deterministic probes (`orc wiki status`,
+`orc pattern status`, `orc gotcha status`, `orc diy status`) and answers:
+
+```
+Plan: merchant-notifications — 7 tasks, 3 waves, 14 files touched
+      top score 78, two tasks marked risky
+
+→ /orc          the plan has risky tasks and a task above 70;
+                review and verify are worth paying for here
+   runner-up    /orc-mini — about 3x faster, but it skips full review
+                and verification. Fine only if you will read the diff yourself.
+   not possible /orc-fast — needs a fresh wiki (yours is STALE) and this plan
+                is 7 tasks; that lane runs ONE task
+
+Start /orc now?  [yes / no]
+```
+
+Every runner-up says what choosing it costs you. Every impossible lane names the
+condition blocking it **and** how to fix it. Risk beats size: a small plan with a
+cited risk still earns the full lane.
+
+`/orc-plan` also offers this automatically after **Save & stop**, so you rarely
+need to type it.
+
+New to ORC and wondering which command to use at all? That is
+`orc onboarding first-run`, not this.
+
+Plan (paste it, or give a path): $ARGUMENTS

package/templates/commands/orc-ultra.md

@@ -0,0 +1,17 @@
+---
+description: Ultra lane — full orchestrator + Opus 5 xhigh advisor and three judgment gates, for ultra-complex work (maximum rigor, cost accepted)
+---
+
+Use the **orc** skill with `ultra_mode: true` forced on for this run. Ultra is
+the maximum-rigor lane for complex/ultra-complex requests: everything the full
+pipeline does, PLUS an up-front Advisor brief with a batched clarification
+round (orc-advisor skill), three judgment gates — after analysis, after
+planning, and after verify (implementation fidelity + ultra-strict quality;
+orc-judge skill) — an assumption ledger, a deterministic traceability matrix,
+a blast-radius map, and an executor tier floor. Forced for the run (run-scoped,
+never written to the user's config): deep analyze (Phase A′ gate bypassed),
+pattern findings on, test authoring on, security review on. Ultra is costly by
+design — state it once, never prompt about cost mid-run. Follow the orc
+SKILL.md's ULTRA LANE section and references/ultra-mode.md exactly.
+
+Request: $ARGUMENTS

package/templates/commands/orc-verify.md

@@ -0,0 +1,11 @@
+---
+description: Standalone verify — checks git-modified changes only, shows summary, Opus 5 medium
+---
+
+Use the **orc-verify** skill independently (no orchestrator): verify
+only the git-modified changes in the working tree using Opus 5 medium effort,
+classify findings on the P0–P3 severity ladder (P0/P1 gate, P2/P3 advisory;
+every P0–P2 finding anchored with file:line + a verbatim quote, else it's
+auto-P3), and show the summary. Read-only — do not fix or commit.
+
+Optional focus: $ARGUMENTS

package/templates/commands/orc-wiki.md

@@ -0,0 +1,42 @@
+---
+description: Build/maintain the project knowledge base (wiki) — Opus 4.8 high, expensive, multi-session, warns before scanning
+---
+
+Use the **orc-wiki** skill. Start at Phase 0: auto-detect whether this is a
+repair of an unregistered wiki, a fresh build, a resume of an in-progress scan,
+or a refresh of an existing wiki, and branch accordingly. On a fresh build, show
+the cost warning and scan NOTHING until the user explicitly confirms. Refreshes
+also sweep for coverage gaps (changed files no doc covers → propose new areas)
+and dead docs (covered files gone → archive/delete, user decides). Every run
+registers via `orc wiki sync` and ends with the integrity self-check. Follow the
+skill's SKILL.md exactly.
+
+**Crosslink is always on.** Plain `/orc-wiki` — every scan, resume, incremental,
+full regenerate, or selective refresh — publishes/updates this repo's boundary
+tags (`wiki/crosslink/`) in the SAME pass as the docs, and a refresh never
+deletes them. There is no separate "generate crosslink" step in a wiki's normal
+life; the only crosslink config is the graph (`orc crosslink`), needed only to
+resolve what this repo consumes.
+
+**`/orc-wiki crosslink`** → the CROSSLINK-ONLY branch (Phase 3c) is a LEGACY
+BACKFILL: publish tags + resolve consumption from the existing docs'
+`Contracts & shapes` rows (opening only the files they anchor), for wikis whose
+docs predate v0.24.0 and so have no `wiki/crosslink/` yet. No area is re-scanned,
+no doc rewritten. On a wiki scanned at ≥v0.24.0, missing tags are not this
+branch — `orc wiki sync --check` names the real fix. Never a refresh.
+
+**`/orc-wiki crosslink compile`** → the one-shot CROSSLINK COMPILE branch
+(v0.33.0 — references/crosslink-compile.md): resolve/consume from the graph →
+generate the federation atlas (`wiki/crosslink/atlas.md`) → write it into each
+linked repo → inject/update the CLAUDE.md pointer block locally and in each
+linked repo (in-place, user content byte-preserved). Requires a crosslink
+config with ≥1 edge; every step warn-only; never a re-scan. Peer writes are
+FILE writes only — never a commit or push.
+
+| Argument | Branch |
+|---|---|
+| *(none)* | Phase 0 auto-branch: repair / fresh / resume / refresh (delta default) |
+| `crosslink` | Phase 3c legacy backfill (publish tags from existing docs) |
+| `crosslink compile` | one-shot resolve + atlas + CLAUDE.md injection (local + peers) |
+
+Optional focus (or `crosslink` / `crosslink compile`): $ARGUMENTS

package/templates/commands/orc.md

@@ -0,0 +1,16 @@
+---
+description: Full orchestrator — intake, planning, scored parallel subagents, review, verify, ship
+---
+
+Use the **orc** skill to handle this request end to end: Phase 0
+intake (with intent-spec sign-off), planning, per-task scoring, spawning scored
+subagents in conflict-free waves, review, verify, and ship. Follow the skill's
+SKILL.md exactly.
+
+If the input IS a plan (pasted planning-output, a `plan-{name}.md` path, or an
+`orc/planner/{name}/` checkpoint) rather than a request, the skill switches to
+its plan-handoff entry contract (`references/plan-handoff.md`) — it re-grounds
+and re-scores the plan in this session, then runs Phase 2–8; it never executes a
+handed-off plan task-by-task ad hoc.
+
+Request: $ARGUMENTS

package/templates/hooks/orc-effort-guard.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * ORC effort guard — a Claude Code PreToolUse hook.
+ *
+ * Blocks invocation of the full `orc` orchestrator skill unless the MAIN
+ * session is running at HIGH reasoning effort (Opus 5 / Fable 5 clear at
+ * medium+ — see the session-model bridge below). This is the one half of the
+ * "run ORC on Opus 4.8 high or better" rule hooks can enforce deterministically:
+ * Claude Code exposes `effort.level` (and $CLAUDE_EFFORT) to PreToolUse, but
+ * NOT the model id (only SessionStart may see the model, and cannot block).
+ * The model tier is surfaced separately by the statusline warning + the
+ * self-check inside skills/orc/SKILL.md.
+ *
+ * Wiring (installed by `orc init` into .claude/settings.json):
+ *   hooks.PreToolUse[] { matcher: "Skill", hooks:[{ type:"command",
+ *     command: 'node "<.claude>/hooks/orc-effort-guard.js"' }] }
+ *
+ * Contract: read PreToolUse JSON from stdin. Exit 0 = allow. Exit 2 = block
+ * the tool call and show stderr to Claude, which relays it to the user.
+ *
+ * Also surfaces a "newer orc version available" nudge here — this hook fires
+ * exactly when /orc is invoked, so it's the natural place to tell the user
+ * without them running `orc version`. On allow it emits a `systemMessage`
+ * (shown to the user, NOT added to model context → zero tokens); on block it
+ * appends the nudge to the block reason. Version check is cached 24h and
+ * fail-silent. (systemMessage handling may vary by Claude Code version — verify
+ * with /doctor if you don't see it; the statusline shows it regardless.)
+ */
+
+// Shared update-check helper (sibling file). Degrade gracefully if absent.
+let updater = null;
+try {
+  updater = require("./orc-update-lib.js");
+} catch (_) {
+  updater = null;
+}
+
+// Effort ladder: low < medium < high < xhigh < max. A tier that meets the bar
+// meets it at that rung OR anything stronger — so "requires high" allows xhigh
+// and max too (the bug this fixes: an xhigh/max session was hard-blocked).
+const EFFORT_LADDER = ["low", "medium", "high", "xhigh", "max"];
+const effortsAtOrAbove = (e) => {
+  const i = EFFORT_LADDER.indexOf(String(e).toLowerCase());
+  return i === -1 ? ["high", "xhigh", "max"] : EFFORT_LADDER.slice(i);
+};
+
+// Session-model bridge (written by orc-statusline.js). The guard can't see the
+// model id itself, so it reads it here to grant the medium-effort allowance of
+// the models that are strictly stronger than the Opus 4.8 baseline (Opus 5 and
+// Fable 5). Fail-OPEN: missing / unreadable / stale → null, and the guard
+// behaves exactly as it would without a bridge (never blocks on our own error).
+// Stale = older than this window; a live session re-renders the statusline far
+// more often, so a fresh file always exists during active use.
+const BRIDGE_MAX_AGE_MS = 30 * 60 * 1000;
+function readSessionModel(projectDir) {
+  try {
+    const fs = require("fs");
+    const path = require("path");
+    const p = path.join(projectDir, ".claude", "orc", "session-model.json");
+    const j = JSON.parse(fs.readFileSync(p, "utf8").replace(/^/, ""));
+    if (!j || typeof j.written_at !== "number") return null;
+    if (Date.now() - j.written_at > BRIDGE_MAX_AGE_MS) return null;
+    return String(j.model_id || "");
+  } catch (_) {
+    return null;
+  }
+}
+// Models that clear /orc at medium effort — strictly stronger than the Opus 4.8
+// baseline, so medium on them beats high on it. Opus 5 (v0.34.0) joins Fable 5.
+// The `\b` after the 5 keeps 4.8 / 4.7 / 5-something-else correctly gated.
+const isMediumOkModel = (id) =>
+  /(opus|fable)[\s._-]?5\b/.test(String(id || "").toLowerCase());
+
+let raw = "";
+process.stdin.on("data", (c) => (raw += c));
+process.stdin.on("end", () => {
+  let data = {};
+  try {
+    data = JSON.parse(raw || "{}");
+  } catch (_) {
+    // Unparseable payload — never block on our own error.
+    process.exit(0);
+  }
+
+  const tool = data.tool_name || "";
+  const input = data.tool_input || {};
+  const skill = String(input.skill || input.name || "");
+
+  // Only gate the full orchestrator and the compiled DIY lane. orc-mini /
+  // orc-fast / orc-analyze / subskills pass — orc-fast is DESIGNED to run at
+  // Sonnet medium; never widen this match to include it.
+  const isOrc = tool === "Skill" && /^orc$/i.test(skill);
+  const isDiy = tool === "Skill" && /^orc-diy$/i.test(skill);
+  if (!isOrc && !isDiy) process.exit(0);
+
+  const effort = String(
+    (data.effort && data.effort.level) || process.env.CLAUDE_EFFORT || ""
+  ).toLowerCase();
+  const installed = updater ? updater.installedVersion(__dirname) : null;
+  const projectDir = data.cwd || process.cwd();
+
+  // Baseline /orc: the session must be at high effort OR stronger (xhigh/max).
+  // Opus 5 and Fable 5 additionally clear at medium — strictly-capable models —
+  // detected through the session-model bridge (the guard can't see the model id
+  // itself; fail-open when the bridge is missing/stale, i.e. medium stays blocked).
+  let requiredEfforts = effortsAtOrAbove("high");
+  let requiredLabel =
+    "Opus 4.8 at high effort (Opus 5 / Fable 5 also clear at medium+)";
+  if (!isDiy && isMediumOkModel(readSessionModel(projectDir))) {
+    requiredEfforts = ["medium", ...requiredEfforts];
+  }
+
+  // /orc-diy: the required tier is whatever the flow was COMPILED for — read
+  // it from flow.lock.json (written only by the `orc diy` CLI). Fail closed:
+  // no lock = no compiled flow = deterministic onboarding block. `compile` /
+  // `status` invocations pass at any effort (they just shell out to the CLI).
+  if (isDiy) {
+    if (/^\s*(compile|status)\b/i.test(String(input.args || ""))) process.exit(0);
+    const fs = require("fs");
+    const path = require("path");
+    let lock = null;
+    try {
+      lock = JSON.parse(
+        fs
+          .readFileSync(
+            path.join(projectDir, ".claude", "orc", "diy", "flow.lock.json"),
+            "utf8"
+          )
+          .replace(/^\uFEFF/, "")
+      );
+    } catch (_) {}
+    if (!lock || !lock.session_tier) {
+      process.stderr.write(
+        "\n⛔ /orc-diy blocked — no compiled flow in this project (fail-closed gate)." +
+          "\n   Compose and build your flow in the terminal first:" +
+          "\n     orc diy init        (then shape it: orc diy set <key> <value>)" +
+          "\n     orc diy compile" +
+          "\n   Guide: .claude/skills/orc-diy/README.md — or use plain /orc for this request.\n"
+      );
+      process.exit(2);
+    }
+    // Effort half is DETERMINISTIC from the compiled slug's suffix (allow that
+    // effort or anything stronger); the model half is warn-only on the
+    // statusline (hooks can't block on model). Covers the full tier grid —
+    // sonnet-4-6 / opus-4-7 / opus-4-8 / fable-5 at med|high|xhigh|max.
+    const m = String(lock.session_tier).match(/-(med|high|xhigh|max)$/);
+    const slugEffort = m ? (m[1] === "med" ? "medium" : m[1]) : "high";
+    requiredEfforts = effortsAtOrAbove(slugEffort);
+    requiredLabel = `${lock.session_tier} (compiled session_tier — needs effort ${slugEffort}+)`;
+  }
+
+  const decide = (nudge) => {
+    if (requiredEfforts.includes(effort)) {
+      // Requirement met — allow. Surface a version nudge if one exists.
+      if (nudge) {
+        try {
+          process.stdout.write(JSON.stringify({ systemMessage: nudge }));
+        } catch (_) {}
+      }
+      process.exit(0);
+    }
+
+    process.stderr.write(
+      `\n⛔ ${isDiy ? "/orc-diy" : "ORC"} blocked — required effort not met` +
+        (effort ? ` (current effort: ${effort}).` : " (effort not detected).") +
+        `\n   Switch this session to ${requiredLabel}, then re-run.` +
+        "\n   Run the MAIN session at (or above) the required tier — subagents cannot" +
+        "\n   exceed the main tier, so pinned agents silently downgrade below it.\n" +
+        (nudge ? "\n" + nudge + "\n" : "")
+    );
+    process.exit(2);
+  };
+
+  if (updater) updater.refreshAndNudge(installed, decide);
+  else decide(null);
+});