@ionivetech/mugiwara 0.4.0 → 0.5.1

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

@@ -1,6 +1,6 @@
 ---
 name: mugiwara-resume
-description: Use when a mission is interrupted, context is lost or compacted, or a new session starts mid-mission - rebuild the full picture from .mugiwara/ state and continue from the exact point, never restart.
+description: Use when mission interrupted, context lost, or new session mid-mission — rebuild from .mugiwara/state.json, continue never restart.
 ---
 
 # Session Resume (Never Start Over)
@@ -10,47 +10,58 @@ description: Use when a mission is interrupted, context is lost or compacted, or
 - Fresh mission: no `.mugiwara/` state exists to rebuild from.
 - No interruption, compaction, or new-session-mid-mission happened.
 
-The host AI can lose context — compaction, a new session, a crash. Disk state under `.mugiwara/` is the single source of truth. Rebuild the picture from disk, continue from the exact point, never restart.
-
-## The state contract
-
-What survives on disk and drives resume:
-
-| File | Holds |
-|------|-------|
-| `.mugiwara/plans/YYYY-MM-DD-<mission>.md` | waves, tasks, acceptance criteria (clean plan) |
-| `.mugiwara/results/<mission>-todos.md` | checkbox per task, checked = done with evidence |
-| `.mugiwara/results/<mission>-trace.md` | every dispatch, outcome |
-| `.mugiwara/issues/YYYY-MM-DD-<mission>-blockers.md` | blocker rows with owners / heal state |
-| `.mugiwara/logs/YYYY-MM-DD-<mission>.md` | Luffy's decision + check-in log |
-| `.mugiwara/config` | current mode (project); `~/.mugiwara/config` = global default; per-mission override rows live in the decision log |
+The host AI can lose context — compaction, new session, crash. Disk state is truth. Rebuild from one file, continue from exact point, never restart.
+
+## State contract
+
+Resume reads one file: `.mugiwara/state.json`. All position data is computed at every wave boundary by `scripts/savepoint.sh`.
+
+```json
+{
+  "mission": "2026-08-11-invitation-accepted",
+  "actor": "farid",
+  "branch": "feature/feat-MKR-412",
+  "lane": "full",
+  "lane_reason": "auth/ path touched",
+  "wave": 5,
+  "mode": "guided",
+  "base_sha": "a3f1c2e",
+  "files_touched": 11,
+  "loc_delta": 340,
+  "sensitive_paths": ["src/auth/invitation.ts"],
+  "tasks": { "done": 7, "total": 12 },
+  "blockers_open": 1,
+  "heal_cycle": 1,
+  "tokens_est": 14200,
+  "budget": 20000,
+  "evidence": [".mugiwara/results/wave4-audit.md"],
+  "updated_at": "2026-08-11T12:40:00Z"
+}
+```
 
 ## Resume protocol
 
-Read in this order, then act:
-
-1. Plan doc → current wave, remaining tasks.
-2. Todos → done/undone (unchecked box = not done, regardless of memory).
-3. Trace → last completed step, last outcome.
-4. Blocker ledger → open rows (they have owners / are mid-heal).
-5. Config → the mode. Read `.mugiwara/config` (project) then `~/.mugiwara/config` (global) before re-deriving position; missing = `guided`. If a per-mission override row exists in the decision log (`.mugiwara/logs/YYYY-MM-DD-<mission>.md`), that level wins over the config file for this mission.
-6. Re-derive position: wave N, tasks remaining, open blockers, heal counter, and the resumed mode.
-7. State it in one line: "Resumed: Wave 5, tasks 5.3-5.7 pending, 1 blocker (env), heal counter 1, mode semi." Then CONTINUE — do not re-verify completed waves unless the trace shows a failure.
+1. Read `.mugiwara/state.json`. If absent, this is a fresh mission — no resume needed.
+2. Derive position from fields: wave N, tasks done/total, blockers open, heal cycle, mode.
+3. If `state.json` is stale or corrupted, fall back to legacy files: plan doc → todos → trace → blocker ledger → config. Then write a fresh `state.json`.
+4. State it: "Resumed: Wave 5, 7/12 tasks, 1 blocker, heal cycle 1, mode guided."
+5. Continue — do not re-verify completed waves.
 
 ## Rules
 
 1. Never trust memory over disk — disk is truth.
