@ionivetech/mugiwara 0.5.4 → 0.6.0

package/src/installer.ts

@@ -2,6 +2,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, copyFileSync, rmSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
 import { parseFrontmatter, type FrontmatterData } from './frontmatter.ts';
 import type { Scope } from './manifest.ts';
 
@@ -10,6 +11,7 @@ export type ContentItem = {
   data: FrontmatterData;
   body: string;
   refs: { relPath: string; text: string }[];
+  internal?: boolean;
 };
 
 export type InstallOptions = {
@@ -34,6 +36,7 @@ export interface Target {
   label: string;
   native: boolean;
   tier?: 1 | 2 | 3;
+  refPointerPrefix?: string;
   paths(opts: { scope: Scope; projectDir: string; home: string }): { skillsDir: string; agentsDir: string };
   transformSkill(data: FrontmatterData, body: string): TransformOut;
   transformAgent(data: FrontmatterData, body: string): TransformOut;
@@ -43,11 +46,11 @@ export interface Target {
   postInstall?(opts: { scope: Scope; projectDir: string; home: string; dryRun: boolean; files: string[] }): { written: string[]; notes: string[] };
 }
 
-export const CONTENT_DIR = join(import.meta.dirname, '..', 'content');
-const pkg = JSON.parse(readFileSync(join(import.meta.dirname, '..', 'package.json'), 'utf8')) as { version: string };
+export const CONTENT_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'content');
+const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8')) as { version: string };
 export const VERSION = pkg.version;
 
-export function collectContent(): { skills: ContentItem[]; agents: ContentItem[] } {
+export function collectContent(): { skills: ContentItem[]; agents: ContentItem[]; sharedRefs: { relPath: string; text: string }[] } {
   const skillNames = readdirSync(join(CONTENT_DIR, 'skills'), { withFileTypes: true })
     .filter(e => e.isDirectory()).map(e => e.name);
   const skills = skillNames.map(name => {
@@ -58,9 +61,17 @@ export function collectContent(): { skills: ContentItem[]; agents: ContentItem[]
     .filter(f => f.endsWith('.md'))
     .map(f => {
       const { data, body } = parseFrontmatter(readFileSync(join(CONTENT_DIR, 'agents', f), 'utf8'));
-      return { name: f.replace(/\.md$/, ''), data, body, refs: [] as { relPath: string; text: string }[] };
+      return { name: f.replace(/\.md$/, ''), data, body, refs: [] as { relPath: string; text: string }[], internal: data.internal === 'true' };
     });
-  return { skills, agents };
+  const sharedRefsDir = join(dirname(CONTENT_DIR), 'references');
+  const sharedRefs: { relPath: string; text: string }[] = [];
+  if (existsSync(sharedRefsDir)) {
+    for (const f of readdirSync(sharedRefsDir)) {
+      if (!f.endsWith('.md')) continue;
+      sharedRefs.push({ relPath: f, text: readFileSync(join(sharedRefsDir, f), 'utf8') });
+    }
+  }
+  return { skills, agents, sharedRefs };
 }
 
 function collectRefs(skillDir: string): { relPath: string; text: string }[] {
@@ -73,7 +84,7 @@ function collectRefs(skillDir: string): { relPath: string; text: string }[] {
 export function installTo(target: Target, opts: InstallOptions): InstallResult {
   const { scope, projectDir, dryRun = false, force = false } = opts;
   const home = opts.home ?? homedir();
-  const { skills, agents } = collectContent();
+  const { skills, agents, sharedRefs } = collectContent();
   const dirs = target.paths({ scope, projectDir, home });
   const backupRoot = join(scope === 'global' ? home : projectDir, '.mugiwara');
   const result: InstallResult = { written: [], skipped: [], backedUp: [], notes: [] };
@@ -87,8 +98,10 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
         return;
       }
       const ts = new Date().toISOString().replace(/[:.]/g, '-');
-      const backupFile = join(backupRoot, 'backup', ts, absPath.replace(/[^a-zA-Z0-9]+/g, '_'));
-      if (!dryRun) { mkdirSync(dirname(backupFile), { recursive: true }); copyFileSync(absPath, backupFile); }
+      const fileName = absPath.replace(/[^a-zA-Z0-9]+/g, '_');
+      const backupDir = join(backupRoot, 'backup', `${ts}-${target.id}`);
+      const backupFile = join(backupDir, fileName);
+      if (!dryRun) { mkdirSync(backupDir, { recursive: true }); copyFileSync(absPath, backupFile); }
       result.backedUp.push(absPath);
     }
     if (!dryRun) { mkdirSync(dirname(absPath), { recursive: true }); writeFileSync(absPath, text); }
@@ -97,10 +110,22 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
 
   for (const s of skills) {
     const out = target.transformSkill(s.data, s.body);
-    if (out) writeOne(join(dirs.skillsDir, out.relPath), out.text);
+    if (out) {
+      let text = out.text;
+      if (target.refPointerPrefix !== undefined && target.refPointerPrefix !== '') {
+        text = text.replace(/`_shared\/references\//g, '`' + target.refPointerPrefix + '_shared/references/');
+      }
+      writeOne(join(dirs.skillsDir, out.relPath), text);
+    }
     if (target.transformSkillFull) {
       const full = target.transformSkillFull(s.data, s.body);
-      if (full && target.refsDir) writeOne(join(target.refsDir({ scope, projectDir, home }, s.name), full.relPath), full.text);
+      if (full && target.refsDir) {
+        let text = full.text;
+        if (target.refPointerPrefix !== undefined && target.refPointerPrefix !== '') {
+          text = text.replace(/`_shared\/references\//g, '`' + target.refPointerPrefix + '_shared/references/');
+        }
+        writeOne(join(target.refsDir({ scope, projectDir, home }, s.name), full.relPath), text);
+      }
     }
     if (s.refs.length && target.refsDir) {
       const refsRoot = target.refsDir({ scope, projectDir, home }, s.name);
@@ -108,7 +133,7 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
     }
   }
   for (const a of agents) {
-    const out = target.transformAgent(a.data, a.body);
+    const out = target.transformAgent({ ...a.data, ...(a.internal ? { 'internal-agent': 'true' } : {}) }, a.body);
     if (out) writeOne(join(dirs.agentsDir, out.relPath), out.text);
     if (target.transformAgentFull) {
       const full = target.transformAgentFull(a.data, a.body);
@@ -116,6 +141,11 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
     }
   }
 
+  if (sharedRefs.length) {
+    const sharedRoot = join(dirs.skillsDir, '_shared', 'references');
+    for (const r of sharedRefs) writeOne(join(sharedRoot, r.relPath), r.text);
+  }
+
   if (target.postInstall) {
     const post = target.postInstall({ scope, projectDir, home, dryRun, files: result.written });
     result.written.push(...post.written);
@@ -133,10 +163,9 @@ export function removeInstalled(manifest: { files: string[] }, { dryRun = false
     for (const f of manifest.files) {
       let d = dirname(f);
       while (existsSync(d) && readdirSync(d).length === 0) {
-        rmSync(d, { recursive: true });
-        const parent = dirname(d);
-        if (parent === d) break;
-        d = parent;
+        if (d.endsWith('/.mugiwara') || d === dirname(d)) break;
+        rmSync(d, { recursive: true, force: true });
+        d = dirname(d);
       }
     }
   }

package/src/mission.ts

@@ -1,6 +1,6 @@
 // src/mission.ts
 // Mission-state helpers for the mugiwara CLI (installer + reset only).
-import { existsSync, rmSync, readFileSync } from 'node:fs';
+import { existsSync, rmSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
 function activeActor(projectDir: string): string | null {
@@ -30,10 +30,12 @@ export function resetMission(projectDir: string, keepLogs: boolean, force?: bool
     const p = join(root, dir);
     if (existsSync(p)) { rmSync(p, { recursive: true, force: true }); removed.push(dir); }
   }
-  // mission state files
-  for (const f of ['state.json']) {
-    const p = join(root, f);
-    if (existsSync(p)) { rmSync(p); removed.push(f); }
+  // mission state files — state.json + branch-specific state-*.json
+  for (const f of readdirSync(root)) {
+    if (/^state(-.+)?\.json$/.test(f)) {
+      const p = join(root, f);
+      if (existsSync(p)) { rmSync(p); removed.push(f); }
+    }
   }
   if (!keepLogs) {
     const p = join(root, 'logs');

package/src/targets/claude.ts

@@ -1,5 +1,5 @@
 // src/targets/claude.ts
-import { existsSync, readFileSync, mkdirSync, copyFileSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, copyFileSync, chmodSync, readdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { stringifyFrontmatter, type FrontmatterData } from '../frontmatter.ts';
@@ -7,11 +7,13 @@ import type { Target } from '../installer.ts';
 
 const here = dirname(fileURLToPath(import.meta.url));
 const HOOK_SRC = join(here, '..', '..', 'hooks', 'session-start.ts');
+const COMMANDS_SRC = join(here, '..', '..', '.claude', 'commands');
 
 export const target: Target = {
   id: 'claude',
   label: 'Claude Code',
   native: true,
+  refPointerPrefix: '../',
   paths({ scope, projectDir, home }) {
     const root = scope === 'global' ? join(home, '.claude') : join(projectDir, '.claude');
     return { skillsDir: join(root, 'skills'), agentsDir: join(root, 'agents') };
@@ -35,12 +37,27 @@ export const target: Target = {
     // Wire the SessionStart hook (inline doctrine) into the installed .claude dir.
     const root = scope === 'global' ? join(home, '.claude') : join(projectDir, '.claude');
     const hookFile = join(root, 'hooks', 'session-start.ts');
+    const written: string[] = [];
+    const notes: string[] = [];
     if (dryRun) return { written: [], notes: [] };
     if (existsSync(HOOK_SRC) && !existsSync(hookFile)) {
       mkdirSync(dirname(hookFile), { recursive: true });
       copyFileSync(HOOK_SRC, hookFile);
-      return { written: [hookFile], notes: [] };
+      chmodSync(hookFile, 0o755);
+      written.push(hookFile);
     }
-    return { written: [], notes: [] };
+    // Port the /mugiwara commands into the installed .claude dir.
+    if (existsSync(COMMANDS_SRC)) {
+      const dstDir = join(root, 'commands');
+      mkdirSync(dstDir, { recursive: true });
+      for (const f of readdirSync(COMMANDS_SRC)) {
+        if (!f.endsWith('.md')) continue;
+        const src = join(COMMANDS_SRC, f);
+        const dst = join(dstDir, f);
+        if (!existsSync(dst)) { copyFileSync(src, dst); written.push(dst); }
+        else notes.push(`existing command kept: ${dst}`);
+      }
+    }
+    return { written, notes };
   },
 };

package/src/targets/generic.ts

@@ -44,7 +44,7 @@ export function makeGeneric(opts: {
       if (stubOnly) {
         return {
           relPath: `agent-${data.name}.md`,
-          text: `# Agent: ${data.name}\n\n> ${data.description}\n\nSkills: ${data.skills ?? ''}. Read \`.mugiwara/refs/${data.name}.md\` when embodying this role.`,
+          text: `# Agent: ${data.name}\n\n> ${data.description}\n\nSkills: ${data.skills ?? ''}. Read \`.mugiwara/refs/${data.name}.md\` when embodying this role.\n\nOnly zoro-execution and brook-healing may modify source code.\nReturn your output to luffy-orchestrator; do not choose the next step.`,
         };
       }
       return { relPath: `agent-${data.name}.md`, text: `# Agent: ${data.name}\n\n> ${data.description}\n\nSkills used: ${data.skills ?? ''}\n\n${body}` };

package/src/targets/opencode.ts

@@ -1,8 +1,13 @@
 // src/targets/opencode.ts
-import { join } from 'node:path';
+import { existsSync, readdirSync, copyFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { stringifyFrontmatter, type FrontmatterData } from '../frontmatter.ts';
 import type { Target } from '../installer.ts';
 
+const here = dirname(fileURLToPath(import.meta.url));
+const COMMANDS_SRC = join(here, '..', '..', '.opencode', 'commands');
+
 type CrewConfig = {
   color: string;
   temperature: number;
@@ -15,26 +20,45 @@ const CREW: Record<string, CrewConfig> = {
   'usopp-brainstorm': { color: '#f59e0b', temperature: 0.6, steps: 15 },
   'nami-planner': { color: '#f97316', temperature: 0.2, steps: 15 },
   'zoro-execution': { color: '#22c55e', temperature: 0.1, steps: 30 },
-  'chopper-checkpoint': { color: '#3b82f6', temperature: 0.1, permission: { edit: 'deny' }, steps: 15 },
-  'sanji-quality': { color: '#a855f7', temperature: 0.1, permission: { edit: 'deny' }, steps: 10 },
-  'franky-gates': { color: '#06b6d4', temperature: 0.1, permission: { edit: 'deny' }, steps: 10 },
-  'robin-reviewer': { color: '#8b5cf6', temperature: 0.2, permission: { edit: 'deny' }, steps: 15 },
-  'jinbe-security': { color: '#6366f1', temperature: 0.2, permission: { edit: 'deny' }, steps: 15 },
+  'chopper-checkpoint': { color: '#3b82f6', temperature: 0.1, steps: 15 },
+  'sanji-quality': { color: '#a855f7', temperature: 0.1, steps: 10 },
+  'franky-gates': { color: '#06b6d4', temperature: 0.1, steps: 10 },
+  'robin-reviewer': { color: '#8b5cf6', temperature: 0.2, steps: 15 },
+  'jinbe-security': { color: '#6366f1', temperature: 0.2, steps: 15 },
   'brook-healing': { color: '#ec4899', temperature: 0.1, steps: 20 },
-  'skeptic-verifier': { color: '#64748b', temperature: 0.1, permission: { edit: 'deny' }, steps: 12 },
+  'skeptic-verifier': { color: '#64748b', temperature: 0.1, steps: 12 },
   'eval-runner': { color: '#14b8a6', temperature: 0.2, steps: 15 },
   'resume-coordinator': { color: '#d97706', temperature: 0.2, steps: 10 },
   'memory-keeper': { color: '#d946ef', temperature: 0.2, steps: 8 },
 };
 
-function agentFrontmatter(name: string, description: string) {
+// write-scope is the single source of truth (content/agents/*.md frontmatter).
+// The path boundary (artifacts vs source) IS expressible in opencode:
+// permission.edit accepts glob/pattern -> action, last match wins. Artifacts
+// agents get deny-all-edit except .mugiwara/**; source agents (zoro, brook)
+// get full edit allow. Derived at install time from the frontmatter field.
+function permissionFromScope(scope: string | undefined): Record<string, string | Record<string, string>> | undefined {
+  if (scope === 'source') return { edit: 'allow' };
+  if (scope === 'artifacts') return { edit: { '*': 'deny', '.mugiwara/**': 'allow' } };
+  return undefined;
+}
+
+function agentFrontmatter(name: string, description: string, writeScope?: string) {
   const crew = CREW[name];
   const lines = [`description: ${description}`, `mode: all`];
   if (crew) {
     lines.push(`color: '${crew.color}'`, `temperature: ${crew.temperature}`, `steps: ${crew.steps}`);
-    if (crew.permission) {
+    const perm = permissionFromScope(writeScope);
+    if (perm) {
       lines.push('permission:');
-      for (const [k, v] of Object.entries(crew.permission)) lines.push(`  ${k}: ${v}`);
+      for (const [k, v] of Object.entries(perm)) {
+        if (typeof v === 'string') {
+          lines.push(`  ${k}: ${v}`);
+        } else {
+          lines.push(`  ${k}:`);
+          for (const [pk, pv] of Object.entries(v)) lines.push(`    "${pk}": ${pv}`);
+        }
+      }
     }
   }
   return lines.join('\n');
@@ -44,6 +68,7 @@ export const target: Target = {
   id: 'opencode',
   label: 'opencode',
   native: true,
+  refPointerPrefix: '../',
   paths({ scope, projectDir, home }) {
     const root = scope === 'global' ? join(home, '.config', 'opencode') : join(projectDir, '.opencode');
     return { skillsDir: join(root, 'skills'), agentsDir: join(root, 'agents') };
@@ -55,11 +80,28 @@ export const target: Target = {
     };
   },
   transformAgent(data: FrontmatterData, body: string) {
-    const fm = agentFrontmatter(data.name, data.description);
+    const desc = data['internal-agent'] === 'true' ? `[INTERNAL] ${data.description}` : data.description;
+    const fm = agentFrontmatter(data.name, desc, data['write-scope']);
     return { relPath: `${data.name}.md`, text: `---\n${fm}\n---\n${body}` };
   },
   refsDir({ scope, projectDir, home }, skillName: string) {
     const root = scope === 'global' ? join(home, '.config', 'opencode') : join(projectDir, '.opencode');
     return join(root, 'skills', skillName, 'references');
   },
+  postInstall({ scope, projectDir, home, dryRun }) {
+    const root = scope === 'global' ? join(home, '.config', 'opencode') : join(projectDir, '.opencode');
+    const dstDir = join(root, 'commands');
+    if (dryRun) return { written: [], notes: [] };
+    if (!existsSync(COMMANDS_SRC)) return { written: [], notes: [] };
+    mkdirSync(dstDir, { recursive: true });
+    const written: string[] = [];
+    for (const f of readdirSync(COMMANDS_SRC)) {
+      if (!f.endsWith('.md')) continue;
+      const src = join(COMMANDS_SRC, f);
+      const dst = join(dstDir, f);
+      copyFileSync(src, dst);
+      written.push(dst);
+    }
+    return { written, notes: [] };
+  },
 };

package/docs/adoption-guide.md

@@ -1,72 +0,0 @@
-# Adoption Guide
-
-How to take the crew into your workflow without fighting it.
-
-## Pick your harness
-
-The crew ships native skills + agents where the harness supports them, and
-markdown rule files everywhere else.
-
-| Situation | Pick |
-|-----------|------|
-| You live in Claude Code or opencode | Native install — agents + skills + (Claude) session hook |
-| You want the full crew pipeline | Claude Code, opencode |
-| You want skills-only, any tool | `npx skills add ionivetech/mugiwara` (agentskills.io layout) |
-| You only use one niche tool | Its per-harness guide (index → install by harness) |
-
-Native targets (Claude Code, opencode, Copilot) register the 14 agents directly.
-Rule-based targets (Gemini, Codex, Cursor, Windsurf, Cline, Kilo, Antigravity)
-get the same 32 skills as markdown rules plus a bootstrap pointer, so the crew
-is still steered even where subagents don't exist.
-
-## Pick your mode
-
-Modes live in `.mugiwara/config` (project) or `~/.mugiwara/config` (global):
-
-```
-mode=guided
-branch=feature/{type}-{issue}-{slug}
-commit=conventional
-```
-
-| Level | What it asks you |
-|-------|------------------|
-| `guided` | Plan GO, branch, commits, ambiguities, check-ins — everything |
-| `semi` | Plan GO only; branch/commits/ambiguities self-answer and log |
-| `auto` | Nothing, unless a high-risk task exists (auto-GO is gated) |
-
-State-mutating tests against shared state (real DB writes, network, browsers)
-always need your explicit consent — in every mode. That consent is not a knob.
-
-Missing config on read = `guided`. A flip applies from the next wave, never
-mid-wave.
-
-## Fit the crew to your workflow
-
-- **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
-  pipeline, including Skeptic's adversarial pass and Brook's heal loop.
-- **Repos the crew has touched before** read the lessons ledger at triage, so
-  every mission stands on the previous ones.
-
-## The execution model, in one sentence
-
-The crew runs **inline in your main conversation**; subagents are used only for
-independent `[PARALLEL]` task batches and background checks. You see every wave
-as it happens. See [execution-model.md](execution-model.md).
-
-## What the crew will never do
-
-- Merge a PR, or deploy. It pushes the branch and hands you the verdict file —
-  PR review is the terminal gate.
-- Auto-react to review comments or CI.
-- Let a wave pass on a spoken claim — evidence or it didn't happen.
-- Work around a blocker silently — everything lands in the ledger.
-
-## Going further
-
-- [Developer onboarding](developer-onboarding.md) if you want to contribute.
-- [Comparison](comparison.md) if you're weighing mugiwara against alternatives.

package/docs/agent-anatomy.md

@@ -1,72 +0,0 @@
-# Agent Anatomy
-
-Every mugiwara agent is a portable markdown file that names a crew member's
-persona, rules, and output contract. Agents are harness-native where supported
-(Claude Code, opencode) and markdown rule files elsewhere.
-
-## File structure
-
-```
-agents/<name>.md
-```
-
-```markdown
----
-name: chopper-checkpoint
-description: Dispatch after each execution wave to audit results against the plan - re-runs every acceptance criterion, verifies commit hygiene and parallel-file safety, classifies failures honestly, appends ledger rows, and issues a Definition-of-Done verdict. Auditor only; never fixes code.
-skills: mugiwara-checkpoint
----
-
-# Chopper — Checkpoint (Auditor)
-
-## Role
-...
-```
-
-## Frontmatter
-
-| Field | Required | Notes |
-|-------|----------|-------|
-| `name` | yes | lowercase, hyphen-separated; matches the file name |
-| `description` | yes | ≥20 chars; what this agent does and when to summon it |
-| `skills` | no | the crew skills this member holds, comma-separated |
-
-Harness-specific agents (opencode) may add `mode`, `permission`, `model`, etc.
-in their own installation copy — the content stays portable.
-
-## The body — house style
-
-Agents follow a fixed skeleton so every member reads the same way:
-
-1. **Role** — one paragraph: what the member does and the boundary it never
-   crosses ("Auditor, not fixer", "never implements code").
-2. **Experience** — a one-line persona so the model adopts the right instincts
-   ("QA lead who has caught 'works on my machine' for 20 years").
-3. **When dispatched** — which wave of `mugiwara-workflow` and with what inputs.
-4. **Rules** — numbered, each an action bound to its reason, deferring to the
-   held skill for the full protocol.
-5. **Output** — where the artifact lands (`.mugiwara/results/...`) and how it
-   routes.
-6. **Red flags** — behaviors that mean the member stopped doing its job.
-
-## Agent vs skill
-
-- A **skill** is the reusable playbook ("how to audit a wave").
-- An **agent** is the persona that applies it ("Chopper is the auditor; Chopper
-  never fixes code").
-
-One agent holds many skills (Zoro holds `mugiwara-execution`, `mugiwara-git`,
-`mugiwara-mode`, `mugiwara-testcases`, `mugiwara-backend`). When the crew runs
-inline, the main thread loads the member's skills and embodies the persona.
-
-## Validation
-
-Agents are validated alongside skills on check-in (name, description length,
-sync between `content/` and the repo-root plugin copies). Run:
-
-```bash
-bun run validate
-bun run validate --check-sync
-```
-
-See [developer-onboarding.md](developer-onboarding.md).

package/docs/agents.md

@@ -1,53 +0,0 @@
-# The Crew — 14 Agents
-
-Every agent is a focused specialist. The main thread embodies each role inline
-using its skill; you can also summon any member directly. "Dispatch" below
-means "route the mission to this role."
-
-The front door is the `using-mugiwara` skill — load it for crew overview.
-Slash command: `/using-mugiwara`.
-
-| Agent | Crew member | Role | Summon for |
-|-------|-------------|------|------------|
-| `luffy-orchestrator` | Luffy | Captain — 5-way triage, check-ins, decisions, closure | mission start, wave boundaries, escalations |
-| `usopp-brainstorm` | Usopp | Critical friend — interrogates, researches, no rubber-stamps | vague ideas, direction, options |
-| `nami-planner` | Nami | Planner — interview-first, full-context scan, scaled plans | turning an idea into an execution plan |
-| `zoro-execution` | Zoro | Executor — inline sequential tasks, parallel worker batches, evidence per task | executing an approved plan |
-| `chopper-checkpoint` | Chopper | Auditor — verify-everything, deduped re-runs, failure ledger | auditing a wave's results |
-| `sanji-quality` | Sanji | Quality — discover real tooling, format/lint/test | after checkpoint passes |
-| `franky-gates` | Franky | Gates — coverage, build, Definition of Done, binary verdicts | after quality checks |
-| `robin-reviewer` | Robin | Reviewer — doubt-driven diff review, breaking-change map first | after gates pass |
-| `jinbe-security` | Jinbe | Security — STRIDE, OWASP, secrets, injection, dependencies | security audit of a diff |
-| `brook-healing` | Brook | Healer — reads the ledger, root-cause fixes, ≤3 cycles | any wave produced failures |
-| `skeptic-verifier` | Skeptic | Adversarial verifier — doubts every output, does NOT validate | high-stakes verdicts, plans, reviews |
-| `eval-runner` | Eval Runner | Harness tester — task suites, judge-agent comparison | verifying mugiwara itself works |
-| `resume-coordinator` | Resume Coordinator | Resumer — rebuilds state from `.mugiwara/`, continues never restarts | context loss, new session mid-mission |
-| `memory-keeper` | Memory Keeper | Institutional memory — surfaces past lessons, captures new ones | mission start + closure |
-
-## How to summon
-
-Say a crew member's name in your request:
-
-```
-> Chopper, audit the last wave against the plan
-> Nami, plan this out
-```
-
-Luffy still records the route and its reason, and direct calls do not skip
-check-ins. The harness stays coherent either way.
-
-## Who never does what
-
-- **Luffy** never implements code.
-- **Chopper** never fixes findings — reports them.
-- **Skeptic** never validates — doubts.
-- **Robin/Jinbe** never implement — findings to Brook.
-- Crew members never dispatch each other. Workers are subagents, never crew.
-
-## The crew ships whole
-
-Every install gets all 14 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 26 techniques, or
-[workflow.md](workflow.md) for the pipeline.

package/docs/audit-trail.md

@@ -1,65 +0,0 @@
-# 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.

package/docs/claude-setup.md

@@ -1,43 +0,0 @@
-# Claude Code Setup
-
-Claude Code is a fully supported target — native skills + agents + SessionStart
-hook.
-
-## Install via the marketplace
-
-```bash
-/plugin marketplace add ionivetech/mugiwara
-/plugin install mugiwara
-```
-
-## Install via CLI (global or per project)
-
-```bash
-# global Claude Code install
-npx @ionivetech/mugiwara@latest --global --target claude --yes
-
-# project install
-npx @ionivetech/mugiwara@latest --project ./my-app --target claude --yes
-```
-
-**Update** — re-install from the marketplace (or `mugiwara update` via CLI).
-
-**Uninstall** — `/plugin uninstall mugiwara`, or `mugiwara uninstall` via CLI.
-
-## What you get
-
-- 32 skills in `~/.claude/skills/` (global) or `.claude/skills/` (project).
-- 14 agents in `~/.claude/agents/` or `.claude/agents/`.
-- A SessionStart hook that announces the crew and auto-activates the workflow —
-  a non-trivial request runs the pipeline by itself. `/using-mugiwara` is an
-  optional explicit router if you want to hand-route a mission.
-
-## Use it
-
-```
-> add dark mode to the settings page
-```
-
-The crew runs inline in your main conversation; subagents only for parallel
-batches. At closure the crew pushes the branch and hands you the PR verdict
-file with a ready PR summary block — you open the PR, in every mode.