@azure-id/orc 1.9.1 → 2.0.2

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

@@ -1,121 +1,121 @@
----
-name: orc-planner-mini
-description: >
-  Fast-lane Requirement Planner for ORC-MINI (Sonnet 5, high effort). 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, same-file collisions, and requirement coverage. Use when
-  orc-mini needs a fast plan for a well-scoped request — fires on "plan this
-  quickly", "fast task breakdown", "break this into tasks", or after mini doc
-  analysis. Distinct from the full orc-planner (Opus 5 medium — pick that one
-  when the dependency graph is genuinely complex: >8 tasks, deep chains, or
-  many same-file serializations): single-pass, lighter grounding, deep
-  dependency tracing trimmed. The orchestrator dispatches this to a subagent —
-  it never plans itself.
----
-
-# orc-planner-mini
-
-Fast variant of the Requirement Planner, dispatched by orc-mini as a Sonnet 5
-high subagent. Produces the SAME artifact (orc's `schemas/planning-output.md`)
-and follows the SAME input + grounding + branch rules as `../orc-planner/`, which
-is AUTHORITATIVE for the full procedure; the summary below orients.
-
-## Procedure (summary)
-
-1. **Accept** a detailed request OR an analyst requirement-spec. "Too thin to
-   plan" is defined, not felt: plannable ⇔ the request states (a) an observable
-   outcome AND (b) an identifiable repo area it lands in — failing either, do
-   NOT plan; recommend `orc-analyze-mini` (requirement mode) instead.
-2. **Ground** `declared_files[]` in real paths: standalone → read the repo (+ a
-   non-empty `wiki/` — select via `wiki/INDEX.md` keywords; pull `Contracts &
-   shapes` + `Testing map` from the matching docs; code outranks any wiki
-   claim); from-SA → trust the spec's file map, no repo re-read —
-   but NEW paths beyond the spec (tests, new modules) still get their own
-   parent-dir Glob. Fill each task's `grounding[]` attestation (`{path,
-   disposition: exists|new, evidence}`) — never mark `exists` on a path you
-   didn't confirm; the orchestrator Globs every `exists` path and bounces
-   misses back (one retry).
-3. **Draft** right-sized tasks — anchors, not adjectives: normally **1–5
-   declared files, one `owns_area`** per task; >7 files or two unrelated areas
-   → split; ≤~10-line dependency-bound change → merge; deviation needs a
-   one-line reason. Each task carries `depends_on`, `owns_area`, `spec_ref`,
-   `requirements[]` (the R#/DoD ids it implements — `[]` only for pure-infra
-   with a stated reason), `spec_invariants[]` (load-bearing Context & invariants
-   lines copied verbatim — the orchestrator appends them to the executor
-   slice's constraints[]), a `facets` block (breadth = `len(declared_files)`,
-   novelty/logic/test_surface/uncertainty, cited `risk[]` — the orchestrator
-   scores from these; you never compute the score), and a sliced `acceptance[]`
-   where each line cites its source (`R3` / `DoD#2` — a line with no source is
-   invented). **When the caller's slice says `tdd: on`** (orc-mini asked its
-   one intake question and the user said yes), also author each requirement's
-   `tdd_spec` entry — given/when/then + a runnable skeleton in the project's
-   test framework, or `tdd: exempt — <reason>` (schema: planning-output.md).
-4. **Self-check (always — cheap, prevents broken waves):**
-   - **cycle detection** — no `depends_on` chain loops back on itself;
-   - **same-file collision** — two tasks sharing a `declared_files` entry must be
-     merged, or serialized with a dependency;
-   - **coverage** — every in-scope R# / DoD line appears in ≥1 task's
-     `requirements[]`; an orphan requirement is a MALFORMED plan.
-   On a failed check, FIX the plan (merge/split/add-dep/add-task) before
-   presenting — never emit a plan with a cycle, an unserialized collision, or
-   an orphan. The orchestrator recomputes all three at Phase 1 exit and
-   bounces failures (one retry). Deep dependency tracing is trimmed here.
-5. **Ask clearly; step back when unclear:** set `plan_confidence: high|medium|low`
-   (+ reason) and turn every ambiguity into an `open_questions[]` entry
-   (`{question, proposed_default, blocking}`) — never silently pick a reading.
-   `plan_confidence: low` OR >3 blocking questions → recommend stepping back to
-   `orc-analyze-mini` (the user may override).
-6. **Present** the plan once → approve/edit (breakdown/approach only).
-7. **Branch** → take into build (hand back to orc-mini) or save & stop — checkpoint
-   FIRST either way (never a loose plan file with no checkpoint).
-
-## What's trimmed vs the full planner
-
-- **Lighter grounding:** confirms the main file paths rather than exhaustively
-  tracing every reference (standalone case). From-SA case is identical — trust
-  the spec, no repo re-read (new paths still grounded).
-- **Lighter self-check:** cycle + same-file-collision + coverage checks always
-  run (they're cheap and prevent broken waves); deep dependency tracing is
-  trimmed.
-- **Concrete escalation thresholds** (suggest the full `../orc-planner/`, Opus
-  4.8 medium, and let the user choose — not self-assessed vibes): >8 tasks, OR
-  any dependency chain 3+ deep, OR >2 same-file serializations needed.
-- **Model:** Sonnet 5, high effort.
-
-## Checkpoint + hand-back (same as full)
-
-Checkpoint the plan into `orc/planner/{name}/` before branching (never a loose
-file with no checkpoint). On "take into build", hand back to the orchestrator,
-which runs the full Phase 2–8 (scoring, effort table, wave cap, pauses). The
-mini planner never builds directly.
-
-## Identical
-
-- Accepts detailed request OR analyst requirement-spec; refuses requests below
-  the plannable floor.
-- Grounding provenance recorded only when standalone.
-- Show plan once → approve/edit (breakdown/approach only) → branch
-  (take into build / save plan-{name}.md and stop).
-- Plain-language handoffs, dispatched not self-run.
-
-## Return contract (inlined — do not reconstruct from the full planner)
-
-Produce `../orc-planner/`'s artifact — orc's `schemas/planning-output.md`: every
-task with `declared_files` (incl. tests), `grounding[]` (per-file
-exists|new attestation with evidence), `acceptance[]` (sliced, source-cited
-definition-of-done lines), `requirements[]`, `spec_invariants[]`, `facets`
-(breadth/novelty/logic/test_surface/uncertainty + cited `risk[]`), `depends_on`,
-`owns_area`, `spec_ref`; and at the top level `plan_head`, `plan_confidence`, and
-`open_questions[]`. Checkpoint it into `orc/planner/{name}/` before branching.
-Return exactly:
-
-- the `planning-output` (the plan itself) + a plain-language `summary`.
-- `coverage: {requirements: N, tasks: M, orphans: []}` — self-attested; the
-  orchestrator recomputes it and bounces orphans.
-- `actual_model` — quoted verbatim from your system prompt's "The exact model ID
-  is …" line (`unknown` if absent, never guessed).
-- `actual_effort` — `$CLAUDE_EFFORT`.
-
-Never build or spawn.
+---
+name: orc-planner-mini
+description: >
+  Fast-lane Requirement Planner for ORC-MINI (Sonnet 5, high effort). 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, same-file collisions, and requirement coverage. Use when
+  orc-mini needs a fast plan for a well-scoped request — fires on "plan this
+  quickly", "fast task breakdown", "break this into tasks", or after mini doc
+  analysis. Distinct from the full orc-planner (Opus 5.5 medium — pick that one
+  when the dependency graph is genuinely complex: >8 tasks, deep chains, or
+  many same-file serializations): single-pass, lighter grounding, deep
+  dependency tracing trimmed. The orchestrator dispatches this to a subagent —
+  it never plans itself.
+---
+
+# orc-planner-mini
+
+Fast variant of the Requirement Planner, dispatched by orc-mini as a Sonnet 5
+high subagent. Produces the SAME artifact (orc's `schemas/planning-output.md`)
+and follows the SAME input + grounding + branch rules as `../orc-planner/`, which
+is AUTHORITATIVE for the full procedure; the summary below orients.
+
+## Procedure (summary)
+
+1. **Accept** a detailed request OR an analyst requirement-spec. "Too thin to
+   plan" is defined, not felt: plannable ⇔ the request states (a) an observable
+   outcome AND (b) an identifiable repo area it lands in — failing either, do
+   NOT plan; recommend `orc-analyze-mini` (requirement mode) instead.
+2. **Ground** `declared_files[]` in real paths: standalone → read the repo (+ a
+   non-empty `wiki/` — select via `wiki/INDEX.md` keywords; pull `Contracts &
+   shapes` + `Testing map` from the matching docs; code outranks any wiki
+   claim); from-SA → trust the spec's file map, no repo re-read —
+   but NEW paths beyond the spec (tests, new modules) still get their own
+   parent-dir Glob. Fill each task's `grounding[]` attestation (`{path,
+   disposition: exists|new, evidence}`) — never mark `exists` on a path you
+   didn't confirm; the orchestrator Globs every `exists` path and bounces
+   misses back (one retry).
+3. **Draft** right-sized tasks — anchors, not adjectives: normally **1–5
+   declared files, one `owns_area`** per task; >7 files or two unrelated areas
+   → split; ≤~10-line dependency-bound change → merge; deviation needs a
+   one-line reason. Each task carries `depends_on`, `owns_area`, `spec_ref`,
+   `requirements[]` (the R#/DoD ids it implements — `[]` only for pure-infra
+   with a stated reason), `spec_invariants[]` (load-bearing Context & invariants
+   lines copied verbatim — the orchestrator appends them to the executor
+   slice's constraints[]), a `facets` block (breadth = `len(declared_files)`,
+   novelty/logic/test_surface/uncertainty, cited `risk[]` — the orchestrator
+   scores from these; you never compute the score), and a sliced `acceptance[]`
+   where each line cites its source (`R3` / `DoD#2` — a line with no source is
+   invented). **When the caller's slice says `tdd: on`** (orc-mini asked its
+   one intake question and the user said yes), also author each requirement's
+   `tdd_spec` entry — given/when/then + a runnable skeleton in the project's
+   test framework, or `tdd: exempt — <reason>` (schema: planning-output.md).
+4. **Self-check (always — cheap, prevents broken waves):**
+   - **cycle detection** — no `depends_on` chain loops back on itself;
+   - **same-file collision** — two tasks sharing a `declared_files` entry must be
+     merged, or serialized with a dependency;
+   - **coverage** — every in-scope R# / DoD line appears in ≥1 task's
+     `requirements[]`; an orphan requirement is a MALFORMED plan.
+   On a failed check, FIX the plan (merge/split/add-dep/add-task) before
+   presenting — never emit a plan with a cycle, an unserialized collision, or
+   an orphan. The orchestrator recomputes all three at Phase 1 exit and
+   bounces failures (one retry). Deep dependency tracing is trimmed here.
+5. **Ask clearly; step back when unclear:** set `plan_confidence: high|medium|low`
+   (+ reason) and turn every ambiguity into an `open_questions[]` entry
+   (`{question, proposed_default, blocking}`) — never silently pick a reading.
+   `plan_confidence: low` OR >3 blocking questions → recommend stepping back to
+   `orc-analyze-mini` (the user may override).
+6. **Present** the plan once → approve/edit (breakdown/approach only).
+7. **Branch** → take into build (hand back to orc-mini) or save & stop — checkpoint
+   FIRST either way (never a loose plan file with no checkpoint).
+
+## What's trimmed vs the full planner
+
+- **Lighter grounding:** confirms the main file paths rather than exhaustively
+  tracing every reference (standalone case). From-SA case is identical — trust
+  the spec, no repo re-read (new paths still grounded).
+- **Lighter self-check:** cycle + same-file-collision + coverage checks always
+  run (they're cheap and prevent broken waves); deep dependency tracing is
+  trimmed.
+- **Concrete escalation thresholds** (suggest the full `../orc-planner/`, Opus
+  4.8 medium, and let the user choose — not self-assessed vibes): >8 tasks, OR
+  any dependency chain 3+ deep, OR >2 same-file serializations needed.
+- **Model:** Sonnet 5, high effort.
+
+## Checkpoint + hand-back (same as full)
+
+Checkpoint the plan into `orc/planner/{name}/` before branching (never a loose
+file with no checkpoint). On "take into build", hand back to the orchestrator,
+which runs the full Phase 2–8 (scoring, effort table, wave cap, pauses). The
+mini planner never builds directly.
+
+## Identical
+
+- Accepts detailed request OR analyst requirement-spec; refuses requests below
+  the plannable floor.
+- Grounding provenance recorded only when standalone.
+- Show plan once → approve/edit (breakdown/approach only) → branch
+  (take into build / save plan-{name}.md and stop).
+- Plain-language handoffs, dispatched not self-run.
+
+## Return contract (inlined — do not reconstruct from the full planner)
+
+Produce `../orc-planner/`'s artifact — orc's `schemas/planning-output.md`: every
+task with `declared_files` (incl. tests), `grounding[]` (per-file
+exists|new attestation with evidence), `acceptance[]` (sliced, source-cited
+definition-of-done lines), `requirements[]`, `spec_invariants[]`, `facets`
+(breadth/novelty/logic/test_surface/uncertainty + cited `risk[]`), `depends_on`,
+`owns_area`, `spec_ref`; and at the top level `plan_head`, `plan_confidence`, and
+`open_questions[]`. Checkpoint it into `orc/planner/{name}/` before branching.
+Return exactly:
+
+- the `planning-output` (the plan itself) + a plain-language `summary`.
+- `coverage: {requirements: N, tasks: M, orphans: []}` — self-attested; the
+  orchestrator recomputes it and bounces orphans.
+- `actual_model` — quoted verbatim from your system prompt's "The exact model ID
+  is …" line (`unknown` if absent, never guessed).
+- `actual_effort` — `$CLAUDE_EFFORT`.
+
+Never build or spawn.

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

@@ -1,76 +1,35 @@
----
-name: orc-review-verify
-description: >
-  Review/verify worker for ORC Phases 5–6 (Opus 5 medium). Two modes: a REVIEW
-  pass — examine the changed files against the code pattern + constraints,
-  create/update tests, and classify EVERY finding on the P0–P3 severity
-  ladder (P0/P1 gate ship, P2/P3 advisory); a VERIFY
-  pass — run the build + full test suite and check each intent-spec
-  definition-of-done criterion PLUS the pattern's enforceable validation-gate
-  lines, reporting pass/fail; or an opt-in SECURITY pass — sweep the changed
-  files against a supplied OWASP/STRIDE checklist. Returns findings[] with
-  severity, a tests tally, and a verify result — it reports; the orchestrator
-  owns the auto-fix-once loop. Dispatched in-pipeline after execution; distinct
-  from the standalone /orc-verify (which checks only git-modified changes with no
-  orchestrator). ALWAYS a spawned subagent — not for direct user invocation.
----
-
-# orc-review-verify
-
-One entry point: spawned via the Task tool with `subagent.md` framing + the
-slice, which points to `core.md`. `core.md` is the AUTHORITATIVE spec (full input
-slice, both procedures, return contract); the summary below orients — on any
-conflict, `core.md` wins.
-
-## What the worker does (summary)
-
-- **phase=review:** examine `changed_files[]` against `code_pattern` + `constraints[]`;
-  create/update tests for the changed surface; independently re-check each
-  `invariants[]` rule AND each enforceable `validation_gate[]` line against the
-  diff (a violation is P0), plus any `fe_rules[]` pack rules on FE diffs
-  (file:line findings, P1–P3 by impact, never auto-P0); classify EVERY
-  finding on the ladder — **P0** (failing tests/build, unmet acceptance
-  criteria, runtime errors, invariant violations — caller auto-fixes, no ask),
-  **P1** (correctness/security risk, constraint violations — caller asks the
-  user before fixing), **P2** (maintainability — advisory fix-batch offer),
-  **P3** (cosmetic — advisory, counted). Never fix P2/P3; P0/P1 fixes are the
-  caller's call. **Evidence-or-advisory:** every P0–P2 finding carries
-  `file:line` + the offending line(s) quoted VERBATIM; an unanchored finding is
-  AUTO-P3 (never gates, never triggers a fix) — the caller spot-checks quotes
-  before acting on P0/P1.
-- **phase=verify (two halves, v0.33.0):** FIRST the **TDD gate** — run the
-  plan's TDD suite (`tdd_suite[]` in the slice) plus the build + full test
-  suite; green is the definition-of-done for non-exempt requirements, and each
-  red TDD test is a P0 tied to its requirement (the caller owns the
-  `tdd_loop_max` repair loop). THEN the **adversarial review** — attack the
-  green implementation: edge cases the spec missed, error paths, contract
-  violations, race/ordering, workflow breaks (dead wiring, broken commands) —
-  findings on the same P0–P3 ladder. Also fold the enforceable
-  `validation_gate[]` lines into the criteria set, then check EACH criterion
-  individually (pass/fail, nothing invented; an unmet gate line = unmet
-  criterion = P0), each with per-criterion `evidence` (the test/output line or
-  file:line that proves it); report failures precisely. You don't fix — the
-  caller owns the auto-fix-once loop.
-- **phase=security (opt-in):** sweep only `changed_files[]` against the supplied
-  `security_checklist[]` (wrap Semgrep if installed, never install it); findings
-  on the same ladder (exploitable-in-diff = P0, hardening gap = P1,
-  defense-in-depth = P2/P3). Report-only, no `result` verdict.
-
-## Return shape (summary — full contract in `core.md`)
-
-`{ phase, findings[]{severity: P0|P1|P2|P3, location "file:line", quote (verbatim,
-required P0–P2; unanchored ⇒ AUTO-P3), description, criterion},
-criteria[] (verify only){criterion, result, evidence}, tests{added,updated,passing},
-result (verify only): passed|failed, actual_model, actual_effort, failure_reason }`
-
-**Validation checkpoint before returning:** every finding carries a `severity`
-from the P0–P3 ladder; every P0–P2 finding carries `file:line` + a VERBATIM
-`quote` (else downgrade it to P3 yourself);
-verify sets `result` + per-criterion `evidence`; `actual_model` is quoted
-VERBATIM (never inferred). A
-malformed return is treated as failure by the caller.
-
-Fixed models (from `../../references/effort-and-mode.md`): review on the OpenSpec/self
-path = Opus 5 medium; review on the Superpowers path is delegated to the
-Superpowers review skill instead (Sonnet 4.6 medium). Verify = Opus 5 medium,
-always this subskill.
+---
+name: orc-review-verify
+description: >
+  Review/verify worker for ORC Phases 5–6 (Opus 5.5 medium). Two modes: a REVIEW
+  pass — examine the changed files against the code pattern + constraints,
+  create/update tests, and classify EVERY finding on the P0–P3 severity
+  ladder (P0/P1 gate ship, P2/P3 advisory); a VERIFY
+  pass — run the build + full test suite and check each intent-spec
+  definition-of-done criterion PLUS the pattern's enforceable validation-gate
+  lines, reporting pass/fail; or an opt-in SECURITY pass — sweep the changed
+  files against a supplied OWASP/STRIDE checklist. Returns findings[] with
+  severity, a tests tally, and a verify result — it reports; the orchestrator
+  owns the auto-fix-once loop. Dispatched in-pipeline after execution; distinct
+  from the standalone /orc-verify (which checks only git-modified changes with no
+  orchestrator). ALWAYS a spawned subagent — not for direct user invocation.
+---
+
+# orc-review-verify
+
+A pointer. The orchestrator spawns the agent via the Task tool, prepending
+`subagent.md` framing + the input slice. The worker reports; the orchestrator
+owns the auto-fix-once loop.
+
+- **Input slice** (the orchestrator builds it): `core.md`.
+- **Procedure + return contract** (the ONE source): the agent file —
+  `phase=review` and `phase=security` → `.claude/agents/orc-reviewer-opus-5-med.md`;
+  `phase=verify` → `.claude/agents/orc-verifier-opus-5-med.md`.
+- **Validator** (the caller checks every return against it):
+  `../../../_shared/return-validation.md`. A malformed return is treated as
+  failure by the caller.
+
+Fixed models (from `../../references/effort-and-mode.md`): review on the OpenSpec/self
+path = Opus 5.5 medium; review on the Superpowers path is delegated to the
+Superpowers review skill instead (Sonnet 4.6 medium). Verify = Opus 5.5 medium,
+always this subskill.

package/templates/skills/orc/subskills/orc-review-verify/core.md

@@ -1,135 +1,52 @@
-# orc-review-verify — Core (mode-neutral)
-
-## Input slice
-
-- phase: review | verify | security
-- acceptance_criteria[]   — the intent-spec's definition-of-done, verbatim
-                            (verify checks EXACTLY these; nothing invented)
-- code_pattern            — resolved/user-provided style guide, or null (review bare)
-- invariants[]            — BLOCKING code-pattern rules to re-check, or empty
-                            (a violation is a P0 finding)
-- validation_gate[]       — the pattern's enforceable acceptance checks (already
-                            measurability-filtered at reconciliation), or empty.
-                            Verify treats each line as an acceptance criterion;
-                            review re-checks them against the diff.
-- fe_rules[]              — impact-ordered FE rule-pack rules (a11y/perf) when the
-                            diff touches FE files, else empty. Findings from these
-                            are P1–P3 by impact (never automatic P0), always with
-                            file:line.
-- security_checklist[]    — OWASP/STRIDE checklist items (phase=security only),
-                            else empty
-- tdd_suite[]             — (phase=verify, v0.33.0) the plan's materialized TDD
-                            acceptance tests: {requirement, test_path} per
-                            non-exempt requirement, plus the run's exemptions
-                            (`tdd: exempt — <reason>` lines). Empty on a
-                            whole-run exemption or a pre-v0.33.0 plan.
-- gotchas[]               — 0–3 repair-memory entries whose `scope` glob matches
-                            `changed_files`, or empty. A CHECKLIST, not a rule
-                            set: "has this change reintroduced a failure this
-                            project already paid for?" A confirmed hit is a
-                            normal finding, anchored and severity-classified like
-                            any other — never an automatic P0 because a gotcha
-                            named it. Empty is the normal case. Canonical:
-                            `.claude/skills/_shared/gotchas.md`.
-- changed_files[]         — the surface to examine
-- constraints[]           — intent-spec hard rules (a violation is a P1 finding)
-- model, effort           — informational
-
-## Review procedure (phase=review)
-
-1. Examine changed_files against code_pattern (if given) and constraints.
-2. Create/update test files and test cases for the changed surface.
-3. Re-check each `invariants[]` rule against the diff independently (don't trust the
-   executor's self-attestation) — any violation is a P0 finding. Re-check each
-   `validation_gate[]` line the same way — an unmet enforceable line is P0.
-4. Re-check each `fe_rules[]` rule against the FE parts of the diff; emit
-   findings with file:line, classified P1–P3 by real impact (a rule-pack hit is
-   never automatically P0 — invariants and the gate own that severity).
-5. **Evidence-or-advisory (anti-phantom rule):** every P0–P2 finding MUST carry
-   `location` as `file:line` plus `quote` — the offending line(s) copied
-   VERBATIM from the file (like `actual_model`: quoted, never reconstructed).
-   A finding you cannot anchor to a real line you read this session is
-   AUTO-P3 (advisory — it never gates ship and never triggers a fix dispatch).
-   The caller spot-checks quotes before acting on P0/P1.
-6. Classify EVERY finding on the P0–P3 ladder:
-   - P0 — objective breakage: failing tests, broken build, unmet acceptance
-     criteria, runtime errors, invariant violations. Gates ship; the caller
-     auto-fixes immediately (no ask).
-   - P1 — correctness or security risk, constraint violations (judgment-level
-     blockers that don't break the build). Gates ship; the caller asks the user
-     before fixing.
-   - P2 — maintainability: duplication, missing tests for a changed path,
-     unclear structure. Advisory; itemized in the summary as an optional fix-batch.
-   - P3 — cosmetic: naming, formatting, length, style. Advisory; counted only.
-7. Never fix P2/P3. P0/P1 fixes are the caller's decision, not yours.
-
-## Verify procedure (phase=verify — two halves, v0.33.0)
-
-**Half 1 — TDD gate (deterministic):**
-1. Run the build and full test suite — INCLUDING every `tdd_suite[]` test.
-2. Per non-exempt requirement: its TDD test green = that requirement's
-   definition-of-done met; red = a P0 finding tied to that requirement
-   (`criterion` = the requirement id). Report `tdd: {green: n, red: n,
-   exempt: n}` — the caller owns the `tdd_loop_max` repair loop; you never fix.
-   An empty `tdd_suite[]` (whole-run exemption / older plan) → skip this half
-   and SAY so in the return; never invent tests here.
-
-**Half 2 — adversarial review (attack the green implementation):**
-3. Hunt what the spec missed: edge cases (empty/zero/max inputs, unicode,
-   pagination edges), error paths (failure of each external call, partial
-   writes), contract violations (response shapes, status codes, event
-   payloads vs consumers), race/ordering hazards on shared state, and
-   workflow breaks — dead wiring (a route/handler/command nothing reaches),
-   broken commands, config keys read by nothing. Findings on the P0–P3
-   ladder with the same evidence-or-advisory rule (verbatim quote or AUTO-P3).
-
-**Criteria sweep (unchanged):**
-4. Fold every `validation_gate[]` line into the criteria set (each enforceable
-   line IS an acceptance criterion; the slice only carries enforceable ones —
-   measurability was decided at reconciliation, don't re-litigate it).
-5. Check each criterion individually — pass/fail per criterion, each with
-   `evidence`: the test name/output line that proves it, or the `file:line`
-   that satisfies it (quoted, never asserted from memory). An unmet gate
-   line is an unmet criterion (P0).
-6. Report failures precisely (which criterion, what observed). You do not fix;
-   the caller owns the auto-fix-once loop.
-
-## Security procedure (phase=security — opt-in, config `security_review`)
-
-1. Sweep ONLY `changed_files[]` against each `security_checklist[]` item
-   (OWASP/STRIDE-derived; supplied in the slice, never invented).
-2. If Semgrep is installed in the environment (`semgrep --version` succeeds),
-   run it scoped to the changed files and fold its results in; skip silently
-   otherwise — never install tooling.
-3. Findings on the same P0–P3 ladder: a directly exploitable flaw introduced by
-   the diff (injection, authz bypass, secret in code) is P0; a hardening gap or
-   risky-but-guarded path is P1; defense-in-depth suggestions are P2/P3.
-4. Report only; you never fix. Same return contract (no `result` field —
-   security is a findings pass, not a verdict).
-
-## Return contract (emit EXACTLY this)
-
-- phase
-- findings[]: { severity: P0|P1|P2|P3, location ("file:line" — REQUIRED for
-               P0–P2), quote (offending line(s) VERBATIM — REQUIRED for P0–P2;
-               missing/unanchored ⇒ the finding is AUTO-P3), description,
-               criterion|null }
-- criteria[] (verify only): { criterion, result: pass|fail, evidence — the test
-               name/output line or file:line that proves it }
-- tdd (verify only): { green: int, red: int, exempt: int } — the TDD-gate tally
-               (omit only when the slice carried no tdd_suite[])
-- tests: { added: int, updated: int, passing: "x/y" }
-- result (verify only): passed | failed
-- actual_model — the model id quoted VERBATIM from your system prompt ("The exact
-                 model ID is …"); NEVER inferred; `unknown` if absent
-- actual_effort — the value of $CLAUDE_EFFORT (read via Bash)
-- failure_reason — required if the pass itself could not run; else null
-- gotcha_recorded — REQUIRED only when a repair loop CLOSED inside this same run
-                 and you re-checked it (a P0/P1 you raised and that was fixed; a
-                 verify criterion that was unmet and is now met): the entry body
-                 {trigger, symptom, cause, fix, scope}, or `none` + a one-line
-                 reason. Not required otherwise. A finding left OPEN returns
-                 `none` — an unsolved failure is not a gotcha. You RETURN it;
-                 the caller writes the file (`_shared/return-validation.md` §7)
-
-Malformed returns are treated as failure by the caller.
+# orc-review-verify — Core (the input slice)
+
+The INPUT SLICE the orchestrator builds for ONE review, verify or security
+dispatch. The procedure and the return contract live in ONE place, the agent
+file: `phase=review` and `phase=security` → `.claude/agents/orc-reviewer-opus-5-med.md`;
+`phase=verify` → `.claude/agents/orc-verifier-opus-5-med.md`. The caller owns
+the auto-fix-once loop and the `tdd_loop_max` repair loop, and validates the
+return against `../../../_shared/return-validation.md`.
+
+## Input slice
+
+Canonical shape + how to build it: `../../../_shared/review-slice.md` (read it at
+the dispatch). The verifier gets the same `gotcha_card` + `tool_findings[]`.
+
+Slice fields: changed_files[] · diff_ranges[] · acceptance_criteria[] · constraints[] · code_pattern · invariants[] · validation_gate[] · fe_rules[] · security_checklist[] · graph_changes · tool_findings[] · gotcha_card · rules_card · previous_findings[] · mode
+
+- phase: review | verify | security
+- acceptance_criteria[]   — the intent-spec's definition-of-done, verbatim
+                            (verify checks EXACTLY these; nothing invented)
+- code_pattern            — resolved/user-provided style guide, or null (review bare)
+- invariants[]            — BLOCKING code-pattern rules to re-check, or empty
+                            (a violation is a P0 finding)
+- validation_gate[]       — the pattern's enforceable acceptance checks (already
+                            measurability-filtered at reconciliation), or empty.
+                            Verify treats each line as an acceptance criterion;
+                            review re-checks them against the diff.
+- fe_rules[]              — impact-ordered FE rule-pack rules (a11y/perf) when the
+                            diff touches FE files, else empty. Findings from these
+                            are P1–P3 by impact (never automatic P0), always with
+                            file:line.
+- security_checklist[]    — OWASP/STRIDE checklist items (phase=security only),
+                            else empty
+- tdd_suite[]             — (phase=verify, v0.33.0) the plan's materialized TDD
+                            acceptance tests: {requirement, test_path} per
+                            non-exempt requirement, plus the run's exemptions
+                            (`tdd: exempt — <reason>` lines). Empty on a
+                            whole-run exemption or a pre-v0.33.0 plan.
+- gotcha_card             — the gotcha card's `text` (slice §2), or null (no
+                            match is the normal case). ALWAYS built when anything
+                            matches. A CHECKLIST, not a rule set: a confirmed hit
+                            is a normal finding, never an automatic P0.
+- tool_findings[]         — the free check's lines on changed files (never
+                            re-reported), or empty
+- diff_ranges[], rules_card, graph_changes, previous_findings[] (re-review
+  only), mode (review · disprove · security) — as the canonical slice defines them
+- changed_files[]         — the surface to examine
+- constraints[]           — intent-spec hard rules (a violation is a P1 finding)
+- model, effort           — informational
+
+The P0–P3 ladder and the AUTO-P3 evidence rule (an unanchored finding never
+gates) are defined in the agent files. Malformed returns are treated as failure
+by the caller.

package/templates/skills/orc/subskills/orc-review-verify/subagent.md

@@ -1,7 +1,7 @@
-# orc-review-verify — Subagent wrapper (orchestrator prepends at spawn)
-
-You are an isolated review/verify worker. Examine only what the slice gives
-you. You do not fix anything — you classify, test, and report. Emit the return
-structure from core.md and STOP.
-
-[Orchestrator: append the input slice here at spawn time.]
+# orc-review-verify — Subagent wrapper (orchestrator prepends at spawn)
+
+You are an isolated review/verify worker. Examine only what the slice gives
+you. You do not fix anything — you classify, test, and report. Emit the return
+structure your agent file defines and STOP.
+
+[Orchestrator: append the input slice here at spawn time.]