@ionivetech/mugiwara 0.5.4 → 0.6.0

package/scripts/savepoint.sh

@@ -8,21 +8,30 @@ die() { echo "savepoint: $*" >&2; exit 1; }
 MUGIWARA_DIR="${MUGIWARA_DIR:-.mugiwara}"
 
 # --- parse mission args ---
-MISSION="${1:-${STATE_MISSION:-}}"
-ACTOR="${2:-${STATE_ACTOR:-${GIT_AUTHOR_NAME:-${USER:-}}}}"
-BRANCH="${3:-$(git branch --show-current 2>/dev/null || echo 'unknown')}"
-WAVE="${4:-${STATE_WAVE:-1}}"
-MODE="${5:-${STATE_MODE:-guided}}"
-
-# --branch flag for per-branch state
+# --branch flag must parse FIRST — it shifts positionals
 BRANCH_MODE=0
 if [ "${1:-}" = "--branch" ]; then
   BRANCH_MODE=1
-  MISSION="${2:-${STATE_MISSION:-}}"
+  shift
+  MISSION="${1:-${STATE_MISSION:-}}"
+  ACTOR="${2:-${STATE_ACTOR:-${GIT_AUTHOR_NAME:-${USER:-}}}}"
+  BRANCH="${3:-$(git branch --show-current 2>/dev/null || echo 'unknown')}"
+  WAVE="${4:-${STATE_WAVE:-1}}"
+  MODE="${5:-${STATE_MODE:-guided}}"
+else
+  MISSION="${1:-${STATE_MISSION:-}}"
+  ACTOR="${2:-${STATE_ACTOR:-${GIT_AUTHOR_NAME:-${USER:-}}}}"
   BRANCH="${3:-$(git branch --show-current 2>/dev/null || echo 'unknown')}"
-  shift 2 2>/dev/null || true
+  WAVE="${4:-${STATE_WAVE:-1}}"
+  MODE="${5:-${STATE_MODE:-guided}}"
 fi
 
+# mission allowlist — MISSION feeds paths + sed + node argv; traversal or
+# sed metacharacters must not reach filesystem operations
+case "$MISSION" in
+  ""|*[!a-zA-Z0-9._-]*) die "invalid mission name \"$MISSION\" (allowlist: [a-zA-Z0-9._-])" ;;
+esac
+
 # per-branch state file when --branch used
 BRANCH_SLUG=$(echo "$BRANCH" | tr '/' '-')
 if [ "$BRANCH_MODE" -eq 1 ]; then
@@ -69,6 +78,19 @@ else
   LANE_REASON="$FILES_TOUCHED file(s) under 20 LOC"
 fi
 
+# path-weighted sizing (mirrors lane.sh): docs-only changes outside the product
+# surface never escalate to full from file count alone; sensitive-path
+# escalation above still wins.
+PRODUCT_PAT="^content/|^src/|^scripts/|^test/|^hooks/|^\.opencode/|^\.claude/|^evals/"
+if [ "$LANE" = "full" ] && [ -n "$CHANGED_FILES" ]; then
+  CODE_COUNT=$(echo "$CHANGED_FILES" | grep -E "$PRODUCT_PAT" 2>/dev/null | grep -c . || true)
+  if [ -z "$CODE_COUNT" ] || [ "$CODE_COUNT" -eq 0 ] 2>/dev/null; then
+    PREV="$LANE"
+    LANE="standard"
+    LANE_REASON="$FILES_TOUCHED files, docs-only — path-weighted down from $PREV"
+  fi
+fi
+
 # task counts from plan doc
 PLAN_FILE=$(ls "$MUGIWARA_DIR/plans/${MISSION}.md" 2>/dev/null || true)
 TASKS_DONE=0
@@ -85,22 +107,29 @@ if [ -n "$BLOCKERS_FILE" ] && [ -f "$BLOCKERS_FILE" ]; then
   BLOCKERS_OPEN=$(grep -c '|' "$BLOCKERS_FILE" 2>/dev/null || echo 0)
 fi
 
-# heal cycle
+# heal cycle — count WAVE-8 banner occurrences in the trace, not the word
+# "heal" anywhere (heal workers/healing text would inflate the counter and
+# cause a premature halt)
 HEAL_CYCLE=1
