@azure-id/orc 1.9.1 → 2.0.2

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
@@ -105,9 +104,9 @@ waves:     3 planned — will pause after wave 2 (batch_pause_every=2)
   table` · `Opus-5-only ladder (opus5_only)` · `custom
   (rubric_bands_override, <n> rows)`. An un-shown table is as unaccountable as
   an un-shown number, and the Opus-5-only ladder in particular means EVERY
-  dispatch needs an Opus 5 main session — the user should see that before the
+  dispatch needs an Opus 5.5 main session — the user should see that before the
   first dispatch, not in a trace full of downgrades. When `opus5_only` is on,
-  append ` · all fixed roles forced to Opus 5` and name any selector it
+  append ` · all fixed roles forced to Opus 5.5` and name any selector it
   shadowed (a `rubric_bands_override` present but INERT) — a setting
   the user tuned and the run then ignored has to be said out loud. With Extra in
   play the table is a COMPOSITE and reads as one (`6-band default table + extra
@@ -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

@@ -6,7 +6,7 @@ the ultra deltas. Ultra exists ONLY here — never in orc-mini, never on a plain
 `/orc` run.
 
 Cost stance: ultra is costly by definition. State it once at intake
-("ultra adds an Opus 5 xhigh advisor + up to 3 judge dispatches + revision
+("ultra adds an Opus 5.5 xhigh advisor + up to 3 judge dispatches + revision
 loops"), then never prompt about cost again.
 
 ## Forced overrides (run-scoped — NEVER written to the user's config file)
@@ -20,13 +20,15 @@ Apply at Phase 0, on top of the normal config resolution:
   boundary (65) rise to at least `orc-executor-opus-5-low`. The floor only ever
   raises a band, so the top `[90,100]` band keeps `orc-executor-opus-5-med`.
   **Under `opus5_only` the floor raises EFFORT, not model** (every band is
-  already Opus 5, so there is no model left to raise): the `[0,90)` band rises
+  already Opus 5.5, so there is no model left to raise): the `[0,90)` band rises
   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 (advisor and judge are pinned there by default) and the scouts rise to
+> Opus 5.5 (advisor and judge are pinned there by default) and the scouts rise to
 > `orc-scout-opus-5-low`. It FORCES. See `../../_shared/opus5-only.md`.
 
 ## Phase U0 — Advisor (after intake sign-off, before the analyst)
@@ -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.

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

@@ -1,13 +1,14 @@
-# orc-execution — Subagent wrapper (orchestrator prepends this at spawn)
-
-You are an isolated execution worker. You have no memory of the wider run
-beyond the slice below. Do exactly one task.
-
-- Work only within your slice's declared_files and worktree_path (if set).
-- Do not touch the checkpoint, state-of-play, or the raw decision log — your
-  log_entries are returned, and the orchestrator appends them.
-- Emit milestone pings as you progress.
-- When done (or blocked), emit the return structure from `core.md` and STOP.
-  Do not continue past your task.
-
-[Orchestrator: append the input slice here at spawn time.]
+# orc-execution — Subagent wrapper (orchestrator prepends this at spawn)
+
+You are an isolated execution worker. You have no memory of the wider run
+beyond the slice below. Do exactly one task.
+
+- Work only within your slice's declared_files and worktree_path (if set).
+- Do not touch the checkpoint, state-of-play, or the raw decision log — your
+  log_entries are returned, and the orchestrator appends them.
+- Emit milestone pings as you progress.
+- When done (or blocked), emit the return structure your agent file defines
+  and STOP.
+  Do not continue past your task.
+
+[Orchestrator: append the input slice here at spawn time.]

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

@@ -1,7 +1,7 @@
 ---
 name: orc-planner
 description: >
-  Requirement Planner for ORC (Opus 5 medium). Turns a detailed request OR a
+  Requirement Planner for ORC (Opus 5.5 medium). Turns a detailed request OR a
   System Analyst requirement-spec into orc's planning-output: right-sized tasks,
   each with grounded declared_files (incl. tests), explicit depends_on, owns_area,
   and spec_ref — self-checked for dependency cycles and same-file collisions. A
@@ -14,7 +14,7 @@ description: >
 
 # orc-planner (Requirement Planner)
 
-The orchestrator stays on top and **dispatches a planner subagent (Opus 5,
+The orchestrator stays on top and **dispatches a planner subagent (Opus 5.5,
 medium)** to produce the plan. Strictly planning: it does not implement, review,
 or verify. Output contract is orc's `schemas/planning-output.md` (single-source;
 do not redefine it here).