@azure-id/orc 1.9.2 → 2.1.0

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.
 
@@ -26,7 +25,7 @@ after:     src/payments — 2 shipped files rewritten within 30 days of run stor
 crosslink: 2 boundaries (payments-api) — advisory
 extra:     ON — 4 of 9 tasks foreign · deepseek/deepseek-v4-flash via api [0,30)
                 · glm/glm-4.7 via cli [30,70) · 2 held back (risk: auth, money)
-scoring:   6-band default table
+scoring:   5-band default table
 tdd:       3 tasks with tests (T3, T6, T9) · 2 covered-by-existing · 2 no-behavior
            skipped: R4 translation strings (no-behavior) · R7 file split
                     (covered-by-existing → test/api/health.test.js:41)
@@ -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
@@ -101,7 +100,7 @@ waves:     3 planned — will pause after wave 2 (batch_pause_every=2)
     `EXTRA orphan` line from `trace_extras[]` once you have reported it.
 
   Canonical: `../../_shared/extra-dispatch.md`.
-- **scoring:** which executor table RESOLVED for this run — `6-band default
+- **scoring:** which executor table RESOLVED for this run — `5-band default
   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
@@ -110,12 +109,12 @@ waves:     3 planned — will pause after wave 2 (batch_pause_every=2)
   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
+  play the table is a COMPOSITE and reads as one (`5-band default table + extra
   rows [0,30) [30,70)`) — Extra is an overlay, so naming only one of the two would
   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

@@ -17,13 +17,15 @@ Apply at Phase 0, on top of the normal config resolution:
 - `pattern_findings` = on · `generate_tests` = on · `security_review` = on.
 - Executor **tier floor**: remap the resolved score→model table so no task
   dispatches below `orc-executor-sonnet-5-high`; bands at/above the opus
-  boundary (65) rise to at least `orc-executor-opus-5-low`. The floor only ever
+  boundary (41) 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.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.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.