@azure-id/orc 1.9.0 → 1.9.2

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

@@ -74,9 +74,9 @@ hand off to orc-mini via the fallback contract below. Never stop the chat.
 
 **e. Code graph cache — NOT a gate, and never skipped** (`../_shared/code-graph.md` §0). Every call carries
 `--if-enabled`: exit 3 = off → print `graph: off` once, make no other graph call. Print each JSON `line`; put
-each `trace` in the next packet VERBATIM. (1) **Here:** `orc graph status --if-enabled --heal --json` builds or
-updates the cache itself. (2) **F2 slice:** ONE `orc graph ctx <declared files> --if-enabled --json` → its `card`
-is the `graph` block; the return carries `graph_used`. (3) **F3 GREEN:** `orc graph update --if-enabled --json`,
+each `trace` in the next packet VERBATIM. (1) **Here:** `orc graph status --if-enabled --heal --json --brief` builds or
+updates the cache itself. (2) **F2 slice:** ONE `orc graph ctx <declared files> --if-enabled --json --brief` → its `card`
+is the `graph` block; the return carries `graph_used`. (3) **F3 GREEN:** `orc graph update --if-enabled --json --brief`,
 then one `orc graph notes pending` batch — the next run starts from this cache. A missing graph never falls back.
 
 **d. Extra — a PROBE, not a gate (P0).** Run `orc extra resolve --slot fast-executor --json` (0 = extra, 1 = Claude) — **a gate that is never probed is a gate that is always off**, and without this step the lane silently runs on Claude however `extra_enabled` and `orc extra role` were set. `extra` → print the `extra:` line HERE and carry the answer into F2; `claude` → print nothing, never fall back, never stop.
@@ -99,7 +99,7 @@ migration) and write the intent-spec + a minimal checkpoint.
 ## Phase F2 — Slice build + dispatch (ONE executor)
 
 Build one slice for `orc-executor-sonnet-4-6-high` (dispatch BY NAME; model
-pinned in the agent file). **Under `opus5_only` it is `orc-executor-opus-5-low`** — forced, and while that mode is on this lane needs an Opus 5 main session, so the "runs fine at Sonnet medium" premise applies only with it off (`../_shared/opus5-only.md`).
+pinned in the agent file). **Under `opus5_only` it is `orc-executor-opus-5-low`** — forced, and while that mode is on this lane needs an Opus 5.5 main session, so the "runs fine at Sonnet medium" premise applies only with it off (`../_shared/opus5-only.md`).
 
 **Extra (`extra_enabled`, `../_shared/extra-dispatch.md`):** the same slice may run off Claude. **This lane has no score at all, so it holds a POSITION, not a band:** resolve `orc extra resolve --slot fast-executor --json` (set with `orc extra role set fast-executor <profile>/<model>`). No row on that slot = Claude, and that is an answer, not a gap. The `extra:` line joins the F0 preflight (P0, printed whenever the gate is on) and NAMES the agent it displaces — `orc-executor-sonnet-4-6-high`; dispatch through `orc extra dispatch --task <file> --json` with `slot: "fast-executor"` and **no `score`** (both is refused by name); validate with `return-validation.md` **§2b, not §2**; a failure runs `orc extra reconcile <task_id>` FIRST — a worktree that moved is RESUMED, never re-done — then falls back to that same pinned agent BY NAME, announced. Extra is orthogonal to the knowledge gate — a fresh wiki and a cached pattern are still required, and a foreign worker gets the same pointers-not-content slice.
 

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

@@ -23,7 +23,7 @@ it — the human-onboarding lane. It is NOT the wiki: the wiki grounds the
 
 **Dispatch, don't do.** Whatever model this chat runs on, the skill only picks
 the topic/mode and spawns `orc-learn-writer-opus-5-low` (the pinned
-engine) — the deepening scan + all writes run at Opus 5 low regardless of
+engine) — the deepening scan + all writes run at Opus 5.5 low regardless of
 the caller's tier. The skill's only self-writes are the behavior-trace
 markers around the spawn. Interactivity is DELIBERATELY minimal but non-zero
 (unlike orc-claude): exactly one question per mode — "which feature?" (INIT)
@@ -173,16 +173,16 @@ exit code, and never re-derive a state word — the CLI's state words are the on
 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-learn --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 **none** · safe point **single dispatch**. Nothing here to checkpoint, so all three modes behave identically — say so rather than asking. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.
+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-learn --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 **none** · safe point **single dispatch**. Nothing here to checkpoint, so all three modes behave identically — say so rather than asking. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.

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

