@ionivetech/mugiwara 0.1.2 → 0.2.0

package/docs/skills.md

@@ -0,0 +1,61 @@
+# The Techniques — 25 Skills
+
+Each skill is a portable markdown playbook — the "how to" the crew follows when
+it embodies a role. Skills are the actual content; agents are the personas.
+
+## Core pipeline
+
+| Skill | Enforces |
+|-------|----------|
+| `mugiwara-workflow` | The harness entry point: inline execution model, gateway triage, wave pipeline, workspace layout, blocker protocol, cleanup |
+| `mugiwara-orchestration` | Luffy's captain behavior: 5-way classifier, check-ins, work splitting, decision log, closure |
+| `mugiwara-brainstorm` | Usopp's critical sparring: interrogate, research facts, cut over-engineering, recommend |
+| `mugiwara-planning` | Interview-first, full-context scan, wave plans with parallel/sequential markers + anti-patterns |
+| `mugiwara-execution` | Todo list, sequential tasks inline + parallel worker batches, 6-field delegation for parallel work, one commit per logical task |
+| `mugiwara-checkpoint` | Verify-everything audit — deduped and scoped to the wave's diff; failure rows to the blocker ledger |
+| `mugiwara-quality` | Discover the project's real tooling; formatter, linter, unit tests under the consent matrix |
+| `mugiwara-gates` | Coverage ≥90% new / ≥80% modified, build validation, Definition of Done |
+| `mugiwara-review` | Doubt-driven review: breaking-change analysis, five-axis, severity-tagged findings |
+| `mugiwara-security` | OWASP-driven security review, untrusted-data doctrine, severity by exploitability × impact |
+| `mugiwara-healing` | Reads the ledger, Stop-the-Line + Prove-It root-cause fixes, rollback prep |
+
+## Mission control
+
+| Skill | Enforces |
+|-------|----------|
+| `mugiwara-mode` | Runtime levels guided / semi / auto, consent invariants, gated auto-GO, push + ready-PR terminal |
+| `mugiwara-git` | Atomic commits, save-points, multi-commit splitting, bisect/blame debugging |
+| `mugiwara-testcases` | User-test intake (ATDD): immutable-gold rule, declarative-AC routing, consent, failure adjudication |
+| `mugiwara-pr` | CI/CD loop terminal: one verdict file + push via plain git; stop-at-PR invariant |
+| `mugiwara-ship` | GO/NO-GO ship gate: pre-launch checklist, feature flags, rollback plan |
+| `mugiwara-deprecation` | Sunset & migration discipline: keep-or-retire gate, cutover playbooks, safe schema changes |
+| `mugiwara-resume` | Session resume: rebuild state from `.mugiwara/` after compaction/loss; never restart |
+| `mugiwara-lessons` | Cross-mission memory: actionable lessons ledger, read at triage, written at closure |
+| `mugiwara-observability` | Trace the crew: structured logs, OTel-compatible spans, session correlation |
+
+## Domain & advanced
+
+| Skill | Enforces |
+|-------|----------|
+| `mugiwara-frontend` | Anti-slop frontend: audit-first redesigns, design-system extraction, slop list |
+| `mugiwara-backend` | Backend/server code: repo standards first, API design, data integrity, error handling, security |
+| `mugiwara-agent-security` | Secure the agent layer: prompt injection, memory poisoning, excessive agency, secrets, sandboxing |
+| `mugiwara-dynamic-workflow` | Runtime workflow patterns: fan-out-and-synthesize, tournament, loop-until-done, classify-and-act |
+| `mugiwara-eval` | Test the harness itself: task suites, judge-agent rubric comparison, pass/fail per case |
+
+## Anatomy of a skill
+
+Every skill is a single `SKILL.md` with frontmatter + a playbook body:
+
+```markdown
+---
+name: mugiwara-checkpoint
+description: Use after an execution wave to audit results against the plan. ...
+---
+
+# Checkpoint (Chopper)
+
+<playbook: protocol, rules, red flags, iron law>
+```
+
+See [skill-anatomy.md](skill-anatomy.md) for the details.

package/docs/windsurf-setup.md

@@ -0,0 +1,16 @@
+# Windsurf Setup
+
+## Install
+
+```bash
+npx @ionivetech/mugiwara@latest --project ./my-app --target windsurf --yes
+```
+
+## What you get
+
+- 25 skills as rules files in `.devin/rules`.
+
+## Notes
+
+Windsurf is a **project-only** target. Skills-only — the crew pipeline runs
+through the rule files.

package/docs/workflow.md

