@event4u/agent-config 16.1.0 → 16.2.0

package/dist/cli-delegate/{chunk-QJWAUMJW.js → chunk-YJ72UIAK.js}

@@ -4,6 +4,7 @@ import {
 } from "./chunk-F7DQWYR5.js";
 import {
   has_stable_session_id,
+  owns_session_state,
   prune_legacy_state_file,
   prune_stale_session_states,
   session_state_file,
@@ -563,6 +564,472 @@ function validateAssumption(input, label = "assumption") {
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+
+// src/scripts/_lib/verification_command.ts
+var VERIFY_BINARIES = /* @__PURE__ */ new Set([
+  "vitest",
+  "jest",
+  "pytest",
+  "phpunit",
+  "pest",
+  "tsc",
+  "eslint",
+  "ruff",
+  "mypy",
+  "pyright",
+  "clippy",
+  "phpstan",
+  "psalm",
+  "ecs"
+]);
+var DELEGATING_HEADS = /* @__PURE__ */ new Set([
+  "npx",
+  "bunx",
+  "sudo",
+  "time",
+  "command"
+]);
+var PATH_PREFIXES = [
+  "./",
+  "vendor/bin/",
+  ".venv/bin/",
+  "node_modules/.bin/",
+  "bin/"
+];
+var VERIFY_WORD = /(^|[-_:])(test|tests|check|checks|lint|typecheck|tsc|qa|preflight|smoke|validate)([-_:]|$)/i;
+var NPM_SCRIPT_WORD = /(^|[-_:])(test|tests|check|checks|lint|typecheck|tsc|build)([-_:]|$)/i;
+function stripComment(command) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < command.length; i += 1) {
+    const ch = command[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (ch === "#" && !inSingle && !inDouble && (i === 0 || /\s/.test(command[i - 1] ?? ""))) {
+      return command.slice(0, i);
+    }
+  }
+  return command;
+}
+function splitSegments(command) {
+  const raw = [];
+  let buf = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < command.length; i += 1) {
+    const ch = command[i];
+    const two = command.slice(i, i + 2);
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      buf += ch;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      buf += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble) {
+      if (two === "&&" || two === "||") {
+        raw.push({ text: buf, sep: two });
+        buf = "";
+        i += 1;
+        continue;
+      }
+      if (ch === ";" || ch === "|") {
+        raw.push({ text: buf, sep: ch });
+        buf = "";
+        continue;
+      }
+    }
+    buf += ch;
+  }
+  raw.push({ text: buf, sep: null });
+  return raw.map((entry, idx) => {
+    const next = raw[idx + 1];
+    const nextWords = next ? words(next.text) : [];
+    return {
+      words: words(entry.text),
+      nextSep: entry.sep,
+      nextHead: (nextWords[0] ?? null)?.toLowerCase() ?? null
+    };
+  });
+}
+function words(text) {
+  const tokens = text.trim().split(/\s+/).filter((w) => w.length > 0);
+  let i = 0;
+  while (i < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[i])) i += 1;
+  return tokens.slice(i);
+}
+function bareName(word) {
+  let w = word;
+  for (const prefix of PATH_PREFIXES) {
+    if (w.startsWith(prefix)) {
+      w = w.slice(prefix.length);
+      break;
+    }
+  }
+  const slash = w.lastIndexOf("/");
+  return (slash >= 0 ? w.slice(slash + 1) : w).toLowerCase();
+}
+function failureIsDiscarded(seg) {
+  if (seg.nextSep === "||") return seg.nextHead === "true" || seg.nextHead === ":";
+  if (seg.nextSep === ";") return seg.nextHead === "true" || seg.nextHead === ":";
+  return false;
+}
+function segmentVerifies(rawWords) {
+  const w = rawWords.filter((x) => x.length > 0);
+  let idx = 0;
+  while (idx < w.length && DELEGATING_HEADS.has(bareName(w[idx]))) idx += 1;
+  if (idx >= w.length) return false;
+  const head = bareName(w[idx]);
+  const rest = w.slice(idx + 1).map((x) => x.toLowerCase());
+  const arg1 = rest[0] ?? "";
+  if (VERIFY_BINARIES.has(head)) return true;
+  switch (head) {
+    case "npm":
+    case "pnpm":
+    case "yarn":
+    case "bun": {
+      if (arg1 === "dlx" || arg1 === "exec") return segmentVerifies(rest.slice(1));
+      const script = arg1 === "run" ? rest[1] ?? "" : arg1;
+      return NPM_SCRIPT_WORD.test(script);
+    }
+    case "task":
+      return VERIFY_WORD.test(arg1) || /^ci([-_:]|$)/i.test(arg1);
+    case "cargo":
+      return arg1 === "test" || arg1 === "check" || arg1 === "clippy";
+    case "go":
+      return arg1 === "test" || arg1 === "vet";
+    case "make":
+      return VERIFY_WORD.test(arg1) || /^ci([-_:]|$)/i.test(arg1);
+    case "composer":
+      return VERIFY_WORD.test(arg1) || arg1 === "phpstan";
+    case "php":
+      return arg1 === "artisan" && (rest[1] ?? "") === "test";
+    case "artisan":
+      return arg1 === "test";
+    case "python":
+    case "python3":
+      return arg1 === "-m" && VERIFY_BINARIES.has(rest[1] ?? "");
+    case "node":
+    case "deno":
+      return rest.some((a) => a === "test" || a.startsWith("--test"));
+    case "scripts-run": {
+      const script = bareName(arg1);
+      return /^(check|lint|verify|validate)[-_]/.test(script);
+    }
+    default:
+      return false;
+  }
+}
+function isVerificationCommand(command) {
+  if (!command) return false;
+  const segments = splitSegments(stripComment(command));
+  return segments.some((seg) => !failureIsDiscarded(seg) && segmentVerifies(seg.words));
+}
+var _WIDE_CANDIDATE_RE = /\b(test|tests|vitest|jest|pytest|phpunit|pest|tsc|eslint|ruff|mypy|pyright|clippy|phpstan|typecheck|lint[-_:a-z]*|build|ci|preflight|smoke[-_:a-z]*|check[-_:a-z]*|validate[-_:a-z]*)\b|\b(task|npm|pnpm|yarn|composer|cargo|go|make|php artisan|bun)\s+(run\s+)?\S*(test|check|lint|build|ci|typecheck)/i;
+function mightBeVerification(command) {
+  return _WIDE_CANDIDATE_RE.test(command);
+}
+
+// src/scripts/_lib/verification_evidence.ts
+var INSTRUMENT_GAP_REASONS = /* @__PURE__ */ new Set([
+  "exit_code_unavailable",
+  "unreadable_record"
+]);
+function isInstrumentGap(verdict) {
+  return verdict.kind === "INVALID_RUN" && INSTRUMENT_GAP_REASONS.has(verdict.reason);
+}
+var NON_VERIFYING_EXECUTABLES = /* @__PURE__ */ new Set([
+  ":",
+  "awk",
+  "basename",
+  "cat",
+  "cd",
+  "chmod",
+  "cp",
+  "curl",
+  "cut",
+  "date",
+  "dirname",
+  "echo",
+  "exit",
+  "export",
+  "false",
+  "find",
+  "git",
+  "grep",
+  "head",
+  "less",
+  "ln",
+  "ls",
+  "mkdir",
+  "more",
+  "mv",
+  "open",
+  "printf",
+  "pwd",
+  "realpath",
+  "rg",
+  "rm",
+  "sed",
+  "sleep",
+  "sort",
+  "source",
+  "tail",
+  "tee",
+  "touch",
+  "tr",
+  "true",
+  "type",
+  "uniq",
+  "wc",
+  "wget",
+  "which",
+  "yes"
+]);
+var COMMAND_PREFIXES = /* @__PURE__ */ new Set([
+  "bunx",
+  "command",
+  "env",
+  "exec",
+  "nice",
+  "nohup",
+  "npx",
+  "sudo",
+  "time"
+]);
+function leadingExecutable(segment) {
+  for (const raw of segment.trim().split(/\s+/)) {
+    if (raw === "") continue;
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(raw)) continue;
+    const base = (raw.split("/").pop() ?? raw).replace(/\.exe$/i, "").toLowerCase();
+    if (base === "") continue;
+    if (COMMAND_PREFIXES.has(base)) continue;
+    return base;
+  }
+  return null;
+}
+function canVerify(command) {
+  for (const segment of command.split(/&&|\|\||[;|\n]/)) {
+    if (segment.trim() === "") continue;
+    const exe = leadingExecutable(segment);
+    if (exe !== null && NON_VERIFYING_EXECUTABLES.has(exe)) continue;
+    if (isVerificationCommand(segment)) return true;
+  }
+  return false;
+}
+var KILLED_EXIT_CODES = /* @__PURE__ */ new Set([137, 143]);
+var LOAD_FAILURE_PATTERNS = [
+  /\bfailed to load\b/i,
+  /\berror(?:s)? collecting\b/i,
+  /\bcollection error\b/i,
+  /\bcannot find module\b/i,
+  /\bmodule not found\b/i,
+  /\bunable to load\b/i,
+  /\btransform failed\b/i,
+  /\bconftest\.py\b.*\berror\b/i,
+  /\bcould not open input file\b/i,
+  /\bfatal error\b/i
+];
+function _num(m) {
+  return m?.[1] === void 0 ? 0 : Number(m[1]);
+}
+function parseVitestOrJest(text) {
+  const line = /^[ \t]*Tests:?[ \t]+(.+)$/m.exec(text);
+  if (line?.[1] === void 0) return null;
+  const body = line[1];
+  const failed = _num(/(\d+)\s+failed/i.exec(body));
+  const passed = _num(/(\d+)\s+passed/i.exec(body));
+  const totalMatch = /\((\d+)\)\s*$/.exec(body.trim()) ?? /(\d+)\s+total/i.exec(body);
+  const total = totalMatch?.[1] === void 0 ? null : Number(totalMatch[1]);
+  return { passed, failed, total };
+}
+function parsePytest(text) {
+  if (/\bno tests ran\b/i.test(text)) return { passed: 0, failed: 0, total: 0 };
+  const line = /^[= ]*((?:\d+\s+(?:passed|failed|error|errors|skipped|xfailed|xpassed|deselected)[,\s]*)+)(?:in\s+[\d.]+s)?[= ]*$/im.exec(
+    text
+  );
+  if (line?.[1] === void 0) return null;
+  const body = line[1];
+  const passed = _num(/(\d+)\s+passed/i.exec(body));
+  const failed = _num(/(\d+)\s+failed/i.exec(body)) + _num(/(\d+)\s+errors?\b/i.exec(body));
+  const skipped = _num(/(\d+)\s+skipped/i.exec(body));
+  return { passed, failed, total: passed + failed + skipped };
+}
+function parsePhpunit(text) {
+  if (/\bno tests executed\b/i.test(text)) return { passed: 0, failed: 0, total: 0 };
+  const ok = /\bOK\s*\((\d+)\s+tests?/i.exec(text);
+  if (ok?.[1] !== void 0) {
+    const n = Number(ok[1]);
+    return { passed: n, failed: 0, total: n };
+  }
+  const counted = /^[ \t]*Tests:\s*(\d+),\s*Assertions:\s*\d+(.*)$/m.exec(text);
+  if (counted?.[1] === void 0) return null;
+  const total = Number(counted[1]);
+  const rest = counted[2] ?? "";
+  const failed = _num(/Failures:\s*(\d+)/i.exec(rest)) + _num(/Errors:\s*(\d+)/i.exec(rest)) + _num(/Risky:\s*(\d+)/i.exec(rest));
+  return { passed: Math.max(total - failed, 0), failed, total };
+}
+function parseTap(text) {
+  const plan = /^1\.\.(\d+)\s*$/m.exec(text);
+  const okLines = text.match(/^ok\b/gim)?.length ?? 0;
+  const notOkLines = text.match(/^not ok\b/gim)?.length ?? 0;
+  const trailerFail = /^#\s*fail\s+(\d+)\s*$/im.exec(text);
+  if (plan?.[1] === void 0 && okLines === 0 && notOkLines === 0) return null;
+  const total = plan?.[1] === void 0 ? okLines + notOkLines : Number(plan[1]);
+  const failed = trailerFail?.[1] === void 0 ? notOkLines : Number(trailerFail[1]);
+  return { passed: okLines, failed, total };
+}
+function parseSummary(text) {
+  return parsePhpunit(text) ?? parseVitestOrJest(text) ?? parsePytest(text) ?? parseTap(text);
+}
+function output(record) {
+  return `${record.stdout_tail ?? ""}
+${record.stderr_tail ?? ""}`;
+}
+function classifyRun(record) {
+  if (typeof record !== "object" || record === null || Array.isArray(record)) {
+    return { kind: "INVALID_RUN", reason: "unreadable_record" };
+  }
+  const r = record;
+  if (typeof r.command !== "string" || r.command.trim() === "") {
+    return { kind: "INVALID_RUN", reason: "unreadable_record" };
+  }
+  if (!canVerify(r.command)) {
+    return { kind: "INVALID_RUN", reason: "not_a_verification_command" };
+  }
+  if (r.exit_code !== null && r.exit_code !== void 0 && (typeof r.exit_code !== "number" || !Number.isFinite(r.exit_code))) {
+    return { kind: "INVALID_RUN", reason: "unreadable_record" };
+  }
+  const text = output(r);
+  const summary = parseSummary(text);
+  if (r.interrupted === true || typeof r.exit_code === "number" && KILLED_EXIT_CODES.has(r.exit_code)) {
+    if (summary !== null && summary.failed > 0) return { kind: "FAIL_EVIDENCE" };
+    return { kind: "INVALID_RUN", reason: "timeout_or_killed" };
+  }
+  if (summary !== null && summary.failed > 0) return { kind: "FAIL_EVIDENCE" };
+  if (r.exit_code === null || r.exit_code === void 0) {
+    return { kind: "INVALID_RUN", reason: "exit_code_unavailable" };
+  }
+  if ((summary === null || summary.passed === 0) && LOAD_FAILURE_PATTERNS.some((re) => re.test(text))) {
+    return { kind: "INVALID_RUN", reason: "fixture_or_load_failure" };
+  }
+  if (summary !== null) {
+    if (summary.failed > 0) return { kind: "FAIL_EVIDENCE" };
+    if (summary.total === 0 || summary.total === null && summary.passed === 0) {
+      return { kind: "INVALID_RUN", reason: "zero_tests_discovered" };
+    }
+    if (summary.total !== null && summary.total > 0 && summary.passed === 0) {
+      return { kind: "INVALID_RUN", reason: "zero_tests_discovered" };
+    }
+    if (r.exit_code !== 0) {
+      return { kind: "INVALID_RUN", reason: "nonzero_exit_without_test_failure" };
+    }
+    return { kind: "PASS_EVIDENCE_OK" };
+  }
+  if (r.exit_code !== 0) {
+    return { kind: "INVALID_RUN", reason: "nonzero_exit_without_test_failure" };
+  }
+  return { kind: "PASS_EVIDENCE_OK" };
+}
+function runnerOf(command) {
+  for (const [name, re] of [
+    ["vitest", /\bvitest\b/i],
+    ["jest", /\bjest\b/i],
+    ["pytest", /\bpytest\b/i],
+    ["phpunit", /\bphpunit\b/i],
+    ["pest", /\bpest\b/i],
+    ["go", /\bgo\s+test\b/i],
+    ["cargo", /\bcargo\s+test\b/i]
+  ]) {
+    if (re.test(command)) return name;
+  }
+  return "other";
+}
+function placeRecord(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+  const v = raw["after_edits"];
+  if (typeof v !== "number" || !Number.isFinite(v)) return null;
+  return v;
+}
+function readRunEvidence(state) {
+  const reasons = [];
+  let passed = false;
+  let failed = false;
+  let gap = false;
+  for (const raw of state.runs) {
+    const placed = placeRecord(raw);
+    if (placed === null) {
+      gap = true;
+      reasons.push("unreadable_record");
+      continue;
+    }
+    if (placed < state.edits_this_turn) continue;
+    const verdict = classifyRun(raw);
+    if (verdict.kind === "PASS_EVIDENCE_OK") {
+      passed = true;
+      continue;
+    }
+    if (verdict.kind === "FAIL_EVIDENCE") {
+      failed = true;
+      continue;
+    }
+    reasons.push(verdict.reason);
+    if (isInstrumentGap(verdict)) gap = true;
+  }
+  return { passed, failed, instrumentGap: gap && !passed && !failed, reasons };
+}
+function testTargetKey(command) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const token of command.split(/\s+/)) {
+    const bare = token.replace(/^['"]|['"]$/g, "");
+    if (/[./]\w*(?:test|spec)\w*\.[a-z]+$/i.test(bare) || /(?:Test|Spec)\.php$/.test(bare)) {
+      targets.add(bare);
+    }
+  }
+  return [...targets].sort().join("|");
+}
+function hasRedThenGreen(state) {
+  let reddenedAnywhere = false;
+  const reddened = /* @__PURE__ */ new Set();
+  for (let i = 0; i < state.runs.length; i += 1) {
+    const raw = state.runs[i];
+    const verdict = classifyRun(raw);
+    const key = testTargetKey(
+      typeof raw === "object" && raw !== null && !Array.isArray(raw) ? String(raw["command"] ?? "") : ""
+    );
+    if (RED_VERDICTS(verdict)) {
+      reddened.add(key);
+      reddenedAnywhere = true;
+      continue;
+    }
+    if (verdict.kind !== "PASS_EVIDENCE_OK") continue;
+    const placed = placeRecord(raw);
+    if (placed === null || placed < state.edits_this_turn) continue;
+    if (key === "" ? reddenedAnywhere : reddened.has(key)) return true;
+  }
+  return false;
+}
+function RED_VERDICTS(verdict) {
+  if (verdict.kind === "FAIL_EVIDENCE") return true;
+  if (verdict.kind !== "INVALID_RUN") return false;
+  return verdict.reason === "fixture_or_load_failure" || verdict.reason === "nonzero_exit_without_test_failure" || verdict.reason === "zero_tests_discovered";
+}
+function describeRecordFinding(failed, reasons) {
+  const tail = " (verify-before-complete: no verification command run in this message \u2192 you cannot claim it passes)";
+  if (failed) {
+    return "this turn changed a file and its verification run FAILED \u2014 a recorded run after the last edit reports failing tests" + tail;
+  }
+  if (reasons.length === 0) {
+    return "this turn changed a file and no verification run was recorded after the last edit" + tail;
+  }
+  return `this turn changed a file and no recorded run after the last edit proves anything \u2014 the runs seen classify as ${[...new Set(reasons)].join(", ")}` + tail;
+}
+var NO_RED_EVIDENCE_REASON = "a completion claim over production code this turn changed, with a test file touched but `no_red_evidence` \u2014 no recorded run shows that test target failing and then passing after the last edit. A test never seen red has unknown sensitivity: run it against the unfixed code, watch it fail for the intended reason, then fix and re-run";
+
+// src/scripts/before_complete_hook.ts
 var STATE_FILE = path.join("agents", "state", "verify-before-complete.json");
 var STATE_DIR = path.join("agents", "state", "verify-before-complete");
 var STATE_RETENTION_DAYS = 7;
@@ -585,10 +1052,6 @@ var COMMAND_TOOLS = /* @__PURE__ */ new Set([
   "RunShellCommand"
   // Cursor
 ]);
-var _VERIFICATION_RE = new RegExp(
-  "(?:^|[\\s;&|`(])(task\\s+(?:ci|test|tests|lint|check|qa|phpstan|rector|ecs|pest|pytest)|(?:\\./|\\.venv/bin/|vendor/bin/)?(?:pest|phpunit|phpstan|psalm|rector|ecs)\\b|(?:python3?|\\.venv/bin/python3?)\\s+-m\\s+pytest|pytest\\b|(?:npm|pnpm|yarn|bun)\\s+(?:run\\s+)?(?:test|check|lint|typecheck|tsc)|cargo\\s+(?:test|check|clippy)|go\\s+test|make\\s+(?:test|check|lint)|composer\\s+(?:test|check|lint|phpstan)|(?:php\\s+)?artisan\\s+test)",
-  "i"
-);
 function _now() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "+00:00");
 }
