@ikon85/agent-workflow-kit 0.33.0 → 0.34.1

package/.agents/skills/to-issues/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: to-issues
-description: "Break a plan, spec, or PRD into independently-grabbable issues on the project issue tracker using tracer-bullet vertical slices. Use when user wants to convert a plan into issues, create implementation tickets, or break down work into issues."
+description: "Break a Feature or Program plan, spec, or PRD into independently-grabbable issues on the project issue tracker. This is the single public Planning facade: explicit Feature identity uses tracer-bullet decomposition; explicit Program identity delegates to the internal graph engine."
 ---
 
 # To Issues
@@ -23,6 +23,39 @@ node scripts/readiness.mjs check --skill to-issues --json
 - `managedBoard=not-applicable`: `STOP` and report that `/to-issues` is **inapplicable** for a project that deliberately has no managed board. This is a terminal project decision, not invalid evidence and not a partially active mode.
 <!-- readiness:required-preflight:end -->
 
+## Planning facade — select by explicit identity only
+
+`to-issues` is the **single public Planning facade**. After the readiness
+preflight and before any remote write, classify the source from its explicit PRD
+identity:
+
+- **Feature identity → `planning-mode=feature`.** The body carries
+  `<!-- prd: awaiting-decomposition -->` and its one `type:*` label is not the
+  configured Program type. Run the existing Feature decomposition path below:
+  one slice stays ATOMIC; two or more slices PROMOTE to a wave anchor.
+- **Program identity → `planning-mode=program`.** The body carries
+  `<!-- prd: program -->` and its one `type:*` label is the board profile's
+  `labels.programType` value. Preserve the source and delegate to the internal
+  `to-waves` graph engine. That engine still validates the graph, shows the
+  complete Program preview, waits for the single explicit approval, and performs
+  zero remote writes before approval.
+
+**Missing or contradictory identity is a hard stop before a remote write.**
+Missing means neither marker is present, including a raw issue, file bundle, or
+external PRD without an explicit identity. Contradictory means both markers are
+present, the marker disagrees with the `type:*` label, or the source carries
+multiple type labels. Report the observed markers and type labels, then ask the
+user to establish exactly one identity. A cold-entry source may receive a
+Feature or Program identity only after that explicit choice; rerun this
+classification before any normalization or publication.
+
+**Size, prose, and model judgment never select the mode.** A `## Wellenplan`
+heading, estimated file count, wording such as “large program”, or an agent's
+inference may validate or contradict an already explicit identity, but none may
+create or switch it. A Program identity without the graph grammar is a blocking
+contract error, not a fallback to Feature. A Feature identity with Program-only
+graph grammar is likewise contradictory and stops.
+
 ## Process
 
 ### 1. Gather context
@@ -110,7 +143,8 @@ Ask the user:
 
 Iterate until the user approves the breakdown.
 
-**Program batch handoff.** When `to-waves` invokes this skill for a Stufe-1p stub,
+**Program batch handoff.** When the internal Program graph engine invokes this
+skill for a Stufe-1p stub,
 the complete Program preview has already shown and approved every wave's slice
 contract. Reuse that approval when this pass preserves the approved cut: do not
 pause again merely because the internal pipeline crossed a skill boundary. Run
@@ -122,9 +156,21 @@ newly discovered gate invalidates the inherited approval and returns to §4.
 
 **Cluster/Wave discriminator (identical wording — `to-prd` §2 / `to-issues` §5):** `type:cluster` (label) always stops. A Wave number also stops, **unless** the target carries the `wave-stub` label — a Wave-stamped `wave-stub` issue is a **Stufe-1p Program-stub** (`to-waves`-published, native parent = a Program-PRD) and remains a **valid target**. A Wave-stamped issue **without** `wave-stub` (an already-assigned leaf, or a drifted item) is still a hard stop.
 
