@event4u/agent-config 15.0.0 → 16.1.0

package/dist/cli-delegate/cmd_conformance.js

@@ -10,11 +10,13 @@ import {
   sessionRefusalFile,
   statePathFor,
   validateAssumption
-} from "./chunk-TYSY33MD.js";
+} from "./chunk-QJWAUMJW.js";
 import {
   readHookStdin
 } from "./chunk-F7DQWYR5.js";
 import {
+  DeadScopeError,
+  assertScanned,
   reportScanned
 } from "./chunk-I3EIN2YG.js";
 import {
@@ -34,14 +36,15 @@ import {
   frontmatterPaths,
   proseEqual,
   splitFrontmatter
-} from "./chunk-55ACLDUE.js";
+} from "./chunk-GJCBB2UG.js";
 import "./chunk-FTAISGDQ.js";
 import "./chunk-M2DPGFZ4.js";
+import "./chunk-ROYYTEZU.js";
 import "./chunk-BTWUYDGN.js";
 import {
   projectStoreSlug,
   resolveSessionRole
-} from "./chunk-GYC3VRYN.js";
+} from "./chunk-FXYUYU4N.js";
 import {
   atomic_write_json,
   atomic_write_text,
@@ -52,18 +55,26 @@ import {
   prune_stale_session_states,
   session_state_file
 } from "./chunk-E4XIZDIB.js";
+import {
+  artefact_roots
+} from "./chunk-NUHLI2RX.js";
+import {
+  readRecentEntries
+} from "./chunk-5R7HOLAF.js";
 import {
   detectToolPresence
 } from "./chunk-A4QJ6ENT.js";
 import {
   atomicAppendLine,
+  probeHostCapabilities
+} from "./chunk-6KM6ORRY.js";
+import "./chunk-T7L2QK3K.js";
+import "./chunk-DMSZHXZS.js";
+import {
   manifest_path,
-  probeHostCapabilities,
   read_manifest
-} from "./chunk-2TAQ2K4V.js";
+} from "./chunk-4E2W63DA.js";
 import "./chunk-MWRD5YOH.js";
-import "./chunk-T7L2QK3K.js";
-import "./chunk-DMSZHXZS.js";
 import {
   require_dist
 } from "./chunk-OY53J6II.js";