@@ -0,0 +1,80 @@
+# The Wave Pipeline
+
+A mission runs as ten waves (plus one optional adversarial pass). Each wave is
+owned by one crew member and runs **inline** in the main conversation.
+
+| Wave | Owner | Skill | Output |
+|------|-------|-------|--------|
+| 0 Triage | Luffy | `mugiwara-orchestration` | 5-way route decision + reason |
+| 1 Brainstorm | Usopp | `mugiwara-brainstorm` | refined direction, options, recommendation |
+| 2 Planning | Nami | `mugiwara-planning` | plan doc: waves, tasks, acceptance criteria |
+| 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 (optional) |
+| 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; loops back to Wave 4, max 3 cycles |
+| 9 Closure | Luffy | `mugiwara-orchestration` | closure report + push + PR verdict handed to you |
+
+## Wave 0 — Triage
+
+Every mission starts at the Luffy gateway, which classifies the request 5 ways:
+
+| Class | Signal | Route |
+|-------|--------|-------|
+| Trivial | one obvious small change, no ambiguity | Wave 2 directly |
+| Explicit | clear requirements, written spec exists | Wave 2 directly |
+| Exploratory | needs direction, options, research | Wave 1 first |
+| Open-ended | broad goal, undefined scope | Wave 1 first |
+| Ambiguous | requirements, APIs, scope unclear | Wave 1 first |
+
+The decision + reason is logged in `.mugiwara/logs/`. Risk (money/security/
+data/public API) always triggers the full pipeline.
+
+## Wave 4 — Checkpoint (Chopper)
+
+The verify-everything gate. After execution, Chopper re-runs every acceptance
+criterion — but efficiently:
+
+- **Deduped**: each unique check command runs once per wave, scoped to the
+  files this wave changed. No running `npm test` once per task.
+- **Scoped by diff**: `git diff --name-only <wave-base>..HEAD` decides what
+  actually needs re-verification.
+- **Commit hygiene**: one `git log --stat` pass, not per-commit.
+- Failures land in the blocker ledger `.mugiwara/issues/` with honest
+  code-vs-env classification.
+
+## Wave 7 — Review
+
+Robin (doubt-driven review) and Jinbe (security) run in parallel. Robin maps
+breaking changes to callers before reading the diff; Jinbe runs STRIDE + OWASP.
+Findings are severity-tagged with path:line.
+
+## Wave 8 — Healing
+
+Brook reads the blocker ledger and fixes root causes, proving each fix by
+re-running the failed check. The loop returns to Wave 4 — max 3 cycles, then
+escalation to you.
+
+## Wave 9 — Closure
+
+Luffy runs the ship gate, writes the closure report, deletes superseded
+intermediate files, then the terminal step in every mode: **save-point commit →
+push the mission branch → write the PR verdict file → hand branch + verdict to
+you**, who opens the PR. The crew never creates a PR, merges, or deploys.
+
+## The two rules that hold it together
+
+1. **Evidence over claims.** No wave passes on assertion — the owning agent
+   runs the checks and shows output. "Subagents lie. No evidence = not
+   complete."
+2. **The plan is the source of truth.** From Wave 2 on, the plan doc in
+   `.mugiwara/plans/` holds the clean execution plan; the decision log holds the
+   who-and-why trace. No wave is skipped without the reason recorded.
+
+## Blocker protocol
+
+Any agent that hits a blocker appends a row
+(`wave | task | symptom | attempted | help-needed`) to the ledger and escalates.
+Never a silent workaround. Brook heals what the ledger lists.

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "@ionivetech/mugiwara",
-  "version": "0.1.2",
-  "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, self-healing. Installs into Claude Code, opencode, Copilot, Gemini, Codex, Windsurf, Cline, Kilo, Antigravity.",
+  "version": "0.2.0",
+  "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, self-healing. Installs into Claude Code, opencode, Copilot, Gemini, Codex, Cursor, Kimi, pi, Windsurf, Cline, Kilo, Antigravity.",
   "type": "module",
   "license": "MIT",
+  "main": "./.opencode/plugins/mugiwara.mjs",
+  "exports": {
+    ".": "./.opencode/plugins/mugiwara.mjs",
+    "./plugin": "./.opencode/plugins/mugiwara.mjs",
+    "./package.json": "./package.json"
+  },
   "bin": {
     "mugiwara": "dist/mugiwara.js"
   },
@@ -11,11 +17,18 @@
     "dist",
     "src",
     "content",
+    "docs",
+    ".opencode",
     "scripts/install.sh",
     "scripts/install.ps1",
     "README.md",
     "LICENSE"
   ],
+  "pi": {
+    "skills": [
+      "./content/skills"
+    ]
+  },
   "engines": {
     "node": ">=20.11"
   },
@@ -26,7 +39,8 @@
     "build": "bun build src/cli.ts --outfile dist/mugiwara.js --target node --format esm",
     "validate": "bun scripts/validate-content.ts",
     "evals": "bun scripts/run-evals.ts",
