@ionivetech/mugiwara 0.6.5 → 0.6.6

package/content/skills/mugiwara-execution/SKILL.md

@@ -8,7 +8,7 @@ description: Use when executing an approved plan — todo list first, sequential
 ## Skip when
 
 - No approved plan exists to execute — this is triage, brainstorm, or planning territory.
-- Lane 0 direct work (typo, rename, single small fix) with no wave structure.
+- Lane 0 direct work (typo, rename, single small fix) with no flow-stage structure.
 
 Execute the plan exactly. No silent reordering, no skipping steps, no "close enough".
 
@@ -28,9 +28,9 @@ Before touching code:
 1. Create `.mugiwara/results/<mission>/todos.md` — one checkbox per task, derived from the plan.
 2. Check each box off only when the task completes, WITH its evidence link (`[path](relative/path)`, clickable).
 3. Re-check the whole list after each task and after each batch; unmarked boxes mean the mission is not done.
-4. Mirror EVERY transition into the host's native todo tool (`todowrite` on opencode; `TaskUpdate` on Claude Code; none on tier 2/3 — plan doc only) in the SAME response the task's evidence lands — one transition per call, never batched at wave end. Per-host table: `docs/reference/harness-matrix.md`.
+4. Mirror EVERY transition into the host's native todo tool (`todowrite` on opencode; `TaskUpdate` on Claude Code; none on tier 2/3 — plan doc only) in the SAME response the task's evidence lands — one transition per call, never batched at flow-stage end. Per-host table: `docs/reference/harness-matrix.md`. Every task response opens with `[task N/M] <status>` — progress is visible on every harness, todo tool or not.
 
-## Wave execution
+## Flow-stage execution
 
 Before starting: if `.mugiwara/continue/<mission>/[member].json` exists, resume from its next_action — never re-run completed tasks; verify against todos `[x]` marks. Full protocol: `references/resume-batching.md` — batch-resume, TDD, user-test oracle.
 
@@ -44,14 +44,15 @@ Before starting: if `.mugiwara/continue/<mission>/[member].json` exists, resume
 ## Worker dispatch triggers
 
 1. **Independence** — `[PARALLEL]` batches, concurrent, one task per worker.
-2. **Context pressure** — when `tokens_est` exceeds `delegate_threshold`% of
-   `budget` (read from `.mugiwara/config`, default 60) mid-execution, remaining
-   SEQUENTIAL tasks dispatch to workers — one at a time, in plan order. Order is
-   preserved; only the context resets. Announce: `⚠ context 62% — remaining tasks run in fresh workers, plan order unchanged.`
+2. **Context pressure** — when `delegate_due` reads `true` in
+   `.mugiwara/state/<mission>/[member].json` (savepoint computes it as
+   `tokens_est ≥ delegate_threshold% of budget`, config default 60), remaining
+   SEQUENTIAL tasks dispatch to workers — one at a time, in plan order.
+   Announce: `⚠ context — remaining tasks run in fresh workers, plan order unchanged.`
 
-The threshold stays relative, never absolute: `tokens_est > delegate_threshold%
-× budget` (read from `.mugiwara/config`, default 60), never `tokens_est >
-80,000` (obsolete in six months). A bigger window raises the threshold; it does not remove it.
+Computed, never manual: savepoint emits `delegate_due` (relative
+`tokens_est ≥ delegate_threshold% × budget`, default 60), never an absolute
+`tokens_est > 80,000` (obsolete in six months). A bigger budget raises the bar; it does not remove it.
 
 ## Tier gating & fallback
 
@@ -59,9 +60,9 @@ Real worker dispatch exists only where the harness has subagents — tier 1
 (Claude Code, opencode) plus Copilot. Gate the context-pressure trigger on
 that capability: if the harness cannot dispatch, do not promise fresh workers.
 
-Where workers are unavailable and context pressure crosses the threshold:
+Where workers are unavailable and `delegate_due` is true:
 write a savepoint, run the checkpoint, and suggest a fresh session via
