@ionivetech/mugiwara 0.2.0 → 0.4.0

package/.opencode/commands/mugiwara-execute.md

@@ -0,0 +1,11 @@
+---
+description: Execute an approved mugiwara plan as Zoro (execution stage)
+---
+Execute the approved plan as Zoro, inline in the main conversation:
+
+1. Load the skill: `mugiwara-execution`.
+2. Read the existing plan from `.mugiwara/plans/` — that file is the bridge, never re-plan.
+3. Open a todo list, run tasks sequentially inline; dispatch [PARALLEL] batches to worker subagents only.
+4. Commit per logical task and verify every acceptance criterion with evidence in `.mugiwara/results/`.
+
+See skills/mugiwara-execution for the wave-structured protocol.

package/.opencode/commands/mugiwara-heal.md

@@ -0,0 +1,11 @@
+---
+description: Heal earlier-wave failures as Brook (healing stage, after review/security findings)
+---
+Heal failures as Brook, inline in the main conversation:
+
+1. Load the skill: `mugiwara-healing`.
+2. Read the `.mugiwara/issues` ledger first — stop-the-line triage per failure, never fix blind.
+3. Prove-it before fixing: reproduce or verify the failure from `.mugiwara/results/` evidence.
+4. Apply minimal root-cause fixes, update the ledger with evidence.
+
+See skills/mugiwara-healing for the triage protocol.

package/.opencode/commands/mugiwara-mode.md

@@ -0,0 +1,6 @@
+---
+description: Set the mugiwara runtime mode (guided | semi | auto)
+---
+Set mugiwara mode: $ARGUMENTS
+
+Valid levels: guided, semi, auto. If no level given, show the current mode. The flip applies from the next wave.

package/.opencode/commands/mugiwara-plan.md

@@ -0,0 +1,15 @@
+---
+description: Plan a mugiwara mission as Nami (planning stage)
+---
+Plan the mission as Nami, inline in the main conversation:
+
+1. Load the skill: `mugiwara-planning`.
+2. Classify mission size, interview first, scan full context, write the scaled Quick/Standard/Full plan.
+3. Embody the Nami crew role inline — never Task-dispatch.
+4. Persist the plan to `.mugiwara/plans/`; later stages read it from there as the bridge.
+
+Spec input: read `.mugiwara/spec/YYYY-MM-DD-<mission>.md`. If it is empty or
+missing, write the spec bridge from the user's request first (goal, acceptance
+criteria, constraints) before planning — never plan from an empty spec.
+
+See skills/mugiwara-planning for the full template and wave structure.

package/.opencode/commands/mugiwara-review.md

@@ -0,0 +1,11 @@
+---
+description: Review the mission diff as Robin (review stage, after gates pass)
+---
+Review the diff adversarially as Robin, inline in the main conversation:
+
+1. Load the skill: `mugiwara-review`.
+2. Run the doubt-driven review: breaking-change damage map first, five-axis review, severity criteria, dispute hierarchy.
+3. Use `.mugiwara/results/` evidence and `.mugiwara/review/` findings as the bridge.
+4. Write findings to `.mugiwara/review/`; escalate after 3 cycles. Never fixes code.
+
+See skills/mugiwara-review for the full protocol.

package/.opencode/commands/mugiwara-security.md

@@ -0,0 +1,11 @@
+---
+description: Security-audit the diff as Jinbe (security stage, can run concurrent with review)
+---
+Security-audit the diff as Jinbe, inline in the main conversation:
+
+1. Load the skill: `mugiwara-security`.
+2. STRIDE first, OWASP Top 10 mapping, then the full checklist in order: secrets, injection, authn/authz, data exposure, dependencies, deserialization, crypto.
+3. Use `.mugiwara/results/` evidence and `.mugiwara/review/` findings as the bridge.
+4. Write findings to `.mugiwara/review/` with CVSS-style severity. Never fixes code.
+
+See skills/mugiwara-security for the full checklist.

package/.opencode/commands/mugiwara-ship.md

@@ -0,0 +1,11 @@
+---
+description: Close the mission as Luffy (closure + ship stage, at mission end)
+---
+Close the mission as Luffy, inline in the main conversation:
+
+1. Load the skills: `mugiwara-orchestration` + `mugiwara-ship`.
+2. Run the ship gate: pre-launch checklist, feature flags, staged rollout, mandatory rollback plan — binary GO/NO-GO with evidence.
+3. Bridge on `.mugiwara/plans/` (promise) vs `.mugiwara/results/` (evidence) for the Definition-of-Done verdict.
+4. Close the mission: lessons ledger update, then `/mugiwara-pr` for push + PR material.
+
+See skills/mugiwara-ship for the gate and skills/mugiwara-orchestration for closure.