-2. Never re-run completed work — the trace proves it.
+2. Never re-run completed work — state.json proves it.
 3. Never skip the resume read — guessing position = drift.
-4. If disk state is missing/contradictory → escalate to Luffy to reconcile, do not invent state.
+4. If state.json is absent and no legacy files exist → fresh mission, escalate to Luffy.
 
-## Writing discipline
+## Rationalizations
 
-Update todos/trace AFTER every task, not at the end. Resume quality is proportional to log freshness. A stale log makes the next resume guess.
+- "I remember where we were" → memory lies after compaction; disk is truth.
+- "Re-running is safer" → wastes the mission; trust state.json.
+- "I'll update state later" → savepoint.sh runs at every wave boundary; state is always current.
 
-## Rationalizations + red flags
+## Red flags
 
-- "I remember where we were" → memory lies after compaction; disk is truth.
-- "Re-running is safer" → wastes the mission; trust the trace.
-- "I'll update todos later" → later never comes; resume breaks.
-- Red flags: reading any file out of order, re-doing a wave the trace shows complete, skipping the blocker ledger, inventing state instead of escalating, a resume position stated without citing the files.
+- Resume position stated without citing state.json or legacy files.
+- Re-doing a wave state.json shows complete.
+- Inventing state instead of escalating when files are missing.

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

@@ -1,6 +1,6 @@
 ---
 name: mugiwara-review
-description: Use after quality gates pass to review the diff adversarially - doubt-driven review, breaking-change damage map via repo-wide caller mapping first, five-axis review with regression emphasis, sonar smells, severity criteria, dispute hierarchy, docs gaps. Findings to .mugiwara/review/. Max 3 cycles then escalate.
+description: Use after gates pass to review PR diff, code review — breaking-change map via caller mapping, five-axis review, severity-tagged findings. Max 3 cycles.
 ---
 
 # Review (Robin)

package/content/skills/mugiwara-review/references/five-axis-worksheet.md

@@ -0,0 +1,36 @@
+# Five-Axis Review Worksheet
+
+One verdict + evidence per axis. No axis passes on assertion.
+
+## Axes
+
+| Axis | Question | Evidence required |
+|------|----------|-------------------|
+| Correctness | Does the change break anything that currently works? | Re-run caller tests, verify edge cases |
+| Readability | Can a new team member understand the diff in 5 minutes? | Naming convention check, function length, comment quality |
+| Architecture | Does the change fit the existing system structure? | No parallel patterns, no new abstraction without need |
+| Security | Any security regression or new attack surface? | STRIDE on changed surface, checklist pass |
+| Performance | Any N+1, O(n²), or unbounded resource use introduced? | Profiler output or manual analysis of hot path |
+
+## Example
+
+```
+Axis: Correctness
+Verdict: PASS
+Evidence: npm test -- --shard=1/2 passes (312 tests), caller grep confirms all
+          imports of renamed function updated
+```
+
+```
+Axis: Security
+Verdict: FAIL
+Evidence: New endpoint POST /api/export has no authz middleware. Missing rate
+          limit on file generation (DoS risk).
+```
+
+## Rules
+
+- One verdict per axis. "Partial pass" = FAIL.
+- Evidence is command output or file path, never a paraphrase.
+- FAIL on any axis → overall review FAIL → Brook (Wave 8).
+- PASS on all 5 → forward to closure.

package/content/skills/mugiwara-review/references/severity-rubric.md