@@ -1,61 +1,61 @@
-# Worked example — orc-learn runs (mock; orient only, never execute from this)
-
-## Run 1 — INIT with a fresh wiki
-
-U: /orc-learn
-C: Repo root found. Reads wiki/INDEX.md + the wiki manifest → tier FRESH.
-   Presents the wiki's feature areas; user picks "orders". Slug: `orders`.
-   Spawns orc-learn-writer-opus-5-low with mode=init, covers from the
-   orders doc's globs (the skill never writes the docs itself).
-W: Reads the orders wiki doc for boundary + contracts, re-verifies against
-   code. Deepens: maps 14 functions (file:line), traces one real flow —
-   POST /orders → validate (routes/orders.ts:31) → price (pricing.ts:88) →
-   persist (repo/orders.ts:15) → emit event → 201. Harvests 3 invariants,
-   4 why-this-way findings, 2 couplings.
-W: Writes learning-docs/orders/knowledge.md (fingerprint header:
-   source_commit=HEAD, 9 hashed files; functions & flow; contracts; verify
-   commands from the wiki manifest's `commands`) and learning.md (mental
-   model, walkthrough of the SAME flow, 3 change recipes, gotchas, FAQ ×6).
-   Derives learning-docs/INDEX.md. Returns functions_mapped=14,
-   flow_traced=true, faq_count=6, actual_model=claude-opus-5,
-   actual_effort=low.
-C: Relays the report. `learning-docs/` not in .gitignore → offers the line;
-   user accepts → appended.
-
-## Run 2 — INIT, no wiki
-
-U: /orc-learn focus=src/billing
-C: No wiki/ → tier none (traced all the same). Asks only to confirm the
-   feature ("billing", from the focus pointer). Writer does a TARGETED scan
-   of src/billing/** only — never repo-wide — then deepens and writes the
-   pair as above.
-
-## Run 3 — REFRESH, multi-select
-
-U: /orc-learn refresh
-C: Reads each learning-docs/*/knowledge.md header; computes tiers on read:
-   orders STALE (drift hit pricing.ts), billing FRESH. Shows BOTH with
-   flags; user picks orders only. One writer dispatch regenerates the orders
-   pair (new source_commit, recomputed hashes, changelog line), re-derives
-   INDEX.md. billing: byte-untouched.
-
-## Run 4 — behavior trace (permanent, always on)
-
-The skill writes the run pointer (`run-learn-<slug>-<DDMMYY>-<HHMMSS>.txt` into
-`log_dir`) before the spawn, 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):
-
-```
-[170726 10:02:01.050] writer   WIKI-CONSULT tier=FRESH :: topic-pick
-[170726 10:02:44.310] writer   DISPATCH orc-learn-writer :: init orders expect=opus-5/low
-[170726 10:02:44.420] hook     SPAWN orc-learn-writer-opus-5-low
-[170726 10:06:12.900] hook     RETURN
-[170726 10:06:13.010] writer   VERIFY writer actual=claude-opus-5/low ✅ MATCH
-[170726 10:06:13.120] writer   FINISH :: init orders
-```
-
-Then the writer packet returns and the run pointer is deleted (in that order).
-REFRESH traces one DISPATCH/VERIFY pair per
-selected feature, ending `FINISH :: refresh <n> features`. No phase/score/
-finding/verdict markers — this lane runs none of those phases.
+# Worked example — orc-learn runs (mock; orient only, never execute from this)
+
+## Run 1 — INIT with a fresh wiki
+
+U: /orc-learn
+C: Repo root found. Reads wiki/INDEX.md + the wiki manifest → tier FRESH.
+   Presents the wiki's feature areas; user picks "orders". Slug: `orders`.
+   Spawns orc-learn-writer-opus-5-low with mode=init, covers from the
+   orders doc's globs (the skill never writes the docs itself).
+W: Reads the orders wiki doc for boundary + contracts, re-verifies against
+   code. Deepens: maps 14 functions (file:line), traces one real flow —
+   POST /orders → validate (routes/orders.ts:31) → price (pricing.ts:88) →
+   persist (repo/orders.ts:15) → emit event → 201. Harvests 3 invariants,
+   4 why-this-way findings, 2 couplings.
+W: Writes learning-docs/orders/knowledge.md (fingerprint header:
+   source_commit=HEAD, 9 hashed files; functions & flow; contracts; verify
+   commands from the wiki manifest's `commands`) and learning.md (mental
+   model, walkthrough of the SAME flow, 3 change recipes, gotchas, FAQ ×6).
+   Derives learning-docs/INDEX.md. Returns functions_mapped=14,
+   flow_traced=true, faq_count=6, actual_model=claude-opus-5-5,
+   actual_effort=low.
+C: Relays the report. `learning-docs/` not in .gitignore → offers the line;
+   user accepts → appended.
+
+## Run 2 — INIT, no wiki
+
+U: /orc-learn focus=src/billing
+C: No wiki/ → tier none (traced all the same). Asks only to confirm the
+   feature ("billing", from the focus pointer). Writer does a TARGETED scan
+   of src/billing/** only — never repo-wide — then deepens and writes the
+   pair as above.
+
+## Run 3 — REFRESH, multi-select
+
+U: /orc-learn refresh
+C: Reads each learning-docs/*/knowledge.md header; computes tiers on read:
+   orders STALE (drift hit pricing.ts), billing FRESH. Shows BOTH with
+   flags; user picks orders only. One writer dispatch regenerates the orders
+   pair (new source_commit, recomputed hashes, changelog line), re-derives
+   INDEX.md. billing: byte-untouched.
+
+## Run 4 — behavior trace (permanent, always on)
+
+The skill writes the run pointer (`run-learn-<slug>-<DDMMYY>-<HHMMSS>.txt` into
+`log_dir`) before the spawn, 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):
+
+```
+[170726 10:02:01.050] writer   WIKI-CONSULT tier=FRESH :: topic-pick
+[170726 10:02:44.310] writer   DISPATCH orc-learn-writer :: init orders expect=opus-5/low
+[170726 10:02:44.420] hook     SPAWN orc-learn-writer-opus-5-low
+[170726 10:06:12.900] hook     RETURN
+[170726 10:06:13.010] writer   VERIFY writer actual=claude-opus-5-5/low ✅ MATCH
+[170726 10:06:13.120] writer   FINISH :: init orders
+```
+
+Then the writer packet returns and the run pointer is deleted (in that order).
+REFRESH traces one DISPATCH/VERIFY pair per
+selected feature, ending `FINISH :: refresh <n> features`. No phase/score/
+finding/verdict markers — this lane runs none of those phases.

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