-TRACE_FILE=$(ls "$MUGIWARA_DIR/results/${MISSION}-trace.md" 2>/dev/null || true)
+TRACE_FILE=$(ls "$MUGIWARA_DIR/results/${MISSION}/"*trace*.md 2>/dev/null | head -1 || true)
 if [ -n "$TRACE_FILE" ] && [ -f "$TRACE_FILE" ]; then
-  HEAL_COUNT=$(grep -ci 'Wave 8\|wave 8\|heal' "$TRACE_FILE" 2>/dev/null || echo 0)
+  HEAL_COUNT=$(grep -ci '^.*Wave 8.*\|wave 8' "$TRACE_FILE" 2>/dev/null || echo 0)
   HEAL_CYCLE=$((HEAL_COUNT + 1))
 fi
 
-# evidence paths
-EVIDENCE=$(ls "$MUGIWARA_DIR/results/" 2>/dev/null | grep "$MISSION" | sed 's|^|.mugiwara/results/|' | tr '\n' ',' | sed 's/,$//' || true)
+# evidence paths — per-mission results folder (quoted printf, no sed — mission
+# name is allowlisted above, but avoid sed metacharacter semantics entirely)
+EVIDENCE=""
+for evf in "$MUGIWARA_DIR/results/${MISSION}/"*.md; do
+  [ -f "$evf" ] || continue
+  EVIDENCE="${EVIDENCE}${EVIDENCE:+,}.mugiwara/results/${MISSION}/$(basename "$evf")"
+done
 
-# skill version from package.json
+# skill version from package.json (argv-passing — never interpolate paths into node -e)
 SKILL_VERSION="1"
 if [ -f package.json ]; then
   PKG_JSON="$MUGIWARA_DIR/../package.json"
-  [ -f "$PKG_JSON" ] && SKILL_VERSION=$(python3 -c "import json; v=json.load(open('$PKG_JSON')).get('version','1'); print(v.split('.')[0])" 2>/dev/null || echo "1")
+  [ -f "$PKG_JSON" ] && SKILL_VERSION=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync(process.argv[1],'utf8')).version.split('.')[0])}catch(e){console.log('1')}" "$PKG_JSON" 2>/dev/null || echo "1")
 fi
 
 # tokens from env var (harness exports estimated tokens consumed)
@@ -126,41 +155,59 @@ elif [ "$BUDGET" -gt 0 ] && [ "$TOKENS_EST" -ge "$WARN_AT" ] 2>/dev/null; then
   STATUS="warn"
 fi
 
-SENSITIVE_ARR=""
-if [ -n "$SENSITIVE_PATHS" ]; then
-  SENSITIVE_ARR=$(echo "$SENSITIVE_PATHS" | tr ',' '\n' | sed 's/^/"/;s/$/"/' | tr '\n' ',' | sed 's/,$//')
-fi
-EVIDENCE_ARR=""
-if [ -n "$EVIDENCE" ]; then
-  EVIDENCE_ARR=$(echo "$EVIDENCE" | tr ',' '\n' | sed 's/^/"/;s/$/"/' | tr '\n' ',' | sed 's/,$//')
-fi
-
 mkdir -p "$MUGIWARA_DIR"
 