package/.opencode/commands/mugiwara.md

@@ -0,0 +1,11 @@
+---
+description: Run the mugiwara crew workflow for a task
+---
+Mugiwara workflow:
+
+1. The crew runs inline in the main conversation. Start any non-trivial task through `using-mugiwara` (embodied inline) to route to the right crew member.
+2. The pipeline flows: Luffy triage -> Usopp brainstorm (when needed) -> Nami planning -> Zoro execution -> Chopper checkpoint -> Sanji quality -> Franky gates -> Robin/Jinbe review -> Brook healing -> Luffy closure.
+3. Subagents are used only for parallel work (Zoro's [PARALLEL] workers, Robin + Jinbe concurrent review, independent re-run checks).
+4. Switch runtime mode with `/mugiwara-mode` (guided | semi | auto). Default is guided.
+
+See skills/mugiwara-workflow for the full pipeline.

package/.opencode/plugins/mugiwara.mjs

@@ -9,18 +9,46 @@
 // or from the git repo:
 //   { "plugin": ["mugiwara@git+https://github.com/ionivetech/mugiwara.git"] }
 
-import { readdirSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, appendFileSync, lstatSync, renameSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+const VALID_MODES = new Set(['guided', 'semi', 'auto']);
+
+// Read the runtime mode: `.mugiwara/config` (project) wins over
+// `~/.mugiwara/config` (global) per key; a missing key or a value outside the
+// enum falls back to `guided`. Never creates files on read.
+export function readMode({ projectDir = process.cwd(), home = homedir() } = {}) {
+  const readValue = (dir) => {
+    const file = join(dir, '.mugiwara', 'config');
+    if (!existsSync(file)) return undefined;
+    for (const line of readFileSync(file, 'utf8').split(/\r?\n/)) {
+      const t = line.trim();
+      if (!t || t.startsWith('#')) continue;
+      const [k, v] = t.split('=').map((s) => s.trim());
+      if (k !== 'mode') continue;
+      return VALID_MODES.has(v) ? v : 'INVALID';
+    }
+    return undefined;
+  };
+  const proj = readValue(projectDir);
+  if (proj === 'INVALID') return 'guided';
+  if (proj) return proj;
+  const glob = readValue(home);
+  if (glob === 'INVALID') return 'guided';
+  if (glob) return glob;
+  return 'guided';
+}
+
 const contentDir = join(__dirname, '..', '..', 'content');
 const skillsDir = join(contentDir, 'skills');
 const agentsDir = join(contentDir, 'agents');
 
 const ANNOUNCE =
-  "Mugiwara crew available. Start non-trivial missions by invoking `using-mugiwara` (or ask 'how do I use mugiwara?') - it routes you to the right crew member. Run the crew pipeline inline: embody ONE crew role at a time in the main conversation using its skill, wait for its report, then move to the next. Subagents only for [PARALLEL] task batches and background checks. Crew members never dispatch each other. See skills/mugiwara-workflow.";
+  "Mugiwara crew available. The workflow auto-activates for non-trivial requests — no need to call `/using-mugiwara` at session start (it remains an optional router). Run the crew pipeline inline in the main conversation: embody ONE crew role at a time using its skill, wait for its report, then move to the next. Never Task-dispatch a crew member — the crew runs in the main thread; subagents only for [PARALLEL] task batches, concurrent review/security, and independent re-run checks. Progress shows as checkpoint reports at wave/stage boundaries, pausing on failure or risk. Switch mode with `/mugiwara-mode` (guided|semi|auto). See skills/mugiwara-workflow.";
 
 // OpenCode per-agent tuning. Content stays portable markdown; these knobs
 // (color, temperature, permission, steps) are opencode-only.
@@ -72,12 +100,78 @@ function readAgents() {
       continue;
     }
     if (!parsed.data.description || !parsed.body) continue;
-    agents[name] = { description: parsed.data.description, mode: 'subagent', prompt: parsed.body };
+    agents[name] = { description: parsed.data.description, mode: 'all', prompt: parsed.body };
     if (CREW[name]) agents[name] = { ...agents[name], ...CREW[name] };
   }
   return agents;
 }
 