@@ -0,0 +1,20 @@
+# Severity Rubric
+
+For review findings. Every finding gets a severity backed by criteria.
+
+| Severity | Definition | Examples | Action |
+|----------|-----------|----------|--------|
+| **blocker** | public-break with no migration path, wrong behavior shipped, security hole | renamed public API with callers unfixed, authz bypass, data loss | Fix before merge |
+| **major** | internal-break with callers unfixed, missed contract, behavior change outside declared scope | changed function signature, missing error handling, N+1 in hot path | Fix this mission |
+| **minor** | polish, style drift, batched items | inconsistent naming, missing test for edge case, duplicated 3-line helper | May batch with Brook |
+
+## CVSS-style for security
+
+| Severity | Exploitability × Impact |
+|----------|------------------------|
+| Critical | Reachable + tooling exists + pre-auth → data loss/auth bypass/RCE |
+| High | Reachable + limited tooling → PII leak, privilege escalation |
+| Medium | Requires auth/conditions → partial exposure |
+| Low | Defense-in-depth gaps, no known exploit path |
+
+Security findings are never "minor by default." Every finding gets the matrix.

package/content/skills/{mugiwara-systematic-debugging → mugiwara-root-cause}/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: mugiwara-systematic-debugging
-description: Use when any agent or worker hits a failure and must debug it - a bug, a test that fails for an unknown reason, a crash, a wrong result, or an unexplained regression. A standalone 4-phase discipline - reproduce, localize, reduce, fix + guard. Stop-the-line on failures, prove-it before fixing, rollback prep before a risky fix.
+name: mugiwara-root-cause
+description: Use for debugging bugs — debug, bug, crash, error, recurring, intermittent, track it down. 4-phase: reproduce, localize, reduce, fix+guard. Root cause hunt.
 ---
 
 # Systematic Debugging
@@ -16,6 +16,8 @@ A failure is a stopping event, not a speed bump. Do not guess, do not patch. Wal
 
 Any bug, unexplained failure, crash, or regression in code, tests, or config. When the cause is unknown, the fix is not obvious, or the failure is intermittent. Standalone discipline — use it before any fix ships, and escalate when a phase cannot complete.
 
+Framework code from docs, not memory: `references/source-grounding.md`.
+
 ## Process
 
 ### Phase 1 — Reproduce

package/content/skills/mugiwara-root-cause/references/four-phase-worked.md

@@ -0,0 +1,71 @@
+# Four-Phase Debugging — Worked Example
+
+A real bug traced end to end through reproduce → localize → reduce → fix + guard.
+
+## The bug report
+
+```
+Title: Users see "null" instead of display name on profile page
+Severity: medium
+Reported: Aug 2026
+```
+
+## Phase 1 — Reproduce
+
+```bash
+# Create user with no displayName
+$ curl -X POST /api/users -d '{"email":"test@ex.com"}'
+{"id": "u_42", "email": "test@ex.com"}
+
+# Fetch profile
+$ curl /api/users/u_42
+{"id": "u_42", "displayName": "null", "email": "test@ex.com"}
+```
+
+Expected: `displayName` should be `null` (JSON null) or omitted, not string `"null"`.
+
+## Phase 2 — Localize
+
+```bash
+$ git grep -n 'displayName' src/
+src/models/user.ts:12:  displayName?: string | null;
+src/services/user-profile.ts:34:  return user.displayName ?? 'null';
+```
+
+Bug at `src/services/user-profile.ts:34`: `?? 'null'` is the string `"null"`, not the JavaScript `null` value. The default should be `null` or `undefined`.
+
+## Phase 3 — Reduce
+
+```ts
+// Before (broken):
+return user.displayName ?? 'null'; // string "null"!
+
+// Minimal reproduction:
+const result = undefined ?? 'null'; // "null" — this is a string
+```
+
+The `??` operator returns the right operand only when the left is `null`/`undefined`. But `'null'` is a truthy string — it's never the `null` value.
+
+## Phase 4 — Fix + Guard
+
+```ts
+// Fix:
+return user.displayName ?? null; // JSON null
+
+// Guard test:
+it('returns null for missing displayName, not string "null"', () => {
+  const user = { id: 'u_42', email: 'test@ex.com' };
+  const profile = buildProfile(user);
+  expect(profile.displayName).toBeNull(); // was: toBe('null')
+});
+```
+
+```
+$ npm test -- user-profile.test.ts
+PASS  user-profile.test.ts
+  ✓ returns null for missing displayName, not string "null"
+```
+
+## Lesson
+
+String `"null"` ≠ JavaScript `null`. The `??` operator with a string default is almost always a bug. Grep the codebase: `git grep "?? '"` to find similar patterns.

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