@@ -16,7 +16,7 @@ below. Load its references and schemas by path — the HOT-PATH essentials
 (dispatch names, return-contract fields, artifact path) are inlined here so
 nothing is reconstructed from "full minus deltas."
 
-Run as **Opus 4.8 high**, or Opus 5 / Fable 5 at medium+ (as full; never downgrade).
+Run as **Opus 4.8 high**, or Opus 5.5 / Fable 5 at medium+ (as full; never downgrade).
 **You never implement — you spawn.** The one exception is the **smoke gate**: a
 read-only build+test run, not implementation — you still never write code.
 **Worked example** (orient only — never execute from it): `examples/mini-run-mock.md`.
@@ -73,12 +73,12 @@ returned `gotcha_recorded` YOURSELF. `.claude/orc/gotchas.md` and the mechanics:
 ## Code graph cache — consult, build, use, update (`../_shared/code-graph.md` §0)
 
 Never skipped. Every call carries `--if-enabled`: exit 3 = off → print `graph: off` once, make no other graph call. Print each JSON `line` in chat; put each `trace` in the next packet VERBATIM.
-1. **Preflight, with the probes, before the planner:** `orc graph status --if-enabled --heal --json` — it builds or updates the cache itself.
-2. **Phase 0, before the tiered round:** `orc graph map --focus "<3–6 words from the request>" --budget 800 --if-enabled --json`. Its ranked files pre-fill Q4's `➡️` recommendation. Never ask what the map already answered.
-3. **Phase 1, into `graph_facts` and the complexity line:** `orc graph impact <declared_files> --if-enabled --json` (ONE call) and `orc graph cochange <each declared file> --if-enabled --json` — NUMBERS, never a judgment (`references/complexity.md`).
-4. **Phase 3 slice:** ONE `orc graph ctx <declared_files> --for-slice --if-enabled --json` → its `card` is the `graph` block, the OUTSIDE view. No card when the change stays inside one named file with no signature change (`../_shared/code-graph.md` §7). The return carries `graph_used`.
-5. **Phase M, before the suite:** `orc graph changes --if-enabled --json` names the tests that reach the change; run those first, then the suite. `risk` never prints without its `why`.
-6. **Phase M GREEN:** `orc graph update --notes-pending --files <actual_files> --if-enabled --json` — ONE call for the update AND the notes batch (§6) — then `orc graph gain --run <this run> --if-enabled --json`, `line` copied VERBATIM into the ship summary. It is an estimate with a range; never restate it as a saving.
+1. **Preflight, with the probes, before the planner:** `orc graph status --if-enabled --heal --json --brief` — it builds or updates the cache itself.
+2. **Phase 0, before the tiered round:** `orc graph map --focus "<3–6 words from the request>" --budget 800 --if-enabled --json --brief`. Its ranked files pre-fill Q4's `➡️` recommendation. Never ask what the map already answered.
+3. **Phase 1, ONE call:** `orc graph impact <declared_files> --complexity --risk=<facets.risk[] as class[@file:line],…> --if-enabled --json --brief`. Its `complexity.line` IS the complexity line — print it VERBATIM (`risk not given` → append the classes yourself); its `facts{}` IS `graph_facts` — paste it, then set `facts.map` to the `map --focus` card you already hold. No `complexity` in the answer (an older CLI) → count as `references/complexity.md` §2 says.
+4. **Phase 3 slice:** ONE `orc graph ctx <declared_files> --for-slice --if-enabled --json --brief` → its `card` is the `graph` block, the OUTSIDE view. No card when the change stays inside one named file with no signature change (`../_shared/code-graph.md` §7). The return carries `graph_used`.
+5. **Phase M, before the suite:** `orc graph changes --files=<actual_files> --if-enabled --json --brief` — print its `tests_line`, run the files its `tests[]` names first, then the suite, then its `blast_line` VERBATIM. The CLI attaches every `risk` word's `why`.
+6. **Phase M GREEN:** `orc graph update --notes-pending --files <actual_files> --if-enabled --json --brief` — ONE call for the update AND the notes batch (§6) — then `orc graph gain --run <this run> --if-enabled --json --brief`, `line` copied VERBATIM into the ship summary. It is an estimate with a range; never restate it as a saving.
 
 ## Phase M — Smoke gate (build + test; blocks ship on red)
 
