@ionivetech/mugiwara 0.6.6 → 0.8.0

package/src/slop.ts

@@ -0,0 +1,306 @@
+// src/slop.ts
+// Phase 6 Stop-Slop Governor — slop taxonomy, detection signals, progress
+// measurement, work-to-cost anomaly, intervention rules + 6 category detectors
+// (Native Cost Governor, plan §51 Phase 6, §20–§24, §21).
+//
+// Boundary: pure verdict functions over explicit inputs (unit-testable), plus a
+// record helper that persists via the sanitized recordOptDecision (§41). No new
+// config keys; savepoint.sh/lane-base.sh untouched. The crew acts — this module
+// records.
+
+import { recordOptDecision } from './cost.ts';
+
+// ── Slop taxonomy (§21) ──
+
+export type SlopKind =
+  | 'investigation'
+  | 'context'
+  | 'reasoning'
+  | 'output'
+  | 'code'
+  | 'retry'
+  | 'healing'
+  | 'scope';
+
+export const SLOP_TAXONOMY: Record<SlopKind, string> = {
+  investigation: 'reading unrelated files / searching without narrowing / repeated exploration',
+  context: 'repeated reads / duplicate content / irrelevant files',
+  reasoning: 'speculative architecture / repeated reconsideration / hypothetical requirements',
+  output: 'verbose output / duplicate explanations without compression',
+  code: 'unnecessary abstraction / dependency / boilerplate without justification',
+  retry: 'same action with same evidence repeatedly failing',
+  healing: 'healing cycle with no fixes',
+  scope: 'files outside declared scope without acceptance expansion',
+};
+
+/**
+ * Classify a raw signal string into the §21 taxonomy via keyword match.
+ * Returns null when the signal does not map to any known kind.
+ */
+export function classifySlop(signal: string): SlopKind | null {
+  const s = signal.toLowerCase();
+  if (s.includes('same command') || s.includes('same action') || s.includes('repeated command') || s.includes('retry') || s.includes('same evidence'))
+    return 'retry';
+  if (s.includes('healing') || s.includes('heal') || s.includes('fixes_in_cycle') || s.includes('no fixes'))
+    return 'healing';
+  if (s.includes('repeated file') || s.includes('repeated read') || s.includes('duplicate') || s.includes('irrelevant file') || s.includes('re-read'))
+    return 'context';
+  if (s.includes('unrelated file') || s.includes('exploration') || s.includes('investigation') || s.includes('searching without'))
+    return 'investigation';
+  if (s.includes('scope') || s.includes('out-of-scope') || s.includes('out of scope') || s.includes('declared scope') || s.includes('unrelated refactor'))
+    return 'scope';
+  if (s.includes('loc') || s.includes('boilerplate') || s.includes('abstraction') || s.includes('dependency') || s.includes('code slop'))
+    return 'code';
+  if (s.includes('speculative') || s.includes('reconsideration') || s.includes('hypothetical') || s.includes('reasoning slop'))
+    return 'reasoning';
+  if (s.includes('verbose') || s.includes('duplicate explanation') || s.includes('output slop') || s.includes('compress'))
+    return 'output';
+  return null;
+}
+
+// ── Detection signals (§22) ──
+
+export type SlopSignal = { kind: SlopKind; signal: string; count: number; threshold: number };
+
+export function detectSlopSignal(input: {
+  kind: SlopKind;
+  count: number;
+  threshold: number;
+  evidence_delta?: number;
+}): { slop: boolean; reason: string } {
+  const { kind, count, threshold, evidence_delta } = input;
+  const hasGain = evidence_delta !== undefined && evidence_delta !== 0;
+  const slop = count >= threshold && !hasGain;
+  const reason = slop
+    ? `slop: ${kind} — count ${count} ≥ threshold ${threshold} with no evidence gain`
+    : `no slop: ${kind} — ${count < threshold ? `count ${count} < threshold ${threshold}` : `evidence gained (${evidence_delta})`}`;
+  return { slop, reason };
+}
+
+// ── Progress measurement (§23) ──
+
+export type ProgressSnapshot = {
+  tokens_used: number;
+  evidence_items: number;
+  criteria_mapped: number;
+  files_understood: number;
+  tests_fixed: number;
+  code_chars: number;
+};
+
+export function measureProgress(
+  before: ProgressSnapshot,
+  after: ProgressSnapshot,
+): { progress: number; cost_delta: number; progress_per_cost: number; slop_signal: boolean; reason: string } {
+  const evidenceDelta = after.evidence_items - before.evidence_items;
+  const criteriaDelta = after.criteria_mapped - before.criteria_mapped;
+  const testsDelta = after.tests_fixed - before.tests_fixed;
+  const codeDelta = after.code_chars - before.code_chars;
+  const codeProgress = codeDelta > 0 ? 1 : 0;
+  const progress = evidenceDelta + criteriaDelta + testsDelta + codeProgress;
+  const cost_delta = after.tokens_used - before.tokens_used;
+  const progress_per_cost = cost_delta > 0 ? progress / cost_delta : 0;
+  const slop_signal = cost_delta > 0 && progress === 0;
+  const reason = slop_signal ? `slop — ${cost_delta} tokens with no progress` : `progress ${progress} over ${cost_delta} tokens`;
+  return { progress, cost_delta, progress_per_cost, slop_signal, reason };
+}
+
+// ── Work-to-cost anomaly (§24) ──
+
+export type AnomalyInput = { progress_per_cost: number; baseline_per_cost: number; drop_threshold?: number };
+
+export function detectAnomaly(input: AnomalyInput): { anomaly: boolean; reason: string } {
+  const threshold = input.drop_threshold ?? 0.5;
+  if (input.baseline_per_cost <= 0) {
+    return { anomaly: false, reason: 'no anomaly — baseline 0 or above threshold' };
+  }
+  const anomaly = input.progress_per_cost < input.baseline_per_cost * threshold;
+  if (anomaly) {
+    const pct = Math.round((1 - input.progress_per_cost / input.baseline_per_cost) * 100);
+    return { anomaly: true, reason: `anomaly — ${pct}% drop below baseline` };
+  }
+  return { anomaly: false, reason: 'no anomaly — baseline 0 or above threshold' };
+}
+
+// ── Intervention rules (§20) ──
+
+export type Intervention = 'tolerate' | 'stop' | 'compress' | 'escalate';
+export type InterventionInput = {
+  kind: SlopKind;
+  slop: boolean;
+  severity: 'harmless' | 'wasteful' | 'harmful';
+  progress_stalled: boolean;
+};
+
+export function decideIntervention(input: InterventionInput): { intervention: Intervention; reason: string } {
+  if (!input.slop) return { intervention: 'tolerate', reason: `tolerate — no slop for ${input.kind}` };
+  if (input.severity === 'harmful') return { intervention: 'escalate', reason: `escalate — ${input.kind} harmful slop` };
+  if (input.severity === 'wasteful') return { intervention: 'stop', reason: `stop — ${input.kind} wasteful slop` };
+  // harmless
+  if (input.progress_stalled) return { intervention: 'compress', reason: `compress — ${input.kind} harmless but stalled` };
+  return { intervention: 'tolerate', reason: `tolerate — ${input.kind} harmless slop` };
+}
+
+// ── Retry slop (§21.6/§31) ──
+
+export type RetryInput = {
+  action: string;
+  evidence_fingerprint: string;
+  outcome: 'fail' | 'pass';
+  history: { action: string; evidence_fingerprint: string; outcome: string }[];
+};
+
+export function detectRetrySlop(input: RetryInput): { slop: boolean; reason: string; kind: SlopKind } {
+  const kind: SlopKind = 'retry';
+  if (input.outcome !== 'fail') return { slop: false, reason: 'no slop — outcome is pass', kind };
+  const found = input.history.some((h) => h.action === input.action && h.evidence_fingerprint === input.evidence_fingerprint && h.outcome === 'fail');
+  if (found) return { slop: true, reason: `slop: retry — same action ${input.action} with same evidence ${input.evidence_fingerprint} repeatedly failing`, kind };
+  return { slop: false, reason: 'no slop — no matching failed history', kind };
+}
+
+// ── Healing slop (§21.7/§32) ──
+
+export type HealingInput = { cycle: number; fixes_in_cycle: number; history_fixes: number[]; max_cycles?: number };
+
+export function detectHealingSlop(input: HealingInput): { slop: boolean; reason: string; kind: SlopKind } {
+  const kind: SlopKind = 'healing';
+  const max = input.max_cycles ?? 3;
+  const hasZeroHistory = input.history_fixes.some((n) => n === 0);
+  if (input.fixes_in_cycle === 0 && hasZeroHistory) {
+    return { slop: true, reason: `slop: healing — no fixes in cycle ${input.cycle} with previous zero-fix cycle`, kind };
+  }
+  if (input.cycle >= max && input.fixes_in_cycle === 0) {
+    return { slop: true, reason: `slop: healing — cycle ${input.cycle} ≥ max ${max} with no fixes`, kind };
+  }
+  return { slop: false, reason: 'no slop — healing making progress', kind };
+}
+
+// ── Scope slop (§21.8) ──
+
+export type ScopeSlopInput = {
+  files_changed: string[];
+  declared_scope: string[];
+  acceptance_expanded: boolean;
+  unrelated_refactors: string[];
+};
+
+export function detectScopeSlop(input: ScopeSlopInput): { slop: boolean; reason: string; kind: SlopKind } {
+  const kind: SlopKind = 'scope';
+  const outOfScope = input.files_changed.filter((f) => !input.declared_scope.includes(f));
+  const hasScopeDrift = outOfScope.length > 0 || input.unrelated_refactors.length > 0;
+  if (hasScopeDrift && !input.acceptance_expanded) {
+    const names = [...outOfScope, ...input.unrelated_refactors].join(', ');
+    return { slop: true, reason: `slop: scope — out-of-scope ${names} without acceptance expansion`, kind };
+  }
+  return { slop: false, reason: 'no scope slop — within declared scope or acceptance expanded', kind };
+}
+
+// ── Context slop (§21.2/§12) ──
+
+export type ContextSlopInput = {
+  repeated_reads: number;
+  repeated_read_threshold: number;
+  duplicate_chars: number;
+  irrelevant_files: string[];
+};
+
+export function detectContextSlop(input: ContextSlopInput): { slop: boolean; reason: string; kind: SlopKind } {
+  const kind: SlopKind = 'context';
+  const signals: string[] = [];
+  if (input.repeated_reads >= input.repeated_read_threshold) signals.push(`repeated reads ${input.repeated_reads} ≥ ${input.repeated_read_threshold}`);
+  if (input.duplicate_chars > 0) signals.push(`duplicate chars ${input.duplicate_chars}`);
+  if (input.irrelevant_files.length > 0) signals.push(`irrelevant files ${input.irrelevant_files.join(', ')}`);
+  if (signals.length > 0) return { slop: true, reason: `slop: context — ${signals.join('; ')}`, kind };
+  return { slop: false, reason: 'no context slop', kind };
+}
+
+// ── Investigation slop (§21.1/§13) ──
+
+export type InvestigationSlopInput = {
+  unrelated_files_opened: number;
+  max_unrelated_files: number;
+  repeated_reads: number;
+  repeated_read_threshold: number;
+  exploration_passes: number;
+  max_passes: number;
+  acceptance_mapped: boolean;
+  has_concrete_reason: boolean;
+};
+
+export function detectInvestigationSlop(input: InvestigationSlopInput): { slop: boolean; reason: string; kind: SlopKind } {
+  const kind: SlopKind = 'investigation';
+  if (input.has_concrete_reason) return { slop: false, reason: 'no investigation slop — concrete reason present', kind };
+  const breaches: string[] = [];
+  if (input.unrelated_files_opened > input.max_unrelated_files) breaches.push(`unrelated files ${input.unrelated_files_opened} > ${input.max_unrelated_files}`);
+  if (input.repeated_reads >= input.repeated_read_threshold) breaches.push(`repeated reads ${input.repeated_reads} ≥ ${input.repeated_read_threshold}`);
+  if (input.exploration_passes >= input.max_passes) breaches.push(`passes ${input.exploration_passes} ≥ ${input.max_passes}`);
+  if (breaches.length > 0) return { slop: true, reason: `slop: investigation — ${breaches.join('; ')}`, kind };
+  return { slop: false, reason: 'no investigation slop', kind };
+}
+
+// ── Code slop (§21.5/§15) ──
+
+export type CodeSlopInput = {
+  new_abstractions: number;
+  new_dependencies: number;
+  loc_added: number;
+  acceptance_expanded: boolean;
+  justification_provided: boolean;
+  boilerplate_chars: number;
+};
+
+export function detectCodeSlop(input: CodeSlopInput): { slop: boolean; reason: string; kind: SlopKind } {
+  const kind: SlopKind = 'code';
+  if (input.acceptance_expanded || input.justification_provided) {
+    return { slop: false, reason: 'no code slop — acceptance expanded or justified', kind };
+  }
+  const signals: string[] = [];
+  if (input.new_abstractions > 0) signals.push(`abstractions ${input.new_abstractions}`);
+  if (input.new_dependencies > 0) signals.push(`dependencies ${input.new_dependencies}`);
+  if (input.boilerplate_chars > 0) signals.push(`boilerplate ${input.boilerplate_chars} chars`);
+  if (input.loc_added > 100) signals.push(`loc ${input.loc_added}`);
+  if (signals.length > 0) return { slop: true, reason: `slop: code — ${signals.join('; ')} without acceptance or justification`, kind };
+  return { slop: false, reason: 'no code slop', kind };
+}
+
+// ── Decision trail (§41) ──
+
+export function recordSlopDecision(
+  missionDir: string,
+  d: { decision: string; reason: string; evidence?: string; kind?: SlopKind },
+): void {
+  const prefix = d.kind ? `[${d.kind}] ` : '';
+  recordOptDecision(missionDir, {
+    actor: 'slop-governor',
+    decision: `${prefix}${d.decision}`,
+    reason: d.reason,
+    evidence: d.evidence,
+  });
+}
+
+// ── Live wiring (§3.3) ──
+// Runs the existing detectors over state already available at ledger-build time
+// (state.json heal cycle, context-registry repeated reads). One call site feeds
+// the ledger's slopMetrics.interventions so it stops reading 0. Per-crew
+// attribution: healing → Brook (Flow 8), context → all.
+export type LiveSlopResult = {
+  interventions: number;
+  perRole: Record<string, number>;
+  rows: { role: string; kind: SlopKind; reason: string }[];
+};
+
+export function computeLiveSlop(input: {
+  heal_cycle: number;
+  repeated_reads: number;
+  repeated_read_threshold?: number;
+  max_heal_cycles?: number;
+}): LiveSlopResult {
+  const rows: { role: string; kind: SlopKind; reason: string }[] = [];
+  const thr = input.repeated_read_threshold ?? 3;
+  const heal = detectHealingSlop({ cycle: input.heal_cycle, fixes_in_cycle: 0, history_fixes: [], max_cycles: input.max_heal_cycles ?? 3 });
+  if (heal.slop) rows.push({ role: 'Brook', kind: 'healing', reason: heal.reason });
+  if (input.repeated_reads >= thr) rows.push({ role: 'all', kind: 'context', reason: `repeated reads ${input.repeated_reads} ≥ ${thr}` });
+  const perRole: Record<string, number> = {};
+  for (const r of rows) perRole[r.role] = (perRole[r.role] ?? 0) + 1;
+  return { interventions: rows.length, perRole, rows };
+}