-cat > "$STATE_FILE" <<JSON
-{
-  "mission": "$MISSION",
-  "actor": "$ACTOR",
-  "branch": "$BRANCH",
-  "lane": "$LANE",
-  "lane_reason": "$LANE_REASON",
-  "wave": $WAVE,
-  "mode": "$MODE",
-  "base_sha": "$BASE_SHA",
-  "head_sha": "$HEAD_SHA",
-  "files_touched": $FILES_TOUCHED,
-  "loc_delta": $LOC_DELTA,
-  "sensitive_paths": [${SENSITIVE_ARR}],
-  "tasks": { "done": $TASKS_DONE, "total": $TASKS_TOTAL },
-  "blockers_open": $BLOCKERS_OPEN,
-  "heal_cycle": $HEAL_CYCLE,
-  "tokens_est": $TOKENS_EST,
-  "budget": $BUDGET,
-  "budget_status": "$STATUS",
-  "skill_version": "$SKILL_VERSION",
-  "evidence": [${EVIDENCE_ARR}],
-  "updated_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-}
-JSON
+# --- lane-rise compare (F9): read previous state, flag escalation ---
+LANE_PREV=""
+LANE_ROSE=false
+if [ -f "$STATE_FILE" ]; then
+  LANE_PREV=$(node -e "try{const s=require(process.argv[1]);process.stdout.write(s.lane||'')}catch(e){process.stdout.write('')}" "$STATE_FILE" 2>/dev/null || true)
+  if [ -n "$LANE_PREV" ] && [ "$LANE_PREV" != "$LANE" ]; then
+    # lane order: direct < lean < standard < full < spike (spike resizes, not a rise)
+    case "$LANE_PREV:$LANE" in
+      direct:lean|direct:standard|direct:full|lean:standard|lean:full|standard:full) LANE_ROSE=true ;;
+      *) LANE_ROSE=false ;;
+    esac
+  fi
+fi
 
+node -e "
+const data = {
+  mission: process.argv[1],
+  actor: process.argv[2],
+  branch: process.argv[3],
+  lane: process.argv[4],
+  lane_reason: process.argv[5],
+  lane_prev: process.argv[24] || null,
+  lane_rose: process.argv[25] === 'true',
+  wave: parseInt(process.argv[6], 10),
+  mode: process.argv[7],
+  base_sha: process.argv[8],
+  head_sha: process.argv[9],
+  files_touched: parseInt(process.argv[10], 10),
+  loc_delta: parseInt(process.argv[11], 10),
+  sensitive_paths: process.argv[12] ? process.argv[12].split(',').filter(Boolean) : [],
+  tasks: { done: parseInt(process.argv[13], 10), total: parseInt(process.argv[14], 10) },
+  blockers_open: parseInt(process.argv[15], 10),
+  heal_cycle: parseInt(process.argv[16], 10),
+  tokens_est: parseInt(process.argv[17], 10) || 0,
+  budget: parseInt(process.argv[18], 10) || 0,
+  budget_status: process.argv[19],
+  skill_version: process.argv[20],
+  evidence: process.argv[21] ? process.argv[21].split(',').filter(Boolean) : [],
+  updated_at: process.argv[22]
+};
+require('fs').writeFileSync(process.argv[23], JSON.stringify(data, null, 2) + '\n');
+" \
+  "$MISSION" "$ACTOR" "$BRANCH" "$LANE" "$LANE_REASON" \
+  "$WAVE" "$MODE" "$BASE_SHA" "$HEAD_SHA" "$FILES_TOUCHED" \
+  "$LOC_DELTA" "$SENSITIVE_PATHS" "$TASKS_DONE" "$TASKS_TOTAL" \
+  "$BLOCKERS_OPEN" "$HEAL_CYCLE" "$TOKENS_EST" "$BUDGET" \
+  "$STATUS" "$SKILL_VERSION" "$EVIDENCE" \
+  "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  "$STATE_FILE" "$LANE_PREV" "$LANE_ROSE"
+
+if [ "$LANE_ROSE" = true ]; then
+  echo "⚠ LANE ROSE: $LANE_PREV → $LANE ($LANE_REASON) — escalate per check-in protocol"
+fi
 echo "✓ savepoint written: $STATE_FILE (lane=$LANE, wave=$WAVE, files=$FILES_TOUCHED)"

package/scripts/validate-content.ts

@@ -14,7 +14,7 @@ function checkFile(file: string, wantName: string, kind: 'skill' | 'agent'): Rec
   const { data, body } = parsed;
   if (data.name !== wantName) errors.push(`${kind} ${file}: name "${data.name}" != "${wantName}"`);
   const d = data.description ?? '';
-  if (kind === 'skill' && (d.length < 20 || d.length > 500)) errors.push(`skill ${file}: description must be 20-500 chars (got ${d.length})`);
+  if (kind === 'skill' && (d.length < 20 || d.length > 220)) errors.push(`skill ${file}: description must be 20-220 chars (got ${d.length})`);
   if (kind === 'agent' && d.length < 20) errors.push(`agent ${file}: description too short`);
   if (kind === 'skill' && body.replace(/\r?\n$/, '').split(/\r?\n/).length > 120) errors.push(`skill ${file}: body exceeds 120 lines`);
   if (kind === 'skill' && !body.includes('## Skip when')) errors.push(`skill ${file}: missing required "## Skip when" block (≤4 lines, numeric threshold)`);
