opencode-goal-mode 0.2.2 → 0.3.0

package/docs/benchmarks/results.json

@@ -1,77 +1,217 @@
 {
-  "corpusSize": 71,
-  "destructiveCount": 48,
-  "safeCount": 23,
-  "legacy": {
-    "detectionRate": 20.833333333333336,
-    "falsePositiveRate": 21.73913043478261,
-    "destCaught": 10,
-    "destTotal": 48,
-    "safeFalsePos": 5,
-    "safeTotal": 23,
-    "families": {
-      "classic": {
-        "destTotal": 10,
-        "destCaught": 10,
-        "safeTotal": 0,
-        "safeFalsePos": 0
-      },
-      "bypass": {
-        "destTotal": 35,
-        "destCaught": 0,
-        "safeTotal": 0,
-        "safeFalsePos": 0
-      },
-      "remote-exec": {
-        "destTotal": 3,
-        "destCaught": 0,
-        "safeTotal": 0,
-        "safeFalsePos": 0
+  "external": {
+    "source": "tldr-pages",
+    "commit": "afc5c5409f0c9a94c66980c40cd8215b5f111021",
+    "totals": {
+      "uniqueCommandsScanned": 28713,
+      "destructiveFound": 104,
+      "safeFound": 28609,
+      "safeSampled": 600
+    },
+    "sampleSize": 704,
+    "legacy": {
+      "detectionRate": 53.8,
+      "falsePositiveRate": 0.2,
+      "destCaught": 56,
+      "destTotal": 104,
+      "safeFalsePos": 1,
+      "safeTotal": 600
+    },
+    "current": {
+      "detectionRate": 93.3,
+      "falsePositiveRate": 0.2,
+      "destCaught": 97,
+      "destTotal": 104,
+      "safeFalsePos": 1,
+      "safeTotal": 600,
+      "misses": [
+        "rm -d path/to/directory",
+        "rm -i path/to/file1 path/to/file2 ...",
+        "rm -v $HOME/.cache/fuzzel",
+        "rm -v path/to/file1 path/to/file2 ...",
+        "rm /dev/sdXN",
+        "rm path/to/file1 path/to/file2 ...",
+        "rm torrent_id"
+      ],
+      "falsePositives": [
+        "git filter-repo --path-rename path/to/folder/:"
+      ]
+    }
+  },
+  "fixtures": {
+    "corpusSize": 71,
+    "destructiveCount": 48,
+    "safeCount": 23,
+    "legacy": {
+      "detectionRate": 20.833333333333336,
+      "falsePositiveRate": 21.73913043478261,
+      "destCaught": 10,
+      "destTotal": 48,
+      "safeFalsePos": 5,
+      "safeTotal": 23,
+      "families": {
+        "classic": {
+          "destTotal": 10,
+          "destCaught": 10,
+          "safeTotal": 0,
+          "safeFalsePos": 0
+        },
+        "bypass": {
+          "destTotal": 35,
+          "destCaught": 0,
+          "safeTotal": 0,
+          "safeFalsePos": 0
+        },
+        "remote-exec": {
+          "destTotal": 3,
+          "destCaught": 0,
+          "safeTotal": 0,
+          "safeFalsePos": 0
+        },
+        "safe": {
+          "destTotal": 0,
+          "destCaught": 0,
+          "safeTotal": 23,
+          "safeFalsePos": 5
+        }
       },
-      "safe": {
-        "destTotal": 0,
-        "destCaught": 0,
-        "safeTotal": 23,
-        "safeFalsePos": 5
-      }
+      "opsPerSec": 1260371,
+      "usPerCommand": 0.79
     },
-    "opsPerSec": 381490,
-    "usPerCommand": 2.62
+    "current": {
+      "detectionRate": 100,
+      "falsePositiveRate": 0,
+      "destCaught": 48,
+      "destTotal": 48,
+      "safeFalsePos": 0,
+      "safeTotal": 23,
+      "families": {
+        "classic": {
+          "destTotal": 10,
+          "destCaught": 10,
+          "safeTotal": 0,
+          "safeFalsePos": 0
+        },
+        "bypass": {
+          "destTotal": 35,
+          "destCaught": 35,
+          "safeTotal": 0,
+          "safeFalsePos": 0
+        },
+        "remote-exec": {
+          "destTotal": 3,
+          "destCaught": 3,
+          "safeTotal": 0,
+          "safeFalsePos": 0
+        },
+        "safe": {
+          "destTotal": 0,
+          "destCaught": 0,
+          "safeTotal": 23,
+          "safeFalsePos": 0
+        }
+      },
+      "opsPerSec": 901050,
+      "usPerCommand": 1.11
+    }
   },
-  "current": {
-    "detectionRate": 100,
-    "falsePositiveRate": 0,
-    "destCaught": 48,
-    "destTotal": 48,
-    "safeFalsePos": 0,
-    "safeTotal": 23,
-    "families": {
-      "classic": {
-        "destTotal": 10,
-        "destCaught": 10,
-        "safeTotal": 0,
-        "safeFalsePos": 0
+  "completionFixtures": {
+    "name": "False Completion Dataset",
+    "corpusSize": 9,
+    "requiredBaseGates": [
+      "goal-prompt-auditor",
+      "goal-reviewer",
+      "goal-diff-reviewer",
+      "goal-verifier",
+      "goal-final-auditor"
+    ],
+    "score": 100,
+    "decisionAccuracy": 100,
+    "reasonAccuracy": 100,
+    "falseCompletionBlockRate": 100,
+    "validCompletionAllowRate": 100,
+    "cases": [
+      {
+        "id": "missing-review-cycles-line",
+        "family": "false-completion",
+        "expectedBlocked": true,
+        "actualBlocked": true,
+        "decisionCorrect": true,
+        "reasonCorrect": true,
+        "reason": "missing required Review cycles line"
       },
-      "bypass": {
-        "destTotal": 35,
-        "destCaught": 35,
-        "safeTotal": 0,
-        "safeFalsePos": 0
+      {
+        "id": "zero-review-cycles",
+        "family": "false-completion",
+        "expectedBlocked": true,
+        "actualBlocked": true,
+        "decisionCorrect": true,
+        "reasonCorrect": true,
+        "reason": "no review cycles recorded"
       },
-      "remote-exec": {
-        "destTotal": 3,
-        "destCaught": 3,
-        "safeTotal": 0,
-        "safeFalsePos": 0
+      {
+        "id": "wrong-review-cycle-count",
+        "family": "false-completion",
+        "expectedBlocked": true,
+        "actualBlocked": true,
+        "decisionCorrect": true,
+        "reasonCorrect": true,
+        "reason": "claimed review cycles (1) do not match recorded review cycles (2)"
       },
-      "safe": {
-        "destTotal": 0,
-        "destCaught": 0,
-        "safeTotal": 23,
-        "safeFalsePos": 0
+      {
+        "id": "stale-review-after-edit",
+        "family": "false-completion",
+        "expectedBlocked": true,
+        "actualBlocked": true,
+        "decisionCorrect": true,
+        "reasonCorrect": true,
+        "reason": "required review gates are missing or stale (goal-prompt-auditor, goal-reviewer, goal-diff-reviewer, goal-verifier, goal-final-auditor)"
+      },
+      {
+        "id": "missing-contextual-security-gate",
+        "family": "false-completion",
+        "expectedBlocked": true,
+        "actualBlocked": true,
+        "decisionCorrect": true,
+        "reasonCorrect": true,
+        "reason": "required review gates are missing or stale (goal-security-reviewer)"
+      },
+      {
+        "id": "valid-completion-allowed",
+        "family": "true-completion",
+        "expectedBlocked": false,
+        "actualBlocked": false,
+        "decisionCorrect": true,
+        "reasonCorrect": true,
+        "reason": ""
+      },
+      {
+        "id": "mid-text-mention-not-policed",
+        "family": "true-completion",
+        "expectedBlocked": false,
+        "actualBlocked": false,
+        "decisionCorrect": true,
+        "reasonCorrect": true,
+        "reason": ""
+      },
+      {
+        "id": "inactive-session-not-policed",
+        "family": "true-completion",
+        "expectedBlocked": false,
+        "actualBlocked": false,
+        "decisionCorrect": true,
+        "reasonCorrect": true,
+        "reason": ""
+      },
+      {
+        "id": "custom-marker-escaping",
+        "family": "true-completion",
+        "expectedBlocked": false,
+        "actualBlocked": false,
+        "decisionCorrect": true,
+        "reasonCorrect": true,
+        "reason": ""
       }
-    },
-    "opsPerSec": 256879,
-    "usPerCommand": 3.89
+    ]
   }
 }

package/docs/benchmarks/truthfulness-score.svg

@@ -0,0 +1,17 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="720" height="202" viewBox="0 0 720 202" font-family="-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif">
+<rect width="720" height="202" fill="#ffffff"/>
+<text x="20" y="28" font-size="17" font-weight="700" fill="#1f2328">Completion-enforcement fixtures</text>
+<text x="20" y="47" font-size="12" fill="#656d76">9 hand-authored policy cases (a spec, not a survey): premature claims blocked, valid ones allowed.</text>
+<text x="218" y="87" font-size="12" text-anchor="end" fill="#1f2328">Truthfulness score</text>
+<rect x="230" y="70" width="420" height="22" rx="3" fill="#eaeef2"/>
+<rect x="230" y="70" width="420.0" height="22" rx="3" fill="#2da44e"/>
+<text x="658.0" y="87" font-size="12" font-weight="600" fill="#1f2328">100.0%</text>
+<text x="218" y="125" font-size="12" text-anchor="end" fill="#1f2328">Decision accuracy</text>
+<rect x="230" y="108" width="420" height="22" rx="3" fill="#eaeef2"/>
+<rect x="230" y="108" width="420.0" height="22" rx="3" fill="#0969da"/>
+<text x="658.0" y="125" font-size="12" font-weight="600" fill="#1f2328">100.0%</text>
+<text x="218" y="163" font-size="12" text-anchor="end" fill="#1f2328">Reason accuracy</text>
+<rect x="230" y="146" width="420" height="22" rx="3" fill="#eaeef2"/>
+<rect x="230" y="146" width="420.0" height="22" rx="3" fill="#bf8700"/>
+<text x="658.0" y="163" font-size="12" font-weight="600" fill="#1f2328">100.0%</text>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-goal-mode",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Strict Goal Mode agents, commands, and guard plugin for OpenCode.",
   "type": "module",
   "engines": {
@@ -12,6 +12,7 @@
   },
   "files": [
     "agents/",
+    "benchmarks/",
     "commands/",
     "docs/",
     "plugins/",
@@ -31,6 +32,9 @@
     "test:agents": "node --test tests/agents.test.mjs tests/commands.test.mjs",
     "test:install": "node --test tests/install.test.mjs",
     "bench": "node benchmarks/run.mjs",
+    "bench:external": "node benchmarks/external.mjs",
+    "bench:corpus": "node benchmarks/build-external-corpus.mjs",
+    "bench:truthfulness": "node benchmarks/truthfulness.mjs",
     "bench:compare": "node benchmarks/comparison.mjs",
     "pack:check": "npm pack --dry-run",
     "audit": "npm audit --audit-level=moderate",

package/plugins/goal-guard/config.js

@@ -26,6 +26,12 @@ export const DEFAULT_CONFIG = Object.freeze({
   sessionTtlMs: 24 * 60 * 60 * 1000,
   /** Emit a TUI toast when completion is blocked. */
   toastOnBlock: true,
+  /** Emit a TUI toast when a review gate records a PASS/FAIL, and when completion unlocks. */
+  toastOnReview: true,
+  /** Show the experimental yellow goal banner in the TUI sidebar (TUI-plugin-capable OpenCode only). */
+  sidebarBanner: true,
+  /** Foreground colour (hex) for the sidebar goal banner. */
+  sidebarColor: "#FFD700",
   /** Phrase that, at the start of an assistant message, claims completion. */
   completionMarker: "Goal Completed",
   /** Replacement marker when completion is blocked. */
@@ -59,6 +65,9 @@ function fromEnv(env) {
     GOAL_GUARD_MAX_SESSIONS: ["maxSessions", coerceInt],
     GOAL_GUARD_SESSION_TTL_MS: ["sessionTtlMs", coerceInt],
     GOAL_GUARD_TOAST_ON_BLOCK: ["toastOnBlock", coerceBool],
+    GOAL_GUARD_TOAST_ON_REVIEW: ["toastOnReview", coerceBool],
+    GOAL_GUARD_SIDEBAR_BANNER: ["sidebarBanner", coerceBool],
+    GOAL_GUARD_SIDEBAR_COLOR: ["sidebarColor", (v) => (v == null ? undefined : String(v))],
   };
   for (const [key, [field, coerce]] of Object.entries(map)) {
     if (env[key] !== undefined) out[field] = coerce(env[key], DEFAULT_CONFIG[field]);

package/plugins/goal-guard/events.js

@@ -29,6 +29,7 @@ export function markVerification(store, state) {
   state.lastVerificationAt = at;
   state.lastVerificationSeq = store.nextSeq();
   state.updatedAt = at;
+  return state.lastVerificationSeq;
 }
 
 export function markFileChanged(store, state, file) {
@@ -41,14 +42,16 @@ export function markFileChanged(store, state, file) {
 
 export function recordEvidence(store, state, command, result, criteria) {
   const at = store.nowIso();
-  state.evidence.push({
+  const entry = {
     command: String(command || ""),
     result: String(result || ""),
     criteria: Array.isArray(criteria) ? criteria.slice(0, 50) : [],
     at,
-  });
+    seq: 0,
+  };
+  state.evidence.push(entry);
   trim(state.evidence, 100);
-  markVerification(store, state);
+  entry.seq = markVerification(store, state);
   state.updatedAt = at;
 }
 

package/plugins/goal-guard/shell.js

@@ -415,7 +415,7 @@ const DIRECT_TEST_BINS = new Set(["jest", "mocha", "vitest", "ava", "tap", "tape
 const FORMATTERS = new Set(["prettier", "eslint", "black", "ruff", "gofmt", "goimports", "rustfmt", "clang-format", "autopep8", "isort", "standard", "biome", "dprint", "yapf", "stylelint"]);
 
 const MUTATING_BINS = new Set(["mkdir", "rmdir", "touch", "ln", "mv", "cp", "tee", "install", "patch", "rsync", "rename", "chmod", "chown", "chgrp", "git-apply"]);
-const DESTRUCTIVE_BINS = new Set(["shred", "mkfs", "fdisk", "parted", "wipefs", "sgdisk", "blkdiscard", "unlink"]);
+const DESTRUCTIVE_BINS = new Set(["shred", "srm", "mkfs", "mkswap", "fdisk", "parted", "wipefs", "sgdisk", "blkdiscard", "unlink"]);
 
 /**
  * Classify a single already-split simple command (array of words).
@@ -603,8 +603,9 @@ function classifyCommand(words, redirects, depth, acc, pipelineCmds, indexInPipe
     return;
   }
 
-  // Destructive disk/file utilities.
-  if (DESTRUCTIVE_BINS.has(bin)) {
+  // Destructive disk/file utilities. `mkfs.<fstype>` (mkfs.ext4, mkfs.erofs, …)
+  // is the same irreversible filesystem-format operation as bare `mkfs`.
+  if (DESTRUCTIVE_BINS.has(bin) || /^mkfs\./.test(bin)) {
     acc.destructive = true;
     acc.reasons.push(bin);
     return;

package/plugins/goal-guard/sidebar-data.js

@@ -0,0 +1,71 @@
+/**
+ * Read-only projection of persisted guard state for the TUI sidebar banner.
+ *
+ * The sidebar plugin runs in OpenCode's TUI process, separate from the server
+ * plugin that owns the live store. The two are paired through the same on-disk
+ * snapshot the server plugin already writes (persistence.js). This module reads
+ * that snapshot and projects the active session's goal into a compact banner
+ * model. It is pure and synchronous (a cheap file read), so it is unit-testable
+ * without a TUI runtime.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { stateBaseDir, projectKey } from "./persistence.js";
+import { DEFAULT_CONFIG } from "./config.js";
+import { sidebarView } from "./summary.js";
+
+/** Absolute path of the guard's state file for a given worktree. */
+export function sidebarStateFile(worktree, env = process.env) {
+  return join(stateBaseDir(env), `${projectKey(worktree)}.json`);
+}
+
+/** Defensive normalisation so a partial/legacy record never throws in projection. */
+function normalize(record) {
+  const st = record && typeof record === "object" ? record : {};
+  if (!Array.isArray(st.stickyGates)) st.stickyGates = [];
+  if (!Array.isArray(st.changedFiles)) st.changedFiles = [];
+  if (!st.latestVerdict || typeof st.latestVerdict !== "object") st.latestVerdict = {};
+  return st;
+}
+
+/**
+ * Choose which session's goal to show: the most-recently-touched ACTIVE session
+ * (optionally preferring an explicit sessionId when it is present and active).
+ */
+export function pickSession(snapshot, sessionId) {
+  if (!snapshot || !Array.isArray(snapshot.sessions)) return null;
+  const records = snapshot.sessions
+    .filter((e) => Array.isArray(e) && e.length === 2)
+    .map(([key, st]) => [key, normalize(st)]);
+  if (sessionId) {
+    const direct = records.find(([key, st]) => key === sessionId && st.active);
+    if (direct) return direct[1];
+  }
+  const active = records.filter(([, st]) => st.active);
+  if (active.length === 0) return null;
+  active.sort((a, b) => (b[1].touchedAt || 0) - (a[1].touchedAt || 0));
+  return active[0][1];
+}
+
+/**
+ * Build the sidebar banner model for a worktree, or null if there is nothing to
+ * show. Returns { goal, status, allowed, … } (see summary.sidebarView).
+ *
+ * @param {object} opts
+ * @param {string} opts.worktree   Project worktree root (same key the guard uses).
+ * @param {string} [opts.sessionId]
+ * @param {object} [opts.config]
+ * @param {Record<string,string|undefined>} [opts.env]
+ */
+export function readSidebarModel({ worktree, sessionId, config = DEFAULT_CONFIG, env = process.env } = {}) {
+  let snapshot;
+  try {
+    snapshot = JSON.parse(readFileSync(sidebarStateFile(worktree, env), "utf8"));
+  } catch {
+    return null; // no state yet, or unreadable — show nothing.
+  }
+  const record = pickSession(snapshot, sessionId);
+  if (!record) return null;
+  return sidebarView(record, config);
+}

package/plugins/goal-guard/state.js

@@ -36,6 +36,7 @@ export function createState(nowIso) {
     lastReviewAt: null,
     lastVerificationAt: null,
     verdicts: [],
+    reviewerMemory: [],
     evidence: [],
     latestVerdict: {},
     currentAgent: undefined,
@@ -59,7 +60,7 @@ function reviveState(raw) {
     if (raw[field] !== undefined) base[field] = raw[field];
   }
   // Defensive normalisation of array/object shapes.
-  for (const arrField of ["dirtyReasons", "changedFiles", "verdicts", "evidence", "completionRejections"]) {
+  for (const arrField of ["dirtyReasons", "changedFiles", "verdicts", "reviewerMemory", "evidence", "completionRejections"]) {
     if (!Array.isArray(base[arrField])) base[arrField] = [];
   }
   if (!base.latestVerdict || typeof base.latestVerdict !== "object") base.latestVerdict = {};

package/plugins/goal-guard/summary.js

@@ -3,7 +3,40 @@
  * messages, and the `goal_status` tool. Kept pure and dependency-light.
  */
 
-import { requiredGates, missingGates } from "./gates.js";
+import { requiredGates, missingGates, gatePassedFresh } from "./gates.js";
+
+/**
+ * A short, single-line human label for the current goal — preferring the
+ * recorded Goal Contract's original request, falling back to the captured goal
+ * text. Collapses whitespace and truncates to `max` chars for compact display
+ * (status reports, the TUI sidebar banner).
+ */
+export function shortGoalLabel(state, max = 80) {
+  const raw = String(state?.contract?.original || state?.goalText || "").replace(/\s+/g, " ").trim();
+  if (!raw) return "";
+  // Prefer the first sentence/clause if it is reasonably short.
+  const firstSentence = raw.split(/(?<=[.!?])\s/)[0];
+  const base = firstSentence.length > 0 && firstSentence.length <= max ? firstSentence : raw;
+  if (base.length <= max) return base;
+  return `${base.slice(0, max - 1).trimEnd()}…`;
+}
+
+/**
+ * Compact projection for the TUI sidebar banner: the short goal label, a
+ * one-line gate/dirty status, and whether completion is currently allowed.
+ * Returns null when there is no active goal worth showing.
+ */
+export function sidebarView(state, config) {
+  if (!state || !state.active) return null;
+  const goal = shortGoalLabel(state);
+  if (!goal) return null;
+  const required = requiredGates(state, config);
+  const missing = missingGates(state, config);
+  const passing = required.length - missing.length;
+  const allowed = required.length > 0 && missing.length === 0 && !state.dirty;
+  const status = `${passing}/${required.length} gates` + (state.dirty ? " · dirty" : "") + (allowed ? " · ready" : "");
+  return { goal, status, allowed, reviewCycles: state.reviewCycles, passing, required: required.length, dirty: Boolean(state.dirty) };
+}
 
 export function summarizeState(state, config) {
   const verdictSummary =
@@ -18,17 +51,39 @@ export function summarizeState(state, config) {
     `lastEditSeq=${state.lastEditSeq || 0}`,
     `lastReviewSeq=${state.lastReviewSeq || 0}`,
     `recentVerdicts=${verdictSummary}`,
+    `openReviewerMemory=${reviewerMemoryReport(state).open.length}`,
     `missingGates=${missingGates(state, config).join(" ") || "none"}`,
     `dirtyReasons=${state.dirtyReasons.slice(-5).join(" | ") || "none"}`,
   ].join("; ");
 }
 
+export function reviewerMemoryReport(state) {
+  const memory = Array.isArray(state.reviewerMemory) ? state.reviewerMemory : [];
+  const shape = (item) => ({
+    agent: item.agent,
+    finding: item.finding,
+    severity: item.severity || "blocking",
+    status: item.status || "open",
+    count: item.count || 1,
+    firstAt: item.firstAt || null,
+    lastAt: item.lastAt || null,
+    resolvedAt: item.resolvedAt || null,
+    fresh: Number(item.lastSeq || 0) > Number(state.lastEditSeq || 0),
+  });
+  return {
+    open: memory.filter((item) => (item.status || "open") === "open").slice(-20).map(shape),
+    resolved: memory.filter((item) => item.status === "resolved").slice(-20).map(shape),
+    total: memory.length,
+  };
+}
+
 /** Structured status object for the goal_status tool / diagnostics. */
 export function statusReport(state, config) {
   const required = requiredGates(state, config);
   const missing = missingGates(state, config);
   return {
     active: Boolean(state.active),
+    goal: shortGoalLabel(state),
     dirty: Boolean(state.dirty),
     reviewCycles: state.reviewCycles,
     requiredGates: required,
@@ -39,8 +94,91 @@ export function statusReport(state, config) {
     lastReviewAt: state.lastReviewAt,
     lastVerificationAt: state.lastVerificationAt,
     evidenceCount: state.evidence.length,
+    reviewerMemory: reviewerMemoryReport(state),
     changedFiles: state.changedFiles.slice(-50),
     contract: state.contract,
     completionAllowed: Boolean(state.active) && missing.length === 0,
   };
 }
+
+function evidenceMatchesCriterion(entry, criterion) {
+  const criteria = Array.isArray(entry.criteria) ? entry.criteria : [];
+  return criteria.some((c) => String(c).trim().toLowerCase() === String(criterion).trim().toLowerCase());
+}
+
+function evidenceFresh(entry, state) {
+  const lastEditSeq = Number(state.lastEditSeq || 0);
+  if (!entry.seq) return lastEditSeq === 0;
+  return Number(entry.seq) > lastEditSeq;
+}
+
+function criterionStatus(entries, state, missing) {
+  if (entries.length === 0) return "missing";
+  if (!entries.some((entry) => evidenceFresh(entry, state))) return "stale";
+  if (missing.length > 0 || state.dirty) return "partially covered";
+  return "covered";
+}
+
+/** Structured Requirement/Acceptance Criteria -> Evidence -> Reviewer -> Status map. */
+export function evidenceMapReport(state, config) {
+  const required = requiredGates(state, config);
+  const missing = missingGates(state, config);
+  const reviewers = required.map((agent) => {
+    const latest = state.latestVerdict[agent] || null;
+    return {
+      agent,
+      verdict: latest?.verdict || "missing",
+      at: latest?.at || null,
+      fresh: gatePassedFresh(state, agent),
+    };
+  });
+  const criteria = Array.isArray(state.contract?.acceptanceCriteria) ? state.contract.acceptanceCriteria : [];
+  const items = criteria.map((criterion) => {
+    const entries = state.evidence.filter((entry) => evidenceMatchesCriterion(entry, criterion));
+    const status = criterionStatus(entries, state, missing);
+    const memory = reviewerMemoryReport(state).open.filter((item) => item.finding.toLowerCase().includes(String(criterion).trim().toLowerCase()));
+    return {
+      criterion,
+      status,
+      evidence: entries.map((entry) => ({
+        command: entry.command,
+        result: entry.result,
+        at: entry.at,
+        seq: entry.seq || null,
+        fresh: evidenceFresh(entry, state),
+      })),
+      reviewers,
+      reviewerMemory: memory,
+      gap:
+        status === "missing"
+          ? "No recorded evidence references this acceptance criterion."
+          : status === "stale"
+            ? "Recorded evidence is older than the latest edit."
+            : missing.length > 0
+              ? `Missing or stale reviewer gates: ${missing.join(", ")}.`
+              : state.dirty
+                ? "Session is dirty; rerun reviews after the latest change."
+                : "None recorded.",
+      nextAction:
+        status === "covered"
+          ? "No action required for this criterion."
+          : status === "missing"
+            ? "Run verification and record it with goal_evidence, including this criterion."
+            : status === "stale"
+              ? "Rerun verification after the latest edit and record fresh evidence."
+              : "Complete missing/stale reviewer gates after verification.",
+    };
+  });
+  return {
+    active: Boolean(state.active),
+    dirty: Boolean(state.dirty),
+    lastEditAt: state.lastEditAt,
+    requiredGates: required,
+    missingGates: missing,
+    reviewers,
+    unmappedEvidence: state.evidence
+      .filter((entry) => !criteria.some((criterion) => evidenceMatchesCriterion(entry, criterion)))
+      .map((entry) => ({ command: entry.command, result: entry.result, criteria: entry.criteria || [], at: entry.at, seq: entry.seq || null })),
+    criteria: items,
+  };
+}