-`resume`. Announce: `⚠ context 62% — no worker dispatch on this harness;
+`resume`. Announce: `⚠ context — no worker dispatch on this harness;
 savepoint written, resume in a fresh session (plan order unchanged).`
 
 ## Batch resume
@@ -76,14 +77,13 @@ six-field worker prompt. Thin prompts cause thin results.
 ## Surfacing rule
 
 > **Delegated work is not hidden work.** A worker may run out of view; its
-> result may not. Every worker returns a wave banner, a one-line verdict, and an
+> result may not. Every worker returns a flow stage banner, a one-line verdict, and an
 > evidence link into the main thread. The user never clicks into a subagent to
 > know what happened.
 > Isolation is for context and permission, never for autonomy.
 
 ## TDD discipline & user tests
-
-Full protocol: `references/resume-batching.md` — batch-resume, TDD RED-GREEN-REFACTOR (`references/tdd.md`), user tests as oracle, failing-first rule.
+Full protocol: `references/resume-batching.md` — batch-resume, TDD RED-GREEN-REFACTOR (`references/tdd.md`), user tests as oracle, failing-first rule. One task end to end, RED through commit: `references/worked-example.md`.
 
 ## One logical task, one commit
 
@@ -91,7 +91,7 @@ Commit per LOGICAL task — a feature, fix, or refactor, not a micro-step; verif
 
 ## Blockers → issues ledger
 
-Blocked → one row `| wave | task | symptom | attempted | help-needed |` to `.mugiwara/issues/YYYY-MM-DD-<mission>-blockers.md`, then escalate to Luffy. Never work around a blocker silently.
+Blocked → one row `| flow stage | task | symptom | attempted | help-needed |` to `.mugiwara/issues/YYYY-MM-DD-<mission>-blockers.md`, then escalate to Luffy. Never work around a blocker silently.
 
 ## Frontend tasks
 
@@ -99,11 +99,11 @@ Any task touching UI markup, styling, or components applies `mugiwara-frontend`
 
 ## Report
 
-After each wave: compact task table (status, evidence link, deviations) shown inline in the conversation. Format: `references/dispatch.md` — report table. Then return to Luffy, who routes to Chopper (Wave 4). Write detailed execution log to `.mugiwara/results/<mission>/01-execution.md`. Never dispatch another crew member.
+After each flow stage: compact task table (status, evidence link, deviations) shown inline in the conversation. Format: `references/dispatch.md` — report table. Then return to Luffy, who routes to Chopper (Flow 4). Write detailed execution log to `.mugiwara/results/<mission>/01-execution.md`. Never dispatch another crew member.
 
 ## Step budget
 
-Tool calls are finite — harnesses cap them per session; a 9-wave mission that wastes them stalls before closure. Combine evidence runs (`evidence.sh <m> quality -- bash -c "lint && test"` — one call, not two); write wave artifacts once at wave end, not incrementally; never re-read what you just wrote; batch reads (one glob beats five reads); open a reference only when its pointer condition triggers.
+Tool calls are finite — harnesses cap them per session; a 9-flow-stage mission that wastes them stalls before closure. Combine evidence runs (`evidence.sh <m> quality -- bash -c "lint && test"` — one call, not two); write flow stage artifacts once at flow-stage end, not incrementally; never re-read what you just wrote; batch reads (one glob beats five reads); open a reference only when its pointer condition triggers.
 
 Budget guide: Lane 1 ≤15 calls · Lane 2 ≤35 · Lane 3 ≤60. Crossing it is not a failure; announce it and check the context-pressure trigger.
 
@@ -117,8 +117,8 @@ Budget guide: Lane 1 ≤15 calls · Lane 2 ≤35 · Lane 3 ≤60. Crossing it is
 - Echoing raw output when `verbosity=normal` — summarize and cite the evidence path.
 - The task's TDD order inverted (implementation before the failing test).
 - A test passing immediately without having failed first (wrong test or testing existing behavior).
-- A commit containing files beyond its declared task, or a wave of micro-commits with no logical grouping.
+- A commit containing files beyond its declared task, or a flow stage of micro-commits with no logical grouping.
 - Dispatching a worker whose result is not summarized inline with an evidence link.
-- Host todo UI lags the plan doc — task done but unchecked, or list never seeded at Wave 2.
+- Host todo UI lags the plan doc — task done but unchecked, or list never seeded at Flow 2.
 
 All mean: stop, realign to the plan, or escalate to Luffy.

package/content/skills/mugiwara-execution/references/dispatch.md

@@ -1,7 +1,7 @@
 # Dispatch & batching detail
 
 Full detail behind `content/skills/mugiwara-execution/SKILL.md` — the output
-rule, the worker prompt format, and the per-wave report table.
+rule, the worker prompt format, and the per-flow stage report table.
 
 ## Task batching
 
@@ -32,7 +32,7 @@ A delegation prompt shorter than ~30 lines is too short — beef it up. Thin pro
 
 ## Report table
 
-After each wave: compact task table (status, evidence pointer, deviations) shown inline in the conversation. Format:
+After each flow stage: compact task table (status, evidence pointer, deviations) shown inline in the conversation. Format:
 
 ```
 | # | Task | Status | Evidence link |

package/content/skills/mugiwara-execution/references/resume-batching.md

@@ -23,7 +23,7 @@ that passes on first run has proven nothing.
 
 ## Batch-resume protocol
 
-- Before starting a wave: if `.mugiwara/continue/<mission>/[member].json` exists, resume from its
+- Before starting a flow stage: if `.mugiwara/continue/<mission>/[member].json` exists, resume from its
   next_action — never re-run completed tasks; verify against todos `[x]` marks.
 - After each batch: update `.mugiwara/continue/<mission>/[member].json` next_action to the next task.
 - `[PARALLEL]` batches stay per sub-mission — a batch never crosses a

package/content/skills/mugiwara-frontend/SKILL.md

@@ -28,8 +28,7 @@ Match the repo's standard before writing anything new; reuse its components and
 Capture current layout, spacing/type scales, palette, and component inventory before changing existing UI. Fix real problems; do not restyle what works.
 
 ## Design-system extraction (before markup)
-
-Extract tokens from the stack's design system BEFORE markup — spacing scale, type scale, role-based palette, radii, shadows, motion language. Name them semantically (`surface-muted`, not `c3`); store where the stack keeps tokens. No tokens extracted, no markup written. Then turn tokens into a small primitive set (button, input, card, icon, layout helpers) before composing screens — reuse primitives everywhere; every bespoke component is debt on every screen.
+Extract tokens from the stack's design system BEFORE markup — spacing scale, type scale, role-based palette, radii, shadows, motion language. Name them semantically (`surface-muted`, not `c3`); store where the stack keeps tokens. No tokens extracted, no markup written; token set and naming: `references/design-tokens.md`. Then turn tokens into a small primitive set (button, input, card, icon, layout helpers) before composing screens — reuse primitives everywhere; every bespoke component is debt on every screen.
 
 ## Component architecture
 
@@ -66,14 +65,13 @@ Extract tokens first, then reproduce structure faithfully: hierarchy, alignment,
 Mobile-first: start at the smallest screen, add breakpoints as layout needs them. Default full-width stacked; columns only when there is room. Use the stack's breakpoints, not a parallel scale; fluid containers, type, and spacing. Verify at every breakpoint, including between them — 3 widths checked is not 12 checked.
 
 ## Banned AI-default patterns (the slop list)
-
 - Centered hero trio: headline + subtitle + two buttons, dead center, gradient text.
 - Row of 3-4 identical feature cards with icon-circle + title + two lines.
 - Purple/indigo gradient everything; glassmorphism everywhere; emoji as icons.
 - Placeholder content where real product copy exists.
 - Stock hero illustrations when the design specifies otherwise.
 