package/src/targets/claude.ts

@@ -40,8 +40,8 @@ function copyScripts(dstDir: string): string[] {
     if (!existsSync(src)) return;
     for (const f of readdirSync(src)) {
       // install.sh is the npx bootstrap, not a harness script — never shipped
-      // into a project. initiative.ts ships too: `mugiwara initiative` runs it.
-      if ((!f.endsWith('.sh') && f !== 'initiative.ts') || f === 'install.sh') continue;
+      // into a project.
+      if (!f.endsWith('.sh') || f === 'install.sh') continue;
       const to = join(dst, f);
       mkdirSync(dst, { recursive: true });
       copyFileSync(join(src, f), to);

package/src/work.ts

@@ -0,0 +1,273 @@
+// src/work.ts
+// Phase 3 Work Governor — verdict engine + decision trail
+// (Native Cost Governor initiative, plan §51 Phase 3, spec §7/§8/§9/§19/§30/§41).
+//
+// Turns the Phase-2 signals into auditable skip/avoid/delegate/complete
+// verdicts. Honest boundary (same as Phase 2 for investigation.ts): this
+// module PRODUCES and RECORDS verdicts; the LLM crew (workflow skill, T4) is
+// the only thing that acts on them. The module makes the decision structured
+// and auditable — it does not pretend a TS function can force the model.
+//
+// Every verdict is a pure function of explicit inputs (unit-testable, parity
+// locked by fixtures) and every skip/avoid/delegate/complete decision lands in
+// the trail via recordWorkDecision → recordOptDecision (§41, S2 sanitizer).
+import { delegateAt, laneBaseForLane, recordOptDecision } from './cost.ts';
+
+// ── Stage classification (§7/§34) ───────────────────────────────────────────
+
+export type StageClass = 'required' | 'conditional' | 'optional';
+
+export type StageClassifyInput = {
+  stage: string;
+  requirement_kind: 'explicit' | 'exploratory' | 'ambiguous';
+  uncertainty_high: boolean;
+  provides_required_evidence: boolean;
+  protects_quality_security: boolean;
+};
+
+export type StageClassifyVerdict = { stage: string; class: StageClass; reason: string };
+
+/**
+ * Classify a flow stage as required/conditional/optional. A stage that
+ * protects quality/security or provides required evidence is `required`
+ * (never skipped); a stage with high uncertainty or a non-explicit
+ * requirement is `conditional`; everything else is `optional`.
+ */
+export function classifyStage(input: StageClassifyInput): StageClassifyVerdict {
+  if (input.protects_quality_security) {
+    return { stage: input.stage, class: 'required', reason: 'protects quality/security — required' };
+  }
+  if (input.provides_required_evidence) {
+    return { stage: input.stage, class: 'required', reason: 'provides required evidence — required' };
+  }
+  if (input.uncertainty_high || input.requirement_kind !== 'explicit') {
+    return { stage: input.stage, class: 'conditional', reason: 'uncertain or non-explicit requirement — conditional' };
+  }
+  return { stage: input.stage, class: 'optional', reason: 'explicit, no protection/evidence need — optional' };
+}
+
+// ── Evidence-backed stage skipping (§7/§13) ─────────────────────────────────
+
+export type SkipInput = {
+  stage: string;
+  classification: StageClass;
+  evidence_present: boolean;
+  investigation_stopped: boolean;
+  context_over: boolean;
+};
+
+export type SkipVerdict = { stage: string; skip: boolean; reason: string; evidence?: string };
+
+/**
+ * Decide whether a classified stage may be skipped on evidence. `required`
+ * never skips (protects quality/security). `conditional` skips when evidence
+ * already answers or the investigation stopped; `optional` skips when
+ * evidence answers or the context is over budget. Every skip carries an
+ * explicit reason (§7 — never skipped silently).
+ */
+export function shouldSkipStage(input: SkipInput): SkipVerdict {
+  if (input.classification === 'required') {
+    return { stage: input.stage, skip: false, reason: 'required — protects quality/security' };
+  }
+  if (input.classification === 'conditional') {
+    if (input.evidence_present) {
+      return { stage: input.stage, skip: true, reason: 'evidence already answers', evidence: input.stage };
+    }
+    if (input.investigation_stopped) {
+      return { stage: input.stage, skip: true, reason: 'investigation stopped — no further value' };
+    }
+    return { stage: input.stage, skip: false, reason: 'conditional — no skip signal; run' };
+  }
+  // optional
+  if (input.evidence_present) {
+    return { stage: input.stage, skip: true, reason: 'evidence already answers', evidence: input.stage };
+  }
+  if (input.context_over) {
+    return { stage: input.stage, skip: true, reason: 'context over budget — tighten, do not expand' };
+  }
+  return { stage: input.stage, skip: false, reason: 'optional — no skip signal; run' };
+}
+
+// ── Agent invocation control (§8) ───────────────────────────────────────────
+
+export type InvocationInput = {
+  agent: string;
+  unique_responsibility: boolean;
+  evidence_answers: boolean;
+  stage_can_perform: boolean;
+  expected_value_gt_cost: boolean;
+};
+
+export type InvocationVerdict = { agent: string; invoke: boolean; reason: string };
+
+/**
+ * Decide whether an agent earns invocation. Invoke only when the agent has
+ * unique responsibility, evidence cannot answer, the stage cannot perform
+ * itself, and expected value exceeds cost. Never invoke merely because the
+ * agent exists in the crew. On refusal, name the first failing clause.
+ */
+export function evaluateInvocation(input: InvocationInput): InvocationVerdict {
+  if (!input.unique_responsibility) {
+    return { agent: input.agent, invoke: false, reason: 'no unique responsibility' };
+  }
+  if (input.evidence_answers) {
+    return { agent: input.agent, invoke: false, reason: 'evidence already answers' };
+  }
+  if (input.stage_can_perform) {
+    return { agent: input.agent, invoke: false, reason: 'stage can perform itself' };
+  }
+  if (!input.expected_value_gt_cost) {
+    return { agent: input.agent, invoke: false, reason: 'expected value not greater than cost' };
+  }
+  return { agent: input.agent, invoke: true, reason: 'unique responsibility, evidence cannot answer, value exceeds cost' };
+}
+
+// ── Skill loading control (§9) ──────────────────────────────────────────────
+
+export type SkillInput = {
+  skill: string;
+  required_by_task: boolean;
+  required_by_policy: boolean;
+  required_by_dependency: boolean;
+  failing_verification: boolean;
+};
+
+export type SkillVerdict = { skill: string; load: boolean; reason: string };
+
+/**
+ * Decide whether a skill earns loading — minimum sufficient set (§9): load
+ * only when required by the task, by policy, by a dependency, or by a failing
+ * verification. Else refuse with the standard reason.
+ */
+export function shouldLoadSkill(input: SkillInput): SkillVerdict {
+  if (input.required_by_task) return { skill: input.skill, load: true, reason: 'required by task' };
+  if (input.required_by_policy) return { skill: input.skill, load: true, reason: 'required by policy' };
+  if (input.required_by_dependency) return { skill: input.skill, load: true, reason: 'required by dependency' };
+  if (input.failing_verification) return { skill: input.skill, load: true, reason: 'required by failing verification' };
+  return { skill: input.skill, load: false, reason: 'not required by task/policy/dependency/verification' };
+}
+
+// ── Delegation optimization (§30, consumes delegateAt + laneBaseForLane) ────
+
+export type DelegationInput = {
+  lane: string;
+  budget: number;
+  tokens_used: number;
+  threshold_pct: number;
+  independent_tasks: number;
+  parallel_value: number;
+  estimated_overhead: number;
+};
+
+export type DelegationVerdict = {
+  delegate: boolean;
+  reason: string;
+  budget_at: number;
+  lane_base: number;
+  parallel_value: number;
+  overhead: number;
+};
+
+/**
+ * Decide whether delegation is worthwhile. Closes the Phase-2 Q1 remainder:
+ * budget ceiling = delegateAt(budget, threshold_pct); overhead floor = one
+ * delegate costs at least one agent's context load (laneBaseForLane). Delegate
+ * only when there are ≥2 independent tasks, parallel value beats the overhead
+ * floor, and usage is inside the delegation budget. Else refuse naming the
+ * failing clause.
+ */
+export function evaluateDelegation(input: DelegationInput): DelegationVerdict {
+  const budget_at = delegateAt(input.budget, input.threshold_pct);
+  const lane_base = laneBaseForLane(input.lane);
+  const overhead = Math.max(input.estimated_overhead, lane_base);
+  if (input.independent_tasks < 2) {
+    return {
+      delegate: false,
+      reason: 'not enough independent tasks (needs >= 2)',
+      budget_at,
+      lane_base,
+      parallel_value: input.parallel_value,
+      overhead,
+    };
+  }
+  if (input.parallel_value <= overhead) {
+    return {
+      delegate: false,
+      reason: 'parallel value not greater than overhead',
+      budget_at,
+      lane_base,
+      parallel_value: input.parallel_value,
+      overhead,
+    };
+  }
+  if (input.tokens_used > budget_at) {
+    return {
+      delegate: false,
+      reason: 'over delegation budget',
+      budget_at,
+      lane_base,
+      parallel_value: input.parallel_value,
+      overhead,
+    };
+  }
+  return {
+    delegate: true,
+    reason: 'parallel value exceeds overhead and within budget',
+    budget_at,
+    lane_base,
+    parallel_value: input.parallel_value,
+    overhead,
+  };
+}
+
+// ── Completion detection (§19) ──────────────────────────────────────────────
+
+export type CompletionInput = {
+  acceptance_satisfied: boolean;
+  implementation_complete: boolean;
+  tests_complete: boolean;
+  quality_gates_complete: boolean;
+  evidence_collected: boolean;
+};
+
+export type CompletionVerdict = { complete: boolean; missing: string[]; reason: string };
+
+const COMPLETION_FIELDS: Array<keyof CompletionInput> = [
+  'acceptance_satisfied',
+  'implementation_complete',
+  'tests_complete',
+  'quality_gates_complete',
+  'evidence_collected',
+];
+
+/**
+ * A mission is complete only when all five §19 conditions hold. `missing`
+ * lists every condition still open; `reason` is `ready for closure` or the
+ * comma-joined missing list.
+ */
+export function completionCheck(input: CompletionInput): CompletionVerdict {
+  const missing = COMPLETION_FIELDS.filter((f) => !input[f]);
+  if (missing.length === 0) {
+    return { complete: true, missing: [], reason: 'ready for closure' };
+  }
+  return { complete: false, missing, reason: `missing: ${missing.join(', ')}` };
+}
+
+// ── Decision trail (§41) ────────────────────────────────────────────────────
+
+/**
+ * Record any skip/avoid/delegate/complete verdict as an optimization decision
+ * with the `work-governor` actor. Thin wrapper over the sanitized
+ * recordOptDecision (S2 — newline/CR stripped, no markdown injection).
+ */
+export function recordWorkDecision(
+  missionDir: string,
+  d: { decision: string; reason: string; evidence?: string },
+): void {
+  recordOptDecision(missionDir, {
+    actor: 'work-governor',
+    decision: d.decision,
+    reason: d.reason,
+    ...(d.evidence ? { evidence: d.evidence } : {}),
+  });
+}

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

@@ -1,13 +0,0 @@
----
-description: Execute an approved mugiwara plan as Zoro (execution stage)
----
-Execute the approved plan as Zoro, inline in the main conversation:
-
-1. **Entry protocol first** — read the mission state (`.mugiwara/state/<mission>/[member].json`). No active mission → run Flow 0 triage before anything else. Foreign mission → stop, report owner. Base drift → stop, ask. Non-git → degrade to standard, say so once.
-2. Load the skill: `mugiwara-execution`.
-3. Read the existing plan from `.mugiwara/plans/` — that file is the bridge, never re-plan.
-4. Open a todo list, run tasks sequentially inline; dispatch [PARALLEL] batches to worker subagents only.
-5. Commit per logical task and verify every acceptance criterion with evidence in `.mugiwara/results/`.
-6. **Return the result to Luffy — do not choose the next wave.**
-
-See skills/mugiwara-execution for the wave-structured protocol.

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

@@ -1,13 +0,0 @@
----
-description: Heal earlier-wave failures as Brook (healing stage, after review/security findings)
----
-Heal failures as Brook, inline in the main conversation:
-
-1. **Entry protocol first** — read the mission state (`.mugiwara/state/<mission>/[member].json`). No active mission → run Flow 0 triage before anything else. Foreign mission → stop, report owner. Base drift → stop, ask. Non-git → degrade to standard, say so once. Read `heal_halt` (savepoint computes it as `heal_cycle ≥ heal_max_cycles`, config default 3) — when `true`, STOP and escalate to the user.
-2. Load the skill: `mugiwara-healing`.
-3. Read the `.mugiwara/issues` ledger first — stop-the-line triage per failure, never fix blind.
-4. Prove-it before fixing: reproduce or verify the failure from `.mugiwara/results/` evidence.
-5. Apply minimal root-cause fixes, update the ledger with evidence.
-6. **Return the result to Luffy — do not choose the next wave.**
-
-See skills/mugiwara-healing for the triage protocol.

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

@@ -1,14 +0,0 @@
----
-description: Run the Mugiwara onboarding wizard — zero-LLM terminal wizard via `mugiwara onboard`, writes .mugiwara/config.
----
-Mugiwara onboard: $ARGUMENTS
-
-Run the onboarding wizard. One path only — the zero-LLM terminal wizard:
-
-1. Tell the user to run `mugiwara onboard` in their terminal (or `bunx @ionivetech/mugiwara onboard`).
-2. Do NOT ask the questions yourself. Do NOT write .mugiwara/config. The wizard is a plain
-   script — no LLM, no network, works on every platform.
-3. After the user finishes, verify `.mugiwara/config` exists and summarize the values.
-
-The wizard never writes .mugiwara/onboard.json. All 14 crew agents are always active —
-no agent-selection step.

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

@@ -1,17 +0,0 @@
----
-description: Plan a mugiwara mission as Nami (planning stage)
----
-Plan the mission as Nami, inline in the main conversation:
-
-1. **Entry protocol first** — read the mission state (`.mugiwara/state/<mission>/[member].json`). No active mission → run Flow 0 triage before anything else. Foreign mission → stop, report owner. Base drift → stop, ask. Non-git → degrade to standard, say so once.
-2. Load the skill: `mugiwara-planning`.
-3. Classify mission size, interview first, scan full context, write the scaled Quick/Standard/Full plan.
-4. Embody the Nami crew role inline — never Task-dispatch.
-5. Persist the plan to `.mugiwara/plans/`; later stages read it from there as the bridge.
-6. **Return the plan to Luffy — do not choose the next wave.**
-
-Spec input: read `.mugiwara/spec/YYYY-MM-DD-<mission>.md`. If it is empty or
-missing, write the spec bridge from the user's request first (goal, acceptance
-criteria, constraints) before planning — never plan from an empty spec.
-
-See skills/mugiwara-planning for the full template and wave structure.

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

@@ -1,13 +0,0 @@
----
-description: Close the mission as Luffy (closure + ship stage, at mission end)
----
-Close the mission as Luffy, inline in the main conversation:
-
-1. **Entry protocol first** — read the mission state (`.mugiwara/state/<mission>/[member].json`). No active mission → run Flow 0 triage before anything else. Foreign mission → stop, report owner. Base drift → stop, ask. Non-git → degrade to standard, say so once.
-2. Load the skills: `mugiwara-orchestration` + `mugiwara-ship`.
-3. Run the ship gate: pre-launch checklist, feature flags, staged rollout, mandatory rollback plan — binary GO/NO-GO with evidence.
-4. Bridge on `.mugiwara/plans/` (promise) vs `.mugiwara/results/` (evidence) for the Definition-of-Done verdict.
-5. Close the mission: lessons ledger update, then the terminal step — save-point commit, push the branch, write the PR verdict, hand to the user.
-6. **The crew never creates a PR, never merges, never deploys — hand the branch + verdict to the user.**
-
-See skills/mugiwara-ship for the gate and skills/mugiwara-orchestration for closure.