@ionivetech/mugiwara 0.3.0 → 0.5.0

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

@@ -1,10 +1,15 @@
 ---
-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 retiring code or APIs — keep-or-retire gate, safe DB migrations, phased cutovers. Every removal needs a plan and tested way back.
 ---
 
 # Deprecation & Migration (Brook)
 
+## Skip when
+
+- No code, API, or feature is being retired or replaced.
+- Purely additive change — nothing removed, no migration path needed.
+
 Keeping old code alive is a tax, not a virtue: it keeps costing tests, patches, security reviews, and the attention of everyone who walks past it. Retirement is a craft — the removal itself must be as disciplined as the build.
 
 ## Sunset or keep

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

@@ -1,10 +1,15 @@
 ---
 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 — intake formats, immutable-gold rule, declarative-AC routing, consent, failure adjudication. ATDD home.
 ---
 
 # Test Cases (ATDD Contract)
 
+## Skip when
+
+- No user-declared test cases or acceptance criteria in this mission.
+- No repo test source declared and no acceptance oracle needed.
+
 User tests are the crew's acceptance oracle. This is the single home for the ATDD contract — intake, immutable gold, routing, consent, and failure adjudication. Shared by planning, execution, quality, and gates so they cannot drift.
 
 ## Accepted formats

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,10 +1,15 @@
 ---
 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, then brainstorm/plan/execute/checkpoint/quality/gates/review/heal/closure waves.
 ---
 
 # Mugiwara Workflow
 
+## Skip when
+
+- Lane 0 direct work: typo, rename, or single-file fix under 20 LOC.
+- User explicitly declined the harness for this request.
+
 The Straw Hat harness: Wave 0 triage + Waves 1-9, with an optional adversarial pass at Wave 4.5. Waves are phases of the mission, not files — Nami writes them into the plan doc, Zoro executes them. The main thread runs the harness and embodies each crew role inline (Execution model below); the harness always starts through Luffy unless the user summons a crew member directly.
 
 ## Execution model (every harness)