+// Parse a user prompt for a mugiwara mode change. Returns the new mode or null.
+// Mirrors the caveman plugin pattern: opencode expands `/mugiwara-mode <level>`
+// into the command file's body ("Set mugiwara mode: <level>...") before
+// chat.message fires, so parse the template's first line too. The slash command
+// and natural-language phrase must sit at the START of the prompt — a bare
+// mention mid-message (pasted untrusted content) never flips autonomy.
+export 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 tpl = /^set mugiwara mode:[ \t]*(\S*)/.exec(prompt);
+  if (tpl && VALID_MODES.has(tpl[1])) return tpl[1];
+
+  const slash = /^\/(mugiwara[-\s]?)mode[ \t]+(\S*)/.exec(prompt);
+  if (slash && VALID_MODES.has(slash[2])) return slash[2];
+
+  const natural = /^mugiwara mode[ \t]+(\S*)/.exec(prompt);
+  if (natural && VALID_MODES.has(natural[1])) return natural[1];
+
+  return null;
+}
+
+// Refuse to follow a symlinked .mugiwara/config — a malicious repo could point
+// it at ~/.bashrc and any mode flip would overwrite the target.
+function assertNotSymlink(file) {
+  if (!existsSync(file)) return;
+  try {
+    const st = lstatSync(file);
+    if (st.isSymbolicLink()) throw new Error(`refusing to follow symlink: ${file}`);
+  } catch (e) {
+    if (e.code === 'ENOENT') return;
+    throw e;
+  }
+}
+
+// Write `.mugiwara/config` (project) and append a decision-log row.
+// Atomic: write a temp file next to the target, then rename over it, so a
+// crash mid-write never truncates the config (keeps branch/commit keys).
+export function applyModeChange(mode, { projectDir = process.cwd(), home = homedir() } = {}) {
+  if (!VALID_MODES.has(mode)) return;
+  const dir = join(projectDir, '.mugiwara');
+  const file = join(dir, 'config');
+  assertNotSymlink(file);
+  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) => !(l === '' && (i === lines.length - 1 || i === 0))).join('\n') + '\n';
+  const tmp = join(tmpdir(), `mugiwara-config-${process.pid}-${Date.now()}.tmp`);
+  writeFileSync(tmp, body);
+  renameSync(tmp, file);
+  const log = join(dir, 'logs', `${new Date().toISOString().slice(0, 10)}-mode-flip.md`);
+  mkdirSync(dirname(log), { recursive: true });
+  appendFileSync(log, `| ${new Date().toISOString()} | mode flip | guided/semi/auto -> ${mode} | user |\n`);
+}
+
 export default async () => ({
   config: (config) => {
     config.skills = config.skills || {};
@@ -91,12 +185,37 @@ export default async () => ({
     }
   },
 
+  // Intercept user messages to detect `/mugiwara-mode` and natural-language
+  // mode toggles; write `.mugiwara/config` so the next wave reads the new level.
+  'chat.message': async (_input, output) => {
+    if (!output) return;
+    if (typeof output === 'string') {
+      const change = parseModeChange(output);
+      if (change) applyModeChange(change);
+      return;
+    }
+    const parts = output.parts ?? output.messages ?? output;
+    if (!Array.isArray(parts)) return;
+    for (const part of parts) {
+      if (part && typeof part.text === 'string') {
+        const change = parseModeChange(part.text);
+        if (change) applyModeChange(change);
+      }
+    }
+  },
+
   // ponytail-proven hook; appends the announce string to the system prompt.
+  // Dedupes: repeated transforms (model switch/compaction) must not grow the
+  // prompt unbounded — only append once per string content.
   'experimental.chat.system.transform': async (_input, output) => {
-    if (output.system.length > 0) {
-      output.system[output.system.length - 1] += '\n\n' + ANNOUNCE;
-    } else {
-      output.system.push(ANNOUNCE);
+    if (!output.system.some((s) => s.includes('Mugiwara crew available'))) {
+      if (output.system.length > 0) {
+        output.system[output.system.length - 1] += '\n\n' + ANNOUNCE;
+      } else {
+        output.system.push(ANNOUNCE);
+      }
     }
+    const active = `Active mode: ${readMode()} (guided|semi|auto; flip applies next wave).`;
+    if (!output.system.some((s) => s.includes('Active mode:'))) output.system.push(active);
   },
 });