@azure-id/orc 1.9.1 → 2.0.2

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

@@ -1,14 +1,12 @@
 ---
 name: orc-fast
 description: >
-  Fastest ORC lane — knowledge-gated single-executor implementation. Use for
-  "use orc-fast to implement X" or "/orc-fast". Requires TWO prerequisites:
-  a fresh project wiki (orc-wiki) AND a cached code-pattern for the request's
-  language — the precomputed knowledge replaces the analyst/planner entirely.
-  Either missing → falls back to orc-mini (never stops the chat). One
-  Sonnet 4.6 high executor, a build+test smoke gate, one repair round, ship.
-  Orchestrator runs fine at Sonnet medium. The orchestrator never implements —
-  it spawns.
+  Fastest ORC lane — knowledge-gated single-executor implementation, with no
+  analyst and no planner. Use for "use orc-fast to implement X" or "/orc-fast".
+  Requires TWO prerequisites: a fresh project wiki (orc-wiki) AND a cached
+  code-pattern for the request's language. If either is missing, it falls back
+  to orc-mini. One Sonnet 4.6 high executor, a build+test smoke gate, one repair
+  round, ship.
 ---
 
 # ORC-FAST
@@ -32,24 +30,21 @@ fit gate hands it to orc-mini.
 
 ## Phases
 
-`orc lane phases orc-fast --json` is this lane's pipeline: the ordered list, where
-each phase lives, and how much of it to read. **The CLI owns the order** — never
-derive it from the headings below, and never renumber or rename one without the
-manifest, because a `read: section` pointer names a HEADING and a renamed heading
-is a pointer into nothing.
+`orc lane phases orc-fast --json` is this lane's pipeline. **The CLI owns the order**:
+never derive it from the headings below, and never rename or renumber one
+without the manifest (`../_shared/lane-contract.md` §Phases).
 
 ## Phase F0 — Preflight (the two prerequisite gates; no spawn)
 
-Emit a `GATE` trace line per check when logging.
+Emit a `GATE` trace line per check.
 
 **a. Wiki gate.** Decide existence with `orc wiki status` — the deterministic
 probe in `../_shared/detecting-artifacts.md`, never an ad-hoc `find` (`.claude`
-is hidden). `none` = gate FAILED → fallback; else wiki present → compute the
-tier from `.claude/orc/wiki-meta.json` per `../orc-wiki/references/staleness.md`:
-`git rev-list --count <scan_commit>..HEAD` → FRESH / AGING / STALE (manifest
-absent but docs present = STALE; wiki absent/empty = gate FAILED → fallback).
+is hidden). `none` = gate FAILED → fallback; else read the tier from
+`orc wiki status --json` → `.tier` (FRESH / AGING / STALE; the CLI computes
+it — never recompute it by hand).
 - **FRESH** → proceed silently. **AGING** → one-line notice, proceed.
-- **STALE** → the user judges. Ask with exactly these options:
+- **STALE** → the user judges. Ask (H `fast.f0.stale-wiki`) with exactly these options:
   1. **Refresh wiki, then continue fast** *(recommended)* — run orc-wiki's
      incremental refresh (diff since `scan_commit`, re-scan only affected
      docs), then re-enter this preflight.
@@ -99,7 +94,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.
 
@@ -134,35 +129,35 @@ pinned in the agent file). **Under `opus5_only` it is `orc-executor-opus-5-low`*
 - **terse-return rule:** standard contract fields, NO narrative prose — files
   changed, one-line diff summary, smoke-relevant notes only.
 
-Validate the return per `../_shared/return-validation.md` — `unmet[]`
+Validate the return per `../_shared/return-validation.md` §1–§3 + the § of
+each field you injected — `unmet[]`
 honesty, `pattern_version` + `invariants_checked` attestation, `actual_model`
 / `actual_effort` downgrade check (emit the `VERIFY` trace line), and §6's worktree delta (`git status --short` before/after; a path changed outside `declared_files` is a violation whatever the return said). Malformed
 return = failure (one re-dispatch, then fallback offer).
 