-The canonical source is a **Draft-PRD** issue from `to-prd` (carries `plan_revision`, `<!-- prd: awaiting-decomposition -->`, exactly one `type:*` + one `priority:*`, **no** `type:cluster`, and no Wave **unless** the discriminator's `wave-stub` exception applies — a Program-stub's per-wave-start content pass writes this same shape into an already Wave-stamped stub, `to-prd` §2). But `to-issues` is **provenance-independent**: it re-derives readiness from the **artefact** (§3b), never from which tool produced it.
-
-**Cold entry on an already-existing issue.** The source can also be a **raw issue**, an **external PRD embedded in an issue**, or a **mechanical file bundle** — without the `to-prd` markers. Then a **cold-entry preflight applies before anything is mutated:**
+The canonical Feature source is a **Draft-PRD** issue from `to-prd` (carries
+`plan_revision`, `<!-- prd: awaiting-decomposition -->`, exactly one `type:*` +
+one `priority:*`, **no** `type:cluster`, and no Wave **unless** the
+discriminator's `wave-stub` exception applies — a Program-stub's per-wave-start
+content pass writes this same shape into an already Wave-stamped stub, `to-prd`
+§2). The facade is provenance-independent but not identity-optional: it
+re-derives readiness from the **artefact** (§3b), never from which tool produced
+it, only after the explicit identity classification above selected the mode.
+
+**Cold entry on an already-existing issue.** The source can also be a **raw
+issue**, an **external PRD embedded in an issue**, or a **mechanical file
+bundle** — without the `to-prd` markers. That absence first triggers the
+facade's identity hard stop above. Only after the user explicitly establishes
+Feature identity may this **cold-entry preflight apply before anything is
+mutated:**
 - **Hard-stop per the discriminator above** — `type:cluster` always; Wave only when the issue is **not** a `wave-stub` (the exception is already an intended promote target — `promote` reuses its pre-stamped Wave number, §5a below).
 - **Normalize labels** (mirroring `to-prd`'s normalization): exactly **one `type:*` + one `priority:*`**; `needs-info`/`ready-for-agent` **stripped** until the final bucket assignment (§5c).
 - **Synthesize missing `to-prd` markers in place** (never assume them): `plan_revision r1` at the body head, render the Tier-2 anchor body from the template. Surface `source`/`synthesized` in the §7 audit.
@@ -389,7 +435,8 @@ Reference the blocking ticket(s), or "None - can start immediately".
 <!-- mirror-xform:start codex-escalation -->
 ```
 Welle <N> · Slice <X> (<closes #x | refs #<prd#>, Parent #<prd#>>). Read #<prd#> for decisions.
-Start skill: 🧭 Design Grill → /grill-with-docs · 🔬 Verify Spike → /verify-spike · 📐 Trade-off/Research → /decision-gate · AFK → /implement · HITL → /grill-me → /implement. Recommended model: <Model [Effort]>.
+Start skill: 🧭 Design Grill → /grill-with-docs · 🔬 Verify Spike → /verify-spike · 📐 Trade-off/Research → /decision-gate · AFK → /implement · HITL → /grill-me → /implement.
+Routing intent: `routing-intent: <judgment | development | mechanical>` · `reasoning-intent: <deep | balanced | light>`. The dispatching surface resolves the current executable route; never persist that provider route here.
 Worktree: your project's worktree helper, or `git worktree add`
 Scope (<N> files) — REQUIRED FIELD, blast-radius estimate at cut time; the build session checks it against its own recon findings, >2x deviation → STOP:
 - <concrete file + change>
@@ -397,6 +444,12 @@ Live-verify: <user outcome, DB/UI value with comparison>
 PR: <closes #x | Part of #<prd#> — NEVER closes on the anchor>.
 ```
 <!-- mirror-xform:end -->
+
+At execution time, consume that provider-neutral intent only through
+`src/lib/routeDispatcher.mjs` and its shared spawn guard. The active Claude or
+Codex adapter must produce Dispatch receipt v2 with requested/applied route,
+model/effort enforcement, precedence, and catalog/access/policy revisions
+before an AFK subagent starts; the durable issue never claims that proof.
 </issue-template>
 
 **Blast-radius reconciliation (build session):** the stamped `**Blast-Radius:**` is the estimate *at the cut* — the build session compares it against its own recon finding. A real finding **> 2× the estimate → STOP + report** (re-cut at the anchor), do NOT keep building silently.
@@ -430,12 +483,17 @@ It asserts, for the rooted local graph:
 
 If the source was a `wave-stub` stub, briefly confirm the label is gone (the publish mechanic strips it automatically — see §5): `gh issue view <anchor-or-leaf#> --json labels -q '.labels[].name'` shows **no** `wave-stub`. (Not part of `execute-ready-check.py` — its own quick check.)
 
-`--mode audit` is **non-blocking** — a mismatch is a **loud warning** here; the **hard block** is `.claude/hooks/drift-guard.py` at handoff-creation. Emit a visible audit two-liner:
+`--mode audit` is **non-blocking** — a mismatch is a **loud warning** here; the
+**hard block** is `.claude/hooks/drift-guard.py` at handoff-creation. Emit a
+visible audit that names the selected facade mode:
 
 ```
-to-issues: anchor=#<X> mode=<promote|atomic> slices=<n> rev <old>→<new>
+to-issues: planning-mode=feature anchor=#<X> mode=<promote|atomic> slices=<n> rev <old>→<new>
   source=<draft-prd|raw-issue|external-prd|bundle>  synthesized=<marker-list | none>
   AFK=[#a #b] HITL=[#c] · drift=<none | …>  shape=<ok | warn:…>
 ```
 
+The Program graph engine emits `planning-mode=program` in its own counted audit
+after the complete preview gate; the facade relays that audit unchanged.
+
 Do NOT close or modify any parent issue beyond the promote stamp.

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

@@ -1,17 +1,25 @@
 ---
 name: to-waves
 disable-model-invocation: true
-description: "Turn a Program-PRD's wave plan into fully planned, execute-ready wave anchors and slice leaves after one complete chat preview. Validates the graph, publishes every wave, runs the to-prd/spec-self-critique/to-issues maturity contract for each wave, models unresolved work as explicit gates, and audits counted readiness. Idempotent and crash-recoverable. Use on a Program-PRD over several waves. NOT for a single-wave feature (to-issues) or backlog clustering (board-to-waves)."
+description: "Internal Program graph engine behind the public to-issues Planning facade. Turns an explicitly identified Program-PRD into execute-ready wave anchors and slice leaves after one complete chat preview. Kept as a disabled compatibility entrypoint for existing explicit invocations; normal routing always selects to-issues."
 ---
 
-# to-waves — Unfold a Program-PRD's wave plan onto the board
+# to-waves — Internal Program graph engine
+
+This skill is an **Internal Program graph engine**, selected by `to-issues` only
+when the source carries explicit, coherent Program identity. It is not a second
+public Planning route. The disabled `/to-waves` invocation remains only as a
+compatibility entrypoint for existing callers and tests; it applies this same
+contract and should direct future normal use to `/to-issues`.
 
 Takes a **Program-PRD** — the native Sub-Issue anchor over a multi-wave program
 (Programm → Phase → Welle → Slice) — and turns its `## Wellenplan` chapter into
 **fully planned wave anchors + slice leaves** on the board. Pipeline position:
-`scale-check → grill → to-prd (program mode) → to-waves`, with the per-wave
-`to-prd → spec-self-critique → to-issues` maturity pass owned inside this run.
-The **grill and to-prd sit upstream**; to-waves runs once the Program-PRD exists.
+`scale-check → grill → to-prd (program mode) → to-issues`, with this internal
+engine owning the per-wave `to-prd → spec-self-critique → to-issues` maturity
+pass inside this run.
+The **grill and to-prd sit upstream**; the facade dispatches here once the
+Program-PRD exists and its identity is coherent.
 It **never invents structure** — it only unfolds what the plan already decided.
 
 <!-- readiness:required-preflight:start -->
@@ -24,8 +32,8 @@ node scripts/readiness.mjs check --skill to-waves --json
 ```
 
 - `verdict=ready`: continue with the existing workflow without announcing the check. **Ready is silent.**
-- `verdict=blocked`: `STOP` before any mutation. Report every required capability as `<capability>=<state>` so `issueTracker`, `managedBoard`, and `specCompleteness` failures — including distinct `missing`, `pending`, and `invalid` states — stay visible, then give exactly one recovery path: **Run `/setup-workflow`, then rerun `/to-waves`.** Do not fall back to bare tracker or board commands.
-- `managedBoard=not-applicable`: `STOP` and report that `/to-waves` is **inapplicable** for a project that deliberately has no managed board. This is a terminal project decision, not invalid evidence and not a partially active mode.
+- `verdict=blocked`: `STOP` before any mutation. Report every required capability as `<capability>=<state>` so `issueTracker`, `managedBoard`, and `specCompleteness` failures — including distinct `missing`, `pending`, and `invalid` states — stay visible, then give exactly one recovery path: **Run `/setup-workflow`, then rerun `/to-issues`.** Do not fall back to bare tracker or board commands.
+- `managedBoard=not-applicable`: `STOP` and report that Program planning through `/to-issues` is **inapplicable** for a project that deliberately has no managed board. This is a terminal project decision, not invalid evidence and not a partially active mode.
 <!-- readiness:required-preflight:end -->
 
 Board constants (project node, field/status IDs) + helpers live **consumer-side**:
@@ -43,10 +51,14 @@ is the parser.
 
 ## 1. Input — a Program-PRD
 
-The target is a Program-PRD issue: it carries the `<!-- prd: program -->` marker (or
-the program-type label) and a `## Wellenplan` table. Passed in / from context. If the
-issue is a plain feature-PRD or a Welle-Anchor, stop — a feature-PRD is `to-issues`'
-target, an anchor is already a single wave.
+The target is a Program-PRD issue: it carries both the
+`<!-- prd: program -->` marker and the configured Program-type label, plus a
+`## Wellenplan` table. Passed in from the facade or explicit compatibility
+invocation. If either identity half is missing, they disagree, or Feature
+identity is also present, stop before preview or write and return to
+`to-issues`; never infer Program mode from the table, prose, size, or model
+judgment. A plain Feature-PRD remains on the facade's Feature path; a
+Wave-Anchor is already a single wave.
 
 ## 2. Parse + validate — the graph preflight
 
@@ -316,7 +328,7 @@ python3 scripts/board-sync.py program-sync <prd#>
 ## Audit block (visible output)
 
 ```
-to-waves: prd=#<n> preview=<approved|rejected>
+to-issues: planning-mode=program engine=to-waves prd=#<n> preview=<approved|rejected>
   created=<stubs X von Y, leaves X von Y>  adopted=<#a #b … | none>
   stamped=<N von M Wave/Phase>  phase=<stamped | skipped (profile lacks fields.phase)>
   matured=<X von Y>  execute-ready=<X von Y Wellen ausführungsreif>

package/.claude/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/.claude/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/.claude/skills/board-to-waves/SKILL.md

@@ -49,7 +49,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).
 
@@ -77,7 +81,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/.claude/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/.claude/skills/codebase-design/DESIGN-IT-TWICE.md

@@ -18,7 +18,15 @@ 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 -->
 Spawn 3+ sub-agents in parallel using the Agent tool. 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/.claude/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 -->
 Spawn 3+ sub-agents in parallel using the Agent tool. Each must produce a **radically different** interface for the deepened module.
 <!-- mirror-xform:end -->

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

@@ -35,6 +35,12 @@ 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 -->
 Then use the Agent tool with `subagent_type=Explore` to walk the codebase. Don't follow rigid heuristics — explore organically and note where you experience friction:
 <!-- mirror-xform:end -->

package/.claude/skills/kit-release/SKILL.md

@@ -1,13 +1,14 @@
 ---
 name: kit-release
-description: "Prepare a verified release PR for agent-workflow-kit, delegate landing to wrapup, then monitor the trusted post-merge publishing flow through npm/GitHub parity."
+description: "Prepare and integrate a verified agent-workflow-kit release, then record separately confirmed publication intent with an annotated version tag and monitor npm/GitHub parity."
 ---
 
 # Kit Release
 
 Prepare a release deterministically. This skill owns the shipped-delta decision,
-metadata preparation, and verification. It does not implement commit, push, PR,
-merge, registry publishing, tags, or release creation.
+metadata preparation, verification, and the separate post-merge publication
+gate. It delegates commit, branch push, PR, merge, and cleanup to wrapup. It
+never publishes to a registry or creates a GitHub release directly.
 
 ## Workflow
 
@@ -42,7 +43,20 @@ merge, registry publishing, tags, or release creation.
    `scripts/wrapup-land.py` exclusively own commit, push, PR creation, merge,
    and cleanup. Do not reproduce those operations here.
 
-5. After merge, monitor the `release.yml` workflow and inspect its externally
+5. After merge, report the exact integrated version and commit as
+   `awaiting-tag`. Merging integrates the prepared release; it cannot start
+   publication. Ask the user for a second, explicit confirmation to publish
+   that exact `v<version>`. The earlier Semver confirmation authorized metadata
+   preparation, not publication.
+
+6. After that confirmation, verify that the package version on current
+   `origin/main` is exactly `<version>`. Create a matching annotated
+   `v<version>` tag on that commit and push only that tag. A lightweight tag,
+   mismatching version, or commit outside canonical `main` is invalid release
+   intent. Never infer a tag target, move an existing tag, or tag an unmerged
+   commit.
+
+7. Monitor the tag-triggered `release.yml` workflow and inspect its externally
    reconstructable state:
 
    ```sh
@@ -56,6 +70,17 @@ merge, registry publishing, tags, or release creation.
    release asset have identical version, manifest hash, and tarball integrity.
    The release is complete only at `released`.
 
+   Manual dispatch is recovery only. It requires the explicit existing
+   annotated tag and runs the same idempotent reconciler:
+
+   ```sh
+   gh workflow run release.yml -f tag=v<version>
+   ```
+
+   Use it only after reconstructing the release state for that tag. Never use
+   dispatch as the normal publication route or substitute a new version for a
+   partial release.
+
    The registry identity is **`@ikon85/agent-workflow-kit`**. The unscoped
    `agent-workflow-kit` package is owned by another publisher and must never be
    queried, published, or treated as this repository's release.

package/.claude/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/.claude/skills/orchestrate-wave/SKILL.md

@@ -100,7 +100,7 @@ node scripts/readiness.mjs check --skill orchestrate-wave --json
 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).

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