-    "prepack": "bun run build"
+    "sync-version": "bun scripts/sync-version.ts",
+    "prepack": "bun run build && bun run sync-version"
   },
   "keywords": [
     "ai",
@@ -34,9 +48,13 @@
     "skills",
     "claude-code",
     "opencode",
+    "opencode-plugin",
     "copilot",
     "gemini",
     "codex",
+    "cursor",
+    "kimi",
+    "pi",
     "windsurf",
     "cline",
     "multi-agent",

package/src/args.ts

@@ -6,7 +6,7 @@ export type Args = {
   flags: Record<string, FlagValue>;
 };
 
-const VALUE_FLAGS: Record<string, string> = { '--project': 'project', '--target': 'target', '--type': 'type' };
+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', '--help': 'help', '-h': 'help', '--version': 'version', '-v': 'version',

package/src/cli.ts

@@ -11,8 +11,6 @@ import { installTo, removeInstalled, VERSION, CONTENT_DIR } from './installer.ts
 import { manifestPath, readManifest, writeManifest, type Scope } from './manifest.ts';
 import { parseFrontmatter } from './frontmatter.ts';
 
-const TYPES = ['frontend', 'backend', 'fullstack', 'general'];
-
 const str = (v: FlagValue): string | undefined => (typeof v === 'string' ? v : undefined);
 const flag = (v: FlagValue): boolean => v === true;
 
@@ -30,7 +28,7 @@ export async function run(argv: string[]): Promise<void> {
   }
 }
 
-async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; projectDir: string; targetIds: string[]; type: string }> {
+async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; projectDir: string; targetIds: string[] }> {
   const interactive = !flag(flags.yes);
   const rl = interactive ? createRl() : null;
   try {
@@ -53,20 +51,14 @@ async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; pro
       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 };
+    return { scope, projectDir, targetIds };
   } finally {
     if (rl) rl.close();
   }
 }
 
 async function install(flags: Args['flags']): Promise<void> {
-  const { scope, projectDir, targetIds, type } = await resolveOptions(flags);
+  const { scope, projectDir, targetIds } = await resolveOptions(flags);
   const home = homedir();
   const allFiles: string[] = [];
   const allNotes: string[] = [];
@@ -79,7 +71,7 @@ async function install(flags: Args['flags']): Promise<void> {
     }
     installed.push(id);
     console.log(`\n-> ${t.label} (${scope})`);
-    const r = installTo(t, { scope, projectDir, type, home, dryRun: flag(flags.dryRun), force: flag(flags.force) });
+    const r = installTo(t, { scope, projectDir, 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);
@@ -91,7 +83,6 @@ async function install(flags: Args['flags']): Promise<void> {
   writeManifest(file, {
     version: VERSION,
     scope,
-    type,
     installedAt: new Date().toISOString(),
     targets: [...new Set([...(prev?.targets ?? []), ...installed])],
     files: [...new Set([...(prev?.files ?? []), ...allFiles])],
@@ -164,8 +155,7 @@ 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)
+  --yes, -y              non-interactive (needs --global/--project, --target)
   --force                overwrite differing files (with backup)
   --dry-run              print actions without writing`);
 }

package/src/installer.ts

@@ -10,7 +10,6 @@ export type ContentItem = { name: string; data: FrontmatterData; body: string };
 export type InstallOptions = {
   scope: Scope;
   projectDir: string;
-  type: string;
   dryRun?: boolean;
   force?: boolean;
   home?: string;
@@ -39,10 +38,9 @@ export const CONTENT_DIR = join(import.meta.dirname, '..', 'content');
 const pkg = JSON.parse(readFileSync(join(import.meta.dirname, '..', 'package.json'), 'utf8')) as { version: string };
 export const VERSION = pkg.version;
 
-export function collectContent({ includeFrontend }: { includeFrontend: boolean }): { skills: ContentItem[]; agents: ContentItem[] } {
+export function collectContent(): { skills: ContentItem[]; agents: ContentItem[] } {
   const skillNames = readdirSync(join(CONTENT_DIR, 'skills'), { withFileTypes: true })
-    .filter(e => e.isDirectory()).map(e => e.name)
-    .filter(name => includeFrontend || name !== 'mugiwara-frontend');
+    .filter(e => e.isDirectory()).map(e => e.name);
   const skills = skillNames.map(name => {
     const { data, body } = parseFrontmatter(readFileSync(join(CONTENT_DIR, 'skills', name, 'SKILL.md'), 'utf8'));
     return { name, data, body };
@@ -57,9 +55,9 @@ export function collectContent({ includeFrontend }: { includeFrontend: boolean }
 }
 
 export function installTo(target: Target, opts: InstallOptions): InstallResult {
-  const { scope, projectDir, type, dryRun = false, force = false } = opts;
+  const { scope, projectDir, dryRun = false, force = false } = opts;
   const home = opts.home ?? homedir();
-  const { skills, agents } = collectContent({ includeFrontend: type === 'frontend' || type === 'fullstack' });
+  const { skills, agents } = collectContent();
   const dirs = target.paths({ scope, projectDir, home });
   const backupRoot = join(scope === 'global' ? home : projectDir, '.mugiwara');
   const result: InstallResult = { written: [], skipped: [], backedUp: [], notes: [] };

package/src/manifest.ts

@@ -7,7 +7,6 @@ export type Scope = 'global' | 'project';
 export type Manifest = {
   version: string;
   scope: Scope;
-  type: string;
   installedAt: string;
   targets: string[];
   files: string[];