@@ -27,6 +27,30 @@ function checkFile(file: string, wantName: string, kind: 'skill' | 'agent'): Rec
     if (bullets.length === 0) errors.push(`skill ${file}: "## Skip when" needs ≥1 bullet`);
     if (bullets.length > 4) errors.push(`skill ${file}: "## Skip when" block exceeds 4 bullets`);
   }
+  if (kind === 'skill') {
+    const lines = body.split(/\r?\n/);
+    const headingRe = /^## /;
+    const sections: { heading: string; start: number; end: number }[] = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (headingRe.test(lines[i])) sections.push({ heading: lines[i].replace(/^## /, ''), start: i, end: 0 });
+    }
+    for (let si = 0; si < sections.length; si++) {
+      sections[si].end = si + 1 < sections.length ? sections[si + 1].start : lines.length;
+      // count non-empty, non-table, non-code-fence content lines
+      let inFence = false;
+      let contentLines = 0;
+      for (let li = sections[si].start; li < sections[si].end; li++) {
+        const l = lines[li].trim();
+        if (!l) continue;
+        if (l.startsWith('```')) { inFence = !inFence; continue; }
+        if (inFence) continue;
+        if (l.startsWith('|') || l.startsWith('- |')) continue;
+        contentLines++;
+      }
+      if (contentLines >= 20) errors.push(`skill ${file}: section "${sections[si].heading}" is ${contentLines} content lines (≥20) — move to references/`);
+      else if (contentLines >= 15) console.warn(`⚠  skill ${file}: section "${sections[si].heading}" is ${contentLines} content lines (≥15, consider moving to references/)`);
+    }
+  }
   return data;
 }
 
@@ -110,6 +134,59 @@ for (const dir of skillDirs) {
   if (dir !== 'mugiwara-workflow' && !usedSkills.has(dir)) errors.push(`skill ${dir}: not referenced by any agent`);
 }
 
+// --- write-scope gate (F2): every agent declares a scope; only executors may write source ---
+const SOURCE_SCOPED = new Set(['zoro-execution', 'brook-healing']);
+for (const f of agentFiles) {
+  const name = f.replace(/\.md$/, '');
+  const parsed = parseFrontmatter(readFileSync(join(agentDir, f), 'utf8'));
+  const scope = parsed.data['write-scope'];
+  if (!scope) { errors.push(`agent ${f}: missing write-scope (artifacts | source)`); continue; }
+  if (scope !== 'artifacts' && scope !== 'source') errors.push(`agent ${f}: write-scope must be artifacts | source (got "${scope}")`);
+  if (scope === 'source' && !SOURCE_SCOPED.has(name)) errors.push(`agent ${f}: only zoro-execution and brook-healing may declare write-scope: source`);
+}
+
+// --- hub-rule gate (F3): every non-Luffy agent carries both hub sections ---
+for (const f of agentFiles) {
+  const name = f.replace(/\.md$/, '');
+  if (name === 'luffy-orchestrator') continue;
+  const text = readFileSync(join(agentDir, f), 'utf8');
+  if (!text.includes('## Before you start')) errors.push(`agent ${f}: missing "## Before you start" entry protocol`);
+  if (!text.includes('## Return to Luffy')) errors.push(`agent ${f}: missing "## Return to Luffy" hub rule`);
+}
+
+// --- hub-skill gate (F3): every agent lists mugiwara-orchestration (the hub rule's home) ---
+for (const f of agentFiles) {
+  const parsed = parseFrontmatter(readFileSync(join(agentDir, f), 'utf8'));
+  const skills = (parsed.data.skills ?? '').split(',').map(s => s.trim());
+  if (!skills.includes('mugiwara-orchestration')) errors.push(`agent ${f}: missing mugiwara-orchestration in skills (hub rule lives there)`);
+}
+
+// --- handoff-target gate (F4): a body naming another crew member as a handoff
+// target without Luffy in the same line fails CI ---
+const HANDOFF_CREW = ['usopp', 'nami', 'zoro', 'chopper', 'sanji', 'franky', 'robin', 'jinbe', 'brook', 'skeptic', 'memory-keeper', 'resume-coordinator', 'eval-runner'];
+// Verb class covers direct handoff language plus synonyms (route/send/pass/
+// escalate/delegate/transfer) so the F4 gate does not leak through paraphrase.
+const handoffRe = new RegExp(`\\b(hand to|hand off to|dispatch|route to|send to|pass to|escalate to|delegate to|transfer to)\\s+(?:a\\s+|another\\s+|the\\s+)?(?:crew members?|${HANDOFF_CREW.join('|')})`, 'i');
+// Negation must DIRECTLY precede the handoff verb, not sit anywhere in the
+// line ("do not hand off" later in the same line is a different clause).
+const NEGATION_VERB = /\b(never|not|no|don't|do not)\s+(hand|dispatch|route|send|pass|escalate|delegate|transfer)\b/i;
+for (const f of [...agentFiles, ...skillDirs.map(d => join(root, 'skills', d, 'SKILL.md'))]) {
+  if (!existsSync(f)) continue;
+  const text = readFileSync(f, 'utf8');
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const m = handoffRe.exec(line);
+    if (!m) continue;
+    // clause boundary: only the clause containing the handoff verb counts
+    const clauseStart = line.lastIndexOf('.', m.index) + 1;
+    const clause = line.slice(clauseStart, m.index + m[0].length);
+    if (NEGATION_VERB.test(clause)) continue;      // "never dispatch X" — constraint
+    if (/\bLuffy\b|to Luffy\b/.test(line)) continue; // hub named in same line ("main thread" is NOT the hub — Luffy is)
+    errors.push(`handoff leak ${f.replace(root + '/', '')}:${i + 1}: "${line.trim()}" — handoff target must be Luffy or name Luffy in the same line`);
+  }
+}
+
 // --- manifest-sync check: .claude-plugin/plugin.json must set-equal content/ ---
 const manifestArg = process.argv.indexOf('--check-manifest');
 if (manifestArg !== -1) {
@@ -188,20 +265,20 @@ if (totalDescChars > INDEX_BUDGET) {
 const docsArg = process.argv.indexOf('--check-docs');
 if (docsArg !== -1) {
   const docsDir = join(import.meta.dirname, '..', 'docs');
-  const skillsDoc = join(docsDir, 'skills.md');
-  const agentsDoc = join(docsDir, 'agents.md');
+const skillsDoc = join(docsDir, 'concepts', 'skills.md');
+const agentsDoc = join(docsDir, 'concepts', 'agents.md');
   let docErrors = 0;
 
   if (existsSync(skillsDoc)) {
     const content = readFileSync(skillsDoc, 'utf8');
     for (const dir of skillDirs) {
       if (!content.includes(dir)) {
-        errors.push(`docs/skills.md: missing skill "${dir}"`);
+        errors.push(`docs/concepts/skills.md: missing skill "${dir}"`);
         docErrors++;
       }
     }
   } else {
-    errors.push('docs/skills.md: file not found');
+    errors.push('docs/concepts/skills.md: file not found');
     docErrors++;
   }
 
@@ -210,12 +287,12 @@ if (docsArg !== -1) {
     for (const f of agentFiles) {
       const name = f.replace(/\.md$/, '');
       if (!content.includes(name)) {
-        errors.push(`docs/agents.md: missing agent "${name}"`);
+        errors.push(`docs/concepts/agents.md: missing agent "${name}"`);
         docErrors++;
       }
     }
   } else {
-    errors.push('docs/agents.md: file not found');
+    errors.push('docs/concepts/agents.md: file not found');
     docErrors++;
   }
 

package/scripts/verify-install.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env bun
+// scripts/verify-install.ts — G1: verify all references/*.md pointers resolve after install.
+// Installs to temp dir for one target per tier, then checks every pointer.
+
+import { existsSync, mkdtempSync, rmSync, readFileSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { installTo } from '../src/installer.ts';
+import { targets } from '../src/targets/index.ts';
+
+const tierTargets = [
+  { id: 'claude', tier: 1 },
+  { id: 'codex', tier: 2 },
+  { id: 'kilo', tier: 3 },
+];
+
+let total = 0;
+let broken = 0;
+
+for (const tt of tierTargets) {
+  const target = targets[tt.id];
+  if (!target) { console.log(`⚠  target ${tt.id} not found, skipping`); continue; }
+  const dir = mkdtempSync(join(tmpdir(), `mugi-verify-${tt.id}-`));
+  try {
+    installTo(target, { scope: 'project', projectDir: dir, dryRun: false, force: true });
+
+    const skillsDir = target.paths({ scope: 'project', projectDir: dir, home: '' }).skillsDir;
+    const mugiwaraRefsDir = join(dir, '.mugiwara', 'refs');
+
+    function findSkillFiles(root: string): string[] {
+      const out: string[] = [];
+      if (!existsSync(root)) return out;
+      for (const ent of readdirSync(root, { withFileTypes: true })) {
+        const p = join(root, ent.name);
+        if (ent.isDirectory()) out.push(...findSkillFiles(p));
+        else if (ent.name.endsWith('.md')) out.push(p);
+      }
+      return out;
+    }
+
+    const skillFiles = findSkillFiles(skillsDir)
+      .filter(f => !f.replace(skillsDir, '').includes('/references/'));
+
+    for (const file of skillFiles) {
+      const body = readFileSync(file, 'utf8');
+      const refs = [...body.matchAll(/`([^`]*references\/[^`]+\.md)`/g)];
+
+      for (const m of refs) {
+        total++;
+        const pointer = m[1];
+        const localResolve = join(dirname(file), pointer);
+        const mugiwaraResolve = join(mugiwaraRefsDir, pointer.replace(/^(?:_shared\/)?references\//, ''));
+        const resolved = [localResolve, mugiwaraResolve].find(p => existsSync(p));
+
+        if (!resolved) {
+          broken++;
+          const relFile = file.replace(dir + '/', '');
+          console.log(`✗ ${relFile}: \`${pointer}\` → not found`);
+        }
+      }
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+if (broken > 0) {
+  console.log(`\n✗ ${broken}/${total} pointers cannot resolve after install`);
+  process.exit(1);
+}
+
+console.log(`✓ ${total} pointers checked across ${tierTargets.length} targets — all resolve`);

package/src/args.ts

@@ -9,7 +9,7 @@ export type Args = {
 const VALUE_FLAGS: Record<string, string> = { '--project': 'project', '--target': 'target' };
 const BOOL_FLAGS: Record<string, string> = {
   '--global': 'global', '--yes': 'yes', '-y': 'yes', '--force': 'force',
-  '--dry-run': 'dryRun', '--keep-logs': 'keepLogs',
+  '--dry-run': 'dryRun', '--keep-logs': 'keepLogs', '--check': 'check',
   '--help': 'help', '-h': 'help', '--version': 'version', '-v': 'version',
 };
 

package/src/cli.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 // src/cli.ts
-import { existsSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { parseArgs, type FlagValue, type Args } from './args.ts';
 import { createRl, choose, multiChoose, confirm } from './prompt.ts';
 import { targets, TARGET_IDS } from './targets/index.ts';
@@ -43,12 +43,15 @@ function resetCmd(flags: Args['flags']): void {
 
 async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; projectDir: string; targetIds: string[] }> {
   const interactive = !flag(flags.yes);
+  if (interactive && !process.stdin.isTTY) {
+    throw new Error('Not a terminal. Run with --yes and --global or --project <dir> --target <ids|all>');
+  }
   const rl = interactive ? createRl() : null;
   try {
     let scope: Scope | null = 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';
+      if (!interactive) { scope = 'project'; }
+      else 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' && !existsSync(projectDir)) throw new Error(`Project dir not found: ${projectDir}`);
@@ -56,9 +59,11 @@ async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; pro
     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]);
+      if (!interactive) { targetIds = [...TARGET_IDS]; }
+      else {
+        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)`);
@@ -110,7 +115,17 @@ async function uninstall(flags: Args['flags']): Promise<void> {
   const home = homedir();
   const file = manifestPath({ scope, projectDir, home });
   const manifest = readManifest(file);
-  if (!manifest) { console.log('Nothing installed (no manifest found).'); return; }
+  if (!manifest) {
+    if (scope === 'project') {
+      const globalFile = manifestPath({ scope: 'global', projectDir, home });
+      if (existsSync(globalFile)) {
+        console.log('No project manifest found, but a global install exists. Try:\n  mugiwara uninstall --global');
+        return;
+      }
+    }
+    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();
@@ -119,7 +134,20 @@ async function uninstall(flags: Args['flags']): Promise<void> {
     if (!ok) { console.log('Aborted.'); return; }
   }
   const removed = removeInstalled(manifest, { dryRun: flag(flags.dryRun) });
-  if (!flag(flags.dryRun)) rmSync(file);
+  if (!flag(flags.dryRun)) {
+    rmSync(file);
+    const mugiDir = join(scope === 'global' ? home : projectDir, '.mugiwara');
+    if (existsSync(mugiDir) && readdirSync(mugiDir).length === 0) {
+      rmSync(mugiDir, { recursive: true, force: true });
+    }
+    if (manifest.targets.includes('opencode')) {
+      const opencodeCache = join(home, '.cache', 'opencode', 'packages', '@ionivetech');
+      if (existsSync(opencodeCache)) {
+        rmSync(opencodeCache, { recursive: true, force: true });
+        console.log('   cleared opencode npm cache (stale plugin versions)');
+      }
+    }
+  }
   console.log(`OK removed ${removed.length} files`);
 }
 
@@ -134,7 +162,12 @@ function list(flags: Args['flags']): void {
     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 (flag(flags.check)) {
+      const missing = m.files.filter(f => !existsSync(f));
+      console.log(`${label}: v${m.version} targets=${m.targets.join(',')} files=${m.files.length} missing=${missing.length} installed=${m.installedAt}`);
+    } else {
+      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.');
 }
@@ -143,10 +176,11 @@ function help(): void {
   console.log(`mugiwara ${VERSION} — the Straw Hat crew for AI agents
 
 Usage:
-  mugiwara [install]     install the crew (default; wizard when flags missing)
+  mugiwara [install]     install the crew (wizard; with --yes uses project + all)
   mugiwara update        replace existing files (backs up differences first)
   mugiwara uninstall     remove installed files via manifest
   mugiwara list          show installations
+  mugiwara list --check  health check: show installations + missing files
   mugiwara reset         wipe mission state (spec/plans/results/review/issues[/logs])
   mugiwara --help        this help
   mugiwara --version     print version
@@ -155,21 +189,14 @@ Flags:
   --global               user-wide install
   --project <dir>        project install (default: cwd)
   --target <ids|all>     comma-separated: ${TARGET_IDS.join(', ')}
-  --yes, -y              non-interactive (needs --global/--project, --target)
+  --yes, -y              non-interactive (defaults: project, all targets)
   --force                overwrite differing files (with backup)
   --dry-run              print actions without writing
+  --check                with list: report missing files (health check)
   --keep-logs            with reset: keep .mugiwara/logs (lessons ledger survives)`);
 }
 
-let entry = process.argv[1] !== undefined ? resolve(process.argv[1]) : undefined;
-if (entry !== undefined) {
-  try {
-    entry = realpathSync(entry);
-  } catch {
-    // ponytail: realpath can throw on a missing/odd path — fall back to the raw resolve
-  }
-}
-const isMain = entry !== undefined && import.meta.url === pathToFileURL(entry).href;
+const isMain = process.argv[1] !== undefined && fileURLToPath(import.meta.url) === resolve(process.argv[1]);
 if (isMain) {
   run(process.argv.slice(2)).catch(err => {
     console.error(`mugiwara: ${err.message}`);

package/src/frontmatter.ts

@@ -7,9 +7,9 @@ export function parseFrontmatter(text: string): { data: FrontmatterData; body: s
   const data: FrontmatterData = {};
   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();
+    const i = line.indexOf(': ');
+    if (i === -1) throw new Error(`Bad frontmatter line (missing ': ' separator): ${line}`);
+    data[line.slice(0, i).trim()] = line.slice(i + 2).trim();
   }
   return { data, body: text.slice(m[0].length) };
 }