@@ -5,13 +5,14 @@ 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 on the current Codex host.** A verify spike against
-codex-cli 0.144.6 (2026-07-21) proved native start plus bounded wait, and an
-effective concurrency of 4, but the host exposes tool entries carrying only a
-name and a description: no tool schema, no callable or permitted flags, no
-thread capacity. The adapter therefore emits `unknown` for those fields and the
-selector fails closed to Path C. Only a future host that supplies the complete
-normalized inventory selects this path.
+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
 
@@ -55,10 +56,21 @@ Reconciliation is never delegated to a subagent.
 
 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. The host
-exposes no per-agent role, model, or reasoning selector, so routing falls back
-to the parent session configuration — record the tier you intended in the
-prompt itself rather than assuming the host honoured it.
+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

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

@@ -48,6 +48,14 @@ current reconciled batch, make one `agent()` call per slice with explicit
 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`

package/.claude/skills/research/SKILL.md

@@ -3,6 +3,12 @@ name: research
 description: Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo. Use when the user wants a topic researched, docs or API facts gathered, or reading legwork delegated to a background agent.
 ---
 
+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.
+
 Spin up a **background agent** to do the research, so you keep working while it reads.
 
 Its job:

package/.claude/skills/scale-check/SKILL.md

@@ -87,8 +87,9 @@ skills — this skill only picks the entry point.
 
 ### Program (≥2 criteria)
 
-A multi-wave undertaking: grill it once into a Program-PRD with a wave plan, then
-unfold that plan onto the board after a chat preview gate.
+A multi-wave undertaking: grill it once into a Program-PRD with a wave plan,
+then hand that explicit Program identity to the public Planning facade. The
+facade unfolds the plan onto the board after a chat preview gate.
 
 ```
 New program: <one-sentence outcome from Q2>.
