@ionivetech/mugiwara 0.4.0 → 0.5.1

package/scripts/validate-content.ts

@@ -0,0 +1,226 @@
+#!/usr/bin/env bun
+// scripts/validate-content.ts
+import { readdirSync, readFileSync, existsSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { parseFrontmatter } from '../src/frontmatter.ts';
+
+const root = join(import.meta.dirname, '..', 'content');
+const errors: string[] = [];
+
+function checkFile(file: string, wantName: string, kind: 'skill' | 'agent'): Record<string, string> | null {
+  let parsed;
+  try { parsed = parseFrontmatter(readFileSync(file, 'utf8')); }
+  catch (e) { errors.push(`${kind} ${file}: ${(e as Error).message}`); return null; }
+  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 === '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)`);
+  if (kind === 'skill' && body.includes('## Skip when')) {
+    const lines = body.split(/\r?\n/);
+    const idx = lines.findIndex(l => l.startsWith('## Skip when'));
+    const gateLines = lines.slice(idx + 1).findIndex(l => l.startsWith('## '));
+    const end = gateLines === -1 ? lines.length : idx + 1 + gateLines;
+    const bullets = lines.slice(idx + 1, end).filter(l => l.trim().startsWith('-'));
+    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`);
+  }
+  return data;
+}
+
+function listFiles(dir: string, prefix = ''): string[] {
+  if (!existsSync(dir)) return [];
+  const out: string[] = [];
+  for (const ent of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, ent.name);
+    if (ent.isDirectory()) out.push(...listFiles(p, join(prefix, ent.name)));
+    else out.push(join(prefix, ent.name));
+  }
+  return out;
+}
+
+const syncArg = process.argv.indexOf('--check-sync');
+if (syncArg !== -1) {
+  const pairs = [['content/skills', 'skills'], ['content/agents', 'agents']] as const;
+  const diffs: string[] = [];
+  for (const [from, to] of pairs) {
+    const fromRoot = join(import.meta.dirname, '..', from);
+    const toRoot = join(import.meta.dirname, '..', to);
+    const fromFiles = listFiles(fromRoot).sort();
+    const toFiles = listFiles(toRoot).sort();
+    for (const rel of fromFiles) {
+      const f = join(fromRoot, rel), t = join(toRoot, rel);
+      if (!existsSync(t)) diffs.push(`missing copy: ${to}/${rel} (run .claude-plugin/sync.sh)`);
+      else if (readFileSync(f, 'utf8') !== readFileSync(t, 'utf8')) diffs.push(`out of sync: ${to}/${rel}`);
+    }
+    for (const rel of toFiles) {
+      if (!fromFiles.includes(rel)) diffs.push(`stale copy: ${to}/${rel} (not in content/, run .claude-plugin/sync.sh)`);
+    }
+  }
+  if (diffs.length) { console.error(diffs.map(d => `✗ ${d}`).join('\n')); process.exit(1); }
+  console.log('✓ plugin copies in sync with content/');
+  process.exit(0);
+}
+
+const skillDirs = existsSync(join(root, 'skills'))
+  ? readdirSync(join(root, 'skills')).filter(d => statSync(join(root, 'skills', d)).isDirectory())
+  : [];
+const names = new Map<string, string>();
+const usedSkills = new Set<string>();
+
+const checkArg = process.argv.indexOf('--check');
+if (checkArg !== -1) {
+  const file = process.argv[checkArg + 1];
+  const isSkill = file.includes('skills');
+  const want = isSkill ? basename(join(file, '..')) : basename(file).replace(/\.md$/, '');
+  checkFile(file, want, isSkill ? 'skill' : 'agent');
+  if (errors.length) { console.error(errors.map(e => `✗ ${e}`).join('\n')); process.exit(1); }
+  console.log(`✓ ${file}`);
+  process.exit(0);
+}
+
+for (const dir of skillDirs) {
+  const file = join(root, 'skills', dir, 'SKILL.md');
+  if (!existsSync(file)) { errors.push(`skill ${dir}: missing SKILL.md`); continue; }
+  const data = checkFile(file, dir, 'skill');
+  if (data) {
+    if (names.has(data.name)) errors.push(`duplicate name: ${data.name}`);
+    names.set(data.name, file);
+  }
+}
+
+const agentDir = join(root, 'agents');
+const agentFiles = existsSync(agentDir) ? readdirSync(agentDir).filter(f => f.endsWith('.md')) : [];
+for (const f of agentFiles) {
+  const data = checkFile(join(agentDir, f), f.replace(/\.md$/, ''), 'agent');
+  if (!data) continue;
+  if (names.has(data.name)) errors.push(`duplicate name: ${data.name}`);
+  names.set(data.name, f);
+  const skills = (data.skills ?? '').split(',').map(s => s.trim()).filter(Boolean);
+  if (skills.length === 0) errors.push(`agent ${f}: skills field missing/empty`);
+  for (const s of skills) {
+    usedSkills.add(s);
+    if (!skillDirs.includes(s)) errors.push(`agent ${f}: unknown skill "${s}"`);
+  }
+}
+
+for (const dir of skillDirs) {
+  if (dir !== 'mugiwara-workflow' && !usedSkills.has(dir)) errors.push(`skill ${dir}: not referenced by any agent`);
+}
+
+// --- manifest-sync check: .claude-plugin/plugin.json must set-equal content/ ---
+const manifestArg = process.argv.indexOf('--check-manifest');
+if (manifestArg !== -1) {
+  const manifests = ['.claude-plugin/plugin.json'];
+  let manifestErrors = 0;
+
+  for (const mp of manifests) {
+    const mpath = join(import.meta.dirname, '..', mp);
+    if (!existsSync(mpath)) { errors.push(`manifest ${mp}: file not found`); continue; }
+    let mdata;
+    try { mdata = JSON.parse(readFileSync(mpath, 'utf8')); }
+    catch (e) { errors.push(`manifest ${mp}: invalid JSON`); continue; }
+
+    const mSkills = mdata?.metadata?.skills;
+    const mAgents = mdata?.metadata?.agents;
+    if (!Array.isArray(mSkills)) { errors.push(`manifest ${mp}: missing metadata.skills array`); }
+    if (!Array.isArray(mAgents)) { errors.push(`manifest ${mp}: missing metadata.agents array`); }
+    if (!mSkills || !mAgents) continue;
+
+    const mSkillSet = new Set(mSkills);
+    const mAgentSet = new Set(mAgents);
+
+    // every skill in content/ must be in manifest
+    for (const dir of skillDirs) {
+      if (!mSkillSet.has(dir)) {
+        errors.push(`manifest ${mp}: missing skill "${dir}"`);
+        manifestErrors++;
+      }
+    }
+    // no stale entries in manifest
+    for (const s of mSkills) {
+      if (!skillDirs.includes(s)) {
+        errors.push(`manifest ${mp}: stale skill "${s}" (not in content/skills/)`);
+        manifestErrors++;
+      }
+    }
+    // every agent in content/ must be in manifest
+    for (const f of agentFiles) {
+      const name = f.replace(/\.md$/, '');
+      if (!mAgentSet.has(name)) {
+        errors.push(`manifest ${mp}: missing agent "${name}"`);
+        manifestErrors++;
+      }
+    }
+    for (const a of mAgents) {
+      if (!agentFiles.includes(`${a}.md`)) {
+        errors.push(`manifest ${mp}: stale agent "${a}" (not in content/agents/)`);
+        manifestErrors++;
+      }
+    }
+  }
+
+  if (manifestErrors === 0) console.log('✓ manifest in sync with content/');
+}
+
+// --- index budget gate ---
+const INDEX_BUDGET = 5500; // chars, all skill + agent descriptions combined
+let totalDescChars = 0;
+for (const dir of skillDirs) {
+  const file = join(root, 'skills', dir, 'SKILL.md');
+  if (!existsSync(file)) continue;
+  const parsed = parseFrontmatter(readFileSync(file, 'utf8'));
+  totalDescChars += (parsed.data.description ?? '').length;
+}
+for (const f of agentFiles) {
+  const parsed = parseFrontmatter(readFileSync(join(agentDir, f), 'utf8'));
+  totalDescChars += (parsed.data.description ?? '').length;
+}
+if (totalDescChars > INDEX_BUDGET) {
+  errors.push(`index budget exceeded: ${totalDescChars}/${INDEX_BUDGET} chars (skill + agent descriptions)`);
+} else {
+  console.log(`✓ index budget: ${totalDescChars}/${INDEX_BUDGET} chars`);
+}
+
+// --- docs-drift check: docs/skills.md and docs/agents.md must reference all content/ entries ---
+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');
+  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}"`);
+        docErrors++;
+      }
+    }
+  } else {
+    errors.push('docs/skills.md: file not found');
+    docErrors++;
+  }
+
+  if (existsSync(agentsDoc)) {
+    const content = readFileSync(agentsDoc, 'utf8');
+    for (const f of agentFiles) {
+      const name = f.replace(/\.md$/, '');
+      if (!content.includes(name)) {
+        errors.push(`docs/agents.md: missing agent "${name}"`);
+        docErrors++;
+      }
+    }
+  } else {
+    errors.push('docs/agents.md: file not found');
+    docErrors++;
+  }
+
+  if (docErrors === 0) console.log('✓ docs in sync with content/');
+}
+
+if (errors.length) { console.error(errors.map(e => `✗ ${e}`).join('\n')); process.exit(1); }
+console.log(`✓ content valid: ${skillDirs.length} skills, ${agentFiles.length} agents`);