-**Before any re-dispatch, run `orc run inflight`** (0 clear · 1 in-flight · 2 unknown). A Task error does not kill the agent behind it, and exit 2 REFUSES by default — `a lane that re-dispatches over a live attempt` has broken the contract. Canonical: `../_shared/return-validation.md`.
+**Before any re-dispatch, run `orc run inflight`**. A Task error does not kill the agent behind it, and exit 2 REFUSES by default — `a lane that re-dispatches over a live attempt` has broken the contract. Canonical: `../_shared/return-validation.md`.
 
 ## Phase F3 — Smoke gate (build + test; blocks ship on red)
 
 Run the gate per `../_shared/smoke-gate.md`, sourcing commands **from
 `wiki-meta.json`'s `commands` block** (recorded at wiki scan — don't
 rediscover tooling; manifest lacks them → detect once and say so). **GREEN**
-→ code-graph step e.(3) (never a gate) → ship. **RED** → one repair round; second red → STOP and offer: escalate to
+→ code-graph step e.(3) (never a gate) → ship. **RED** → the flaky check, then one repair round; second red → STOP and offer: escalate to
 orc-mini (reason `smoke-red-escalation`) / switch to full `/orc` / stop.
 Docs-only → gate N/A, say so.
 
 ## Phase F3.5 — Mock example (config `mock_example`, default ask)
 
-Canonical: `../_shared/drift-recovery.md` — load on fire. Only after a GREEN
-F3, before ship: `ask` → MANDATORY offer · `on` → build · `off` → skip.
-Deliverable `mock-examples/<change-slug>/` at project root — **never
-committed/staged**. Drift answer → `DRIFT-FROM` recovery (cap 2 loops, honest
-report on cap). Trace: `PHASE mock-example`, `DRIFT loop=<n>`.
+After a GREEN F3, before ship (H `fast.f3-5.mock`): follow `../_shared/drift-recovery.md` (load on
+fire) — the `mock-examples/<change-slug>/` deliverable, the `DRIFT-FROM` loop and
+its cap. Trace: `PHASE mock-example`, `DRIFT loop=<n>`.
 
 ## Phase F4 — Ship
 
-Offer commit (push if asked; never stage `mock-examples/`). Append the final markers to the checkpoint, emit
+Offer commit (H `fast.f4.ship` · `any.ship.review-before-push`; push if asked; never stage `mock-examples/`). Append the final markers to the checkpoint, emit
 `OUTCOME task=… band=fast model=… retries=… unmet=…` + `FINISH`, show the
-dispatch line (model/effort actually used) + the `/usage` reminder. Fast never
+dispatch line (model/effort actually used) + the `/usage` reminder. Every end — ship
+or a red STOP — prints the card (`../_shared/phases/summary.md` §End-of-run card). Fast never
 triggers the post-ship wiki refresh ask (preflight polices freshness on the
 way in) — the passive stale-flag note still applies to touched covered files.
 
@@ -176,46 +171,25 @@ already in the shared format — no migration.
 
 ## Behavior trace (always on)
 
-`../_shared/phases/trace.md` (`core`, at run start; `orc lane phases` names
-the file and the layers). Lane token `fast`, tier **Build lanes** —
-per phase, batched to **2 packets** (preflight+dispatch · gate+ship), each
-paired with the next phase's first dispatch.
-At run start write `log_dir/.current` = `run-fast-<slug>-<DDMMYY>-<HHMMSS>.txt` AND
-`touch the trace file` of that name in the SAME step.
-Nothing else about the protocol is restated here; a phase that ends with
-`zero new trace lines is a protocol violation`.
-
-## Config
-
-**ONE resolver, and it is not you:** `orc lane config orc-fast --json`. Obey
-`effective`, print every line in `announce[]` VERBATIM at preflight, and honour
-`stops[]` before wave 1. Never re-derive a value, a precedence or an inertness
-from `.claude/orc.config.yaml` — a key this lane does not read is not in the
-answer, and a key another key shadows comes back already marked. Exit ≠ 0 → say
-the CLI is unavailable and fall back to `../_shared/config-precedence.md`'s
-documented defaults, out loud. Priorities and families:
-`../_shared/config-precedence.md`.
+`../_shared/phases/trace.md` (`core`, at run start; `orc lane phases orc-fast --json` →
+`trace_grammar` gives the verbs). Lane token `fast`, tier
+**Build lanes** — batched to **2 packets** (preflight+dispatch ·
+gate+ship) → `orc trace write --packet -`. At run start write `log_dir/.current` =
+`run-fast-<slug>-<DDMMYY>-<HHMMSS>.txt` AND `touch the trace file` of that name
+in the SAME step. A phase that ends with `zero new trace lines is a protocol violation`.
 