@@ -97,10 +98,11 @@ Tripped altitude criteria: <e.g. C1 staged delivery, C2 multiple subsystems, C4
    structure-bearing decisions (escalate a single bounded choice to `decision-gate`).
 2. `to-prd` — it auto-detects the program mode from the Wellenplan chapter and writes
    a Program-PRD (native anchor over the waves).
-3. `to-waves` — after one complete chat preview, materialize the whole Program with
-   **all waves execute-ready by default**: complete slice contracts, buckets,
-   dependencies and handoffs. Decision Gates, Verify Spikes and Design-Grill waves
-   are explicit planned exceptions; generic late-binding cleanup is not.
+3. `to-issues` — its explicit Program identity selects the internal graph path.
+   After one complete chat preview, materialize the whole Program with **all
+   waves execute-ready by default**: complete slice contracts, buckets,
+   dependencies and handoffs. Decision Gates, Verify Spikes and Design-Grill
+   waves are explicit planned exceptions; generic late-binding cleanup is not.
 ```
 
 ### Feature (0–1 criteria, or any doubt)
@@ -134,7 +136,7 @@ Bug: <what's broken — expected vs. actual>.
 ```
 scale-check: verdict=<Program | Feature | Direct-Slice | Bug>
   criteria tripped=<C1,C2,… | none | n/a (bug/direct)>