@@ -612,6 +1075,11 @@ function _empty_state() {
     // has to survive it: the measured failure is a completion claim in a LATER
     // turn than the poll it rests on.
     ci_last: null,
+    // Round 8 — see `_reset_turn`. Present in the empty state so a freshly
+    // created file has the same shape as one that has seen a turn boundary;
+    // a reader must never have to distinguish "no runs yet" from "key absent".
+    verification_runs: [],
+    edits_this_turn: 0,
     checked_at: _now()
   };
 }
@@ -639,7 +1107,7 @@ function _extract_command(payload) {
   return [tool, null];
 }
 function _is_verification(command) {
-  return _VERIFICATION_RE.test(command) || isCiPoll(command);
+  return isVerificationCommand(command) || isCiPoll(command);
 }
 var _VACUOUS_PATTERNS = [
   // gh pr checks / gh run — no checks registered at all.
@@ -655,8 +1123,8 @@ var _VACUOUS_PATTERNS = [
   /\b0\s+files?\s+(?:checked|scanned|linted)\b/i,
   /\bnothing to check\b/i
 ];
-function isVacuousOutput(output) {
-  const text = output.trim();
+function isVacuousOutput(output2) {
+  const text = output2.trim();
   if (!text) {
     return false;
   }
@@ -667,19 +1135,19 @@ var _CI_POLL_RE = /\bgh\s+(?:pr\s+checks|run\s+(?:watch|list|view))\b/i;
 function isCiPoll(command) {
   return _CI_POLL_RE.test(command);
 }
-function pendingCount(output) {
-  const m = /(\d+)\s+(?:checks? )?pending\b/i.exec(output) ?? /\bpending[:=]\s*(\d+)/i.exec(output);
+function pendingCount(output2) {
+  const m = /(\d+)\s+(?:checks? )?pending\b/i.exec(output2) ?? /\bpending[:=]\s*(\d+)/i.exec(output2);
   if (m?.[1] !== void 0) {
     return Number(m[1]);
   }
-  const rows = output.match(/^\S.*\b(pending|in_progress|queued)\b/gim);
+  const rows = output2.match(/^\S.*\b(pending|in_progress|queued)\b/gim);
   if (rows) {
     return rows.length;
   }
-  if (/\bno checks reported\b/i.test(output)) {
+  if (/\bno checks reported\b/i.test(output2)) {
     return null;
   }
-  if (/^\S+\s+(pass|fail|skipping|successful|failing)\b/im.test(output)) {
+  if (/^\S+\s+(pass|fail|skipping|successful|failing)\b/im.test(output2)) {
     return 0;
   }
   return null;
@@ -696,11 +1164,101 @@ function _extract_output(payload) {
   }
   return null;
 }
+var EDIT_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit",
+  "str-replace-editor",
+  "save-file",
+  "str_replace_editor",
+  "create_file",
+  "write_to_file",
+  "replace_in_file",
+  "apply_diff",
+  "edit_file"
+]);
+var MAX_VERIFICATION_RUNS_PER_TURN = 24;
+var RUN_OUTPUT_TAIL_BYTES = 4096;
+function _cap_runs(runs) {
+  if (runs.length <= MAX_VERIFICATION_RUNS_PER_TURN) return runs;
+  const tail = runs.slice(-(MAX_VERIFICATION_RUNS_PER_TURN - 1));
+  const head = runs.find((r) => {
+    if (r === null || typeof r !== "object" || Array.isArray(r)) return false;
+    const rec = r;
+    const code = rec["exit_code"];
+    return typeof code === "number" && code !== 0;
+  });
+  if (head === void 0 || tail.includes(head)) {
+    return runs.slice(-MAX_VERIFICATION_RUNS_PER_TURN);
+  }
+  return [head, ...tail];
+}
+var _ERROR_EXIT_PREFIX = /^Error:\s*Exit code\s*(\d+)/i;
+var _NO_EXIT = { code: null, source: null, interrupted: false };
+function _numeric_exit_field(obj) {
+  for (const key of ["exit_code", "exitCode", "returncode", "returnCode", "status_code"]) {
+    const v = obj[key];
+    if (typeof v === "number" && Number.isFinite(v)) return Math.trunc(v);
+    if (typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v))) {
+      return Math.trunc(Number(v));
+    }
+  }
+  return null;
+}
+function _extract_exit_reading(payload) {
+  const direct = _numeric_exit_field(payload);
+  if (direct !== null) return { code: direct, source: "field", interrupted: false };
+  for (const key of ["tool_response", "toolResponse", "result", "output"]) {
+    const v = payload[key];
+    if (typeof v === "string") {
+      const m = _ERROR_EXIT_PREFIX.exec(v);
+      if (m?.[1] !== void 0) {
+        return { code: Number(m[1]), source: "error_prefix", interrupted: false };
+      }
+      continue;
+    }
+    if (v === null || typeof v !== "object" || Array.isArray(v)) continue;
+    const obj = v;
+    const nested = _numeric_exit_field(obj);
+    if (nested !== null) return { code: nested, source: "field", interrupted: false };
+    if (obj["interrupted"] === true) return { code: null, source: null, interrupted: true };
+    const hasStream = typeof obj["stdout"] === "string" || typeof obj["stderr"] === "string";
+    if (obj["interrupted"] === false && hasStream) {
+      return { code: 0, source: "response_shape", interrupted: false };
+    }
+  }
+  return _NO_EXIT;
+}
+function _extract_run_streams(payload) {
+  for (const key of ["tool_response", "toolResponse", "result", "output"]) {
+    const v = payload[key];
+    if (typeof v === "string") return { stdout: v, stderr: "" };
+    if (v === null || typeof v !== "object" || Array.isArray(v)) continue;
+    const obj = v;
+    const out = obj["stdout"] ?? obj["output"];
+    const err = obj["stderr"];
+    if (typeof out === "string" || typeof err === "string") {
+      return {
+        stdout: typeof out === "string" ? out : "",
+        stderr: typeof err === "string" ? err : ""
+      };
+    }
+  }
+  const topOut = payload["stdout"] ?? payload["output"];
+  const topErr = payload["stderr"];
+  return {
+    stdout: typeof topOut === "string" ? topOut : "",
+    stderr: typeof topErr === "string" ? topErr : ""
+  };
+}
 function _reset_turn(state, session_id) {
   state["session_id"] = session_id || state["session_id"] || "";
   state["turn_started_at"] = _now();
   state["verifications_this_turn"] = 0;
   state["verified_this_turn"] = false;
+  state["verification_runs"] = [];
+  state["edits_this_turn"] = 0;
   state["ci_saw_pending"] = false;
   state["nonevidence_this_turn"] = 0;
   return state;
@@ -732,12 +1290,15 @@ function _update(state, event, envelope) {
     state = _reset_turn(state, session_id);
   } else if (event === "post_tool_use") {
     const [tool, cmd] = _extract_command(pl);
+    if (tool !== null && EDIT_TOOLS.has(tool)) {
+      state["edits_this_turn"] = _asInt(state["edits_this_turn"]) + 1;
+    }
     if (cmd && _is_verification(cmd)) {
-      const output = _extract_output(pl);
-      const vacuous = output !== null && isVacuousOutput(output);
+      const output2 = _extract_output(pl);
+      const vacuous = output2 !== null && isVacuousOutput(output2);
       let counts = !vacuous;
       if (isCiPoll(cmd)) {
-        const pending = output === null ? null : pendingCount(output);
+        const pending = output2 === null ? null : pendingCount(output2);
         if (pending !== null && pending > 0) {
           state["ci_saw_pending"] = true;
           counts = false;
@@ -769,6 +1330,30 @@ function _update(state, event, envelope) {
         state["nonevidence_this_turn"] = _asInt(state["nonevidence_this_turn"]) + 1;
       }
     }
+    if (cmd && mightBeVerification(cmd)) {
+      const streams = _extract_run_streams(pl);
+      const exit = _extract_exit_reading(pl);
+      const runs = Array.isArray(state["verification_runs"]) ? [...state["verification_runs"]] : [];
+      runs.push({
+        command: cmd.slice(0, 512),
+        tool,
+        exit_code: exit.code,
+        // Provenance, not decoration: `response_shape` is a code this recorder
+        // DERIVED from the host's success form, and a reader disputing a verdict
+        // needs to know which of the three readings produced it.
+        exit_source: exit.source,
+        interrupted: exit.interrupted,
+        stdout_tail: streams.stdout.slice(-RUN_OUTPUT_TAIL_BYTES),
+        // Written, and previously not: `RunRecord.stderr_tail` was declared and
+        // read by the classifier's `output()` while nothing populated it, so
+        // stderr reached a parser only by accident inside a stringified blob.
+        stderr_tail: streams.stderr.slice(-RUN_OUTPUT_TAIL_BYTES),
+        runner: runnerOf(cmd),
+        after_edits: _asInt(state["edits_this_turn"]),
+        at: _now()
+      });
+      state["verification_runs"] = _cap_runs(runs);
+    }
   } else if (event === "stop") {
     state["last_stop_at"] = _now();
   }
@@ -859,6 +1444,23 @@ function main(argv) {
   const args = parse_args(argv ?? process.argv.slice(2));
   return run(_readStdin(), { consumer_root: process.cwd(), verbose: args.verbose });
 }
+function readTurnRunState(workspaceRoot, session_id) {
+  if (!has_stable_session_id(session_id)) return null;
+  try {
+    const raw = fs.readFileSync(path.join(workspaceRoot, statePathFor(session_id)), "utf-8");
+    const decoded = JSON.parse(raw);
+    if (!owns_session_state(decoded, session_id)) return null;
+    if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return null;
+    const state = decoded;
+    const runs = state["verification_runs"];
+    const edits = state["edits_this_turn"];
+    if (!Array.isArray(runs)) return null;
+    if (typeof edits !== "number" || !Number.isFinite(edits) || edits < 1) return null;
+    return { runs, edits_this_turn: edits };
+  } catch {
+    return null;
+  }
+}
 function _isCliEntry() {
   if (true) {
     return false;
@@ -1009,6 +1611,79 @@ function readInstallBoundary() {
     return { version: null, installed_at: null };
   }
 }
+var SHADOW_LAYERS = ["stop_hook_active", "refused_turn"];
+function emptyRetryCounts() {
+  const out = {};
+  for (const l of SHADOW_LAYERS) out[l] = 0;
+  return out;
+}
+var SHADOW_MAX_ROWS = 200;
+var SHADOW_SUFFIX = ".shadow.json";
+function sessionShadowFile(workspaceRoot, sessionKey) {
+  return path2.join(refusalStateDir(workspaceRoot), `${sessionKey}${SHADOW_SUFFIX}`);
+}
+function parseShadowRecord(raw) {
+  let decoded;
+  try {
+    decoded = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return null;
+  const o = decoded;
+  const rowsRaw = o["would_refuse_again"];
+  if (!Array.isArray(rowsRaw)) return null;
+  const rows = [];
+  for (const r of rowsRaw) {
+    if (typeof r !== "object" || r === null || Array.isArray(r)) continue;
+    const ro = r;
+    const det = ro["detector"];
+    const turn = ro["turn"];
+    const at = ro["at"];
+    const layer = ro["layer"];
+    if (!isDetector(det)) continue;
+    if (typeof turn !== "number" || !Number.isFinite(turn)) continue;
+    if (typeof at !== "string") continue;
+    if (layer !== "stop_hook_active" && layer !== "refused_turn") continue;
+    rows.push({ detector: det, turn, at, layer });
+  }
+  const num = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
+  const observed = o["retries_observed"];
+  const byLayer = emptyRetryCounts();
+  if (typeof observed === "object" && observed !== null && !Array.isArray(observed)) {
+    for (const l of SHADOW_LAYERS) {
+      byLayer[l] = num(observed[l]);
+    }
+  }
+  return {
+    would_refuse_again: rows,
+    retries_observed: byLayer,
+    dropped: num(o["dropped"]),
+    first_at: typeof o["first_at"] === "string" ? o["first_at"] : "",
+    last_at: typeof o["last_at"] === "string" ? o["last_at"] : ""
+  };
+}
+function foldShadow(prev, input) {
+  const rows = [...prev?.would_refuse_again ?? []];
+  for (const d of input.detectors) {
+    rows.push({ detector: d, turn: input.turnOrdinal, at: input.at, layer: input.layer });
+  }
+  let dropped = prev?.dropped ?? 0;
+  if (rows.length > SHADOW_MAX_ROWS) {
+    dropped += rows.length - SHADOW_MAX_ROWS;
+    rows.splice(0, rows.length - SHADOW_MAX_ROWS);
+  }
+  const retries = emptyRetryCounts();
+  for (const l of SHADOW_LAYERS) retries[l] = prev?.retries_observed[l] ?? 0;
+  retries[input.layer] += 1;
+  return {
+    would_refuse_again: rows,
+    retries_observed: retries,
+    dropped,
+    first_at: prev?.first_at !== void 0 && prev.first_at !== "" ? prev.first_at : input.at,
+    last_at: input.at
+  };
+}
 var REFUSAL_STATE_MAX_AGE_DAYS = 90;
 function pruneAgedRefusalState(workspaceRoot, opts = {}) {
   const maxAgeDays = opts.maxAgeDays ?? REFUSAL_STATE_MAX_AGE_DAYS;
@@ -1026,6 +1701,37 @@ function pruneAgedRefusalState(workspaceRoot, opts = {}) {
     if (!name.endsWith(".json")) continue;
     result.scanned += 1;
     const file = path2.join(dir, name);
+    if (name.endsWith(SHADOW_SUFFIX)) {
+      let shadow = null;
+      try {
+        shadow = parseShadowRecord(fs2.readFileSync(file, "utf-8"));
+      } catch {
+        shadow = null;
+      }
+      const shadowAt = shadow === null ? NaN : Date.parse(shadow.last_at);
+      if (!Number.isFinite(shadowAt)) {
+        let mtime = NaN;
+        try {
+          mtime = fs2.statSync(file).mtimeMs;
+        } catch {
+          mtime = NaN;
+        }
+        if (!Number.isFinite(mtime) || mtime >= cutoffMs) {
+          result.kept += 1;
+          continue;
+        }
+      } else if (shadowAt >= cutoffMs) {
+        result.kept += 1;
+        continue;
+      }
+      try {
+        fs2.unlinkSync(file);
+        result.pruned += 1;
+      } catch {
+        result.kept += 1;
+      }
+      continue;
+    }
     let rec = null;
     try {
       rec = parseRecord(fs2.readFileSync(file, "utf-8"));
@@ -1052,10 +1758,16 @@ function pruneAgedRefusalState(workspaceRoot, opts = {}) {
 }
 
 export {
+  isVerificationCommand,
+  readRunEvidence,
+  hasRedThenGreen,
+  describeRecordFinding,
+  NO_RED_EVIDENCE_REASON,
   statePathFor,
   isVacuousOutput,
   isCiPoll,
   pendingCount,
+  readTurnRunState,
   CAPSULE_SCHEMA_VERSION,
   scanEnvelopeDirectives,
   wrapAsPriorSessionData,
@@ -1068,5 +1780,8 @@ export {
   parseRecord,
   foldRefusal,
   readInstallBoundary,
+  sessionShadowFile,
+  parseShadowRecord,
+  foldShadow,
   pruneAgedRefusalState
 };