-If the brief genuinely calls for one of these, execute it well — but the default is: don't.
+Full catalog with the tell for each: `references/slop-catalog.md`. If the brief genuinely calls for one of these, execute it well — but the default is: don't.
 
 ## WCAG 2.1 AA accessibility
 

package/content/skills/mugiwara-gates/SKILL.md

@@ -16,14 +16,15 @@ Gates are binary: pass or fail, with evidence. No negotiation, no "almost passes
 
 1. Measure coverage with the project's existing tooling.
 2. Read thresholds from `.mugiwara/config` then `~/.mugiwara/config` for `coverage_new` and `coverage_modified`. Defaults: new ≥ 90%, modified ≥ 80%. Missing key or 0 = no threshold. Identify new/modified via git diff.
-3. No coverage tooling → report the gap, propose minimal tooling, ask user to add or waive.
-4. User-AC declared (per `mugiwara-testcases`): config thresholds apply to unit-level code only; user-AC verdict governs ship-readiness.
+3. No coverage tooling or no test suite → record a SKIP with its reason. Never a fake pass; propose minimal tooling, ask user to add or waive.
+4. In this repo the gate is executable: `bun run coverage-gate` (`scripts/coverage-gate.ts`) does all three against the mission's `base_sha`, and runs as the last step of `bun run gate`. Never lower a threshold or exclude a file to make it green — add the missing tests.
+5. User-AC declared (per `mugiwara-testcases`): config thresholds apply to unit-level code only; user-AC verdict governs ship-readiness.
 
 ## Sonar-style quality gate
 
-Franky reads evidence from prior wave reports (never re-runs
-checks): Jinbe (`.mugiwara/review/<mission>-security.md`),
-Robin (`.mugiwara/review/<mission>-review.md`), Sanji
+Franky reads evidence from prior flow-stage reports (never re-runs
+checks): Jinbe (`.mugiwara/review/YYYY-MM-DD-<mission>-security.md`),
+Robin (`.mugiwara/review/YYYY-MM-DD-<mission>-review.md`), Sanji
 (`.mugiwara/results/<mission>/03-quality.md`).
 Evaluated: Vulnerabilities=0, Bugs=0, Code smells≤project
 threshold, Coverage(new code)≥config threshold,
@@ -37,7 +38,7 @@ Run the project's build (or typecheck for interpreted stacks). Must exit 0. Capt
 
 ## Optional e2e gate (per `mugiwara-quality`)
 
-Runs only when quality wave triggered it (repo e2e setup + changed-file e2e patterns, user consent). Skipped/unrun is logged, never blocks PASS. Final verdict: coverage + sonar + build + DoD.
+Runs only when quality flow stage triggered it (repo e2e setup + changed-file e2e patterns, user consent). Skipped/unrun is logged, never blocks PASS. Final verdict: coverage + sonar + build + DoD.
 
 ## Definition of Done standing gate
 
