@ionivetech/mugiwara 0.6.4 → 0.6.6

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "mugiwara",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, healing.",
   "contextFileName": "GEMINI.md"
 }

package/hooks/auto-savepoint.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+// @bun
+
+// hooks/auto-savepoint.ts
+import { existsSync as existsSync2, readFileSync, readdirSync as readdirSync2 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/run.ts
+import { existsSync, readdirSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var here = dirname(fileURLToPath(import.meta.url));
+var SCRIPTS_DIR = join(here, "..", "scripts");
+function findBash() {
+  const explicit = process.env.MUGIWARA_BASH?.trim();
+  if (explicit)
+    return existsSync(explicit) ? explicit : null;
+  const candidates = process.platform === "win32" ? [
+    "C:\\Program Files\\Git\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+    join(process.env.LOCALAPPDATA ?? "", "Programs", "Git", "bin", "bash.exe")
+  ] : ["/bin/bash", "/usr/bin/bash", "/usr/local/bin/bash", "/opt/homebrew/bin/bash"];
+  for (const p of candidates) {
+    if (p && existsSync(p))
+      return p;
+  }
+  const probe = spawnSync(process.platform === "win32" ? "where" : "which", ["bash"], {
+    encoding: "utf8"
+  });
+  const first = probe.stdout?.split(/\r?\n/).find((l) => l.trim());
+  return first?.trim() || null;
+}
+
+// hooks/auto-savepoint.ts
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var root = join2(dirname2(fileURLToPath2(import.meta.url)), "..");
+var cwd = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+var SAFE = /^[A-Za-z0-9._-]+$/;
+function bootstrapMission() {
+  for (const dir of ["plans", "spec", "logs"]) {
+    const d = join2(cwd, ".mugiwara", dir);
+    if (!existsSync2(d))
+      continue;
+    const files = readdirSync2(d).filter((f) => f.endsWith(".md") && f !== "lessons.md").sort().reverse();
+    for (const f of files) {
+      const name = f.replace(/\.md$/, "").replace(/^\d{4}-\d{2}-\d{2}-/, "");
+      if (name && SAFE.test(name) && !/^\.+$/.test(name)) {
+        return { mission: name, member: "", wave: "0", mode: readMode(), updated: 0 };
+      }
+    }
+  }
+  return null;
+}
+function readMode() {
+  const file = join2(cwd, ".mugiwara", "config");
+  if (!existsSync2(file))
+    return "guided";
+  for (const line of readFileSync(file, "utf8").split(/\r?\n/)) {
+    const [k, v] = line.split("=").map((s) => s.trim());
+    if (k === "mode" && ["guided", "semi", "auto"].includes(v))
+      return v;
+  }
+  return "guided";
+}
+function activeMission() {
+  const base = join2(cwd, ".mugiwara", "state");
+  if (!existsSync2(base))
+    return bootstrapMission();
+  let best = null;
+  for (const e of readdirSync2(base, { withFileTypes: true })) {
+    if (!e.isDirectory() || !SAFE.test(e.name) || /^\.+$/.test(e.name))
+      continue;
+    for (const f of readdirSync2(join2(base, e.name))) {
+      if (!f.endsWith(".json"))
+        continue;
+      const stem = f.slice(0, -5);
+      const member = stem === "state" ? "" : stem;
+      if (member && (!SAFE.test(member) || /^\.+$/.test(member)))
+        continue;
+      try {
+        const s = JSON.parse(readFileSync(join2(base, e.name, f), "utf8"));
+        const updated = Date.parse(s.updated_at ?? "") || 0;
+        if (best && updated <= best.updated)
+          continue;
+        const wave = String(s.flow ?? s.wave ?? "").replace(/\D/g, "") || "1";
+        const mode = ["guided", "semi", "auto"].includes(s.mode) ? s.mode : "guided";
+        best = { mission: e.name, member, wave, mode, updated };
+      } catch {}
+    }
+  }
+  return best ?? bootstrapMission();
+}
+try {
+  const active = activeMission();
+  const script = join2(root, "scripts", "savepoint.sh");
+  const bash = findBash();
+  if (active && bash && existsSync2(script)) {
+    spawnSync2(bash, [script, active.mission, active.member, active.wave, active.mode], {
+      cwd,
+      stdio: "ignore",
+      timeout: 15000
+    });
+  }
+} catch {}

package/hooks/auto-savepoint.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env bun
+// hooks/auto-savepoint.ts — Stop hook: refresh the active mission's savepoint.
+//
+// State used to depend on the model remembering the prose instruction "run
+// scripts/savepoint.sh". It forgot, so .mugiwara/state/ and .mugiwara/continue/
+// stayed empty and everything reading them (resume, heal_cycle cap, lane-rise
+// detection, the SessionStart auto-resume) was dead. This makes the write
+// happen whether or not the crew remembers.
+//
+// Refreshes the CURRENT wave — it never advances one. Wave transitions stay an
+// explicit crew action; this only keeps tasks/lane/blockers honest.
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+// Shared with `mugiwara run` — a second copy here drifted (it lacked the PATH
+// probe), so the hook found no bash where the CLI did. One definition, bundled in.
+import { findBash } from '../src/run.ts';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+const cwd = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+const SAFE = /^[A-Za-z0-9._-]+$/;
+
+type Active = { mission: string; member: string; wave: string; mode: string; updated: number };
+
+/**
+ * Name the mission when no savepoint exists yet, so the first one can be
+ * written. Ordered most- to least-authoritative; returns null when nothing
+ * indicates a mission is underway, which keeps this hook silent on projects
+ * that never engaged the crew.
+ */
+function bootstrapMission(): Active | null {
+  // A plan, spec, or decision log means Flow 0 produced artifacts but no
+  // savepoint — exactly the drift this hook exists to end.
+  for (const dir of ['plans', 'spec', 'logs']) {
+    const d = join(cwd, '.mugiwara', dir);
+    if (!existsSync(d)) continue;
+    const files = readdirSync(d)
+      .filter((f) => f.endsWith('.md') && f !== 'lessons.md')
+      .sort()
+      .reverse();
+    for (const f of files) {
+      // strip the YYYY-MM-DD- prefix the crew writes; what remains is the mission
+      const name = f.replace(/\.md$/, '').replace(/^\d{4}-\d{2}-\d{2}-/, '');
+      if (name && SAFE.test(name) && !/^\.+$/.test(name)) {
+        return { mission: name, member: '', wave: '0', mode: readMode(), updated: 0 };
+      }
+    }
+  }
+  return null;
+}
+
+function readMode(): string {
+  const file = join(cwd, '.mugiwara', 'config');
+  if (!existsSync(file)) return 'guided';
+  for (const line of readFileSync(file, 'utf8').split(/\r?\n/)) {
+    const [k, v] = line.split('=').map((s) => s.trim());
+    if (k === 'mode' && ['guided', 'semi', 'auto'].includes(v)) return v;
+  }
+  return 'guided';
+}
+
+function activeMission(): Active | null {
+  const base = join(cwd, '.mugiwara', 'state');
+  if (!existsSync(base)) return bootstrapMission();
+  let best: Active | null = null;
+  for (const e of readdirSync(base, { withFileTypes: true })) {
+    if (!e.isDirectory() || !SAFE.test(e.name) || /^\.+$/.test(e.name)) continue;
+    for (const f of readdirSync(join(base, e.name))) {
+      if (!f.endsWith('.json')) continue;
+      const stem = f.slice(0, -5);
+      const member = stem === 'state' ? '' : stem;
+      if (member && (!SAFE.test(member) || /^\.+$/.test(member))) continue;
+      try {
+        const s = JSON.parse(readFileSync(join(base, e.name, f), 'utf8'));
+        const updated = Date.parse(s.updated_at ?? '') || 0;
+        if (best && updated <= best.updated) continue;
+        const wave = String(s.flow ?? s.wave ?? '').replace(/\D/g, '') || '1';
+        const mode = ['guided', 'semi', 'auto'].includes(s.mode) ? s.mode : 'guided';
+        best = { mission: e.name, member, wave, mode, updated };
+      } catch {
+        // corrupt savepoint — skip, never break the Stop hook
+      }
+    }
+  }
+  return best ?? bootstrapMission();
+}
+
+try {
+  const active = activeMission();
+  const script = join(root, 'scripts', 'savepoint.sh');
+  const bash = findBash();
+  if (active && bash && existsSync(script)) {
+    spawnSync(bash, [script, active.mission, active.member, active.wave, active.mode], {
+      cwd,
+      stdio: 'ignore',
+      timeout: 15_000,
+    });
+  }
+} catch {
+  // a Stop hook must never fail the turn
+}

package/hooks/engagement-marker.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+// @bun
+
+// hooks/engagement-marker.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var cwd = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+async function main() {
+  let input = "";
+  for await (const chunk of process.stdin)
+    input += chunk;
+  let payload = {};
+  try {
+    payload = JSON.parse(input);
+  } catch {}
+  const toolName = typeof payload.tool_name === "string" ? payload.tool_name.toLowerCase() : "";
+  const toolInput = payload.tool_input ?? {};
+  const subagentType = typeof toolInput.subagent_type === "string" ? toolInput.subagent_type.toLowerCase() : "";
+  const skillName = typeof toolInput.skill === "string" ? toolInput.skill.toLowerCase() : "";
+  const agentField = `${toolName} ${subagentType} ${skillName}`;
+  if (!agentField.includes("mugiwara"))
+    return;
+  const dispatched = /zoro-execution|brook-healing|mugiwara-execution|mugiwara-healing|mugiwara-execute|mugiwara-heal/.test(agentField);
+  const planned = /nami-planner|mugiwara-planning|mugiwara-plan/.test(agentField);
+  const dir = join(cwd, ".mugiwara", "state");
+  const file = join(dir, ".engaged");
+  const sessionId = typeof payload.session_id === "string" ? payload.session_id : "";
+  try {
+    mkdirSync(dir, { recursive: true });
+    let firstSeen = new Date().toISOString();
+    let dispatchedAt = "";
+    let plannedAt = "";
+    if (existsSync(file)) {
+      try {
+        const prev = JSON.parse(readFileSync(file, "utf8"));
+        const sameSession = !sessionId || !prev.session_id || prev.session_id === sessionId;
+        if (sameSession && typeof prev.first_seen === "string")
+          firstSeen = prev.first_seen;
+        if (sameSession && typeof prev.executor_dispatched_at === "string")
+          dispatchedAt = prev.executor_dispatched_at;
+        if (sameSession && typeof prev.planner_dispatched_at === "string")
+          plannedAt = prev.planner_dispatched_at;
+      } catch {}
+    }
+    if (dispatched)
+      dispatchedAt = new Date().toISOString();
+    if (planned)
+      plannedAt = new Date().toISOString();
+    writeFileSync(file, JSON.stringify({
+      session_id: sessionId,
+      first_seen: firstSeen,
+      touched_at: new Date().toISOString(),
+      executor_dispatched_at: dispatchedAt,
+      planner_dispatched_at: plannedAt
+    }, null, 2) + `
+`);
+  } catch {}
+}
+main().catch(() => {});

package/hooks/engagement-marker.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env bun
+// hooks/engagement-marker.ts — PostToolUse on Task|Skill: record that this
+// session engaged the mugiwara crew.
+//
+// The pipeline guard only polices sessions that actually used mugiwara. Without
+// this marker the guard would either police every session in every repo that
+// happens to have a .mugiwara dir (infuriating, and users would disable it) or
+// police nothing. Engagement is the scope.
+//
+// Never throws: a failed marker write degrades to "not engaged", which means
+// the guard stays silent. Failing open is deliberate — an enforcement layer
+// that can wedge a session gets turned off, and then it enforces nothing.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const cwd = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+
+async function main(): Promise<void> {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  let payload: Record<string, unknown> = {};
+  try { payload = JSON.parse(input) as Record<string, unknown>; } catch { /* not JSON — treat as no payload */ }
+
+  // Only mugiwara work counts as engagement. The tool input carries the agent
+  // or skill name; anything else in the session is none of our business.
+  // Match the STRUCTURED agent/skill-name field only — never free-text tool
+  // input. A Task description that merely cites a skill, or a doc read that
+  // mentions one, must not count as a dispatch (that would let the actor the
+  // guard constrains spoof the marker and neuter the check).
+  const toolName = typeof payload.tool_name === 'string' ? payload.tool_name.toLowerCase() : '';
+  const toolInput = (payload.tool_input ?? {}) as Record<string, unknown>;
+  const subagentType = typeof toolInput.subagent_type === 'string' ? toolInput.subagent_type.toLowerCase() : '';
+  const skillName = typeof toolInput.skill === 'string' ? toolInput.skill.toLowerCase() : '';
+  const agentField = `${toolName} ${subagentType} ${skillName}`;
+  if (!agentField.includes('mugiwara')) return;
+
+  // Executor dispatch is a second, narrower fact recorded in the same marker:
+  // did the session hand source work to the only two roles allowed to write it
+  // (Zoro / Brook)? Both the subagent form and the inline-embody skill form
+  // count — on Codex-style harnesses embodying the role IS the dispatch.
+  // The guard uses this to catch a captain implementing Lane 1+ work inline.
+  const dispatched = /zoro-execution|brook-healing|mugiwara-execution|mugiwara-healing|mugiwara-execute|mugiwara-heal/.test(agentField);
+
+  // Planner dispatch is a third fact: did the session hand plan-writing to the
+  // only role allowed to write the plan doc (Nami)? Same two forms count —
+  // subagent `nami-planner` and inline skill `mugiwara-planning`/`mugiwara-plan`.
+  // The guard uses this to catch a captain (or anyone else) writing the plan
+  // inline, which is escape #2: only Nami writes the plan.
+  const planned = /nami-planner|mugiwara-planning|mugiwara-plan/.test(agentField);
+
+  const dir = join(cwd, '.mugiwara', 'state');
+  const file = join(dir, '.engaged');
+  // session_id scopes the marker when the payload carries one. Its presence on
+  // every hook event is NOT verified, so the guard also accepts a recent mtime
+  // — correct under both, rather than assuming a payload shape.
+  const sessionId = typeof payload.session_id === 'string' ? payload.session_id : '';
+
+  try {
+    mkdirSync(dir, { recursive: true });
+    // preserve the first engagement time; only refresh the touch timestamp.
+    // BUT: first_seen is the "this session" anchor for the plan guard's
+    // planTouched() (a plan is "written this session" if its mtime >=
+    // first_seen). A continuation session is a NEW session — carrying the old
+    // first_seen forward would make every prior plan count as "written this
+    // session" while the new session's planner dispatch is empty, warning on
+    // every guard event. Reset first_seen when the session changes.
+    let firstSeen = new Date().toISOString();
+    let dispatchedAt = '';
+    let plannedAt = '';
+    if (existsSync(file)) {
+      try {
+        const prev = JSON.parse(readFileSync(file, 'utf8')) as { session_id?: string; first_seen?: string; executor_dispatched_at?: string; planner_dispatched_at?: string };
+        const sameSession = !sessionId || !prev.session_id || prev.session_id === sessionId;
+        if (sameSession && typeof prev.first_seen === 'string') firstSeen = prev.first_seen;
+        // A dispatch belongs to the session that made it. Carrying it into the
+        // next session would excuse a captain who implements inline today
+        // because Zoro ran yesterday.
+        if (sameSession && typeof prev.executor_dispatched_at === 'string') dispatchedAt = prev.executor_dispatched_at;
+        if (sameSession && typeof prev.planner_dispatched_at === 'string') plannedAt = prev.planner_dispatched_at;
+      } catch { /* corrupt marker — rewrite it */ }
+    }
+    if (dispatched) dispatchedAt = new Date().toISOString();
+    if (planned) plannedAt = new Date().toISOString();
+    writeFileSync(file, JSON.stringify({
+      session_id: sessionId,
+      first_seen: firstSeen,
+      touched_at: new Date().toISOString(),
+      executor_dispatched_at: dispatchedAt,
+      planner_dispatched_at: plannedAt,
+    }, null, 2) + '\n');
+  } catch {
+    // cannot write (read-only fs, permissions) — stay silent, guard stays off
+  }
+}
+
+main().catch(() => { /* a hook must never fail the turn */ });

package/hooks/hooks.json

@@ -5,7 +5,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/hooks/session-start.ts",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/hooks/session-start.js",
             "timeout": 10
           }
         ]