@@ -31,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)
@@ -51,9 +58,9 @@ At session start, after context loss, or on any "where were we?" — embody `res
 
 ## Wave 0 — Luffy Triage (always first)
 
-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. The user may summon any crew member directly — Luffy still records the route.
+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
 
@@ -64,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 |
@@ -83,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
 
@@ -91,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

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync2, realpathSync, rmSync as rmSync2 } from "node:fs";
+import { existsSync as existsSync6, realpathSync, rmSync as rmSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join7, resolve } from "node:path";
+import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/args.ts
@@ -14,6 +14,7 @@ var BOOL_FLAGS = {
   "-y": "yes",
   "--force": "force",
   "--dry-run": "dryRun",
+  "--keep-logs": "keepLogs",
   "--help": "help",
   "-h": "help",
   "--version": "version",
@@ -131,6 +132,10 @@ var target = {
       fm.tools = data.tools;
     return { relPath: `${data.name}.md`, text: stringifyFrontmatter(fm, body) };
   },
+  refsDir({ scope, projectDir, home }, skillName) {
+    const root = scope === "global" ? join(home, ".claude") : join(projectDir, ".claude");
+    return join(root, "skills", skillName, "references");
+  },
   postInstall({ scope, projectDir, home, dryRun }) {
     const root = scope === "global" ? join(home, ".claude") : join(projectDir, ".claude");
     const hookFile = join(root, "hooks", "session-start.ts");
@@ -166,6 +171,10 @@ var target2 = {
     if (data.tools)
       fm.tools = data.tools;
     return { relPath: `${data.name}.md`, text: stringifyFrontmatter(fm, body) };
+  },
+  refsDir({ scope, projectDir, home }, skillName) {
+    const root = scope === "global" ? join2(home, ".config", "opencode") : join2(projectDir, ".opencode");
+    return join2(root, "skills", skillName, "references");
   }
 };
 
@@ -190,6 +199,9 @@ var target3 = {
       relPath: `${data.name}.md`,
       text: stringifyFrontmatter({ name: data.name, description: data.description }, body)
     };
+  },
+  refsDir(_opts, skillName) {
+    return join3(_opts.projectDir, ".mugiwara", "refs", skillName);
   }
 };
 
@@ -197,11 +209,13 @@ var target3 = {
 import { existsSync as existsSync2, writeFileSync } from "node:fs";
 import { join as join4 } from "node:path";
 function makeGeneric(opts) {
-  const { id, label, rulesDir, bootstrapFile, bootstrapPointer } = opts;
+  const { id, label, rulesDir, bootstrapFile, bootstrapPointer, tier = bootstrapPointer ? 2 : 3 } = opts;
+  const stubOnly = tier === 3;
   return {
     id,
     label,
     native: false,
+    tier,
     paths({ scope, projectDir }) {
       if (scope === "global")
         throw new Error(`${label} supports project scope only`);
@@ -209,6 +223,27 @@ function makeGeneric(opts) {
       return { skillsDir: dir, agentsDir: dir };
     },
     transformSkill(data, body) {
+      if (stubOnly) {
+        return {
+          relPath: `${data.name}.md`,
+          text: `# ${data.name}
+
+> ${data.description}
+
+## Skip when
+
+Full skill: \`${data.name}\` — read \`.mugiwara/refs/${data.name}.md\` when the crew invokes this role.`
+        };
+      }
+      return { relPath: `${data.name}.md`, text: `# ${data.name}
+
+> ${data.description}
+
+${body}` };
+    },
+    transformSkillFull(data, body) {
+      if (!stubOnly)
+        return null;
       return { relPath: `${data.name}.md`, text: `# ${data.name}
 
 > ${data.description}
@@ -216,6 +251,16 @@ function makeGeneric(opts) {
 ${body}` };
     },
     transformAgent(data, body) {
+      if (stubOnly) {
+        return {
+          relPath: `agent-${data.name}.md`,
+          text: `# Agent: ${data.name}
+
+> ${data.description}
+
+Skills: ${data.skills ?? ""}. Read \`.mugiwara/refs/${data.name}.md\` when embodying this role.`
+        };
+      }
       return { relPath: `agent-${data.name}.md`, text: `# Agent: ${data.name}
 
 > ${data.description}
@@ -224,6 +269,20 @@ Skills used: ${data.skills ?? ""}
 
 ${body}` };
     },
+    transformAgentFull(data, body) {
+      if (!stubOnly)
+        return null;
+      return { relPath: `${data.name}.md`, text: `# Agent: ${data.name}
+
+> ${data.description}
+
+Skills used: ${data.skills ?? ""}
+
+${body}` };
+    },
+    refsDir({ projectDir }) {
+      return join4(projectDir, ".mugiwara", "refs");
+    },
     postInstall({ projectDir, dryRun }) {
       if (!bootstrapFile)
         return { written: [], notes: [] };
@@ -289,7 +348,8 @@ var target8 = makeGeneric({
   "instructions": [
     ".kilo/rules/*.md"
   ]
-}`
+}`,
+  tier: 3
 });
 
 // src/targets/antigravity.ts