-Fast has no config key of its own — command-entry only; wave/scoring/review
-keys never apply, and the tier edges the F0 gate reads arrive resolved.
-
-## Rules — the anti-slop card (`../_shared/phases/rules.md`)
+## Lane contract (`../_shared/lane-contract.md` — read it ONLY when a call exits ≠ 0)
 
-`orc rules slice --lane orc-fast --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[]`.
-## Calls
+- **Calls:** `orc lane calls orc-fast --json` names every call and its exit codes.
+  **An exit code is an ANSWER where it says so, not a failure.** Make no other call.
+- **Config:** `orc lane config orc-fast --json`. Obey `effective`, print every line
+  in `announce[]` VERBATIM at preflight, and honour `stops[]` before wave 1.
+  Never merge `.claude/orc.config.yaml` yourself (`../_shared/config-precedence.md`).
+- **Rules:** `orc rules slice --lane orc-fast --json` is the ONLY assembler
+  (`../_shared/phases/rules.md`). Its `line` prints VERBATIM at preflight.
 
-**ONE catalogue, and it is not you:** `orc lane calls orc-fast --json` names every
-CLI call this lane makes, each with its exit-code contract, its cost, when to run
-it, and what an EMPTY answer means. Never invent a spelling, never re-word an
-exit code, and never re-derive a state word — the CLI's state words are the only
-state words, and **an exit code is an ANSWER wherever that contract says so, not
-a failure**. A call the answer does not name is a call this lane does not make.
-Exit ≠ 0 from the catalogue itself → say the CLI is unavailable and name the
-command you are about to run, out loud, before running it.
+Fast has no config key of its own — command-entry only; wave/scoring/review
+keys never apply, and the tier edges the F0 gate reads arrive resolved.
 
 ## Checkpoint (minimal, append-only)
 
@@ -223,14 +197,12 @@ One `fast-checkpoint.md` in the run folder: GATE results (+ any
 `wiki_stale_override`), the dispatch, smoke verdicts, OUTCOME — enough for
 /orc-retro mining and fresh-session resume, nothing more.
 
-## What fast still enforces (from the main hard rules)
+## What fast still enforces
 
-Never implement yourself (smoke gate = read-only build+test) · all artifacts
-in the run subfolder, never project root · validate the subagent return
-(malformed = failure) · never offer commit on a red build · report the
-dispatch + remind the user to run `/usage` (never invoke it programmatically).
+All artifacts in the run subfolder, never project root · never offer commit on
+a red build · never invoke `/usage` programmatically.
 
 ## Waiting mid-run (`/orc-wait`)
 
 Canonical: `../_shared/wait.md`. **`a lane that waits without a hand-back` has broken this contract.**
-Checkpoint **full** · safe point **after the executor returns**. `soft` FORCES that checkpoint and does NOT stop if the write fails; `hard` skips it and can lose an in-flight return. Never begin a wait between a dispatch and its validated return, or before the smoke gate has reported.
+Checkpoint **full** · safe point **after the executor returns**.

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

