@event4u/agent-config 9.36.0 → 10.1.0

package/dist/cli-delegate/cmd_conformance.js

@@ -19,7 +19,7 @@ import {
   frontmatterPaths,
   proseEqual,
   splitFrontmatter
-} from "./chunk-SFGARMAB.js";
+} from "./chunk-2H5SE7DU.js";
 import "./chunk-FTAISGDQ.js";
 import {
   atomic_write_json,
@@ -27,7 +27,7 @@ import {
   is_replay_mode
 } from "./chunk-EJITJBJX.js";
 import "./chunk-Q26HT4QT.js";
-import "./chunk-55RI5UXK.js";
+import "./chunk-XT2YTJCZ.js";
 import "./chunk-PZWRPRWP.js";
 import "./chunk-M2DPGFZ4.js";
 import {
@@ -37,7 +37,7 @@ import {
 } from "./chunk-63WSP6YZ.js";
 import "./chunk-GRRPEPRN.js";
 import "./chunk-NXFWFAYV.js";
-import "./chunk-JEJABGKB.js";
+import "./chunk-XTC5ARB6.js";
 import "./chunk-NDJLNC6Q.js";
 import {
   detectToolPresence
@@ -54,12 +54,12 @@ import {
 
 // src/scripts/_cli/cmd_conformance.ts
 var YAML = __toESM(require_dist(), 1);
-import * as fs11 from "node:fs";
-import * as os6 from "node:os";
-import * as path11 from "node:path";
+import * as fs13 from "node:fs";
+import * as os7 from "node:os";
+import * as path13 from "node:path";
 import process5 from "node:process";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
+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";
@@ -120,18 +120,18 @@ function routeTargetPathsPosix(target) {
 }
 
 // src/scripts/report_conformance_funnel.ts
-import * as fs10 from "node:fs";
-import * as os5 from "node:os";
-import * as path10 from "node:path";
+import * as fs12 from "node:fs";
+import * as os6 from "node:os";
+import * as path12 from "node:path";
 import process4 from "node:process";
-import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
+import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
 
 // src/scripts/conformance_scan.ts
-import { createHash } from "node:crypto";
-import fs6 from "node:fs";
-import os from "node:os";
-import path6 from "node:path";
-import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL6 } from "node:url";
+import { createHash as createHash3 } from "node:crypto";
+import fs8 from "node:fs";
+import os2 from "node:os";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
 
 // src/scripts/_lib/transcript_entry.ts
 function _isObject(v) {
@@ -1037,6 +1037,14 @@ function _empty_state() {
     verified_this_turn: false,
     ci_saw_pending: false,
     nonevidence_this_turn: 0,
+    // Round 7 § Phase 1 — the last CI read, SESSION-scoped on purpose. Every
+    // other counter here is turn-scoped because a stale POSITIVE would wrongly
+    // vouch ("I verified"). This one is a NEGATIVE ("CI was not settled"), and a
+    // stale negative only ever refuses more often — so surviving the turn
+    // boundary preserves the freshness invariant rather than bypassing it. It
+    // has to survive it: the measured failure is a completion claim in a LATER
+    // turn than the poll it rests on.
+    ci_last: null,
     checked_at: _now()
   };
 }
@@ -1164,6 +1172,7 @@ function _update(state, event, envelope) {
   if (session_id && session_id !== state["session_id"]) {
     state["session_id"] = session_id;
     state["verifications_this_session"] = 0;
+    state["ci_last"] = null;
     state = _reset_turn(state, session_id);
   }
   let payload = envelope["payload"];
@@ -1189,6 +1198,12 @@ function _update(state, event, envelope) {
         } else {
           counts = false;
         }
+        state["ci_last"] = {
+          at: _now(),
+          command: cmd.slice(0, 512),
+          pending,
+          settled: pending === 0 && counts === true
+        };
       }
       state["last_verification"] = {
         command: cmd.slice(0, 512),
@@ -1302,15 +1317,758 @@ if (isCliEntry) {
   process.exit(main4(process.argv.slice(2)));
 }
 
-// src/scripts/hooks/evidence_independence.ts
-import crypto from "node:crypto";
-import fs5 from "node:fs";
-import path5 from "node:path";
+// src/scripts/hooks/turn_end_gate_hook.ts
+import * as crypto2 from "node:crypto";
+import * as fs6 from "node:fs";
+import * as path6 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";
+import * as fs5 from "node:fs";
+import * as os from "node:os";
+import * as path5 from "node:path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
-var EXIT_ALLOW4 = 0;
+
+// src/scripts/_lib/review_skipped_record.ts
+function isNonNegInt(n) {
+  return typeof n === "number" && Number.isFinite(n) && Number.isInteger(n) && n >= 0;
+}
+var HIGH_RISK_DIFF_LINES = 200;
+function buildReviewSkippedLine(input) {
+  const errors = [];
+  if (!isNonNegInt(input.diff_lines)) {
+    errors.push("diff_lines must be a non-negative integer");
+  }
+  if (input.mutation_measure !== "exact" && input.mutation_measure !== "capped_approximation") {
+    errors.push('mutation_measure must be "exact" or "capped_approximation"');
+  }
+  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 (errors.length) return { line: null, errors };
+  const line = {
+    schema_version: 1,
+    id: input.id,
+    ts: input.ts,
+    work_id: input.work_id ?? `review-skipped-${input.ts}`,
+    phase: "report",
+    outcome: "skipped",
+    confidence_band: "medium",
+    risk_class: input.diff_lines >= HIGH_RISK_DIFF_LINES ? "high" : "medium",
+    memory: { asks: 0, hits: 0 },
+    verify: { claims: 0, first_try_passes: 0 },
+    rules_applied: ["delegation-policy"],
+    persona: null,
+    input_kind: "prompt",
+    type: "note",
+    review_skipped: { diff_lines: input.diff_lines, mutation_measure: input.mutation_measure }
+  };
+  return { line, errors: [] };
+}
+
+// src/scripts/hooks/envelope.ts
+var ENVELOPE_KEYS = [
+  "schema_version",
+  "platform",
+  "event",
+  "payload"
+];
+function _isObject5(obj) {
+  return typeof obj === "object" && obj !== null && !Array.isArray(obj);
+}
+function looks_like_envelope(obj) {
+  if (!_isObject5(obj)) {
+    return false;
+  }
+  return ENVELOPE_KEYS.every((key) => key in obj);
+}
+function unwrap(stdin_text, default_platform = "generic") {
+  const text = (stdin_text ?? "").trim();
+  if (!text) {
+    return [{}, {}, default_platform];
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(text);
+  } catch {
+    return [{}, {}, default_platform];
+  }
+  if (looks_like_envelope(decoded)) {
+    const env = decoded;
+    let payload2 = env["payload"];
+    if (!payload2 || !_isObject5(payload2)) {
+      payload2 = {};
+    }
+    const platRaw = env["platform"];
+    const platform = String(platRaw || default_platform);
+    return [env, payload2, platform];
+  }
+  const payload = _isObject5(decoded) ? decoded : {};
+  return [
+    {
+      schema_version: 1,
+      platform: default_platform,
+      event: "",
+      native_event: "",
+      session_id: "",
+      workspace_root: "",
+      payload,
+      settings: {}
+    },
+    payload,
+    default_platform
+  ];
+}
+
+// src/scripts/hooks/end_review_nudge_hook.ts
+var MUTATION_LINE_THRESHOLD = 50;
+var UNTRACKED_FILE_CAP = 20;
+var TRANSCRIPT_SCAN_MAX_BYTES = 50 * 1024 * 1024;
+function isSafeTranscriptPath(rawPath, opts = {}) {
+  if (!rawPath || !/\.jsonl$/i.test(rawPath)) return false;
+  const homeDir = opts.homeDir ?? os.homedir();
+  const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
+  try {
+    const realHome = fs5.realpathSync(homeDir);
+    const realPath = fs5.realpathSync(rawPath);
+    const relative2 = path5.relative(realHome, realPath);
+    if (relative2 === "" || relative2.startsWith("..") || path5.isAbsolute(relative2)) {
+      return false;
+    }
+    const { size } = fs5.statSync(realPath);
+    return size <= maxBytes;
+  } catch {
+    return false;
+  }
+}
+var EXIT_WARN2 = 2;
+function parseNumstat(raw) {
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    const m = /^(\d+|-)\t(\d+|-)\t(.+)$/.exec(line);
+    if (!m) continue;
+    const addedStr = m[1];
+    const deletedStr = m[2];
+    rows.push({
+      added: addedStr === "-" ? 0 : Number(addedStr),
+      deleted: deletedStr === "-" ? 0 : Number(deletedStr),
+      path: m[3]
+    });
+  }
+  return rows;
+}
+var DOC_PATH_RE = /\.md$/i;
+function isDocPath(p) {
+  return DOC_PATH_RE.test(p);
+}
+function nonDocMutatedLines(rows) {
+  return rows.filter((r) => !isDocPath(r.path)).reduce((sum, r) => sum + r.added + r.deleted, 0);
+}
+function gitNumstatRows(cwd) {
+  try {
+    const r = spawnSync("git", ["diff", "--numstat", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      maxBuffer: 16 * 1024 * 1024
+    });
+    if (r.status !== 0) return [];
+    return parseNumstat(r.stdout ?? "");
+  } catch {
+    return [];
+  }
+}
+function untrackedNonDocFiles(cwd) {
+  try {
+    const r = spawnSync("git", ["ls-files", "--others", "--exclude-standard"], {
+      cwd,
+      encoding: "utf8",
+      maxBuffer: 16 * 1024 * 1024
+    });
+    if (r.status !== 0) return [];
+    return (r.stdout ?? "").split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !isDocPath(l));
+  } catch {
+    return [];
+  }
+}
+function untrackedFileLineCount(cwd, relPath) {
+  try {
+    const r = spawnSync("git", ["diff", "--numstat", "--no-index", "/dev/null", relPath], {
+      cwd,
+      encoding: "utf8",
+      maxBuffer: 16 * 1024 * 1024
+    });
+    return parseNumstat(r.stdout ?? "").reduce((sum, row) => sum + row.added + row.deleted, 0);
+  } catch {
+    return 0;
+  }
+}
+function totalNonDocMutatedLinesWithMeasure(cwd) {
+  const trackedLines = nonDocMutatedLines(gitNumstatRows(cwd));
+  const untracked = untrackedNonDocFiles(cwd);
+  if (untracked.length > UNTRACKED_FILE_CAP) {
+    return { lines: MUTATION_LINE_THRESHOLD + 1 + trackedLines, measure: "capped_approximation" };
+  }
+  const untrackedLines = untracked.reduce(
+    (sum, relPath) => sum + untrackedFileLineCount(cwd, relPath),
+    0
+  );
+  return { lines: trackedLines + untrackedLines, measure: "exact" };
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function str(v) {
+  return typeof v === "string" ? v : "";
+}
+var DISPATCH_TOOL_RE = /^(agent|task)$/i;
+var REVIEW_SHAPED_LABEL_RE = /\b(review|judge|adversarial|critique|second[- ]opinion|blind\s+(pass|review)|cross-model)\b/i;
+var REVIEW_SHAPED_PROMPT_RE = /\b(code\s+review|neutral\s+review|adversarial|judge|critique|second[- ]opinion|blind\s+(pass|review)|cross-model)\b/i;
+var REVIEW_SKILL_NAME_RE = /^(review[-:]changes|judge[-:][a-z0-9-]+|adversarial-review|code-review)$/i;
+function scanTranscriptForReviewer(transcriptText) {
+  for (const raw of transcriptText.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isObject(obj) || obj["type"] !== "assistant") continue;
+    const msg = obj["message"];
+    if (!isObject(msg)) continue;
+    const content = msg["content"];
+    if (!Array.isArray(content)) continue;
+    for (const blk of content) {
+      if (!isObject(blk) || blk["type"] !== "tool_use") continue;
+      const name = str(blk["name"]);
+      const input = blk["input"];
+      const inputObj = isObject(input) ? input : {};
+      if (DISPATCH_TOOL_RE.test(name)) {
+        const label = [
+          str(inputObj["description"]),
+          str(inputObj["subagent_type"])
+        ].filter(Boolean).join(" ");
+        if (REVIEW_SHAPED_LABEL_RE.test(label)) return true;
+        const prompt = str(inputObj["prompt"]);
+        if (REVIEW_SHAPED_PROMPT_RE.test(prompt)) return true;
+        continue;
+      }
+      if (/^skill$/i.test(name)) {
+        const skillName = str(inputObj["skill"]) || str(inputObj["name"]) || str(inputObj["command"]);
+        if (REVIEW_SKILL_NAME_RE.test(skillName)) return true;
+        continue;
+      }
+      if (REVIEW_SKILL_NAME_RE.test(name)) return true;
+    }
+  }
+  return false;
+}
+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) {
+  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()
+  });
+  if (errors.length || line === null) return;
+  try {
+    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 path5.join(workspaceRoot, "agents", "runtime", "state", "end-review-nudge");
+}
+function sessionStateFile(workspaceRoot, sessionKey) {
+  return path5.join(sessionStateDir(workspaceRoot), `${sessionKey}.json`);
+}
+function deriveSessionKey(envelope, payload) {
+  const raw = str(envelope["session_id"]) || str(payload["transcript_path"] ?? payload["transcriptPath"]);
+  const material = raw || "unknown-session";
+  return crypto.createHash("sha256").update(material).digest("hex");
+}
+function hasFiredThisSession(workspaceRoot, sessionKey) {
+  try {
+    return fs5.existsSync(sessionStateFile(workspaceRoot, sessionKey));
+  } catch {
+    return false;
+  }
+}
+function markFiredThisSession(workspaceRoot, sessionKey, ts) {
+  try {
+    atomic_write_json(sessionStateFile(workspaceRoot, sessionKey), { fired_at: ts });
+  } catch {
+  }
+}
+function _read_stdin() {
+  return readHookStdin();
+}
+function main5() {
+  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 mutationMeasure;
+  try {
+    const measured = totalNonDocMutatedLinesWithMeasure(workspace_root);
+    diffLines = measured.lines;
+    mutationMeasure = measured.measure;
+  } catch {
+    return 0;
+  }
+  if (diffLines <= MUTATION_LINE_THRESHOLD) {
+    return 0;
+  }
+  const sessionKey = deriveSessionKey(envelope, payload);
+  if (hasFiredThisSession(workspace_root, sessionKey)) {
+    return 0;
+  }
+  const transcriptPath = str(
+    payload["transcript_path"] ?? payload["transcriptPath"]
+  ).trim();
+  let reviewerRan = false;
+  if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
+    try {
+      reviewerRan = scanTranscriptForReviewer(fs5.readFileSync(transcriptPath, "utf-8"));
+    } catch {
+      reviewerRan = false;
+    }
+  }
+  if (reviewerRan) {
+    return 0;
+  }
+  markFiredThisSession(workspace_root, sessionKey, (/* @__PURE__ */ new Date()).toISOString());
+  try {
+    appendReviewSkippedTelemetry(workspace_root, diffLines, mutationMeasure);
+  } catch {
+  }
+  process.stdout.write(
+    `${JSON.stringify({
+      decision: "warn",
+      reason: `end-review-nudge: session mutated ${diffLines} non-doc lines without a neutral review`,
+      additional_context: buildAdvisoryLine(diffLines)
+    })}
+`
+  );
+  return EXIT_WARN2;
+}
+function _isCliEntry5() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL5(path5.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]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry5()) {
+  process.exit(main5());
+}
+
+// src/scripts/hooks/turn_end_gate_hook.ts
 var EXIT_BLOCK2 = 1;