@@ -1,6 +1,6 @@
 ---
 name: mugiwara-security
-description: Use for the security audit of a diff or system - STRIDE threat model first, OWASP Top 10 mapping, full checklist in order (secrets, injection, authn/authz, data exposure, dependencies, deserialization, crypto), security-regression and cross-cutting impact checks, untrusted-data doctrine, CVSS-style severity. Findings to .mugiwara/review/.
+description: Use for security audit of a diff — STRIDE, OWASP Top 10, secrets, injection, authn/authz, authorization, RBAC, roles, permissions, dependency audit. Findings to .mugiwara/review/.
 ---
 
 # Security (Jinbe)

package/content/skills/mugiwara-security/references/owasp-mapping.md

@@ -0,0 +1,30 @@
+# OWASP Top 10 Mapping
+
+Required when the project handles payments, health data, or PII.
+
+| Code | Category | Review area |
+|------|----------|-------------|
+| A01 | Broken access control | authz gaps, IDOR, missing server-side checks |
+| A02 | Cryptographic failures | PII in transit/at rest, weak crypto, exposed secrets |
+| A03 | Injection | SQL/NoSQL/OS/template injection, unsanitized input to exec/render |
+| A04 | Insecure design | missing threat model, trust-boundary failures |
+| A05 | Misconfiguration | default creds, verbose errors, permissive headers, debug on |
+| A06 | Vulnerable components | dependency audit, known-vuln check, outdated libs |
+| A07 | Authn failures | broken sessions, brute-forceable login, credential reuse |
+| A08 | Integrity | insecure deserialization, supply-chain tamper |
+| A09 | Logging/monitoring | PII in logs, missing audit trail, silent failures |
+| A10 | SSRF | server-side requests to attacker-controlled targets, URL validation |
+
+## How to map
+
+For each security check run, record which OWASP category it covers. A handled
+category with no mapping row = documentation gap in the security report.
+
+```
+| OWASP | Check | Verdict |
+|-------|-------|---------|
+| A01   | Authz on /api/admin routes | PASS |
+| A02   | TLS enforced, no hardcoded secrets | PASS |
+| A03   | SQL params in user query handler | PASS |
+| A06   | npm audit: 0 critical/high | PASS |
+```

package/content/skills/mugiwara-security/references/stride-worksheet.md