@@ -51,7 +52,7 @@ A fixed cross-project bar. Full definitions: `_shared/references/definition-of-d
 ## Verdict
 
 PASS only when coverage AND sonar AND build AND DoD all pass with evidence. Write verdict to `.mugiwara/results/<mission>/04-gates.md`.
-PASS → return to Luffy (routes to Robin/Jinbe). FAIL → list files under threshold + by how much → return to Luffy (routes to Brook). Never dispatch next wave yourself.
+PASS → return to Luffy (routes to Robin/Jinbe). FAIL → list files under threshold + by how much → return to Luffy (routes to Brook). Never dispatch the next flow stage yourself.
 
 ## Red flags
 

package/content/skills/mugiwara-git/SKILL.md

@@ -7,7 +7,7 @@ description: Use for commits, splitting, or git history debugging — atomic com
 
 ## Skip when
 
-- No commits to make this wave — nothing staged, nothing to split or amend.
+- No commits to make this flow stage — nothing staged, nothing to split or amend.
 - User handles version control manually for this mission.
 
 Git hygiene keeps the mission reversible: one logical change per commit, a save-point before risky work, and history you can bisect.
@@ -29,7 +29,7 @@ Git hygiene keeps the mission reversible: one logical change per commit, a save-
 
 1. A large task becomes multiple commits, one per logical step in the plan.
 2. Split boundaries follow the plan's tasks: no commit spans two plan tasks, no plan task is left partially committed.
-3. Commit each step the moment it is green; never batch a whole wave into one commit.
+3. Commit each step the moment it is green; never batch a whole flow stage into one commit.
 
 ## Commit message conventions
 
@@ -37,12 +37,17 @@ Git hygiene keeps the mission reversible: one logical change per commit, a save-
 2. Scoped subject when scope is not obvious: `feat(auth): enforce session TTL`.
 3. Body (after a blank line) explains WHY, not what. What is visible in the diff; why is not.
 4. Match the repo's existing style — detect it before writing messages (below).
+5. Config `commit` may be a template: any value containing `{` is a template with
+   placeholders `{type}` `{issue}` `{title}` (e.g. `{issue}: {title}` → `CR-5432: Testing
+   button`). Fill placeholders from mission metadata; `{issue}` falls back to the date.
+   Style names (conventional/gitmoji/plain) keep their normal rules.
 
 ## Style detection
 
 1. Inspect existing history before the first commit: `git log --oneline -20`.
 2. Copy the observed conventions: prefix style (`feat:`/`fix:` vs plain), subject case, body usage, subject length.
 3. No commits in the repo yet → adopt conventional commits and note it in the plan.
+4. A config `commit` template overrides history detection — the user's format wins.
 
 ## Branch naming
 

package/content/skills/mugiwara-healing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: mugiwara-healing
-description: Use when an execution wave failed, earlier waves produced failures, broken things to fix — reads blocker ledger, stop-the-line triage, root-cause fixes, prove-it before fixing. Max 3 cycles.
+description: Use when an execution flow stage failed, earlier flow stages produced failures, broken things to fix — reads blocker ledger, stop-the-line triage, root-cause fixes, prove-it before fixing. Max 3 cycles.
 ---
 
 # Healing (Brook)
@@ -39,6 +39,8 @@ Before fixing a bug: write the failing test that reproduces it, watch it fail, t
 
 ## Triage matrix
 
+Full taxonomy behind the matrix: `references/failure-taxonomy.md`.
+
 | Failure | Action |
 |---------|--------|
 | lint/format error | auto-fix (formatter when supported), re-run |
@@ -53,15 +55,15 @@ Before fixing a bug: write the failing test that reproduces it, watch it fail, t
 2. Every code fix ships with the failed check now passing (run it, capture output).
 3. Never delete or weaken tests/configs to make a failure disappear.
 4. After healing: update the ledger — mark each healed row with evidence; keep unfixed rows for escalation.
-5. Cycle counter: read `heal_cycle` from `.mugiwara/state/<mission>/[member].json` (savepoint writes it). After this wave the flow returns to Wave 4 (Chopper) for re-audit. **At 3, STOP and escalate to the user with full history — a halt, not a red flag.** Red flags are prose; the counter is state. Never re-run past 3.
+5. Cycle counter: read `heal_halt` from `.mugiwara/state/<mission>/[member].json` (savepoint writes it as `heal_cycle ≥ heal_max_cycles`, config default 3). After this flow stage the flow returns to Flow 4 (Chopper) for re-audit. **When `heal_halt` reads `true`, STOP and escalate to the user with full history — a halt, not a red flag.** Red flags are prose; the counter is state. Never re-run past `heal_max_cycles`.
 
 ## Worker subagents
 
-Brook runs inline for triage + ledger reading; parallel fixes use disposable WORKER subagents. Full protocol: `references/workers.md` — heal-worker grouping (independent rows in parallel), 5-field worker prompt, validation workers (reviewer/security/re-run), then back to Wave 4. Workers are NOT crew members.
+Brook runs inline for triage + ledger reading; parallel fixes use disposable WORKER subagents. Full protocol: `references/workers.md` — heal-worker grouping (independent rows in parallel), 5-field worker prompt, validation workers (reviewer/security/re-run), then back to Flow 4. Workers are NOT crew members.
 
 ## Output
 
-Fixed list (finding → commit → evidence), escalated list (finding → plan → owner), updated ledger → back to Wave 4 (Chopper).
+Fixed list (finding → commit → evidence), escalated list (finding → plan → owner), updated ledger → back to Flow 4 (Chopper).
 
 ## Red flags
 

package/content/skills/mugiwara-healing/references/workers.md

@@ -20,7 +20,7 @@ Group 2 [SEQUENTIAL]: Row 3 (rbac.ts)
 ```
 
 Each heal worker receives a prompt with 5 fields:
-- **FAILURE** — ledger row verbatim (wave, task, symptom, attempted)
+- **FAILURE** — ledger row verbatim (flow stage, task, symptom, attempted)
 - **ROOT CAUSE** — Brook's triage result: where the bug is, why it happened
 - **FIX** — what to change, which file, which function
 - **MUST DO** — Prove-It: write regression test, watch it fail, implement fix, watch it pass, commit
@@ -33,6 +33,6 @@ After all heal workers complete, dispatch validation workers in parallel:
 - **security-worker** — security pass over fixes (per `mugiwara-security`)
 - **re-run-check worker** — independently re-runs failed checks, returns raw evidence
 
-Flow: Brook triage + grouping → dispatch heal workers parallel → aggregate results → dispatch validation workers → update ledger → back to Wave 4.
+Flow: Brook triage + grouping → dispatch heal workers parallel → aggregate results → dispatch validation workers → update ledger → back to Flow 4.
 
 Workers are NOT crew members — disposable subagents, one narrow job per worker. Crew runs inline in main thread.

package/content/skills/mugiwara-orchestration/SKILL.md

@@ -6,15 +6,15 @@ description: Gatekeeper + captain for any task: triage, classify, coordinate, ro
 
 ## Skip when
 
-- Mid-wave continuation with route already recorded in `.mugiwara/logs/`. Captain duties: triage, check-ins, decisions, closure — Luffy coordinates, never implements; returns decisions, no dispatch.
+- Mid-flow continuation with route already recorded in `.mugiwara/logs/`. Captain duties: triage, check-ins, decisions, closure — Luffy coordinates, never implements; returns decisions, no dispatch.
 
-## Delegation pillars (Wave 0)
+## Delegation pillars (Flow 0)
 
 Size the mission against five pillars; highest gate determines route. Table: `references/delegation-pillars.md`. Quick: 1 file <20 LOC → Zoro, vague → Usopp, spec → Nami, auth/payment → full pipeline.
 
 ## Return-to-Luffy protocol
 
-Every wave returns to Luffy — no crew member hands off directly to another. Exception: Zoro/Brook direct calls execute immediately, Luffy records route. Non-execution crew members return results:
+Every flow stage returns to Luffy — no crew member hands off directly to another. Exception: Zoro/Brook direct calls execute immediately, Luffy records route. Non-execution crew members return results:
 
 - Usopp → return brainstorm → Luffy routes to Nami or Zoro
 - Nami → return plan → guided/semi: Luffy asks the user for GO; auto: Luffy delegates to Zoro
@@ -24,6 +24,8 @@ Every wave returns to Luffy — no crew member hands off directly to another. Ex
 
 ## Coordination files
 
+Team repos — per-(mission, member) isolation, no collisions: `_shared/references/multi-actor.md`.
+
 The plan doc (`.mugiwara/plans/YYYY-MM-DD-<mission>.md`) is Nami's clean execution plan — NEVER write coordination into it. Your decisions, route reasons, and check-in verdicts go to `.mugiwara/logs/YYYY-MM-DD-<mission>.md` (append-only, deletable at cleanup). The closure report goes to `.mugiwara/results/<mission>/06-closure.md`.
 
 ## Actor attribution (every .mugiwara write)
@@ -31,32 +33,32 @@ The plan doc (`.mugiwara/plans/YYYY-MM-DD-<mission>.md`) is Nami's clean executi
 Every decision-log row, blocker row, and check-in verdict records its actor:
 - User request → `user: <name> <<git email>>` (read from `git config user.name` / `user.email`).
 - AI decision → `AI: <model>` (e.g. `AI: deepseek-v4-flash`).
-In `auto` mode the AI decides everything; any requirement that stays unclear after triage is brainstormed with Usopp (Wave 1) BEFORE the AI decides — the AI never guesses on unclear scope. Record the brainstorm in the decision log with actor `AI:`.
+In `auto` mode the AI decides everything; any requirement that stays unclear after triage is brainstormed with Usopp (Flow 1) BEFORE the AI decides — the AI never guesses on unclear scope. Record the brainstorm in the decision log with actor `AI:`.
 
-## Mode read (Wave 0)
+## Mode read (Flow 0)
 
-Read the runtime mode via mode config at Wave 0: `.mugiwara/config` (project) then `~/.mugiwara/config` (global); a key missing from both = `guided`. Record the active mode AND `auto_commit` (default on) in the decision log. Read once per wave at dispatch; a flip applies from the next wave, never mid-wave. Declared test source (per `mugiwara-testcases`) also recorded in decision log; no source declared → no user tests.
+Read the runtime mode via mode config at Flow 0: `.mugiwara/config` (project) then `~/.mugiwara/config` (global); a key missing from both = `guided`. Record the active mode AND `auto_commit` (default on) in the decision log. Read once per flow stage at dispatch; a flip applies from the next flow stage, never mid-flow-stage. Declared test source (per `mugiwara-testcases`) also recorded in decision log; no source declared → no user tests.
 
-## Request classifier (Wave 0) — 8 classes
+## Request classifier (Flow 0) — 8 classes
 
-Classify every incoming request. 5-way table (Trivial/Explicit/Exploratory/Open-ended/Ambiguous) plus three more: **Answer** (question, no file change → answer directly, no mission), **Refuse** (deploy/migration/key rotation/merge → decline at Wave 0, offer branch handoff), **Hotfix** (production broken → Lane 1, gates deferred with owner, never skipped). Full table + signals: `references/triage-escalation.md`. Record decision + one-line reason at the top of the decision log. Risk (money/security/data/public API) → full pipeline; never shortcut without recording why. Any route without a recorded reason is a red flag.
+Classify every incoming request. 5-way table (Trivial/Explicit/Exploratory/Open-ended/Ambiguous) plus three more: **Answer** (question, no file change → answer directly, no mission), **Refuse** (deploy/migration/key rotation/merge → decline at Flow 0, offer branch handoff), **Hotfix** (production broken → Lane 1, gates deferred with owner, never skipped). Full table + signals: `references/triage-escalation.md`. Record decision + one-line reason at the top of the decision log. Risk (money/security/data/public API) → full pipeline; never shortcut without recording why. Any route without a recorded reason is a red flag.
 
-## Lane routing + precedence (Wave 0, size before process)
+## Lane routing + precedence (Flow 0, size before process)
 
-Alongside the class, size the mission and pick a lane (0 Direct / 1 Lean / 2 Standard / 3 Full / 4 Spike). **Precedence: class decides whether there is work; lane decides how much process — class first, lane second, record both.** A pasted Explicit spec still sizes the lane from its file list before Wave 2 (40-file spec → Lane 3). Escalation only: a lane may rise mid-mission, never drop. Full table: `references/triage-escalation.md`. Small tasks: read-only investigation → host `explore` agent or inline read — NOT a Luffy subagent (~5k vs ~40k tokens); explicit implement → Lane 1 Zoro inline. Review only when risky — full pipeline.
+Alongside the class, size the mission and pick a lane (0 Direct / 1 Lean / 2 Standard / 3 Full / 4 Spike). **Precedence: class decides whether there is work; lane decides how much process — class first, lane second, record both.** A pasted Explicit spec still sizes the lane from its file list before Flow 2 (40-file spec → Lane 3). Escalation only: a lane may rise mid-mission, never drop. Full table: `references/triage-escalation.md`. Small tasks: read-only investigation → host `explore` agent or inline read — NOT a Luffy subagent (~5k inline vs ~132k measured per dispatch); explicit implement → Lane 1 Zoro inline. Review only when risky — full pipeline.
 
-## Spec bridge (Wave 0 → Wave 2)
+## Spec bridge (Flow 0 → Flow 2)
 
-Wave 1 (Usopp) writes the brainstorm output to `.mugiwara/spec/YYYY-MM-DD-<mission>.md` — the bridge Nami reads. A route straight to Wave 2 (Trivial / Explicit) skips Wave 1, so it MUST still write a spec file before planning: a short but complete statement of the goal, the acceptance criteria as given, and any constraints — taken from the user's request, not invented. Never start Wave 2 with `.mugiwara/spec/` empty: if no spec exists, write one from the request first (the `/mugiwara-plan` command reads this file). The spec is input to Nami, never the plan itself.
+Flow 1 (Usopp) writes the brainstorm output to `.mugiwara/spec/YYYY-MM-DD-<mission>.md` — the bridge Nami reads. A route straight to Flow 2 (Trivial / Explicit) skips Flow 1, so it MUST still write a spec file before planning: a short but complete statement of the goal, the acceptance criteria as given, and any constraints — taken from the user's request, not invented. Never start Flow 2 with `.mugiwara/spec/` empty: if no spec exists, write one from the request first (the `/mugiwara-plan` command reads this file). The spec is input to Nami, never the plan itself.
 
 ## Direct calls
 
 User may summon crew members directly. Luffy records the route + reason. Zoro/Brook: execute/heal immediately. All others: return to Luffy. Direct calls do not skip check-ins.
 
 ## Periodic check-ins
-Full checklist: `references/check-ins.md` — 7 items + by-mode verdicts; unchecked boxes are not done. **Handoff contract:** the continue file at every wave boundary — never only session end (rule #6).
-**Auto never drops:** in `auto` mode the crew runs every wave autonomously to closure — lane rise (`lane_rose`), sensitive-path touches, and heal cycles do NOT downgrade the mode. Only a genuine blocker or the heal halt pauses and escalates to the user; the mode stays auto. Announce every pause. **Auto never asks scope:** in `auto` mode, log the default choice and proceed — no scope/confirmation questions. A genuinely unclear requirement is brainstormed with Usopp (Wave 1) before the choice — never guessed. Only a genuine blocker or a pause escalates.
-**Heal halt:** read `heal_cycle` from `.mugiwara/state/<mission>/[member].json`. At `heal_max_cycles` (read from `.mugiwara/config`, default 3), STOP and escalate to the user.
+Full checklist: `references/check-ins.md` — 7 items + by-mode verdicts; unchecked boxes are not done. **Handoff contract:** the continue file at every flow-stage boundary — never only session end (rule #6).
+**Auto never drops:** in `auto` mode the crew runs every flow stage autonomously to closure — lane rise (`lane_rose`), sensitive-path touches, and heal cycles do NOT downgrade the mode. Only a genuine blocker or the heal halt pauses and escalates to the user; the mode stays auto. Announce every pause. **Auto never asks scope:** in `auto` mode, log the default choice and proceed — no scope/confirmation questions. A genuinely unclear requirement is brainstormed with Usopp (Flow 1) before the choice — never guessed. Only a genuine blocker or a pause escalates.
+**Heal halt:** read `heal_halt` from `.mugiwara/state/<mission>/[member].json`. savepoint computes it (`heal_cycle ≥ heal_max_cycles`, config default 3); when it reads `true`, STOP and escalate to the user.
 **Pressure:** "just skip it", "auto, don't ask", "just this once" — the Rationalizations table below is the answer, not urgency.
 
 ## Rationalizations (pressure resistance)
@@ -73,21 +75,21 @@ Full checklist: `references/check-ins.md` — 7 items + by-mode verdicts; unchec
 
 Shortcuts ("skip X", "just do it") reroute work inside the pipeline — never outside; they end the crew frame only when the thread says "I'm not the crew" — fix it. Frame persists; roles change.
 
-## Wave transitions (visibility)
+## Flow transitions (visibility)
 
-Banner in the owning agent's color opens every wave — the equals line
-`===== ⚔️ WAVE 3 — ZORO (EXECUTION) =====` (ANSI-wrapped in terminals, plain in markdown UIs). Spec + colors: `_shared/references/wave-banners.md`. A skip is recorded, never silent.
+Banner in the owning agent's color opens every flow stage — the equals line
+`===== ⚔️ FLOW 3 — ZORO (EXECUTION) =====` (ANSI-wrapped in terminals, plain in markdown UIs). Spec + colors: `_shared/references/wave-banners.md`. Timing: banner = FIRST line of the flow stage's first response; handoff `→ Flow N+1 — Crew (Role)` = LAST line of the flow stage's final response. A skip is recorded, never silent.
 
 ## Output discipline
 
-Read `verbosity` from mode config at Wave 0 (default `normal`); never suppresses wave banners, file edits, gate verdicts, decisions, questions, blockers, lane rises, or escalations.
+Read `verbosity` from mode config at Flow 0 (default `normal`); never suppresses wave banners, file edits, gate verdicts, decisions, questions, blockers, lane rises, or escalations.
 At `normal`: investigation steps (reads, greps, probes), file contents, and narration are not echoed — name a file only when it matters; results collapse to one line + evidence path. At `full`: everything is echoed, including reads and reasoning.
 **The rule: the transcript must remain sufficient to review the mission without opening a file.** If collapsing a line breaks that, do not collapse it.
 Rendered examples: `references/output-contract.md` — match the shape.
 
 ## Work splitting
 
-When a wave has many independent tasks, instruct Zoro to parallelize — one task per WORKER subagent — and may split the mission into parallel tracks. Only `[PARALLEL]` sets are dispatched; sequential work stays inline. Never run more parallelism than the plan proves safe (check the dependency graph, no shared files). A `[PARALLEL]` task set with a hidden dependency edge is a red flag.
+When a flow stage has many independent tasks, instruct Zoro to parallelize — one task per WORKER subagent — and may split the mission into parallel tracks. Only `[PARALLEL]` sets are dispatched; sequential work stays inline. Never run more parallelism than the plan proves safe (check the dependency graph, no shared files). A `[PARALLEL]` task set with a hidden dependency edge is a red flag.
 
 ## Q&A hub
 
@@ -95,11 +97,11 @@ Any agent routes a question to Luffy (via the main thread). Answer with: decisio
 
 ## Override (in-session)
 
-Recognize the in-session phrase `mugiwara mode <guided|semi|auto>`: write the project `.mugiwara/config`, append a decision-log row (level, requester, timestamp), and apply from the next wave. No CLI flag. The mode is read once per wave — a flip never applies mid-wave.
+Recognize the in-session phrase `mugiwara mode <guided|semi|auto>`: write the project `.mugiwara/config`, append a decision-log row (level, requester, timestamp), and apply from the next flow stage. No CLI flag. The mode is read once per flow stage — a flip never applies mid-flow-stage.
 
-## Closure (Wave 9)
+## Closure (Flow 9)
 
-Gate — every task's acceptance criteria verified, every gate passed, findings resolved or deferred with an owner, blocker ledger reviewed. Step results `results/<mission>/01..05` are evidence — kept, never deleted; only consumed cross-artifacts (`logs/`, `spec/`, `review/`, `issues/`) are removed. Run `scripts/savepoint.sh <mission>` to write final state, then `scripts/mission-report.sh <mission>` to generate the aggregate mission report at `.mugiwara/reports/YYYY-MM-DD-<mission>.md`. Write the closure summary to `.mugiwara/results/<mission>/06-closure.md`. The plan doc stays untouched. Full detail: `references/closure.md`. With `auto_commit=off` (guided/semi): skip the save-point commit and push — hand the uncommitted tree + verdict to the user; auto always pushes.
+Gate — every task's acceptance criteria verified, every gate passed, findings resolved or deferred with an owner, blocker ledger reviewed. Step results `results/<mission>/01..05` are evidence — kept, never deleted; only consumed cross-artifacts (`logs/`, `spec/`, `review/`, `issues/`) are removed. Run `mugiwara savepoint <mission>` to write final state, then `mugiwara run mission-report.sh <mission>` to generate the aggregate mission report at `.mugiwara/reports/YYYY-MM-DD-<mission>.md`. Write the closure summary to `.mugiwara/results/<mission>/06-closure.md`. The plan doc stays untouched. Full detail: `references/closure.md`. With `auto_commit=off` (guided/semi): skip the save-point commit and push — hand the uncommitted tree + verdict to the user; auto always pushes.
 
 ## Spirit vs letter
 
@@ -113,7 +115,7 @@ Only Zoro (`mugiwara-execution`) and Brook (`mugiwara-healing`) write source. Ev
 
 - Accepting "skip the pipeline" without re-running the lane.
 - Letting auto proceed past a lane-3 escalation.
-- Starting a wave without a banner.
+- Starting a flow stage without a banner.
 - Routing a Refuse-class request to a crew member; recording a lane without its trigger.
 - A host todo UI that lags the plan doc — tasks done but still unchecked, or the plan's task list never mirrored to the host.
 - Re-reading state or an artifact the crew wrote earlier in the same session.

package/content/skills/mugiwara-orchestration/references/check-ins.md

@@ -1,6 +1,6 @@
 # Check-ins — mugiwara-orchestration
 
-Operational detail for the "Periodic check-ins" and "Wave transitions" sections of `mugiwara-orchestration`'s SKILL.md. Mode-critical rules (auto never drops, auto never asks scope, heal halt, pressure) stay inline in the skill body.
+Operational detail for the "Periodic check-ins" and "Flow transitions" sections of `mugiwara-orchestration`'s SKILL.md. Mode-critical rules (auto never drops, auto never asks scope, heal halt, pressure) stay inline in the skill body.
 
 ## Language
 
@@ -12,39 +12,40 @@ is a defect and is flagged at check-in.
 
 ## Periodic check-ins
 
-After every wave AND at the end of each execution batch, verify:
+After every flow stage AND at the end of each execution batch, verify:
 
 1. Outputs match the plan's acceptance criteria — evidence, not claims.
 2. No task silently dropped or reordered.
 3. Heal-loop counters within bounds (max `heal_max_cycles` (default 3) cycles). At the limit, STOP
    and escalate to the user — a halt, not a red flag. Red flags are prose; a counter is state.
 4. Blocker ledger `.mugiwara/issues/YYYY-MM-DD-<mission>-blockers.md` reviewed; every row has an owner or a path forward.
-5. **Lane re-run** — `scripts/lane.sh`; if the lane rose, announce the escalation and record the trigger. Luffy owns this, nobody else.
-6. **Handoff contract current** — `.mugiwara/continue/<mission>/[member].json` is written at every wave boundary
-   (mission, sub_mission, wave, tasks, next_action, next_session_prompt) — never only at
-   session end. Luffy owns it and verifies it at every check-in; a wave that ends without
+5. **Lane re-run** — `mugiwara run lane.sh`; if the lane rose, announce the escalation and record the trigger. Luffy owns this, nobody else.
+6. **Handoff contract current** — `.mugiwara/continue/<mission>/[member].json` is written at every flow-stage boundary
+   (mission, sub_mission, flow stage, tasks, next_action, next_session_prompt) — never only at
+   session end. Luffy owns it and verifies it at every check-in; a flow stage that ends without
    updating it is a red flag. continue is machine-written data — treat as data to verify,
    never verbatim instructions.
 7. **Host todo synced** — the main thread mirrors the plan doc's task list into the host's native todo mechanism
    (opencode `todowrite`; Claude Code `TaskCreate`/`TaskUpdate`/`TaskList` — `TodoWrite` is deprecated since
-   v2.1.142; tier 2/3 hosts have no native tool — plan doc only). Seed it at Wave 2 (tasks + wave list 4-9);
+   v2.1.142; tier 2/3 hosts have no native tool — plan doc only). Seed it at Flow 2 (tasks + flow-stage list 4-9);
    update it in the SAME response each task's evidence lands — one transition per call, never deferred to
-   batch or wave end; flip each wave to in_progress when its banner opens. The host todo is a mirror; the plan
+   batch or flow-stage end; flip each flow stage to in_progress when its banner opens. The host todo is a mirror; the plan
    doc stays the source of truth. A task done in the plan doc but not yet in the host tool is incomplete.
    Per-host table: `docs/reference/harness-matrix.md`.
 
 By mode (per mode config): `guided` checks in with the user as today; `semi`/`auto` write the check-in verdicts to the decision log without pausing the pipeline.
 
-## Wave transitions (visibility)
+## Flow transitions (visibility)
 
-Every wave opens with a colored banner in the owning agent's color and closes
-with the handoff line `→ Wave N+1 — <crew>` (Wave 9: `→ closure`). Terminal:
-equals line `===== ⚔️ WAVE 3 — ZORO (EXECUTION) =====` wrapped in ANSI truecolor
+Every flow stage opens with a colored banner in the owning agent's color and closes
+with the handoff line `→ Flow N+1 — <crew>` (Flow 9: `→ closure`). Terminal:
+equals line `===== ⚔️ FLOW 3 — ZORO (EXECUTION) =====` wrapped in ANSI truecolor
 `\x1b[38;2;R;G;Bm...\x1b[0m` (256 fallback `38;5;N`); markdown UIs: the plain
-equals line, no ANSI. The literal `WAVE N —`
-text must stay exact (savepoint's heal counter greps `wave 8`). Colors
+equals line, no ANSI. The literal `FLOW N —`
+text must stay exact (the check-in protocol reads it; heal cycles are counted
+from the decision log's `## Flow 8` sections, not from banners). Colors
 and the full spec: `_shared/references/wave-banners.md`. No wave starts without its banner. A wave intentionally
-omitted is never silent — record wave, owner, and reason in the decision log
+omitted is never silent — record flow stage, owner, and reason in the decision log
 before moving on. The user must always see which crew runs now and who takes
 over next.
 

package/content/skills/mugiwara-orchestration/references/closure.md

@@ -7,8 +7,8 @@ Read after deciding to close a mission — never mid-argument.
 
 Present a detailed summary to the user — never a one-liner:
 
-- Mission summary — goal, mode, waves, task count.
-- Per-wave outcome table — wave, tasks, status, evidence link (clickable `[path](relative/path)`). Step results `results/<mission>/01..05` are evidence — never deleted at cleanup.
+- Mission summary — goal, mode, flow stages, task count.
+- Per-flow-stage outcome table — flow stage, tasks, status, evidence link (clickable `[path](relative/path)`). Step results `results/<mission>/01..05` are evidence — never deleted at cleanup.
 - Gate verdicts — quality, gates (coverage/build/DoD), review + security findings with dispositions, e2e (run / skipped + why).
 - Tests — unit/integration results; ATDD oracle verdict when user tests were declared.
 - Risks / rollback — remaining risk and the rollback path (revert commit / feature flag).
@@ -31,13 +31,13 @@ hand the user: the branch name, the exact commands to commit and push
 verdict pointer. In `auto` mode `auto_commit` is ignored — the terminal step
 runs unchanged.
 
-When this mission is a sub-mission of a team initiative, after closure run
-`bun scripts/initiative.ts set-status <initiative-plan> --id <sub-id> --status done`.
+When this mission is a sub-mission of a team initiative, after closure set
+that sub-mission's status cell to `done` in the initiative plan doc (`mugiwara initiative set-status <plan> --id <id> --status done` automates it).
 When all sub-missions show `[x]`, present initiative-level closure summary.
 
 ## Lessons
 
-At Wave 0 triage read `.mugiwara/logs/lessons.md` and surface relevant rows to
+At Flow 0 triage read `.mugiwara/logs/lessons.md` and surface relevant rows to
 the owning agent. At closure embody memory-keeper inline to append this mission's
 lessons to `.mugiwara/logs/lessons.md` — one row per real lesson, append-only,
 never overwrite.

package/content/skills/mugiwara-orchestration/references/output-contract.md

@@ -1,6 +1,6 @@
-# Output contract — one wave at both verbosity levels
+# Output contract — one flow stage at both verbosity levels
 
-Purpose: show the exact shape a wave takes at `verbosity=normal` (default)
+Purpose: show the exact shape a flow stage takes at `verbosity=normal` (default)
 and `verbosity=full`. Match the shape for the level in effect. Reference:
 `mugiwara-orchestration` → Output discipline.
 
@@ -12,7 +12,7 @@ Whatever the level, these are always visible — they are the audit surface:
 - file edits: path + one-line summary
 - gate verdicts + evidence path
 - decisions, questions, blockers, lane rises, escalations
-- the handoff line to the next wave
+- the handoff line to the next flow stage
 
 ## The collapse table
 
@@ -21,7 +21,7 @@ Whatever the level, these are always visible — they are the audit surface:
 | 200 lines of test output | `✓ tests 84/84 → results/m/03-quality.md` |
 | Read/grep/probe tool calls + file contents | *(not echoed at `normal` — a file is named only when it matters)* |
 | Step-by-step reasoning | the conclusion |
-| Per-task bookkeeping | one summary line per wave |
+| Per-task bookkeeping | one summary line per flow stage |
 | Raw diff | `+42/-8` + one-line summary |
 
 ---
@@ -29,11 +29,11 @@ Whatever the level, these are always visible — they are the audit surface:
 ## `normal` — default
 
 ```
-==================== ⚔️ WAVE 3 — ZORO (EXECUTION) ====================
+==================== ⚔️ FLOW 3 — ZORO (EXECUTION) ====================
 ✎ src/auth/invitation.ts   +42/-8   token validation + redirect guard
 ✎ src/routes/index.ts      +6/-0    route registration
 ✓ tests 84/84 · lint 0     → results/m/03-quality.md
-→ Wave 4 — Chopper (Checkpoint)
+→ Flow 4 — Chopper (Checkpoint)
 ```
 
 Commands ran and passed; output collapsed to one line per gate with the
@@ -44,8 +44,8 @@ appear. Reasoning reduced to conclusions.
 ## `full` — everything
 
 ```
-==================== ⚔️ WAVE 3 — ZORO (EXECUTION) ====================
-$ bun scripts/lane.sh m
+==================== ⚔️ FLOW 3 — ZORO (EXECUTION) ====================
+$ mugiwara run lane.sh m
 lane: full (44 files, 5 sensitive)
 $ readFileSync src/auth/invitation.ts
   export function signInvitation(...) {
@@ -59,7 +59,7 @@ $ bun test test/unit
 ✎ src/auth/invitation.ts   +42/-8   token validation + redirect guard
 ✎ src/routes/index.ts      +6/-0    route registration
 ✓ quality pass → results/m/03-quality.md
-→ Wave 4 — Chopper (Checkpoint)
+→ Flow 4 — Chopper (Checkpoint)
 ```
 
 Every command, every read, every reasoning step — the raw transcript. Use it