@ikon85/agent-workflow-kit 0.32.1 → 0.34.0

package/.agents/skills/ask-matt/SKILL.md

@@ -49,7 +49,8 @@ Prefer the smallest depth that produces a clear next action.
   undertaking, several independently-shippable stages. Run `/scale-check`
   first (it owns the altitude criteria catalog — this router only names it);
   two or more criteria tripped routes to a program grill → `/to-prd` →
-  `/to-waves`.
+  `/to-issues`. The explicit Program identity makes the Planning facade select
+  its internal graph engine; the user never chooses that engine.
 - **Deep:** `/grill-with-docs` followed by `/to-prd` and `/to-issues` when
   terminology, contracts, rollout order, or ownership are still uncertain.
 - **Medium:** `/to-issues` for a ready artefact that needs slicing.
@@ -73,9 +74,9 @@ A starting situation that generates work, then merges onto the main flow.
 
 - **Bugs and requests piling up** → **`/triage`**. Moves issues through triage and produces agent-ready issues that `/implement` later picks up. Only for issues **you didn't create** — `/to-issues` output is already agent-ready, don't triage it.
 - **Something's broken** → **`/diagnose`**. For the hard ones: the bug that resists a first glance, the intermittent flake, the regression between two known-good states. Refuses to theorise until it has a **tight feedback loop** — one command that already goes red on *this* bug — then fixes with a regression test. Its post-mortem hands off to **`/improve-codebase-architecture`** when the finding is that there's no good seam.
-- **A huge, foggy effort too big for one agent session** — a greenfield build or a sprawling feature where the way from here to the destination isn't yet visible, and it's still **pre-spec** (before any grill or PRD) → **`/wayfinder`** (user-invoked). It charts a **shared map** of investigation slices on the tracker and resolves them one at a time — producing **decisions, not deliverables** — until the fog lifts and the route is clear, then merges onto the main flow at **`/to-prd`** (or, if the effort turned out small enough, straight to **`/implement`**). Where `/grill-with-docs` sharpens an idea you can hold in one session, wayfinder is for the one you can't. Once an undertaking has already resolved into several independently-shippable waves, `/scale-check` → `/to-waves` stays the primary route.
+- **A huge, foggy effort too big for one agent session** — a greenfield build or a sprawling feature where the way from here to the destination isn't yet visible, and it's still **pre-spec** (before any grill or PRD) → **`/wayfinder`** (user-invoked). It charts a **shared map** of investigation slices on the tracker and resolves them one at a time — producing **decisions, not deliverables** — until the fog lifts and the route is clear, then merges onto the main flow at **`/to-prd`** (or, if the effort turned out small enough, straight to **`/implement`**). Where `/grill-with-docs` sharpens an idea you can hold in one session, wayfinder is for the one you can't. Once an undertaking has already resolved into several independently-shippable waves, `/scale-check` → `/to-issues` stays the primary route.
 - **A backlog to cluster** → **`/board-to-waves`**. Groups an existing board into themed waves when you need to *find* the next wave rather than start fresh.
-- **A whole wave to LAND** → **`/orchestrate-wave`**. When a wave anchor (file-disjoint slices, specs already locked) is ready to build, verify and land end-to-end — often AFK: it dispatches an implementer per slice in its own worktree, integrates serially, verifies centrally, and lands the wave. The execute-and-land node of the wave ladder (`scale-check` → `to-waves`/`board-to-waves` → `orchestrate-wave`). A single slice just goes to `/implement`.
+- **A whole wave to LAND** → **`/orchestrate-wave`**. When a wave anchor (file-disjoint slices, specs already locked) is ready to build, verify and land end-to-end — often AFK: it dispatches an implementer per slice in its own worktree, integrates serially, verifies centrally, and lands the wave. The execute-and-land node of the wave ladder (`scale-check` → `to-issues`/`board-to-waves` → `orchestrate-wave`). A single slice just goes to `/implement`.
 
 ## Cross-model review (Codex)
 

package/.agents/skills/audit-skills/SKILL.md

@@ -114,6 +114,12 @@ otherwise stay invisible.
 
 ### 2. Audit in parallel — one subagent per skill
 
+Before dispatch, resolve a provider-neutral Routing intent through
+`src/lib/routeDispatcher.mjs` and require a Dispatch receipt from the shared
+spawn guard. A detected transport is not authorization; AFK dispatch stops
+unless requested/applied route, model/effort enforcement, environment
+precedence, and catalog/access/policy revisions are proved.
+
 Run **one read-only research subagent per skill** — several in parallel in a
 SINGLE message (they are independent and read-only, so they don't contend for the
 git index). Per subagent prompt:

package/.agents/skills/board-to-waves/SKILL.md

