@ionivetech/mugiwara 0.7.0 → 0.8.1

package/gemini-extension.json

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

package/hooks/mugiwara-mode-tracker.js

@@ -54,12 +54,22 @@ function applyModeChange(mode) {
   writeFileSync(tmp, body);
   renameSync(tmp, file);
 }
+function isCodexInput(parsed) {
+  if (process.env.CODEX_HOME || process.env.CODEX_THREAD_ID)
+    return true;
+  if (typeof parsed.turn_id === "string")
+    return true;
+  if (typeof parsed.cwd === "string" && typeof parsed.model === "string")
+    return true;
+  return false;
+}
 async function main() {
   let input = "";
   for await (const chunk of process.stdin)
     input += chunk;
   if (!input.trim()) {
-    process.stdout.write(JSON.stringify({ prompt: "" }));
+    const codexEmpty = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID);
+    process.stdout.write(JSON.stringify(codexEmpty ? {} : { prompt: "" }));
     return;
   }
   let parsed;
@@ -68,12 +78,22 @@ async function main() {
   } catch {
     parsed = { prompt: input };
   }
-  const prompt = parsed.prompt ?? "";
+  const prompt = typeof parsed.prompt === "string" ? parsed.prompt : "";
   const change = parseModeChange(prompt);
   if (change)
     applyModeChange(change);
-  process.stdout.write(JSON.stringify({ prompt }));
+  const codex = isCodexInput(parsed);
+  if (codex) {
+    if (change) {
+      process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: `Mugiwara mode changed to ${change}` } }));
+    } else {
+      process.stdout.write(JSON.stringify({}));
+    }
+  } else {
+    process.stdout.write(JSON.stringify({ prompt }));
+  }
 }
 main().catch(() => {
-  process.stdout.write(JSON.stringify({ prompt: "" }));
+  const codexFallback = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID);
+  process.stdout.write(JSON.stringify(codexFallback ? {} : { prompt: "" }));
 });

package/hooks/mugiwara-mode-tracker.ts

@@ -57,24 +57,53 @@ function applyModeChange(mode: string) {
   renameSync(tmp, file);
 }
 
+// Codex vs Claude: Codex UserPromptSubmit expects {} or {hookSpecificOutput:{hookEventName,additionalContext}}
+// Claude expects {prompt:""} — Codex rejects "prompt" (additionalProperties:false).
+// Detect Codex via env or input shape (turn_id/cwd/model are Codex-only).
+function isCodexInput(parsed: Record<string, unknown>): boolean {
+  if (process.env.CODEX_HOME || process.env.CODEX_THREAD_ID) return true;
+  if (typeof parsed.turn_id === 'string') return true;
+  if (typeof parsed.cwd === 'string' && typeof parsed.model === 'string') return true;
+  return false;
+}
+
 // main
 async function main() {
   let input = '';
   for await (const chunk of process.stdin) input += chunk;
-  if (!input.trim()) { process.stdout.write(JSON.stringify({ prompt: '' })); return; }
+  if (!input.trim()) {
+    // empty stdin — Codex expects {}, Claude expects {prompt:""}
+    // Emit Codex-safe empty ( {} ) — Claude also accepts {} as no-op (prompt passthrough)
+    // but to keep Claude behavior, sniff env: if Codex-like env, emit {}, else prompt
+    const codexEmpty = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID);
+    process.stdout.write(JSON.stringify(codexEmpty ? {} : { prompt: '' }));
+    return;
+  }
 
-  let parsed: { prompt?: string };
-  try { parsed = JSON.parse(input); } catch { parsed = { prompt: input }; }
-  const prompt = parsed.prompt ?? '';
+  let parsed: Record<string, unknown>;
+  try { parsed = JSON.parse(input) as Record<string, unknown>; } catch { parsed = { prompt: input }; }
+  const prompt = typeof parsed.prompt === 'string' ? parsed.prompt : '';
 
   const change = parseModeChange(prompt);
   if (change) applyModeChange(change);
 