@@ -16,11 +16,50 @@
         "hooks": [
           {
             "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/hooks/mugiwara-mode-tracker.ts",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/hooks/mugiwara-mode-tracker.js",
             "timeout": 5
           }
         ]
       }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/hooks/auto-savepoint.js",
+            "timeout": 20
+          },
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/hooks/pipeline-guard.js",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Task|Skill",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/hooks/engagement-marker.js",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/hooks/pipeline-guard.js",
+            "timeout": 15
+          }
+        ]
+      }
     ]
   }
 }

package/hooks/mugiwara-mode-tracker.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// @bun
+
+// hooks/mugiwara-mode-tracker.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var VALID_MODES = new Set(["guided", "semi", "auto"]);
+function parseModeChange(promptRaw) {
+  if (typeof promptRaw !== "string")
+    return null;
+  let prompt = promptRaw.trim();
+  const wrapped = /^(["'`])([\s\S]*)\1$/.exec(prompt);
+  if (wrapped)
+    prompt = wrapped[2].trim();
+  prompt = prompt.toLowerCase();
+  if (!prompt)
+    return null;
+  const tplSet = /^(?:set |)mugiwara mode:[ \t]*(\S*)/.exec(prompt);
+  if (tplSet && VALID_MODES.has(tplSet[1]))
+    return tplSet[1];
+  const slashMode = /^\/(?:mugiwara[-\s]?)?mode[ \t]+(\S*)/.exec(prompt);
+  if (slashMode && VALID_MODES.has(slashMode[1]))
+    return slashMode[1];
+  const slashMain = /^\/mugiwara[ \t]+(\S*)/.exec(prompt);
+  if (slashMain && VALID_MODES.has(slashMain[1]))
+    return slashMain[1];
+  const natural = /^mugiwara mode[ \t]+(\S*)/.exec(prompt);
+  if (natural && VALID_MODES.has(natural[1]))
+    return natural[1];
+  return null;
+}
+function applyModeChange(mode) {
+  if (!VALID_MODES.has(mode))
+    return;
+  const cwd = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+  const dir = join(cwd, ".mugiwara");
+  const file = join(dir, "config");
+  mkdirSync(dir, { recursive: true });
+  const lines = [];
+  if (existsSync(file)) {
+    for (const line of readFileSync(file, "utf8").split(/\r?\n/)) {
+      const t = line.trim();
+      if (t.startsWith("mode="))
+        continue;
+      lines.push(line);
+    }
+  }
+  lines.push(`mode=${mode}`);
+  const body = lines.filter((_l, i) => !(lines[i] === "" && (i === lines.length - 1 || i === 0))).join(`
+`) + `
+`;
+  const tmp = join(tmpdir(), `mugiwara-config-${process.pid}-${Date.now()}.tmp`);
+  writeFileSync(tmp, body);
+  renameSync(tmp, file);
+}
+async function main() {
+  let input = "";
+  for await (const chunk of process.stdin)
+    input += chunk;
+  if (!input.trim()) {
+    process.stdout.write(JSON.stringify({ prompt: "" }));
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch {
+    parsed = { prompt: input };
+  }
+  const prompt = parsed.prompt ?? "";
+  const change = parseModeChange(prompt);
+  if (change)
+    applyModeChange(change);
+  process.stdout.write(JSON.stringify({ prompt }));
+}
+main().catch(() => {
+  process.stdout.write(JSON.stringify({ prompt: "" }));
+});