@ionivetech/mugiwara 0.7.0 → 0.8.1

package/src/mission.ts

@@ -4,10 +4,17 @@ import { existsSync, rmSync, readFileSync, readdirSync, mkdirSync, writeFileSync
 import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
 import { checkTrail, formatIssues } from './integrity.ts';
+import { checkMissionArtifacts } from './check-artifacts.ts';
 import { generateRollback } from './rollback.ts';
 import { writeProvenance } from './provenance.ts';
+import { loadPolicy } from './policy.ts';
+import { verifyReport } from './sign.ts';
 import { rankFiles, renderRouting } from './routing.ts';
-import { formatFootprint, measureContextChars, readBudgetConfig } from './budget.ts';
+import { formatFootprint, measureContextChars, readBudgetConfig, shouldCompress, compressThreshold } from './budget.ts';
+import { budgetForLane, costEnvelope, appendCostEvent, COMPRESSED_KIND } from './cost.ts';
+import { loadRegistry } from './evidence.ts';
+import { computeContextMetrics, contextStatus } from './context.ts';
+import { buildCostLedger, renderAdaptationSection } from './reporting.ts';
 
 function isStateFile(f: string): boolean {
   // state.json (solo) or <member>.json (team) — never continue*.json
@@ -26,6 +33,52 @@ function primaryState(dir: string, files: string[]): Record<string, unknown> | n
   }
 }
 