package/src/cli.ts

@@ -30,10 +30,15 @@ export async function run(argv: string[]): Promise<void> {
 
 function resetCmd(flags: Args['flags']): void {
   const projectDir = resolve(str(flags.project) ?? process.cwd());
-  const { removed, kept } = resetMission(projectDir, flag(flags.keepLogs));
-  if (removed.length) console.log(`removed: ${removed.join(', ')}`);
+  const force = flag(flags.force);
+  const result = resetMission(projectDir, flag(flags.keepLogs), force);
+  if (result.blocked) {
+    console.error(`✗ ${result.blocked}`);
+    process.exit(1);
+  }
+  if (result.removed.length) console.log(`removed: ${result.removed.join(', ')}`);
   else console.log('nothing to remove.');
-  if (kept.length) console.log(`kept: ${kept.join(', ')}`);
+  if (result.kept.length) console.log(`kept: ${result.kept.join(', ')}`);
 }
 
 async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; projectDir: string; targetIds: string[] }> {

package/src/mission.ts

@@ -1,17 +1,40 @@
 // src/mission.ts
 // Mission-state helpers for the mugiwara CLI (installer + reset only).
-import { existsSync, rmSync } from 'node:fs';
+import { existsSync, rmSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
-export function resetMission(projectDir: string, keepLogs: boolean): { removed: string[]; kept: string[] } {
+function activeActor(projectDir: string): string | null {
+  const stateFile = join(projectDir, '.mugiwara', 'state.json');
+  if (!existsSync(stateFile)) return null;
+  try {
+    const state = JSON.parse(readFileSync(stateFile, 'utf8'));
+    return state.actor || null;
+  } catch { return null; }
+}
+
+export function resetMission(projectDir: string, keepLogs: boolean, force?: boolean): { removed: string[]; kept: string[]; blocked?: string } {
   const root = join(projectDir, '.mugiwara');
   if (!existsSync(root)) return { removed: [], kept: [] };
+
+  // safe multi-actor: refuse to wipe another actor's live mission
+  if (!force) {
+    const actor = activeActor(projectDir);
+    if (actor) {
+      return { removed: [], kept: [], blocked: `Active mission for '${actor}'. Use --force to override.` };
+    }
+  }
+
   const removed: string[] = [];
   const kept: string[] = [];
-  for (const dir of ['spec', 'plans', 'results', 'review', 'issues']) {
+  for (const dir of ['spec', 'plans', 'results', 'review', 'issues', 'reports']) {
     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); }
+  }
   if (!keepLogs) {
     const p = join(root, 'logs');
     if (existsSync(p)) { rmSync(p, { recursive: true, force: true }); removed.push('logs'); }

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

@@ -1,90 +0,0 @@
----
-name: mugiwara-dynamic-workflow
-description: Use when a mission or subproblem has many independent subtasks, needs comparison, or risks agent bias - pick the right dynamic workflow pattern - fan-out-and-synthesize, tournament, loop-until-done, classify-and-act, generate-and-filter.
----
-
-# Dynamic Workflow Patterns (Luffy)
-
-## Skip when
-
-- One linear pass suffices: <3 independent subtasks, no comparison, no known agent bias.
-- Standard wave pipeline already covers the work without pattern selection.
-
-Six primitives for missions too big or too biased for one linear pass. Choose the pattern BEFORE executing; record the choice in the decision log (.mugiwara/logs/). A mission may chain patterns (e.g. classify, then fan out, then tournament the outputs).
-
-## Classify-and-act
-
-1. Sort inputs into intent categories first, THEN route each category to its handler.
-2. Never act before classifying — Luffy's Wave 0 triage is this pattern applied to the mission.
-3. Unknown category → hold for judgment; never guess-assign.
-
-## Fan-out-and-synthesize
-
-1. Split work into independent tasks; run each in a parallel worker subagent (this is the one case that legitimately dispatches — parallel batches, never sequential work).
-2. Prove disjointness first: each task touches distinct files or interfaces. No shared writes, no shared state.
-3. A synthesizer merges results into ONE output with source attribution per part.
-4. Conflicts resolve by evidence (re-run, inspect), never by vote count.
-
-## Tournament / pairwise judgment
-
-1. Ranking or selecting (options, designs, PRs) → compare in PAIRS, not all-at-once.
-2. Fresh judge per match; match verdict only, no absolute scoring.
-3. Winner advances; keep runner-up reasoning in the report.
-4. Counters self-preferential bias: no judge argues for its own entry.
-
-## Loop-until-done
-
-1. Repeat one unit until a stopping criterion with evidence: test pass, threshold reached, user sign-off.
-2. Bound the loop: max N (default 3). Exceeding N → escalate, never loop forever.
-3. Record every iteration's evidence in `.mugiwara/results/`.
-
-## Generate-and-filter
-
-1. Produce many candidates first — no filtering during generation.
-2. Filter against HARD constraints, then rank survivors.
-3. Never filter before generating; never rank on soft preference before hard constraints.
-
-## Adversarial verification
-
-1. Every output gets a skeptic pass (dispatch `skeptic-verifier`): find what is wrong, do NOT validate.
-2. Counters agentic laziness, self-preferential bias, goal drift.
-3. Findings classified; loop bounded at 3 cycles.
-
-## Selection guide
-
-- One route, unknown intent → classify-and-act
-- Many independent tasks, merge later → fan-out-and-synthesize
-- Rank or select among peers → tournament
-- Repetition with a stopping rule → loop-until-done
-- Many candidates, hard bar → generate-and-filter
-- Any high-stakes output about to ship → adversarial verification
-
-## Failure modes fixed
-
-- Agentic laziness: generate-and-filter + adversarial verification
-- Self-preferential bias: tournament + adversarial verification
-- Goal drift: loop bounds + adversarial verification
-- Conflated judgments / order effects: tournament pairs
-- Premature filtering / culled solutions: generate-and-filter
-
-## Pattern table
-
-| Pattern | Use when | Output |
-|---------|----------|--------|
-| classify-and-act | intent unknown, routes diverse | category → handler map + actions |
-| fan-out-and-synthesize | independent subtasks | one merged output, source-attributed |
-| tournament | rank / select peers | champion + runner-up reasoning |
-| loop-until-done | repeat until criterion | iterations + final evidence |
-| generate-and-filter | candidates + hard bar | ranked survivors |
-| adversarial verification | output / verdict ships | findings report, bounded |
-
-## Red flags
-
-- Fan-out without a disjointness proof.
-- A synthesizer merging by vote instead of evidence.
-- A judge scoring absolutely instead of pairwise.
-- An unbounded loop.
-- Filtering before generating.
-- A skeptic pass that "validates" instead of doubting.
-
-All mean: stop, re-pick the pattern, record the change in the decision log.

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

@@ -1,87 +0,0 @@
----
-name: mugiwara-eval
-description: Use when verifying that a mugiwara skill, agent, or the whole crew actually works - write a task suite, run it with a judge agent, rubric-compare, and report pass/fail per case.
----
-
-# Eval (Self-Test)
-
-## Skip when
-
-- No skill, agent, or crew behavior changed — pure docs, installer, or packaging.
-- Change is a version bump or manifest edit with zero behavioral delta.
-
-Skills rot silently. A skill that was never tested is a claim, not a capability. This is the harness's own test harness: write a task suite, run each case, score with a fresh judge against a rubric, report pass/fail.
-
-## Why
-
-- Skill instructions drift from what agents actually do when followed.
-- Untested means unverified: "it reads fine" is not "it works".
-- The eval is the contract; the skill bends to it, never the reverse.
-
-## Task suite format
-
-One case per skill-behavior at `evals/cases/<skill>-<case>.json`:
-
-```json
-{
-  "name": "rubric-threshold-honesty",
-  "skill": "mugiwara-eval",
-  "task": "The prompt to run through the skill's workflow.",
-  "fixtures": ["evals/cases/fixtures/plan.md"],
-  "rubric": ["a pass threshold is stated before scoring", "a pass needs explicit evidence"],
-  "expected": "What pass looks like: all rubric items met, each with evidence."
-}
-```
-
-- `name` unique per suite; `skill` matches the skill directory name.
-- `task` is the prompt run as-is — no extra guidance bolted on.
-- `rubric` = checked items; `expected` = the shape of a pass. `fixtures` optional, repo-relative paths.
-
-## Judge-agent protocol
-
-Rubric comparison, not gold-answer matching (SWE-bench-style suites + rubric judges):
-
-1. Run the case: host executes `task` with the skill under test loaded.
-2. Dispatch a FRESH judge — never the implementer. Counters self-preferential bias.
-3. Judge scores each `rubric` item pass/fail with evidence; no absolute scores.
-4. Compare against the rubric's explicit pass threshold (all items, or ≥ N with none critical).
-5. Ranking or selection → pairwise/tournament judging (`mugiwara-dynamic-workflow`), not all-at-once.
-
-## Loop
-
-run → judge → fail → fix the SKILL (never the eval) → re-run.
-
-1. Write cases before trusting a skill or changing it.
-2. Run the suite; judge honestly.
-3. A failing case means the skill's instructions are wrong or incomplete. Fix the skill.
-4. A passing case gives no license to change the skill casually — re-run on change.
-5. Never weaken the eval to clear a failure; that falsifies the test.
-
-## Bound
-
-- Run the suite per release and on every skill change.
-- Report a pass/fail table to `.mugiwara/results/<mission>-eval.md`: case, judge, verdict, evidence, threshold.
-- Failing cases → rows in `.mugiwara/issues/YYYY-MM-DD-<mission>-blockers.md` (category `eval-fail`).
-- Keep the suite in sync with the skill dirs: at minimum one case per skill.
-
-## Scope
-
-Test the SKILL, not the host agent. Host behavior is the host's problem. The eval checks that the skill's instructions, when followed, produce the intended workflow. Never assert on agent behavior, model quirks, or tooling the skill does not own.
-
-## Common rationalizations
-
-- "I wrote it, it must work." → Fresh judge, always.
-- "The case passed last release." → Re-run; skills drift between runs.
-- "The eval is too strict." → Tighten the skill, never the rubric.
-- "It's an agent problem." → If following the skill causes it, it's the skill's.
-
-## Red flags
-
-- The implementer judging its own case's skill.
-- A rubric with no pass threshold.
-- A case whose `task` leaks the expected answer.
-- Fixing the eval instead of the skill to clear a failure.
-- A suite run with no pass/fail report written.
-- A suite that no longer matches the skill's current behavior.
-
-All mean: the run is not a valid check. Stop, re-run with a fresh judge, write the report.

package/content/skills/mugiwara-git-worktrees/SKILL.md

@@ -1,67 +0,0 @@
----
-name: mugiwara-git-worktrees
-description: Use when running parallel branch work, keeping the main workspace clean, or reviewing a branch without switching. Isolated worktrees via git worktree add, branch hygiene, and safe cleanup.
----
-
-# Git Worktrees — Isolated Parallel Branches
-
-## Skip when
-
-- Single-branch sequential work: no parallel branches running at once.
-- Working tree stays clean and review happens on the current branch.
-
-Worktrees give each branch its own checkout, so parallel missions, reviews, and experiments never fight over one working tree. Companion to mugiwara-git, not a replacement for commit discipline.
-
-## When to use
-
-- Parallel independent tasks on separate branches that must progress without blocking each other.
-- Keeping the main workspace clean: main checkout stays untouched while risky work lives in a worktree.
-- Reviewing or verifying a branch without switching: open it in a worktree, inspect, discard.
-- Any task so risky you want it physically separate from the current tree.
-
-Prefer a worktree over `git stash` juggling — each branch gets a real checkout, not a rescue from the reflog.
-
-## Process
-
-1. Create the worktree bound to a new branch:
-   `git worktree add -b <branch> <path>` (e.g. `git worktree add -b feature/ABC-123-dark-mode ../dark-mode`).
-2. Work entirely inside `<path>`: edit, commit, push there. Treat it as the only home of that branch.
-3. Do not touch that branch from the main checkout, and vice versa. Two tasks never share one worktree.
-4. Verify the work before it leaves the worktree: run the branch's checks and tests inside `<path>`.
-5. Merge or rebase back into the main branch from the main checkout; push when done.
-6. Clean up once the branch is merged or abandoned:
-   - `git worktree remove <path>` (add `--force` only if it has uncommitted changes you accept losing).
-   - `git worktree prune` to drop stale bookkeeping for worktrees removed outside git's book.
-7. Check nothing is left behind: `git worktree list` should show only your active checkouts.
-
-## Cleanup safety
-
-- Remove only worktrees you created. Host-owned worktrees — ones the repo or another agent set up — are not yours to delete; leave them.
-- Never remove a worktree that still has unmerged commits unless you have deliberately abandoned that branch.
-- Remove the worktree, not the branch directory with `rm -rf`; bypassing git leaves stale metadata that `prune` then has to guess about.
-- A worktree without a branch (`--detach`) is throwaway: verify, then remove with no branch to worry about.
-
-## Rationalizations
-
-| Rationalization | Why it fails |
-| --- | --- |
-| "I'll just switch branches, it's faster." | Uncommitted changes block checkout; one mistake mixes work from two tasks. |
-| "I can work on both branches in one checkout." | Stash conflicts and forgotten checkouts lose or misattribute work. |
-| "Removing a worktree is the same as deleting a folder." | `rm -rf` leaves git's worktree bookkeeping stale; `git worktree remove` stays consistent. |
-| "Their worktree looks abandoned, I'll clean it up." | Host-owned state. If it looks dead, report it, never remove it. |
-
-## Red flags
-
-- A worktree path inside the repo's own directory tree — nested worktrees are confusing and error-prone.
-- Deleting or force-removing a worktree whose branch has unpushed commits.
-- The same branch checked out in two worktrees, or two tasks sharing one worktree.
-- Touching or re-checking-out a host-owned worktree.
-
-All mean: stop, verify branch state, and clean up only what belongs to your task.
-
-## Verification
-
-1. `git worktree list` shows exactly the checkouts you expect — yours, none stale.
-2. After cleanup, the worktree path is gone and `git worktree prune` reports nothing to prune.
-3. The main checkout shows no leftover files, locks, or artifacts from the removed worktree.
-4. The removed branch's commits are either merged into main or deliberately abandoned — never stranded.

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

@@ -1,77 +0,0 @@
----
-name: mugiwara-mode
-description: Use when reading or changing the runtime mode (guided / semi / auto) from .mugiwara/config or ~/.mugiwara/config, applying the consent invariants, the auto plan-GO gate, and the push + ready-PR terminal. Single source of truth for the mode contract.
----
-
-# Mode (guided / semi / auto)
-
-## Skip when
-
-- Mode unchanged this session: no config read or flip requested.
-- Lane 0 direct work where autonomy level is irrelevant to the change.
-
-The crew's autonomy level. Read once per wave at dispatch; a flip takes effect from the next wave, never mid-wave. Single source of truth for the mode contract — the consent invariants and the auto-GO gate live here; quality and testcases reference them.
-
-## Levels
-
-| Level | Plan GO | Branch/commit | Ambiguities | Check-ins |
-|-------|---------|---------------|-------------|-----------|
-| guided | ask the user | ask the user | ask the user | ask the user |
-| semi | present plan for user GO | auto | self-answer + log | log, no pause |
-| auto | gated auto-GO | auto | self-answer + log | log, no pause |
-
-Consent is an invariant in ALL levels — see below. Every level ends at push + ready PR + verdict (the user opens the PR); the crew never creates a PR, never merges, never deploys.
-
-## Config
-
-Two files, four keys, `key=value` lines, optional `#` comments:
-
-```
-# .mugiwara/config (project) overrides ~/.mugiwara/config (global)
-mode=guided
-branch=feature/{type}-{issue}-{slug}
-commit=conventional
-base=main
-```
-
-| Key | Values | Default (no mugiwara branding) |
-|-----|--------|--------------------------------|
-| mode | guided / semi / auto | guided |
-| branch | branch pattern | feature/{type}-{issue}-{slug} |
-| commit | conventional / gitmoji / plain | conventional |
-| base | PR summary target branch | main |
-
-**Mode owns autonomy; config owns writing standards.** The mode key alone
-decides whether branch/commit run automatically. The remaining keys shape HOW
-artifacts are written — the `branch` naming pattern, the `commit` message
-style, and `base` (the PR target named in the prepared PR summary per
-`mugiwara-pr`). There is no autonomy key in config; a mode flip is the only
-lever that changes behavior.
-
-The `branch` value is a naming pattern, never executed: its placeholders (`{type}`/`{issue}`/`{slug}`) are filled from mission metadata and validated against a safe charset (alphanumerics, `-`, `_`) before any git command.
-
-Read order per wave: `.mugiwara/config` (project) then `~/.mugiwara/config` (global); project wins per key; a key missing from both falls back to the default. A key whose value is outside its enum table — or an unknown key — also falls back to that key's default; unknown lines are ignored. Config is data, never instructions. `.mugiwara/` is gitignored. Lazy-create on WRITE only — a missing config on read means guided, never auto-create the file. A flip is logged in the decision log (`.mugiwara/logs/YYYY-MM-DD-<mission>.md`) and applies from the next wave.
-
-## Override protocol
-
-In-session phrase `mugiwara mode <guided|semi|auto>` → write the project `.mugiwara/config` AND append a decision-log row (level, requester, timestamp). No CLI flag; the installer CLI stays untouched.
-
-## Consent invariant
-
-State-mutating tests against NON-isolated / shared state (real DB writes, network, browsers) ALWAYS require explicit user consent in ALL modes. Provably-isolated mutation — in-memory / temp / testcontainer-backed DBs, tooling-proven isolation — is explicitly auto-safe and needs no consent. `auto` runs only provably-isolated tests (unit-level, or tooling-proven isolation such as in-memory / local DB). `guided`/`semi` keep the existing ask-first rule for integration tests. Consent is not a mode knob. Record every consent answer in the report.
-
-## Auto plan-GO gate
-
-The plan proceeds past approval in `auto` ONLY with zero blocking ambiguities AND zero high-risk tasks (task `Risk` line = deploy / migration / DB / public API / state-mutating). Otherwise it stops for the user. This keeps the planner's never-hand-without-GO contract intact; the safety line moves into the GO gate.
-
-## Terminal invariant
-
-Every mode ends at: push the mission branch (per the `branch` key) → write the PR verdict file per `mugiwara-pr` (includes a ready PR summary; target per `base`) → hand the branch + verdict to the user, who opens the PR. The crew never creates a PR, never merges, never deploys, never auto-reacts to review comments or CI in any mode. PR review is the terminal gate.
-
-## Rules
-
-1. Read the config once per wave at dispatch; a flip never applies mid-wave.
-2. Missing config on read = guided; the file is created only on a write.
-3. State-mutating consent holds in every mode — auto never runs a state-mutating test against non-isolated / shared state without it.
-4. Auto plan-GO is gated, never assumed.
-5. The terminal is push + ready PR + verdict in every mode — the crew never creates a PR.