@event4u/agent-config 10.3.0 → 10.4.0

package/dist/cli-delegate/cmd_conformance.js

@@ -2,6 +2,9 @@ import { createRequire as __acCreateRequire } from 'node:module'; const require
 import {
   readHookStdin
 } from "./chunk-MMJL4TIX.js";
+import {
+  validateAssumption
+} from "./chunk-ZPSXJTLI.js";
 import {
   ArgparseExit,
   STATUS_SYMBOLS,
@@ -59,12 +62,12 @@ import {
 
 // src/scripts/_cli/cmd_conformance.ts
 var YAML = __toESM(require_dist(), 1);
-import * as fs14 from "node:fs";
+import * as fs15 from "node:fs";
 import * as os7 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import process6 from "node:process";
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { fileURLToPath as fileURLToPath14, pathToFileURL as pathToFileURL14 } from "node:url";
+import { fileURLToPath as fileURLToPath15, pathToFileURL as pathToFileURL15 } from "node:url";
 
 // src/install/txlog.ts
 import { createReadStream, createWriteStream, existsSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
@@ -125,18 +128,18 @@ function routeTargetPathsPosix(target) {
 }
 
 // src/scripts/report_conformance_funnel.ts
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import * as os6 from "node:os";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 import process5 from "node:process";
-import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL13 } from "node:url";
+import { fileURLToPath as fileURLToPath14, pathToFileURL as pathToFileURL14 } from "node:url";
 
 // src/scripts/conformance_scan.ts
-import { createHash as createHash3 } from "node:crypto";
-import fs9 from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import fs10 from "node:fs";
 import os2 from "node:os";
-import path9 from "node:path";
-import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
+import path10 from "node:path";
+import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
 
 // src/scripts/_lib/transcript_entry.ts
 function _isObject(v) {
@@ -1339,10 +1342,10 @@ if (isCliEntry) {
 }
 
 // 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";
+import * as crypto3 from "node:crypto";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
+import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL7 } from "node:url";
 
 // src/scripts/hooks/end_review_nudge_hook.ts
 import { spawnSync } from "node:child_process";
@@ -1710,9 +1713,456 @@ if (_isCliEntry5()) {
   process.exit(main5());
 }
 
+// src/scripts/hooks/subagent_ledger_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/_lib/subagent_response.ts
+var MAX_SUMMARY_CHARS = 2e3;
+var MAX_RESPONSE_LINE_CHARS = 240;
+var MAX_RESPONSE_ENTRIES = 40;
+var MAX_ARTIFACT_REF_CHARS = 200;
+var MAX_ENVELOPE_CHARS = 12e3;
+var CONFIDENCE = /* @__PURE__ */ new Set(["low", "medium", "high"]);
+function validateResponse(input) {
+  const errors = [];
+  if (input === null || typeof input !== "object") {
+    return { valid: false, errors: ["response is not an object"] };
+  }
+  const r = input;
+  if (typeof r.summary !== "string") errors.push("summary missing or not a string");
+  if (typeof r.handoff !== "string") errors.push("handoff missing or not a string");
+  if (!CONFIDENCE.has(r.confidence)) errors.push(`confidence must be low|medium|high (got ${String(r.confidence)})`);
+  if (!Array.isArray(r.findings)) errors.push("findings missing or not an array");
+  if (!Array.isArray(r.risks)) errors.push("risks missing or not an array");
+  if (Array.isArray(r.findings)) {
+    for (const [i, f] of r.findings.entries()) {
+      if (!f || typeof f.title !== "string") errors.push(`finding[${i}] missing title`);
+      const refs = f?.evidence_refs;
+      if (refs && refs.some((x) => typeof x !== "string" || x.includes("\n"))) {
+        errors.push(`finding[${i}] evidence_refs must be ref tokens, not bodies`);
+      }
+    }
+  }
+  if (r.assumptions !== void 0) {
+    if (!Array.isArray(r.assumptions)) {
+      errors.push("assumptions must be an array of {statement, basis, epistemic_state}");
+    } else {
+      for (const [i, a] of r.assumptions.entries()) {
+        errors.push(...validateAssumption(a, `assumptions[${i}]`));
+      }
+    }
+  }
+  if (typeof r.summary === "string" && r.summary.length > MAX_SUMMARY_CHARS) {
+    errors.push(`summary is ${r.summary.length} chars (max ${MAX_SUMMARY_CHARS}) \u2014 the envelope carries a bounded summary; the full result belongs on disk (artifact_paths)`);
+  }
+  if (typeof r.handoff === "string" && r.handoff.length > MAX_RESPONSE_LINE_CHARS) {
+    errors.push(`handoff is ${r.handoff.length} chars (max ${MAX_RESPONSE_LINE_CHARS})`);
+  }
+  for (const [key, arr] of [
+    ["findings", r.findings],
+    ["risks", r.risks],
+    ["artifact_paths", r.artifact_paths]
+  ]) {
+    if (Array.isArray(arr) && arr.length > MAX_RESPONSE_ENTRIES) {
+      errors.push(`${key} carries ${arr.length} entries (max ${MAX_RESPONSE_ENTRIES}) \u2014 an envelope is a handoff, not a transcript`);
+    }
+  }
+  if (Array.isArray(r.risks)) {
+    for (const [i, risk] of r.risks.entries()) {
+      if (typeof risk === "string" && risk.length > MAX_RESPONSE_LINE_CHARS) {
+        errors.push(`risks[${i}] is ${risk.length} chars (max ${MAX_RESPONSE_LINE_CHARS})`);
+      }
+    }
+  }
+  if (Array.isArray(r.findings)) {
+    for (const [i, f] of r.findings.entries()) {
+      if (f && typeof f.title === "string" && f.title.length > MAX_RESPONSE_LINE_CHARS) {
+        errors.push(`finding[${i}] title is ${f.title.length} chars (max ${MAX_RESPONSE_LINE_CHARS})`);
+      }
+    }
+  }
+  if (r.artifact_paths !== void 0) {
+    if (!Array.isArray(r.artifact_paths)) {
+      errors.push("artifact_paths must be an array of path ref tokens");
+    } else {
+      for (const [i, p] of r.artifact_paths.entries()) {
+        if (typeof p !== "string" || p.includes("\n") || p.length > MAX_ARTIFACT_REF_CHARS) {
+          errors.push(`artifact_paths[${i}] must be a single-line path ref \u2264 ${MAX_ARTIFACT_REF_CHARS} chars`);
+        }
+      }
+    }
+  }
+  try {
+    const serialized = JSON.stringify(input);
+    if (serialized.length > MAX_ENVELOPE_CHARS) {
+      errors.push(`envelope serializes to ${serialized.length} chars (max ${MAX_ENVELOPE_CHARS}) \u2014 move content to disk and reference it via artifact_paths`);
+    }
+  } catch {
+    errors.push("envelope is not JSON-serializable");
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/scripts/hooks/subagent_ledger_hook.ts
+var EXIT_ALLOW4 = 0;
+function isObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+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) {
+  return crypto2.createHash("sha256").update(agentId, "utf8").digest("hex").slice(0, 12);
+}
+function unwrapPayload(envelope) {
+  const inner = envelope["payload"];
+  return isObject2(inner) ? inner : envelope;
+}
+function str2(payload, ...keys) {
+  for (const k of keys) {
+    const v = payload[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return null;
+}
+function extractParentId(payload, ownId) {
+  const explicit = str2(payload, "parent_agent_id", "parentAgentId");
+  if (explicit) return explicit;
+  const session = payload["session"];
+  if (isObject2(session)) {
+    const sessionAgent = str2(session, "agent_id", "agentId");
+    if (sessionAgent && sessionAgent !== ownId) return sessionAgent;
+  }
+  return null;
+}
+function classifyEnvelope(message) {
+  if (message === null || !message.trim()) return { verdict: "absent", error_count: 0 };
+  const candidates = _jsonObjectCandidates(message);
+  if (candidates.length === 0) return { verdict: "absent", error_count: 0 };
+  let best = null;
+  for (const candidate of candidates) {
+    const result = validateResponse(candidate);
+    if (result.valid) return { verdict: "ok", error_count: 0 };
+    if (best === null) best = { verdict: "fail", error_count: result.errors.length };
+  }
+  return best ?? { verdict: "absent", error_count: 0 };
+}
+function _jsonObjectCandidates(message) {
+  const texts = [];
+  for (const match of message.matchAll(/^[ \t]*```[ \t]*(?:json)?[ \t]*\r?\n([\s\S]*?)^[ \t]*```/gm)) {
+    if (match[1]) texts.push(match[1]);
+  }
+  let depth = 0;
+  let start = -1;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < message.length; i++) {
+    const ch = message[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (ch === "}") {
+      if (depth > 0) {
+        depth--;
+        if (depth === 0 && start !== -1) {
+          texts.push(message.slice(start, i + 1));
+          start = -1;
+        }
+      }
+    }
+  }
+  const out = [];
+  for (const text of texts) {
+    try {
+      const parsed = JSON.parse(text.trim());
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+function openDir(root) {
+  return path6.join(root, LEDGER_DIR, OPEN_SUBDIR);
+}
+function openFile(root, ref) {
+  return path6.join(openDir(root), `${ref}.json`);
+}
+var DEPTH_BASES = /* @__PURE__ */ new Set(["observed", "asserted-parent", "assumed-root"]);
+function _asOpenRecord(value, expectedRef) {
+  if (!isObject2(value)) return null;
+  const ref = value["ref"];
+  if (typeof ref !== "string" || ref !== expectedRef) return null;
+  if (typeof value["started_at"] !== "string") return null;
+  if (typeof value["depth"] !== "number" || !Number.isFinite(value["depth"])) return null;
+  if (typeof value["depth_basis"] !== "string" || !DEPTH_BASES.has(value["depth_basis"])) return null;
+  const agentType = value["agent_type"];
+  const parentRef = value["parent_ref"];
+  const sessionId = value["session_id"];
+  return {
+    ref,
+    agent_type: typeof agentType === "string" ? agentType : null,
+    started_at: value["started_at"],
+    parent_ref: typeof parentRef === "string" ? parentRef : null,
+    depth: value["depth"],
+    depth_basis: value["depth_basis"],
+    session_id: typeof sessionId === "string" ? sessionId : null
+  };
+}
+function readOpenRecords(root) {
+  const out = /* @__PURE__ */ new Map();
+  let names;
+  try {
+    names = fs6.readdirSync(openDir(root));
+  } catch {
+    return out;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const expectedRef = name.slice(0, -".json".length);
+    try {
+      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 {
+    }
+  }
+  return out;
+}
+function resolveDepth(parentRef, open) {
+  if (parentRef === null) return { depth: 1, depth_basis: "assumed-root" };
+  const parent = open.get(parentRef);
+  if (!parent) return { depth: 2, depth_basis: "asserted-parent" };
+  return { depth: parent.depth + 1, depth_basis: "observed" };
+}
+function ledgerFileFor(root, ts) {
+  return path6.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
+}
+function appendLedgerLine(root, ts, line) {
+  if (is_replay_mode()) return;
+  const file = ledgerFileFor(root, ts);
+  fs6.mkdirSync(path6.dirname(file), { recursive: true });
+  fs6.appendFileSync(file, `${JSON.stringify(line)}
+`, "utf8");
+}
+var WALL_CLOCK_ARMS_MS = [
+  { label: "5m", ms: 5 * 60 * 1e3 },
+  { label: "15m", ms: 15 * 60 * 1e3 },
+  { label: "30m", ms: 30 * 60 * 1e3 },
+  { label: "2h", ms: 2 * 60 * 60 * 1e3 }
+];
+function armsExceeded(elapsedMs) {
+  if (elapsedMs === null || !Number.isFinite(elapsedMs)) return [];
+  return WALL_CLOCK_ARMS_MS.filter((a) => elapsedMs >= a.ms).map((a) => a.label);
+}
+function openRecordStats(root, nowMs = Date.now()) {
+  const ledgerPresent = fs6.existsSync(path6.join(root, LEDGER_DIR));
+  const open = readOpenRecords(root);
+  let maxDepth = 0;
+  let counted = 0;
+  let stale = 0;
+  for (const rec of open.values()) {
+    const started = Date.parse(rec.started_at);
+    const isStale = Number.isFinite(started) && nowMs - started >= OPEN_RECORD_TTL_MS;
+    if (isStale) {
+      stale++;
+      continue;
+    }
+    counted++;
+    if (rec.depth > maxDepth) maxDepth = rec.depth;
+  }
+  return {
+    open_count: counted,
+    max_depth: maxDepth,
+    stale_excluded: stale,
+    ledger_present: ledgerPresent
+  };
+}
+function writeOpenRecord(root, rec) {
+  atomic_write_json(openFile(root, rec.ref), rec);
+}
+function removeOpenRecord(root, ref) {
+  if (is_replay_mode()) return;
+  try {
+    fs6.unlinkSync(openFile(root, ref));
+  } catch {
+  }
+}
+function countOpen(root) {
+  try {
+    return fs6.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+  } catch {
+    return 0;
+  }
+}
+function reapStaleOpenRecords(root, nowIso) {
+  const now = Date.parse(nowIso);
+  if (!Number.isFinite(now)) return 0;
+  let reaped = 0;
+  for (const rec of readOpenRecords(root).values()) {
+    const started = Date.parse(rec.started_at);
+    if (!Number.isFinite(started) || now - started < OPEN_RECORD_TTL_MS) continue;
+    removeOpenRecord(root, rec.ref);
+    reaped++;
+    appendLedgerLine(root, nowIso, {
+      event: "subagent_reaped",
+      ts: nowIso,
+      ref: rec.ref,
+      agent_type: rec.agent_type,
+      depth: rec.depth,
+      depth_basis: rec.depth_basis,
+      // R2 round 2, finding 5: the arm list is NOT repeated here. A reap
+      // fires only past OPEN_RECORD_TTL_MS (24 h), which exceeds every
+      // arm (largest: 2 h), so `stop_loss_arms_exceeded` would be a
+      // constant on this line — a field that cannot vary answers no
+      // question. `age_ms` carries strictly more information and is what
+      // a reader should aggregate over.
+      age_ms: now - started,
+      reason: "open record exceeded OPEN_RECORD_TTL_MS without a stop"
+    });
+  }
+  return reaped;
+}
+function appendUnidentified(root, event, nowIso, payload) {
+  appendLedgerLine(root, nowIso, {
+    event,
+    ts: nowIso,
+    ref: null,
+    unidentified: true,
+    // The agent TYPE is an id-shaped enum and may still be present; it is
+    // the only thing salvageable from a payload with no id.
+    agent_type: str2(payload, "agent_type", "agentType", "subagent_type", "subagentType"),
+    reason: "payload carried no agent id \u2014 nothing to correlate start with stop"
+  });
+}
+function handleStart(root, payload, nowIso, sessionId) {
+  const agentId = str2(payload, "agent_id", "agentId");
+  if (agentId === null) {
+    appendUnidentified(root, "subagent_start", nowIso, payload);
+    return;
+  }
+  const ref = refFor(agentId);
+  const parentId = extractParentId(payload, agentId);
+  const parentRef = parentId ? refFor(parentId) : null;
+  const { depth, depth_basis } = resolveDepth(parentRef, readOpenRecords(root));
+  const rec = {
+    ref,
+    agent_type: str2(payload, "agent_type", "agentType", "subagent_type", "subagentType"),
+    started_at: nowIso,
+    parent_ref: parentRef,
+    depth,
+    depth_basis,
+    session_id: sessionId
+  };
+  writeOpenRecord(root, rec);
+  appendLedgerLine(root, nowIso, {
+    event: "subagent_start",
+    ts: nowIso,
+    ref,
+    agent_type: rec.agent_type,
+    parent_ref: parentRef,
+    depth,
+    depth_basis,
+    concurrent_open: countOpen(root)
+  });
+}
+function handleStop(root, payload, nowIso) {
+  const agentId = str2(payload, "agent_id", "agentId");
+  if (agentId === null) {
+    appendUnidentified(root, "subagent_stop", nowIso, payload);
+    return;
+  }
+  const ref = refFor(agentId);
+  const rec = readOpenRecords(root).get(ref) ?? null;
+  let durationMs = null;
+  if (rec) {
+    const started = Date.parse(rec.started_at);
+    if (Number.isFinite(started)) durationMs = Math.max(0, Date.parse(nowIso) - started);
+  }
+  const parse2 = classifyEnvelope(str2(payload, "last_assistant_message", "lastAssistantMessage"));
+  removeOpenRecord(root, ref);
+  appendLedgerLine(root, nowIso, {
+    event: "subagent_stop",
+    ts: nowIso,
+    ref,
+    agent_type: rec?.agent_type ?? str2(payload, "agent_type", "agentType", "subagent_type", "subagentType"),
+    depth: rec?.depth ?? null,
+    depth_basis: rec?.depth_basis ?? null,
+    // `null` = the matching start was never seen. That is a finding about
+    // the instrument's own coverage and is recorded as such, not as 0.
+    duration_ms: durationMs,
+    // Phase 3 Step 3, shadow: which wall-clock arms this dispatch would
+    // have tripped. Recorded, never acted on.
+    stop_loss_arms_exceeded: armsExceeded(durationMs),
+    start_seen: rec !== null,
+    envelope_parse: parse2.verdict,
+    envelope_error_count: parse2.error_count,
+    concurrent_open: countOpen(root)
+  });
+}
+function processEnvelope(envelope, consumerRoot) {
+  try {
+    if (!isObject2(envelope)) return EXIT_ALLOW4;
+    const event = envelope["event"];
+    if (event !== "subagent_start" && event !== "subagent_stop") return EXIT_ALLOW4;
+    const payload = unwrapPayload(envelope);
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionId = str2(payload, "session_id", "sessionId") ?? str2(envelope, "session_id", "sessionId");
+    reapStaleOpenRecords(consumerRoot, nowIso);
+    if (event === "subagent_start") handleStart(consumerRoot, payload, nowIso, sessionId);
+    else handleStop(consumerRoot, payload, nowIso);
+  } catch {
+    return EXIT_ALLOW4;
+  }
+  return EXIT_ALLOW4;
+}
+function resolveConsumerRoot(envelope) {
+  if (isObject2(envelope)) {
+    const pr = str2(envelope, "workspace_root", "project_root");
+    if (pr) return pr;
+    const payload = unwrapPayload(envelope);
+    const cwd = str2(payload, "cwd");
+    if (cwd) return cwd;
+  }
+  return process.cwd();
+}
+function main6() {
+  const raw = readHookStdin();
+  let envelope = {};
+  try {
+    envelope = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return EXIT_ALLOW4;
+  }
+  return processEnvelope(envelope, resolveConsumerRoot(envelope));
+}
+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 {
+    return fs6.realpathSync(fileURLToPath6(import.meta.url)) === fs6.realpathSync(path6.resolve(process.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry6()) process.exit(main6());
+
 // src/scripts/hooks/turn_end_gate_hook.ts
 var EXIT_BLOCK2 = 1;
-var EXIT_ALLOW4 = 0;
+var EXIT_ALLOW5 = 0;
 var TRANSCRIPT_READ_MAX_BYTES = 8 * 1024 * 1024;
 function stripFencedBlocks(text) {
   const out = [];
@@ -1816,7 +2266,7 @@ function detectPromissory(reply) {
 }
 function readCiSettled(workspaceRoot) {
   try {
-    const raw = fs6.readFileSync(path6.join(workspaceRoot, STATE_FILE3), "utf-8");
+    const raw = fs7.readFileSync(path7.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"];
@@ -1850,7 +2300,7 @@ function detectCompletionClaim(reply, ci) {
 }
 function readLanguagePin(workspaceRoot) {
   try {
-    const raw = fs6.readFileSync(path6.join(workspaceRoot, STATE_FILE), "utf-8");
+    const raw = fs7.readFileSync(path7.join(workspaceRoot, STATE_FILE), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       const lang = decoded["language"];
@@ -1899,17 +2349,17 @@ function detectUnverifiedEdit(toolCalls) {
   };
 }
 function stateDir(workspaceRoot) {
-  return path6.join(workspaceRoot, "agents", "runtime", "state", "turn-end-gate");
+  return path7.join(workspaceRoot, "agents", "runtime", "state", "turn-end-gate");
 }
 function sessionStateFile2(workspaceRoot, sessionKey) {
-  return path6.join(stateDir(workspaceRoot), `${sessionKey}.json`);
+  return path7.join(stateDir(workspaceRoot), `${sessionKey}.json`);
 }
 function deriveSessionKey2(sessionId) {
-  return crypto2.createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
+  return crypto3.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 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;
@@ -1934,10 +2384,10 @@ function readTranscriptTail(transcriptPath, opts = {}) {
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs6.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs7.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs6.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs7.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
@@ -2010,33 +2460,41 @@ function _messageText(content) {
   }
   return parts.length > 0 ? parts.join("\n") : null;
 }
-function str2(v) {
+function str3(v) {
   return typeof v === "string" ? v : "";
 }
-function main6() {
+function main7() {
   let envelope;
   let payload;
   try {
     [envelope, payload] = unwrap(readHookStdin(), "claude");
   } catch {
-    return EXIT_ALLOW4;
+    return EXIT_ALLOW5;
+  }
+  if (payload["stop_hook_active"] === true) return EXIT_ALLOW5;
+  const workspaceRoot = str3(envelope["workspace_root"]) || process.cwd();
+  let dispatchOpen = false;
+  try {
+    dispatchOpen = openRecordStats(workspaceRoot).open_count > 0;
+  } catch {
   }
-  if (payload["stop_hook_active"] === true) return EXIT_ALLOW4;
-  const workspaceRoot = str2(envelope["workspace_root"]) || process.cwd();
-  const transcriptPath = str2(
+  const transcriptPath = str3(
     payload["transcript_path"] ?? payload["transcriptPath"]
   );
   const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
     maxBytes: TRANSCRIPT_READ_MAX_BYTES
   });
-  if (!lastAssistant) return EXIT_ALLOW4;
+  if (!lastAssistant) return EXIT_ALLOW5;
   const sessionKey = deriveSessionKey2(
-    str2(envelope["session_id"]) || "unknown-session"
+    str3(envelope["session_id"]) || "unknown-session"
   );
-  if (alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal)) return EXIT_ALLOW4;
+  if (alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal)) return EXIT_ALLOW5;
   const findings = [];
   for (const f of [
-    detectPromissory(lastAssistant),
+    // A and D are the completion-adjacent pair a pending dispatch excuses
+    // (Phase 3 Step 2, narrowed by R2 round 2 finding 2). B and C are not
+    // excused by anything about a dispatch and run unchanged.
+    dispatchOpen ? null : detectPromissory(lastAssistant),
     detectLanguage(lastAssistant, readLanguagePin(workspaceRoot)),
     detectUnverifiedEdit(toolCalls),
     // Round 7 § Phase 1 — detector D, in the same unconditional list as the
@@ -2046,11 +2504,11 @@ function main6() {
     // 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))
+    dispatchOpen ? null : detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot))
   ]) {
     if (f) findings.push(f);
   }
-  if (findings.length === 0) return EXIT_ALLOW4;
+  if (findings.length === 0) return EXIT_ALLOW5;
   markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, findings[0].detector);
   const lines = findings.map(
     (f) => `  \xB7 ${f.detector}: ${f.reason}
@@ -2065,37 +2523,37 @@ ${lines.join("\n")}
   );
   return EXIT_BLOCK2;
 }
-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(path7.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 = fs7.realpathSync(fileURLToPath7(import.meta.url));
+    const argv = fs7.realpathSync(path7.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry6()) {
-  process.exit(main6());
+if (_isCliEntry7()) {
+  process.exit(main7());
 }
 
 // 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;
+import crypto4 from "node:crypto";
+import fs8 from "node:fs";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
+var EXIT_ALLOW6 = 0;
 var EXIT_BLOCK3 = 1;
-var STATE_FILE4 = path7.join("agents", "state", "evidence-dispatch.json");
+var STATE_FILE4 = path8.join("agents", "state", "evidence-dispatch.json");
 function _isObject6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -2163,8 +2621,8 @@ function extractDispatch(envelope) {
 }
 function _ledgerStamp(consumer_root) {
   try {
-    const raw = fs7.readFileSync(
-      path7.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);
@@ -2175,7 +2633,7 @@ function _ledgerStamp(consumer_root) {
 }
 function _load(target) {
   try {
-    const decoded = JSON.parse(fs7.readFileSync(target, "utf8"));
+    const decoded = JSON.parse(fs8.readFileSync(target, "utf8"));
     if (_isObject6(decoded) && Array.isArray(decoded["evaluations"])) {
       return decoded;
     }
@@ -2186,7 +2644,7 @@ 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_ALLOW5, stdout: "", stderr: "", evaluations: priorEvaluations };
+    return { exit: EXIT_ALLOW6, stdout: "", stderr: "", evaluations: priorEvaluations };
   }
   const preloaded = preloadedVerdict(prompt);
   if (preloaded !== null) {
@@ -2199,11 +2657,11 @@ function decide2(tool, prompt, priorEvaluations) {
     };
   }
   if (!isSelfScoped(prompt)) {
-    return { exit: EXIT_ALLOW5, stdout: "", stderr: "", evaluations: priorEvaluations };
+    return { exit: EXIT_ALLOW6, stdout: "", stderr: "", evaluations: priorEvaluations };
   }
   if (priorEvaluations >= 1) {
     return {
-      exit: EXIT_ALLOW5,
+      exit: EXIT_ALLOW6,
       stdout: `${JSON.stringify({
         decision: "warn",
         reason: `Second evaluation dispatch of your own work in this turn. If both passes judge the SAME subject, that is verdict shopping \u2014 commissioning another with a different prompt or scope selects the answer instead of measuring it. Report what the first pass returned, then re-plan. If this is an implementation fan-out rather than a second review, carry on: this check reads prose and cannot tell the two apart with certainty.`
@@ -2214,7 +2672,7 @@ function decide2(tool, prompt, priorEvaluations) {
     };
   }
   return {
-    exit: EXIT_ALLOW5,
+    exit: EXIT_ALLOW6,
     stdout: `${JSON.stringify({ decision: "warn", reason: WARN_TEXT })}
 `,
     stderr: "",
@@ -2230,10 +2688,10 @@ function run5(stdin_text, options) {
         envelope = decoded;
       }
     } catch {
-      return EXIT_ALLOW5;
+      return EXIT_ALLOW6;
     }
   }
-  const target = path7.join(options.consumer_root, STATE_FILE4);
+  const target = path8.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)}`;
@@ -2247,7 +2705,7 @@ function run5(stdin_text, options) {
   if (decision.evaluations > state.evaluations.length) {
     state.evaluations.push({
       at: (/* @__PURE__ */ new Date()).toISOString(),
-      digest: crypto3.createHash("sha256").update(prompt).digest("hex").slice(0, 16),
+      digest: crypto4.createHash("sha256").update(prompt).digest("hex").slice(0, 16),
       prompt_chars: prompt.length
     });
     try {
@@ -2263,7 +2721,7 @@ function run5(stdin_text, options) {
   }
   return decision.exit;
 }
-function main7(argv) {
+function main8(argv) {
   const args = argv ?? process.argv.slice(2);
   let consumer_root = process.cwd();
   for (let i = 0; i < args.length; i += 1) {
@@ -2277,33 +2735,33 @@ function main7(argv) {
   }
   return run5(readHookStdin(), { consumer_root });
 }
-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(path8.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 = fs8.realpathSync(fileURLToPath8(import.meta.url));
+    const argv = fs8.realpathSync(path8.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry7()) {
-  process.exit(main7());
+if (_isCliEntry8()) {
+  process.exit(main8());
 }
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-import fs8 from "node:fs";
-import path8 from "node:path";
-import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
+import fs9 from "node:fs";
+import path9 from "node:path";
+import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
 
 // src/scripts/_lib/host_capability.ts
 import process2 from "node:process";
@@ -2630,7 +3088,7 @@ function resolveSubagentRouting(inp) {
 }
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-var EXIT_ALLOW6 = 0;
+var EXIT_ALLOW7 = 0;
 var EXIT_WARN3 = 2;
 function _isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -2791,34 +3249,34 @@ function _workspaceRoot(envelope) {
   }
   return process.cwd();
 }
-function main8() {
+function main9() {
   let envelope = {};
   try {
     const raw = readHookStdin();
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW6;
+    return EXIT_ALLOW7;
   }
   const env = _isObject7(envelope) ? envelope : {};
   const event = env["event"];
   const slot = typeof event === "string" && event !== "" ? event : "user_prompt_submit";
   if (slot !== "user_prompt_submit") {
-    return EXIT_ALLOW6;
+    return EXIT_ALLOW7;
   }
   const payload = _isObject7(env["payload"]) ? env["payload"] : env;
   const prompt = _extractPrompt2(payload);
   if (!prompt) {
-    return EXIT_ALLOW6;
+    return EXIT_ALLOW7;
   }
   if (isSyntheticPrompt(prompt)) {
-    return EXIT_ALLOW6;
+    return EXIT_ALLOW7;
   }
   const root = _workspaceRoot(env);
   const platform = env["platform"];
   const hostId = typeof platform === "string" && platform ? platform : null;
   const result = classifyPrompt(prompt, root, hostId);
   if (!result) {
-    return EXIT_ALLOW6;
+    return EXIT_ALLOW7;
   }
   process.stdout.write(
     `${JSON.stringify({
@@ -2830,31 +3288,31 @@ function main8() {
   );
   return EXIT_WARN3;
 }
-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(path9.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 = fs9.realpathSync(fileURLToPath9(import.meta.url));
+    const argv = fs9.realpathSync(path9.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry8()) {
-  process.exit(main8());
+if (_isCliEntry9()) {
+  process.exit(main9());
 }
 
 // src/scripts/conformance_scan.ts
-var REPO_ROOT = path9.resolve(path9.dirname(fileURLToPath9(import.meta.url)), "..", "..");
+var REPO_ROOT = path10.resolve(path10.dirname(fileURLToPath10(import.meta.url)), "..", "..");
 var OBSERVED_BAND = { low: 9.1, high: 39.2 };
 var BAND_MIN_TURNS = 1978;
 var CARRIER_CHANGES = [
@@ -3204,7 +3662,7 @@ function scanSession(sessionId, lines) {
   closeWindow();
   return report;
 }
-var DEFAULT_RATE_SERIES = path9.join(
+var DEFAULT_RATE_SERIES = path10.join(
   REPO_ROOT,
   "agents",
   "runtime",
@@ -3213,7 +3671,7 @@ var DEFAULT_RATE_SERIES = path9.join(
 );
 function defaultStore(projectDir) {
   const slug = projectStoreSlug(projectDir);
-  return path9.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
+  return path10.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
 }
 function _tokens(chars) {
   return Math.round(chars / 4);
@@ -3224,13 +3682,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   return {
     project: {
       dir: projectRulesDir,
-      present: fs9.existsSync(projectRulesDir),
+      present: fs10.existsSync(projectRulesDir),
       files: p.files,
       tokens: _tokens(p.chars)
     },
     global: {
       dir: globalRulesDir,
-      present: fs9.existsSync(globalRulesDir),
+      present: fs10.existsSync(globalRulesDir),
       files: g.files,
       tokens: _tokens(g.chars)
     },
@@ -3238,13 +3696,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   };
 }
 function storeKey(store) {
-  return createHash3("sha256").update(path9.resolve(store)).digest("hex").slice(0, 12);
+  return createHash4("sha256").update(path10.resolve(store)).digest("hex").slice(0, 12);
 }
 function scanStore(store, limit) {
-  const files = fs9.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs9.statSync(path9.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 = fs9.readFileSync(path9.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);
@@ -3272,10 +3730,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(
-    path9.join(REPO_ROOT, ".claude", "rules"),
-    path9.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 = path9.resolve(store) === path9.resolve(defaultStore(REPO_ROOT));
+  const ownStore = path10.resolve(store) === path10.resolve(defaultStore(REPO_ROOT));
   return {
     scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
     store,
@@ -3305,8 +3763,8 @@ function scanStore(store, limit) {
   };
 }
 function recordRate(file, scanned_at, rate) {
-  fs9.mkdirSync(path9.dirname(file), { recursive: true });
-  fs9.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) {
@@ -3405,7 +3863,7 @@ function render(report) {
   lines.push("    checkbox batching                     \u2014 measured NOWHERE. ~5 low-severity findings.");
   return lines.join("\n");
 }
-function main9(argv) {
+function main10(argv) {
   const args = argv ?? process.argv.slice(2);
   let store = null;
   let limit = 30;
@@ -3437,14 +3895,14 @@ function main9(argv) {
     return 2;
   }
   const resolved = store ?? defaultStore(process.cwd());
-  if (!fs9.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) {
-    fs9.writeFileSync(out, `${JSON.stringify(report, null, 2)}
+    fs10.writeFileSync(out, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   }
   if (record) {
@@ -3452,7 +3910,7 @@ function main9(argv) {
   }
   if (why !== null) {
     const id = why;
-    fs9.writeSync(
+    fs10.writeSync(
       1,
       json ? `${JSON.stringify(
         {
@@ -3472,48 +3930,48 @@ function main9(argv) {
     );
     return 0;
   }
-  fs9.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
+  fs10.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
 ` : `${render(report)}
 `);
   return 0;
 }
-function _isCliEntry9() {
+function _isCliEntry10() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL9(path9.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL10(path10.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs9.realpathSync(fileURLToPath9(import.meta.url));
-    const argv = fs9.realpathSync(path9.resolve(process.argv[1]));
+    const here = fs10.realpathSync(fileURLToPath10(import.meta.url));
+    const argv = fs10.realpathSync(path10.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry9()) {
-  process.exit(main9());
+if (_isCliEntry10()) {
+  process.exit(main10());
 }
 
 // src/scripts/report_carrier_divergence.ts
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 import * as os3 from "node:os";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 import process3 from "node:process";
-import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
-var _HERE = fileURLToPath10(import.meta.url);
-var REPO_ROOT2 = path10.resolve(path10.dirname(_HERE), "..", "..");
-var PROJECT_RULES = path10.join(".claude", "rules");
-var PROJECTION_SOURCE = path10.join("dist", "agent-src", "rules");
-var GLOBAL_RULES = path10.join(".claude", "rules");
+import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
+var _HERE = fileURLToPath11(import.meta.url);
+var REPO_ROOT2 = path11.resolve(path11.dirname(_HERE), "..", "..");
+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 fs10.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    return fs11.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -3521,7 +3979,7 @@ function _listRules(dir) {
 function _ruleType(file) {
   let text;
   try {
-    text = fs10.readFileSync(file, "utf-8");
+    text = fs11.readFileSync(file, "utf-8");
   } catch {
     return "";
   }
@@ -3532,8 +3990,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
   const out = {
     projectDir,
     globalDir,
-    globalPresent: fs10.existsSync(globalDir),
-    projectPresent: fs10.existsSync(projectDir),
+    globalPresent: fs11.existsSync(globalDir),
+    projectPresent: fs11.existsSync(projectDir),
     shared: 0,
     identical: [],
     provenanceOnly: [],
@@ -3556,7 +4014,7 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     }
     if (!inP && inG) {
       out.globalOnly.push(rule);
-      if (sourceDir !== void 0 && _ruleType(path10.join(sourceDir, rule)) === "manual") {
+      if (sourceDir !== void 0 && _ruleType(path11.join(sourceDir, rule)) === "manual") {
         out.manualOnlyGlobal.push(rule);
       }
       continue;
@@ -3566,8 +4024,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     let projectCopy;
     let globalCopy;
     try {
-      projectCopy = fs10.readFileSync(path10.join(projectDir, rule));
-      globalCopy = fs10.readFileSync(path10.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;
@@ -3712,11 +4170,11 @@ function render2(d) {
   }
   return lines.join("\n");
 }
-function main10(argv) {
+function main11(argv) {
   const args = argv ?? process3.argv.slice(2);
-  let projectDir = path10.join(REPO_ROOT2, PROJECT_RULES);
-  let globalDir = path10.join(os3.homedir(), GLOBAL_RULES);
-  let sourceDir = path10.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;
@@ -3730,7 +4188,7 @@ function main10(argv) {
 `);
         return 1;
       }
-      const resolved = path10.resolve(v);
+      const resolved = path11.resolve(v);
       if (a === "--project") projectDir = resolved;
       else if (a === "--global") globalDir = resolved;
       else sourceDir = resolved;
@@ -3750,44 +4208,44 @@ function main10(argv) {
 `);
   return 0;
 }
-function _isCliEntry10() {
+function _isCliEntry11() {
   if (process3.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL10(path10.resolve(process3.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL11(path11.resolve(process3.argv[1])).href) return true;
   try {
-    return fs10.realpathSync(_HERE) === fs10.realpathSync(path10.resolve(process3.argv[1]));
+    return fs11.realpathSync(_HERE) === fs11.realpathSync(path11.resolve(process3.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry10()) {
-  process3.exit(main10());
+if (_isCliEntry11()) {
+  process3.exit(main11());
 }
 
 // src/scripts/report_skill_activation.ts
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os4 from "node:os";
-import * as path11 from "node:path";
-import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
-var _HERE2 = fileURLToPath11(import.meta.url);
-var REPO_ROOT3 = path11.resolve(path11.dirname(_HERE2), "..", "..");
+import * as path12 from "node:path";
+import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
+var _HERE2 = fileURLToPath12(import.meta.url);
+var REPO_ROOT3 = path12.resolve(path12.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 (!fs11.existsSync(root)) {
+  if (!fs12.existsSync(root)) {
     return out;
   }
-  for (const entry of fs11.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 = path11.join(root, entry.name, "SKILL.md");
-    if (!fs11.existsSync(file)) {
+    const file = path12.join(root, entry.name, "SKILL.md");
+    if (!fs12.existsSync(file)) {
       continue;
     }
     out.total += 1;
-    const text = fs11.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))) {
@@ -3801,17 +4259,17 @@ function censusSkills(root) {
   return out;
 }
 function defaultStore2(cwd) {
-  return path11.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 (!fs11.existsSync(store)) {
+  if (!fs12.existsSync(store)) {
     return rep;
   }
-  const files = fs11.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path11.join(store, f)).sort((a, b) => fs11.statSync(b).mtimeMs - fs11.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 fs11.readFileSync(file, "utf8").split("\n")) {
+    for (const line of fs12.readFileSync(file, "utf8").split("\n")) {
       if (!line.trim()) {
         continue;
       }
@@ -3874,7 +4332,7 @@ function render3(census, usage) {
     }
     totalInv += u.invocations;
     lines.push(
-      `  ${path11.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("");
@@ -3899,7 +4357,7 @@ function render3(census, usage) {
   lines.push("  catalogue once per session, then count descriptions against bare names.");
   return lines.join("\n");
 }
-function main11(argv) {
+function main12(argv) {
   let limit = 30;
   const stores = [];
   for (let i = 0; i < argv.length; i += 1) {
@@ -3922,24 +4380,24 @@ function main11(argv) {
   if (stores.length === 0) {
     stores.push(defaultStore2(REPO_ROOT3));
   }
-  const census = censusSkills(path11.join(REPO_ROOT3, SKILLS_ROOT));
+  const census = censusSkills(path12.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 === pathToFileURL11(path11.resolve(process.argv[1])).href) {
-  process.exit(main11(process.argv.slice(2)));
+if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL12(path12.resolve(process.argv[1])).href) {
+  process.exit(main12(process.argv.slice(2)));
 }
 
 // src/scripts/report_skill_obligation_violations.ts
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import * as os5 from "node:os";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 import process4 from "node:process";
-import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
-var _HERE3 = fileURLToPath12(import.meta.url);
-var REPO_ROOT4 = path12.resolve(path12.dirname(_HERE3), "..", "..");
+import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL13 } from "node:url";
+var _HERE3 = fileURLToPath13(import.meta.url);
+var REPO_ROOT4 = path13.resolve(path13.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;
@@ -3977,7 +4435,7 @@ function _artefacts(line) {
   return out;
 }
 function extractObligations(repoRoot) {
-  const skillsRoot = path12.join(repoRoot, SKILLS_ROOT);
+  const skillsRoot = path13.join(repoRoot, SKILLS_ROOT);
   const census = censusSkills(skillsRoot);
   const out = {
     skills: census.withDeterministicObligation,
@@ -3991,7 +4449,7 @@ function extractObligations(repoRoot) {
   for (const skill of census.withDeterministicObligation) {
     let text;
     try {
-      text = fs12.readFileSync(path12.join(skillsRoot, skill, "SKILL.md"), "utf-8");
+      text = fs13.readFileSync(path13.join(skillsRoot, skill, "SKILL.md"), "utf-8");
     } catch {
       continue;
     }
@@ -4107,7 +4565,7 @@ function scanSessionForViolations(session, lines, forbidden, parsed) {
   return flags;
 }
 function defaultStore3(cwd) {
-  return path12.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);
@@ -4120,14 +4578,14 @@ function scanStore2(repoRoot, store, limit) {
   };
   let files;
   try {
-    files = fs12.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path12.join(store, f), m: fs12.statSync(path12.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 = fs12.readFileSync(file, "utf-8").split("\n");
-    const id = path12.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));
@@ -4197,7 +4655,7 @@ function render4(r) {
   lines.push("  ships as detection-only, and this one says so.");
   return lines.join("\n");
 }
-function main12(argv) {
+function main13(argv) {
   const args = argv ?? process4.argv.slice(2);
   let limit = 30;
   let json = false;
@@ -4250,35 +4708,35 @@ 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(path13.resolve(process4.argv[1])).href) return true;
   try {
-    return fs12.realpathSync(_HERE3) === fs12.realpathSync(path12.resolve(process4.argv[1]));
+    return fs13.realpathSync(_HERE3) === fs13.realpathSync(path13.resolve(process4.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry11()) {
-  process4.exit(main12());
+if (_isCliEntry12()) {
+  process4.exit(main13());
 }
 
 // src/scripts/report_conformance_funnel.ts
-var _HERE4 = fileURLToPath13(import.meta.url);
-var REPO_ROOT5 = path13.resolve(path13.dirname(_HERE4), "..", "..");
+var _HERE4 = fileURLToPath14(import.meta.url);
+var REPO_ROOT5 = path14.resolve(path14.dirname(_HERE4), "..", "..");
 function buildFunnel(opts = {}) {
   const repoRoot = opts.repoRoot ?? REPO_ROOT5;
-  const projectRulesDir = opts.projectRulesDir ?? path13.join(repoRoot, PROJECT_RULES);
-  const globalRulesDir = opts.globalRulesDir ?? path13.join(os6.homedir(), GLOBAL_RULES);
-  const sourceDir = opts.sourceDir ?? path13.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(path13.join(repoRoot, SKILLS_ROOT)),
+    skills: censusSkills(path14.join(repoRoot, SKILLS_ROOT)),
     usage: measureUsage(store, limit),
-    storePresent: fs13.existsSync(store),
+    storePresent: fs14.existsSync(store),
     sk2: scanStore2(repoRoot, store, limit)
   };
 }
@@ -4403,7 +4861,7 @@ function render5(r) {
   lines.push("workflow without a measured false-positive rate first (locked policy).");
   return lines.join("\n");
 }
-function main13(argv) {
+function main14(argv) {
   const args = argv ?? process5.argv.slice(2);
   const opts = {};
   const value = (i) => {
@@ -4419,7 +4877,7 @@ function main13(argv) {
 `);
         return 1;
       }
-      const resolved = path13.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;
@@ -4449,21 +4907,21 @@ function main13(argv) {
 `);
   return 0;
 }
-function _isCliEntry12() {
+function _isCliEntry13() {
   if (process5.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL13(path13.resolve(process5.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL14(path14.resolve(process5.argv[1])).href) return true;
   try {
-    return fs13.realpathSync(_HERE4) === fs13.realpathSync(path13.resolve(process5.argv[1]));
+    return fs14.realpathSync(_HERE4) === fs14.realpathSync(path14.resolve(process5.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry12()) {
-  process5.exit(main13());
+if (_isCliEntry13()) {
+  process5.exit(main14());
 }
 
 // src/scripts/_cli/cmd_conformance.ts
-var _HERE5 = fileURLToPath14(import.meta.url);
+var _HERE5 = fileURLToPath15(import.meta.url);
 var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
 var CONFORMANCE_CHECK_IDS = [
   "txlog-clean",
@@ -4486,17 +4944,17 @@ function conformanceLogPath() {
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path14.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
+  return path15.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
 }
 function installLogPath() {
   const override = process6.env["AGENT_CONFIG_INSTALL_LOG"];
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path14.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 (!fs14.existsSync(logPath)) {
+  if (!fs15.existsSync(logPath)) {
     return {
       id: "txlog-clean",
       status: "ok",
@@ -4530,11 +4988,11 @@ function _check_txlog_clean(logPath = installLogPath()) {
   };
 }
 function routeTargetPaths(target) {
-  return routeTargetPathsPosix(target).map((rel) => path14.join(...rel.split("/")));
+  return routeTargetPathsPosix(target).map((rel) => path15.join(...rel.split("/")));
 }
 function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
-  const routerPath = path14.join(packageRoot, "dist", "router.json");
-  if (!fs14.existsSync(routerPath)) {
+  const routerPath = path15.join(packageRoot, "dist", "router.json");
+  if (!fs15.existsSync(routerPath)) {
     return {
       id: "router-pointers",
       status: "fail",
@@ -4544,7 +5002,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
   }
   let router;
   try {
-    router = JSON.parse(fs14.readFileSync(routerPath, "utf8"));
+    router = JSON.parse(fs15.readFileSync(routerPath, "utf8"));
   } catch (exc) {
     return {
       id: "router-pointers",
@@ -4553,13 +5011,13 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
       remedy: "reinstall the package \u2014 dist/router.json is corrupt"
     };
   }
-  const rulesDir = path14.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 (!fs14.existsSync(path14.join(rulesDir, `${kernelId}.md`))) {
+    if (!fs15.existsSync(path15.join(rulesDir, `${kernelId}.md`))) {
       broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
     }
   }
@@ -4567,7 +5025,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
     for (const entry of router[tier] ?? []) {
       const ruleId = String(entry["id"] ?? "");
       ids += 1;
-      if (!fs14.existsSync(path14.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"] ?? []) {
@@ -4577,7 +5035,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
           broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
           continue;
         }
-        if (!candidates.some((rel) => fs14.existsSync(path14.join(packageRoot, rel)))) {
+        if (!candidates.some((rel) => fs15.existsSync(path15.join(packageRoot, rel)))) {
           broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
         }
       }
@@ -4609,9 +5067,9 @@ function detectSmokePlatform(projectRoot) {
   return "claude";
 }
 function dispatcherRunner(packageRoot) {
-  const localTsx = path14.join(packageRoot, "node_modules", ".bin", "tsx");
-  const script = path14.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
-  if (fs14.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];
@@ -4661,12 +5119,12 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT, opts =
   };
 }
 function readSettingsMode(projectRoot) {
-  const settingsPath = path14.join(projectRoot, ".agent-settings.yml");
-  if (!fs14.existsSync(settingsPath)) {
+  const settingsPath = path15.join(projectRoot, ".agent-settings.yml");
+  if (!fs15.existsSync(settingsPath)) {
     return "eager-all";
   }
   try {
-    const parsed = YAML.parse(fs14.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";
@@ -4677,7 +5135,7 @@ function readSettingsMode(projectRoot) {
 function kernelIdsFromRouter(packageRoot) {
   try {
     const router = JSON.parse(
-      fs14.readFileSync(path14.join(packageRoot, "dist", "router.json"), "utf8")
+      fs15.readFileSync(path15.join(packageRoot, "dist", "router.json"), "utf8")
     );
     return new Set((router["kernel"] ?? []).map(String));
   } catch {
@@ -4694,8 +5152,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 ?? path14.join(projectRoot, ".augment", "rules");
-  if (!fs14.existsSync(rulesDir)) {
+  const rulesDir = projectedRulesDir ?? path15.join(projectRoot, ".augment", "rules");
+  if (!fs15.existsSync(rulesDir)) {
     return {
       id: "lean-projection",
       status: "skipped",
@@ -4704,7 +5162,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
     };
   }
   const kernel = kernelIdsFromRouter(packageRoot);
-  const files = fs14.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 {
@@ -4718,7 +5176,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
   for (const f of nonKernel) {
     let text = "";
     try {
-      text = fs14.readFileSync(path14.join(rulesDir, f), "utf8");
+      text = fs15.readFileSync(path15.join(rulesDir, f), "utf8");
     } catch {
       continue;
     }
@@ -4749,8 +5207,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 = path14.join(projectRoot, ".agent-settings.yml");
-  if (!fs14.existsSync(settingsPath)) {
+  const settingsPath = path15.join(projectRoot, ".agent-settings.yml");
+  if (!fs15.existsSync(settingsPath)) {
     return {
       id: "host-manifest",
       status: "ok",
@@ -4760,7 +5218,7 @@ function _check_host_manifest(projectRoot) {
   }
   let parsed = null;
   try {
-    parsed = YAML.parse(fs14.readFileSync(settingsPath, "utf8"));
+    parsed = YAML.parse(fs15.readFileSync(settingsPath, "utf8"));
   } catch (exc) {
     return {
       id: "host-manifest",
@@ -4859,7 +5317,7 @@ function _parse(argv) {
   }
   return opts;
 }
-function main14(argv = null) {
+function main15(argv = null) {
   const opts = _parse(argv !== null ? Array.from(argv) : process6.argv.slice(2));
   if (opts.funnel) {
     print(render5(buildFunnel()));
@@ -4930,25 +5388,25 @@ function main14(argv = null) {
   }
   return failed ? 1 : 0;
 }
-function _isCliEntry13() {
+function _isCliEntry14() {
   if (process6.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL14(path14.resolve(process6.argv[1])).href;
+  const argvUrl = pathToFileURL15(path15.resolve(process6.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs14.realpathSync(fileURLToPath14(import.meta.url));
-    const argv = fs14.realpathSync(path14.resolve(process6.argv[1]));
+    const here = fs15.realpathSync(fileURLToPath15(import.meta.url));
+    const argv = fs15.realpathSync(path15.resolve(process6.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry13() || process6.argv[1] === _HERE5) {
+if (_isCliEntry14() || process6.argv[1] === _HERE5) {
   try {
-    process6.exitCode = main14(process6.argv.slice(2));
+    process6.exitCode = main15(process6.argv.slice(2));
   } catch (e) {
     if (e instanceof ArgparseExit) {
       process6.exitCode = e.code;
@@ -4971,7 +5429,7 @@ export {
   conformanceLogPath,
   detectSmokePlatform,
   installLogPath,
-  main14 as main,
+  main15 as main,
   routeTargetPaths,
   runConformanceChecks
 };