-  // pass-through — always return the prompt unchanged
-  process.stdout.write(JSON.stringify({ prompt }));
+  const codex = isCodexInput(parsed);
+  if (codex) {
+    // Codex schema: additionalProperties:false — "prompt" is invalid. Use hookSpecificOutput or {}.
+    if (change) {
+      process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: `Mugiwara mode changed to ${change}` } }));
+    } else {
+      process.stdout.write(JSON.stringify({}));
+    }
+  } else {
+    // Claude: pass-through prompt
+    process.stdout.write(JSON.stringify({ prompt }));
+  }
 }
 
 main().catch(() => {
   // silent — hook must never block the conversation
-  process.stdout.write(JSON.stringify({ prompt: '' }));
+  // Codex-safe fallback: {} (valid for both, but Claude prefers prompt — however {} is also accepted as no-op)
+  const codexFallback = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID);
+  process.stdout.write(JSON.stringify(codexFallback ? {} : { prompt: '' }));
 });

package/hooks/pipeline-guard.js

@@ -135,7 +135,7 @@ function planTouched() {
       if (!existsSync(plan))
         continue;
       const at = lstatSync(plan).mtimeMs;
-      if (at >= sessionStart)
+      if (at + 1000 >= sessionStart)
         return true;
     }
   } catch {}

package/hooks/pipeline-guard.ts

@@ -179,8 +179,9 @@ function planTouched(): boolean {
       if (!existsSync(plan)) continue;
       // lstat, not stat: a symlinked plan pointing outside .mugiwara/
       // must not count as a plan write.
+      // 1s tolerance: file mtime can be ~7ms before first_seen due to FS granularity / clock skew
       const at = lstatSync(plan).mtimeMs;
-      if (at >= sessionStart) return true;
+      if (at + 1000 >= sessionStart) return true;
     }
   } catch { /* unreadable — treat as untouched */ }
   return false;

package/hooks/session-start.js

