@ionivetech/mugiwara 0.1.0

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

@@ -0,0 +1,90 @@
+---
+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.
+---
+
+# Mugiwara Workflow
+
+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 harness always runs through Luffy unless the user summons a crew member directly.
+
+## Workspace layout
+
+Every mission creates and works inside `.mugiwara/` at the repo root:
+
+```
+.mugiwara/
+├── spec/          # brainstorm output: YYYY-MM-DD-<mission>.md
+├── plans/         # plan doc: YYYY-MM-DD-<mission>.md — single source of truth from Wave 2
+├── results/       # wave results: audit reports, quality/gate reports, test output
+├── review/        # review + security findings
+├── issues/        # blocker log: YYYY-MM-DD-<mission>-blockers.md
+└── logs/          # Luffy's decision log
+```
+
+The owning agent creates the folder it needs on first write. No mission artifacts go outside `.mugiwara/`.
+
+## Resume
+
+At session start, after context loss, or on any "where were we?" — dispatch `resume-coordinator` (mugiwara-resume) BEFORE Wave 0 triage. It rebuilds the picture from disk (plan, todos, trace, blockers) and reports the resume point. Resume before any wave; never start over. Disk state is truth.
+
+## Wave 0 — Luffy Triage (always first)
+
+Front door: dispatch `using-mugiwara` (easy to remember) — it routes to the right crew member and records the route. For a full triage dispatch `luffy-orchestrator`. 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.
+
+## Waves
+
+| Wave | Owner | Skill | Output |
+|------|-------|-------|--------|
+| 0 Triage | Luffy | mugiwara-orchestration | route decision + reason |
+| 1 Brainstorm | Usopp | mugiwara-brainstorm | refined direction, options, recommendation |
+| 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 |
+| 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 |
+| 8 Healing | Brook | mugiwara-healing | fixes, then loop back to Wave 4 |
+| 9 Closure | Luffy | mugiwara-orchestration | closure report appended to plan |
+
+Wave 4.5 is optional — Luffy invokes Skeptic after Chopper on high-stakes missions (verdicts, plans, reviews), or parallel to Wave 7 review when he calls for it. Skip means recorded without a pass.
+
+## Blockers
+
+Any agent that hits a blocker APPENDS a row to `.mugiwara/issues/YYYY-MM-DD-<mission>-blockers.md`:
+
+`| <wave> | <task> | <symptom> | <attempted> | <help-needed> |`
+
+Never silently work around a blocker. Brook reads this ledger at Wave 8 to decide what to heal; Luffy reviews it at every check-in.
+
+## Cleanup
+
+At closure (Wave 9), delete unused intermediate markdown files in `.mugiwara/` — superseded results, review, and issues reports. Keep the plan doc and the closure report.
+
+## Rules
+
+1. Evidence over claims: no wave passes on assertion. The owning agent runs the checks and shows output.
+2. No wave skipped without the reason recorded in the plan doc.
+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 (re-dispatch `luffy-orchestrator`) for decisions and escalations.
+5. Wave 7 runs Robin and Jinbe in parallel.
+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 agent may hold many skills (e.g. Usopp holds `mugiwara-brainstorm` + `mugiwara-frontend`; the crew is 11 members); dispatch the agent, not the skill.
+9. On session start, context loss, or "where were we?" — resume before any wave via `resume-coordinator` (mugiwara-resume); never start over.
+
+## 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.
+
+## Red flags
+
+- A wave "passes" on a spoken claim with no command output or file to point at.
+- Heal loop beyond 3 cycles with the same failure still open.
+- A wave skipped with no reason recorded in the plan doc.
+- 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.
+
+All mean: stop the pipeline, diagnose with Chopper's ledger, decide continue / retry / escalate.

package/dist/mugiwara.js