-  route=<program grill → to-prd → to-waves (all waves execute-ready by default) | grill-with-docs → to-prd → to-issues | implement | diagnose>
+  route=<program grill → to-prd → to-issues (Program mode; all waves execute-ready by default) | grill-with-docs → to-prd → to-issues (Feature mode) | implement | diagnose>
   start-prompt: <the paste-ready block above, filled in>
 ```
 

package/.claude/skills/setup-workflow/SKILL.md

@@ -28,6 +28,7 @@ This is a prompt-driven skill, not a deterministic script. Explore, present what
 | `docs/agents/census.md` | optional-census choice, paths, state, and safe disable contract seeded from [census.md](./census.md) (Section A3) |
 | `docs/agents/workflow-capabilities.json` + capability assets | consumer-owned Worktree Lifecycle, Memory Lifecycle, Workflow Advisories, and Safety Guardrails choices (Sections A4–A7) |
 | `.claude/settings.json` | additive activation of the advisory kit-origin Edit/Write hint (Section A8) |
+| user-local routing profile | familiar agent surfaces + switching autonomy (Section A9; never package- or repository-owned) |
 
 ## Idempotency contract — read before writing anything
 
@@ -60,6 +61,9 @@ Read the current state; don't assume. For every target file, read its first line
 - `docs/agents/census.md`, `.census/profile.json`, `.census/active.json` — an existing census choice or consumer-owned census to adopt.
 - `docs/agents/workflow-capabilities.json`, `.claude/settings.json`, `git config --get core.hooksPath` — existing capability choices/profile plus Worktree Lifecycle, Workflow Advisories, Safety Guardrails, and kit-origin hint wiring to adopt.
 - `.memory/active/`, `.memory/archive/`, and `.memory/receipts/` — consumer-owned Memory Lifecycle policies or recovery evidence to adopt without normalization.
+- The Kit routing-profile preflight — adopt a valid user-local choice without
+  printing or copying it into the repository. Never infer personal routing
+  policy from instruction files, credentials, or package-owned metadata.
 - `gh auth status` (if GitHub) — is `gh` authenticated, and with which scopes?
 
 ### 2. Section A — Issue tracker
@@ -280,6 +284,41 @@ This is an additive, idempotent settings edit, not a settings rewrite:
    `PreToolUse`, are consumer-owned conflicts: leave the file untouched and
    report the skipped activation. Never replace or normalize them.
 
+### 2h. Section A9 — Agent surfaces and switching autonomy
+
+> Routing setup asks which familiar agent apps you use and whether the Kit may
+> switch between them. Surface adapters establish providers, transports,
+> selectors, and enforcement capabilities; the default interview never asks
+> the user to describe those technical facts.
+
+Read the versioned agent-surface registry and detection result. Show its
+multi-select labels with detected entries preselected; never embed a separate
+list in prompt prose. Then ask only one plain-language autonomy question:
+
+- **Switch automatically** — record `automatic`.
+- **Ask before switching** — record `ask`.
+- **Stay in the current app** — record `current-surface-only`.
+
+When exactly one surface is selected, skip the autonomy question and use
+`current-surface-only`. Show an activation summary with explicit **Back**,
+**Advanced**, **Approve**, and **Safe current surface** actions. Back revisits
+the simple choices. Advanced is the only flow that may collect model
+preferences or optimization overrides, but those values remain a draft and
+return to the activation summary; Advanced alone never writes. Only a later
+Approve or Safe current surface action activates the draft. Safe current
+surface activates the selection with `current-surface-only`.
+
+Store the answer through `src/lib/routingProfile.mjs` in its user-local state
+location, outside the consumer repository and package manifest. Never print
+credentials or derive personal choices from detected transports. A valid
+existing profile is terminal and reports `still valid`; do not prompt again.
+Missing or invalid profiles receive one migration interview. Reconcile a
+materially stale profile, a removed route, or a newly detected meaningful
+surface with a typed delta that names only the changed choice and preserves
+unaffected surfaces, autonomy, and advanced values. Re-read the profile before
+activation and use its fingerprint plus the exclusive profile lock; a
+concurrent user-local change blocks activation and remains byte-preserved.
+
 ### 3. Section B — Triage labels
 
 > When `triage` processes an incoming issue it applies labels (or your tracker's equivalent). It needs strings you've actually configured, or it creates duplicates.
@@ -309,7 +348,14 @@ Seed `docs/agents/domain.md` from [domain.md](./domain.md).
 
 **Fallback (the single catch-all — no board / >1 / ambiguous / scope error / read failure):** do **not** auto-create a board (`gh project create` alone cannot provision the Status options + workflow fields a board needs). Write `board-sync.md` with `state=stub`, `mode=github-projects-v2`, and inline **instructions**: which fields the workflow profile needs (a Status single-select with your stage options; optionally a Wave number, a Cluster text, a Spec-Path / Plan-Path text), how to create the board in the GitHub UI / `gh`, and "then run `/setup-workflow` again — it will discover and fill the IDs." Retryable.
 
-**Optional — Phase field + saved Views (Program route only):** never auto-discovered or auto-created, unlike the fields above — a Phase field's option set is plan-specific. If this project plans to use the Program route (`scale-check` → `to-waves` → `validate-graph`), point the user at the seeded [board-sync.md](./board-sync.md)'s "Optional: the Program route" section for the `gh project field-create` command, the optional `fields.phase` / `labels.programType` profile keys, and the two saved Views to create by hand.
+**Optional — Phase field + saved Views (Program route only):** never
+auto-discovered or auto-created, unlike the fields above — a Phase field's
+option set is plan-specific. If this project plans to use the Program route
+(`scale-check` → `to-issues` with explicit Program identity → internal graph
+validation), point the user at the seeded [board-sync.md](./board-sync.md)'s
+"Optional: the Program route" section for the `gh project field-create`
+command, the optional `fields.phase` / `labels.programType` profile keys, and
+the two saved Views to create by hand.
 
 ### 6. Section E — Spec-layer seeds (non-interactive)