@@ -72,7 +83,7 @@ import {
 } from "./chunk-MCJYCQPF.js";
 import {
   load_agent_settings
-} from "./chunk-2XY7ILBT.js";
+} from "./chunk-FC75PGJE.js";
 import "./chunk-NDJLNC6Q.js";
 import {
   __toESM
@@ -80,45 +91,12 @@ import {
 
 // src/scripts/_cli/cmd_conformance.ts
 var YAML = __toESM(require_dist(), 1);
-import * as fs13 from "node:fs";
+import * as fs15 from "node:fs";
 import * as os7 from "node:os";
-import * as path13 from "node:path";
+import * as path15 from "node:path";
 import process5 from "node:process";
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL13 } from "node:url";
-
-// src/install/txlog.ts
-import { createReadStream, createWriteStream, existsSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
-var ROTATION_MAX_BYTES = 10 * 1024 * 1024;
-var ROTATION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
-var RECOVERY_DEPTH_CAP = 500;
-function readRecentEntries(logPath) {
-  if (!existsSync(logPath)) {
-    return [];
-  }
-  const raw = readFileSync(logPath, "utf8");
-  const lines = raw.split("\n").filter((l) => l.length > 0);
-  const tail = lines.slice(-RECOVERY_DEPTH_CAP);
-  const out = [];
-  for (const line of tail) {
-    const parsed = tryParseEntry(line);
-    if (parsed !== null) {
-      out.push(parsed);
-    }
-  }
-  return out;
-}
-function tryParseEntry(line) {
-  try {
-    const obj = JSON.parse(line);
-    if (typeof obj.ts !== "string" || typeof obj.kind !== "string" || typeof obj.path !== "string") {
-      return null;
-    }
-    return obj;
-  } catch {
-    return null;
-  }
-}
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { fileURLToPath as fileURLToPath14, pathToFileURL as pathToFileURL14 } from "node:url";
 
 // src/scripts/router_target_paths.mjs
 var ROUTE_TARGET_TEMPLATES = Object.freeze({
@@ -131,10 +109,10 @@ var ROUTE_TARGET_TEMPLATES = Object.freeze({
   ])
 });
 function parseRouteTarget(target) {
-  const sep = target.indexOf(":");
-  if (sep <= 0) return null;
-  const kind = target.slice(0, sep);
-  const id = target.slice(sep + 1);
+  const sep2 = target.indexOf(":");
+  if (sep2 <= 0) return null;
+  const kind = target.slice(0, sep2);
+  const id = target.slice(sep2 + 1);
   if (!id) return null;
   if (!Object.prototype.hasOwnProperty.call(ROUTE_TARGET_TEMPLATES, kind)) return null;
   return { kind, id };
@@ -146,18 +124,18 @@ function routeTargetPathsPosix(target) {
 }
 
 // src/scripts/report_conformance_funnel.ts
-import * as fs12 from "node:fs";
+import * as fs14 from "node:fs";
 import * as os6 from "node:os";
-import * as path12 from "node:path";
+import * as path14 from "node:path";
 import process4 from "node:process";
-import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
+import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL13 } from "node:url";
 
 // src/scripts/conformance_scan.ts
 import { createHash as createHash3 } from "node:crypto";
-import fs8 from "node:fs";
+import fs10 from "node:fs";
 import os2 from "node:os";
-import path8 from "node:path";
-import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
+import path10 from "node:path";
+import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
 
 // src/scripts/_lib/transcript_entry.ts
 function _isObject(v) {
@@ -1940,17 +1918,464 @@ var COMMAND_OBJECTS = {
 };
 
 // src/scripts/hooks/turn_end_gate_hook.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
-import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
+import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL6 } from "node:url";
 
-// src/scripts/hooks/end_review_nudge_hook.ts
-import { spawnSync } from "node:child_process";
-import * as crypto from "node:crypto";
+// src/scripts/check_reply_consistency.ts
 import * as fs3 from "node:fs";
-import * as os from "node:os";
 import * as path3 from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "node:url";
+var _HERE = fileURLToPath3(import.meta.url);
+var ROOT = path3.resolve(path3.dirname(_HERE), "..", "..");
+var QUIET = process.argv.slice(2).includes("--quiet");
+var OPTION_LINE_RE = /^\s*>?\s*(\d+)\.\s+\S/;
+var REC_LINE_RE = /(?:Recommendation|Empfehlung)\s*:\s*(\d+)\b/i;
+var TAG_RE = /\((?:recommended|rec|empfohlen)\)/i;
+var CODESPAN_RE = /`[^`\n]*`/g;
+var HEADING_RE = /^#{1,6}\s/;
+var FENCE_RE = /^\s*(```|~~~)/;
+var REC_ADJACENCY_WINDOW = 2;
+function _strip_codespans(line) {
+  return line.replace(CODESPAN_RE, "``");
+}
+function splitAndMask(text) {
+  return mask_fences(_splitlines(text));
+}
+function _splitlines(text) {
+  if (text === "") return [];
+  const parts = text.split(/\r\n|\r|\n/);
+  if (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+function mask_fences(lines) {
+  const out = [];
+  let fence = null;
+  for (const raw of lines) {
+    const m = FENCE_RE.exec(raw);
+    if (m) {
+      const marker = m[1];
+      if (fence === null) {
+        fence = marker;
+      } else if (fence === marker) {
+        fence = null;
+      }
+      out.push("");
+      continue;
+    }
+    out.push(fence === null ? raw : "");
+  }
+  return out;
+}
+function find_option_blocks(text) {
+  const lines = mask_fences(_splitlines(text));
+  const blocks = [];
+  let current = null;
+  for (let idx = 0; idx < lines.length; idx++) {
+    const m = OPTION_LINE_RE.exec(lines[idx]);
+    if (m) {
+      const num = parseInt(m[1], 10);
+      if (current === null) {
+        current = { startLine: idx + 1, endLine: idx + 1, numbers: [num] };
+      } else {
+        current.endLine = idx + 1;
+        current.numbers.push(num);
+      }
+    } else {
+      if (current !== null && current.numbers.length >= 2) {
+        blocks.push(current);
+      }
+      current = null;
+    }
+  }
+  if (current !== null && current.numbers.length >= 2) {
+    blocks.push(current);
+  }
+  return blocks;
+}
+function recommendationsUnder(text, block, maskedLines) {
+  const lines = maskedLines ?? mask_fences(_splitlines(text));
+  const recs = [];
+  let inspected = 0;
+  for (let idx = block.endLine; idx < lines.length && inspected < REC_ADJACENCY_WINDOW; idx++) {
+    const line = lines[idx];
+    if (line.trim() === "") {
+      continue;
+    }
+    if (HEADING_RE.test(line) || OPTION_LINE_RE.test(line)) {
+      break;
+    }
+    inspected += 1;
+    const m = REC_LINE_RE.exec(line);
+    if (m) {
+      recs.push({ line: idx + 1, num: parseInt(m[1], 10) });
+    }
+  }
+  return recs;
+}
+function check_reply(text) {
+  const rawLines = _splitlines(text);
+  const lines = mask_fences(rawLines);
+  const findings = [];
+  for (let idx = 0; idx < lines.length; idx++) {
+    const stripped = _strip_codespans(lines[idx]);
+    if (OPTION_LINE_RE.test(stripped) && TAG_RE.test(stripped)) {
+      findings.push({
+        line: idx + 1,
+        message: `inline tag on numbered option \u2014 ${rawLines[idx].trim()}`
+      });
+    }
+  }
+  const blocks = find_option_blocks(text);
+  for (const block of blocks) {
+    const recs = recommendationsUnder(text, block);
+    if (recs.length === 0) {
+      findings.push({
+        line: block.startLine,
+        message: "numbered options block without a Recommendation:/Empfehlung: line directly under it"
+      });
+      continue;
+    }
+    if (recs.length > 1) {
+      findings.push({
+        line: recs[1].line,
+        message: `multiple recommendation lines under one options block: [${recs.map((r) => r.num).join(", ")}]`
+      });
+      continue;
+    }
+    const rec = recs[0];
+    if (!block.numbers.includes(rec.num)) {
+      findings.push({
+        line: rec.line,
+        message: `recommendation ${String(rec.num)} not present in the options block above it (options: [${block.numbers.join(", ")}])`
+      });
+    }
+  }
+  findings.sort((a, b) => a.line - b.line);
+  return findings;
+}
+function _isDir(p) {
+  try {
+    return fs3.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _rglobMdSorted(dir) {
+  const out = [];
+  const walk = (current) => {
+    let entries;
+    try {
+      entries = fs3.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path3.join(current, ent.name);
+      if (ent.isDirectory() || ent.isSymbolicLink() && _isDir(full)) {
+        walk(full);
+      } else if (ent.name.endsWith(".md")) {
+        out.push(full);
+      }
+    }
+  };
+  walk(dir);
+  out.sort();
+  return out;
+}
+function _relToPosixOrAbs(child, root) {
+  const rel = path3.relative(root, child);
+  if (rel === "" || rel.startsWith("..") || path3.isAbsolute(rel)) {
+    return child.split(path3.sep).join("/");
+  }
+  return rel.split(path3.sep).join("/");
+}
+function cmd_scan_dir(root) {
+  let roots;
+  if (!_isDir(root)) {
+    const legacy = path3.join(ROOT, ".agent-src.uncondensed");
+    if (path3.resolve(root) === path3.resolve(legacy)) {
+      roots = artefact_roots();
+      if (roots.length === 0) {
+        process.stderr.write("error: no artefact roots found (legacy or packages/*)\n");
+        return 1;
+      }
+    } else {
+      process.stderr.write(`error: not a directory: ${root}
+`);
+      return 1;
+    }
+  } else {
+    roots = [root];
+  }
+  const violations = [];
+  let scanned = 0;
+  for (const r of roots) {
+    for (const md of _rglobMdSorted(r)) {
+      scanned += 1;
+      const text = fs3.readFileSync(md, "utf-8");
+      const lines = _splitlines(text);
+      for (let idx = 0; idx < lines.length; idx++) {
+        const raw = lines[idx];
+        const stripped = _strip_codespans(raw);
+        if (OPTION_LINE_RE.test(stripped) && TAG_RE.test(stripped)) {
+          violations.push([md, idx + 1, raw.trim()]);
+        }
+      }
+    }
+  }
+  try {
+    assertScanned({
+      gate: "check_reply_consistency",
+      scanned,
+      units: "markdown file(s)",
+      roots: roots.map((r) => _relToPosixOrAbs(r, ROOT))
+    });
+  } catch (exc) {
+    if (exc instanceof DeadScopeError) {
+      process.stderr.write(`\u274C  ${exc.message}
+`);
+      return 1;
+    }
+    throw exc;
+  }
+  if (violations.length > 0) {
+    for (const [p, line, snippet] of violations) {
+      process.stderr.write(`  \u{1F534} ${p}:${String(line)} \u2014 inline-tag \u2014 ${snippet}
+`);
+    }
+    process.stderr.write(`
+\u274C  ${String(violations.length)} legacy-pattern violation(s)
+`);
+    return 2;
+  }
+  if (!QUIET) {
+    const scanned2 = roots.map((r) => _relToPosixOrAbs(r, ROOT)).join(", ");
+    process.stdout.write(`\u2705  No legacy (recommended) tags found under ${scanned2}
+`);
+  }
+  return 0;
+}
+var USAGE = "usage: check_reply_consistency [-h] (--stdin | --file FILE | --scan-dir SCAN_DIR)\n                              [-v] [--quiet]\n";
+function _usage_error(message) {
+  process.stderr.write(USAGE);
+  process.stderr.write(`check_reply_consistency: error: ${message}
+`);
+  process.exit(1);
+}
+function _readStdin() {
+  try {
+    return fs3.readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function parse_args(argv) {
+  let stdin = false;
+  let file = null;
+  let scan_dir = null;
+  let verbose = false;
+  const groupSeen = [];
+  const need = (i, name) => {
+    const v = argv[i];
+    if (v === void 0) {
+      _usage_error(`argument ${name}: expected one argument`);
+    }
+    return v;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--stdin") {
+      stdin = true;
+      groupSeen.push("--stdin");
+    } else if (arg === "--file") {
+      file = need(++i, "--file");
+      groupSeen.push("--file");
+    } else if (arg.startsWith("--file=")) {
+      file = arg.slice("--file=".length);
+      groupSeen.push("--file");
+    } else if (arg === "--scan-dir") {
+      scan_dir = need(++i, "--scan-dir");
+      groupSeen.push("--scan-dir");
+    } else if (arg.startsWith("--scan-dir=")) {
+      scan_dir = arg.slice("--scan-dir=".length);
+      groupSeen.push("--scan-dir");
+    } else if (arg === "-v" || arg === "--verbose") {
+      verbose = true;
+    } else if (arg === "--quiet") {
+    } else if (arg === "-h" || arg === "--help") {
+      process.stdout.write(USAGE);
+      process.exit(0);
+    } else {
+      _usage_error(`unrecognized arguments: ${arg}`);
+    }
+  }
+  if (groupSeen.length === 0) {
+    _usage_error("one of the arguments --stdin --file --scan-dir is required");
+  }
+  if (groupSeen.length > 1) {
+    _usage_error(`argument ${groupSeen[1]}: not allowed with argument ${groupSeen[0]}`);
+  }
+  return { stdin, file, scan_dir, verbose };
+}
+function main3(argv = process.argv.slice(2)) {
+  const args = parse_args(argv);
+  if (args.scan_dir !== null) {
+    return cmd_scan_dir(args.scan_dir);
+  }
+  let text;
+  try {
+    text = args.stdin ? _readStdin() : fs3.readFileSync(args.file, "utf-8");
+  } catch (e) {
+    process.stderr.write(`error: ${String(e)}
+`);
+    return 1;
+  }
+  const findings = check_reply(text);
+  if (findings.length === 0) {
+    if (args.verbose && !QUIET) {
+      process.stdout.write("\u2705  reply consistent (every options block carries one adjacent recommendation)\n");
+    }
+    return 0;
+  }
+  for (const f of findings) {
+    process.stderr.write(`\u274C  line ${String(f.line)}: ${f.message}
+`);
+  }
+  return 2;
+}
+function _isCliEntry3() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL3(path3.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs3.realpathSync(fileURLToPath3(import.meta.url));
+    const argv = fs3.realpathSync(path3.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+var _IN_BUNDLE = true;
+if (!_IN_BUNDLE && (_isCliEntry3() || process.argv[1] === _HERE)) {
+  process.exit(main3());
+}
+
+// src/scripts/_lib/dropped_decision.ts
+function detectDroppedDecision(assistantTurnTexts, closingFromPayload = false) {
+  if (assistantTurnTexts.length < 2) return null;
+  const asksIn = (text) => {
+    const blocks = find_option_blocks(text);
+    if (blocks.length === 0) return blocks;
+    const masked = splitAndMask(text);
+    return blocks.filter((b) => recommendationsUnder(text, b, masked).length > 0);
+  };
+  const closing = assistantTurnTexts[assistantTurnTexts.length - 1];
+  if (asksIn(closing).length > 0) return null;
+  for (let i = assistantTurnTexts.length - 2; i >= 0; i -= 1) {
+    const earlier = assistantTurnTexts[i];
+    const blocks = asksIn(earlier);
+    if (blocks.length === 0) continue;
+    const block = blocks[blocks.length - 1];
+    return {
+      detector: "pending-decision",
+      // The option NUMBERS and the line span, never the option text: the
+      // evidence is quoted into a refusal that reaches the transcript, and
+      // an options block can carry anything the reply carried.
+      evidence: `options ${block.numbers.join("/")} at lines ${block.startLine}-${block.endLine} of an earlier reply this turn (closing reply read from ${closingFromPayload ? "the stop payload" : "the transcript"})`,
+      reason: "an earlier reply in THIS turn put numbered options to the user and no user answer followed \u2014 this closing reply carries no options block, so the decision disappeared without being answered, cancelled or superseded. A hook nudge, a reviewer result or a task notification may ADD to a turn; it may not displace a question already asked (user-interaction Iron Law 3: a decision handed to the user outlives the turn). Re-present the block and its recommendation line at the end of this reply"
+    };
+  }
+  return null;
+}
+
+// src/scripts/hooks/end_review_nudge_hook.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import * as crypto from "node:crypto";
+import * as fs5 from "node:fs";
+import * as os from "node:os";
+import * as path5 from "node:path";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL4 } from "node:url";
+
+// src/scripts/_lib/review_baseline.ts
+import { spawnSync } from "node:child_process";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+function currentHeadSha(cwd) {
+  try {
+    const r = spawnSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" });
+    if (r.status !== 0) return null;
+    const out = (r.stdout ?? "").trim();
+    return out === "" ? null : out;
+  } catch {
+    return null;
+  }
+}
+var BASELINE_STATE_REL = path4.join("agents", "runtime", "state", "review-baseline");
+function baselineStateDir(workspaceRoot) {
+  return path4.join(workspaceRoot, BASELINE_STATE_REL);
+}
+function baselineStateFile(workspaceRoot, sessionKey) {
+  return path4.join(baselineStateDir(workspaceRoot), `${sessionKey}.json`);
+}
+function parseBaseline(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 lines = o["baseline_lines"];
+  if (typeof lines !== "number" || !Number.isFinite(lines) || lines < 0) return null;
+  const written = o["written_at"];
+  if (typeof written !== "string") return null;
+  const head = o["head_sha"];
+  const measure = o["measure"];
+  return {
+    head_sha: typeof head === "string" && head !== "" ? head : null,
+    baseline_lines: lines,
+    ...measure === "exact" || measure === "capped_approximation" ? { measure } : {},
+    written_at: written
+  };
+}
+function readBaseline(workspaceRoot, sessionKey) {
+  const file = baselineStateFile(workspaceRoot, sessionKey);
+  let raw;
+  try {
+    raw = fs4.readFileSync(file, "utf-8");
+  } catch (exc) {
+    const code = exc?.code;
+    return code === "ENOENT" ? "absent" : "unreadable";
+  }
+  return parseBaseline(raw) ?? "unreadable";
+}
+function applyBaseline(measuredLines, baseline, headSha, measuredMeasure = "exact") {
+  if (baseline === "absent" || baseline === "unreadable") {
+    return { applied: false, fallback: baseline, lines: measuredLines };
+  }
+  if (baseline.measure !== "exact" || measuredMeasure !== "exact") {
+    return { applied: false, fallback: "mixed-measure", lines: measuredLines };
+  }
+  if (baseline.head_sha !== headSha()) {
+    return { applied: false, fallback: "head-moved", lines: measuredLines };
+  }
+  return {
+    applied: true,
+    baseline,
+    lines: Math.max(0, measuredLines - baseline.baseline_lines)
+  };
+}
 
 // src/scripts/_lib/audit_field_provenance.ts
 var MAX_APPLIED_IDS = 32;
@@ -1966,6 +2391,13 @@ function appliedIds(values) {
 }
 
 // src/scripts/_lib/review_skipped_record.ts
+var BASELINE_APPLICATIONS = [
+  "applied",
+  "absent",
+  "unreadable",
+  "head_moved",
+  "mixed_measure"
+];
 var PRODUCER_PRIVACY_CLASS = "ids-only";
 function isNonNegInt(n) {
   return typeof n === "number" && Number.isFinite(n) && Number.isInteger(n) && n >= 0;
@@ -1981,6 +2413,9 @@ function buildReviewSkippedLine(input) {
   }
   if (!input.ts) errors.push("ts (ISO-8601 UTC) is required");
   if (!input.id) errors.push("id (ULID, UUID, or content hash) is required");
+  if (input.baseline !== void 0 && !BASELINE_APPLICATIONS.includes(input.baseline)) {
+    errors.push(`baseline must be one of ${BASELINE_APPLICATIONS.join(", ")}`);
+  }
   if (errors.length) return { line: null, errors };
   const line = {
     schema_version: 1,
@@ -2007,7 +2442,14 @@ function buildReviewSkippedLine(input) {
     persona: null,
     input_kind: "prompt",
     type: "note",
-    review_skipped: { diff_lines: input.diff_lines, mutation_measure: input.mutation_measure }
+    review_skipped: {
+      diff_lines: input.diff_lines,
+      mutation_measure: input.mutation_measure,
+      // Omitted, not defaulted, when the producer recorded nothing —
+      // audit-log-v1's absent-versus-present split is the same one
+      // `skills_applied` uses above, for the same reason.
+      ...input.baseline === void 0 ? {} : { baseline: input.baseline }
+    }
   };
   return { line, errors: [] };
 }
@@ -2075,13 +2517,13 @@ function isSafeTranscriptPath(rawPath, opts = {}) {
   const homeDir = opts.homeDir ?? os.homedir();
   const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
   try {
-    const realHome = fs3.realpathSync(homeDir);
-    const realPath = fs3.realpathSync(rawPath);
-    const relative2 = path3.relative(realHome, realPath);
-    if (relative2 === "" || relative2.startsWith("..") || path3.isAbsolute(relative2)) {
+    const realHome = fs5.realpathSync(homeDir);
+    const realPath = fs5.realpathSync(rawPath);
+    const relative3 = path5.relative(realHome, realPath);
+    if (relative3 === "" || relative3.startsWith("..") || path5.isAbsolute(relative3)) {
       return false;
     }
-    const { size } = fs3.statSync(realPath);
+    const { size } = fs5.statSync(realPath);
     return size <= maxBytes;
   } catch {
     return false;
@@ -2112,7 +2554,7 @@ function nonDocMutatedLines(rows) {
 }
 function gitNumstatRows(cwd) {
   try {
-    const r = spawnSync("git", ["diff", "--numstat", "HEAD"], {
+    const r = spawnSync2("git", ["diff", "--numstat", "HEAD"], {
       cwd,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024
@@ -2125,7 +2567,7 @@ function gitNumstatRows(cwd) {
 }
 function untrackedNonDocFiles(cwd) {
   try {
-    const r = spawnSync("git", ["ls-files", "--others", "--exclude-standard"], {
+    const r = spawnSync2("git", ["ls-files", "--others", "--exclude-standard"], {
       cwd,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024
@@ -2140,13 +2582,13 @@ var BINARY_PROBE_BYTES = 8e3;
 var UNTRACKED_FILE_READ_CAP_BYTES = 8 * 1024 * 1024;
 function untrackedFileLineCount(cwd, relPath) {
   try {
-    const abs = path3.resolve(cwd, relPath);
-    const size = fs3.statSync(abs).size;
+    const abs = path5.resolve(cwd, relPath);
+    const size = fs5.statSync(abs).size;
     if (size === 0) return 0;
     if (size > UNTRACKED_FILE_READ_CAP_BYTES) {
       return MUTATION_LINE_THRESHOLD + 1;
     }
-    const buf = fs3.readFileSync(abs);
+    const buf = fs5.readFileSync(abs);
     if (buf.length === 0) return 0;
     const probe = buf.subarray(0, Math.min(buf.length, BINARY_PROBE_BYTES));
     if (probe.includes(0)) return 0;
@@ -2225,30 +2667,31 @@ function scanTranscriptForReviewer(transcriptText) {
 function buildAdvisoryLine(diffLines) {
   return `this session mutated ${diffLines} lines without a neutral review; spawn a cross-model reviewer before claiming done (delegation-policy / verify-budget)`;
 }
-function appendReviewSkippedTelemetry(workspaceRoot, diffLines, mutationMeasure) {
+function appendReviewSkippedTelemetry(workspaceRoot, diffLines, mutationMeasure, baseline) {
   if (is_replay_mode()) return;
   const ts = (/* @__PURE__ */ new Date()).toISOString();
   const { line, errors } = buildReviewSkippedLine({
     diff_lines: diffLines,
     mutation_measure: mutationMeasure,
     ts,
-    id: crypto.randomUUID()
+    id: crypto.randomUUID(),
+    baseline
   });
   if (errors.length || line === null) return;
   try {
-    const dir = path3.join(workspaceRoot, "agents", "runtime", "state", "audit");
-    fs3.mkdirSync(dir, { recursive: true });
-    const file = path3.join(dir, `${ts.slice(0, 7)}.jsonl`);
-    fs3.appendFileSync(file, `${JSON.stringify(line)}
+    const dir = path5.join(workspaceRoot, "agents", "runtime", "state", "audit");
+    fs5.mkdirSync(dir, { recursive: true });
+    const file = path5.join(dir, `${ts.slice(0, 7)}.jsonl`);
+    fs5.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
 }
 function sessionStateDir(workspaceRoot) {
-  return path3.join(workspaceRoot, "agents", "runtime", "state", "end-review-nudge");
+  return path5.join(workspaceRoot, "agents", "runtime", "state", "end-review-nudge");
 }
 function sessionStateFile(workspaceRoot, sessionKey) {
-  return path3.join(sessionStateDir(workspaceRoot), `${sessionKey}.json`);
+  return path5.join(sessionStateDir(workspaceRoot), `${sessionKey}.json`);
 }
 function deriveSessionKey2(envelope, payload) {
   const raw = str(envelope["session_id"]) || str(payload["transcript_path"] ?? payload["transcriptPath"]);
@@ -2257,7 +2700,7 @@ function deriveSessionKey2(envelope, payload) {
 }
 function hasFiredThisSession(workspaceRoot, sessionKey) {
   try {
-    return fs3.existsSync(sessionStateFile(workspaceRoot, sessionKey));
+    return fs5.existsSync(sessionStateFile(workspaceRoot, sessionKey));
   } catch {
     return false;
   }
@@ -2271,26 +2714,45 @@ function markFiredThisSession(workspaceRoot, sessionKey, ts) {
 function _read_stdin() {
   return readHookStdin();
 }
-function main3() {
+var FALLBACK_TO_TELEMETRY = {
+  absent: "absent",
+  unreadable: "unreadable",
+  "head-moved": "head_moved",
+  "mixed-measure": "mixed_measure"
+};
+function main4() {
   const [envelope, payload] = unwrap(_read_stdin(), "claude");
   const event = String(envelope["event"] ?? "");
   if (event !== "" && event !== "stop") {
     return 0;
   }
   const workspace_root = String(envelope["workspace_root"] ?? "").trim() || process.cwd();
-  let diffLines;
+  let measuredLines;
   let mutationMeasure;
   try {
     const measured = totalNonDocMutatedLinesWithMeasure(workspace_root);
-    diffLines = measured.lines;
+    measuredLines = measured.lines;
     mutationMeasure = measured.measure;
   } catch {
     return 0;
   }
+  const sessionKey = deriveSessionKey2(envelope, payload);
+  const baselineOutcome = applyBaseline(
+    measuredLines,
+    readBaseline(workspace_root, sessionKey),
+    // A THUNK, not a value: on the `absent` and `unreadable` branches the
+    // result is discarded, and those two are the steady state on every host
+    // without this nudge and on every session before its first baseline
+    // write. Passing the value eagerly spent an 11-14 ms `git rev-parse` on
+    // each of those stops for nothing.
+    () => currentHeadSha(workspace_root),
+    mutationMeasure
+  );
+  const diffLines = baselineOutcome.lines;
+  const baselineApplication = baselineOutcome.applied ? "applied" : FALLBACK_TO_TELEMETRY[baselineOutcome.fallback];
   if (diffLines <= MUTATION_LINE_THRESHOLD) {
     return 0;
   }
-  const sessionKey = deriveSessionKey2(envelope, payload);
   if (hasFiredThisSession(workspace_root, sessionKey)) {
     return 0;
   }
@@ -2300,7 +2762,7 @@ function main3() {
   let reviewerRan = false;
   if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
     try {
-      reviewerRan = scanTranscriptForReviewer(fs3.readFileSync(transcriptPath, "utf-8"));
+      reviewerRan = scanTranscriptForReviewer(fs5.readFileSync(transcriptPath, "utf-8"));
     } catch {
       reviewerRan = false;
     }
@@ -2310,7 +2772,12 @@ function main3() {
   }
   markFiredThisSession(workspace_root, sessionKey, (/* @__PURE__ */ new Date()).toISOString());
   try {
-    appendReviewSkippedTelemetry(workspace_root, diffLines, mutationMeasure);
+    appendReviewSkippedTelemetry(
+      workspace_root,
+      diffLines,
+      mutationMeasure,
+      baselineApplication
+    );
   } catch {
   }
   process.stdout.write(
@@ -2323,34 +2790,34 @@ function main3() {
   );
   return EXIT_WARN2;
 }
-function _isCliEntry3() {
+function _isCliEntry4() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL3(path3.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL4(path5.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs3.realpathSync(fileURLToPath3(import.meta.url));
-    const argv = fs3.realpathSync(path3.resolve(process.argv[1]));
+    const here = fs5.realpathSync(fileURLToPath4(import.meta.url));
+    const argv = fs5.realpathSync(path5.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry3()) {
-  process.exit(main3());
+if (_isCliEntry4()) {
+  process.exit(main4());
 }
 
 // src/scripts/hooks/subagent_ledger_hook.ts
 import * as crypto2 from "node:crypto";
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
-import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL4 } from "node:url";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
 
 // src/scripts/_lib/subagent_response.ts
 var MAX_SUMMARY_CHARS = 2e3;
@@ -2456,7 +2923,7 @@ var EXIT_ALLOW3 = 0;
 function isObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var LEDGER_DIR = path4.join("agents", "runtime", "state", "subagent-ledger");
+var LEDGER_DIR = path6.join("agents", "runtime", "state", "subagent-ledger");
 var OPEN_SUBDIR = "open";
 var OPEN_RECORD_TTL_MS = 24 * 60 * 60 * 1e3;
 function refFor(agentId) {
@@ -2546,10 +3013,10 @@ function _jsonObjectCandidates(message) {
   return out;
 }
 function openDir(root) {
-  return path4.join(root, LEDGER_DIR, OPEN_SUBDIR);
+  return path6.join(root, LEDGER_DIR, OPEN_SUBDIR);
 }
 function openFile(root, ref) {
-  return path4.join(openDir(root), `${ref}.json`);
+  return path6.join(openDir(root), `${ref}.json`);
 }
 var DEPTH_BASES = /* @__PURE__ */ new Set(["observed", "asserted-parent", "assumed-root"]);
 function _asOpenRecord(value, expectedRef) {
@@ -2576,7 +3043,7 @@ function readOpenRecords(root) {
   const out = /* @__PURE__ */ new Map();
   let names;
   try {
-    names = fs4.readdirSync(openDir(root));
+    names = fs6.readdirSync(openDir(root));
   } catch {
     return out;
   }
@@ -2584,7 +3051,7 @@ function readOpenRecords(root) {
     if (!name.endsWith(".json")) continue;
     const expectedRef = name.slice(0, -".json".length);
     try {
-      const raw = fs4.readFileSync(path4.join(openDir(root), name), "utf8");
+      const raw = fs6.readFileSync(path6.join(openDir(root), name), "utf8");
       const rec = _asOpenRecord(JSON.parse(raw), expectedRef);
       if (rec) out.set(rec.ref, rec);
     } catch {
@@ -2599,13 +3066,13 @@ function resolveDepth(parentRef, open) {
   return { depth: parent.depth + 1, depth_basis: "observed" };
 }
 function ledgerFileFor2(root, ts) {
-  return path4.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
+  return path6.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
 }
 function appendLedgerLine(root, ts, line) {
   if (is_replay_mode()) return;
   const file = ledgerFileFor2(root, ts);
-  fs4.mkdirSync(path4.dirname(file), { recursive: true });
-  fs4.appendFileSync(file, `${JSON.stringify(line)}
+  fs6.mkdirSync(path6.dirname(file), { recursive: true });
+  fs6.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 var WALL_CLOCK_ARMS_MS = [
@@ -2619,7 +3086,7 @@ function armsExceeded(elapsedMs) {
   return WALL_CLOCK_ARMS_MS.filter((a) => elapsedMs >= a.ms).map((a) => a.label);
 }
 function openRecordStats(root, nowMs = Date.now()) {
-  const ledgerPresent = fs4.existsSync(path4.join(root, LEDGER_DIR));
+  const ledgerPresent = fs6.existsSync(path6.join(root, LEDGER_DIR));
   const open = readOpenRecords(root);
   let maxDepth = 0;
   let counted = 0;
@@ -2647,13 +3114,13 @@ function writeOpenRecord(root, rec) {
 function removeOpenRecord(root, ref) {
   if (is_replay_mode()) return;
   try {
-    fs4.unlinkSync(openFile(root, ref));
+    fs6.unlinkSync(openFile(root, ref));
   } catch {
   }
 }
 function countOpen(root) {
   try {
-    return fs4.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+    return fs6.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
   } catch {
     return 0;
   }
@@ -2804,7 +3271,7 @@ function resolveConsumerRoot(envelope) {
   }
   return process.cwd();
 }
-function main4() {
+function main5() {
   const raw = readHookStdin();
   let envelope = {};
   try {
@@ -2814,20 +3281,20 @@ function main4() {
   }
   return processEnvelope(envelope, resolveConsumerRoot(envelope));
 }
-function _isCliEntry4() {
+function _isCliEntry5() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL4(path4.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL5(path6.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs4.realpathSync(fileURLToPath4(import.meta.url)) === fs4.realpathSync(path4.resolve(process.argv[1]));
+    return fs6.realpathSync(fileURLToPath5(import.meta.url)) === fs6.realpathSync(path6.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry4()) process.exit(main4());
+if (_isCliEntry5()) process.exit(main5());
 
 // src/scripts/hooks/turn_end_gate_hook.ts
 var EXIT_BLOCK = 1;
@@ -2936,7 +3403,7 @@ function detectPromissory(reply) {
 function readCiSettled(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return { seen: false, settled: false };
   try {
-    const raw = fs5.readFileSync(path5.join(workspaceRoot, statePathFor(session_id)), "utf-8");
+    const raw = fs7.readFileSync(path7.join(workspaceRoot, statePathFor(session_id)), "utf-8");
     const decoded = JSON.parse(raw);
     if (!owns_session_state(decoded, session_id)) return { seen: false, settled: false };
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
@@ -2972,8 +3439,8 @@ function detectCompletionClaim(reply, ci) {
 function readLanguagePin(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return "und";
   try {
-    const raw = fs5.readFileSync(
-      path5.join(workspaceRoot, statePathFor2(session_id)),
+    const raw = fs7.readFileSync(
+      path7.join(workspaceRoot, statePathFor2(session_id)),
       "utf-8"
     );
     const decoded = JSON.parse(raw);
@@ -3024,12 +3491,37 @@ function detectUnverifiedEdit(toolCalls) {
     reason: "this turn changed a file and then ran no verification command \u2014 no test, type-check, lint or build call follows the last edit (verify-before-complete: a claim without a fresh run is unverified)"
   };
 }
+var _SOURCE_RE = /\.(?:ts|tsx|js|jsx|mjs|cjs|vue|svelte|php|py|rb|go|rs|java|kt|swift|cs|scala|ex|exs)$/i;
+var _TEST_PATH_RE = /(?:^|\/)(?:tests?|specs?|__tests__|__specs__|e2e|cypress|playwright|features)\//i;
+var _TEST_FILE_RE = /(?:\.(?:test|spec)\.[a-z]+$)|(?:_test\.[a-z]+$)|(?:(?:^|\/)test_[^/]+$)|(?:Test\.php$)|(?:Spec\.php$)|(?:\.feature$)/i;
+function _isTestPath(p) {
+  return _TEST_PATH_RE.test(p) || _TEST_FILE_RE.test(p);
+}
+function _isProductionSource(p) {
+  return _SOURCE_RE.test(p) && !_isTestPath(p);
+}
+function detectUntestedChange(reply, toolCalls) {
+  const edited = toolCalls.filter((c) => _EDIT_TOOLS.has(c.name) && c.path !== void 0).map((c) => c.path);
+  const source = edited.filter(_isProductionSource);
+  if (source.length === 0) return null;
+  if (edited.some(_isTestPath)) return null;
+  const prose = visibleProse(reply);
+  const m = _COMPLETION_RE.exec(prose);
+  if (!m) return null;
+  if (_NEGATED_CLAIM_RE.test(_lineAround(prose, m.index))) return null;
+  const shown = source.slice(0, 3).join(", ");
+  return {
+    detector: "untested",
+    evidence: shown + (source.length > 3 ? ` (+${String(source.length - 3)} more)` : ""),
+    reason: "a completion claim over production code this turn changed, with NO test file touched anywhere in the turn \u2014 running a linter is not evidence the change works. Write the test that would have caught the failure, and enumerate the states the change actually has (every view, every CRUD path, the empty and error states) rather than the happy one. If a test genuinely does not belong here, say which file carries the coverage instead"
+  };
+}
 function sessionStateFile2(workspaceRoot, sessionKey) {
   return sessionRefusalFile(workspaceRoot, sessionKey);
 }
 function alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal) {
   try {
-    const raw = fs5.readFileSync(sessionStateFile2(workspaceRoot, sessionKey), "utf-8");
+    const raw = fs7.readFileSync(sessionStateFile2(workspaceRoot, sessionKey), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded["refused_turn"] === turnOrdinal;
@@ -3038,12 +3530,12 @@ function alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal) {
   }
   return false;
 }
-function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detectors) {
+function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detectors, promptId) {
   if (is_replay_mode()) return;
   const file = sessionStateFile2(workspaceRoot, sessionKey);
   let prev = null;
   try {
-    prev = parseRecord(fs5.readFileSync(file, "utf-8"));
+    prev = parseRecord(fs7.readFileSync(file, "utf-8"));
   } catch {
   }
   let version;
@@ -3059,27 +3551,34 @@ function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detectors) {
         detectors,
         turnOrdinal,
         at: (/* @__PURE__ */ new Date()).toISOString(),
-        version
+        version,
+        promptId
       })
     );
   } catch {
   }
 }
 function readTranscriptTail(transcriptPath, opts = {}) {
-  const empty = { lastAssistant: "", turnOrdinal: 0, toolCalls: [] };
+  const empty = {
+    lastAssistant: "",
+    turnOrdinal: 0,
+    toolCalls: [],
+    assistantTurnTexts: []
+  };
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs5.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs7.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs5.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs7.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
   let lastAssistant = "";
   let turnOrdinal = 0;
   let toolCalls = [];
+  let assistantTurnTexts = [];
   for (const rawLine of lines) {
     const line = rawLine.trim();
     if (!line) continue;
@@ -3098,20 +3597,27 @@ function readTranscriptTail(transcriptPath, opts = {}) {
     if (typeof msg !== "object" || msg === null || Array.isArray(msg)) continue;
     const content = msg["content"];
     if (role === "assistant") {
-      toolCalls.push(..._toolCalls(content));
+      toolCalls.push(...extractToolCalls(content));
     }
     const text = _messageText(content);
     if (text === null) continue;
     if (role === "assistant") {
       lastAssistant = text;
+      assistantTurnTexts.push(text);
     } else if (!isSyntheticPrompt(text)) {
       turnOrdinal += 1;
       toolCalls = [];
+      assistantTurnTexts = [];
     }
   }
-  return { lastAssistant: lastAssistant.trim(), turnOrdinal, toolCalls };
+  return {
+    lastAssistant: lastAssistant.trim(),
+    turnOrdinal,
+    toolCalls,
+    assistantTurnTexts
+  };
 }
-function _toolCalls(content) {
+function extractToolCalls(content) {
   if (!Array.isArray(content)) return [];
   const out = [];
   for (const blk of content) {
@@ -3149,7 +3655,7 @@ function _messageText(content) {
 function str3(v) {
   return typeof v === "string" ? v : "";
 }
-function main5() {
+function main6() {
   let envelope;
   let payload;
   try {
@@ -3167,10 +3673,19 @@ function main5() {
   const transcriptPath = str3(
     payload["transcript_path"] ?? payload["transcriptPath"]
   );
-  const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
-    maxBytes: TRANSCRIPT_READ_MAX_BYTES
-  });
+  const { lastAssistant, turnOrdinal, toolCalls, assistantTurnTexts } = readTranscriptTail(
+    transcriptPath,
+    { maxBytes: TRANSCRIPT_READ_MAX_BYTES }
+  );
   if (!lastAssistant) return EXIT_ALLOW4;
+  const payloadClosing = str3(
+    payload["last_assistant_message"] ?? payload["lastAssistantMessage"]
+  );
+  const closingFromPayload = payloadClosing !== "" && !assistantTurnTexts.includes(payloadClosing);
+  const turnTexts = closingFromPayload ? [...assistantTurnTexts, payloadClosing] : assistantTurnTexts;
+  const promptId = str3(
+    payload["prompt_id"] ?? payload["promptId"]
+  );
   const rawSessionId = str3(envelope["session_id"]) || "";
   const sessionKey = deriveSessionKey(rawSessionId || "unknown-session");
   if (alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal)) return EXIT_ALLOW4;
@@ -3192,7 +3707,23 @@ function main5() {
     // gating is where the comment above says gating belongs — inside the
     // detector: no CI observed, or a settled read, or no completion claim
     // ⇒ no finding.
-    dispatchOpen ? null : detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot, rawSessionId))
+    dispatchOpen ? null : detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot, rawSessionId)),
+    // Detector E is UNCONDITIONAL, and that is the opposite choice from A
+    // and D one line above rather than an oversight. An open dispatch
+    // excuses a promissory closing because the work is genuinely still
+    // running; it excuses nothing about a question the user was already
+    // asked. Worse: a dispatch — or the `end-review-nudge` stop concern
+    // that produced the measured failure — IS the continuation that drops
+    // the decision, so narrowing E the same way would silence it in exactly
+    // the case it exists for.
+    detectDroppedDecision(turnTexts, closingFromPayload),
+    // Detector F takes the OTHER side of that same question, and the two
+    // sitting adjacent is the clearest place to say why. E fires on a
+    // question already asked, which an open dispatch cannot excuse. F fires
+    // on a completion CLAIM, and a turn waiting on a subagent has not
+    // finished — so its closing is not the claim F is about. Same slot,
+    // opposite trigger, opposite treatment of `dispatchOpen`.
+    dispatchOpen ? null : detectUntestedChange(lastAssistant, toolCalls)
   ]) {
     if (f) findings.push(f);
   }
@@ -3201,7 +3732,8 @@ function main5() {
     workspaceRoot,
     sessionKey,
     turnOrdinal,
-    findings.map((f) => f.detector)
+    findings.map((f) => f.detector),
+    promptId
   );
   const lines = findings.map(
     (f) => `  \xB7 ${f.detector}: ${f.reason}
@@ -3210,43 +3742,61 @@ function main5() {
   process.stderr.write(
     `turn-end-gate: REFUSED \u2014 this turn is not finished.
 ${lines.join("\n")}
-  Do the promised work now, correct the language, run the verification the edit needs, or read the CI verdict before claiming it \u2014 then end the turn.
+  Do the promised work now, correct the language, run the verification the edit needs, read the CI verdict before claiming it, or re-present the options block this turn dropped \u2014 then end the turn.
   This turn will not be refused a second time.
 `
   );
   return EXIT_BLOCK;
 }
-function _isCliEntry5() {
+function _isCliEntry6() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL5(path5.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL6(path7.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs5.realpathSync(fileURLToPath5(import.meta.url));
-    const argv = fs5.realpathSync(path5.resolve(process.argv[1]));
+    const here = fs7.realpathSync(fileURLToPath6(import.meta.url));
+    const argv = fs7.realpathSync(path7.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry5()) {
-  process.exit(main5());
+if (_isCliEntry6()) {
+  process.exit(main6());
 }
 
 // src/scripts/hooks/evidence_independence.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
 import crypto3 from "node:crypto";
-import fs6 from "node:fs";
-import path6 from "node:path";
-import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL6 } from "node:url";
+import fs8 from "node:fs";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL7 } from "node:url";
+
+// src/scripts/_lib/test_delta.ts
+function isCodePath(p) {
+  const f = p.replace(/\\/g, "/");
+  if (isTestPath(f)) return false;
+  if (!/\.(ts|tsx|js|mjs|cjs)$/.test(f)) return false;
+  if (f.endsWith(".d.ts")) return false;
+  if (/^(dist|\.augment|\.claude|\.cursor|node_modules)\//.test(f)) return false;
+  return /^(src|scripts)\//.test(f);
+}
+function isTestPath(p) {
+  const f = p.replace(/\\/g, "/");
+  if (/^tests\//.test(f)) return true;
+  return /\.(test|spec)\.(ts|tsx|js|mjs|cjs)$/.test(f);
+}
+
+// src/scripts/hooks/evidence_independence.ts
 var EXIT_ALLOW5 = 0;
 var EXIT_BLOCK2 = 1;
-var STATE_FILE3 = path6.join("agents", "state", "evidence-dispatch.json");
+var STATE_FILE3 = path8.join("agents", "state", "evidence-dispatch.json");
 function _isObject5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -3314,8 +3864,8 @@ function extractDispatch(envelope) {
 }
 function _ledgerStamp(consumer_root) {
   try {
-    const raw = fs6.readFileSync(
-      path6.join(consumer_root, "agents", "state", "git-authorization.json"),
+    const raw = fs8.readFileSync(
+      path8.join(consumer_root, "agents", "state", "git-authorization.json"),
       "utf8"
     );
     const d = JSON.parse(raw);
@@ -3326,7 +3876,7 @@ function _ledgerStamp(consumer_root) {
 }
 function _load(target) {
   try {
-    const decoded = JSON.parse(fs6.readFileSync(target, "utf8"));
+    const decoded = JSON.parse(fs8.readFileSync(target, "utf8"));
     if (_isObject5(decoded) && Array.isArray(decoded["evaluations"])) {
       return decoded;
     }
@@ -3372,6 +3922,32 @@ function decide(tool, prompt, priorEvaluations) {
     evaluations: priorEvaluations + 1
   };
 }
+function sameSessionTestFlag(command) {
+  if (command === null || !/\bgit\b[^|;&]*\bcommit\b/.test(command)) return null;
+  return SAME_SESSION_TEXT;
+}
+var SAME_SESSION_TEXT = "This commit stages both a test and code it could cover \u2014 the shape L0 takes in a diff, where the implementer authored the evaluator. This check reads the staged set only: it cannot tell who wrote the test, so it is a prompt to STATE the level, not a finding that you are at L0. L0 is a permitted FALLBACK, not the default: where a second session, a second model or a second provider was available, the test should have come from one of them. Say which in the commit or the PR body \u2014 a diff looks identical either way. See evaluator-independence \xA7 Tests are evaluators.";
+function touchesTestAndCode(paths) {
+  return paths.some(isTestPath) && paths.some(isCodePath);
+}
+function _commandOf(envelope) {
+  const payload = _isObject5(envelope["payload"]) ? envelope["payload"] : envelope;
+  const input = _isObject5(payload["tool_input"]) ? payload["tool_input"] : payload;
+  for (const key of ["command", "cmd", "shell_command"]) {
+    const v = input[key];
+    if (typeof v === "string" && v !== "") return v;
+  }
+  return null;
+}
+function _stagedPaths(consumer_root) {
+  const r = spawnSync3("git", ["diff", "--cached", "--name-only"], {
+    cwd: consumer_root,
+    encoding: "utf8"
+  });
+  if (r.status !== 0) return null;
+  const out = r.stdout.split("\n").map((s) => s.trim()).filter((s) => s !== "");
+  return out.length === 0 ? null : out;
+}
 function run3(stdin_text, options) {
   let envelope = {};
   if (stdin_text.trim()) {
@@ -3384,7 +3960,7 @@ function run3(stdin_text, options) {
       return EXIT_ALLOW5;
     }
   }
-  const target = path6.join(options.consumer_root, STATE_FILE3);
+  const target = path8.join(options.consumer_root, STATE_FILE3);
   const state = _load(target);
   const session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
   const turnMarker = `${session_id}:${_ledgerStamp(options.consumer_root)}`;
@@ -3394,6 +3970,15 @@ function run3(stdin_text, options) {
     state.evaluations = [];
   }
   const [tool, prompt] = extractDispatch(envelope);
+  const flag = sameSessionTestFlag(_commandOf(envelope));
+  if (flag !== null) {
+    const staged = _stagedPaths(options.consumer_root);
+    if (staged !== null && touchesTestAndCode(staged)) {
+      process.stdout.write(`${JSON.stringify({ decision: "warn", reason: flag })}
+`);
+      return EXIT_ALLOW5;
+    }
+  }
   const decision = decide(tool, prompt, state.evaluations.length);
   if (decision.evaluations > state.evaluations.length) {
     state.evaluations.push({
@@ -3422,7 +4007,7 @@ function _errText3(err) {
   const t = err instanceof Error ? err.message : String(err);
   return t.replace(/\s+/g, " ").trim().slice(0, 200);
 }
-function main6(argv) {
+function main7(argv) {
   const args = argv ?? process.argv.slice(2);
   let consumer_root = process.cwd();
   for (let i = 0; i < args.length; i += 1) {
@@ -3436,33 +4021,33 @@ function main6(argv) {
   }
   return run3(readHookStdin(), { consumer_root });
 }
-function _isCliEntry6() {
+function _isCliEntry7() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL6(path6.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL7(path8.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs6.realpathSync(fileURLToPath6(import.meta.url));
-    const argv = fs6.realpathSync(path6.resolve(process.argv[1]));
+    const here = fs8.realpathSync(fileURLToPath7(import.meta.url));
+    const argv = fs8.realpathSync(path8.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry6()) {
-  process.exit(main6());
+if (_isCliEntry7()) {
+  process.exit(main7());
 }
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-import fs7 from "node:fs";
-import path7 from "node:path";
-import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL7 } from "node:url";
+import fs9 from "node:fs";
+import path9 from "node:path";
+import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
 
 // src/scripts/_lib/auto_dispatch.ts
 var SIZE_FLOOR = 1;
@@ -3917,7 +4502,7 @@ function _workspaceRoot(envelope) {
   }
   return process.cwd();
 }
-function main7() {
+function main8() {
   let envelope = {};
   try {
     const raw = readHookStdin();
@@ -3956,31 +4541,31 @@ function main7() {
   );
   return EXIT_WARN3;
 }
-function _isCliEntry7() {
+function _isCliEntry8() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL7(path7.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL8(path9.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs7.realpathSync(fileURLToPath7(import.meta.url));
-    const argv = fs7.realpathSync(path7.resolve(process.argv[1]));
+    const here = fs9.realpathSync(fileURLToPath8(import.meta.url));
+    const argv = fs9.realpathSync(path9.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry7()) {
-  process.exit(main7());
+if (_isCliEntry8()) {
+  process.exit(main8());
 }
 
 // src/scripts/conformance_scan.ts
-var REPO_ROOT = path8.resolve(path8.dirname(fileURLToPath8(import.meta.url)), "..", "..");
+var REPO_ROOT = path10.resolve(path10.dirname(fileURLToPath9(import.meta.url)), "..", "..");
 var OBSERVED_BAND = { low: 9.1, high: 39.2 };
 var BAND_MIN_TURNS = 1978;
 var CARRIER_CHANGES = [
@@ -4346,7 +4931,7 @@ function scanSession(sessionId, lines) {
   closeWindow();
   return report;
 }
-var DEFAULT_RATE_SERIES = path8.join(
+var DEFAULT_RATE_SERIES = path10.join(
   REPO_ROOT,
   "agents",
   "runtime",
@@ -4355,7 +4940,7 @@ var DEFAULT_RATE_SERIES = path8.join(
 );
 function defaultStore(projectDir) {
   const slug = projectStoreSlug(projectDir);
-  return path8.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
+  return path10.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
 }
 function _tokens(chars) {
   return Math.round(chars / 4);
@@ -4366,13 +4951,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   return {
     project: {
       dir: projectRulesDir,
-      present: fs8.existsSync(projectRulesDir),
+      present: fs10.existsSync(projectRulesDir),
       files: p.files,
       tokens: _tokens(p.chars)
     },
     global: {
       dir: globalRulesDir,
-      present: fs8.existsSync(globalRulesDir),
+      present: fs10.existsSync(globalRulesDir),
       files: g.files,
       tokens: _tokens(g.chars)
     },
@@ -4380,13 +4965,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   };
 }
 function storeKey(store) {
-  return createHash3("sha256").update(path8.resolve(store)).digest("hex").slice(0, 12);
+  return createHash3("sha256").update(path10.resolve(store)).digest("hex").slice(0, 12);
 }
 function scanStore(store, limit) {
-  const files = fs8.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs8.statSync(path8.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
+  const files = fs10.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs10.statSync(path10.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
   const per_session = [];
   for (const f of files) {
-    const lines = fs8.readFileSync(path8.join(store, f), "utf8").split("\n");
+    const lines = fs10.readFileSync(path10.join(store, f), "utf8").split("\n");
     const r = scanSession(f.replace(/\.jsonl$/, "").slice(0, 8), lines);
     if (r.assistant_turns > 0) {
       per_session.push(r);
@@ -4414,10 +4999,10 @@ function scanStore(store, limit) {
   const task_completeness_rate_pct = completeness_windows === 0 ? 0 : Number((100 * task_completeness / completeness_windows).toFixed(1));
   const era = spansCarrierChange(per_session.map((s) => s.first_at));
   const delivered = measureDelivered(
-    path8.join(REPO_ROOT, ".claude", "rules"),
-    path8.join(process.env["HOME"] ?? os2.homedir(), ".claude", "rules")
+    path10.join(REPO_ROOT, ".claude", "rules"),
+    path10.join(process.env["HOME"] ?? os2.homedir(), ".claude", "rules")
   );
-  const ownStore = path8.resolve(store) === path8.resolve(defaultStore(REPO_ROOT));
+  const ownStore = path10.resolve(store) === path10.resolve(defaultStore(REPO_ROOT));
   return {
     scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
     store,
@@ -4447,8 +5032,8 @@ function scanStore(store, limit) {
   };
 }
 function recordRate(file, scanned_at, rate) {
-  fs8.mkdirSync(path8.dirname(file), { recursive: true });
-  fs8.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
+  fs10.mkdirSync(path10.dirname(file), { recursive: true });
+  fs10.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
 `, "utf8");
 }
 function render(report) {
@@ -4547,7 +5132,7 @@ function render(report) {
   lines.push("    checkbox batching                     \u2014 measured NOWHERE. ~5 low-severity findings.");
   return lines.join("\n");
 }
-function main8(argv) {
+function main9(argv) {
   const args = argv ?? process.argv.slice(2);
   let store = null;
   let limit = 30;
@@ -4579,14 +5164,14 @@ function main8(argv) {
     return 2;
   }
   const resolved = store ?? defaultStore(process.cwd());
-  if (!fs8.existsSync(resolved)) {
+  if (!fs10.existsSync(resolved)) {
     process.stderr.write(`conformance:behavior: no transcript store at ${resolved}
 `);
     return 1;
   }
   const report = scanStore(resolved, Number.isFinite(limit) && limit > 0 ? limit : 30);
   if (out) {
-    fs8.writeFileSync(out, `${JSON.stringify(report, null, 2)}
+    fs10.writeFileSync(out, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   }
   if (record) {
@@ -4594,7 +5179,7 @@ function main8(argv) {
   }
   if (why !== null) {
     const id = why;
-    fs8.writeSync(
+    fs10.writeSync(
       1,
       json ? `${JSON.stringify(
         {
@@ -4614,48 +5199,48 @@ function main8(argv) {
     );
     return 0;
   }
-  fs8.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
+  fs10.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
 ` : `${render(report)}
 `);
   return 0;
 }
-function _isCliEntry8() {
+function _isCliEntry9() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL8(path8.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL9(path10.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs8.realpathSync(fileURLToPath8(import.meta.url));
-    const argv = fs8.realpathSync(path8.resolve(process.argv[1]));
+    const here = fs10.realpathSync(fileURLToPath9(import.meta.url));
+    const argv = fs10.realpathSync(path10.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry8()) {
-  process.exit(main8());
+if (_isCliEntry9()) {
+  process.exit(main9());
 }
 
 // src/scripts/report_carrier_divergence.ts
-import * as fs9 from "node:fs";
+import * as fs11 from "node:fs";
 import * as os3 from "node:os";
-import * as path9 from "node:path";
+import * as path11 from "node:path";
 import process2 from "node:process";
-import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
-var _HERE = fileURLToPath9(import.meta.url);
-var REPO_ROOT2 = path9.resolve(path9.dirname(_HERE), "..", "..");
-var PROJECT_RULES = path9.join(".claude", "rules");
-var PROJECTION_SOURCE = path9.join("dist", "agent-src", "rules");
-var GLOBAL_RULES = path9.join(".claude", "rules");
+import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
+var _HERE2 = fileURLToPath10(import.meta.url);
+var REPO_ROOT2 = path11.resolve(path11.dirname(_HERE2), "..", "..");
+var PROJECT_RULES = path11.join(".claude", "rules");
+var PROJECTION_SOURCE = path11.join("dist", "agent-src", "rules");
+var GLOBAL_RULES = path11.join(".claude", "rules");
 function _listRules(dir) {
   try {
-    return fs9.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    return fs11.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -4663,7 +5248,7 @@ function _listRules(dir) {
 function _ruleType(file) {
   let text;
   try {
-    text = fs9.readFileSync(file, "utf-8");
+    text = fs11.readFileSync(file, "utf-8");
   } catch {
     return "";
   }
@@ -4674,8 +5259,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
   const out = {
     projectDir,
     globalDir,
-    globalPresent: fs9.existsSync(globalDir),
-    projectPresent: fs9.existsSync(projectDir),
+    globalPresent: fs11.existsSync(globalDir),
+    projectPresent: fs11.existsSync(projectDir),
     shared: 0,
     identical: [],
     provenanceOnly: [],
@@ -4698,7 +5283,7 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     }
     if (!inP && inG) {
       out.globalOnly.push(rule);
-      if (sourceDir !== void 0 && _ruleType(path9.join(sourceDir, rule)) === "manual") {
+      if (sourceDir !== void 0 && _ruleType(path11.join(sourceDir, rule)) === "manual") {
         out.manualOnlyGlobal.push(rule);
       }
       continue;
@@ -4708,8 +5293,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     let projectCopy;
     let globalCopy;
     try {
-      projectCopy = fs9.readFileSync(path9.join(projectDir, rule));
-      globalCopy = fs9.readFileSync(path9.join(globalDir, rule));
+      projectCopy = fs11.readFileSync(path11.join(projectDir, rule));
+      globalCopy = fs11.readFileSync(path11.join(globalDir, rule));
       verdict = comparePair(projectCopy, globalCopy);
     } catch {
       out.shared -= 1;
@@ -4854,11 +5439,11 @@ function render2(d) {
   }
   return lines.join("\n");
 }
-function main9(argv) {
+function main10(argv) {
   const args = argv ?? process2.argv.slice(2);
-  let projectDir = path9.join(REPO_ROOT2, PROJECT_RULES);
-  let globalDir = path9.join(os3.homedir(), GLOBAL_RULES);
-  let sourceDir = path9.join(REPO_ROOT2, PROJECTION_SOURCE);
+  let projectDir = path11.join(REPO_ROOT2, PROJECT_RULES);
+  let globalDir = path11.join(os3.homedir(), GLOBAL_RULES);
+  let sourceDir = path11.join(REPO_ROOT2, PROJECTION_SOURCE);
   const value = (i) => {
     const v = args[i + 1];
     return v === void 0 || v.startsWith("-") ? null : v;
@@ -4872,7 +5457,7 @@ function main9(argv) {
 `);
         return 1;
       }
-      const resolved = path9.resolve(v);
+      const resolved = path11.resolve(v);
       if (a === "--project") projectDir = resolved;
       else if (a === "--global") globalDir = resolved;
       else sourceDir = resolved;
@@ -4892,26 +5477,26 @@ function main9(argv) {
 `);
   return 0;
 }
-function _isCliEntry9() {
+function _isCliEntry10() {
   if (process2.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL9(path9.resolve(process2.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL10(path11.resolve(process2.argv[1])).href) return true;
   try {
-    return fs9.realpathSync(_HERE) === fs9.realpathSync(path9.resolve(process2.argv[1]));
+    return fs11.realpathSync(_HERE2) === fs11.realpathSync(path11.resolve(process2.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry9()) {
-  process2.exit(main9());
+if (_isCliEntry10()) {
+  process2.exit(main10());
 }
 
 // src/scripts/report_skill_activation.ts
-import * as fs10 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os4 from "node:os";
-import * as path10 from "node:path";
-import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
-var _HERE2 = fileURLToPath10(import.meta.url);
-var REPO_ROOT3 = path10.resolve(path10.dirname(_HERE2), "..", "..");
+import * as path12 from "node:path";
+import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
+var _HERE3 = fileURLToPath11(import.meta.url);
+var REPO_ROOT3 = path12.resolve(path12.dirname(_HERE3), "..", "..");
 var SKILLS_ROOT = "src/skills";
 var TRIGGER_KEYS = ["triggers:", "trigger_description:", "file_pattern:", "path_prefix:"];
 var DETERMINISTIC_RE = /^\s*(?:[-*]\s*)?(?:\*\*)?(MUST|NEVER|ALWAYS)\b/m;
@@ -4922,25 +5507,25 @@ function censusSkills(root) {
     withTriggerCorpus: [],
     withDeterministicObligation: []
   };
-  if (!fs10.existsSync(root)) {
+  if (!fs12.existsSync(root)) {
     return out;
   }
-  for (const entry of fs10.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+  for (const entry of fs12.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const file = path10.join(root, entry.name, "SKILL.md");
-    if (!fs10.existsSync(file)) {
+    const file = path12.join(root, entry.name, "SKILL.md");
+    if (!fs12.existsSync(file)) {
       continue;
     }
     out.total += 1;
-    const text = fs10.readFileSync(file, "utf8");
+    const text = fs12.readFileSync(file, "utf8");
     const fmEnd = text.startsWith("---") ? text.indexOf("\n---", 3) : -1;
     const fm = fmEnd === -1 ? "" : text.slice(0, fmEnd);
     if (TRIGGER_KEYS.some((k) => new RegExp(`^${k}`, "m").test(fm))) {
       out.withTriggerKey.push(entry.name);
     }
-    if (fs10.existsSync(path10.join(root, entry.name, "evals", "triggers.json"))) {
+    if (fs12.existsSync(path12.join(root, entry.name, "evals", "triggers.json"))) {
       out.withTriggerCorpus.push(entry.name);
     }
     const body = fmEnd === -1 ? text : text.slice(fmEnd + 4);
@@ -4951,17 +5536,17 @@ function censusSkills(root) {
   return out;
 }
 function defaultStore2(cwd) {
-  return path10.join(os4.homedir(), ".claude", "projects", projectStoreSlug(cwd));
+  return path12.join(os4.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function measureUsage(store, limit) {
   const rep = { store, sessions: 0, assistantTurns: 0, invocations: 0, bySkill: {} };
-  if (!fs10.existsSync(store)) {
+  if (!fs12.existsSync(store)) {
     return rep;
   }
-  const files = fs10.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path10.join(store, f)).sort((a, b) => fs10.statSync(b).mtimeMs - fs10.statSync(a).mtimeMs).slice(0, limit);
+  const files = fs12.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path12.join(store, f)).sort((a, b) => fs12.statSync(b).mtimeMs - fs12.statSync(a).mtimeMs).slice(0, limit);
   rep.sessions = files.length;
   for (const file of files) {
-    for (const line of fs10.readFileSync(file, "utf8").split("\n")) {
+    for (const line of fs12.readFileSync(file, "utf8").split("\n")) {
       if (!line.trim()) {
         continue;
       }
@@ -5034,15 +5619,15 @@ function buildRecord(census, usage, today) {
     assistant_turns: usage.reduce((a, u) => a + u.assistantTurns, 0),
     invocations: usage.reduce((a, u) => a + u.invocations, 0),
     distinct_skills_invoked: distinct.size,
-    stores: usage.map((u) => path10.basename(u.store))
+    stores: usage.map((u) => path12.basename(u.store))
   };
 }
 function readRecord(repoRoot) {
-  const file = path10.join(repoRoot, RECORD_PATH);
-  if (!fs10.existsSync(file)) {
+  const file = path12.join(repoRoot, RECORD_PATH);
+  if (!fs12.existsSync(file)) {
     return null;
   }
-  return JSON.parse(fs10.readFileSync(file, "utf8"));
+  return JSON.parse(fs12.readFileSync(file, "utf8"));
 }
 function render3(census, usage, published = null) {
   const lines = [];
@@ -5077,7 +5662,7 @@ function render3(census, usage, published = null) {
     }
     totalInv += u.invocations;
     lines.push(
-      `  ${path10.basename(u.store).slice(-38).padEnd(38)} sessions=${String(u.sessions).padStart(3)} asst=${String(u.assistantTurns).padStart(6)} Skill calls=${String(u.invocations).padStart(3)}`
+      `  ${path12.basename(u.store).slice(-38).padEnd(38)} sessions=${String(u.sessions).padStart(3)} asst=${String(u.assistantTurns).padStart(6)} Skill calls=${String(u.invocations).padStart(3)}`
     );
   }
   lines.push("");
@@ -5147,8 +5732,8 @@ function render3(census, usage, published = null) {
   lines.push("  catalogue once per session, then count descriptions against bare names.");
   return lines.join("\n");
 }
-var USAGE = "usage: report_skill_activation [--root DIR] [--limit N] [--store PATH]... [--emit] [--allow-empty-store]\n";
-function main10(argv) {
+var USAGE2 = "usage: report_skill_activation [--root DIR] [--limit N] [--store PATH]... [--emit] [--allow-empty-store]\n";
+function main11(argv) {
   let limit = 30;
   let emit = false;
   let allowEmpty = false;
@@ -5170,7 +5755,7 @@ function main10(argv) {
     } else if (a === "--allow-empty-store") {
       allowEmpty = true;
     } else if (a === "--help" || a === "-h") {
-      process.stdout.write(USAGE);
+      process.stdout.write(USAGE2);
       return 0;
     }
   }
@@ -5181,7 +5766,7 @@ function main10(argv) {
   if (stores.length === 0) {
     stores.push(defaultStore2(REPO_ROOT3));
   }
-  const census = censusSkills(path10.join(root, SKILLS_ROOT));
+  const census = censusSkills(path12.join(root, SKILLS_ROOT));
   const usage = stores.map((s) => measureUsage(s, limit));
   process.stdout.write(`${render3(census, usage, readRecord(root))}
 `);
@@ -5202,27 +5787,27 @@ function main10(argv) {
     return 1;
   }
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const file = path10.join(root, RECORD_PATH);
-  fs10.mkdirSync(path10.dirname(file), { recursive: true });
-  fs10.writeFileSync(file, `${JSON.stringify(buildRecord(census, usage, today), null, 2)}
+  const file = path12.join(root, RECORD_PATH);
+  fs12.mkdirSync(path12.dirname(file), { recursive: true });
+  fs12.writeFileSync(file, `${JSON.stringify(buildRecord(census, usage, today), null, 2)}
 `);
   process.stdout.write(`
 wrote ${RECORD_PATH} (measured ${today})
 `);
   return 0;
 }
-if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL10(path10.resolve(process.argv[1])).href) {
-  process.exit(main10(process.argv.slice(2)));
+if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL11(path12.resolve(process.argv[1])).href) {
+  process.exit(main11(process.argv.slice(2)));
 }
 
 // src/scripts/report_skill_obligation_violations.ts
-import * as fs11 from "node:fs";
+import * as fs13 from "node:fs";
 import * as os5 from "node:os";
-import * as path11 from "node:path";
+import * as path13 from "node:path";
 import process3 from "node:process";
-import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
-var _HERE3 = fileURLToPath11(import.meta.url);
-var REPO_ROOT4 = path11.resolve(path11.dirname(_HERE3), "..", "..");
+import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
+var _HERE4 = fileURLToPath12(import.meta.url);
+var REPO_ROOT4 = path13.resolve(path13.dirname(_HERE4), "..", "..");
 var OBLIGATION_LINE_RE = new RegExp(`${DETERMINISTIC_RE.source}.*`, "gm");
 var PATH_RE = /`([A-Za-z0-9_./-]*\/[A-Za-z0-9_.-]+\.[a-z]{2,6})`/g;
 var CMD_RE = /`([a-z][a-z0-9-]*(?: [a-z][a-z0-9:._-]*){1,3})`/g;
@@ -5260,7 +5845,7 @@ function _artefacts(line) {
   return out;
 }
 function extractObligations(repoRoot) {
-  const skillsRoot = path11.join(repoRoot, SKILLS_ROOT);
+  const skillsRoot = path13.join(repoRoot, SKILLS_ROOT);
   const census = censusSkills(skillsRoot);
   const out = {
     skills: census.withDeterministicObligation,
@@ -5274,7 +5859,7 @@ function extractObligations(repoRoot) {
   for (const skill of census.withDeterministicObligation) {
     let text;
     try {
-      text = fs11.readFileSync(path11.join(skillsRoot, skill, "SKILL.md"), "utf-8");
+      text = fs13.readFileSync(path13.join(skillsRoot, skill, "SKILL.md"), "utf-8");
     } catch {
       continue;
     }
@@ -5390,7 +5975,7 @@ function scanSessionForViolations(session, lines, forbidden, parsed) {
   return flags;
 }
 function defaultStore3(cwd) {
-  return path11.join(os5.homedir(), ".claude", "projects", projectStoreSlug(cwd));
+  return path13.join(os5.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function scanStore2(repoRoot, store, limit) {
   const census = extractObligations(repoRoot);
@@ -5403,14 +5988,14 @@ function scanStore2(repoRoot, store, limit) {
   };
   let files;
   try {
-    files = fs11.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path11.join(store, f), m: fs11.statSync(path11.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
+    files = fs13.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path13.join(store, f), m: fs13.statSync(path13.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
   } catch {
     return report;
   }
   report.sessions = files.length;
   for (const file of files) {
-    const lines = fs11.readFileSync(file, "utf-8").split("\n");
-    const id = path11.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
+    const lines = fs13.readFileSync(file, "utf-8").split("\n");
+    const id = path13.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
     const entries = _parseSession(lines);
     if (loadedSkillsFrom(entries).size > 0) report.sessionsWithASkill += 1;
     report.flags.push(...scanSessionForViolations(id, lines, census.forbidden, entries));
@@ -5480,7 +6065,7 @@ function render4(r) {
   lines.push("  ships as detection-only, and this one says so.");
   return lines.join("\n");
 }
-function main11(argv) {
+function main12(argv) {
   const args = argv ?? process3.argv.slice(2);
   let limit = 30;
   let json = false;
@@ -5533,35 +6118,35 @@ function main11(argv) {
   }
   return 0;
 }
-function _isCliEntry10() {
+function _isCliEntry11() {
   if (process3.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL11(path11.resolve(process3.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL12(path13.resolve(process3.argv[1])).href) return true;
   try {
-    return fs11.realpathSync(_HERE3) === fs11.realpathSync(path11.resolve(process3.argv[1]));
+    return fs13.realpathSync(_HERE4) === fs13.realpathSync(path13.resolve(process3.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry10()) {
-  process3.exit(main11());
+if (_isCliEntry11()) {
+  process3.exit(main12());
 }
 
 // src/scripts/report_conformance_funnel.ts
-var _HERE4 = fileURLToPath12(import.meta.url);
-var REPO_ROOT5 = path12.resolve(path12.dirname(_HERE4), "..", "..");
+var _HERE5 = fileURLToPath13(import.meta.url);
+var REPO_ROOT5 = path14.resolve(path14.dirname(_HERE5), "..", "..");
 function buildFunnel(opts = {}) {
   const repoRoot = opts.repoRoot ?? REPO_ROOT5;
-  const projectRulesDir = opts.projectRulesDir ?? path12.join(repoRoot, PROJECT_RULES);
-  const globalRulesDir = opts.globalRulesDir ?? path12.join(os6.homedir(), GLOBAL_RULES);
-  const sourceDir = opts.sourceDir ?? path12.join(repoRoot, PROJECTION_SOURCE);
+  const projectRulesDir = opts.projectRulesDir ?? path14.join(repoRoot, PROJECT_RULES);
+  const globalRulesDir = opts.globalRulesDir ?? path14.join(os6.homedir(), GLOBAL_RULES);
+  const sourceDir = opts.sourceDir ?? path14.join(repoRoot, PROJECTION_SOURCE);
   const store = opts.store ?? defaultStore(repoRoot);
   const limit = opts.limit ?? 30;
   return {
     delivered: measureDelivered(projectRulesDir, globalRulesDir),
     divergence: compareCarriers(projectRulesDir, globalRulesDir, sourceDir),
-    skills: censusSkills(path12.join(repoRoot, SKILLS_ROOT)),
+    skills: censusSkills(path14.join(repoRoot, SKILLS_ROOT)),
     usage: measureUsage(store, limit),
-    storePresent: fs12.existsSync(store),
+    storePresent: fs14.existsSync(store),
     sk2: scanStore2(repoRoot, store, limit)
   };
 }
@@ -5686,7 +6271,7 @@ function render5(r) {
   lines.push("workflow without a measured false-positive rate first (locked policy).");
   return lines.join("\n");
 }
-function main12(argv) {
+function main13(argv) {
   const args = argv ?? process4.argv.slice(2);
   const opts = {};
   const value = (i) => {
@@ -5702,7 +6287,7 @@ function main12(argv) {
 `);
         return 1;
       }
-      const resolved = path12.resolve(v);
+      const resolved = path14.resolve(v);
       if (a === "--store") opts.store = resolved;
       else if (a === "--project") opts.projectRulesDir = resolved;
       else if (a === "--global") opts.globalRulesDir = resolved;
@@ -5732,21 +6317,21 @@ function main12(argv) {
 `);
   return 0;
 }
-function _isCliEntry11() {
+function _isCliEntry12() {
   if (process4.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL12(path12.resolve(process4.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL13(path14.resolve(process4.argv[1])).href) return true;
   try {
-    return fs12.realpathSync(_HERE4) === fs12.realpathSync(path12.resolve(process4.argv[1]));
+    return fs14.realpathSync(_HERE5) === fs14.realpathSync(path14.resolve(process4.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry11()) {
-  process4.exit(main12());
+if (_isCliEntry12()) {
+  process4.exit(main13());
 }
 
 // src/scripts/_cli/cmd_conformance.ts
-var _HERE5 = fileURLToPath13(import.meta.url);
+var _HERE6 = fileURLToPath14(import.meta.url);
 var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
 var CONFORMANCE_CHECK_IDS = [
   "txlog-clean",
@@ -5756,6 +6341,10 @@ var CONFORMANCE_CHECK_IDS = [
   "host-manifest"
 ];
 var THIN_STUB_MARKER = "Routed rule \u2014 load the body on trigger-match";
+var CONFORMANCE_STATUS_SYMBOLS = {
+  ...STATUS_SYMBOLS,
+  unknown: "\u2754"
+};
 function print(s = "") {
   process5.stdout.write(`${s}
 `);
@@ -5769,30 +6358,33 @@ function conformanceLogPath() {
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path13.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
+  return path15.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
 }
 function installLogPath() {
   const override = process5.env["AGENT_CONFIG_INSTALL_LOG"];
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path13.join(os7.homedir(), ".event4u", "agent-config", "install-log.jsonl");
+  return path15.join(os7.homedir(), ".event4u", "agent-config", "install-log.jsonl");
 }
-function _check_txlog_clean(logPath = installLogPath()) {
-  if (!fs13.existsSync(logPath)) {
-    return {
-      id: "txlog-clean",
-      status: "ok",
-      message: "no install transaction log \u2014 nothing to recover",
-      remedy: ""
-    };
-  }
-  const entries = readRecentEntries(logPath);
+function _installLogExpected(projectRoot) {
+  return fs15.existsSync(manifest_path(projectRoot));
+}
+function _check_txlog_clean(logPath = installLogPath(), projectRoot = null) {
+  const entries = fs15.existsSync(logPath) ? readRecentEntries(logPath) : [];
   if (entries.length === 0) {
+    if (projectRoot !== null && _installLogExpected(projectRoot)) {
+      return {
+        id: "txlog-clean",
+        status: "unknown",
+        message: "install manifest present, no usable install transaction log \u2014 nothing recorded this install, so the last run cannot be confirmed complete",
+        remedy: "no install path writes this log today; run `agent-config doctor` for the drift answer this check cannot give"
+      };
+    }
     return {
       id: "txlog-clean",
       status: "ok",
-      message: "install transaction log is empty",
+      message: "no usable install transaction log and no install manifest \u2014 nothing was installed here",
       remedy: ""
     };
   }
@@ -5802,7 +6394,7 @@ function _check_txlog_clean(logPath = installLogPath()) {
       id: "txlog-clean",
       status: "fail",
       message: `install log tail is an abandoned run (abort at ${last.ts}${last.note ? `: ${last.note}` : ""})`,
-      remedy: "re-run `agent-config init` (recovery reverse-applies the aborted tail)"
+      remedy: "re-run `agent-config init` \u2014 it re-applies the plan over the partial tail; the aborted run's writes stay on disk and are replaced only where the plan covers them"
     };
   }
   return {
@@ -5813,11 +6405,11 @@ function _check_txlog_clean(logPath = installLogPath()) {
   };
 }
 function routeTargetPaths(target) {
-  return routeTargetPathsPosix(target).map((rel) => path13.join(...rel.split("/")));
+  return routeTargetPathsPosix(target).map((rel) => path15.join(...rel.split("/")));
 }
 function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
-  const routerPath = path13.join(packageRoot, "dist", "router.json");
-  if (!fs13.existsSync(routerPath)) {
+  const routerPath = path15.join(packageRoot, "dist", "router.json");
+  if (!fs15.existsSync(routerPath)) {
     return {
       id: "router-pointers",
       status: "fail",
@@ -5827,7 +6419,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
   }
   let router;
   try {
-    router = JSON.parse(fs13.readFileSync(routerPath, "utf8"));
+    router = JSON.parse(fs15.readFileSync(routerPath, "utf8"));
   } catch (exc) {
     return {
       id: "router-pointers",
@@ -5836,13 +6428,13 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
       remedy: "reinstall the package \u2014 dist/router.json is corrupt"
     };
   }
-  const rulesDir = path13.join(packageRoot, "dist", "agent-src", "rules");
+  const rulesDir = path15.join(packageRoot, "dist", "agent-src", "rules");
   const broken = [];
   let ids = 0;
   let targets = 0;
   for (const kernelId of router["kernel"] ?? []) {
     ids += 1;
-    if (!fs13.existsSync(path13.join(rulesDir, `${kernelId}.md`))) {
+    if (!fs15.existsSync(path15.join(rulesDir, `${kernelId}.md`))) {
       broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
     }
   }
@@ -5850,7 +6442,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
     for (const entry of router[tier] ?? []) {
       const ruleId = String(entry["id"] ?? "");
       ids += 1;
-      if (!fs13.existsSync(path13.join(rulesDir, `${ruleId}.md`))) {
+      if (!fs15.existsSync(path15.join(rulesDir, `${ruleId}.md`))) {
         broken.push(`${tier}:${ruleId} \u2192 rules/${ruleId}.md missing`);
       }
       for (const target of entry["routes_to"] ?? []) {
@@ -5860,7 +6452,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
           broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
           continue;
         }
-        if (!candidates.some((rel) => fs13.existsSync(path13.join(packageRoot, rel)))) {
+        if (!candidates.some((rel) => fs15.existsSync(path15.join(packageRoot, rel)))) {
           broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
         }
       }
@@ -5892,9 +6484,9 @@ function detectSmokePlatform(projectRoot) {
   return "claude";
 }
 function dispatcherRunner(packageRoot) {
-  const localTsx = path13.join(packageRoot, "node_modules", ".bin", "tsx");
-  const script = path13.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
-  if (fs13.existsSync(localTsx)) {
+  const localTsx = path15.join(packageRoot, "node_modules", ".bin", "tsx");
+  const script = path15.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
+  if (fs15.existsSync(localTsx)) {
     return [localTsx, script];
   }
   return ["npx", "tsx", script];
@@ -5911,7 +6503,7 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT, opts =
       ...event === "stop" ? { stop_reason: "conformance-smoke" } : { source: "startup" }
     });
     const argv = [...runner, "--platform", platform, "--event", event];
-    const proc = spawnSync2(argv[0], argv.slice(1), {
+    const proc = spawnSync4(argv[0], argv.slice(1), {
       input: payload,
       cwd: projectRoot,
       encoding: "utf8",
@@ -5944,12 +6536,12 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT, opts =
   };
 }
 function readSettingsMode(projectRoot) {
-  const settingsPath = path13.join(projectRoot, ".agent-settings.yml");
-  if (!fs13.existsSync(settingsPath)) {
+  const settingsPath = path15.join(projectRoot, ".agent-settings.yml");
+  if (!fs15.existsSync(settingsPath)) {
     return "eager-all";
   }
   try {
-    const parsed = YAML.parse(fs13.readFileSync(settingsPath, "utf8"));
+    const parsed = YAML.parse(fs15.readFileSync(settingsPath, "utf8"));
     const lean = parsed?.["lean_projection"] ?? null;
     const mode = lean?.["mode"];
     return typeof mode === "string" && mode.length > 0 ? mode : "eager-all";
@@ -5960,7 +6552,7 @@ function readSettingsMode(projectRoot) {
 function kernelIdsFromRouter(packageRoot) {
   try {
     const router = JSON.parse(
-      fs13.readFileSync(path13.join(packageRoot, "dist", "router.json"), "utf8")
+      fs15.readFileSync(path15.join(packageRoot, "dist", "router.json"), "utf8")
     );
     return new Set((router["kernel"] ?? []).map(String));
   } catch {
@@ -5977,8 +6569,8 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
       remedy: "set lean_projection.mode to 'eager-all' or 'thin' in .agent-settings.yml"
     };
   }
-  const rulesDir = projectedRulesDir ?? path13.join(projectRoot, ".augment", "rules");
-  if (!fs13.existsSync(rulesDir)) {
+  const rulesDir = projectedRulesDir ?? path15.join(projectRoot, ".augment", "rules");
+  if (!fs15.existsSync(rulesDir)) {
     return {
       id: "lean-projection",
       status: "skipped",
@@ -5987,7 +6579,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
     };
   }
   const kernel = kernelIdsFromRouter(packageRoot);
-  const files = fs13.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
+  const files = fs15.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
   const nonKernel = files.filter((f) => !kernel.has(f.replace(/\.md$/, "")));
   if (nonKernel.length === 0) {
     return {
@@ -6001,7 +6593,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
   for (const f of nonKernel) {
     let text = "";
     try {
-      text = fs13.readFileSync(path13.join(rulesDir, f), "utf8");
+      text = fs15.readFileSync(path15.join(rulesDir, f), "utf8");
     } catch {
       continue;
     }
@@ -6032,8 +6624,8 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
 function _check_host_manifest(projectRoot) {
   const detected = Object.entries(detectToolPresence(projectRoot)).filter(([, v]) => v === true).map(([k]) => k);
   const detectedNote = detected.length > 0 ? `detected surfaces: ${detected.join(", ")}` : "no surfaces detected";
-  const settingsPath = path13.join(projectRoot, ".agent-settings.yml");
-  if (!fs13.existsSync(settingsPath)) {
+  const settingsPath = path15.join(projectRoot, ".agent-settings.yml");
+  if (!fs15.existsSync(settingsPath)) {
     return {
       id: "host-manifest",
       status: "ok",
@@ -6043,7 +6635,7 @@ function _check_host_manifest(projectRoot) {
   }
   let parsed = null;
   try {
-    parsed = YAML.parse(fs13.readFileSync(settingsPath, "utf8"));
+    parsed = YAML.parse(fs15.readFileSync(settingsPath, "utf8"));
   } catch (exc) {
     return {
       id: "host-manifest",
@@ -6073,7 +6665,7 @@ function runConformanceChecks(opts = {}) {
   const projectRoot = opts.projectRoot ?? process5.cwd();
   const packageRoot = opts.packageRoot ?? PACKAGE_ROOT;
   const checks = [];
-  checks.push(_check_txlog_clean());
+  checks.push(_check_txlog_clean(installLogPath(), projectRoot));
   checks.push(_check_router_pointers(packageRoot));
   if (opts.skipDispatcher === true) {
     checks.push({
@@ -6104,14 +6696,14 @@ function appendConformanceReport(checks, projectRoot, logPath = conformanceLogPa
   } catch {
   }
 }
-var USAGE2 = "usage: agent-config conformance [-h] [--project PROJECT] [--json]\n                                [--skip-dispatcher] [--funnel]\n";
+var USAGE3 = "usage: agent-config conformance [-h] [--project PROJECT] [--json]\n                                [--skip-dispatcher] [--funnel]\n";
 function _parse(argv) {
   const opts = { project: null, json: false, skip_dispatcher: false, funnel: false };
   let i = 0;
   while (i < argv.length) {
     const a = argv[i];
     if (a === "-h" || a === "--help") {
-      process5.stdout.write(USAGE2);
+      process5.stdout.write(USAGE3);
       throw new ArgparseExit(0);
     }
     if (a === "--json") {
@@ -6125,7 +6717,7 @@ function _parse(argv) {
         opts.project = a.slice(a.indexOf("=") + 1);
       } else {
         if (i + 1 >= argv.length) {
-          process5.stderr.write(USAGE2);
+          process5.stderr.write(USAGE3);
           process5.stderr.write("agent-config conformance: error: --project expects a value\n");
           throw new ArgparseExit(2);
         }
@@ -6133,7 +6725,7 @@ function _parse(argv) {
         i += 1;
       }
     } else {
-      process5.stderr.write(USAGE2);
+      process5.stderr.write(USAGE3);
       process5.stderr.write(`agent-config conformance: error: unrecognized argument ${a}
 `);
       throw new ArgparseExit(2);
@@ -6142,7 +6734,7 @@ function _parse(argv) {
   }
   return opts;
 }
-function main13(argv = null) {
+function main14(argv = null) {
   const opts = _parse(argv !== null ? Array.from(argv) : process5.argv.slice(2));
   if (opts.funnel) {
     print(render5(buildFunnel()));
@@ -6197,7 +6789,7 @@ function main13(argv = null) {
     print(`  \u{1F4CD}  project_root: ${project_root}`);
     print("conformance:");
     for (const c of allChecks) {
-      const sym = STATUS_SYMBOLS[c["status"]] ?? "?";
+      const sym = CONFORMANCE_STATUS_SYMBOLS[c["status"]] ?? "?";
       print(`  ${sym} ${c["id"]}: ${c["message"]}`);
       if (c["status"] !== "ok" && c["remedy"]) {
         print(`      fix: ${c["remedy"]}`);
@@ -6213,25 +6805,25 @@ function main13(argv = null) {
   }
   return failed ? 1 : 0;
 }
-function _isCliEntry12() {
+function _isCliEntry13() {
   if (process5.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL13(path13.resolve(process5.argv[1])).href;
+  const argvUrl = pathToFileURL14(path15.resolve(process5.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs13.realpathSync(fileURLToPath13(import.meta.url));
-    const argv = fs13.realpathSync(path13.resolve(process5.argv[1]));
+    const here = fs15.realpathSync(fileURLToPath14(import.meta.url));
+    const argv = fs15.realpathSync(path15.resolve(process5.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry12() || process5.argv[1] === _HERE5) {
+if (_isCliEntry13() || process5.argv[1] === _HERE6) {
   try {
-    process5.exitCode = main13(process5.argv.slice(2));
+    process5.exitCode = main14(process5.argv.slice(2));
   } catch (e) {
     if (e instanceof ArgparseExit) {
       process5.exitCode = e.code;
@@ -6249,12 +6841,13 @@ export {
   _check_lean_projection,
   _check_router_pointers,
   _check_txlog_clean,
+  _installLogExpected,
   _parse,
   appendConformanceReport,
   conformanceLogPath,
   detectSmokePlatform,
   installLogPath,
-  main13 as main,
+  main14 as main,
   routeTargetPaths,
   runConformanceChecks
 };