@@ -36,7 +36,11 @@ to-issues        slices + promotes (sets type:cluster + Wave at ≥2 slices)
 
 **Stops at stubs.** No slice plan, no PRD, no sub-issue link, no promotion. Whether/when a stub becomes a real wave = separate step (`to-prd → to-issues`), <maintainer>'s call.
 
-**S4 exit — no stub at all.** A candidate that trips the `scale-check` altitude criteria (Splitter S4 below) skips the stub step entirely — it is reported as an escalation, pointing at `scale-check` (→ a program grill → `to-prd` program mode → `to-waves`), never at `to-prd`/`to-issues` directly. Still <maintainer>'s call, still no board write here.
+**S4 exit — no stub at all.** A candidate that trips the `scale-check` altitude
+criteria (Splitter S4 below) skips the stub step entirely — it is reported as
+an escalation, pointing at `scale-check` (→ a program grill → `to-prd` Program
+mode → `to-issues`), never straight into ordinary Feature decomposition. Still
+<maintainer>'s call, still no board write here.
 
 Model: **strongest available reasoning model for board-wide judgment calls** (survey/plan/brainstorm — cross-board judgment, <maintainer>'s table).
 
@@ -64,7 +68,7 @@ Model: **strongest available reasoning model for board-wide judgment calls** (su
 - **S1 Too big** — > ~7 slices / not shippable in a manageable sequence → split into two waves.
 - **S2 Foreign parent** — issue already hangs under another wave (GitHub 1-parent; `to-issues` link check is the final word).
 - **S3 "Same type alone" ≠ wave** — type is a booster, never a gate. Otherwise "all refactors" becomes a junk drawer.
-- **S4 Programm-Verdacht** — the candidate trips the `scale-check` altitude criteria (`.claude/skills/scale-check/SKILL.md` § "Altitude criteria (the single source of truth)" — referenced here, **never** re-forked; e.g. staged delivery + several subsystems that each stand on their own) → **escalate to the Program route instead of creating a candidate stub**: report it in the candidate list (§3/§5) pointing at `scale-check` (grill once into a Program-PRD with a Wellenplan, then `to-waves` unfolds it), not `to-prd`/`to-issues`. The bottom-up Wave-stamping rule above is unaffected — an escalated candidate is still just a proposal, not yet a committed wave, exactly like any other candidate.
+- **S4 Programm-Verdacht** — the candidate trips the `scale-check` altitude criteria (`.claude/skills/scale-check/SKILL.md` § "Altitude criteria (the single source of truth)" — referenced here, **never** re-forked; e.g. staged delivery + several subsystems that each stand on their own) → **escalate to the Program route instead of creating a candidate stub**: report it in the candidate list (§3/§5) pointing at `scale-check` (grill once into a Program-PRD with a Wellenplan, then `to-issues` selects the Program graph path from that explicit identity), not directly to a hidden engine. The bottom-up Wave-stamping rule above is unaffected — an escalated candidate is still just a proposal, not yet a committed wave, exactly like any other candidate.
 
 **Rule:** issue → candidate X if **Gate(X) satisfied AND ≥1 booster fires** and no splitter applies. Otherwise: own candidate or leftover bucket "unclustered / standalone issue".
 

package/.agents/skills/code-review/SKILL.md

@@ -73,6 +73,12 @@ When `projectEnrichment` is active, read `docs/agents/code-review.md` first. App
 
 ## Execution
 
+Before dispatch, resolve a provider-neutral Routing intent through
+`src/lib/routeDispatcher.mjs` and require a Dispatch receipt from the shared
+spawn guard. A detected transport is not authorization; AFK dispatch stops
+unless requested/applied route, model/effort enforcement, environment
+precedence, and catalog/access/policy revisions are proved.
+
 - Run both axes as **parallel sub-agents** — separate context each, so neither poisons the other's read. Give the Standards sub-agent the Standards sources **plus** the full Fowler baseline in its prompt; it has no other way to see the baseline.
 - Report **side by side**, under `## Standards` and `## Spec` headers, verbatim or lightly cleaned — never merge or re-rank the two into one combined verdict.
 - Cap each sub-agent's report under 400 words — findings, not padding.

package/.agents/skills/codebase-design/DESIGN-IT-TWICE.md

@@ -18,7 +18,17 @@ Show this to the user, then immediately proceed to Step 2. The user reads and th
 
 ### 2. Spawn sub-agents
 
-Spawn 3+ sub-agents in parallel using the Agent tool. Each must produce a **radically different** interface for the deepened module.
+Before dispatch, resolve a provider-neutral Routing intent through
+`src/lib/routeDispatcher.mjs` and require a Dispatch receipt from the shared
+spawn guard. A detected transport is not authorization; AFK dispatch stops
+unless requested/applied route, model/effort enforcement, environment
+precedence, and catalog/access/policy revisions are proved.
+
+<!-- mirror-xform:start codex-parallel-subagent-dispatch -->
+When the user has authorized subagent delegation, make 3+ parallel
+`spawn_agent` calls using only `task_name`, `message`, and `fork_turns`. Each
+must produce a **radically different** interface for the deepened module.
+<!-- mirror-xform:end -->
 
 Prompt each sub-agent with a separate technical brief (file paths, coupling details, dependency category from [DEEPENING.md](DEEPENING.md), what sits behind the seam). The brief is independent of the user-facing problem-space explanation in Step 1. Give each agent a different design constraint:
 

package/.agents/skills/codex-adapter-sync/SKILL.md

@@ -22,23 +22,27 @@ correct issue or slice worktree before the first edit. Never apply adapter
 changes on `main`; move any accidental main-checkout diff into the worktree and
 leave the main checkout clean.
 
-## Model routing
-
-Default to inherited parent model configuration. Do not pin a model merely
-because the source workflow delegates, and do not invent model or role fields
-on a spawn call. The supported built-in agent names are `default`, `worker`, and
-`explorer`; custom agents declare overrides in their TOML files.
-
-When an explicit custom-agent model is genuinely justified, route by task
-shape:
-
-- `gpt-5.6-sol` for complex, open-ended judgment work.
-- `gpt-5.6-terra` for everyday tool-using development.
-- `gpt-5.6-luna` for clear, repeatable, high-volume work.
-
-Use `model_reasoning_effort` for a supported reasoning override. The family
-name `gpt-5.6` describes the family and is not a fourth concrete variant in
-this routing table. Keep user gates, security judgment, and approval decisions
+## Routing intent
+
+Durable issues and handoffs describe task shape with provider-neutral
+`routing-intent` and `reasoning-intent` values. Never persist a provider model
+identifier or copy a resolved route back into shared work. The supported
+built-in agent names remain `default`, `worker`, and `explorer`.
+
+At dispatch time, resolve the intent by comparing the Kit-owned Evidence
+catalog with the user-local Access graph and Routing policy. Keep those
+contracts separate: catalog facts include inaccessible models, the Access graph
+attests available paths and enforcement, and personal policy filters facts
+without changing them. Report the best overall route separately from the best
+currently executable route. Unknown transports and stale capability evidence
+block; missing routing infrastructure may fall back only through explicit
+`inherit`.
+
+Apply any selected provider route only through the active surface's verified
+adapter. An AFK dispatch must prove its requested and applied route plus model
+and effort enforcement in a one-execution Dispatch receipt. Credentials,
+personal access state, and personal policy stay outside repositories and
+package-owned files. Keep user gates, security judgment, and approval decisions
 in the main thread.
 
 ## Scope
@@ -148,8 +152,8 @@ Run validation from the repository root and keep the evidence in the report:
    - Leave clearly Claude-only setup, hook, or personal/meta skills out unless
      the user explicitly wants them ported.
    - Translate Claude-specific delegation rather than copying it literally.
-     Apply the Model routing section above only when an explicit custom-agent
-     override is justified; otherwise preserve inherited parent configuration.
+     Apply the Routing intent section above only when an explicit user-local
+     route is justified; otherwise preserve explicit inheritance.
    - Keep dual-surface generic/vendored skill bodies content-synced. When a
      Codex mirror must intentionally differ from the Claude source, bracket the
      source region and the Codex replacement with a matching transform marker

package/.agents/skills/improve-codebase-architecture/INTERFACE-DESIGN.md

@@ -18,6 +18,12 @@ Show this to the user, then immediately proceed to Step 2. The user reads and th
 
 ### 2. Spawn sub-agents
 
+Before dispatch, resolve a provider-neutral Routing intent through
+`src/lib/routeDispatcher.mjs` and require a Dispatch receipt from the shared
+spawn guard. A detected transport is not authorization; AFK dispatch stops
+unless requested/applied route, model/effort enforcement, environment
+precedence, and catalog/access/policy revisions are proved.
+
 <!-- mirror-xform:start codex-parallel-subagent-dispatch -->
 When the user has authorized subagent delegation, spawn 3+ sub-agents in parallel with `spawn_agent`. Each must produce a **radically different** interface for the deepened module.
 <!-- mirror-xform:end -->

package/.agents/skills/improve-codebase-architecture/SKILL.md

@@ -35,8 +35,17 @@ This skill is _informed_ by the project's domain model. The domain language give
 
 Read the project's domain glossary and any ADRs in the area you're touching first.
 
+Before dispatch, resolve a provider-neutral Routing intent through
+`src/lib/routeDispatcher.mjs` and require a Dispatch receipt from the shared
+spawn guard. A detected transport is not authorization; AFK dispatch stops
+unless requested/applied route, model/effort enforcement, environment
+precedence, and catalog/access/policy revisions are proved.
+
 <!-- mirror-xform:start codex-explorer-dispatch -->
-When the user has authorized subagent delegation, use `spawn_agent` with `agent_type: explorer` to walk the codebase; otherwise explore locally. Don't follow rigid heuristics — explore organically and note where you experience friction:
+When the user has authorized subagent delegation, use `spawn_agent` with only
+`task_name`, `message`, and `fork_turns` to walk the codebase; otherwise explore
+locally. Don't follow rigid heuristics — explore organically and note where you
+experience friction:
 <!-- mirror-xform:end -->
 
 - Where does understanding one concept require bouncing between many small modules?

package/.agents/skills/kit-update/SKILL.md

@@ -57,6 +57,19 @@ release contain the same artifact.
    (`missing-file`, `missing-section`, `empty-section`, or
    `divergent-section`); it never echoes consumer content.
 
+   Independently, run the routing-profile read-only preflight before applying
+   the package candidate. A valid unchanged user-local profile reports
+   `still valid` and causes zero prompts. Ask after successful Kit activation
+   only when the profile is missing, invalid, materially stale, references a
+   removed route, or a newly detected surface creates a meaningful choice.
+   Re-inspect after package activation, present a typed delta containing only
+   that changed choice, and preserve unaffected personal fields. Fingerprint
+   and exclusively lock the destination before writing; a concurrent personal
+   edit blocks reconciliation and remains untouched. Unattended update records
+   `needs-reconcile`; it never invents a personal answer. Declining the
+   routing reconcile leaves the successful Kit update applied because package
+   installation and personal policy are separate transactions.
+
 3. Read the terminal report. `aktuell` proves a second run found no upstream
    delta or pending readiness migration. A conflict report names and counts
    every category and leaves every consumer file untouched. Follow its

package/.agents/skills/orchestrate-wave/SKILL.md

@@ -73,10 +73,10 @@ node scripts/readiness.mjs check --skill orchestrate-wave --json
   - **Plan-level error** (integration/verify reveals a wrong LOCKED decision, not a
     slice bug): STOP the wave. No improvised redesign AFK — keep worktrees intact,
     report findings + options.
-  - **On ANY wave STOP/abort:** if this run planted the active-wave claim, remove
-    exactly that claim as part of shutdown. Never delete a claim marker observed
-    during a preflight collision, nor any sibling/foreign wave marker — those are
-    owned by another run. A stale marker owned by this run would block a safe retry.
+  - **On ANY wave STOP/abort:** if this run planted the active-wave claim, release
+    it via `releaseWaveClaim` with this run's owner as part of shutdown — it
+    refuses a foreign payload. Never delete a claim marker observed during a
+    preflight collision. A stale own marker would block a safe retry.
 - **Routing = one axis: how expensive is a wrong result to catch?** Mechanically
   caught (test/screenshot/lint) → default tier at medium/low effort; plausible-but-
   wrong / subtle logic / architecture → top tier at high effort + main-thread
@@ -87,6 +87,24 @@ node scripts/readiness.mjs check --skill orchestrate-wave --json
   first red test). The same axis sets how hard you re-verify. Borderline → default
   tier + re-verify beats blanket top tier.
 
+## Orchestration mechanics
+
+Pass only host-supplied inventory through `capabilityAdapter.claude` or `.codex`,
+then call the selector. It returns exactly one target; missing or `unknown` evidence
+degrades A → B → C. A model claim is not evidence; do not emulate a missing primitive.
+Before any spawn, resolve the provider-neutral Routing intent through the shared resolver and spawn guard, then use the active Claude or Codex adapter. Codex contributes only its dated host attestation through `routingAdapters/codex.mjs`; it does not create a second catalog, Access graph, or Routing policy. A detected transport is not authorization. The Dispatch receipt must show requested and applied route, model/effort enforcement, environment precedence on mismatch, and catalog/access/policy revisions. AFK blocks unverified, unauthorized, overridden, unenforced, or silently degraded routes; a Codex host without model and effort selectors blocks differentiated AFK before spawn, and unreachable routes follow policy handoff/inherit/block exactly.
+- **Path A:** requires the literal `Workflow` tool, callable and permitted, plus
+  individually proven named phases, run identity, runtime output validation,
+  journal, and resume. Then read [its recipe](references/dispatch-workflow.md).
+- **Path B:** requires proven native spawn, wait, and aggregate plus effective
+  concurrency and thread capacity ≥2. Then read [its recipe](references/dispatch-subagents.md).
+- **Path C:** keep recon and building direct and serial in the main thread. Produce
+  the same FILE → SLICES evidence, create each worktree from the integrated base,
+  apply the builder contract, validate the result, then continue. Load no reference.
+
+Phases 0 and 3–6 always remain in the main thread. Visible fan-out progress may
+replace the ~30-second heartbeat; otherwise the standing heartbeat remains required.
+
 ## Phase 0 — Setup
 
 1. **Read everything**: the anchor body, every sub-issue body (each has a Handoff
@@ -98,15 +116,15 @@ node scripts/readiness.mjs check --skill orchestrate-wave --json
    preflight's single degraded summary is the only warning. Never guess a project
    command, tunnel, login, or verify recipe.
 3. **Preflight — refuse a wave already in flight, otherwise claim it.** Before
-   dispatch, inspect all three same-machine collision signals: **(a)** an existing
-   `wave-active/<anchor>` tag; **(b)** any slice branch ahead of the wave's current
-   base (`git rev-list --count <base>..<slice-branch>` > 0); **(c)** uncommitted
-   changes in any slice worktree (`git -C <worktree> status --porcelain` non-empty).
-   A hit not created by this run means another session may be building the wave:
-   **STOP**, report the exact tag/branch/worktree, and do not touch it. If clean,
-   record that this run owns the claim and plant a LOCAL annotated tag:
-   `git tag -a wave-active/<anchor> -m "orchestrating since <UTC timestamp>;
-   slices: <slice-branches>"`. It is local coordination state — never push it.
+   dispatch, inspect the two same-machine work signals: **(a)** any slice branch
+   ahead of the wave's current base (`git rev-list --count <base>..<slice-branch>`
+   > 0); **(b)** uncommitted changes in any slice worktree (`git -C <worktree>
+   status --porcelain` non-empty). Acquire the claim itself through `claimWave`
+   from `src/lib/waveClaim.mjs`: a compare-and-set on the `wave-active/<anchor>`
+   LOCAL annotated tag, so two sessions racing one wave cannot both win. Either
+   `acquired: false` or a work signal you did not create means another session
+   owns the wave — **STOP**, report the returned `claim.owner` plus the exact
+   branch/worktree, touch nothing. Local coordination state — never push the tag.
 4. **Wave worktree**: reuse the planning worktree (never re-create; the handoff
    points there). Bring its branch to current `main`:
    `git -C <wave> merge --ff-only origin/main` (if your repo guards destructive
@@ -124,17 +142,10 @@ preflight clean + this run's local claim planted · wave branch ff'd to
 
 ## Phase 1 — Disjointness recon (the load-bearing step)
 
-Zero merge conflicts later depends entirely on getting this right.
-
-- Delegate to a read-only investigator agent: for EACH slice the exact file path of
-  every named component + resolve ambiguous targets, then a **FILE → SLICES** table
-  listing every file that appears in ≥2 slices.
-- Build the **overlap graph**. Identify the **conflict hub** (the slice whose new
-  artifacts other slices reuse). **Build the hub first**, merge it, THEN the
-  dependents stop conflicting.
-- Cut into **waves of fully file-disjoint slices**. Edited-by-≥2 = serialize across
-  waves; only-shared-via-import = safe. A new primitive edited by one slice but
-  *consumed* by others is NOT a conflict.
+Phase 1 uses the selected orchestration mechanics. Resolve every named component,
+produce the **FILE → SLICES** table and overlap graph, then build the conflict hub
+before its dependents. Cut fully file-disjoint waves; shared imports are safe, but
+files edited by multiple slices serialize across waves.
 - **Native blocking edges are the frontier authority.** Read the anchor's
   buildable frontier from the tracker's native issue dependencies:
   `python3 scripts/board-sync.py frontier <anchor#>` → `FREI` / `BLOCKED by #…` /
@@ -143,15 +154,11 @@ Zero merge conflicts later depends entirely on getting this right.
   body text or table order alone. The frontier must AGREE with your Phase-1
   dependency order; a contradiction is a plan finding to reconcile before dispatch,
   not a detail.
-- **Reconcile contradictory sub-issue ACs against the plan BEFORE dispatch — the
-  plan is authority.** `to-issues` cuts slices independently, so a shared
-  append-only file (a query-key registry, a barrel, a shared types module) is often
-  claimed by *every* slice, with duplicate/clashing adds. **The hub slice OWNS the
-  shared-mutable file: it pre-adds ALL the wave's keys/types/helpers; dependents
-  CONSUME only and never touch it.** Embed verbatim in each dependent's contract:
-  "X already exists in `<file>` — do NOT add it, consume only." (Real case: all 14
-  sub-issues claimed the same registry adds + 4 contradictions — hub expanded to
-  own all 20 keys, batch merged conflict-free.)
+- **Reconcile contradictory sub-issue ACs against the plan BEFORE dispatch.** Safe
+  declaration-only registries may be predeclared by one hub; eager/validated
+  registries that read targets must serialize helper-owning slices through
+  dependency edges, each appending only its own existing artifact after creation.
+  Both preserve one owner per shared edit and the no-conflict invariant.
 - **Retirement slices require a valid topological deletion order.** Before
   dispatching slices that delete a legacy cluster, map every to-delete module's
   production importers and build the cluster's internal import graph. Order the
@@ -160,25 +167,19 @@ Zero merge conflicts later depends entirely on getting this right.
   deletions form a cycle, separate each-slice-green steps are impossible: combine
   the whole cycle into ONE atomic slice instead of landing dangling imports.
 
-**Done when:** FILE→SLICES table exists · every ≥2-slice file has exactly ONE
-owning slice · disjoint waves cut in dependency order · every dependent contract
-carries its verbatim consume-only lines.
+**Done when:** FILE→SLICES table exists · each shared file has either one
+declaration-only owner with verbatim consume-only dependents, or an explicit serialized
+owner sequence for eager/validated additions where each owner appends only its own existing artifact · disjoint waves cut in dependency order.
 
 ## Phase 2 — Dispatch one wave in parallel (isolated worktree per implementer)
 
-Phase 2+3 repeat **per disjoint wave** from Phase 1 — the conflict-hub wave first.
-Within ONE wave, all slices dispatch at once. **Dispatch only `FREI` slices** —
-re-read the native frontier (`frontier <anchor#>`) before each wave; a
-gate-before-build edge clears only when its blocker actually lands (never
-"unblock" by editing body text — remove the edge via `dep-remove` if the plan
-genuinely changed). Two per-slice calls first: **(a)
-inline vs delegate** — a tiny mechanical bit (a rename, a 1-2-line tweak) you do
-yourself — and **(b) tier + effort** (Standing rules → Routing). For each
-delegated slice:
-
-- **One worktree per agent** off the wave-branch HEAD, own index so parallel agents
-  never share a git index. Use your project's worktree-setup command (`§Setup`),
-  else plain `git worktree add <path> -b feat/<anchor>-<slug>`.
+Phase 2 uses the selected orchestration mechanics, repeating with Phase 3 per
+disjoint wave, conflict hub first. Dispatch only `FREI` slices: re-read
+`frontier <anchor#>` before each wave and clear changed edges only via `dep-remove`.
+Before each slice, bind **(a) inline vs delegate** and **(b) tier + effort** under
+Standing rules. Tiny mechanical work may stay inline.
+For Path A/B, create one worktree per agent from wave HEAD, using `§Setup` or
+`git worktree add <path> -b feat/<anchor>-<slug>`.
 - **Build the prompt from [`references/builder-contract.md`](references/builder-contract.md)**
   — fill the slots with the slice's VERBATIM What+AC, plan decision, recon
   file:line map and consume-only lines; never paraphrase (paraphrase drift has
@@ -193,8 +194,7 @@ package tests + green fast gate (`§Builder Commands`) — or a STOP item you re
 
 ## Phase 3 — Serial integration
 
-In the wave worktree: `git merge --no-ff <slice-branch>` per slice (disjoint →
-conflict-free). After EACH wave, on the integrated branch:
+In the wave worktree, `git merge --no-ff <slice-branch>` per slice. After EACH wave:
 
 - Typecheck both packages + the **FULL suite** — catches sibling/consumer test
   breaks the agent ownership didn't cover (hardcoded count/tab asserts). Exact
@@ -299,9 +299,9 @@ written · merge order documented.
   your own processes, targeted by the worktree's assigned ports, never blind).
   Remove temp verify scripts (a login helper, DB-check scripts).
 - **Remove only this run's claim marker.** If this run planted
-  `wave-active/<anchor>`, delete that exact local tag after success or abort. Never
-  delete a claim marker observed during a preflight collision or any other
-  `wave-active/*` marker; ownership, not a broad pattern, authorizes cleanup.
+  `wave-active/<anchor>`, call `releaseWaveClaim` with this run's owner after
+  success or abort; its owner check, not a broad `wave-active/*` pattern,
+  authorizes cleanup, and a foreign marker is left untouched.
 - **Before removing any slice worktree, read its `ANNAHMEN.md`** (an assumptions
   log, gitignored at worktree-root) and propagate each build-time assumption marker
   to the sibling issue it carries. A hand-driven multi-PR / migration landing does

package/.agents/skills/orchestrate-wave/references/builder-contract.md

@@ -56,13 +56,26 @@ invocation for each in this prompt so the builder cannot guess a wrong one.
    completed command result. Never end your turn while a command is still running.
 
 ## Report back (concise)
-Files touched · decisions taken · test results (exact completed command results
-and exit status) · commit SHA · STOP items · what the orchestrator should visually
-verify.
+Return exactly ONE JSON object against the builder report contract — no prose
+around it, no second object. Cover: files touched · decisions taken · test
+results (exact completed command results and exit status) · commit SHA · STOP
+items · what the orchestrator should visually verify.
 ```
 
 Orchestrator notes:
 
+- **The report contract is identical on every orchestration path.** Whether the
+  builder was dispatched by a scripted workflow, by native subagents, or run
+  directly and serially, it reports the same shape. `src/lib/reportValidator.mjs`
+  is the source of truth; [`references/report-contracts.md`](report-contracts.md)
+  is its machine-checked mirror for hosts that must inline a schema. Fill the
+  report section above with the builder schema from whichever of the two the
+  host can reach — never a hand-written variant.
+- **Validation is always the main thread's.** Schema-validate the returned
+  object, then call `semanticVerify` with independently collected Git facts. A
+  builder's own claim of success is a hypothesis; a payload that does not parse
+  or fails either check is a missing report, not a PASS.
+
 - `{{CONSUME_ONLY_LINES}}` come from the Phase-1 reconciliation, e.g.
   "X already exists in `<file>` — do NOT add it, consume only."
 - For dependent slices, fill hub artifact paths from the hub agent's report

package/.agents/skills/orchestrate-wave/references/dispatch-subagents.md

@@ -0,0 +1,91 @@
+# Path B — Native subagent dispatch
+
+Load this recipe only when the capability selector returns Path B. That result
+requires proven native spawn, wait, and aggregate primitives plus effective
+concurrency and thread capacity ≥2. Route from proven capabilities only, never
+from a surface name, and do not emulate a missing primitive.
+
+This recipe is **dormant unless the current host's complete orchestration
+inventory proves Path B.** The dated Codex routing attestation is a separate
+gate: the observed explicit-spawn schema exposes only `task_name`, `message`,
+and `fork_turns`, with no model or effort selector. Therefore
+`routingAdapters/codex.mjs` blocks differentiated AFK before spawn even when
+native start/wait/aggregate evidence is otherwise sufficient for Path B. A
+future host may enable the route only by attesting both orchestration primitives
+and applied model/effort controls; neither is inferred from the surface name.
+
+## Main-thread preparation
+
+1. Read the canonical `RECON_REPORT_SCHEMA` and `BUILDER_REPORT_SCHEMA` values
+   from `src/lib/reportValidator.mjs`. They are the same contract every
+   orchestration path reports against.
+2. Embed the relevant schema verbatim in each subagent prompt, together with the
+   instruction to return **exactly ONE JSON object** and nothing else — no
+   prose, no fences, no second object. The host does not enforce output shape,
+   so the contract lives in the prompt and the check lives in the main thread.
+3. Acquire the wave claim and create every worktree from the integrated base
+   through `claimWave` in `src/lib/waveClaim.mjs` before any spawn. Claim and
+   worktree creation stay serial in the main thread; only the agents fan out.
+
+## Round 1 — Recon
+
+Spawn **one read-only explorer per slice**, all in one batch so they run
+concurrently, then join them with an **explicit wait** on the spawned set —
+never a sleep, a poll loop, or an implicit continue. Aggregate only after the
+wait returns.
+
+Each explorer returns one recon report. Validate every returned payload against
+the recon schema in the main thread: a payload that does not parse, carries
+extra top-level keys, or fails the schema **is not a PASS** — it is a missing
+report. Re-spawn that single explorer with the failure quoted back to it; never
+accept a prose summary in place of the object.
+
+## Main-thread reconcile boundary
+
+Pass the complete, validated recon set to `reconcileReconReports`. A
+reconciliation failure stops the wave. A successful result is the only boundary
+that permits builders to start; use its overlap graph and dependency edges to
+cut safe dispatch batches. Multiple editors are safe only when dependency
+reachability totally orders them; shared-mutable files still require exactly one
+edit owner.
+
+Every orchestration path crosses this same main-thread reconciliation boundary.
+Reconciliation is never delegated to a subagent.
+
+## Round 2 — Build
+
+For the current reconciled batch, spawn **one builder per slice**, again as one
+concurrent batch joined by an explicit wait. Give each builder the verbatim
+builder contract, its reconciled allowlist, and its required commands. Resolve
+the provider-neutral Routing intent immediately before each spawn. Pass the
+decision through `routeDispatcher.mjs` and the active surface adapter. Claude
+uses its native or explicitly policy-approved transport attestation; Codex uses
+only its dated `routingAdapters/codex.mjs` host attestation. Both must prove
+their requested and applied model and effort controls before invocation.
+Detection alone never authorizes a transport.
+
+The spawn guard compares the requested route with the adapter's applied route
+and environment precedence. It emits the shared Dispatch receipt with
+catalog/access/policy revisions. An unverified control, unauthorized transport,
+override mismatch, or unenforced effort blocks AFK before spawn. A genuinely
+unreachable route follows the policy's handoff, inherit, or block result; never
+silently inherit. A host without a proved per-agent selector remains on its
+existing parent-session fallback only when explicit non-AFK policy permits it.
+
+Each builder returns exactly one builder report. Validate it against the builder
+schema and then run `semanticVerify` on it in the main thread. A subagent's own
+claim of success is a hypothesis, never the gate.
+
+## B1 fan-out is out of scope
+
+The **B1** shape — a single fan-out over a work list (`spawn_agents_on_csv`)
+plus a host-enforced per-agent `output_schema` — is explicitly excluded. The
+same spike found the callable spawn schema exposes only `task_name`, `message`,
+and `fork_turns`: no work-list fan-out and no output-schema parameter. This
+recipe therefore documents the **B2** shape only: explicit per-slice spawns
+joined by an explicit wait, with validation owned by the main thread.
+
+Re-opening B1 requires its own version-pinned verify spike — tracked as an open
+spike issue on the kit's own tracker — before any recipe or adapter change.
+Never infer the capability from a release note; prove it against the pinned
+runtime first.

package/.agents/skills/orchestrate-wave/references/dispatch-workflow.md

@@ -0,0 +1,66 @@
+# Path A — Scripted Workflow dispatch
+
+Load this recipe only when the capability selector returns Path A. That result
+requires the literal `Workflow` tool and every required primitive. Route from
+proven capabilities only, never from a surface name, and do not emulate
+Workflow. The current Codex host lacks complete capability evidence and selects
+Path C; a future host selects whichever path its evidence proves.
+
+## Main-thread preparation
+
+1. Read the canonical `RECON_REPORT_SCHEMA` and `BUILDER_REPORT_SCHEMA` values
+   from `src/lib/reportValidator.mjs`.
+2. Serialize each value as an inline schema literal in its generated Workflow
+   script. Workflow scripts cannot import modules, so never put an `import()`,
+   `require`, `process`, or `fetch` workaround in them.
+3. Build deterministic run arguments. Pass run identity, slice IDs, prompts,
+   models, effort levels, and timestamps through `args`; never call
+   `Date.now()` or `Math.random()` in a script.
+
+## Run 1 — Recon
+
+Declare the named recon phase in `meta.phases`. Within it, make one `agent()`
+call per slice, with explicit `model`, `effort`, and `phase` options. Give every
+call the inline recon schema so the Workflow runtime rejects prose or malformed
+output before aggregation.
+
+Use the run identity supplied in `args` and retain the Workflow-managed
+`journal.jsonl`. The main thread waits for the Recon run to finish and collects
+its schema-valid reports. It must not dispatch a builder yet.
+
+## Main-thread reconcile boundary
+
+Pass the complete Recon-run result to `reconcileReconReports`. A reconciliation
+failure stops the wave. A successful result is the only boundary that permits
+the Build run to start; use its overlap graph and dependency edges to cut safe
+dispatch batches. Multiple editors are safe only when dependency reachability
+totally orders them; shared-mutable files still require exactly one edit owner.
+
+Every orchestration path, including Paths B and C, must cross this same
+main-thread reconciliation boundary. Reconciliation is not Workflow-script
+logic.
+
+## Run 2 — Build
+
+Generate a separate Build run with its own named entry in `meta.phases`. For the
+current reconciled batch, make one `agent()` call per slice with explicit
+`model`, `effort`, and `phase` options and the inline builder schema. Preserve
+the reconciled allowlist and required commands in each verbatim builder prompt;
+the main thread still performs `semanticVerify` on every returned report.
+
+Before each `agent()` call, resolve its provider-neutral Routing intent and pass
+the decision through the shared spawn guard and active surface adapter. The
+Claude adapter must attest Workflow model/effort precedence in the current
+environment; a future Codex host may use this path only when its dated
+`routingAdapters/codex.mjs` attestation proves the same controls. Create the
+Dispatch receipt before invocation; any requested/applied mismatch, unverified
+control, or unauthorized transport blocks AFK rather than silently degrading.
+
+## Resume exactly once
+
+Resume an interrupted Recon or Build run with its recorded `resumeFromRunId`
+and the same deterministic `args`. Workflow returns cached results for completed
+agents: accept those results and dispatch only unfinished calls. Never create a
+replacement run for completed work, and never replay a completed builder. This
+makes each builder phase execute exactly once while the retained
+`journal.jsonl` remains the recovery and progress record.