@@ -316,14 +376,20 @@ function collectContent() {
   const skillNames = readdirSync(join5(CONTENT_DIR, "skills"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   const skills = skillNames.map((name) => {
     const { data, body } = parseFrontmatter(readFileSync2(join5(CONTENT_DIR, "skills", name, "SKILL.md"), "utf8"));
-    return { name, data, body };
+    return { name, data, body, refs: collectRefs(join5(CONTENT_DIR, "skills", name)) };
   });
   const agents = readdirSync(join5(CONTENT_DIR, "agents")).filter((f) => f.endsWith(".md")).map((f) => {
     const { data, body } = parseFrontmatter(readFileSync2(join5(CONTENT_DIR, "agents", f), "utf8"));
-    return { name: f.replace(/\.md$/, ""), data, body };
+    return { name: f.replace(/\.md$/, ""), data, body, refs: [] };
   });
   return { skills, agents };
 }
+function collectRefs(skillDir) {
+  const refsDir = join5(skillDir, "references");
+  if (!existsSync3(refsDir))
+    return [];
+  return readdirSync(refsDir, { recursive: true }).map((f) => String(f)).filter((f) => f.endsWith(".md")).map((rel) => ({ relPath: rel, text: readFileSync2(join5(refsDir, rel), "utf8") }));
+}
 function installTo(target10, opts) {
   const { scope, projectDir, dryRun = false, force = false } = opts;
   const home = opts.home ?? homedir();
@@ -360,11 +426,26 @@ function installTo(target10, opts) {
     const out = target10.transformSkill(s.data, s.body);
     if (out)
       writeOne(join5(dirs.skillsDir, out.relPath), out.text);
+    if (target10.transformSkillFull) {
+      const full = target10.transformSkillFull(s.data, s.body);
+      if (full && target10.refsDir)
+        writeOne(join5(target10.refsDir({ scope, projectDir, home }, s.name), full.relPath), full.text);
+    }
+    if (s.refs.length && target10.refsDir) {
+      const refsRoot = target10.refsDir({ scope, projectDir, home }, s.name);
+      for (const r of s.refs)
+        writeOne(join5(refsRoot, r.relPath), r.text);
+    }
   }
   for (const a of agents) {
     const out = target10.transformAgent(a.data, a.body);
     if (out)
       writeOne(join5(dirs.agentsDir, out.relPath), out.text);
+    if (target10.transformAgentFull) {
+      const full = target10.transformAgentFull(a.data, a.body);
+      if (full && target10.refsDir)
+        writeOne(join5(target10.refsDir({ scope, projectDir, home }, a.name), full.relPath), full.text);
+    }
   }
   if (target10.postInstall) {
     const post = target10.postInstall({ scope, projectDir, home, dryRun, files: result.written });
@@ -412,6 +493,62 @@ function writeManifest(file, data) {
 `);
 }
 
+// src/mission.ts
+import { existsSync as existsSync5, rmSync as rmSync2, readFileSync as readFileSync4 } from "node:fs";
+import { join as join7 } from "node:path";
+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", "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)) {
+      rmSync2(p, { recursive: true, force: true });
+      removed.push("logs");
+    }
+  } else if (existsSync5(join7(root, "logs"))) {
+    kept.push("logs");
+  }
+  for (const f of ["config", "manifest.json", "backup"]) {
+    if (existsSync5(join7(root, f)))
+      kept.push(f);
+  }
+  return { removed, kept };
+}
+
 // src/cli.ts
 var str = (v) => typeof v === "string" ? v : undefined;
 var flag = (v) => v === true;
@@ -432,12 +569,27 @@ async function run(argv) {
       return uninstall(flags);
     case "list":
       return list(flags);
-    case "skills":
-      return skills();
+    case "reset":
+      return resetCmd(flags);
     default:
       throw new Error(`Unknown command: ${command}`);
   }
 }
+function resetCmd(flags) {
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  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 (result.kept.length)
+    console.log(`kept: ${result.kept.join(", ")}`);
+}
 async function resolveOptions(flags) {
   const interactive = !flag(flags.yes);
   const rl = interactive ? createRl() : null;
@@ -449,7 +601,7 @@ async function resolveOptions(flags) {
       scope = await choose(rl, "Install scope?", ["global (user-wide)", "project (this repo)"]) === 0 ? "global" : "project";
     }
     const projectDir = resolve(str(flags.project) ?? process.cwd());
-    if (scope === "project" && !existsSync5(projectDir))
+    if (scope === "project" && !existsSync6(projectDir))
       throw new Error(`Project dir not found: ${projectDir}`);
     let targetIds = str(flags.target)?.split(",").map((s) => s.trim()) ?? null;
     if (targetIds && targetIds.includes("all"))
@@ -533,7 +685,7 @@ async function uninstall(flags) {
   }
   const removed = removeInstalled(manifest, { dryRun: flag(flags.dryRun) });
   if (!flag(flags.dryRun))
-    rmSync2(file);
+    rmSync3(file);
   console.log(`OK removed ${removed.length} files`);
 }
 function list(flags) {
@@ -553,22 +705,6 @@ function list(flags) {
   if (!found)
     console.log("No mugiwara installation found.");
 }
-function skills() {
-  const dir = join7(CONTENT_DIR, "skills");
-  const names = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
-  const rows = names.map((name) => {
-    const { data } = parseFrontmatter(readFileSync4(join7(dir, name, "SKILL.md"), "utf8"));
-    return [name, data.description ?? ""];
-  });
-  const w = Math.max(...rows.map((r) => r[0].length)) + 2;
-  console.log(`mugiwara ${VERSION} — ${rows.length} skills (agentskills.io format):
-`);
-  for (const [name, description] of rows)
-    console.log(`  ${name.padEnd(w)}${description}`);
-  console.log(`
-Install skills into any agent via skills.sh:
-  npx skills add ionivetech/mugiwara`);
-}
 function help() {
   console.log(`mugiwara ${VERSION} — the Straw Hat crew for AI agents
 
@@ -577,7 +713,7 @@ Usage:
   mugiwara update        replace existing files (backs up differences first)
   mugiwara uninstall     remove installed files via manifest
   mugiwara list          show installations
-  mugiwara skills        list installable skills (agentskills.io)
+  mugiwara reset         wipe mission state (spec/plans/results/review/issues[/logs])
   mugiwara --help        this help
   mugiwara --version     print version
 
@@ -587,7 +723,8 @@ Flags:
   --target <ids|all>     comma-separated: ${TARGET_IDS.join(", ")}
   --yes, -y              non-interactive (needs --global/--project, --target)
   --force                overwrite differing files (with backup)
-  --dry-run              print actions without writing`);
+  --dry-run              print actions without writing
+  --keep-logs            with reset: keep .mugiwara/logs (lessons ledger survives)`);
 }
 var entry = process.argv[1] !== undefined ? resolve(process.argv[1]) : undefined;
 if (entry !== undefined) {

package/docs/adoption-guide.md

@@ -43,8 +43,8 @@ mid-wave.
 
 ## Fit the crew to your workflow
 
-- **Trivial one-liners** don't need the crew — Luffy routes them straight to
-  execution.
+- **Trivial one-liners** don't need the crew's full pipeline — Luffy routes them
+  to Lane 0 and they run with zero waves. The process scales to the work.
 - **Medium features** run the standard pipeline: triage → plan → execute →
   checkpoint → quality → gates → review → closure.
 - **High-stakes work** (money, security, data, public API) always gets the full

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.

package/docs/audit-trail.md

@@ -0,0 +1,65 @@
+# Audit Trail
+
+Every artifact the Mugiwara crew produces — what writes it, when, and how to
+read it as a reviewer.
+
+## The artifacts
+
+| Artifact | Path | Written by | When | For |
+|----------|------|-----------|------|-----|
+| **Plan doc** | `.mugiwara/plans/YYYY-MM-DD-<mission>.md` | Nami (planning) | Wave 2 | Zero-context executor — waves, tasks, criteria, risk |
+| **Spec** | `.mugiwara/spec/YYYY-MM-DD-<mission>.md` | Usopp (brainstorm) / Luffy (spec bridge) | Wave 0–1 | Bridge from idea to plan — goal, acceptance, constraints |
+| **State** | `.mugiwara/state.json` | `scripts/savepoint.sh` | Every wave boundary | Computed mission state: lane, wave, files, blockers, token budget, evidence paths |
+| **Decision log** | `.mugiwara/logs/YYYY-MM-DD-<mission>.md` | Luffy (orchestrator) | Every wave | Route reason, check-in verdicts, mode flips, decisions |
+| **Blocker ledger** | `.mugiwara/issues/YYYY-MM-DD-<mission>-blockers.md` | Any agent | On blocker hit | Row per blocker: wave, task, symptom, attempted, help-needed |
+| **Todo list** | `.mugiwara/results/<mission>-todos.md` | Zoro (execution) | Wave 3 | Checkbox per task, checked with evidence pointer |
+| **Audit report** | `.mugiwara/results/YYYY-MM-DD-<mission>-audit.md` | Chopper (checkpoint) | Wave 4 | Per-task evidence, commit hygiene, parallel-conflict, honest classification |
+| **Quality report** | `.mugiwara/results/YYYY-MM-DD-<mission>-quality.md` | Sanji (quality) | Wave 5 | Formatter/linter/unit/user-test results |
+| **Gate verdict** | `.mugiwara/results/YYYY-MM-DD-<mission>-gates.md` | Franky (gates) | Wave 6 | Coverage thresholds from config, build exit, DoD verdict |
+| **Review findings** | `.mugiwara/review/YYYY-MM-DD-<mission>-review.md` | Robin (review) | Wave 7 | Severity-tagged: path:line → problem → fix |
+| **Security report** | `.mugiwara/review/YYYY-MM-DD-<mission>-security.md` | Jinbe (security) | Wave 7 | STRIDE, OWASP mapping, checklist, CVSS severity |
+| **Heal report** | `.mugiwara/results/YYYY-MM-DD-<mission>-heal.md` | Brook (healing) | Wave 8 | Fixed list, escalated list, updated ledger |
+| **Closure report** | `.mugiwara/results/YYYY-MM-DD-<mission>-closure.md` | Luffy (orchestrator) | Wave 9 | Mission summary, per-wave outcomes, deferred items, lessons |
+| **Mission report** | `.mugiwara/reports/YYYY-MM-DD-<mission>.md` | `scripts/mission-report.sh` | Wave 9 | Human-readable summary: what changed, gates, state, token cost |
+| **PR verdict** | `.mugiwara/results/YYYY-MM-DD-<mission>-pr-verdict.md` | Luffy (orchestrator) | Wave 9 | Ready PR summary block for the user to open the PR |
+| **Trace** | `.mugiwara/results/<mission>-trace.md` | Resume coordinator | Every dispatch | Dispatch → outcome — drives resume (legacy; state.json preferred) |
+| **Lessons ledger** | `.mugiwara/logs/lessons.md` | Memory Keeper | Cross-mission | One row per real lesson, append-only, all actors share |
+| **Evidence logs** | `.mugiwara/results/<label>-<hash>.log` | `scripts/evidence.sh` | On demand | Command stdout/stderr capture with timestamp and exit code |
+
+## How to read as a reviewer
+
+1. **Start with the mission report** (`reports/`) — one file, what changed, gates, token cost.
+2. **Check the gate verdict** (`results/<mission>-gates.md`) — coverage from config, build, DoD. Any FAIL needs explanation.
+3. **Spot-check the audit report** (`results/<mission>-audit.md`) — did Chopper re-run checks or accept claims? Every criterion gets a command run + evidence row.
+4. **Review findings count** (`review/`) — how many blocker/major/minor? Were they healed? Check the heal report for closure.
+5. **State.json** for raw numbers — lane, wave, files, blockers open, heal cycle, token budget status (ok/warn/stop).
+
+## What stays after cleanup
+
+After Wave 9 closure (run via `mugiwara-ship` cleanup procedure):
+
+**Kept** (audit trail + PR material):
+- `config` — runtime config
+- `plans/<mission>.md` — clean plan doc
+- `results/<mission>-closure.md` — closure report
+- `results/<mission>-pr-verdict.md` — PR material
+- `reports/<mission>.md` — mission report
+- `state.json` — final mission state (unless another actor's mission is active)
+- `logs/lessons.md` — cross-mission lessons
+- `backup/`, `manifest.json` — harness config
+
+**Deleted** (consumed/superseded):
+- `spec/<mission>.md` — consumed by planning
+- `results/<mission>-todos.md` — consumed
+- `results/<mission>-audit.md` — superseded by closure
+- `results/<mission>-quality.md` — consumed
+- `results/<mission>-gates.md` — consumed
+- `results/<mission>-heal.md` — consumed
+- `results/<mission>-trace.md` — consumed (state.json is canonical)
+- `review/<mission>-review.md` — consumed
+- `review/<mission>-security.md` — consumed
+- `issues/<mission>-blockers.md` — consumed
+- `logs/<mission>.md` — decision log, per-mission
+
+Cleanup lists candidates first (dry-run), then deletes. A mission is only
+closed after cleanup runs.