@@ -0,0 +1,37 @@
+# STRIDE Worksheet
+
+Map every application surface to STRIDE before running security checks.
+
+## Surface inventory
+
+List every surface where data, requests, or state cross trust levels:
+
+- HTTP endpoints (REST, GraphQL, gRPC)
+- CLI arguments and environment variables
+- File uploads, database reads/writes
+- External API calls, webhooks
+- Rendered output (HTML, JSON, logs)
+- Config files, secret stores
+
+## STRIDE per surface
+
+| STRIDE | Ask of each surface |
+|--------|---------------------|
+| Spoofing | Can an identity be forged or impersonated? |
+| Tampering | Can data in transit or at rest be altered undetected? |
+| Repudiation | Can an action occur without a traceable actor? |
+| Info disclosure | Can data leak to an unintended party? |
+| DoS | Can the surface be exhausted or taken down? |
+| Elevation | Can a caller gain privileges beyond their grant? |
+
+## Example
+
+| Surface | S | T | R | I | D | E | Notes |
+|---------|---|---|---|---|---|---|-------|
+| POST /api/invite | ✅ | ✅ | — | ⚠️ | — | ✅ | Email exposed in error response |
+| GET /api/users/:id | ✅ | — | — | ⚠️ | — | ✅ | IDOR: no ownership check |
+| config upload | — | ✅ | — | — | — | — | YAML parsing, no schema validation |
+
+✅ = threat present, ⚠️ = partial mitigation, — = not applicable
+
+A surface with no STRIDE row is a modeling gap, not a safe surface.

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

@@ -1,6 +1,6 @@
 ---
 name: mugiwara-ship
-description: Use at mission end or before any release to run the ship gate - pre-launch checklist, feature flags, staged rollout, mandatory rollback plan. Binary GO/NO-GO verdict with evidence.
+description: Use at mission end — pre-launch checklist, feature flags, staged rollout, mandatory rollback plan. Binary GO/NO-GO.
 ---
 
 # Ship Gate (Luffy, Franky)

package/content/skills/{mugiwara-deprecation → mugiwara-sunset}/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: mugiwara-deprecation
-description: Use when retiring code, APIs, or features that no longer justify their upkeep, or when steering users off one implementation onto another. Sunset criteria, safe DB migrations, phased cutovers, orphaned code. Every removal needs a plan and a tested way back.
+name: mugiwara-sunset
+description: Use when removing, deleting, deprecating old code, legacy APIs, v1 endpoints — keep-or-retire gate, safe DB migrations, phased cutovers. Every removal needs a plan.
 ---
 
 # Deprecation & Migration (Brook)

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

@@ -1,6 +1,6 @@
 ---
 name: mugiwara-testcases
-description: Use when a mission declares user-provided test cases or acceptance criteria - intake formats, immutable-gold rule, declarative-AC routing, consent, and failure adjudication. Single home for the ATDD contract; referenced by the quality and gates agents.
+description: Use when mission declares user test cases, e2e, playwright, cypress, integration tests — intake formats, immutable-gold rule, consent, failure adjudication.
 ---
 
 # Test Cases (ATDD Contract)

package/content/skills/mugiwara-testcases/references/intake-formats.md

@@ -0,0 +1,42 @@
+# Test Intake Formats
+
+Single home for the ATDD contract. Referenced by `mugiwara-quality` and `mugiwara-gates`.
+
+## Format 1: Executable tests (user test files)
+
+```
+Path: tests/acceptance/invitation-flow.test.ts
+Type: integration
+Commands: npm run test:acceptance -- invitation-flow
+```
+
+Imported as immutable gold. Never edit, never skip. Run failing first, green at end.
+
+## Format 2: Declarative acceptance (Gherkin/markdown AC)
+
+```gherkin
+Feature: Invitation flow
+  Scenario: User accepts invitation
+    Given an invitation exists for "user@example.com"
+    When the user clicks the invitation link
+    Then the user is redirected to onboarding
+    And the invitation status changes to "accepted"
+```
+
+The crew translates this to a project test file. Write the test, watch it fail, implement, re-run green.
+
+## Format 3: Command-verifiable
+
+```
+Acceptance: curl -X POST /api/invite -d '{"email":"test@ex.com"}' | jq .status
+Expected: "sent"
+```
+
+Run directly. No translation needed.
+
+## Rules
+
+- No declared test source → no user tests for the mission.
+- Executable user tests = immutable gold. Change requires user consent + ledger row.
+- Declarative AC tests are model-written → extra Chopper scrutiny (can encode the bug).
+- Cross-cutting user ACs (e2e flow spanning tasks) → plan-level criteria, re-run at checkpoint against whole diff.

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