-var STATE_FILE4 = path5.join("agents", "state", "evidence-dispatch.json");
-function _isObject5(v) {
+var EXIT_ALLOW4 = 0;
+var TRANSCRIPT_READ_MAX_BYTES = 8 * 1024 * 1024;
+function stripFencedBlocks(text) {
+  const out = [];
+  let open = null;
+  for (const line of text.split("\n")) {
+    const m = /^[ \t]{0,3}([`~]{3,})(.*)$/.exec(line);
+    if (open === null) {
+      if (m) {
+        open = { ch: m[1][0], len: m[1].length };
+        out.push(" ");
+        continue;
+      }
+      out.push(line);
+      continue;
+    }
+    if (m && m[1][0] === open.ch && m[1].length >= open.len && (m[2] ?? "").trim() === "") {
+      open = null;
+    }
+  }
+  return out.join("\n");
+}
+function visibleProse(reply) {
+  let text = stripFencedBlocks(reply);
+  text = text.replace(/`[^`\n]*`/g, " ");
+  text = text.replace(/^[ \t]*>.*$/gm, " ");
+  text = text.replace(/^[ \t]*\|.*\|[ \t]*$/gm, " ");
+  text = text.replace(/\bhttps?:\/\/\S+/g, " ");
+  text = text.replace(/\S*\/\S+/g, " ");
+  text = text.replace(/\b[\w.-]+\.(ts|js|md|json|ya?ml|py|php|txt|sh)\b/g, " ");
+  return text;
+}
+function finalParagraph(reply) {
+  const prose = visibleProse(reply).trim();
+  if (!prose) return "";
+  const paragraphs = prose.split(/\n\s*\n/).map((p) => p.trim()).filter((p) => p.length > 0);
+  return paragraphs.length === 0 ? "" : paragraphs[paragraphs.length - 1];
+}
+var PROMISSORY = [
+  /\bich melde mich\b/i,
+  /\bmelde ich (mich|dir|Dir)\b/i,
+  /\bich melde\b/i,
+  /\bich berichte\b/i,
+  /\bich (sage|gebe) (dir |Dir )?Bescheid\b/i,
+  /\bals n(ä|ae)chstes (werde|mache|baue|pr(ü|ue)fe) ich\b/i,
+  // German puts the infinitive at the END of the clause ("ich werde jetzt
+  // die Tests schreiben"), so the verb cannot be matched adjacent to
+  // "werde" — it has to be looked for across the rest of the sentence.
+  //
+  // The lookahead excludes a stated REFUSAL to act: declining to do
+  // something is not a promise to do it. R2 finding 4 reproduced four live
+  // false refusals against the old `\bnicht\b`-only version — "Ich werde
+  // nichts anfassen" (no word boundary after `nicht`), "keine Tests
+  // schreiben", "niemals raten", and the passive non-promise "Ich werde
+  // gefragt, ob …". Each was a false refusal on a BLOCKING guard, which is
+  // the precision failure the council warning is about.
+  // `\p{L}` with the `u` flag, NOT `\w`: R2 round 2, finding 15 verified that
+  // `\b\w{3,}en\b` cannot reach an infinitive whose post-umlaut fragment is
+  // short, because `ü`/`ö`/`ä` are not `\w` and create a word boundary — so
+  // "prüfen" and "lösen" were silent while the comment above claimed the
+  // verb-final construction was handled.
+  //
+  // Honest about what this proxy matches: any word of 3+ letters ending in
+  // "en" within the clause, which is the infinitive in practice but also hits
+  // a plural noun ("die Zeilen zählen" matches on "Zeilen"). That is
+  // acceptable here — the clause already requires "ich werde" and excludes
+  // negations and passives, so a forward commitment is what remains — but it
+  // is a proxy for the infinitive, not a parse of one.
+  new RegExp("\\bich werde\\b(?![^.!?\\n]*\\b(?:nicht|nichts|kein(?:e|en|em|er|es)?|niemals|nie)\\b)(?![^.!?\\n]*\\b(?:gefragt|gebeten|informiert|benachrichtigt)\\b)[^.!?\\n]*(?<!\\p{L})\\p{L}{3,}en(?!\\p{L})", "iu"),
+  /\bI(?:'| wi)ll (report|let you know|update you|follow up)\b/i,
+  /\bI(?:'| wi)ll (now |then )?\w+ (it|that|this|next)\b/i,
+  /\bnext,? I(?:'| wi)ll\b/i,
+  /\bI am going to\b/i
+];
+var HANDBACK = [
+  /\bdas entscheidest (du|Du)\b/i,
+  /\bdeine Entscheidung\b/i,
+  /\bich fasse .{0,40}nicht ungefragt an\b/i,
+  /\bsag (Bescheid|ein Wort)\b/i,
+  /\bwarte auf (deine|Deine|dein|Dein)\b/i,
+  /\byour call\b/i,
+  /\byou decide\b/i,
+  /\blet me know (which|if|whether)\b/i,
+  /\bwaiting for your\b/i
+];
+function detectPromissory(reply) {
+  const tail = finalParagraph(reply);
+  if (!tail) return null;
+  if (/\?["'’)\]]*\s*$/.test(tail)) return null;
+  if (HANDBACK.some((re) => re.test(tail))) return null;
+  for (const re of PROMISSORY) {
+    const m = tail.match(re);
+    if (m) {
+      return {
+        detector: "promissory",
+        evidence: m[0],
+        reason: "the closing paragraph promises work that has not been performed, and the turn asks the user nothing \u2014 so nothing ends this turn but the promise itself"
+      };
+    }
+  }
+  return null;
+}
+function readCiSettled(workspaceRoot) {
+  try {
+    const raw = fs6.readFileSync(path6.join(workspaceRoot, STATE_FILE3), "utf-8");
+    const decoded = JSON.parse(raw);
+    if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
+      const ci = decoded["ci_last"];
+      if (typeof ci === "object" && ci !== null && !Array.isArray(ci)) {
+        return { seen: true, settled: ci["settled"] === true };
+      }
+    }
+  } catch {
+  }
+  return { seen: false, settled: false };
+}
+var _COMPLETION_RE = /(^|\n)\s*(?:\*\*)?(?:fertig\b|damit ist alles erledigt|aufgabe erledigt|alles erledigt\b|komplett(?:er)? (?:auftrag|abgearbeitet)|der komplette auftrag ist durch|done[.!]|all done\b|task complete)/i;
+function detectCompletionClaim(reply, ci) {
+  if (!ci.seen || ci.settled) return null;
+  const prose = visibleProse(reply);
+  const m = _COMPLETION_RE.exec(prose);
+  if (!m) return null;
+  const at = m.index;
+  return {
+    detector: "completion",
+    evidence: prose.slice(at, at + 120).trim(),
+    reason: "a completion claim while the last CI read was not settled \u2014 read the verdict, then claim it (verify-before-complete)"
+  };
+}
+function readLanguagePin(workspaceRoot) {
+  try {
+    const raw = fs6.readFileSync(path6.join(workspaceRoot, STATE_FILE), "utf-8");
+    const decoded = JSON.parse(raw);
+    if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
+      const lang = decoded["language"];
+      if (lang === "de" || lang === "en") return lang;
+    }
+  } catch {
+  }
+  return "und";
+}
+function detectLanguage(reply, pinned) {
+  if (pinned !== "de" && pinned !== "en") return null;
+  const prose = visibleProse(reply);
+  const verdict = classify(prose);
+  if (verdict.language === "und") return null;
+  if (verdict.language === pinned) return null;
+  return {
+    detector: "language",
+    evidence: prose.trim().slice(0, 120),
+    reason: `the pinned reply language is "${pinned}" but the reply classifies as "${verdict.language}" (${verdict.de_markers} de / ${verdict.en_markers} en markers; code, quotes, tables, URLs and paths excluded, then scored lead-first by the same classifier that sets the pin)`
+  };
+}
+var _EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var _VERIFY_RE = /\b(test|tests|vitest|jest|pytest|phpunit|pest|tsc|eslint|ruff|mypy|pyright|clippy|typecheck|lint|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 isVerificationCommand(command) {
+  return _VERIFY_RE.test(command);
+}
+function detectUnverifiedEdit(toolCalls) {
+  let lastEdit = -1;
+  for (let i = 0; i < toolCalls.length; i += 1) {
+    if (_EDIT_TOOLS.has(toolCalls[i].name)) lastEdit = i;
+  }
+  if (lastEdit === -1) return null;
+  for (let i = lastEdit + 1; i < toolCalls.length; i += 1) {
+    const c = toolCalls[i];
+    if (c.name === "Bash" && c.command !== void 0 && isVerificationCommand(c.command)) {
+      return null;
+    }
+  }
+  const edited = toolCalls[lastEdit].path;
+  return {
+    detector: "verification",
+    // The path, never the diff: the evidence span is quoted into a refusal,
+    // and `ToolCall` is shaped so a file body cannot reach it.
+    evidence: edited ?? toolCalls[lastEdit].name,
+    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)"
+  };
+}
+function stateDir(workspaceRoot) {
+  return path6.join(workspaceRoot, "agents", "runtime", "state", "turn-end-gate");
+}
+function sessionStateFile2(workspaceRoot, sessionKey) {
+  return path6.join(stateDir(workspaceRoot), `${sessionKey}.json`);
+}
+function deriveSessionKey2(sessionId) {
+  return crypto2.createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
+}
+function alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal) {
+  try {
+    const raw = fs6.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;
+    }
+  } catch {
+  }
+  return false;
+}
+function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detector) {
+  if (is_replay_mode()) return;
+  try {
+    atomic_write_json(sessionStateFile2(workspaceRoot, sessionKey), {
+      refused_at: (/* @__PURE__ */ new Date()).toISOString(),
+      refused_turn: turnOrdinal,
+      detector
+    });
+  } catch {
+  }
+}
+function readTranscriptTail(transcriptPath, opts = {}) {
+  const empty = { lastAssistant: "", turnOrdinal: 0, toolCalls: [] };
+  if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
+  let lines;
+  try {
+    if (opts.maxBytes !== void 0 && fs6.statSync(transcriptPath).size > opts.maxBytes) {
+      return empty;
+    }
+    lines = fs6.readFileSync(transcriptPath, "utf-8").split("\n");
+  } catch {
+    return empty;
+  }
+  let lastAssistant = "";
+  let turnOrdinal = 0;
+  let toolCalls = [];
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) continue;
+    const entry = obj;
+    if (entry["isSidechain"] === true) continue;
+    const role = entry["type"];
+    if (role !== "assistant" && role !== "user") continue;
+    const msg = entry["message"];
+    if (typeof msg !== "object" || msg === null || Array.isArray(msg)) continue;
+    const content = msg["content"];
+    if (role === "assistant") {
+      toolCalls.push(..._toolCalls(content));
+    }
+    const text = _messageText(content);
+    if (text === null) continue;
+    if (role === "assistant") {
+      lastAssistant = text;
+    } else if (!isSyntheticPrompt(text)) {
+      turnOrdinal += 1;
+      toolCalls = [];
+    }
+  }
+  return { lastAssistant: lastAssistant.trim(), turnOrdinal, toolCalls };
+}
+function _toolCalls(content) {
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const blk of content) {
+    if (typeof blk !== "object" || blk === null || Array.isArray(blk)) continue;
+    const b = blk;
+    if (b["type"] !== "tool_use") continue;
+    const name = b["name"];
+    if (typeof name !== "string") continue;
+    const input = b["input"];
+    const call = { name };
+    if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+      const inp = input;
+      const cmd = inp["command"];
+      if (typeof cmd === "string") call.command = cmd;
+      const p = inp["file_path"] ?? inp["path"] ?? inp["notebook_path"];
+      if (typeof p === "string") call.path = p;
+    }
+    out.push(call);
+  }
+  return out;
+}
+function _messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const blk of content) {
+    if (typeof blk !== "object" || blk === null || Array.isArray(blk)) continue;
+    const b = blk;
+    if (b["type"] !== "text") continue;
+    const t = b["text"];
+    if (typeof t === "string") parts.push(t);
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+function str2(v) {
+  return typeof v === "string" ? v : "";
+}
+function main6() {
+  let envelope;
+  let payload;
+  try {
+    [envelope, payload] = unwrap(readHookStdin(), "claude");
+  } catch {
+    return EXIT_ALLOW4;
+  }
+  if (payload["stop_hook_active"] === true) return EXIT_ALLOW4;
+  const workspaceRoot = str2(envelope["workspace_root"]) || process.cwd();
+  const transcriptPath = str2(
+    payload["transcript_path"] ?? payload["transcriptPath"]
+  );
+  const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
+    maxBytes: TRANSCRIPT_READ_MAX_BYTES
+  });
+  if (!lastAssistant) return EXIT_ALLOW4;
+  const sessionKey = deriveSessionKey2(
+    str2(envelope["session_id"]) || "unknown-session"
+  );
+  if (alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal)) return EXIT_ALLOW4;
+  const findings = [];
+  for (const f of [
+    detectPromissory(lastAssistant),
+    detectLanguage(lastAssistant, readLanguagePin(workspaceRoot)),
+    detectUnverifiedEdit(toolCalls),
+    // Round 7 § Phase 1 — detector D, in the same unconditional list as the
+    // other three. It shipped with its own settings flag one commit earlier
+    // and that flag is gone: `hooks.turn_end_gate.*` was deleted on
+    // 2026-08-12 because a default-off safety gate is an absent one. Its
+    // 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.
+    detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot))
+  ]) {
+    if (f) findings.push(f);
+  }
+  if (findings.length === 0) return EXIT_ALLOW4;
+  markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, findings[0].detector);
+  const lines = findings.map(
+    (f) => `  \xB7 ${f.detector}: ${f.reason}
+    evidence: ${JSON.stringify(f.evidence)}`
+  );
+  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.
+  This turn will not be refused a second time.
+`
+  );
+  return EXIT_BLOCK2;
+}
+function _isCliEntry6() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL6(path6.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]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry6()) {
+  process.exit(main6());
+}
+
+// src/scripts/hooks/evidence_independence.ts
+import crypto3 from "node:crypto";
+import fs7 from "node:fs";
+import path7 from "node:path";
+import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL7 } from "node:url";
+var EXIT_ALLOW5 = 0;
+var EXIT_BLOCK3 = 1;
+var STATE_FILE4 = path7.join("agents", "state", "evidence-dispatch.json");
+function _isObject6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var DISPATCH_TOOLS = /* @__PURE__ */ new Set([
@@ -1363,10 +2121,10 @@ function preloadedVerdict(prompt) {
   return null;
 }
 function extractDispatch(envelope) {
-  const payload = _isObject5(envelope["payload"]) ? envelope["payload"] : envelope;
+  const payload = _isObject6(envelope["payload"]) ? envelope["payload"] : envelope;
   const toolRaw = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"];
   const tool = typeof toolRaw === "string" ? toolRaw : null;
-  const input = _isObject5(payload["tool_input"]) ? payload["tool_input"] : _isObject5(payload["toolInput"]) ? payload["toolInput"] : payload;
+  const input = _isObject6(payload["tool_input"]) ? payload["tool_input"] : _isObject6(payload["toolInput"]) ? payload["toolInput"] : payload;
   for (const key of ["prompt", "instructions", "task", "description"]) {
     const v = input[key];
     if (typeof v === "string" && v.trim()) {
@@ -1377,8 +2135,8 @@ function extractDispatch(envelope) {
 }
 function _ledgerStamp(consumer_root) {
   try {
-    const raw = fs5.readFileSync(
-      path5.join(consumer_root, "agents", "state", "git-authorization.json"),
+    const raw = fs7.readFileSync(
+      path7.join(consumer_root, "agents", "state", "git-authorization.json"),
       "utf8"
     );
     const d = JSON.parse(raw);
@@ -1389,8 +2147,8 @@ function _ledgerStamp(consumer_root) {
 }
 function _load(target) {
   try {
-    const decoded = JSON.parse(fs5.readFileSync(target, "utf8"));
-    if (_isObject5(decoded) && Array.isArray(decoded["evaluations"])) {
+    const decoded = JSON.parse(fs7.readFileSync(target, "utf8"));
+    if (_isObject6(decoded) && Array.isArray(decoded["evaluations"])) {
       return decoded;
     }
   } catch {
@@ -1400,12 +2158,12 @@ function _load(target) {
 var WARN_TEXT = "First evaluation dispatch this turn. Two shapes fabricated a binding honest-null in the audited sessions \u2014 check your prompt for both before it goes out: (1) a verdict pre-loaded into the prompt, and (2) a scope narrowed to files you chose. A review you commissioned on your own work is admissible as gate evidence only when the prompt is recorded alongside the verdict.";
 function decide2(tool, prompt, priorEvaluations) {
   if (!isDispatchTool(tool) || !isEvaluationPrompt(prompt)) {
-    return { exit: EXIT_ALLOW4, stdout: "", stderr: "", evaluations: priorEvaluations };
+    return { exit: EXIT_ALLOW5, stdout: "", stderr: "", evaluations: priorEvaluations };
   }
   const preloaded = preloadedVerdict(prompt);
   if (preloaded !== null) {
     return {
-      exit: EXIT_BLOCK2,
+      exit: EXIT_BLOCK3,
       stdout: "",
       stderr: `Blocked: this evaluation prompt pre-loads its verdict ("${preloaded}"). That is the construct that produced a fabricated NO-FINDINGS committed as binding gate evidence, over a delta an unsteered pass then found a live critical in. Remove the expectation from the prompt and let the evaluator reach its own verdict.
 `,
@@ -1413,11 +2171,11 @@ function decide2(tool, prompt, priorEvaluations) {
     };
   }
   if (!isSelfScoped(prompt)) {
-    return { exit: EXIT_ALLOW4, stdout: "", stderr: "", evaluations: priorEvaluations };
+    return { exit: EXIT_ALLOW5, stdout: "", stderr: "", evaluations: priorEvaluations };
   }
   if (priorEvaluations >= 1) {
     return {
-      exit: EXIT_BLOCK2,
+      exit: EXIT_BLOCK3,
       stdout: "",
       stderr: `Blocked: second evaluation dispatch of your own work in this turn (verdict shopping). One evaluation has already run; commissioning another with a different prompt or scope selects the answer instead of measuring it. Report what the first pass returned, then re-plan.
 `,
@@ -1425,7 +2183,7 @@ function decide2(tool, prompt, priorEvaluations) {
     };
   }
   return {
-    exit: EXIT_ALLOW4,
+    exit: EXIT_ALLOW5,
     stdout: `${JSON.stringify({ decision: "warn", reason: WARN_TEXT })}
 `,
     stderr: "",
@@ -1437,14 +2195,14 @@ function run5(stdin_text, options) {
   if (stdin_text.trim()) {
     try {
       const decoded = JSON.parse(stdin_text);
-      if (_isObject5(decoded)) {
+      if (_isObject6(decoded)) {
         envelope = decoded;
       }
     } catch {
-      return EXIT_ALLOW4;
+      return EXIT_ALLOW5;
     }
   }
-  const target = path5.join(options.consumer_root, STATE_FILE4);
+  const target = path7.join(options.consumer_root, STATE_FILE4);
   const state = _load(target);
   const session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
   const turnMarker = `${session_id}:${_ledgerStamp(options.consumer_root)}`;
@@ -1458,7 +2216,7 @@ function run5(stdin_text, options) {
   if (decision.evaluations > state.evaluations.length) {
     state.evaluations.push({
       at: (/* @__PURE__ */ new Date()).toISOString(),
-      digest: crypto.createHash("sha256").update(prompt).digest("hex").slice(0, 16),
+      digest: crypto3.createHash("sha256").update(prompt).digest("hex").slice(0, 16),
       prompt_chars: prompt.length
     });
     try {
@@ -1474,7 +2232,7 @@ function run5(stdin_text, options) {
   }
   return decision.exit;
 }
-function main5(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) {
@@ -1488,34 +2246,54 @@ function main5(argv) {
   }
   return run5(readHookStdin(), { consumer_root });
 }
-function _isCliEntry5() {
+function _isCliEntry7() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL5(path5.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL7(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(fileURLToPath7(import.meta.url));
+    const argv = fs7.realpathSync(path7.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry5()) {
-  process.exit(main5());
+if (_isCliEntry7()) {
+  process.exit(main7());
 }
 
 // src/scripts/conformance_scan.ts
-var REPO_ROOT = path6.resolve(path6.dirname(fileURLToPath6(import.meta.url)), "..", "..");
+var REPO_ROOT = path8.resolve(path8.dirname(fileURLToPath8(import.meta.url)), "..", "..");
 var OBSERVED_BAND = { low: 9.1, high: 39.2 };
 var BAND_MIN_TURNS = 1978;
-function bandVerdict(rate_pct, assistant_turns) {
+var CARRIER_CHANGES = [
+  { at: "2026-08-07T00:00:00Z", what: "language-pin bound on user_prompt_submit (round 5)" }
+];
+function spansCarrierChange(firstAts) {
+  const stamps = firstAts.filter((s) => s !== "").sort();
+  if (stamps.length === 0) {
+    return { spans: false, what: "" };
+  }
+  const lo = stamps[0];
+  const hi = stamps[stamps.length - 1];
+  for (const c of CARRIER_CHANGES) {
+    if (lo < c.at && hi >= c.at) {
+      return { spans: true, what: c.what };
+    }
+  }
+  return { spans: false, what: "" };
+}
+function bandVerdict(rate_pct, assistant_turns, opts = {}) {
+  if (opts.spansCarrier === true) {
+    return "era-spanning";
+  }
   if (assistant_turns < BAND_MIN_TURNS) {
     return "corpus-too-small";
   }
@@ -1525,13 +2303,15 @@ var CHECK_IDS = [
   "language-pin",
   "git-authorization",
   "vacuous-evidence",
-  "evidence-steering"
+  "evidence-steering",
+  "completion-claim"
 ];
 var CHECK_MEANINGS = {
   "language-pin": "An assistant turn whose user-visible prose is not in the language that turn's own pin named. Carries provenance (turns_since_prompt, compaction_since_prompt) so a pin that was ABSENT because compaction removed it stays distinguishable from one that was present and ignored.",
   "git-authorization": "A gated git operation performed in a session where no authorization for that operation was observed. Authorization is per-operation and never carries from one to the next.",
   "vacuous-evidence": "A CI poll read as settled without ever observing an in-flight run \u2014 the poll gap that reports a green settle over a window in which nothing was pending yet.",
-  "evidence-steering": "A self-commissioned evaluation whose prompt pre-loaded its own verdict, or a second self-scoped evaluation of the same subject within one turn."
+  "evidence-steering": "A self-commissioned evaluation whose prompt pre-loaded its own verdict, or a second self-scoped evaluation of the same subject within one turn.",
+  "completion-claim": "An assistant turn claiming the work is complete while the last CI read in that session was NOT settled. Round 7 measured 14 instances by reading, each followed by the user handing the work back; this is the same predicate `turn-end-gate`'s completion detector refuses on, so the rate and the gate cannot disagree. A session that never polled CI can never hit."
 };
 function renderWhy(report, id) {
   const hits = report.per_session.flatMap((s) => s.violations.filter((v) => v.check === id));
@@ -1561,7 +2341,7 @@ function renderWhy(report, id) {
   }
   return lines.join("\n");
 }
-function _isObject6(v) {
+function _isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function userText(entry) {
@@ -1585,15 +2365,15 @@ function assistantText(entry) {
 }
 function toolUses2(entry) {
   const msg = entry["message"];
-  const content = _isObject6(msg) ? msg["content"] : void 0;
+  const content = _isObject7(msg) ? msg["content"] : void 0;
   if (!Array.isArray(content)) {
     return [];
   }
-  return content.filter((b) => _isObject6(b) && b["type"] === "tool_use").map((b) => {
+  return content.filter((b) => _isObject7(b) && b["type"] === "tool_use").map((b) => {
     const o = b;
     return {
       name: String(o["name"] ?? ""),
-      input: _isObject6(o["input"]) ? o["input"] : {}
+      input: _isObject7(o["input"]) ? o["input"] : {}
     };
   });
 }
@@ -1610,7 +2390,9 @@ function scanSession(sessionId, lines) {
     session: sessionId,
     user_turns: 0,
     assistant_turns: 0,
-    violations: []
+    violations: [],
+    de_pin_turns: 0,
+    first_at: ""
   };
   let pinned = null;
   let pendingPoll = null;
@@ -1619,6 +2401,8 @@ function scanSession(sessionId, lines) {
   let evaluationsThisTurn = 0;
   let turnsSincePrompt = 0;
   let compactionSincePrompt = false;
+  let ciSeen = false;
+  let ciSettled = false;
   for (const line of lines) {
     if (!line.trim()) {
       continue;
@@ -1629,6 +2413,9 @@ function scanSession(sessionId, lines) {
     } catch {
       continue;
     }
+    if (report.first_at === "" && typeof entry["timestamp"] === "string") {
+      report.first_at = entry["timestamp"];
+    }
     if (entry["type"] === "user" && entry["toolUseResult"] !== void 0 && pendingPoll !== null) {
       const raw = entry["toolUseResult"];
       const out = typeof raw === "string" ? raw : JSON.stringify(raw);
@@ -1643,6 +2430,8 @@ function scanSession(sessionId, lines) {
           detail: `CI poll read as settled without an in-flight observation: ${out.slice(0, 90)}`
         });
       }
+      ciSeen = true;
+      ciSettled = pending === 0 && sawPending && !isVacuousOutput(out);
       pendingPoll = null;
       continue;
     }
@@ -1682,6 +2471,20 @@ function scanSession(sessionId, lines) {
     if (prose !== null) {
       report.assistant_turns += 1;
       turnsSincePrompt += 1;
+      if (pinned === "de") {
+        report.de_pin_turns += 1;
+      }
+      if (!HARNESS_TEXT.test((prose.split("\n").find((l) => l.trim()) ?? "").trim())) {
+        const cc = detectCompletionClaim(prose, { seen: ciSeen, settled: ciSettled });
+        if (cc !== null) {
+          report.violations.push({
+            check: "completion-claim",
+            session: sessionId,
+            at,
+            detail: `completion claimed over an unsettled CI read: "${cc.evidence.slice(0, 110)}"`
+          });
+        }
+      }
       if (pinned === "de") {
         const first = prose.split("\n").find((l) => l.trim()) ?? "";
         if (HARNESS_TEXT.test(first.trim())) {
@@ -1742,7 +2545,7 @@ function scanSession(sessionId, lines) {
   }
   return report;
 }
-var DEFAULT_RATE_SERIES = path6.join(
+var DEFAULT_RATE_SERIES = path8.join(
   REPO_ROOT,
   "agents",
   "runtime",
@@ -1751,7 +2554,7 @@ var DEFAULT_RATE_SERIES = path6.join(
 );
 function defaultStore(projectDir) {
   const slug = projectDir.replace(/[/.]/g, "-");
-  return path6.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
+  return path8.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
 }
 function _tokens(chars) {
   return Math.round(chars / 4);
@@ -1762,13 +2565,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   return {
     project: {
       dir: projectRulesDir,
-      present: fs6.existsSync(projectRulesDir),
+      present: fs8.existsSync(projectRulesDir),
       files: p.files,
       tokens: _tokens(p.chars)
     },
     global: {
       dir: globalRulesDir,
-      present: fs6.existsSync(globalRulesDir),
+      present: fs8.existsSync(globalRulesDir),
       files: g.files,
       tokens: _tokens(g.chars)
     },
@@ -1776,13 +2579,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   };
 }
 function storeKey(store) {
-  return createHash("sha256").update(path6.resolve(store)).digest("hex").slice(0, 12);
+  return createHash3("sha256").update(path8.resolve(store)).digest("hex").slice(0, 12);
 }
 function scanStore(store, limit) {
-  const files = fs6.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs6.statSync(path6.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
+  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 per_session = [];
   for (const f of files) {
-    const lines = fs6.readFileSync(path6.join(store, f), "utf8").split("\n");
+    const lines = fs8.readFileSync(path8.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);
@@ -1792,7 +2595,8 @@ function scanStore(store, limit) {
     "language-pin": 0,
     "git-authorization": 0,
     "vacuous-evidence": 0,
-    "evidence-steering": 0
+    "evidence-steering": 0,
+    "completion-claim": 0
   };
   for (const s of per_session) {
     for (const v of s.violations) {
@@ -1802,11 +2606,14 @@ function scanStore(store, limit) {
   const assistant_turns = per_session.reduce((n, s) => n + s.assistant_turns, 0);
   const language_pin = totals["language-pin"] ?? 0;
   const rate_pct = assistant_turns === 0 ? 0 : Number((100 * language_pin / assistant_turns).toFixed(1));
+  const de_pin_turns = per_session.reduce((n, s) => n + s.de_pin_turns, 0);
+  const rate_pct_de_pin = de_pin_turns === 0 ? 0 : Number((100 * language_pin / de_pin_turns).toFixed(1));
+  const era = spansCarrierChange(per_session.map((s) => s.first_at));
   const delivered = measureDelivered(
-    path6.join(REPO_ROOT, ".claude", "rules"),
-    path6.join(process.env["HOME"] ?? os.homedir(), ".claude", "rules")
+    path8.join(REPO_ROOT, ".claude", "rules"),
+    path8.join(process.env["HOME"] ?? os2.homedir(), ".claude", "rules")
   );
-  const ownStore = path6.resolve(store) === path6.resolve(defaultStore(REPO_ROOT));
+  const ownStore = path8.resolve(store) === path8.resolve(defaultStore(REPO_ROOT));
   return {
     scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
     store,
@@ -1820,7 +2627,11 @@ function scanStore(store, limit) {
       assistant_turns,
       language_pin,
       rate_pct,
-      band: bandVerdict(rate_pct, assistant_turns),
+      de_pin_turns,
+      rate_pct_de_pin,
+      era_spanning: era.spans,
+      era_reason: era.what,
+      band: bandVerdict(rate_pct, assistant_turns, { spansCarrier: era.spans }),
       // Only attach the carrier figures when the rate and the carriers describe
       // the same project.
       delivered_project_tokens: ownStore ? delivered.project.tokens : null,
@@ -1829,8 +2640,8 @@ function scanStore(store, limit) {
   };
 }
 function recordRate(file, scanned_at, rate) {
-  fs6.mkdirSync(path6.dirname(file), { recursive: true });
-  fs6.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
+  fs8.mkdirSync(path8.dirname(file), { recursive: true });
+  fs8.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
 `, "utf8");
 }
 function render(report) {
@@ -1861,7 +2672,26 @@ function render(report) {
   lines.push(
     `  language-pin rate  ${report.rate.rate_pct.toFixed(1)}%  (${report.rate.language_pin} of ${report.rate.assistant_turns} assistant turns)`
   );
-  if (report.rate.band === "corpus-too-small") {
+  const dePinTurns = report.rate.de_pin_turns;
+  const dePinRate = report.rate.rate_pct_de_pin;
+  if (typeof dePinTurns === "number" && typeof dePinRate === "number") {
+    lines.push(
+      `                     ${dePinRate.toFixed(1)}%  (${report.rate.language_pin} of ${dePinTurns} turns under a GERMAN pin \u2014 the only turns this check can fire on)`
+    );
+    lines.push(
+      "    The band (M5, n=3) was computed on the ALL-turns denominator, so the first figure"
+    );
+    lines.push("    is the comparable one and the second is the honest one. Both are printed.");
+  }
+  if (report.rate.band === "era-spanning") {
+    lines.push(
+      `    Not compared: the corpus SPANS a carrier landing \u2014 ${report.rate.era_reason || "see CARRIER_CHANGES"}.`
+    );
+    lines.push("    A rate pooled across it is a weighted average of two different systems, not");
+    lines.push("    a reading about behaviour. Round 7 measured 23.1% before and 0.0% after that");
+    lines.push("    exact carrier; the pooled 6.5% was announced as the falsifier firing.");
+    lines.push("    Split the window at the carrier date and read each era on its own.");
+  } else if (report.rate.band === "corpus-too-small") {
     lines.push(
       `    Not compared: ${report.rate.assistant_turns} turns is below the ${BAND_MIN_TURNS} of the`
     );
@@ -1883,11 +2713,22 @@ function render(report) {
     lines.push("    as new. Store novelty is not project novelty.");
   }
   lines.push("");
-  lines.push("  Scanned checks are exactly the mechanised ones. Ask-shape, session-canary,");
-  lines.push("  promissory closings and checkbox batching are left as prose and NOT measured.");
+  lines.push("  Scanned checks are exactly the mechanised ones. What is NOT in the counts above:");
+  lines.push("    ask-shape (trailing free-text offer)  \u2014 measured NOWHERE. ~11 findings in round 7's");
+  lines.push("      reading half; the discriminator needs judgement, so it stays advisory on purpose.");
+  lines.push("    session-canary (opening greeting)     \u2014 not here, but PROBEABLE:");
+  lines.push("      `./scripts-run src/scripts/probe_session_canary`. Round 7: 25/28 sessions,");
+  lines.push("      24/25 post-carrier. The per-TASK instance is undecidable \u2014 no task boundary");
+  lines.push("      is recorded in a transcript.");
+  lines.push("    promissory closings                   \u2014 not here, but ALREADY GATED: `turn-end-gate`");
+  lines.push("      ships a blocking `detectPromissory`. Round 7 probe: 1 of 120 hand-back turns");
+  lines.push("      (the 163 this line first printed was the retracted denominator \u2014 it counted");
+  lines.push("      synthetic user turns as hand-back closers).");
+  lines.push("      `./scripts-run src/scripts/probe_promissory_closing`.");
+  lines.push("    checkbox batching                     \u2014 measured NOWHERE. ~5 low-severity findings.");
   return lines.join("\n");
 }
-function main6(argv) {
+function main8(argv) {
   const args = argv ?? process.argv.slice(2);
   let store = null;
   let limit = 30;
@@ -1919,14 +2760,14 @@ function main6(argv) {
     return 2;
   }
   const resolved = store ?? defaultStore(process.cwd());
-  if (!fs6.existsSync(resolved)) {
+  if (!fs8.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) {
-    fs6.writeFileSync(out, `${JSON.stringify(report, null, 2)}
+    fs8.writeFileSync(out, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   }
   if (record) {
@@ -1934,7 +2775,7 @@ function main6(argv) {
   }
   if (why !== null) {
     const id = why;
-    fs6.writeSync(
+    fs8.writeSync(
       1,
       json ? `${JSON.stringify(
         {
@@ -1954,48 +2795,48 @@ function main6(argv) {
     );
     return 0;
   }
-  fs6.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
+  fs8.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
 ` : `${render(report)}
 `);
   return 0;
 }
-function _isCliEntry6() {
+function _isCliEntry8() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL6(path6.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL8(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(fileURLToPath8(import.meta.url));
+    const argv = fs8.realpathSync(path8.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry6()) {
-  process.exit(main6());
+if (_isCliEntry8()) {
+  process.exit(main8());
 }
 
 // src/scripts/report_carrier_divergence.ts
-import * as fs7 from "node:fs";
-import * as os2 from "node:os";
-import * as path7 from "node:path";
+import * as fs9 from "node:fs";
+import * as os3 from "node:os";
+import * as path9 from "node:path";
 import process2 from "node:process";
-import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL7 } from "node:url";
-var _HERE = fileURLToPath7(import.meta.url);
-var REPO_ROOT2 = path7.resolve(path7.dirname(_HERE), "..", "..");
-var PROJECT_RULES = path7.join(".claude", "rules");
-var PROJECTION_SOURCE = path7.join("dist", "agent-src", "rules");
-var GLOBAL_RULES = path7.join(".claude", "rules");
+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");
 function _listRules(dir) {
   try {
-    return fs7.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    return fs9.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -2003,7 +2844,7 @@ function _listRules(dir) {
 function _ruleType(file) {
   let text;
   try {
-    text = fs7.readFileSync(file, "utf-8");
+    text = fs9.readFileSync(file, "utf-8");
   } catch {
     return "";
   }
@@ -2014,8 +2855,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
   const out = {
     projectDir,
     globalDir,
-    globalPresent: fs7.existsSync(globalDir),
-    projectPresent: fs7.existsSync(projectDir),
+    globalPresent: fs9.existsSync(globalDir),
+    projectPresent: fs9.existsSync(projectDir),
     shared: 0,
     identical: [],
     provenanceOnly: [],
@@ -2038,7 +2879,7 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     }
     if (!inP && inG) {
       out.globalOnly.push(rule);
-      if (sourceDir !== void 0 && _ruleType(path7.join(sourceDir, rule)) === "manual") {
+      if (sourceDir !== void 0 && _ruleType(path9.join(sourceDir, rule)) === "manual") {
         out.manualOnlyGlobal.push(rule);
       }
       continue;
@@ -2048,8 +2889,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     let projectCopy;
     let globalCopy;
     try {
-      projectCopy = fs7.readFileSync(path7.join(projectDir, rule));
-      globalCopy = fs7.readFileSync(path7.join(globalDir, rule));
+      projectCopy = fs9.readFileSync(path9.join(projectDir, rule));
+      globalCopy = fs9.readFileSync(path9.join(globalDir, rule));
       verdict = comparePair(projectCopy, globalCopy);
     } catch {
       out.shared -= 1;
@@ -2194,11 +3035,11 @@ function render2(d) {
   }
   return lines.join("\n");
 }
-function main7(argv) {
+function main9(argv) {
   const args = argv ?? process2.argv.slice(2);
-  let projectDir = path7.join(REPO_ROOT2, PROJECT_RULES);
-  let globalDir = path7.join(os2.homedir(), GLOBAL_RULES);
-  let sourceDir = path7.join(REPO_ROOT2, PROJECTION_SOURCE);
+  let projectDir = path9.join(REPO_ROOT2, PROJECT_RULES);
+  let globalDir = path9.join(os3.homedir(), GLOBAL_RULES);
+  let sourceDir = path9.join(REPO_ROOT2, PROJECTION_SOURCE);
   const value = (i) => {
     const v = args[i + 1];
     return v === void 0 || v.startsWith("-") ? null : v;
@@ -2212,7 +3053,7 @@ function main7(argv) {
 `);
         return 1;
       }
-      const resolved = path7.resolve(v);
+      const resolved = path9.resolve(v);
       if (a === "--project") projectDir = resolved;
       else if (a === "--global") globalDir = resolved;
       else sourceDir = resolved;
@@ -2232,44 +3073,44 @@ function main7(argv) {
 `);
   return 0;
 }
-function _isCliEntry7() {
+function _isCliEntry9() {
   if (process2.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL7(path7.resolve(process2.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL9(path9.resolve(process2.argv[1])).href) return true;
   try {
-    return fs7.realpathSync(_HERE) === fs7.realpathSync(path7.resolve(process2.argv[1]));
+    return fs9.realpathSync(_HERE) === fs9.realpathSync(path9.resolve(process2.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry7()) {
-  process2.exit(main7());
+if (_isCliEntry9()) {
+  process2.exit(main9());
 }
 
 // src/scripts/report_skill_activation.ts
-import * as fs8 from "node:fs";
-import * as os3 from "node:os";
-import * as path8 from "node:path";
-import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
-var _HERE2 = fileURLToPath8(import.meta.url);
-var REPO_ROOT3 = path8.resolve(path8.dirname(_HERE2), "..", "..");
+import * as fs10 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), "..", "..");
 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;
 function censusSkills(root) {
   const out = { total: 0, withTriggerKey: [], withDeterministicObligation: [] };
-  if (!fs8.existsSync(root)) {
+  if (!fs10.existsSync(root)) {
     return out;
   }
-  for (const entry of fs8.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+  for (const entry of fs10.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const file = path8.join(root, entry.name, "SKILL.md");
-    if (!fs8.existsSync(file)) {
+    const file = path10.join(root, entry.name, "SKILL.md");
+    if (!fs10.existsSync(file)) {
       continue;
     }
     out.total += 1;
-    const text = fs8.readFileSync(file, "utf8");
+    const text = fs10.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))) {
@@ -2283,17 +3124,17 @@ function censusSkills(root) {
   return out;
 }
 function defaultStore2(cwd) {
-  return path8.join(os3.homedir(), ".claude", "projects", cwd.replace(/[/.]/g, "-"));
+  return path10.join(os4.homedir(), ".claude", "projects", cwd.replace(/[/.]/g, "-"));
 }
 function measureUsage(store, limit) {
   const rep = { store, sessions: 0, assistantTurns: 0, invocations: 0, bySkill: {} };
-  if (!fs8.existsSync(store)) {
+  if (!fs10.existsSync(store)) {
     return rep;
   }
-  const files = fs8.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path8.join(store, f)).sort((a, b) => fs8.statSync(b).mtimeMs - fs8.statSync(a).mtimeMs).slice(0, limit);
+  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);
   rep.sessions = files.length;
   for (const file of files) {
-    for (const line of fs8.readFileSync(file, "utf8").split("\n")) {
+    for (const line of fs10.readFileSync(file, "utf8").split("\n")) {
       if (!line.trim()) {
         continue;
       }
@@ -2356,7 +3197,7 @@ function render3(census, usage) {
     }
     totalInv += u.invocations;
     lines.push(
-      `  ${path8.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)}`
+      `  ${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)}`
     );
   }
   lines.push("");
@@ -2381,7 +3222,7 @@ function render3(census, usage) {
   lines.push("  catalogue once per session, then count descriptions against bare names.");
   return lines.join("\n");
 }
-function main8(argv) {
+function main10(argv) {
   let limit = 30;
   const stores = [];
   for (let i = 0; i < argv.length; i += 1) {
@@ -2404,24 +3245,24 @@ function main8(argv) {
   if (stores.length === 0) {
     stores.push(defaultStore2(REPO_ROOT3));
   }
-  const census = censusSkills(path8.join(REPO_ROOT3, SKILLS_ROOT));
+  const census = censusSkills(path10.join(REPO_ROOT3, SKILLS_ROOT));
   const usage = stores.map((s) => measureUsage(s, limit));
   process.stdout.write(`${render3(census, usage)}
 `);
   return 0;
 }
-if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL8(path8.resolve(process.argv[1])).href) {
-  process.exit(main8(process.argv.slice(2)));
+if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL10(path10.resolve(process.argv[1])).href) {
+  process.exit(main10(process.argv.slice(2)));
 }
 
 // src/scripts/report_skill_obligation_violations.ts
-import * as fs9 from "node:fs";
-import * as os4 from "node:os";
-import * as path9 from "node:path";
+import * as fs11 from "node:fs";
+import * as os5 from "node:os";
+import * as path11 from "node:path";
 import process3 from "node:process";
-import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
-var _HERE3 = fileURLToPath9(import.meta.url);
-var REPO_ROOT4 = path9.resolve(path9.dirname(_HERE3), "..", "..");
+import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
+var _HERE3 = fileURLToPath11(import.meta.url);
+var REPO_ROOT4 = path11.resolve(path11.dirname(_HERE3), "..", "..");
 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;
@@ -2459,7 +3300,7 @@ function _artefacts(line) {
   return out;
 }
 function extractObligations(repoRoot) {
-  const skillsRoot = path9.join(repoRoot, SKILLS_ROOT);
+  const skillsRoot = path11.join(repoRoot, SKILLS_ROOT);
   const census = censusSkills(skillsRoot);
   const out = {
     skills: census.withDeterministicObligation,
@@ -2473,7 +3314,7 @@ function extractObligations(repoRoot) {
   for (const skill of census.withDeterministicObligation) {
     let text;
     try {
-      text = fs9.readFileSync(path9.join(skillsRoot, skill, "SKILL.md"), "utf-8");
+      text = fs11.readFileSync(path11.join(skillsRoot, skill, "SKILL.md"), "utf-8");
     } catch {
       continue;
     }
@@ -2589,7 +3430,7 @@ function scanSessionForViolations(session, lines, forbidden, parsed) {
   return flags;
 }
 function defaultStore3(cwd) {
-  return path9.join(os4.homedir(), ".claude", "projects", cwd.replace(/[/.]/g, "-"));
+  return path11.join(os5.homedir(), ".claude", "projects", cwd.replace(/[/.]/g, "-"));
 }
 function scanStore2(repoRoot, store, limit) {
   const census = extractObligations(repoRoot);
@@ -2602,14 +3443,14 @@ function scanStore2(repoRoot, store, limit) {
   };
   let files;
   try {
-    files = fs9.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path9.join(store, f), m: fs9.statSync(path9.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
+    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);
   } catch {
     return report;
   }
   report.sessions = files.length;
   for (const file of files) {
-    const lines = fs9.readFileSync(file, "utf-8").split("\n");
-    const id = path9.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
+    const lines = fs11.readFileSync(file, "utf-8").split("\n");
+    const id = path11.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));
@@ -2679,7 +3520,7 @@ function render4(r) {
   lines.push("  ships as detection-only, and this one says so.");
   return lines.join("\n");
 }
-function main9(argv) {
+function main11(argv) {
   const args = argv ?? process3.argv.slice(2);
   let limit = 30;
   let json = false;
@@ -2732,35 +3573,35 @@ function main9(argv) {
   }
   return 0;
 }
-function _isCliEntry8() {
+function _isCliEntry10() {
   if (process3.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL9(path9.resolve(process3.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL11(path11.resolve(process3.argv[1])).href) return true;
   try {
-    return fs9.realpathSync(_HERE3) === fs9.realpathSync(path9.resolve(process3.argv[1]));
+    return fs11.realpathSync(_HERE3) === fs11.realpathSync(path11.resolve(process3.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry8()) {
-  process3.exit(main9());
+if (_isCliEntry10()) {
+  process3.exit(main11());
 }
 
 // src/scripts/report_conformance_funnel.ts
-var _HERE4 = fileURLToPath10(import.meta.url);
-var REPO_ROOT5 = path10.resolve(path10.dirname(_HERE4), "..", "..");
+var _HERE4 = fileURLToPath12(import.meta.url);
+var REPO_ROOT5 = path12.resolve(path12.dirname(_HERE4), "..", "..");
 function buildFunnel(opts = {}) {
   const repoRoot = opts.repoRoot ?? REPO_ROOT5;
-  const projectRulesDir = opts.projectRulesDir ?? path10.join(repoRoot, PROJECT_RULES);
-  const globalRulesDir = opts.globalRulesDir ?? path10.join(os5.homedir(), GLOBAL_RULES);
-  const sourceDir = opts.sourceDir ?? path10.join(repoRoot, PROJECTION_SOURCE);
+  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 store = opts.store ?? defaultStore(repoRoot);
   const limit = opts.limit ?? 30;
   return {
     delivered: measureDelivered(projectRulesDir, globalRulesDir),
     divergence: compareCarriers(projectRulesDir, globalRulesDir, sourceDir),
-    skills: censusSkills(path10.join(repoRoot, SKILLS_ROOT)),
+    skills: censusSkills(path12.join(repoRoot, SKILLS_ROOT)),
     usage: measureUsage(store, limit),
-    storePresent: fs10.existsSync(store),
+    storePresent: fs12.existsSync(store),
     sk2: scanStore2(repoRoot, store, limit)
   };
 }
@@ -2885,7 +3726,7 @@ function render5(r) {
   lines.push("workflow without a measured false-positive rate first (locked policy).");
   return lines.join("\n");
 }
-function main10(argv) {
+function main12(argv) {
   const args = argv ?? process4.argv.slice(2);
   const opts = {};
   const value = (i) => {
@@ -2901,7 +3742,7 @@ function main10(argv) {
 `);
         return 1;
       }
-      const resolved = path10.resolve(v);
+      const resolved = path12.resolve(v);
       if (a === "--store") opts.store = resolved;
       else if (a === "--project") opts.projectRulesDir = resolved;
       else if (a === "--global") opts.globalRulesDir = resolved;
@@ -2931,21 +3772,21 @@ function main10(argv) {
 `);
   return 0;
 }
-function _isCliEntry9() {
+function _isCliEntry11() {
   if (process4.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL10(path10.resolve(process4.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL12(path12.resolve(process4.argv[1])).href) return true;
   try {
-    return fs10.realpathSync(_HERE4) === fs10.realpathSync(path10.resolve(process4.argv[1]));
+    return fs12.realpathSync(_HERE4) === fs12.realpathSync(path12.resolve(process4.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry9()) {
-  process4.exit(main10());
+if (_isCliEntry11()) {
+  process4.exit(main12());
 }
 
 // src/scripts/_cli/cmd_conformance.ts
-var _HERE5 = fileURLToPath11(import.meta.url);
+var _HERE5 = fileURLToPath13(import.meta.url);
 var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
 var CONFORMANCE_CHECK_IDS = [
   "txlog-clean",
@@ -2968,17 +3809,17 @@ function conformanceLogPath() {
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path11.join(os6.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
+  return path13.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 path11.join(os6.homedir(), ".event4u", "agent-config", "install-log.jsonl");
+  return path13.join(os7.homedir(), ".event4u", "agent-config", "install-log.jsonl");
 }
 function _check_txlog_clean(logPath = installLogPath()) {
-  if (!fs11.existsSync(logPath)) {
+  if (!fs13.existsSync(logPath)) {
     return {
       id: "txlog-clean",
       status: "ok",
@@ -3012,11 +3853,11 @@ function _check_txlog_clean(logPath = installLogPath()) {
   };
 }
 function routeTargetPaths(target) {
-  return routeTargetPathsPosix(target).map((rel) => path11.join(...rel.split("/")));
+  return routeTargetPathsPosix(target).map((rel) => path13.join(...rel.split("/")));
 }
 function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
-  const routerPath = path11.join(packageRoot, "dist", "router.json");
-  if (!fs11.existsSync(routerPath)) {
+  const routerPath = path13.join(packageRoot, "dist", "router.json");
+  if (!fs13.existsSync(routerPath)) {
     return {
       id: "router-pointers",
       status: "fail",
@@ -3026,7 +3867,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
   }
   let router;
   try {
-    router = JSON.parse(fs11.readFileSync(routerPath, "utf8"));
+    router = JSON.parse(fs13.readFileSync(routerPath, "utf8"));
   } catch (exc) {
     return {
       id: "router-pointers",
@@ -3035,13 +3876,13 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
       remedy: "reinstall the package \u2014 dist/router.json is corrupt"
     };
   }
-  const rulesDir = path11.join(packageRoot, "dist", "agent-src", "rules");
+  const rulesDir = path13.join(packageRoot, "dist", "agent-src", "rules");
   const broken = [];
   let ids = 0;
   let targets = 0;
   for (const kernelId of router["kernel"] ?? []) {
     ids += 1;
-    if (!fs11.existsSync(path11.join(rulesDir, `${kernelId}.md`))) {
+    if (!fs13.existsSync(path13.join(rulesDir, `${kernelId}.md`))) {
       broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
     }
   }
@@ -3049,7 +3890,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
     for (const entry of router[tier] ?? []) {
       const ruleId = String(entry["id"] ?? "");
       ids += 1;
-      if (!fs11.existsSync(path11.join(rulesDir, `${ruleId}.md`))) {
+      if (!fs13.existsSync(path13.join(rulesDir, `${ruleId}.md`))) {
         broken.push(`${tier}:${ruleId} \u2192 rules/${ruleId}.md missing`);
       }
       for (const target of entry["routes_to"] ?? []) {
@@ -3059,7 +3900,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
           broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
           continue;
         }
-        if (!candidates.some((rel) => fs11.existsSync(path11.join(packageRoot, rel)))) {
+        if (!candidates.some((rel) => fs13.existsSync(path13.join(packageRoot, rel)))) {
           broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
         }
       }
@@ -3091,9 +3932,9 @@ function detectSmokePlatform(projectRoot) {
   return "claude";
 }
 function dispatcherRunner(packageRoot) {
-  const localTsx = path11.join(packageRoot, "node_modules", ".bin", "tsx");
-  const script = path11.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
-  if (fs11.existsSync(localTsx)) {
+  const localTsx = path13.join(packageRoot, "node_modules", ".bin", "tsx");
+  const script = path13.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
+  if (fs13.existsSync(localTsx)) {
     return [localTsx, script];
   }
   return ["npx", "tsx", script];
@@ -3110,7 +3951,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 = spawnSync(argv[0], argv.slice(1), {
+    const proc = spawnSync2(argv[0], argv.slice(1), {
       input: payload,
       cwd: projectRoot,
       encoding: "utf8",
@@ -3143,12 +3984,12 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT, opts =
   };
 }
 function readSettingsMode(projectRoot) {
-  const settingsPath = path11.join(projectRoot, ".agent-settings.yml");
-  if (!fs11.existsSync(settingsPath)) {
+  const settingsPath = path13.join(projectRoot, ".agent-settings.yml");
+  if (!fs13.existsSync(settingsPath)) {
     return "eager-all";
   }
   try {
-    const parsed = YAML.parse(fs11.readFileSync(settingsPath, "utf8"));
+    const parsed = YAML.parse(fs13.readFileSync(settingsPath, "utf8"));
     const lean = parsed?.["lean_projection"] ?? null;
     const mode = lean?.["mode"];
     return typeof mode === "string" && mode.length > 0 ? mode : "eager-all";
@@ -3159,7 +4000,7 @@ function readSettingsMode(projectRoot) {
 function kernelIdsFromRouter(packageRoot) {
   try {
     const router = JSON.parse(
-      fs11.readFileSync(path11.join(packageRoot, "dist", "router.json"), "utf8")
+      fs13.readFileSync(path13.join(packageRoot, "dist", "router.json"), "utf8")
     );
     return new Set((router["kernel"] ?? []).map(String));
   } catch {
@@ -3176,8 +4017,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 ?? path11.join(projectRoot, ".augment", "rules");
-  if (!fs11.existsSync(rulesDir)) {
+  const rulesDir = projectedRulesDir ?? path13.join(projectRoot, ".augment", "rules");
+  if (!fs13.existsSync(rulesDir)) {
     return {
       id: "lean-projection",
       status: "skipped",
@@ -3186,7 +4027,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
     };
   }
   const kernel = kernelIdsFromRouter(packageRoot);
-  const files = fs11.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
+  const files = fs13.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 {
@@ -3200,7 +4041,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
   for (const f of nonKernel) {
     let text = "";
     try {
-      text = fs11.readFileSync(path11.join(rulesDir, f), "utf8");
+      text = fs13.readFileSync(path13.join(rulesDir, f), "utf8");
     } catch {
       continue;
     }
@@ -3231,8 +4072,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 = path11.join(projectRoot, ".agent-settings.yml");
-  if (!fs11.existsSync(settingsPath)) {
+  const settingsPath = path13.join(projectRoot, ".agent-settings.yml");
+  if (!fs13.existsSync(settingsPath)) {
     return {
       id: "host-manifest",
       status: "ok",
@@ -3242,7 +4083,7 @@ function _check_host_manifest(projectRoot) {
   }
   let parsed = null;
   try {
-    parsed = YAML.parse(fs11.readFileSync(settingsPath, "utf8"));
+    parsed = YAML.parse(fs13.readFileSync(settingsPath, "utf8"));
   } catch (exc) {
     return {
       id: "host-manifest",
@@ -3341,7 +4182,7 @@ function _parse(argv) {
   }
   return opts;
 }
-function main11(argv = null) {
+function main13(argv = null) {
   const opts = _parse(argv !== null ? Array.from(argv) : process5.argv.slice(2));
   if (opts.funnel) {
     print(render5(buildFunnel()));
@@ -3412,25 +4253,25 @@ function main11(argv = null) {
   }
   return failed ? 1 : 0;
 }
-function _isCliEntry10() {
+function _isCliEntry12() {
   if (process5.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL11(path11.resolve(process5.argv[1])).href;
+  const argvUrl = pathToFileURL13(path13.resolve(process5.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs11.realpathSync(fileURLToPath11(import.meta.url));
-    const argv = fs11.realpathSync(path11.resolve(process5.argv[1]));
+    const here = fs13.realpathSync(fileURLToPath13(import.meta.url));
+    const argv = fs13.realpathSync(path13.resolve(process5.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry10() || process5.argv[1] === _HERE5) {
+if (_isCliEntry12() || process5.argv[1] === _HERE5) {
   try {
-    process5.exitCode = main11(process5.argv.slice(2));
+    process5.exitCode = main13(process5.argv.slice(2));
   } catch (e) {
     if (e instanceof ArgparseExit) {
       process5.exitCode = e.code;
@@ -3453,7 +4294,7 @@ export {
   conformanceLogPath,
   detectSmokePlatform,
   installLogPath,
-  main11 as main,
+  main13 as main,
   routeTargetPaths,
   runConformanceChecks
 };