@ionivetech/mugiwara 0.7.0 → 0.8.1

package/src/policy.ts

@@ -20,10 +20,17 @@ export type MugiwaraPolicy = {
     require_human_approval?: string[];
   };
   evidence?: { required?: string[] };
+  integrity?: { extra_secret_patterns?: Array<{ pattern: string; label: string; severity?: 'block' | 'warn' }> };
+  attestation?: {
+    required?: boolean;
+    trusted_keys?: Array<{ id: string; pubkey: string; added?: string }>;
+    revoked?: Array<{ id: string; revoked?: string; reason?: string; pubkey?: string }>;
+  };
+  harness?: { require_enforcement?: boolean };
 };
 
 const POLICY_FILES = ['mugiwara.policy.yml', 'mugiwara.policy.yaml'];
-const KNOWN_ROOTS = ['lanes', 'gates', 'evidence'];
+const KNOWN_ROOTS = ['lanes', 'gates', 'evidence', 'integrity', 'attestation', 'harness'];
 
 /**
  * Minimal YAML subset: maps, `- item` string lists, scalars.
@@ -97,11 +104,238 @@ function scalar(v: string): unknown {
   return t;
 }
 
+/**
+ * Dedicated extractor for integrity.extra_secret_patterns list-of-maps.
+ * The minimal YAML subset parser only handles scalar lists; this scans the raw
+ * text line-by-line for map items so both forms work:
+ *   - { pattern: "\\b...\\b", label: "NIK" }
+ *   - - pattern: "\\b...\\b"
+ *     label: "NIK"
+ *     severity: warn
+ */
+export function extractExtraSecretPatterns(text: string): Array<{ pattern: string; label: string; severity?: string }> {
+  const lines = text.split(/\r?\n/);
+  let inBlock = false;
+  let baseIndent = -1;
+  const out: Array<Record<string, string>> = [];
+  let current: Record<string, string> | null = null;
+  let currentIndent = -1;
+  for (const rawLine of lines) {
+    const noComment = rawLine.replace(/(^|\s)#.*$/, '');
+    if (!noComment.trim()) continue;
+    const indent = noComment.length - noComment.trimStart().length;
+    const trimmed = noComment.trim();
+    if (!inBlock) {
+      if (trimmed.startsWith('extra_secret_patterns:')) {
+        inBlock = true;
+        baseIndent = indent;
+        continue;
+      }
+    } else {
+      // exit if a sibling key at same or shallower indent (not a list item) appears
+      if (indent <= baseIndent && !trimmed.startsWith('-') && trimmed.includes(':')) {
+        break;
+      }
+      if (trimmed.startsWith('-')) {
+        if (current) out.push(current);
+        current = {};
+        currentIndent = indent;
+        const afterDash = trimmed.slice(1).trim();
+        if (!afterDash) continue;
+        if (afterDash.startsWith('{') && afterDash.endsWith('}')) {
+          const inner = afterDash.slice(1, -1);
+          for (const part of inner.split(',')) {
+            const colon = part.indexOf(':');
+            if (colon === -1) continue;
+            const k = part.slice(0, colon).trim();
+            const v = part.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+            if (k && v) current[k] = v;
+          }
+        } else if (afterDash.includes(':')) {
+          const colon = afterDash.indexOf(':');
+          const k = afterDash.slice(0, colon).trim();
+          const v = afterDash.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+          if (k && v) current[k] = v;
+        } else {
+          const v = afterDash.replace(/^["']|["']$/g, '');
+          if (v) current['pattern'] = v;
+        }
+      } else if (current && trimmed.includes(':')) {
+        if (indent > currentIndent) {
+          const colon = trimmed.indexOf(':');
+          const k = trimmed.slice(0, colon).trim();
+          const v = trimmed.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+          if (k && v) current[k] = v;
+        } else if (indent <= baseIndent) {
+          break;
+        }
+      }
+    }
+  }
+  if (current) out.push(current);
+  return out.filter((o) => typeof o.pattern === 'string' && typeof o.label === 'string' && o.pattern.length > 0) as Array<{ pattern: string; label: string; severity?: string }>;
+}
+
+/**
+ * Extract attestation block: handles both inline `{ id: "...", pubkey: "ed25519:..." }`
+ * and multiline lists. Scans inside `attestation:` indented block so
+ * `evidence: required:` is not confused.
+ */
+export function extractAttestation(text: string): {
+  required?: boolean;
+  trusted_keys?: Array<Record<string, string>>;
+  revoked?: Array<Record<string, string>>;
+} | null {
+  const lines = text.split(/\r?\n/);
+  let attBase = -1;
+  let inAtt = false;
+  let required: boolean | undefined;
+  const trusted: Array<Record<string, string>> = [];
+  const revoked: Array<Record<string, string>> = [];
+  // collection state
+  let collecting: 'trusted' | 'revoked' | null = null;
+  let collectBase = -1;
+  let current: Record<string, string> | null = null;
+  let curIndent = -1;
+
+  const flush = () => {
+    if (!current) return;
+    if (collecting === 'trusted') trusted.push(current);
+    else if (collecting === 'revoked') revoked.push(current);
+    current = null;
+  };
+
+  for (let idx = 0; idx < lines.length; idx++) {
+    const rawLine = lines[idx];
+    const noComment = rawLine.replace(/(^|\s)#.*$/, '');
+    if (!noComment.trim()) continue;
+    const indent = noComment.length - noComment.trimStart().length;
+    const trimmed = noComment.trim();
+
+    if (!inAtt) {
+      if (trimmed === 'attestation:' || trimmed.startsWith('attestation:')) {
+        // handle `attestation: { ... }` inline — not used, but parse required if present
+        const after = trimmed.slice('attestation:'.length).trim();
+        if (after.startsWith('{')) {
+          // inline map form not needed for MVP
+          return null;
+        }
+        inAtt = true;
+        attBase = indent;
+        // if there is a value after colon on same line (e.g., attestation: foo) ignore
+        continue;
+      }
+      continue;
+    }
+
+    // inside attestation block
+    // exit attestation when sibling root key at same/shallower indent
+    if (indent <= attBase && !trimmed.startsWith('-') && trimmed.includes(':')) {
+      flush();
+      break;
+    }
+
+    // handle collecting state first
+    if (collecting) {
+      // exiting collection to sibling key inside attestation (e.g., revoked: after trusted_keys:)
+      if (indent <= collectBase && !trimmed.startsWith('-') && trimmed.includes(':')) {
+        flush();
+        collecting = null;
+        // fall through to process this line as att child
+      } else if (trimmed.startsWith('-')) {
+        flush();
+        current = {};
+        curIndent = indent;
+        const afterDash = trimmed.slice(1).trim();
+        if (!afterDash) continue;
+        if (afterDash.startsWith('{') && afterDash.endsWith('}')) {
+          const inner = afterDash.slice(1, -1);
+          for (const part of inner.split(',')) {
+            const colon = part.indexOf(':');
+            if (colon === -1) continue;
+            const k = part.slice(0, colon).trim();
+            const v = part.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+            if (k && v) current[k] = v;
+          }
+        } else if (afterDash.includes(':')) {
+          const colon = afterDash.indexOf(':');
+          const k = afterDash.slice(0, colon).trim();
+          const v = afterDash.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+          if (k && v) current[k] = v;
+        } else {
+          const v = afterDash.replace(/^["']|["']$/g, '');
+          if (v) current['id'] = v;
+        }
+        continue;
+      } else if (current && trimmed.includes(':')) {
+        if (indent > curIndent) {
+          const colon = trimmed.indexOf(':');
+          const k = trimmed.slice(0, colon).trim();
+          const v = trimmed.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+          if (k && v) current[k] = v;
+          continue;
+        }
+      }
+      // if still collecting but line is not part of current item, skip?
+      if (collecting) continue;
+    }
+
+    // not collecting (or just exited) — look for att children
+    if (trimmed.startsWith('required:')) {
+      const v = trimmed.slice('required:'.length).trim().replace(/^["']|["']$/g, '');
+      if (v === 'true') required = true;
+      else if (v === 'false') required = false;
+      continue;
+    }
+    if (trimmed.startsWith('trusted_keys:')) {
+      const after = trimmed.slice('trusted_keys:'.length).trim();
+      // handle inline empty `[]`
+      if (after === '[]') continue;
+      collecting = 'trusted';
+      collectBase = indent;
+      current = null;
+      // if inline list with one map on same line? e.g., trusted_keys: [{ id: "a", pubkey: "x" }]
+      // MVP not needed; empty case already handled
+      continue;
+    }
+    if (trimmed.startsWith('revoked:')) {
+      const after = trimmed.slice('revoked:'.length).trim();
+      if (after === '[]') continue;
+      collecting = 'revoked';
+      collectBase = indent;
+      current = null;
+      continue;
+    }
+  }
+  flush();
+  if (required === undefined && trusted.length === 0 && revoked.length === 0) return null;
+  const out: { required?: boolean; trusted_keys?: Array<Record<string, string>>; revoked?: Array<Record<string, string>> } = {};
+  if (required !== undefined) out.required = required;
+  if (trusted.length) out.trusted_keys = trusted;
+  if (revoked.length) out.revoked = revoked;
+  return out;
+}
+
 export function loadPolicy(projectDir: string): MugiwaraPolicy | null {
   for (const name of POLICY_FILES) {
     const file = join(projectDir, name);
     if (!existsSync(file)) continue;
-    return normalize(parsePolicyYaml(readFileSync(file, 'utf8')));
+    const text = readFileSync(file, 'utf8');
+    const raw = parsePolicyYaml(text);
+    const extra = extractExtraSecretPatterns(text);
+    if (extra.length) {
+      if (!raw.integrity || typeof raw.integrity !== 'object' || Array.isArray(raw.integrity)) raw.integrity = {};
+      (raw.integrity as Record<string, unknown>).extra_secret_patterns = extra;
+    }
+    const att = extractAttestation(text);
+    if (att) {
+      if (!raw.attestation || typeof raw.attestation !== 'object' || Array.isArray(raw.attestation)) raw.attestation = {};
+      const a = raw.attestation as Record<string, unknown>;
+      if (att.required !== undefined) a.required = att.required;
+      if (att.trusted_keys) a.trusted_keys = att.trusted_keys;
+      if (att.revoked) a.revoked = att.revoked;
+    }
+    return normalize(raw);
   }
   return null;
 }
@@ -128,6 +362,58 @@ function normalize(raw: Record<string, unknown>): MugiwaraPolicy {
   }
   const evidence = raw.evidence as Record<string, unknown> | undefined;
   if (evidence && Array.isArray(evidence.required)) out.evidence = { required: strings(evidence.required) };
+  const integrity = raw.integrity as Record<string, unknown> | undefined;
+  if (integrity && Array.isArray(integrity.extra_secret_patterns)) {
+    const arr = integrity.extra_secret_patterns as unknown[];
+    const cleaned: Array<{ pattern: string; label: string; severity?: 'block' | 'warn' }> = [];
+    for (const e of arr) {
+      if (!e || typeof e !== 'object') continue;
+      const rec = e as Record<string, unknown>;
+      if (typeof rec.pattern !== 'string' || typeof rec.label !== 'string') continue;
+      const sev = rec.severity === 'warn' ? 'warn' as const : rec.severity === 'block' ? 'block' as const : undefined;
+      const entry: { pattern: string; label: string; severity?: 'block' | 'warn' } = { pattern: rec.pattern, label: rec.label };
+      if (sev) entry.severity = sev;
+      cleaned.push(entry);
+    }
+    if (cleaned.length) out.integrity = { extra_secret_patterns: cleaned };
+  }
+  const att = raw.attestation as Record<string, unknown> | undefined;
+  if (att) {
+    const a: NonNullable<MugiwaraPolicy['attestation']> = {};
+    if (typeof att.required === 'boolean') a.required = att.required;
+    if (Array.isArray(att.trusted_keys)) {
+      const cleanedTk: Array<{ id: string; pubkey: string; added?: string }> = [];
+      for (const e of att.trusted_keys as unknown[]) {
+        if (!e || typeof e !== 'object') continue;
+        const rec = e as Record<string, unknown>;
+        if (typeof rec.id !== 'string' || typeof rec.pubkey !== 'string') continue;
+        if (!rec.id.trim() || !rec.pubkey.trim()) continue;
+        const entry: { id: string; pubkey: string; added?: string } = { id: rec.id.trim(), pubkey: rec.pubkey.trim() };
+        if (typeof rec.added === 'string' && rec.added.trim()) entry.added = rec.added.trim();
+        cleanedTk.push(entry);
+      }
+      if (cleanedTk.length) a.trusted_keys = cleanedTk;
+    }
+    if (Array.isArray(att.revoked)) {
+      const cleanedRv: Array<{ id: string; revoked?: string; reason?: string; pubkey?: string }> = [];
+      for (const e of att.revoked as unknown[]) {
+        if (!e || typeof e !== 'object') continue;
+        const rec = e as Record<string, unknown>;
+        if (typeof rec.id !== 'string' || !rec.id.trim()) continue;
+        const entry: { id: string; revoked?: string; reason?: string; pubkey?: string } = { id: rec.id.trim() };
+        if (typeof rec.revoked === 'string' && rec.revoked.trim()) entry.revoked = rec.revoked.trim();
+        if (typeof rec.reason === 'string' && rec.reason.trim()) entry.reason = rec.reason.trim();
+        if (typeof rec.pubkey === 'string' && rec.pubkey.trim()) entry.pubkey = rec.pubkey.trim();
+        cleanedRv.push(entry);
+      }
+      if (cleanedRv.length) a.revoked = cleanedRv;
+    }
+    if (a.required !== undefined || a.trusted_keys || a.revoked) out.attestation = a;
+  }
+  const harness = raw.harness as Record<string, unknown> | undefined;
+  if (harness && typeof harness.require_enforcement === 'boolean') {
+    out.harness = { require_enforcement: harness.require_enforcement };
+  }
   return out;
 }
 
@@ -154,3 +440,70 @@ export function matchedGlobs(paths: string[], globs: string[]): string[] {
 export function effectiveThreshold(configured: number, policyValue: number | undefined): number {
   return Math.max(configured, policyValue ?? 0);
 }
+
+// ── Harness enforcement (D8) ────────────────────────────────────────────────
+// Only opencode has runtime write-scope enforcement; the other 11 harnesses
+// are rules-based. `harness.require_enforcement: true` refuses to run where
+// the harness is not enforced.
+
+/** Detect current harness. Mirrors savepoint.sh logic. */
+export function detectHarness(projectDir?: string): string {
+  const e = process.env;
+  const has = (v: string | undefined) => v !== undefined && v !== '';
+  if (has(e.CLAUDECODE) || has(e.CLAUDE_CODE_ENTRYPOINT) || (typeof e.ANTHROPIC_MODEL === 'string' && /claude/i.test(e.ANTHROPIC_MODEL))) return 'claude';
+  if (has(e.OPENCODE) || has(e.OPENCODE_TOKENS_FILE)) return 'opencode';
+  const candidates = [
+    projectDir ? join(projectDir, '.opencode', 'config.json') : null,
+    join(process.cwd(), '.opencode', 'config.json'),
+  ].filter(Boolean) as string[];
+  for (const p of candidates) {
+    try { if (existsSync(p)) return 'opencode'; } catch { /* ignore */ }
+  }
+  if (has(e.CURSOR) || has(e.VSCODE_GIT_ASKPASS_NODE)) return 'cursor';
+  return 'unknown';
+}
+
+/** Only opencode is runtime-enforced. */
+export function isEnforcedHarness(projectDir?: string): boolean {
+  return detectHarness(projectDir) === 'opencode';
+}
+
+/** Pure check: returns error message when policy requires enforcement but harness is rules-based, else null. */
+export function getHarnessEnforcementError(projectDir: string): string | null {
+  let policy: MugiwaraPolicy | null;
+  try { policy = loadPolicy(projectDir); } catch (e) { throw e; }
+  if (!policy?.harness?.require_enforcement) return null;
+  if (isEnforcedHarness(projectDir)) return null;
+  const h = detectHarness(projectDir);
+  return `harness enforcement required but current harness is rules-based only \u2014 use opencode or set harness.require_enforcement:false (detected: ${h})`;
+}
+
+/** Fail closed when policy requires enforcement but harness is rules-based. */
+export function enforceHarnessPolicy(projectDir: string): void {
+  const err = getHarnessEnforcementError(projectDir);
+  if (!err) return;
+  console.error(`\u2717 ${err}`);
+  process.exit(1);
+}
+
+/** Alias for CLI import convenience. */
+export const checkHarnessEnforcement = enforceHarnessPolicy;
+
+// ── Lane-aware gates (T3) ───────────────────────────────────────────────────
+// Direct → minimal (typecheck+build only), lean → +validate-content, standard+
+// → +evals/retrieval/conformance/benchmark. Single source for gate-selftest
+// and the franky-gates skill doc. Full = 12 steps, direct = 3 steps.
+export const GATE_STEPS_BY_LANE: Record<string, string[]> = {
+  direct: ['build-hooks:check', 'typecheck', 'build'],
+  lean: ['build-hooks:check', 'typecheck', 'build', 'validate-content', 'lane-base', 'check-doc-links'],
+  standard: ['build-hooks:check', 'typecheck', 'build', 'validate-content', 'lane-base', 'check-doc-links', 'test:coverage', 'coverage-gate', 'verify-install'],
+  full: ['build-hooks:check', 'typecheck', 'build', 'validate-content', 'lane-base', 'check-doc-links', 'test:coverage', 'coverage-gate', 'verify-install', 'run-evals', 'retrieval-eval', 'conformance'],
+};
+
+export function gatesForLane(lane: string): string[] {
+  return GATE_STEPS_BY_LANE[lane] ?? GATE_STEPS_BY_LANE.full;
+}
+
+export function isLaneAwareGateStep(step: string, lane: string): boolean {
+  return gatesForLane(lane).includes(step);
+}

package/src/posture.ts

@@ -0,0 +1,86 @@
+// src/posture.ts
+// Mugiwara Phase B — deterministic posture selection matrix. Maps existing
+// lane/risk/dependency/context/governor inputs to an execution posture with a
+// concrete reason + evidence refs — never an opaque score. Pure, testable.
+//
+// Posture is independent of control mode (guided/semi/auto). The governor's
+// verdict can pause but never silently changes mode or crew roles.
+
+export type Posture =
+  | 'inline-sequential'
+  | 'inline-batched'
+  | 'parallel-workers'
+  | 'context-relief'
+  | 'phase-isolated'
+  | 'team-scoped';
+
+export type GovernorVerdict = 'normal' | 'avoid' | 'stop';
+
+export type PostureInput = {
+  lane: 'direct' | 'lean' | 'standard' | 'full' | 'spike';
+  risk: 'low' | 'medium' | 'high';
+  independent_tasks: number;
+  order_dependent: boolean;
+  context_pressure: boolean;
+  team_members: number;
+  phases: number;
+  plan_lines: number;
+  governor: GovernorVerdict;
+};
+
+export type PostureResult = {
+  posture: Posture;
+  pause: boolean;
+  reason: string;
+  evidence_refs: string[];
+};
+
+export function selectPosture(input: PostureInput): PostureResult {
+  // stop verdict → safe pause, keep prior topology (recorded, never silent)
+  if (input.governor === 'stop') {
+    return {
+      posture: 'inline-sequential',
+      pause: true,
+      reason: 'governor stop — pause safely, keep inline; state + continue emitted',
+      evidence_refs: ['governor circuit-breaker', 'state.json'],
+    };
+  }
+  if (input.team_members > 1) {
+    return {
+      posture: 'team-scoped',
+      pause: false,
+      reason: `${input.team_members} team members with non-overlapping scope`,
+      evidence_refs: ['plan ownership map'],
+    };
+  }
+  if (input.phases > 3 || input.plan_lines > 1500) {
+    return {
+      posture: 'phase-isolated',
+      pause: false,
+      reason: `large campaign — ${input.phases} phases / ${input.plan_lines} lines`,
+      evidence_refs: ['plan.md', 'large-campaign-subplan.md'],
+    };
+  }
+  if (input.context_pressure && input.order_dependent) {
+    return {
+      posture: 'context-relief',
+      pause: false,
+      reason: 'context pressure with ordered dependent tasks — one worker at a time, order preserved',
+      evidence_refs: ['state context metrics', 'remaining task order'],
+    };
+  }
+  if (input.independent_tasks >= 2) {
+    return {
+      posture: 'parallel-workers',
+      pause: false,
+      reason: `${input.independent_tasks} independent tasks, no shared files/interfaces`,
+      evidence_refs: ['Nami dependency map', 'work-governor delegation verdict'],
+    };
+  }
+  return {
+    posture: 'inline-sequential',
+    pause: false,
+    reason: 'no parallel/phase/team/relief trigger — default inline in plan order',
+    evidence_refs: ['triage route', 'lane'],
+  };
+}

package/src/provenance.ts

@@ -75,16 +75,34 @@ export function renderProvenanceMd(note: string, sha: string | null): string {
   return lines.join('\n') + '\n';
 }
 
-export function attachGitNote(projectDir: string, branch: string, note: string): { sha: string } | null {
+export function attachGitNote(projectDir: string, branch: string, note: string, baseSha?: string): { sha: string; count: number } | null {
   try {
-    let sha: string;
+    const range = baseSha ? `${baseSha}..${branch}` : branch;
+    let shas: string[] = [];
     try {
-      sha = git(projectDir, ['rev-parse', '--verify', branch]);
+      const raw = git(projectDir, ['rev-list', range]);
+      shas = raw.split('\n').filter(Boolean);
     } catch {
-      sha = git(projectDir, ['rev-parse', 'HEAD']);
+      // rev-list failed (unknown baseSha/branch) — fall back to single head
+      shas = [];
     }
-    git(projectDir, ['notes', '--ref=mugiwara', 'add', '-f', '-m', note, sha]);
-    return { sha };
+    // ponytail: cap at 200 commits, fallback to head-only beyond
+    if (shas.length > 200) {
+      console.warn(`attachGitNote: range ${shas.length} >200, falling back to head-only`);
+      shas = [];
+    }
+    let targets = shas;
+    if (!targets.length) {
+      try {
+        targets = [git(projectDir, ['rev-parse', '--verify', branch])];
+      } catch {
+        targets = [git(projectDir, ['rev-parse', 'HEAD'])];
+      }
+    }
+    for (const sha of targets) {
+      git(projectDir, ['notes', '--ref=mugiwara', 'add', '-f', '-m', note, sha]);
+    }
+    return { sha: targets[0], count: targets.length };
   } catch {
     // not a repo, detached oddities, or notes disabled — degrade honestly
     return null;
@@ -104,13 +122,15 @@ export function blamePath(projectDir: string, path: string): string {
     const note = git(projectDir, ['notes', '--ref=mugiwara', 'show', sha]);
     return `${path} @ ${sha.slice(0, 7)}\n${note}`;
   } catch {
-    return `${path} @ ${sha.slice(0, 7)}\n(no mugiwara provenance note on this commit)`;
+    return `${path} @ ${sha.slice(0, 7)}\nno per-commit note — see .mugiwara/missions/<m>/provenance.md`;
   }
 }
 
 /** Closure hook: write provenance.md + attach the git note. */
-export function writeProvenance(projectDir: string, missionDir: string, state: NoteSource): void {
+export function writeProvenance(projectDir: string, missionDir: string, state: NoteSource & { base_sha?: string }, baseSha?: string): void {
   const note = buildNote(state);
-  const attached = attachGitNote(projectDir, state.branch, note);
+  const resolvedBase = baseSha ?? (typeof (state as Record<string, unknown>).base_sha === 'string' ? (state as Record<string, unknown>).base_sha as string : undefined);
+  const cleanBase = resolvedBase && resolvedBase !== 'unknown' ? resolvedBase : undefined;
+  const attached = attachGitNote(projectDir, state.branch, note, cleanBase);
   writeFileSync(join(missionDir, 'provenance.md'), renderProvenanceMd(note, attached ? attached.sha : null));
 }