+/** Extract tasks from state.json — handles nested tasks:{done,total} (current savepoint) and legacy flat fields. */
+function tasksFromState(state: Record<string, unknown> | null): { done: number; total: number } {
+  if (!state) return { done: 0, total: 0 };
+  const t = (state as Record<string, unknown>).tasks as { done?: unknown; total?: unknown } | undefined;
+  if (t && typeof t.done === 'number' && typeof t.total === 'number') return { done: t.done, total: t.total };
+  const done = Number((state as Record<string, unknown>).tasks_done);
+  const total = Number((state as Record<string, unknown>).tasks_total);
+  return { done: Number.isFinite(done) ? done : 0, total: Number.isFinite(total) ? total : 0 };
+}
+
+/** Fresh task counts from plan.md, with sub-plan fallback for large campaigns (>3 phases). */
+function countPlanTasks(missionDir: string): { done: number; total: number } {
+  let total = 0;
+  let done = 0;
+  const planFile = join(missionDir, 'plan.md');
+  if (existsSync(planFile)) {
+    try {
+      const text = readFileSync(planFile, 'utf8');
+      for (const line of text.split(/\r?\n/)) {
+        if (/^\s*-\s*\[[ xX]\]/.test(line)) {
+          total++;
+          if (/^\s*-\s*\[[xX]\]/.test(line)) done++;
+        }
+      }
+    } catch { /* best-effort */ }
+  }
+  if (total === 0) {
+    const subPlanDir = join(missionDir, 'sub-plan');
+    if (existsSync(subPlanDir)) {
+      try {
+        for (const f of readdirSync(subPlanDir)) {
+          if (!f.endsWith('.md')) continue;
+          const text = readFileSync(join(subPlanDir, f), 'utf8');
+          for (const line of text.split(/\r?\n/)) {
+            if (/^\s*-\s*\[[ xX]\]/.test(line)) {
+              total++;
+              if (/^\s*-\s*\[[xX]\]/.test(line)) done++;
+            }
+          }
+        }
+      } catch { /* best-effort */ }
+    }
+  }
+  return { done, total };
+}
+
 /** Files the mission changed, base..branch. Empty on any git failure — routing is best-effort. */
 function changedFiles(projectDir: string, state: Record<string, unknown> | null): string[] {
   const base = typeof state?.base_sha === 'string' ? state.base_sha : '';
@@ -96,6 +149,11 @@ export function resetMission(projectDir: string, keepLogs: boolean, force?: bool
     if (existsSync(join(root, 'lessons.md'))) kept.push('lessons.md');
     else if (existsSync(join(root, join('logs', 'lessons.md')))) kept.push(join('logs', 'lessons.md'));
   }
+  // index.md is the archive history — after a full reset (missions gone) its entries are dangling (point to deleted report.md). A reset is a fresh start, so clear it; next archive recreates "# Mission index" header.
+  if (removed.includes('missions') && existsSync(join(root, 'index.md'))) {
+    rmSync(join(root, 'index.md'));
+    removed.push('index.md');
+  }
   for (const f of ['config', 'manifest.json', 'backup']) {
     if (existsSync(join(root, f))) kept.push(f);
   }
@@ -117,10 +175,40 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
 
   // Closure integrity gate: the trail validates itself before it
   // folds. Dangling links, secrets, or missing evidence fail the archive.
+  // Card-number shapes are warn-only — they do not block archive.
   if (!dryRun) {
     const issues = checkTrail(dir, projectDir);
-    if (issues.length) {
-      throw new Error(`closure integrity gate failed — fix these before archiving:\n${formatIssues(issues)}`);
+    const blocking = issues.filter((i) => i.kind !== 'secret-warn' && i.severity !== 'warn');
+    if (blocking.length) {
+      throw new Error(`closure integrity gate failed — fix these before archiving:\n${formatIssues(blocking)}`);
+    }
+    if (issues.length && blocking.length === 0) {
+      // warn-only — log but do not fail
+      // console.warn is best-effort; archive proceeds
+      try {
+        const warnText = formatIssues(issues);
+        if (warnText) console.warn(`closure integrity warnings (non-blocking):\n${warnText}`);
+      } catch { /* ignore */ }
+    }
+    // Artifact gate (roadmap v0.8 item 4): Lane 2+ missions must carry
+    // plan.md + flows/* evidence — a mission without its trail does not fold.
+    const artifacts = checkMissionArtifacts(dir);
+    if (!artifacts.ok) {
+      throw new Error(`archive artifact gate failed — missing: ${artifacts.missing.join(', ')} (lane ${artifacts.lane}). Write the evidence trail before archiving.`);
+    }
+    // Attestation gate (D4): when attestation.required true, report must be signed and trusted.
+    try {
+      const policy = loadPolicy(projectDir);
+      if (policy?.attestation?.required) {
+        const v = verifyReport(projectDir, dir);
+        if (!v.ok) {
+          throw new Error(`closure integrity gate failed — attestation required but report not signed/trusted: ${v.message}`);
+        }
+      }
+    } catch (e) {
+      if ((e as Error).message.startsWith('closure integrity gate failed — attestation required')) throw e;
+      if ((e as Error).message.startsWith('unknown policy key')) throw e;
+      // other policy load errors are best-effort — do not block archive
     }
   }
 
@@ -142,18 +230,51 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
     const chars = measureContextChars(dir);
     const budget = readBudgetConfig(projectDir);
     const footprintLine = formatFootprint(chars, budget);
-    if (budget && chars > budget) {
-      throw new Error(`closure context budget failed — ${footprintLine}. Trim the trail or raise context_budget_chars.`);
-    }
     const est = typeof state.tokens_est === 'number' ? state.tokens_est : 0;
     const src = typeof state.tokens_source === 'string' ? state.tokens_source : 'computed';
     const lane = typeof state.lane === 'string' ? state.lane : 'unknown';
-    // lane budgets for readable delta (from lane-base.sh, mirrored here for display only)
-    const laneBudget = lane === 'lean' ? 12000 : lane === 'standard' ? 25000 : lane === 'full' ? 50000 : lane === 'spike' ? 3000 : 0;
-    const effBudget = budget || laneBudget;
-    const pct = effBudget ? Math.round((est / effBudget) * 100) : 0;
+    // C2: `status` gates on the LANE token budget (what savepoint.sh enforces),
+    // never on the context char budget. `contextStatus` below is its own gate.
+    const laneBudget = budgetForLane(lane);
+    // Q1/Q2: the normalized envelope computes planned/used/remaining/pct/status
+    // on the lane token budget — ONE computation (Q2), reused at render and for
+    // the closure event. `effBudget` stays only for the readable delta display.
+    const env = costEnvelope({ lane, budget: laneBudget, tokens_est: est });
+    const effBudget = budget || laneBudget; // display-only delta basis — never for status (C2)
     const delta = effBudget ? (est <= effBudget ? `${(effBudget - est).toLocaleString()} under` : `${(est - effBudget).toLocaleString()} over`) : 'no budget configured';
     const srcLabel = src === 'reported' ? 'provider-reported' : 'estimator';
+    const statusLabel = env.status.toUpperCase(); // derived from the single computation, not recomputed
+    // context status on context_budget_chars — separate gate, never token `est` (C2)
+    const ctxStatus = contextStatus(budget, chars);
+    // context-efficiency metrics from the evidence registry (reads), else all-zero
+    // with a note — a zero row must not be misread as "efficient" (risk row).
+    const registry = loadRegistry(dir);
+    const reads_total = registry.reduce((s, e) => s + e.reads, 0);
+    const repeated_reads = registry.reduce((s, e) => s + Math.max(e.reads - 1, 0), 0);
+    // M1: honest char accounting — each registered entry carries the content
+    // length it holds (chars). total_chars = chars actually loaded (each entry
+    // × its reads); unique_chars = distinct payload bytes. computeContextMetrics
+    // derives duplicate_chars = total − unique (bytes re-read) and
+    // read_avoidance_chars = same (bytes not reloaded by reuse). When a
+    // registry exists but carries no char payloads (legacy/absent field), the
+    // char fields render as n/a — never fabricated 0 — so reuse_rate > 0 never
+    // sits beside a false "read_avoidance_chars: 0".
+    const unique_chars = registry.reduce((s, e) => s + (e.chars ?? 0), 0);
+    const total_chars = registry.reduce((s, e) => s + (e.chars ?? 0) * e.reads, 0);
+    const charTracked = registry.length > 0 && total_chars > 0;
+    const metrics = registry.length
+      ? computeContextMetrics({
+          files_loaded: registry.length,
+          reads_total,
+          reads_reused: repeated_reads,
+          unique_chars,
+          total_chars,
+          repeated_reads,
+        })
+      : { files_loaded: 0, repeated_reads: 0, duplicate_chars: 0, reuse_rate: 0, read_avoidance_chars: 0 };
+    const ctxNote = registry.length
+      ? (charTracked ? '' : ' (char data not tracked)')
+      : ' (no registry — reads not tracked)';
     // provider-reported rollup when any stage reported
     let reportedTotal = 0;
     let hasReported = false;
@@ -176,14 +297,87 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
       '| Metric | Value |',
       '|--------|-------|',
       `| **Tokens used** | ${est.toLocaleString()} (${srcLabel}) |`,
-      `| **Lane** | ${lane} (budget ${effBudget ? effBudget.toLocaleString() : '—'} · warn ${effBudget ? Math.round(effBudget * 1.5).toLocaleString() : '—'} · stop ${effBudget ? (effBudget * 3).toLocaleString() : '—'}) |`,
-      `| **Budget status** | ${effBudget ? `${pct}% of budget · ${delta} · ${est >= effBudget * 3 ? 'STOP' : est >= effBudget * 1.5 ? 'WARN' : 'OK'}` : 'no lane budget'} |`,
+      `| **Lane** | ${lane} (budget ${effBudget ? effBudget.toLocaleString() : '—'} · warn ${effBudget ? env.warn_at.toLocaleString() : '—'} · stop ${effBudget ? env.stop_at.toLocaleString() : '—'}) |`,
+      `| **Budget status** | ${effBudget ? `${env.pct}% of budget · ${delta} · ${statusLabel}` : 'no lane budget'} |`,
       `| **Context footprint** | ${chars.toLocaleString()} chars${budget ? ` (budget ${budget.toLocaleString()})` : ' (no context budget configured)'} |`,
+      `| **Context budget status** | ${ctxStatus.toUpperCase()}${budget ? ` (budget ${budget.toLocaleString()})` : ' (no context budget configured)'} |`,
+      `| **Context efficiency** | files_loaded: ${metrics.files_loaded} · repeated_reads: ${metrics.repeated_reads} · duplicate_chars: ${charTracked ? metrics.duplicate_chars : 'n/a'} · reuse_rate: ${metrics.reuse_rate} · read_avoidance_chars: ${charTracked ? metrics.read_avoidance_chars : 'n/a'}${ctxNote} |`,
     ].join('\n');
     if (hasReported) {
       costSection += `\n| **Provider total** | ${reportedTotal.toLocaleString()} (provider-reported — sum of reported stages) |`;
     }
+    // Phase 8 Reporting — ledger/avoided/efficiency/trail rows (§39/§43)
+    try {
+      const ledger = buildCostLedger({ missionDir: dir, envelope: env });
+      costSection += `\n| Budget | ${ledger.envelope.status} ${ledger.envelope.pct}% (${ledger.envelope.used}/${ledger.envelope.planned}) |`;
+      costSection += `\n| Context | ${chars.toLocaleString()} chars, reuse ${ledger.efficiency.reuse_rate} |`;
+      costSection += `\n| Avoided | ${ledger.avoided.stages_avoided} stages, ${ledger.avoided.contexts_avoided} contexts, ${ledger.avoided.tokens_avoided_est} tokens est |`;
+      costSection += `\n| Efficiency | reuse ${ledger.efficiency.reuse_rate}, dup ${ledger.efficiency.duplicate_avoidance_chars} chars, budget ${ledger.efficiency.budget_efficiency_pct}% |`;
+      costSection += `\n| Trail | ${ledger.trail.length} decisions |`;
+      if (ledger.trail.length) {
+        const show = ledger.trail.slice(0, 5);
+        for (const t of show) costSection += `\n- ${t.ts} — ${t.actor}: ${t.decision} — reason: ${t.reason}${t.evidence ? ` — evidence: ${t.evidence}` : ''}`;
+        if (ledger.trail.length > 5) costSection += `\n… ${ledger.trail.length - 5} more`;
+      }
+    } catch { /* ledger best-effort — trail parse failure never blocks archive */ }
     costSection += '\n';
+    // Phase E — adaptation summary from the posture decision trail
+    try {
+      costSection += renderAdaptationSection(dir);
+    } catch { /* best-effort */ }
+
+    // T4: auto-compress when context >80% budget — compress flows → stub, not throw
+    // (record compressed event; closure still recorded; hard gate only at 100%)
+    if (shouldCompress(budget, chars)) {
+      try {
+        const flowsDir = join(dir, 'flows');
+        const wavesDir = join(dir, 'waves');
+        const targetDir = existsSync(flowsDir) ? flowsDir : existsSync(wavesDir) ? wavesDir : null;
+        if (targetDir && existsSync(targetDir)) {
+          const flowFiles = readdirSync(targetDir).filter(f => f.endsWith('.md'));
+          if (flowFiles.length) {
+            const pct = Math.round((chars / budget) * 100);
+            const stub = `# Compressed trail\n\nTrail ${chars} chars exceeds ${pct}% of budget ${budget} (threshold ${compressThreshold(budget)}) — flows archived as stub to preserve budget. Original flows: ${flowFiles.join(', ')}\n`;
+            for (const f of flowFiles) {
+              try { rmSync(join(targetDir, f), { force: true }); } catch {}
+            }
+            writeFileSync(join(targetDir, '00-compressed.md'), stub);
+          }
+        }
+        appendCostEvent(dir, {
+          kind: COMPRESSED_KIND,
+          mission,
+          tokens_est: est,
+          budget: laneBudget,
+          status: 'compressed',
+          context_chars: chars,
+          context_status: ctxStatus,
+          context_metrics: metrics,
+        });
+        costSection += `\n| **Compressed** | yes — ${chars} chars >80% of ${budget} — flows stubbed as 00-compressed.md |`;
+      } catch { /* compress best-effort — never blocks archive */ }
+    }
+
+    // Cost Governor: record the closure cost event — the mission's final
+    // cost snapshot, folded into report.md with the rest of the trail.
+    // (Phase 1 — native cost governor; pure append, never rewrites state.)
+    appendCostEvent(dir, {
+      kind: 'closure',
+      mission,
+      tokens_est: est,
+      budget: laneBudget,
+      status: env.status, // Q2: the single lane-token-budget computation
+      context_chars: chars,
+      context_status: ctxStatus,
+      context_metrics: metrics,
+    });
+    // M2: the closure event (with context_status possibly 'over') is recorded
+    // BEFORE the hard gate throws — an over-budget closure still leaves a
+    // ledger row so the over-budget condition is observable, never erased.
+    // T4: over 80% already compressed above; hard fail only at 100% preserves gate-selftest.
+    if (budget && chars > budget) {
+      throw new Error(`closure context budget failed — ${footprintLine}. Trim the trail or raise context_budget_chars.`);
+    }
   }
 
   // Fold order: narrative artifacts first, wave evidence last (chronological).