@@ -0,0 +1,602 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, realpathSync, rmSync as rmSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join7, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/args.ts
+var VALUE_FLAGS = { "--project": "project", "--target": "target", "--type": "type" };
+var BOOL_FLAGS = {
+  "--global": "global",
+  "--yes": "yes",
+  "-y": "yes",
+  "--force": "force",
+  "--dry-run": "dryRun",
+  "--help": "help",
+  "-h": "help",
+  "--version": "version",
+  "-v": "version"
+};
+function parseArgs(argv) {
+  const out = { _: [], flags: {}, command: "install" };
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a in BOOL_FLAGS) {
+      out.flags[BOOL_FLAGS[a]] = true;
+      continue;
+    }
+    if (a in VALUE_FLAGS) {
+      const v = argv[++i];
+      if (v === undefined || v.startsWith("-"))
+        throw new Error(`Flag ${a} missing value`);
+      out.flags[VALUE_FLAGS[a]] = v;
+      continue;
+    }
+    if (a.startsWith("-"))
+      throw new Error(`Unknown flag: ${a}`);
+    out._.push(a);
+  }
+  out.command = out._[0] ?? "install";
+  return out;
+}
+
+// src/prompt.ts
+import readline from "node:readline/promises";
+function createRl() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+async function choose(rl, question, options) {
+  for (;; ) {
+    console.log(`
+${question}`);
+    options.forEach((o, i) => console.log(`  ${i + 1}) ${o}`));
+    const n = Number((await rl.question("choice> ")).trim());
+    if (Number.isInteger(n) && n >= 1 && n <= options.length)
+      return n - 1;
+    console.log(`Enter a number between 1 and ${options.length}.`);
+  }
+}
+async function multiChoose(rl, question, options) {
+  for (;; ) {
+    console.log(`
+${question} (comma-separated numbers, or "all")`);
+    options.forEach((o, i) => console.log(`  ${i + 1}) ${o}`));
+    const raw = (await rl.question("choices> ")).trim().toLowerCase();
+    if (raw === "all")
+      return options.map((_, i) => i);
+    const nums = raw.split(",").map((s) => Number(s.trim()));
+    if (nums.length > 0 && nums.every((n) => Number.isInteger(n) && n >= 1 && n <= options.length)) {
+      return [...new Set(nums.map((n) => n - 1))];
+    }
+    console.log("Invalid selection.");
+  }
+}
+async function confirm(rl, question) {
+  const raw = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+  return raw === "y" || raw === "yes";
+}
+
+// src/targets/claude.ts
+import { join } from "node:path";
+
+// src/frontmatter.ts
+function parseFrontmatter(text) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!m)
+    throw new Error("Missing frontmatter fence (---)");
+  const data = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    if (!line.trim())
+      continue;
+    const i = line.indexOf(":");
+    if (i === -1)
+      throw new Error(`Bad frontmatter line: ${line}`);
+    data[line.slice(0, i).trim()] = line.slice(i + 1).trim();
+  }
+  return { data, body: text.slice(m[0].length) };
+}
+function stringifyFrontmatter(data, body) {
+  const lines = Object.entries(data).map(([k, v]) => `${k}: ${v}`);
+  return `---
+${lines.join(`
+`)}
+---
+${body}`;
+}
+
+// src/targets/claude.ts
+var target = {
+  id: "claude",
+  label: "Claude Code",
+  native: true,
+  paths({ scope, projectDir, home }) {
+    const root = scope === "global" ? join(home, ".claude") : join(projectDir, ".claude");
+    return { skillsDir: join(root, "skills"), agentsDir: join(root, "agents") };
+  },
+  transformSkill(data, body) {
+    return {
+      relPath: join(data.name, "SKILL.md"),
+      text: stringifyFrontmatter({ name: data.name, description: data.description }, body)
+    };
+  },
+  transformAgent(data, body) {
+    const fm = { name: data.name, description: data.description };
+    if (data.tools)
+      fm.tools = data.tools;
+    return { relPath: `${data.name}.md`, text: stringifyFrontmatter(fm, body) };
+  }
+};
+
+// src/targets/opencode.ts
+import { join as join2 } from "node:path";
+var target2 = {
+  id: "opencode",
+  label: "opencode",
+  native: true,
+  paths({ scope, projectDir, home }) {
+    const root = scope === "global" ? join2(home, ".config", "opencode") : join2(projectDir, ".opencode");
+    return { skillsDir: join2(root, "skills"), agentsDir: join2(root, "agents") };
+  },
+  transformSkill(data, body) {
+    return {
+      relPath: join2(data.name, "SKILL.md"),
+      text: stringifyFrontmatter({ name: data.name, description: data.description }, body)
+    };
+  },
+  transformAgent(data, body) {
+    const fm = { name: data.name, description: data.description };
+    if (data.tools)
+      fm.tools = data.tools;
+    return { relPath: `${data.name}.md`, text: stringifyFrontmatter(fm, body) };
+  }
+};
+
+// src/targets/copilot.ts
+import { join as join3 } from "node:path";
+var target3 = {
+  id: "copilot",
+  label: "GitHub Copilot",
+  native: true,
+  paths({ scope, projectDir, home }) {
+    const root = scope === "global" ? join3(home, ".copilot") : join3(projectDir, ".github");
+    return { skillsDir: join3(root, "instructions"), agentsDir: join3(root, "agents") };
+  },
+  transformSkill(data, body) {
+    return {
+      relPath: `${data.name}.instructions.md`,
+      text: stringifyFrontmatter({ description: data.description, applyTo: "**/*" }, body)
+    };
+  },
+  transformAgent(data, body) {
+    return {
+      relPath: `${data.name}.md`,
+      text: stringifyFrontmatter({ name: data.name, description: data.description }, body)
+    };
+  }
+};
+
+// src/targets/generic.ts
+import { existsSync, writeFileSync } from "node:fs";
+import { join as join4 } from "node:path";
+function makeGeneric(opts) {
+  const { id, label, rulesDir, bootstrapFile, bootstrapPointer } = opts;
+  return {
+    id,
+    label,
+    native: false,
+    paths({ scope, projectDir }) {
+      if (scope === "global")
+        throw new Error(`${label} supports project scope only`);
+      const dir = join4(projectDir, rulesDir);
+      return { skillsDir: dir, agentsDir: dir };
+    },
+    transformSkill(data, body) {
+      return { relPath: `${data.name}.md`, text: `# ${data.name}
+
+> ${data.description}
+
+${body}` };
+    },
+    transformAgent(data, body) {
+      return { relPath: `agent-${data.name}.md`, text: `# Agent: ${data.name}
+
+> ${data.description}
+
+Skills used: ${data.skills ?? ""}
+
+${body}` };
+    },
+    postInstall({ projectDir, dryRun }) {
+      if (!bootstrapFile)
+        return { written: [], notes: [] };
+      const notes = [];
+      const written = [];
+      const file = join4(projectDir, bootstrapFile);
+      if (!existsSync(file)) {
+        if (!dryRun)
+          writeFileSync(file, `${bootstrapPointer}
+`);
+        written.push(file);
+      } else {
+        notes.push(`add this line to ${bootstrapFile} so the agent finds the crew: "${bootstrapPointer}"`);
+      }
+      return { written, notes };
+    }
+  };
+}
+
+// src/targets/gemini.ts
+var target4 = makeGeneric({
+  id: "gemini",
+  label: "Gemini",
+  rulesDir: ".gemini/mugiwara",
+  bootstrapFile: "GEMINI.md",
+  bootstrapPointer: "Mugiwara crew installed in .gemini/mugiwara/ — read .gemini/mugiwara/mugiwara-workflow.md to run the pipeline."
+});
+
+// src/targets/codex.ts
+var target5 = makeGeneric({
+  id: "codex",
+  label: "Codex",
+  rulesDir: ".codex/mugiwara",
+  bootstrapFile: "AGENTS.md",
+  bootstrapPointer: "Mugiwara crew installed in .codex/mugiwara/ — read .codex/mugiwara/mugiwara-workflow.md to run the pipeline."
+});
+
+// src/targets/windsurf.ts
+var target6 = makeGeneric({
+  id: "windsurf",
+  label: "Windsurf",
+  rulesDir: ".devin/rules",
+  bootstrapFile: null,
+  bootstrapPointer: null
+});
+
+// src/targets/cline.ts
+var target7 = makeGeneric({
+  id: "cline",
+  label: "Cline",
+  rulesDir: ".clinerules",
+  bootstrapFile: null,
+  bootstrapPointer: null
+});
+
+// src/targets/kilo.ts
+var target8 = makeGeneric({
+  id: "kilo",
+  label: "Kilo Code",
+  rulesDir: ".kilo/rules",
+  bootstrapFile: "kilo.jsonc",
+  bootstrapPointer: `{
+  "instructions": [
+    ".kilo/rules/*.md"
+  ]
+}`
+});
+
+// src/targets/antigravity.ts
+var target9 = makeGeneric({
+  id: "antigravity",
+  label: "Antigravity",
+  rulesDir: ".agents/rules",
+  bootstrapFile: null,
+  bootstrapPointer: null
+});
+
+// src/targets/index.ts
+var targets = { claude: target, opencode: target2, copilot: target3, gemini: target4, codex: target5, windsurf: target6, cline: target7, kilo: target8, antigravity: target9 };
+var TARGET_IDS = Object.keys(targets);
+
+// src/installer.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, writeFileSync as writeFileSync2, copyFileSync, rmSync } from "node:fs";
+import { dirname, join as join5 } from "node:path";
+import { homedir } from "node:os";
+var CONTENT_DIR = join5(import.meta.dirname, "..", "content");
+var pkg = JSON.parse(readFileSync(join5(import.meta.dirname, "..", "package.json"), "utf8"));
+var VERSION = pkg.version;
+function collectContent({ includeFrontend }) {
+  const skillNames = readdirSync(join5(CONTENT_DIR, "skills"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).filter((name) => includeFrontend || name !== "mugiwara-frontend");
+  const skills = skillNames.map((name) => {
+    const { data, body } = parseFrontmatter(readFileSync(join5(CONTENT_DIR, "skills", name, "SKILL.md"), "utf8"));
+    return { name, data, body };
+  });
+  const agents = readdirSync(join5(CONTENT_DIR, "agents")).filter((f) => f.endsWith(".md")).map((f) => {
+    const { data, body } = parseFrontmatter(readFileSync(join5(CONTENT_DIR, "agents", f), "utf8"));
+    return { name: f.replace(/\.md$/, ""), data, body };
+  });
+  return { skills, agents };
+}
+function installTo(target10, opts) {
+  const { scope, projectDir, type, dryRun = false, force = false } = opts;
+  const home = opts.home ?? homedir();
+  const { skills, agents } = collectContent({ includeFrontend: type === "frontend" || type === "fullstack" });
+  const dirs = target10.paths({ scope, projectDir, home });
+  const backupRoot = join5(scope === "global" ? home : projectDir, ".mugiwara");
+  const result = { written: [], skipped: [], backedUp: [], notes: [] };
+  const writeOne = (absPath, text) => {
+    if (existsSync2(absPath)) {
+      if (readFileSync(absPath, "utf8") === text) {
+        result.skipped.push(absPath);
+        return;
+      }
+      if (!force) {
+        result.skipped.push(absPath);
+        result.notes.push(`conflict (not overwritten; run update to replace with backup): ${absPath}`);
+        return;
+      }
+      const ts = new Date().toISOString().replace(/[:.]/g, "-");
+      const backupFile = join5(backupRoot, "backup", ts, absPath.replace(/[^a-zA-Z0-9]+/g, "_"));
+      if (!dryRun) {
+        mkdirSync(dirname(backupFile), { recursive: true });
+        copyFileSync(absPath, backupFile);
+      }
+      result.backedUp.push(absPath);
+    }
+    if (!dryRun) {
+      mkdirSync(dirname(absPath), { recursive: true });
+      writeFileSync2(absPath, text);
+    }
+    result.written.push(absPath);
+  };
+  for (const s of skills) {
+    const out = target10.transformSkill(s.data, s.body);
+    if (out)
+      writeOne(join5(dirs.skillsDir, out.relPath), out.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.postInstall) {
+    const post = target10.postInstall({ scope, projectDir, home, dryRun, files: result.written });
+    result.written.push(...post.written);
+    result.notes.push(...post.notes);
+  }
+  return result;
+}
+function removeInstalled(manifest, { dryRun = false } = {}) {
+  const removed = [];
+  for (const f of manifest.files) {
+    if (existsSync2(f)) {
+      if (!dryRun)
+        rmSync(f);
+      removed.push(f);
+    }
+  }
+  if (!dryRun) {
+    for (const f of manifest.files) {
+      let d = dirname(f);
+      while (existsSync2(d) && readdirSync(d).length === 0) {
+        rmSync(d, { recursive: true });
+        const parent = dirname(d);
+        if (parent === d)
+          break;
+        d = parent;
+      }
+    }
+  }
+  return removed;
+}
+
+// src/manifest.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join6 } from "node:path";
+function manifestPath({ scope, projectDir, home }) {
+  return scope === "global" ? join6(home, ".mugiwara", "manifest.json") : join6(projectDir, ".mugiwara", "manifest.json");
+}
+function readManifest(file) {
+  return existsSync3(file) ? JSON.parse(readFileSync2(file, "utf8")) : null;
+}
+function writeManifest(file, data) {
+  mkdirSync2(dirname2(file), { recursive: true });
+  writeFileSync3(file, JSON.stringify(data, null, 2) + `
+`);
+}
+
+// src/cli.ts
+var TYPES = ["frontend", "backend", "fullstack", "general"];
+var str = (v) => typeof v === "string" ? v : undefined;
+var flag = (v) => v === true;
+async function run(argv) {
+  const { command, flags } = parseArgs(argv);
+  if (flag(flags.help) || command === "help")
+    return help();
+  if (flag(flags.version)) {
+    console.log(`mugiwara ${VERSION}`);
+    return;
+  }
+  switch (command) {
+    case "install":
+      return install(flags);
+    case "update":
+      return install({ ...flags, force: true });
+    case "uninstall":
+      return uninstall(flags);
+    case "list":
+      return list(flags);
+    case "skills":
+      return skills();
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+async function resolveOptions(flags) {
+  const interactive = !flag(flags.yes);
+  const rl = interactive ? createRl() : null;
+  try {
+    let scope = flag(flags.global) ? "global" : str(flags.project) ? "project" : null;
+    if (!scope) {
+      if (!interactive)
+        throw new Error("Specify --global or --project <dir> with --yes");
+      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" && !existsSync4(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"))
+      targetIds = [...TARGET_IDS];
+    if (!targetIds) {
+      if (!interactive)
+        throw new Error("Specify --target <ids|all> with --yes");
+      const idx = await multiChoose(rl, "Target AI agents?", ["all targets", ...TARGET_IDS]);
+      targetIds = idx.includes(0) ? [...TARGET_IDS] : idx.map((i) => TARGET_IDS[i - 1]);
+    }
+    for (const id of targetIds) {
+      if (!targets[id])
+        throw new Error(`Unknown target: ${id} (valid: ${TARGET_IDS.join(", ")}, all)`);
+    }
+    let type = str(flags.type) ?? null;
+    if (!type) {
+      if (!interactive)
+        throw new Error("Specify --type with --yes");
+      type = TYPES[await choose(rl, "Project type?", TYPES)];
+    }
+    if (!TYPES.includes(type))
+      throw new Error(`Unknown type: ${type} (valid: ${TYPES.join(", ")})`);
+    return { scope, projectDir, targetIds, type };
+  } finally {
+    if (rl)
+      rl.close();
+  }
+}
+async function install(flags) {
+  const { scope, projectDir, targetIds, type } = await resolveOptions(flags);
+  const home = homedir2();
+  const allFiles = [];
+  const allNotes = [];
+  const installed = [];
+  for (const id of targetIds) {
+    const t = targets[id];
+    if (scope === "global" && !t.native) {
+      console.log(`! ${t.label}: project scope only — skipped for global install`);
+      continue;
+    }
+    installed.push(id);
+    console.log(`
+-> ${t.label} (${scope})`);
+    const r = installTo(t, { scope, projectDir, type, home, dryRun: flag(flags.dryRun), force: flag(flags.force) });
+    console.log(`   written ${r.written.length}, skipped ${r.skipped.length}, backed up ${r.backedUp.length}`);
+    for (const n of r.notes)
+      console.log(`   note: ${n}`);
+    allFiles.push(...r.written);
+    allNotes.push(...r.notes);
+  }
+  if (flag(flags.dryRun)) {
+    console.log(`
+Dry run — nothing written.`);
+    return;
+  }
+  const file = manifestPath({ scope, projectDir, home });
+  const prev = readManifest(file);
+  writeManifest(file, {
+    version: VERSION,
+    scope,
+    type,
+    installedAt: new Date().toISOString(),
+    targets: [...new Set([...prev?.targets ?? [], ...installed])],
+    files: [...new Set([...prev?.files ?? [], ...allFiles])]
+  });
+  console.log(`
+OK mugiwara ${VERSION} installed (manifest: ${file})`);
+  if (allNotes.length)
+    console.log(`${allNotes.length} note(s) above may need attention.`);
+}
+async function uninstall(flags) {
+  const scope = flag(flags.global) ? "global" : "project";
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const home = homedir2();
+  const file = manifestPath({ scope, projectDir, home });
+  const manifest = readManifest(file);
+  if (!manifest) {
+    console.log("Nothing installed (no manifest found).");
+    return;
+  }
+  console.log(`Will remove ${manifest.files.length} files (targets: ${manifest.targets.join(", ")}).`);
+  if (!flag(flags.yes)) {
+    const rl = createRl();
+    const ok = await confirm(rl, "Proceed?");
+    rl.close();
+    if (!ok) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  const removed = removeInstalled(manifest, { dryRun: flag(flags.dryRun) });
+  if (!flag(flags.dryRun))
+    rmSync2(file);
+  console.log(`OK removed ${removed.length} files`);
+}
+function list(flags) {
+  const home = homedir2();
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  let found = false;
+  for (const [label, file] of [
+    ["project", manifestPath({ scope: "project", projectDir, home })],
+    ["global", manifestPath({ scope: "global", projectDir, home })]
+  ]) {
+    const m = readManifest(file);
+    if (!m)
+      continue;
+    found = true;
+    console.log(`${label}: v${m.version} targets=${m.targets.join(",")} files=${m.files.length} installed=${m.installedAt}`);
+  }
+  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(readFileSync3(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
+
+Usage:
+  mugiwara [install]     install the crew (default; wizard when flags missing)
+  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 --help        this help
+  mugiwara --version     print version
+
+Flags:
+  --global               user-wide install
+  --project <dir>        project install (default: cwd)
+  --target <ids|all>     comma-separated: ${TARGET_IDS.join(", ")}
+  --type <t>             frontend | backend | fullstack | general
+  --yes, -y              non-interactive (needs --global/--project, --target, --type)
+  --force                overwrite differing files (with backup)
+  --dry-run              print actions without writing`);
+}
+var entry = process.argv[1] !== undefined ? resolve(process.argv[1]) : undefined;
+if (entry !== undefined) {
+  try {
+    entry = realpathSync(entry);
+  } catch {}
+}
+var isMain = entry !== undefined && import.meta.url === pathToFileURL(entry).href;
+if (isMain) {
+  run(process.argv.slice(2)).catch((err) => {
+    console.error(`mugiwara: ${err.message}`);
+    process.exit(1);
+  });
+}
+export {
+  run
+};