@@ -1,82 +1,77 @@
----
-name: orc-judge
-description: >
-  Judgment gates for the ORC ultra lane. One judge skill, one agent
-  (orc-judge-opus-5-xhigh), three dispatch contexts: gate=analysis (after the
-  analyst), gate=plan (after the planner), gate=implementation (after verify —
-  the anti-miss-implementation fidelity + strict-quality gate). Returns a
-  structured verdict (APPROVE | REVISE | ESCALATE) with anchored,
-  consequence-cited findings; REVISE loops the author with a hard 2-loop cap
-  and a convergence rule. Dispatched only from /orc-ultra — no slash command
-  of its own, never in orc or orc-mini. The orchestrator dispatches the judge
-  subagent — it never judges itself.
----
-
-# ORC-JUDGE (ultra-lane judgment gates)
-
-A model-based quality gate on top of ORC's deterministic gates. The judge
-handles what determinism cannot: scope-interpretation correctness, plan
-soundness, implementation fidelity, and — at the final gate — ultra-strict
-code quality. Deterministic gates ALWAYS run first; the judge never re-checks
-what a string-compare catches.
-
-Ultra lane ONLY. No `/orc-judge` command; the orchestrator dispatches
-`orc-judge-opus-5-xhigh` at the three ultra gates.
-
-## Hard rules
-
-1. **The orchestrator never judges — it spawns.** One agent, three contexts
-   (`gate=analysis|plan|implementation`).
-2. **Deterministic first.** A judge dispatch is only legal AFTER the gate's
-   deterministic checks passed (evidence spot-check + derivation lint /
-   coverage + graph checks / verify + traceability matrix + static analysis).
-3. **The judge is read-only** and blind to the author's internal reasoning or
-   self-assessment (anti-anchoring): it sees the artifact, its evidence, the
-   advisor brief + rubric, and the original request.
-4. **Judge gates ADD to user sign-offs, never replace them.** Gate approvals
-   never skip the analyst challenge round or the plan sign-off.
-5. **Gate scope is one-directional.** gate=plan takes the approved spec as
-   fixed ground truth; gate=implementation takes the approved plan as fixed —
-   no gate re-litigates an earlier approved gate.
-6. **The judge never fixes.** Authors fix: analyst (gate=analysis), planner
-   (gate=plan), a scored executor fix wave (gate=implementation).
-
-## Verdict handling (orchestrator side)
-
-Validate the return against the agent's verdict contract, then:
-
-- **Downgrade enforcement:** any blocking finding missing its verbatim
-  anchor or its class-appropriate justification (failure_consequence for
-  correctness/security; named category + concrete alternative for
-  smell/simplification/placement) → downgrade to advisory and tell the user.
-  EXCEPTION: a security finding with a concrete consequence is always
-  blocking — never downgraded.
-- **APPROVE** → record the verdict artifact, continue the pipeline.
-- **REVISE** → re-dispatch the author with the original slice + the blocking
-  findings verbatim. The author's return must echo `finding_id → resolution`
-  per finding; a missing echo is a malformed return (requeue). Then RE-JUDGE
-  under the convergence rule: block only on unresolved prior findings by id
-  or on lines the revision changed; new findings on untouched material are
-  advisory-only. **Hard cap: 2 revision loops per gate**, counted in the
-  checkpoint.
-- **ESCALATE** (or a third failure) → present the ESCALATE menu:
-  accept-and-proceed (unresolved findings recorded in the Phase 7 summary) /
-  user fixes manually then re-judge (does not consume a loop) / grant one
-  extra loop / stop-and-checkpoint.
-- Advisory findings NEVER loop — they ride forward attached to the next
-  phase's slices as notes.
-- Persist every verdict as `run/{run-slug}/ultra/verdict-<gate>-<round>.md`
-  (mined by /orc-retro; survives resume). When logging, emit
-  `JUDGE <gate> <verdict>` and the judgment GATE line (pass|bounce|escalate).
-
-## The three gates
-
-| Gate | After | Judges | REVISE target |
-|------|-------|--------|---------------|
-| analysis | analyst-return deterministic gates | scope interpretation, requirement coherence, rubric misses, stale-doc risk | analyst |
-| plan | Phase 1 exit gate + blast-radius map | decomposition, declared-file plausibility, deps, right-sizing, blast-radius coverage | planner |
-| implementation | Phase 6/6.5 + traceability matrix + static analysis | fidelity to the user's ask + ultra-strict quality (security, smells, simplification, placement, pattern invariants) | scored executor fix wave → re-verify → re-judge |
-
-Return fields include `actual_model` + `actual_effort` (standard
-claimed-vs-actual check) and `rubric_items_checked[]` +
-`unconfirmed_assumptions_touched[]` — validate them like any worker return.
+---
+name: orc-judge
+description: >
+  Internal to /orc-ultra: the three judgment gates — analysis, plan,
+  implementation. Returns APPROVE | REVISE | ESCALATE with anchored findings;
+  REVISE has a hard 2-loop cap. No slash command of its own.
+disable-model-invocation: true
+---
+
+# ORC-JUDGE (ultra-lane judgment gates)
+
+A model-based quality gate on top of ORC's deterministic gates. The judge
+handles what determinism cannot: scope-interpretation correctness, plan
+soundness, implementation fidelity, and — at the final gate — ultra-strict
+code quality. Deterministic gates ALWAYS run first; the judge never re-checks
+what a string-compare catches.
+
+Ultra lane ONLY. No `/orc-judge` command; the orchestrator dispatches
+`orc-judge-opus-5-xhigh` at the three ultra gates.
+
+## Hard rules
+
+1. **The orchestrator never judges — it spawns.** One agent, three contexts
+   (`gate=analysis|plan|implementation`).
+2. **Deterministic first.** A judge dispatch is only legal AFTER the gate's
+   deterministic checks passed (evidence spot-check + derivation lint /
+   coverage + graph checks / verify + traceability matrix + static analysis).
+3. **The judge is read-only** and blind to the author's internal reasoning or
+   self-assessment (anti-anchoring): it sees the artifact, its evidence, the
+   advisor brief + rubric, and the original request.
+4. **Judge gates ADD to user sign-offs, never replace them.** Gate approvals
+   never skip the analyst challenge round or the plan sign-off.
+5. **Gate scope is one-directional.** gate=plan takes the approved spec as
+   fixed ground truth; gate=implementation takes the approved plan as fixed —
+   no gate re-litigates an earlier approved gate.
+6. **The judge never fixes.** Authors fix: analyst (gate=analysis), planner
+   (gate=plan), a scored executor fix wave (gate=implementation).
+
+## Verdict handling (orchestrator side)
+
+Validate the return against the agent's verdict contract, then:
+
+- **Downgrade enforcement:** any blocking finding missing its verbatim
+  anchor or its class-appropriate justification (failure_consequence for
+  correctness/security; named category + concrete alternative for
+  smell/simplification/placement) → downgrade to advisory and tell the user.
+  EXCEPTION: a security finding with a concrete consequence is always
+  blocking — never downgraded.
+- **APPROVE** → record the verdict artifact, continue the pipeline.
+- **REVISE** → re-dispatch the author with the original slice + the blocking
+  findings verbatim. The author's return must echo `finding_id → resolution`
+  per finding; a missing echo is a malformed return (requeue). Then RE-JUDGE
+  under the convergence rule: block only on unresolved prior findings by id
+  or on lines the revision changed; new findings on untouched material are
+  advisory-only. **Hard cap: 2 revision loops per gate**, counted in the
+  checkpoint.
+- **ESCALATE** (or a third failure) → present the ESCALATE menu:
+  accept-and-proceed (unresolved findings recorded in the Phase 7 summary) /
+  user fixes manually then re-judge (does not consume a loop) / grant one
+  extra loop / stop-and-checkpoint.
+- Advisory findings NEVER loop — they ride forward attached to the next
+  phase's slices as notes.
+- Persist every verdict as `run/{run-slug}/ultra/verdict-<gate>-<round>.md`
+  (mined by /orc-retro; survives resume). When logging, emit
+  `JUDGE <gate> <verdict>` and the judgment GATE line (pass|bounce|escalate).
+
+## The three gates
+
+| Gate | After | Judges | REVISE target |
+|------|-------|--------|---------------|
+| analysis | analyst-return deterministic gates | scope interpretation, requirement coherence, rubric misses, stale-doc risk | analyst |
+| plan | Phase 1 exit gate + blast-radius map | decomposition, declared-file plausibility, deps, right-sizing, blast-radius coverage | planner |
+| implementation | Phase 6/6.5 + traceability matrix + static analysis | fidelity to the user's ask + ultra-strict quality (security, smells, simplification, placement, pattern invariants) | scored executor fix wave → re-verify → re-judge |
+
+Return fields include `actual_model` + `actual_effort` (standard
+claimed-vs-actual check) and `rubric_items_checked[]` +
+`unconfirmed_assumptions_touched[]` — validate them like any worker return.

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.