@@ -194,13 +388,30 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
   }
   // Flow artifacts: flows/ is the current layout; a legacy mission that still
   // keeps waves/ folds from there so an upgrade never strands a trail.
+  // 07-pr-verdict.md SURVIVES archive as a standalone `pr-verdict.md` at the
+  // mission root — it is the PR material handed to the user, so it must not
+  // fold away into report.md.
+  const PR_VERDICT = 'pr-verdict.md';
+  const PR_VERDICT_SRC = join('flows', '07-pr-verdict.md');
   const flowsDir = join(dir, 'flows');
   const legacyWavesDir = join(dir, 'waves');
   const artDir = existsSync(flowsDir) ? flowsDir : existsSync(legacyWavesDir) ? legacyWavesDir : flowsDir;
   const artRel = artDir === legacyWavesDir ? 'waves' : 'flows';
   if (existsSync(artDir)) {
-    for (const f of readdirSync(artDir).sort()) fold.push(join(artRel, f));
+    for (const f of readdirSync(artDir).sort()) {
+      if (artRel === 'flows' && f === '07-pr-verdict.md') continue; // survives as pr-verdict.md
+      fold.push(join(artRel, f));
+    }
   }
+  // Cost events ledger — appended by the closure event above (or a prior
+  // savepoint in a later phase); folds like any other trail artifact so
+  // nothing survives loose after archive.
+  if (existsSync(join(dir, 'cost-events.jsonl'))) fold.push('cost-events.jsonl');
+  // H1: the context registry is the same class of artifact as cost-events.jsonl
+  // (append-only JSONL ledger) — fold it into report.md and remove it so it does
+  // NOT survive loose after archive (survival parity; the fold loop below also
+  // removes every folded file).
+  if (existsSync(join(dir, 'context-registry.jsonl'))) fold.push('context-registry.jsonl');
 
   // The report survives: an existing report.md wins; otherwise the closure
   // wave seeds it; otherwise it starts empty.