@@ -1,6 +1,6 @@
 ---
 name: mugiwara-workflow
-description: Use at the start of any non-trivial mission to run the Mugiwara crew harness - Luffy triage gateway first, then brainstorm, planning, execution, checkpoint, quality, gates, review, healing, and closure waves.
+description: Use at start of any non-trivial mission — Luffy triage gateway, full pipeline: brainstorm/plan/execute/checkpoint/quality/gates/review/heal/closure waves.
 ---
 
 # Mugiwara Workflow
@@ -36,9 +36,11 @@ Every mission creates and works inside `.mugiwara/` at the repo root:
 ```
 .mugiwara/
 ├── config         # runtime mode config: mode/branch/commit/pr key=value (gitignored; project overrides global)
+├── state.json     # computed mission state at every wave boundary (scripts/savepoint.sh)
 ├── spec/          # brainstorm output: YYYY-MM-DD-<mission>.md
-├── plans/         # plan doc: YYYY-MM-DD-<mission>.md — CLEAN, Nami-only, source of truth from Wave 2. No agent names, no log, no closure.
+├── plans/         # plan doc: YYYY-MM-DD-<mission>.md — CLEAN, Nami-only, source of truth from Wave 2
 ├── results/       # wave results: audit/quality/gate reports, todos, closure report
+├── reports/       # human-readable mission reports: YYYY-MM-DD-<mission>.md
 ├── review/        # review + security findings
 ├── issues/        # blocker log: YYYY-MM-DD-<mission>-blockers.md
 └── logs/          # Luffy's decision + check-in log: YYYY-MM-DD-<mission>.md (deleted at cleanup)
@@ -58,7 +60,7 @@ At session start, after context loss, or on any "where were we?" — embody `res
 
 Front door: embody `using-mugiwara` inline (the router) — it routes to the right crew member and records the route. For a full triage embody `luffy-orchestrator` inline. NEVER start directly with brainstorming or planning. Luffy classifies every request 5 ways (Trivial / Explicit / Exploratory / Open-ended / Ambiguous) and routes: Trivial and Explicit → Wave 2 directly; Exploratory, Open-ended, and Ambiguous → Wave 1 brainstorm first. Alongside the class, Luffy sizes the mission and picks a lane (0 Direct / 1 Lean / 2 Standard / 3 Full / 4 Spike) — small work skips the pipeline, sensitive work never sneaks through the lean path. The user may summon any crew member directly — Luffy still records the route.
 
-Alongside triage, read the mode config per `mugiwara-mode`: `.mugiwara/config` (project) then `~/.mugiwara/config` (global); a key missing from both = `guided`. Lazy-create the project config on first WRITE only, never auto-create on read.
+Alongside triage, read the mode config per mode config: `.mugiwara/config` (project) then `~/.mugiwara/config` (global); a key missing from both = `guided`. Lazy-create the project config on first WRITE only, never auto-create on read.
 
 ## Waves
 