@@ -134,17 +134,13 @@ trace. `OUTCOME … band=mini` per task.
 
 ## Complexity read (replaces the scoring table) — `references/complexity.md`
 
-ONE line before dispatch, carrying its own NUMBERS — never a narrative
-judgment. Counted from `graph_facts` and `facets.risk[]`; how, and why each
-threshold is that number: `references/complexity.md`.
+ONE line before dispatch, carrying its own NUMBERS. **The CLI computes it** —
+`complexity.line` from the Phase 1 call, printed VERBATIM. The four thresholds,
+the `(graph off)` form and why each number is that number: `references/complexity.md`.
 `complexity: mini-ok — 3 files · confident callers 4 in 2 files · tests reach 2 · risk none · cochange none`
-**Recommend the full lane when ANY holds:** confident callers in 4+ files
-outside `declared_files` · 8+ confident callers · any `facets.risk[]` entry · a
-`cochange` partner with 3+ co-commits not in the plan. `AMBIGUOUS` callers print
-as `maybe <n>` and never trip one alone. Graph off → the `(graph off)` form,
-from `facets.risk[]` alone; never invent a number. It is an OFFER: *1. switch to
-/orc (recommended — <the reason>) · 2. continue in mini*. Continuing writes the
-NUMBERS into the decision log. Trace: `GATE complexity :: <the line>`.
+It is an OFFER: *1. switch to /orc (recommended — <the reason>) · 2. continue in
+mini*. Continuing writes the NUMBERS into the decision log, so `/orc-retro` can
+move a threshold instead of anyone arguing about it. Trace: `GATE complexity :: <the line>`.
 
 ## Fallback intake (arriving from orc-fast)
 
@@ -162,7 +158,7 @@ mini skipped. Record the switch in the decision log.
 
 ## Dispatch via named agents (canonical name-map — dispatch BY these names)
 
-Models pinned in `.claude/agents/`; look one up here, never reconstruct a name (agent = skill-name + model-effort suffix). See `.claude/agents/MODEL-MAPPING.md`. `opus5_only: true` FORCES the right column and needs an Opus 5 main session — mini's cheap-lane premise is off while it is on (`../_shared/opus5-only.md`).
+Models pinned in `.claude/agents/`; look one up here, never reconstruct a name (agent = skill-name + model-effort suffix). See `.claude/agents/MODEL-MAPPING.md`. `opus5_only: true` FORCES the right column and needs an Opus 5.5 main session — mini's cheap-lane premise is off while it is on (`../_shared/opus5-only.md`).
 
 **Extra (`extra_enabled`, `../_shared/extra-dispatch.md`):** mini's ONE executor may run off Claude. It has no score, so resolve the pinned executor's **BAND, both edges, and require them to agree** — a partially covering row keeps the run on Claude and the preflight says so. Print the `extra:` line at intake whenever the gate is on (P0: `a lane that sends work off Claude without saying so`); dispatch via `orc extra dispatch --task <file> --json` with the IDENTICAL slice; validate with `return-validation.md` **§2b, not §2** (⛔ SUBSTITUTION replaces the downgrade check); a failure runs `orc extra reconcile <task_id>` FIRST — a worktree that moved is RESUMED, never re-done — then falls back to the pinned Claude agent, announced. A cited-risk change never leaves Claude (`extra_risk_tasks`, default `off`) — and mini's complexity read is not a substitute for that gate.
 