@@ -211,6 +422,14 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
 
   if (!dryRun) {
     mkdirSync(dir, { recursive: true });
+    // PR verdict survives archive as a standalone file at the mission root —
+    // it is the PR material handed to the user and must not fold away.
+    const prVerdictSrc = join(dir, PR_VERDICT_SRC);
+    if (existsSync(prVerdictSrc)) {
+      const prVerdictPath = join(dir, PR_VERDICT);
+      writeFileSync(prVerdictPath, readFileSync(prVerdictSrc, 'utf8'));
+      kept.push(join('missions', mission, PR_VERDICT));
+    }
     if (fold.length) {
       const sections = fold.map((f) => {
         const body = readFileSync(join(dir, f), 'utf8').trim();
@@ -235,6 +454,11 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
       rmSync(join(dir, f), { force: true, recursive: true });
       removed.push(join('missions', mission, f));
     }
+    // the pr-verdict source was copied to the root — remove the flows/ copy
+    if (existsSync(prVerdictSrc)) {
+      rmSync(join(dir, PR_VERDICT_SRC), { force: true });
+      removed.push(join('missions', mission, PR_VERDICT_SRC));
+    }
     // session state dies with the mission
     for (const f of files.filter((f) => f.endsWith('.json'))) rmSync(join(dir, f), { force: true });
     // flows/ may now be empty — remove the folder
@@ -254,17 +478,23 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
       });
       if (rb) kept.push(join('missions', mission, rb.file));
       try {
+        const st = tasksFromState(state);
+        const pt = countPlanTasks(dir);
+        const tasks_done = pt.total > 0 ? pt.done : st.done;
+        const tasks_total = pt.total > 0 ? pt.total : st.total;
+        const baseShaForNote = typeof state.base_sha === 'string' ? state.base_sha : undefined;
         writeProvenance(projectDir, dir, {
           mission,
           actor: typeof state.actor === 'string' ? state.actor : '',
           lane: typeof state.lane === 'string' ? state.lane : '',
           mode: typeof state.mode === 'string' ? state.mode : '',
           branch: state.branch,
-          tasks_done: Number(state.tasks_done) || 0,
-          tasks_total: Number(state.tasks_total) || 0,
+          tasks_done,
+          tasks_total,
           evidence: Array.isArray(state.evidence) ? (state.evidence as string[]) : [],
           models: stageModels,
-        });
+          base_sha: baseShaForNote,
+        } as never, baseShaForNote);
         kept.push(join('missions', mission, 'provenance.md'));
       } catch { /* provenance is additive; archive proceeds */ }
     }