@azure-id/orc 1.9.2 → 2.0.2

package/templates/skills/orc/references/pattern-gate.md

@@ -1,89 +1,89 @@
-# Reference — Code-Pattern Gate (orchestrator side)
-
-How the full lane resolves, injects, and enforces per-language code-patterns so
-executors MATCH the existing codebase instead of writing generic-template code.
-The engine (playbooks, codifier slice, reconcile rules) is the sibling skill
-`../../orc-pattern/SKILL.md`; this file is the orchestrator's gate + wiring.
-Load at Phase 2 (tagging) and Phase 3 (resolve gate + slice injection).
-
-Principle: **conventions defer to the project; security/correctness invariants
-are always enforced.**
-
-## Phase 2 — Tag each task while scoring
-
-From its `declared_files` extensions + repo deps (see
-`../../orc-pattern/references/INDEX.md`):
-`{domain: FE|BE|null, lang: react|nextjs|vue|fastapi|nestjs|go|…|null}`.
-Tasks with no FE/BE language need no pattern.
-
-**Postgres secondary tag:** on a Postgres project (`pg`/`psycopg`/`asyncpg`/
-`pgx`/`lib/pq`/`Npgsql`/Prisma `postgresql`/`postgrex` in deps), add
-`db: postgres` to any task whose `declared_files` touch the data-access layer
-(repositories/dao/models/queries, `*.sql`, ORM entities/migrations). `db`
-co-applies WITH the framework `lang`, never instead of it — it pulls the
-cross-cutting `postgres` playbook into the same resolve gate.
-
-## Phase 3 — Resolve gate (once, before the first wave)
-
-For each distinct tagged language (including `postgres` when any task is
-`db`-tagged), resolve against the cache `.claude/orc/patterns/<lang>-pattern.md`
-— test existence with the deterministic probe `orc pattern status <lang>`
-(exit 0 = cached; see `../../_shared/detecting-artifacts.md`), never an ad-hoc
-`find`, so a codified pattern is never missed:
-
-Every resolved language prints exactly ONE user-visible line (no cost, no ask —
-visibility only, so the user always knows which house style is in force):
-
-- **Cache hit, no drift** → no ask, no cost, but print
-  `pattern: <lang>-pattern.md applied (cached)`.
-- **Cache miss** → apply config `pattern_findings` (default `ask`):
-  - `ask` → ONE P0 prompt batched across ALL missing languages ("Learn
-    conventions for {…} via orc-pattern, or proceed language-agnostic?");
-  - `on` → codify without asking; print `pattern: <lang> — codifying (cache miss)`;
-  - `off` → agnostic; print `pattern: <lang> — running language-agnostic (no cached pattern)`.
-- **On learn/`on`** → dispatch `orc-pattern-codifier-sonnet-5-high` per missing
-  language (`orc-pattern-codifier-opus-5-med` when `opus5_only` — see
-  `../../_shared/opus5-only.md`; slice per `../../orc-pattern/SKILL.md`
-  Phase 1); YOU write the returned pattern to the cache.
-- **Agnostic fallback** (declined / `off` / no playbook for the language): no
-  codifier, no scan — the executor enforces the universal invariants and
-  imitates the neighbor files it already reads. ~Zero added cost.
-
-Hold the resolved pattern per language in run state (survives
-checkpoint/resume) — it is injected at dispatch and reused at Phase 5/6.
-
-## Slice injection (anti-skip layer 1)
-
-Inject the resolved conventions + blocking invariants + the enforceable
-`validation_gate[]` lines LITERALLY into each FE/BE task's slice as `pattern` —
-never a file pointer. Agnostic tasks get the universal invariants only.
-
-**Gotchas ride BESIDE the pattern block, never inside it** (config `gotchas`;
-canonical `../../_shared/gotchas.md`). Same slice, same literal injection, one
-hard difference: the pattern applies to a LANGUAGE, so it goes to every task
-tagged with that language — a gotcha applies to a `scope` GLOB, so it goes only to
-tasks whose `declared_files` match it, capped at 3, highest `hits` first. Zero
-matches = no gotcha block at all. Never inject unfiltered: a pattern is what this
-project always does, a gotcha is what it got wrong ONCE, somewhere specific.
-
-For a `db:postgres`-tagged task, ALSO merge the resolved `postgres` pattern's
-Conventions + Invariants + gate lines into the SAME `pattern` block (appended
-to the framework pattern, or standalone if the task has no framework lang) —
-query invariants (bound params only, pooled connections, transactional
-multi-writes) ride the same anti-skip path. Record the postgres
-`pattern_version` in run state/log too.
-
-## Return validation (anti-skip layer 2)
-
-A task that was given a `pattern` must return `invariants_checked: true` + a
-`pattern_version` matching what you injected — the single attestation covers a
-merged block. Missing/false attestation = malformed return (requeue). Record
-the applied `pattern_version` in the trace.
-
-## Review/verify re-check (anti-skip layer 3)
-
-- **Phase 5 (review):** pass the resolved pattern as `code_pattern` AND its
-  blocking `invariants[]` + `validation_gate[]` lines for the re-check — don't
-  re-ask the user. An invariant violation or unmet gate line is P0.
-- **Phase 6 (verify):** pass the `validation_gate[]` lines in the slice — each
-  line is an acceptance criterion; an unmet line is P0.
+# Reference — Code-Pattern Gate (orchestrator side)
+
+How the full lane resolves, injects, and enforces per-language code-patterns so
+executors MATCH the existing codebase instead of writing generic-template code.
+The engine (playbooks, codifier slice, reconcile rules) is the sibling skill
+`../../orc-pattern/SKILL.md`; this file is the orchestrator's gate + wiring.
+Load at Phase 2 (tagging) and Phase 3 (resolve gate + slice injection).
+
+Principle: **conventions defer to the project; security/correctness invariants
+are always enforced.**
+
+## Phase 2 — Tag each task while scoring
+
+From its `declared_files` extensions + repo deps (see
+`../../orc-pattern/references/INDEX.md`):
+`{domain: FE|BE|null, lang: react|nextjs|vue|fastapi|nestjs|go|…|null}`.
+Tasks with no FE/BE language need no pattern.
+
+**Postgres secondary tag:** on a Postgres project (`pg`/`psycopg`/`asyncpg`/
+`pgx`/`lib/pq`/`Npgsql`/Prisma `postgresql`/`postgrex` in deps), add
+`db: postgres` to any task whose `declared_files` touch the data-access layer
+(repositories/dao/models/queries, `*.sql`, ORM entities/migrations). `db`
+co-applies WITH the framework `lang`, never instead of it — it pulls the
+cross-cutting `postgres` playbook into the same resolve gate.
+
+## Phase 3 — Resolve gate (once, before the first wave)
+
+For each distinct tagged language (including `postgres` when any task is
+`db`-tagged), resolve against the cache `.claude/orc/patterns/<lang>-pattern.md`
+— test existence with the deterministic probe `orc pattern status <lang>`
+(exit 0 = cached; see `../../_shared/detecting-artifacts.md`), never an ad-hoc
+`find`, so a codified pattern is never missed:
+
+Every resolved language prints exactly ONE user-visible line (no cost, no ask —
+visibility only, so the user always knows which house style is in force):
+
+- **Cache hit, no drift** → no ask, no cost, but print
+  `pattern: <lang>-pattern.md applied (cached)`.
+- **Cache miss** → apply config `pattern_findings` (default `ask`):
+  - `ask` → ONE P0 prompt (H `orc.phase-3.pattern`) batched across ALL missing languages ("Learn
+    conventions for {…} via orc-pattern, or proceed language-agnostic?");
+  - `on` → codify without asking; print `pattern: <lang> — codifying (cache miss)`;
+  - `off` → agnostic; print `pattern: <lang> — running language-agnostic (no cached pattern)`.
+- **On learn/`on`** → dispatch `orc-pattern-codifier-sonnet-5-high` per missing
+  language (`orc-pattern-codifier-opus-5-med` when `opus5_only` — see
+  `../../_shared/opus5-only.md`; slice per `../../orc-pattern/SKILL.md`
+  Phase 1); YOU write the returned pattern to the cache.
+- **Agnostic fallback** (declined / `off` / no playbook for the language): no
+  codifier, no scan — the executor enforces the universal invariants and
+  imitates the neighbor files it already reads. ~Zero added cost.
+
+Hold the resolved pattern per language in run state (survives
+checkpoint/resume) — it is injected at dispatch and reused at Phase 5/6.
+
+## Slice injection (anti-skip layer 1)
+
+Inject the resolved conventions + blocking invariants + the enforceable
+`validation_gate[]` lines LITERALLY into each FE/BE task's slice as `pattern` —
+never a file pointer. Agnostic tasks get the universal invariants only.
+
+**Gotchas ride BESIDE the pattern block, never inside it** (config `gotchas`;
+canonical `../../_shared/gotchas.md`). Same slice, same literal injection, one
+hard difference: the pattern applies to a LANGUAGE, so it goes to every task
+tagged with that language — a gotcha applies to a `scope` GLOB, so it goes only to
+tasks whose `declared_files` match it, capped at 3, highest `hits` first. Zero
+matches = no gotcha block at all. Never inject unfiltered: a pattern is what this
+project always does, a gotcha is what it got wrong ONCE, somewhere specific.
+
+For a `db:postgres`-tagged task, ALSO merge the resolved `postgres` pattern's
+Conventions + Invariants + gate lines into the SAME `pattern` block (appended
+to the framework pattern, or standalone if the task has no framework lang) —
+query invariants (bound params only, pooled connections, transactional
+multi-writes) ride the same anti-skip path. Record the postgres
+`pattern_version` in run state/log too.
+
+## Return validation (anti-skip layer 2)
+
+A task that was given a `pattern` must return `invariants_checked: true` + a
+`pattern_version` matching what you injected — the single attestation covers a
+merged block. Missing/false attestation = malformed return (requeue). Record
+the applied `pattern_version` in the trace.
+
+## Review/verify re-check (anti-skip layer 3)
+
+- **Phase 5 (review):** pass the resolved pattern as `code_pattern` AND its
+  blocking `invariants[]` + `validation_gate[]` lines for the re-check — don't
+  re-ask the user. An invariant violation or unmet gate line is P0.
+- **Phase 6 (verify):** pass the `validation_gate[]` lines in the slice — each
+  line is an acceptance criterion; an unmet line is P0.

package/templates/skills/orc/references/phases/intake.md

@@ -1,47 +1,41 @@
-# Phase — Intake   (id: `intake`)
-
-> **`/orc` phase file.** Moved out of `orc/SKILL.md` at v1.0.0 W12. The spine is
-> loaded IN FULL when the skill activates; this is loaded when the phase fires,
-> and most runs skip most phases. ONE consumer today, so it stays in this lane —
-> `../../../_shared/phases/README.md`'s rule: a file with one consumer stays home.
-> When a second lane reads it (W13 `orc-diy`, W14 `orc-mini`/`orc-fast`) it moves
-> to `_shared/phases/` and gains a `composed` or `trim` layer beside this one.
-> `orc lane phases orc --json` names the file and the layers.
-
-<!-- orc:layer full -->
-
-## Intake (load ../../../_shared/phases/intake.md)
-
-**Plan-input trigger (check FIRST — load `../../../_shared/phases/plan-handoff.md`):** if the
-run input IS a plan (pasted planning-output, a `plan-{name}.md` path, or an
-`orc/planner/{name}/` checkpoint), follow that reference: bootstrap the trace,
-schema-validate, apply the `plan_head` staleness valve, RE-RUN the full Phase 1
-exit gate here (the deterministic catch for phantom-file drift), relay
-`open_questions[]`, then continue at Phase 2. A plan input never skips Phase 2/3
-nor executes task-by-task ad hoc.
-
-**Analyst auto-trigger:** on a document (PDF path, pasted doc, audit sheet)
-OR an ambiguous/underspecified requirement, FIRST dispatch the System Analyst
-(doc-optional — with no doc the request itself is the source). Offer
-standard/deep (`config.default_analysis_depth` presets it; mention `orc
-config set default_analysis_depth deep`); deep → you dispatch the scouts. On
-return run the analyst-return gates (analyst-gates.md); on build, continue at
-Phase 1 with the Requirement Planner.
-
-Emit `PHASE intake start` FIRST, then create `run/{run-slug}/` (slug from the
-intent). Then: rough-size →
-question tier (2/4/6) → ONE batched question round → draft the intent-spec
-(`../../schemas/intent-spec.md`) → **repo cross-check** (intake Step 3.5:
-Glob/Grep-confirm everything the spec names, or tag `UNVERIFIED`; tags become
-ONE batched sign-off question; >3 tags → recommend `orc-analyze`) → sign-off
-preference (gate/soft; DEFAULT GATE) → show spec → approval or edits. **No
-planning until approved (gate mode) and no unresolved `UNVERIFIED` tags
-either way.** On approval, emit `PHASE intake end`.
-
-The intent-spec's definition-of-done becomes Phase 6's acceptance criteria;
-its constraints become hard rules in every slice — at slice-assembly each
-task's `spec_invariants[]` is appended VERBATIM to that slice's
-`constraints[]`. Offer the opt-in **Test Authoring** (Phase 6.5; default
-`config.generate_tests`) in the sign-off round.
-
-<!-- /orc:layer -->
+# Phase — Intake   (id: `intake`)
+
+> **`/orc` phase file** — read when the phase fires. One consumer, so it stays home (`../../../_shared/phases/README.md`). `orc lane phases orc --json` names the file and the layers.
+
+<!-- orc:layer full -->
+
+## Intake (load ../../../_shared/phases/intake.md)
+
+**Plan-input trigger (check FIRST — load `../../../_shared/phases/plan-handoff.md`):** if the
+run input IS a plan (pasted planning-output, a `plan-{name}.md` path, or an
+`orc/planner/{name}/` checkpoint), follow that reference: bootstrap the trace,
+schema-validate, apply the `plan_head` staleness valve, RE-RUN the full Phase 1
+exit gate here (the deterministic catch for phantom-file drift), relay
+`open_questions[]`, then continue at Phase 2. A plan input never skips Phase 2/3
+nor executes task-by-task ad hoc.
+
+**Analyst auto-trigger:** on a document (PDF path, pasted doc, audit sheet)
+OR an ambiguous/underspecified requirement, FIRST dispatch the System Analyst
+(doc-optional — with no doc the request itself is the source). Offer
+standard/deep (H `any.analysis.depth`; `config.default_analysis_depth` presets it; mention `orc
+config set default_analysis_depth deep`); deep → you dispatch the scouts. On
+return run the analyst-return gates (analyst-gates.md); on build, continue at
+Phase 1 with the Requirement Planner.
+
+Emit `PHASE intake start` FIRST, then create `run/{run-slug}/` (slug from the
+intent). Then: rough-size →
+question tier (2/4/6) → ONE batched question round → draft the intent-spec
+(`../../schemas/intent-spec.md`) → **repo cross-check** (intake Step 3.5:
+Glob/Grep-confirm everything the spec names, or tag `UNVERIFIED`; tags become
+ONE batched sign-off question; >3 tags → recommend `orc-analyze`) → sign-off
+preference (gate/soft; DEFAULT GATE) → show spec → approval or edits. **No
+planning until approved (gate mode) and no unresolved `UNVERIFIED` tags
+either way.** On approval, emit `PHASE intake end`.
+
+The intent-spec's definition-of-done becomes Phase 6's acceptance criteria;
+its constraints become hard rules in every slice — at slice-assembly each
+task's `spec_invariants[]` is appended VERBATIM to that slice's
+`constraints[]`. Offer the opt-in **Test Authoring** (H `orc.intake.testgen`; Phase 6.5; default
+`config.generate_tests`) in the sign-off round.
+
+<!-- /orc:layer -->

package/templates/skills/orc/references/phases/integration.md

@@ -1,19 +1,13 @@
-# Phase — Integration (worktrees)   (id: `integration`)
-
-> **`/orc` phase file.** Moved out of `orc/SKILL.md` at v1.0.0 W12. The spine is
-> loaded IN FULL when the skill activates; this is loaded when the phase fires,
-> and most runs skip most phases. ONE consumer today, so it stays in this lane —
-> `../../../_shared/phases/README.md`'s rule: a file with one consumer stays home.
-> When a second lane reads it (W13 `orc-diy`, W14 `orc-mini`/`orc-fast`) it moves
-> to `_shared/phases/` and gains a `composed` or `trim` layer beside this one.
-> `orc lane phases orc --json` names the file and the layers.
-
-<!-- orc:layer full -->
-
-## Integration (worktrees only)
-
-Emit `PHASE integration start`. Merge worker branches; conflicts → resolver
-subagent (Opus 4.8 medium) given BOTH tasks' specs/intents, not just the diff.
-Record merge state in checkpoint; emit `PHASE integration end`.
-
-<!-- /orc:layer -->
+# Phase — Integration (worktrees)   (id: `integration`)
+
+> **`/orc` phase file** — read when the phase fires. One consumer, so it stays home (`../../../_shared/phases/README.md`). `orc lane phases orc --json` names the file and the layers.
+
+<!-- orc:layer full -->
+
+## Integration (worktrees only)
+
+Emit `PHASE integration start`. Merge worker branches; conflicts → resolver
+subagent (Opus 4.8 medium) given BOTH tasks' specs/intents, not just the diff.
+Record merge state in checkpoint; emit `PHASE integration end`.
+
+<!-- /orc:layer -->

package/templates/skills/orc/references/preflight-report.md

@@ -4,11 +4,10 @@ One compact, user-visible block printed ONCE at Phase 1, after the planning
 input is settled (wiki consulted, crosslink probed, waves computed at Phase 2 —
 so print it at the point all inputs exist, typically end of Phase 1 / start of
 Phase 3). This is **presentation only** — no new probes; every value is already
-computed by the wiki consult (Change 3), the crosslink probe (Change 5), the
-pattern resolve gate (Change 4), and wave grouping.
+computed by the wiki consult, the crosslink probe, the pattern resolve gate,
+and wave grouping.
 
-The point is that the four knowledge gates the run used to keep silent are now
-always surfaced: the user always knows whether the run is grounded (wiki),
+The point: the four knowledge gates are ALWAYS surfaced: the user always knows whether the run is grounded (wiki),
 whose house style is in force (pattern), whether peer contracts are in play
 (crosslink), where the trace is, and when the run will pause.
 
@@ -49,7 +48,7 @@ waves:     3 planned — will pause after wave 2 (batch_pause_every=2)
   that the run is not learning from its own repairs, and a user who did not should
   see that it is. Canonical: `../../_shared/gotchas.md`. `.claude/orc/gotchas.md`
   is where the entries live.
-- **wiki, the debt tail (v0.46.0):** append `· <n> docs pending refresh, <tok> /
+- **wiki, the debt tail:** append `· <n> docs pending refresh, <tok> /
   <$>` from `orc wiki debt --json` **only when debt exists** (exit 1). Exit 0
   appends nothing — a tail that says "no debt" on every run is a tail people stop
   reading, and this one has to be legible the time it matters.
@@ -73,7 +72,7 @@ waves:     3 planned — will pause after wave 2 (batch_pause_every=2)
 - **crosslink:** the crosslink line from `wiki-consult.md` when a probe hit
   (`cached` or `configured-no-cache`); omit the whole line when crosslink is
   not in play (state `none`).
-- **extra:** (v0.50.0) printed on **every** run where `config.extra_enabled` is
+- **extra:** printed on **every** run where `config.extra_enabled` is
   true — including a run where nothing routed foreign (`ON — 0 of 9 tasks
   foreign; no route row covers this plan's scores`). This is the P0 line
   (`a lane that sends work off Claude without saying so`), so unlike every other
@@ -115,7 +114,7 @@ waves:     3 planned — will pause after wave 2 (batch_pause_every=2)
   be naming the wrong half for every covered score.
 - **tdd:** ALWAYS printed on a lane whose TDD policy is on — BOTH branches, not
   only the exemption. Counted straight from the plan's `tdd_spec`, broken down
-  by `disposition` so the user sees **what got no test and why** (v0.41.0):
+  by `disposition` so the user sees **what got no test and why**:
 
   ```
   tdd:  3 tasks with tests (T3, T6, T9) · 2 covered-by-existing · 2 no-behavior
@@ -150,10 +149,10 @@ block.
 
 ---
 
-# The `forecast:` block (v0.42.0) — printed EARLIER, and separately
+# The `forecast:` block — printed EARLIER, and separately
 
 A second, shorter block. It is NOT part of the preflight block above and does not
-change it. It answers the one question ORC never answered: **what will this run
+change it. It answers one question: **what will this run
 cost me in time, before it starts?**
 
 ## When

package/templates/skills/orc/references/ultra-mode.md

@@ -24,6 +24,8 @@ Apply at Phase 0, on top of the normal config resolution:
   low → medium, which makes both bands medium. It is still a floor — it never
   lowers a band, and it never raises `[90,100]` past medium.
   Show the remapped table with the Phase 2 scoring table.
+- **Habits** (`habits{}` present) never answer a forced key or question here —
+  ultra wins; say so on the habits preflight line. Record those `ASK`s `by=config`.
 
 > Opus-5-only mode: if `opus5_only`, every role this lane dispatches is already
 > Opus 5.5 (advisor and judge are pinned there by default) and the scouts rise to
@@ -83,13 +85,13 @@ author's reasoning or self-assessment.
      evidence`. An R# with an EMPTY diff column is a deterministically caught
      missing implementation — dispatch the fix wave directly, no judge needed
      for that miss.
-  2. **Static analysis**: run the project's own tooling on the changed files
-     when the stack detection found any (linter, sonar-scanner,
-     type-checker) — never install tooling. Inject results into the slice;
-     tool findings on changed lines are blocking input the judge triages.
+  2. **Static analysis**: the shared R1 free check
+     (`../../_shared/review-slice.md` §1) — reuse Phase 5's `tool_findings[]`;
+     re-run it when a fix wave changed files. Never install tooling.
+     Tool findings on changed lines are blocking input the judge triages.
   Slice adds: matrix, changed-file LIST (never an inlined diff — the judge
-  reads matrix-guided via its own Read/Grep), verify report, static-analysis
-  results, the resolved pattern's blocking invariants. REVISE → scored
+  reads matrix-guided via its own Read/Grep), verify report, `tool_findings[]`,
+  `gotcha_card` (§2), the resolved pattern's blocking invariants. REVISE → scored
   executor **fix wave** for only the affected tasks (findings verbatim in
   slices) → re-verify → re-judge. All clear → Phase 7.
 

package/templates/skills/orc/subskills/orc-execution/SKILL.md

@@ -1,73 +1,27 @@
----
-name: orc-execution
-description: >
-  Executor worker for ORC — the single-task implementer. Given one task slice
-  (task_id, declared_files, constraints, spec_ref, log_digest), it implements
-  EXACTLY that task within its declared files, honors every hard-rule constraint,
-  creates/updates tests, emits milestone progress pings, and returns a strict
-  contract (status done|failed|partial|needs_context, actual_files, log_entries,
-  and claimed-vs-actual model/effort so the caller can catch a silent tier
-  downgrade). Dispatched once per task in an execution wave, on the scored model
-  pinned by its executor agent. Distinct from the review/verify/test-author
-  workers — this one writes the implementation. ALWAYS a spawned subagent; the
-  orchestrator never implements. Not for direct user invocation.
----
-
-# orc-execution
-
-One entry point: the orchestrator spawns a subagent via the Task tool,
-prepending `subagent.md` framing + the input slice, which points to `core.md`.
-`core.md` is the AUTHORITATIVE spec (full input slice, procedure, and return
-contract); the summary below orients — on any conflict, `core.md` wins.
-
-## What the worker does (summary)
-
-1. Absorb `log_digest` (prior DECISIONs/INTERFACEs/ANSWERs bind you); read `spec_ref`.
-2. Implement EXACTLY the task in the slice, touching only `declared_files[]`,
-   honoring every `constraints[]` hard rule AND the standing `house_rules` card
-   (surgical changes, simplicity-first, no unrequested scope, never claim
-   unobserved results, honest partial over false done), then the `rules_card`
-   under it (project rules beat ORC rules; return the three `rules_*` fields); create/update
-   tests for what you build.
-3. Run the proof: build/test for your changes, capturing `evidence`
-   {command, exit_code, tail} VERBATIM (no runner → `no_runner_detected: true`);
-   self-check the diff against the slice's `acceptance[]` + `constraints[]` —
-   anything unsatisfied goes in `unmet[]` (non-empty = partial/failed, never done).
-4. Emit milestone pings ({percent, files_written[], notes}) as you go.
-5. Stay in your slice — need outside context? emit `needs_context`, don't fetch it.
-
-## Return shape (summary — full contract in `core.md`)
-
-`{ task_id, actual_model, actual_effort, status: done|failed|partial|needs_context,
-actual_files[], evidence, no_runner_detected, unmet[], log_entries[],
-failure_reason, progress, context_request,
-pattern_version, invariants_checked, tdd_state }`
-
-When the slice carries a `pattern`, MATCH its conventions, satisfy every BLOCKING
-invariant AND every enforceable `validation_gate[]` line (advisory gate lines are
-informational); echo the `pattern_version` and set `invariants_checked: true` only after
-re-checking your diff. A pattern task that returns false/absent here is malformed.
-
-When the slice carries a `tdd_spec` (v0.33.0), run its materialized tests and
-implement to green — implement→test→repair, capped at the slice's
-`tdd_loop_max`; never edit a TDD test to make it pass (a wrong-looking test is
-a spec bug — return it). Return `tdd_state: green|red` (green needs the passing
-run in `evidence`; `done` with red is malformed).
-
-**Crosslink injection (orchestrator-side, advisory).** At slice assembly, if a
-task's declared files include a call site that matches an entry in
-`.claude/orc/crosslink/needs.json`, prepend the cached tag contract (from
-`.claude/orc/crosslink/cache/`) to the slice as `crosslink`, labeled with its
-effective cross-repo tier + "hints, not verified". The executor MATCHES the
-stated field names/types but never lets it override local code — it is advisory,
-so there is NO return field and nothing to attest (unlike `pattern`). A task with
-no boundary carries no `crosslink`.
-On a UI task, if the environment ships a `frontend-design` skill, read and apply
-it (skip silently when absent).
-
-**Validation checkpoint before returning:** `status=failed` REQUIRES a
-`failure_reason`; `needs_context` REQUIRES a `context_request` (capped at 2/task);
-`actual_model` is quoted VERBATIM from your system prompt, never inferred;
-`status=done` REQUIRES `evidence` when a runner exists (else
-`no_runner_detected: true`) and an EMPTY `unmet[]`. A
-malformed return is treated as failure by the caller.
+---
+name: orc-execution
+description: >
+  Executor worker for ORC — the single-task implementer. Given one task slice
+  (task_id, declared_files, constraints, spec_ref, log_digest), it implements
+  EXACTLY that task within its declared files, honors every hard-rule constraint,
+  creates/updates tests, emits milestone progress pings, and returns a strict
+  contract (status done|failed|partial|needs_context, actual_files, log_entries,
+  and claimed-vs-actual model/effort so the caller can catch a silent tier
+  downgrade). Dispatched once per task in an execution wave, on the scored model
+  pinned by its executor agent. Distinct from the review/verify/test-author
+  workers — this one writes the implementation. ALWAYS a spawned subagent; the
+  orchestrator never implements. Not for direct user invocation.
+---
+
+# orc-execution
+
+A pointer. The orchestrator spawns the scored executor agent via the Task tool,
+prepending `subagent.md` framing + the input slice. The orchestrator never
+implements.
+
+- **Input slice** (the orchestrator builds it): `core.md`.
+- **Procedure + return contract** (the ONE source): the executor agent file,
+  `.claude/agents/orc-executor-*.md`.
+- **Validator** (the caller checks every return against it):
+  `../../../_shared/return-validation.md`. A malformed return is treated as
+  failure by the caller.

package/templates/skills/orc/subskills/orc-execution/core.md

@@ -1,7 +1,9 @@
-# orc-execution — Core (mode-neutral)
+# orc-execution — Core (the input slice)
 
-A procedure specification: inputs, steps, outputs. Executed by a spawned
-subagent; the orchestrator never runs this itself.
+The INPUT SLICE the orchestrator builds for ONE executor dispatch. The
+procedure and the return contract live in ONE place: the executor agent file
+(`.claude/agents/orc-executor-*.md`). The caller validates the return against
+`../../../_shared/return-validation.md`. The orchestrator never implements.
 
 ## Input slice (you receive exactly this; you cannot pull more)
 
@@ -31,9 +33,11 @@ subagent; the orchestrator never runs this itself.
 - crosslink               — the cross-repo boundary contract for a call site in
                             this task, or null. Present ONLY when a declared file
                             touches a boundary the orchestrator resolved from
-                            `.claude/orc/crosslink/needs.json` + cache. It is
+                            `.claude/orc/crosslink/needs.json` + the cached tag
+                            contract in `.claude/orc/crosslink/cache/`. It is
                             ADVISORY hints ("cross-repo fresh/aging/stale wiki")
-                            labeled with an effective tier — MATCH the field
+                            labeled with an effective tier + "hints, not
+                            verified" — MATCH the field
                             names/types/errors it states, but it never overrides
                             local code and there is nothing to attest (no return
                             field). Absent on any task with no boundary.
@@ -75,97 +79,6 @@ subagent; the orchestrator never runs this itself.
 - worktree_path           — null unless worktrees mode
 - model, effort           — informational (already applied by the caller)
 
-## Procedure
-
-1. Absorb log_digest — prior DECISIONs/INTERFACEs/ANSWERs bind you.
-2. Read spec_ref if provided.
-2a. **Read on the ladder** (`../../../_shared/read-ladder.md`): locate
-   (Grep/Glob) → outline → the ±40 lines around the anchor → full. Stop at the
-   step that answers the question; two full reads with no answer is
-   `needs_context`, not a third. TWO EXCEPTIONS — every `declared_files` path is
-   a FULL read before you edit it (an `old_string` rebuilt from an outline is a
-   corruption bug), and build/test output is always read whole.
-3. Perform the task within `worktree_path` (or the current tree if null).
-   Obey every `house_rules` line, then every `rules_card` rule (two rules that
-   disagree go in `rules_conflicts[]`, never a silent choice). Follow every constraint. If `pattern` is present, MATCH its conventions,
-   satisfy every BLOCKING invariant, and satisfy every enforceable
-   `validation_gate[]` line (re-read your diff to confirm before returning;
-   advisory gate lines are informational — never add tooling to meet one);
-   if `pattern` is null but carries invariants (agnostic), still satisfy them and
-   imitate the neighboring files you read. Create/update tests for what you build.
-   **UI task + a `frontend-design` skill present in the environment** (check
-   `.claude/skills/frontend-design/` or the plugin dir): read its SKILL.md and
-   apply its guidance to the UI work — skip silently when absent.
-4. **Run the proof, capture the evidence:** if the project has a runnable build
-   or test setup, run it for your changes and capture {command, exit_code, the
-   last ~5 output lines} — QUOTED VERBATIM, never paraphrased, never predicted.
-   No runner → set `no_runner_detected: true` instead. Never claim green you
-   did not observe. With a `tdd_spec`: run ITS tests too — implement → test →
-   repair up to `tdd_loop_max` iterations; still red at the cap → stop and
-   return `tdd_state: red` honestly (the failing tests listed in unmet[]).
-5. **Self-check before returning:** re-read your diff against every
-   `acceptance[]` line and every `constraints[]` rule. Anything you could not
-   satisfy goes in `unmet[]` — and a non-empty `unmet[]` means status `partial`
-   (or `failed`), never `done`. An honest partial beats a false done.
-6. **Milestone pings:** after each declared file completed or logical subtask
-   done, emit a brief progress ping: {percent, files_written[], notes}. These
-   bound what a mid-wave stop can save — do not skip them.
-7. Stay within your task. Discovering needed context outside your slice →
-   emit the needs_context return (below). Do NOT fetch it yourself.
-
-## Return contract (emit EXACTLY this structure; the caller validates)
-
-- task_id
-- actual_model            — the model id quoted VERBATIM from your system prompt
-                            ("The exact model ID is …"); NEVER inferred from priors;
-                            `unknown` if no such line exists. Lets the caller catch
-                            a silent tier downgrade (claimed-vs-actual model check)
-- actual_effort           — the value of $CLAUDE_EFFORT (read via Bash at start)
-- status: done | failed | partial | needs_context
-- actual_files[]          — every file you truly touched (audited vs declared)
-- evidence                — {command, exit_code, tail} of the build/test you ran,
-                            quoted VERBATIM (like actual_model — never invented).
-                            REQUIRED when status=done and the project has a
-                            runnable build/test; null when it has none
-- no_runner_detected      — true ONLY when the project exposes no runnable
-                            build/test (explains a null evidence); else absent
-- unmet[]                 — acceptance[]/constraints[] lines you could NOT
-                            satisfy. MUST be empty when status=done — a
-                            non-empty unmet[] forces partial/failed
-- log_entries[]           — cross-cutting decisions for the decision log,
-                            tagged DECISION | CONSTRAINT | INTERFACE
-- failure_reason          — REQUIRED when status=failed (the why); else null
-- progress                — {percent, files_written[], notes} when partial; else null
-- context_request         — REQUIRED when status=needs_context: what you need
-                            and why (e.g. "needs T1's type enum interface");
-                            else null
-- pattern_version         — the `pattern.pattern_version` you applied; null if no
-                            pattern was supplied
-- invariants_checked      — true ONLY if you verified every BLOCKING invariant in
-                            `pattern` against your diff; false/null if no invariants
-                            were supplied. A pattern task returning false/absent here
-                            is a malformed return
-- tdd_state               — green | red | null. REQUIRED when the slice carried a
-                            `tdd_spec`: green ONLY after its tests pass (run quoted
-                            in `evidence`); red = cap hit/unresolved (failing tests
-                            in unmet[]); null only without a tdd_spec. status=done
-                            with red is malformed
-- repro                   — REQUIRED when the slice carried
-                            `repro.required: true`; else absent. {command, before:
-                            {exit_code, tail}, after: {exit_code, tail}} quoted
-                            VERBATIM, or `none` + a one-line reason. status=done
-                            with before.exit_code 0 (never red) or a non-zero
-                            after.exit_code (still red) is malformed. Canonical:
-                            `.claude/skills/_shared/return-validation.md` §5d
-- gotcha_recorded         — REQUIRED when this return CLOSES a repair loop (you
-                            drove a tdd_spec test red → green): the entry body
-                            {trigger, symptom, cause, fix, scope}, or `none` + a
-                            one-line reason. Absent on a repair-closing return is
-                            malformed; not required when nothing was repaired. A
-                            loop that hit `tdd_loop_max` and STOPPED returns
-                            `none` — an unsolved failure is not a gotcha. You
-                            RETURN it; the caller writes the file
-
-Malformed returns are treated as failure by the caller. needs_context is
-capped at 2 per task — a third means the slice or plan is wrong and escalates
-to the user.
+A task with no boundary carries no `crosslink`. Malformed returns are treated
+as failure by the caller. needs_context is capped at 2 per task — a third means
+the slice or plan is wrong and escalates to the user.