@@ -171,7 +167,7 @@ Models pinned in `.claude/agents/`; look one up here, never reconstruct a name (
 | mini analysis (docs only) | `orc-analyze-mini-sonnet-5-high` | claude-sonnet-5 / high | `orc-analyze-mini-opus-5-med` |
 | mini planning | `orc-planner-mini-sonnet-5-high` | claude-sonnet-5 / high | `orc-planner-mini-opus-5-med` |
 | mini execution | `orc-executor-sonnet-5-high` | claude-sonnet-5 / high | `orc-executor-opus-5-low` |
-| test authoring (opt-in) | `orc-test-author-opus-5-med` | claude-opus-5 / medium | unchanged |
+| test authoring (opt-in) | `orc-test-author-opus-5-med` | claude-opus-5-5 / medium | unchanged |
 
 ## Config
 
@@ -235,7 +231,7 @@ mini-analyst return: evidence spot-check + derivation lint; refuse
 take-into-build on open `UNVERIFIED`/missing `scope_closed`; `git_head` ≠
 HEAD at plan time → re-run the spot-check first. On mini-planner return: confirm
 every `disposition: exists` path with `orc graph ctx <paths> --if-enabled
---json`, FIVE at a time — exit 0 confirms, exit 4 or an unindexed path falls
+--json --brief`, FIVE at a time — exit 0 confirms, exit 4 or an unindexed path falls
 back to a Glob. Then recompute coverage (no orphan requirements), cycle +
 collision checks. Any miss → bounce (one retry, then escalate). At dispatch,
 append the task's `spec_invariants` to the slice's `constraints[]` verbatim.

package/templates/skills/orc-mini/references/complexity.md

@@ -6,23 +6,30 @@ the answer is an OFFER — the user always chooses.
 
 It runs after the planner returns and passes the exit gate, before dispatch.
 
-## 1. The three calls
+## 1. The one call
 
 | Call | What you take from it | Exit codes |
 |---|---|---|
-| `orc graph impact <declared_files> --if-enabled --json` | confident callers OUTSIDE `declared_files`, the distinct files they sit in, the tests that reach | 0 found · 1 no graph · 3 off · 4 not found |
-| `orc graph cochange <each declared file> --if-enabled --json` | partners with `count >= 3` that are not in `declared_files` | 0 rows · 1 no history · 3 off · 4 none |
-| the planner's own `facets.risk[]` | the cited risk classes | — |
+| `orc graph impact <declared_files> --complexity [--risk=<class>[@<file:line>],…] --if-enabled --json --brief` | `complexity.line` (print it verbatim), `complexity.numbers`, `complexity.why[]`, and `facts{}` for the planner slice | 0 found · 1 no graph · 3 off · 4 not found |
+| the planner's own `facets.risk[]` | the cited risk classes — pass them in `--risk=`, so the ONE line is complete | — |
 
-One `impact` call for ALL the declared files. `cochange` is one call per file.
+ONE call for ALL the declared files, and it answers what `impact` plus one
+`cochange` per file used to answer. The co-change half runs inside the same
+process, against the same per-HEAD cache.
 
-**Exit 3 anywhere means the graph is off.** Print the `graph off` form of the
-line (§3) and decide from `facets.risk[]` alone. Never invent a number.
+**Exit 3 means the graph is off.** Print the `graph off` form of the line (§3)
+and decide from `facets.risk[]` alone. Never invent a number.
+
+**An older CLI** answers without `complexity` and without `facts`. Then count as
+§2 says, from `impact` and one `cochange` per file, and print the line yourself.
 
 ## 1b. `graph_facts` — the same numbers, in the planner slice
 
-The planner is dispatched BEFORE the complexity read, and it gets the same
-facts, so it can ground its own plan on them instead of guessing:
+The CLI returns them in `facts{}`, in exactly this shape. `map` comes back
+`null`: the lane already holds the `map --focus` card from Phase 0 and fills it
+in, so the same card is never computed twice. The planner is dispatched BEFORE
+the complexity read and gets the same facts, so it can ground its own plan on
+them instead of guessing:
 
 ```yaml
 graph_facts:
@@ -36,7 +43,7 @@ The graph off, or every call exit 3 → `graph_facts: null`, and the planner pla
 as it did before. A `cochange` partner that is not in the plan becomes an
 `open_questions[]` entry — never a file the planner adds in silence.
 
-## 2. How to count
+## 2. How the CLI counts
 
 **Confident callers** are the edges the graph is sure about: `LOCAL`, `IMPORT`,
 `UNIQUE` and `ROUTE`. A `ROUTE` edge is a test or a client that reaches the code
@@ -50,9 +57,16 @@ caller is counted, never followed.
 is not blast radius — it is part of the change. Only callers outside
 `declared_files` count.
 
+The four numbers live in `bin/graph-signals.js` as `COMPLEXITY_CALLER_FILES`,
+`COMPLEXITY_CALLERS` and `COMPLEXITY_COCHANGE_MIN` (the fourth is "any risk
+class"). **Change them there and here in the same commit.** The answer carries
+them in `complexity.thresholds`, so a reader can always check the verdict
+against the numbers that produced it.
+
 ## 3. The line
 
-Print exactly one line. Three shapes:
+Print exactly one line — the CLI's `complexity.line`, verbatim. The lane prints
+the third shape itself, because the CLI never answered. Three shapes:
 
 ```
 complexity: mini-ok — 3 files · confident callers 4 in 2 files · tests reach 2 · risk none · cochange none

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

@@ -56,7 +56,7 @@ is a pointer into nothing.
    knowledge never stops the run, never causes a fallback, never triggers a
    scan. Print ONE line each.
 4. **Code graph cache — never skipped** (`../_shared/code-graph.md` §0). Run
-   `orc graph status --if-enabled --heal --json`: it builds or updates the cache
+   `orc graph status --if-enabled --heal --json --brief`: it builds or updates the cache
    in the same call. Print its `line`; put its `trace` (`GRAPH-CONSULT …`) in the
    packet VERBATIM. Exit 3 = off → no other graph call this session. Every graph
    call carries `--if-enabled`, so the CLI reads the `code_graph` keys —
@@ -94,11 +94,11 @@ Print it on ONE line so nothing is skipped in secret:
 
 **The dig — graph first** (`references/look.md`). Ask the graph BEFORE any
 Grep; Grep only for what the graph does not know.
-- Names a file or symbol → `orc graph ctx <targets> --if-enabled --json`, 5 at
+- Names a file or symbol → `orc graph ctx <targets> --if-enabled --json --brief`, 5 at
   most. Names none → `orc graph map --focus "<3–6 words>" --budget 800
-  --if-enabled --json`, then `ctx` on the files it ranks first. Asks what breaks
+  --if-enabled --json --brief`, then `ctx` on the files it ranks first. Asks what breaks
   or who uses something → `ctx <symbol> --depth 2` and `orc graph coverage
-  <files> --if-enabled --json` before you call anything absent. Exit 3 →
+  <files> --if-enabled --json --brief` before you call anything absent. Exit 3 →
   Grep/Glob. Exit 4 → Grep the name, carry EVERY candidate into your question.
   Copy each `line` into chat, each `trace` into the running record. A `map`
   answer is ONE call; a card never replaces reading the range it names.
@@ -155,7 +155,7 @@ Rules:
 
 Put in the slice: the change sketch, the Q2 answers, 2–3 acceptance bullets, the
 `graph` block from `orc graph ctx <declared files> --for-slice --if-enabled
---json` (the OUTSIDE view — `references/look.md` §5), the wiki **paths**, the
+--json --brief` (the OUTSIDE view — `references/look.md` §5), the wiki **paths**, the
 cached pattern (whole text), the `house_rules` card
 (`../_shared/phases/house-rules.md`, whole text), the `rules_card` under it
 (`orc rules slice --lane orc-quick --json` → `text`, whole text), PR comments
@@ -187,12 +187,11 @@ say it once; never invent a build command — take it from `wiki-meta.json`'s
 exit=<n>` then `REPRO green :: <cmd> exit=0`. `repro: none` → say **not
 reproduced** with the reason (`references/defect.md`).
 
-**Affected tests first.** Run `orc graph changes --if-enabled --json`, keep the
-`symbols[]` whose `file` is in the return's `actual_files`, and run the test
-files their `tests[]` name BEFORE the suite — when the runner takes a file list.
-A runner that takes none → one line saying so. Then print the blast radius from
-the same answer, one line, and never a `risk` word without its `why`. Zero
-symbols in the graph → `blast radius   none indexed (<n> files not in the graph)`.
+**Affected tests first.** Run `orc graph changes --files=<actual_files> --if-enabled
+--json --brief`. Print its `tests_line`, run the files its `tests[]` names BEFORE
+the suite — a runner that takes no file list → one line saying so — and append
+` → <n> passed`. Then the suite. Then print its `blast_line` VERBATIM: the CLI
+attaches every `risk` word's `why`, so never restate it. Exit 3 → nothing.
 
 `tests reached  3 files (ROUTE 2 · call 1) → 12 passed` · then the suite · then
 `blast radius   3 symbols · callers 7 in 4 files · tests reach 2 · risk high: <symbol> (exported, fan-in 4, no test reaches it)`
@@ -210,13 +209,13 @@ Never offer commit while tests are red.
 
 **After a request that WROTE code** (never after a read-only one), so the next
 request and the next session start from a current cache, in this order:
-`orc graph update --notes-pending --files <actual_files> --if-enabled --json`
+`orc graph update --notes-pending --files <actual_files> --if-enabled --json --brief`
 — ONE call that answers both (print its `line`, copy its `trace`). Exit 0 on
 `notes` → dispatch `orc-graph-noter-sonnet-4-6-med` in the SAME tool block as
 this doc write. It is ORC bookkeeping, like the trace writer — not a Q2 gate
 dispatch (`references/dispatch-gate.md` rule 8). Exit 3 or 5 → nothing. Then,
 after the entry is appended, `orc graph gain --run <this run> --if-enabled
---json` → print its `line` VERBATIM into chat and the entry. It is an estimate
+--json --brief` → print its `line` VERBATIM into chat and the entry. It is an estimate
 with a range; never restate it as a saving.
 
 Append entry N to `orc-quick/<slug>/quick-context.md`

package/templates/skills/orc-quick/references/gh-mode.md

@@ -70,7 +70,7 @@ It does not tell you what sits there or what depends on it.
 For each thread the user takes, run one call:
 
 ```bash
-orc graph ctx <the anchor file:line> --if-enabled --json
+orc graph ctx <the anchor file:line> --if-enabled --json --brief
 ```
 
 It names the symbol the comment sits in, its callers, and the tests that reach

package/templates/skills/orc-quick/references/look.md

@@ -20,9 +20,9 @@ way round.
 
 | The request | The call |
 |---|---|
-| names a file or a symbol | `orc graph ctx <targets> --if-enabled --json` — 5 targets at most |
-| names none ("where is the retry logic?") | `orc graph map --focus "<3–6 words from the request>" --budget 800 --if-enabled --json`, then `ctx` on the files it ranks first |
-| asks what breaks, or who uses something | `orc graph ctx <symbol> --depth 2 --if-enabled --json`, then `orc graph coverage <files> --if-enabled --json` |
+| names a file or a symbol | `orc graph ctx <targets> --if-enabled --json --brief` — 5 targets at most |
+| names none ("where is the retry logic?") | `orc graph map --focus "<3–6 words from the request>" --budget 800 --if-enabled --json --brief`, then `ctx` on the files it ranks first |
+| asks what breaks, or who uses something | `orc graph ctx <symbol> --depth 2 --if-enabled --json --brief`, then `orc graph coverage <files> --if-enabled --json --brief` |
 
 Exit 3 = the graph is off → Grep and Glob, as before, and make no other graph
 call this session. Exit 1 = no index → the same. **A `map` answer is ONE call**,
@@ -52,7 +52,7 @@ candidate into your Q2 question. Never pick one in silence.
 
 "What breaks if I change this?" · "Who uses this?" · "Is it safe to change?"
 
-Run `orc graph coverage <the files in play> --if-enabled --json` FIRST. A file
+Run `orc graph coverage <the files in play> --if-enabled --json --brief` FIRST. A file
 whose coverage is `partial` is read in the source before you call anything
 absent in it.
 
@@ -75,7 +75,7 @@ sentence, word for word:
 ## 5. What you hand to an executor
 
 ```
-orc graph ctx <declared files> --for-slice --if-enabled --json
+orc graph ctx <declared files> --for-slice --if-enabled --json --brief
 ```
 
 ONE call, 10 files at most. Its `card` becomes the slice's `graph` block. This

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

@@ -5,7 +5,7 @@ description: >
   "/orc-verify", or "check the modified files". Runs INDEPENDENTLY —
   no orchestrator, no planning, no run folder required. Verifies only the
   git-modified changes in the working tree and shows a summary of results. Uses
-  Opus 5 medium effort. Read-only: it reports, it does not fix or commit.
+  Opus 5.5 medium effort. Read-only: it reports, it does not fix or commit.
 ---
 
 # ORC-VERIFY (standalone)
@@ -13,7 +13,7 @@ description: >
 A focused, dependency-free verify pass. No intake, no planning, no checkpoint —
 you point it at your uncommitted work and it tells you what's wrong.
 
-Run as Opus 5, medium effort.
+Run as Opus 5.5, medium effort.
 
 **Worked example** (orient only — never execute from it): `examples/verify-mock.md`.
 
@@ -97,16 +97,16 @@ exit code, and never re-derive a state word — the CLI's state words are the on
 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-verify --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 **none** · safe point **single dispatch**. Nothing here to checkpoint, so all three modes behave identically — say so rather than asking. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.
+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-verify --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 **none** · safe point **single dispatch**. Nothing here to checkpoint, so all three modes behave identically — say so rather than asking. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.

package/templates/skills/orc-verify/examples/verify-mock.md

@@ -1,33 +1,33 @@
-# Example — Annotated Standalone Verify (dry run)
-
-V: = verifier (Opus 5 medium) · U: = user. Nothing real. Runs INDEPENDENTLY — no
-orchestrator, no planning, no run folder. Read-only: it reports, never fixes or commits.
-
-U: /orc-verify
-
-## Scope — git-modified changes only
-V: [git status/diff] 3 modified files: api/routes/orders.py, api/schemas.py,
-   tests/test_orders.py. Nothing staged beyond the working tree — verifying exactly
-   these changes (no repo-wide sweep).
-
-## Build + tests
-V: [detects Python/poetry/pytest]
-   $ poetry run pytest tests/test_orders.py  → 11 passed
-   $ poetry run mypy api/                     → clean
-   Build/type/test: GREEN.
-
-## Diff sanity + findings (P0–P3 ladder)
-V: Walks each hunk against intent inferred from the diff (every P0–P2 finding
-   anchored: file:line + the offending line quoted VERBATIM, else auto-P3):
-   ⛔ P1  api/routes/orders.py:42 — quote: `async def get_order(order_id: str):`
-      — new `/orders/{id}` route has no auth decorator; every sibling route
-      uses `@require_auth`. Security risk — likely unintended.
-      (Not P0: build/tests are green.)
-   • P3  api/schemas.py:18 — field `createdAt` breaks the snake_case convention
-      used elsewhere (`created_at`).
-   • P2  tests/test_orders.py — no negative-path test for a missing id.
-
-## Summary (read-only — no edits, no commit)
-V: 1 P1, 1 P2, 1 P3. Tests green but the missing auth decorator gates the
-   commit (P0/P1 = fix before commit; P2/P3 advisory). I don't edit or commit —
-   hand this to /orc or fix manually, then re-run /orc-verify.
+# Example — Annotated Standalone Verify (dry run)
+
+V: = verifier (Opus 5.5 medium) · U: = user. Nothing real. Runs INDEPENDENTLY — no
+orchestrator, no planning, no run folder. Read-only: it reports, never fixes or commits.
+
+U: /orc-verify
+
+## Scope — git-modified changes only
+V: [git status/diff] 3 modified files: api/routes/orders.py, api/schemas.py,
+   tests/test_orders.py. Nothing staged beyond the working tree — verifying exactly
+   these changes (no repo-wide sweep).
+
+## Build + tests
+V: [detects Python/poetry/pytest]
+   $ poetry run pytest tests/test_orders.py  → 11 passed
+   $ poetry run mypy api/                     → clean
+   Build/type/test: GREEN.
+
+## Diff sanity + findings (P0–P3 ladder)
+V: Walks each hunk against intent inferred from the diff (every P0–P2 finding
+   anchored: file:line + the offending line quoted VERBATIM, else auto-P3):
+   ⛔ P1  api/routes/orders.py:42 — quote: `async def get_order(order_id: str):`
+      — new `/orders/{id}` route has no auth decorator; every sibling route
+      uses `@require_auth`. Security risk — likely unintended.
+      (Not P0: build/tests are green.)
+   • P3  api/schemas.py:18 — field `createdAt` breaks the snake_case convention
+      used elsewhere (`created_at`).
+   • P2  tests/test_orders.py — no negative-path test for a missing id.
+
+## Summary (read-only — no edits, no commit)
+V: 1 P1, 1 P2, 1 P3. Tests green but the missing auth decorator gates the
+   commit (P0/P1 = fix before commit; P2/P3 advisory). I don't edit or commit —
+   hand this to /orc or fix manually, then re-run /orc-verify.

package/templates/skills/orc-wiki/references/extra.md

@@ -20,7 +20,7 @@ tier:
 | `wiki-scanner-light` | `orc-wiki-scanner-sonnet-5-high` |
 
 Both collapse onto `orc-wiki-scanner-opus-5-med` while `opus5_only` is on, which
-is why this adds **no agent and no pair**. Two slots and one Opus 5 agent is not
+is why this adds **no agent and no pair**. Two slots and one Opus 5.5 agent is not
 a contradiction: a slot names the POSITION, not the model.
 
 ```