@@ -104,6 +104,11 @@ if (active.length === 1 && mode === "auto") {
 ${lines}
 ` + `Run /mugiwara continue <mission> [member] to resume one explicitly.`;
 }
+var isCodexSession = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID || process.env.CODEX_HOME_DIR);
 if (resumeContext) {
-  console.log(JSON.stringify({ additionalContext: resumeContext }));
+  if (isCodexSession) {
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: resumeContext } }));
+  } else {
+    console.log(JSON.stringify({ additionalContext: resumeContext }));
+  }
 }

package/hooks/session-start.ts

@@ -131,6 +131,13 @@ if (active.length === 1 && mode === 'auto') {
 
 // Silent unless there is in-flight work: a session that never used mugiwara
 // gets zero injected context.
+// Codex vs Claude: Codex SessionStart expects {hookSpecificOutput:{hookEventName,additionalContext}}
+// Claude expects {additionalContext} — Codex rejects top-level additionalContext (additionalProperties:false).
+const isCodexSession = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID || process.env.CODEX_HOME_DIR);
 if (resumeContext) {
-  console.log(JSON.stringify({ additionalContext: resumeContext }));
+  if (isCodexSession) {
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: resumeContext } }));
+  } else {
+    console.log(JSON.stringify({ additionalContext: resumeContext }));
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ionivetech/mugiwara",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "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.",
   "homepage": "https://github.com/ionivetech/mugiwara#readme",
   "repository": {
@@ -63,7 +63,7 @@
     "sync-version": "bun scripts/sync-version.ts",
     "build-hooks": "bun scripts/build-hooks.ts",
     "build-hooks:check": "bun scripts/build-hooks.ts --check",
-    "gate": "bun run build-hooks:check && bun run typecheck && bun run test:coverage && bun run build && bun scripts/validate-content.ts --check-manifest --check-docs --check-doc-integrity && bun scripts/lane-base.ts && bun scripts/check-doc-links.ts && bun run verify-pack && bun scripts/run-evals.ts && bun scripts/retrieval-eval.ts && bun scripts/verify-install.ts && bun scripts/conformance.ts && bun run coverage-gate",
+    "gate": "bun run build-hooks:check && bun run typecheck && bun run test:coverage && bun run build && bun scripts/write-metrics.ts && bun scripts/validate-content.ts --check-manifest --check-docs --check-doc-integrity --check-readme-metrics && bun scripts/lane-base.ts && bun scripts/check-doc-links.ts && bun run verify-pack && bun scripts/run-evals.ts && bun scripts/retrieval-eval.ts && bun scripts/benchmark-governor.ts && bun scripts/verify-install.ts && bun scripts/conformance.ts && bun run coverage-gate",
     "verify-pack": "npm pack --dry-run 2>&1 | node -e \"let s='';process.stdin.on('data',d=>s+=d);process.stdin.on('end',()=>{if(!s.includes('ionivetech-mugiwara')){console.error('npm pack failed');process.exit(1)};console.log('npm package clean')})\"",
     "prepack": "bun run build && bun run sync-version"
   },

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mugiwara",
   "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, healing.",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "author": {
     "name": "ionivetech"
   },

package/references/cost-governor.md

@@ -0,0 +1,104 @@
+# Cost Governor — Terse & Low-Cost Execution
+
+Single source for Work, Scope/Code, Cognitive/Output, Stop-Slop, Adaptive Budget, Benchmark. Verdicts recommended, not enforced; crew acts. Trail rows → `.mugiwara/missions/<mission>/decisions.md` → `## Cost governor decisions`. `savepoint`/`lane-base`/`config` untouched.
+
+## Ladder — before adding code, run top to bottom, stop at first that holds
+
+1. Does this need to exist at all? Speculative need → skip, one line why (YAGNI).
+2. Already in codebase? Reuse helper/util/pattern nearby → reuse it.
+3. Stdlib does it? Use it.
+4. Native platform covers it? `<input type="date">` over picker lib, CSS over JS, DB constraint over app code → native.
+5. Already-installed dependency solves it? Use it. Never add new dep for a few lines.
+6. Can it be one line? One line.
+7. Only then: minimum code that works. No unrequested abstraction (one impl → no interface/factory/config), no boilerplate for later, deletion over addition, fewest files, shortest diff.
+
+Each step: grep callers first; fix root cause in shared function, not symptom in caller. One guard in shared path beats guards in every caller.
+
+## Output — terse, deduped
+
+Reasoning: Question → Evidence → Decision → Action. No speculative architecture, hypothetical requirements, repeated reconsideration, unrelated implementations. Investigation ends when `acceptance_mapped + surface_understood + path_established` or limits hit with concrete reason (§13). Alternatives ≤3, evidence-backed only.
+
+Output: Decision / Action / Result / Evidence / Blocker only, mission-focused. Duplicate explanations fingerprinted and dropped. Every verdict → `cognitive-governor` trail row.
+
+## Scope & code
+
+Prefer smallest correct scope — reuse + local modification over new architecture (§14). Abstraction justified only when used in ≥2 places or required by contract, never speculative (§15). Dependency added only with explicit justification (§16). Minimum sufficient implementation, never minimum LOC at expense of verification/quality (§15/§38). Measure change surface. Code waste (unnecessary helper/abstraction/wrapper/interface/config/dependency/generated code/refactor) named. Trail row `scope-governor`.
+
+## Slop — taxonomy, signals, measurement, intervention
+
+Taxonomy 8 kinds (§21): investigation, context, reasoning, output, code, retry, healing, scope.
+
+Signals (§22): repeated reads/commands, token-without-evidence, LOC-without-acceptance, abstraction-without-justification.
+
+Measure (§23): evidence/criteria/tests/code vs cost delta — cost grows without progress → slop. Flag anomaly (§24): 5k tokens zero progress, work-to-cost drop.
+
+Intervene (§20): tolerate / stop / compress / escalate by severity.
+
+Detectors — six categories:
+- retry §21.6/§31 same-action same-evidence same-failure → STOP
+- healing §21.7/§32 no progress → stop; `heal_cycle ≥ 3` → halt
+- scope §21.8 out-of-scope without acceptance → reject
+- context §21.2 duplicate/irrelevant → discard/compress
+- investigation §21.1 unbounded exploration → stop
+- code §21.5 unnecessary abstraction/dependency/boilerplate → remove/simplify
+
+Trail row `slop-governor`.
+
+## Budget — reserve, projection, thresholds, breaker
+
+Reserve expected max before expensive stages (Review/Security/Healing). Continuously project `current + remaining required + expected conditional + possible healing` (§26).
+
+Expand only with evidence (§27 valid: scope legitimately expanded, security-sensitive path, test surface larger, architecture dependency, legitimate healing; invalid: verbosity/reread/repeat/unnecessary code).
+
+Thresholds (§28): 60% → optimize, 75% → aggressive, 90% → protect, 100% → pause, 150% → warning, 300% → stop.
+
+Breaker (§29): actual ≥ 2× expected without progress/scope/evidence → trip.
+
+Anomaly (§24): flag 5k-zero-progress, re-consumes slop signal.
+
+Record every non-ok verdict via `recordBudgetDecision` (§41). Trail row `budget-governor`. Ledger aggregates envelope+events+registry+trail; `mugiwara cost` surfaces ledger (--json); report Cost section renders ledger+avoided+efficiency+trail (§43).
+
+## Benchmark & hardening
+
+Tracks `scripts/benchmark-governor.ts` harness (deterministic, no network).
+
+Cost suite (§48) — 4 workloads:
+- lean-trivial: projected 8000 + overhead 1000, context ≤20000, evidence ≥1, surface 2 files 50 LOC
+- standard-feature: projected 15000 + overhead 1500, context ≤40000, evidence ≥3
+- large-repo: projected 22000 + overhead 2200, context ≤80000, evidence ≥5, surface 50 files
+- long-mission: projected 23000 + overhead 2300, context ≤90000, 9 stages projection ≤ budget
+Check: `measured.tokens ≤ projected + overhead` else fail; `measured.context ≤ max` else fail
+
+Stop-Slop suite (§45) — 12 scenarios detect→classify→intervene:
+- endless-exploration → investigation slop → stop
+- repeated-reads (3× no evidence) → context slop → stop; with concrete reason → tolerate
+- repeated-commands (same cmd+evidence fail) → retry slop → stop
+- repeated-failed-test → retry slop → stop
+- repeated-reasoning → reasoning slop → stop
+- unnecessary-abstraction → code slop → stop
+- unnecessary-dependency → code slop → stop
+- unrelated-refactor → scope slop → stop
+- verbose-output → output slop → stop
+- no-progress-healing (cycle ≥3, 0 fixes) → healing slop → stop
+- premature-completion → scope slop → escalate
+- excessive-context (repeated reads + duplicate chars) → context slop → stop
+
+Stress (bench-only, no runtime): large repository 50 files within scope → pass; long mission 9 stages projection ≤ full budget → pass; runaway 2× expected no progress → breaker tripped.
+
+Thresholds live in `scripts/benchmark-thresholds.json` (or THRESHOLDS const) — `tokens > projected+overhead` fail, `context > max` fail, only move on explicit fixture update, ratchet like retrieval-eval. Regression (§49): cost down but correctness/evidence/security/quality/scope down → fail. Determinism: harness pure over explicit fixture inputs, no Date.now/Math.random/network. CI: `package.json:gate` includes harness; `gate-selftest` tampers thresholds → harness must exit 1. Harness measures, not enforces.
+
+## Reporting & trail
+
+Ledger aggregates envelope+events+registry+trail; `mugiwara cost` surfaces ledger; report Cost section renders ledger+avoided+efficiency+trail (§43). Every verdict lands as trail row in decisions.md.
+
+## Checklist
+
+- [ ] ladder run before each code addition, no skipped rung
+- [ ] output Decision/Action/Result/Evidence/Blocker, deduped
+- [ ] scope/code: reuse checked, abstraction & dep justified
+- [ ] slop: taxonomy classified, signals measured, intervention applied
+- [ ] budget: reserved, projected, thresholds respected, breaker armed
+- [ ] benchmark: 4 cost + 12 slop + 3 stress green, thresholds ratcheted
+- [ ] trail rows written for every non-trivial verdict
+
+Unchecked boxes are not done.

package/references/multi-actor.md

@@ -64,3 +64,24 @@ clobber each other's resume position.
 The session-start hook (auto mode) surfaces only the missions owned by your git
 actor — never another member's. If you hold several in-flight missions it lists
 them and asks, it never guesses.
+
+## Ownership & interface declarations (Phase D)
+
+Each member declares its owned files/interfaces in the shared plan's ownership
+map. A member or worker never receives another member's scope — in `auto` mode
+this is a hard boundary, never silently crossed (the resumed scope is exactly
+the selected `(mission, member)` file).
+
+## Standardized handoff
+
+Handoff between members or sequential sub-missions carries: done-criteria,
+branch/base status, dependency status, continuation pointer
+(`continue-<member>.json`), and unresolved blocker references. Never a bare
+"here's where I left off".
+
+## Base drift & collisions
+
+Base drift, merge, and interface collisions are **routing/escalation events**,
+never a silent retry or an automatic cross-scope edit. When main has moved past
+the mission base, escalate (rebase check) before continuing; an interface
+collision routes to Luffy, never silently overwrites another member's work.

package/references/posture-routing.md

@@ -0,0 +1,31 @@
+# Posture Routing (Flow 0/2)
+
+Posture is independent of control mode. Luffy records it; Nami proposes the
+resolved posture; it is chosen deterministically — never opaque scoring.
+
+## Initial posture (Flow 0)
+
+At triage, alongside route + lane + risk, record the initial execution posture +
+rationale + evidence refs. Ordinary work defaults to `inline-sequential` (a
+no-op route — no posture change).
+
+Deterministic matrix: `src/posture.ts` `selectPosture(input)` → `{ posture,
+reason, evidence_refs }`. Inputs: lane, risk, independent_tasks, order_dependent,
+context_pressure, team_members, phases, plan_lines, governor verdict.
+
+| Trigger | Posture |
+|---------|---------|
+| ordinary / none | `inline-sequential` (default) |
+| ≥2 independent tasks, no shared files/interfaces | `parallel-workers` |
+| context pressure + ordered tasks | `context-relief` |
+| >3 phases or >1500 plan lines | `phase-isolated` |
+| >1 team member | `team-scoped` |
+| governor stop | safe pause (keep inline, emit state + continue) |
+
+Governor stop never silently changes mode or crew roles; it pauses and records.
+
+## Plan posture (Flow 2)
+
+Nami declares dependencies, write-conflict groups, explicit `[PARALLEL]`
+eligibility (file- AND interface-disjoint), member ownership, phase/sub-plan
+trigger, acceptance evidence. Luffy records the resolved posture.

package/references/wave-banners.md

@@ -53,8 +53,7 @@ their banners appear only when a wave or worker names them.
 
 ## Rules
 
-1. Banner before EVERY flow stage; handoff after it. No flow stage starts without its
-   banner (orchestration red flag).
+1. Banner before EVERY flow stage; handoff after it. Main thread emits `===== FLOW N — CREW =====` FIRST line and `→ Flow N+1 — Crew` LAST line even when subagent does work — covers Flow 0 Luffy, 1 Usopp, 2 Nami, 3 Zoro, 4 Chopper, 5 Sanji, 6 Franky, 7 Robin/Jinbe, 8 Brook, 9 Luffy. No flow stage starts without its banner (orchestration red flag).
 2. The color comes from this table only — never invent a hex mid-mission.
 3. One form everywhere: equals line `===== <emoji> FLOW N — <CREW> (ROLE) =====` — five `=` per side, the crew emoji from the table leading the line, ANSI-wrapped in terminals, plain in markdown-rendering UIs. When unsure, the plain form is safe everywhere.
 4. Only the crew table's colors and the two SGR forms above (truecolor,