@@ -69,7 +71,7 @@ Alongside triage, read the mode config per `mugiwara-mode`: `.mugiwara/config` (
 | 2 Planning | Nami | mugiwara-planning | plan doc: waves/tasks/criteria, parallel markers |
 | 3 Execution | Zoro | mugiwara-execution | implemented tasks with evidence |
 | 4 Checkpoint | Chopper | mugiwara-checkpoint | audit report + failure ledger |
-| 4.5 Adversarial | Skeptic | mugiwara-dynamic-workflow | findings report + failure ledger |
+| 4.5 Adversarial | Skeptic | mugiwara-claim-audit | findings report + failure ledger |
 | 5 Quality | Sanji | mugiwara-quality | formatter/linter/test results |
 | 6 Gates | Franky | mugiwara-gates | coverage + build verdict |
 | 7 Review | Robin ∥ Jinbe | mugiwara-review + mugiwara-security | severity-tagged findings |
@@ -88,7 +90,7 @@ Never silently work around a blocker. Brook reads this ledger at Wave 8 to decid
 
 ## Cleanup
 
-At closure (Wave 9), after the terminal step, run the cleanup procedure in `mugiwara-ship`: delete consumed intermediates — superseded results, review, issues reports, the per-mission decision log in `logs/`, and the consumed spec. Keep the plan doc, the closure report, the PR verdict, `config`, and cross-mission state (`logs/lessons.md`, `backup/`, `manifest.json`). List candidates before deleting.
+At closure (Wave 9), after the terminal step, run cleanup per `mugiwara-ship`: delete consumed intermediates — superseded results, review, issues, the decision log in `logs/`, and consumed spec. Keep the plan doc, closure report, PR verdict, mission report, `config`, `state.json`, and cross-mission state (`logs/lessons.md`, `backup/`, `manifest.json`). List candidates before deleting.
 
 ## Rules
 
@@ -96,29 +98,24 @@ At closure (Wave 9), after the terminal step, run the cleanup procedure in `mugi
 2. No wave skipped without the reason recorded in the decision log (`.mugiwara/logs/`) — name the wave, owner, and reason at the moment of omission.
 3. Heal loop is bounded: Wave 8 → Wave 4, max 3 cycles. After that, escalate to the human with full history.
 4. Any agent may consult Luffy mid-flight (embody `luffy-orchestrator` inline) for decisions and escalations.
-5. Wave 7 runs Robin and Jinbe review passes in parallel — both are inline passes over the same diff, or parallel review subagents for large diffs.
-6. The plan doc (`.mugiwara/plans/YYYY-MM-DD-<mission>.md`) is the single source of truth from Wave 2 onward.
-7. Frontend-touching tasks in Wave 3 must apply `mugiwara-frontend` in the same pass.
-8. One crew member may hold many skills (e.g. Usopp holds `mugiwara-brainstorm` + `mugiwara-frontend`; the crew is 15 members); load the member's skills, embody the role inline.
-9. On session start, context loss, or "where were we?" — resume before any wave via `resume-coordinator` (mugiwara-resume); never start over.
-10. The crew never merges and never deploys — push the branch + hand the verdict file to the user, who opens the PR; PR review is the terminal gate in every mode.
+5. Wave 7 runs Robin and Jinbe in parallel over the same diff.
+6. The plan doc is the single source of truth from Wave 2 onward.
+7. Frontend tasks in Wave 3 must apply `mugiwara-frontend`.
+8. On session start or context loss — resume via `resume-coordinator` before any wave; never start over.
+9. Push branch + hand verdict file to the user, who opens the PR; crew never merges, never deploys.
 
 ## Iron Law
 
-EVIDENCE OVER CLAIMS. No wave passes on assertion — the owning agent runs the checks and shows output. A wave that cannot produce evidence is a failed wave.
-
-## Verification gate (every completion claim)
-
-A claim is only as strong as the evidence produced in the same turn that made it. "Done", "passes", and "fixed" each name a command that would prove them — run that command, read its full output, then speak. A result from an earlier run, a guess, or a worker's word for it is not proof; re-run it and diff the work against the tree before reporting. Trust is not a substitute for verification.
+EVIDENCE OVER CLAIMS. No wave passes on assertion — the owning agent runs the checks and shows output. "Done", "passes", and "fixed" must be proved by running the check command in the same turn; no stale results, no guesses, no worker's word for it.
 
 ## Red flags
 
-- A wave "passes" on a spoken claim with no command output or file to point at.
+- A wave passes on a spoken claim with no command output.
 - Heal loop beyond 3 cycles with the same failure still open.
-- A wave skipped with no reason recorded in the decision log.
-- Execution starts before triage (Wave 0), or planning before brainstorm when triage routed to Wave 1.
-- Mission artifacts landing outside `.mugiwara/`.
-- Wave order drifts from the table (e.g. quality before checkpoint).
-- A blocker worked around silently with no ledger row.
+- Wave skipped with no reason recorded in the decision log.
+- Execution before triage (Wave 0).
+- Mission artifacts outside `.mugiwara/`.
+- Wave order drifts (e.g. quality before checkpoint).
+- Blocker worked around silently with no ledger row.
 
-All mean: stop the pipeline, diagnose with Chopper's ledger, decide continue / retry / escalate.
+All mean: stop, diagnose with Chopper's ledger, decide continue/retry/escalate.

package/dist/mugiwara.js

@@ -494,21 +494,45 @@ function writeManifest(file, data) {
 }
 
 // src/mission.ts
-import { existsSync as existsSync5, rmSync as rmSync2 } from "node:fs";
+import { existsSync as existsSync5, rmSync as rmSync2, readFileSync as readFileSync4 } from "node:fs";
 import { join as join7 } from "node:path";
-function resetMission(projectDir, keepLogs) {
+function activeActor(projectDir) {
+  const stateFile = join7(projectDir, ".mugiwara", "state.json");
+  if (!existsSync5(stateFile))
+    return null;
+  try {
+    const state = JSON.parse(readFileSync4(stateFile, "utf8"));
+    return state.actor || null;
+  } catch {
+    return null;
+  }
+}
+function resetMission(projectDir, keepLogs, force) {
   const root = join7(projectDir, ".mugiwara");
   if (!existsSync5(root))
     return { removed: [], kept: [] };
+  if (!force) {
+    const actor = activeActor(projectDir);
+    if (actor) {
+      return { removed: [], kept: [], blocked: `Active mission for '${actor}'. Use --force to override.` };
+    }
+  }
   const removed = [];
   const kept = [];
-  for (const dir of ["spec", "plans", "results", "review", "issues"]) {
+  for (const dir of ["spec", "plans", "results", "review", "issues", "reports"]) {
     const p = join7(root, dir);
     if (existsSync5(p)) {
       rmSync2(p, { recursive: true, force: true });
       removed.push(dir);
     }
   }
+  for (const f of ["state.json"]) {
+    const p = join7(root, f);
+    if (existsSync5(p)) {
+      rmSync2(p);
+      removed.push(f);
+    }
+  }
   if (!keepLogs) {
     const p = join7(root, "logs");
     if (existsSync5(p)) {
@@ -553,13 +577,18 @@ async function run(argv) {
 }
 function resetCmd(flags) {
   const projectDir = resolve(str(flags.project) ?? process.cwd());
-  const { removed, kept } = resetMission(projectDir, flag(flags.keepLogs));
-  if (removed.length)
-    console.log(`removed: ${removed.join(", ")}`);
+  const force = flag(flags.force);
+  const result = resetMission(projectDir, flag(flags.keepLogs), force);
+  if (result.blocked) {
+    console.error(`✗ ${result.blocked}`);
+    process.exit(1);
+  }
+  if (result.removed.length)
+    console.log(`removed: ${result.removed.join(", ")}`);
   else
     console.log("nothing to remove.");
-  if (kept.length)
-    console.log(`kept: ${kept.join(", ")}`);
+  if (result.kept.length)
+    console.log(`kept: ${result.kept.join(", ")}`);
 }
 async function resolveOptions(flags) {
   const interactive = !flag(flags.yes);

package/docs/agents.md

@@ -44,8 +44,8 @@ check-ins. The harness stays coherent either way.
 
 ## The crew ships whole
 
-Every install gets all 15 agents and all 32 skills. No project-type selection —
+Every install gets all 15 agents and all 26 skills. No project-type selection —
 the harness routes each task to the right specialist.
 
-See [skills.md](skills.md) for the 32 techniques, or
+See [skills.md](skills.md) for the 26 techniques, or
 [workflow.md](workflow.md) for the pipeline.