@event4u/agent-config 14.17.0 → 14.19.0

package/dist/cli-delegate/cmd_adr_effective.js

@@ -6,16 +6,16 @@ import {
 import "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_adr_effective.ts
-import * as fs2 from "node:fs";
-import * as path3 from "node:path";
-import process4 from "node:process";
-import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
+import process5 from "node:process";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
 
 // src/scripts/adr_cite_check.ts
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import * as os from "node:os";
-import * as path2 from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import * as path3 from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 
 // src/scripts/_lib/adr_frontmatter.ts
 var FOLD_MARKERS = /* @__PURE__ */ new Set([">", ">-", ">+", "|", "|-", "|+"]);
@@ -218,9 +218,234 @@ function isLowEvidenceAccepted(fm) {
   const evidence = evidenceOf(fm);
   return evidence?.strength === "E0" || evidence?.strength === "E1";
 }
+var DATED_TRIGGER_RE = /^\s*(?:expir(?:y|es)\b\s*[:—-]?\s*)?(\d{4})-(\d{2})-(\d{2})(?!\d)/iu;
+var DATED_TRIGGER_PROBE = /^\s*(?:expir(?:y|es)\b|\d{4}-\d{1,2}-\d{1,2}\b)/iu;
+function iso_day(d) {
+  return d.toISOString().slice(0, 10);
+}
+function dated_trigger_day(trigger) {
+  const m = DATED_TRIGGER_RE.exec(trigger);
+  if (m === null) return null;
+  const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  const at = new Date(Date.UTC(y, mo - 1, d));
+  if (at.getUTCFullYear() !== y || at.getUTCMonth() !== mo - 1 || at.getUTCDate() !== d) {
+    return null;
+  }
+  return iso_day(at);
+}
 
-// src/scripts/_lib/gate_ledger.ts
+// src/scripts/_lib/as_of.ts
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import process2 from "node:process";
+import { fileURLToPath } from "node:url";
+var AsOfPinError = class extends Error {
+};
+var REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+function readArgvPin(argv) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i] ?? "";
+    if (arg === "--as-of") return argv[i + 1] ?? "";
+    if (arg.startsWith("--as-of=")) return arg.slice("--as-of=".length);
+  }
+  return void 0;
+}
+function parsePin(raw, source) {
+  const trimmed = raw.trim();
+  const ms = Date.parse(trimmed);
+  if (trimmed === "" || Number.isNaN(ms)) {
+    throw new AsOfPinError(
+      `${source} is not a parseable date: ${JSON.stringify(raw)}. Pass an ISO-8601 instant, e.g. 2026-08-23T00:00:00Z.`
+    );
+  }
+  return new Date(ms);
+}
+function inCi(env) {
+  const raw = (env.CI ?? "").trim().toLowerCase();
+  return raw !== "" && raw !== "0" && raw !== "false";
+}
+function headCommitDate(cwd = REPO_ROOT) {
+  const res = spawnSync("git", ["log", "-1", "--format=%cI", "HEAD"], {
+    cwd,
+    encoding: "utf-8"
+  });
+  if (res.status !== 0) return null;
+  const iso = (res.stdout ?? "").trim();
+  if (iso === "") return null;
+  const ms = Date.parse(iso);
+  return Number.isNaN(ms) ? null : new Date(ms);
+}
+function resolveAsOf(sources = {}) {
+  const argv = sources.argv ?? process2.argv.slice(2);
+  const env = sources.env ?? process2.env;
+  const argvPin = readArgvPin(argv);
+  if (argvPin !== void 0) {
+    return { at: parsePin(argvPin, "--as-of"), rung: "argv", reproducible: true };
+  }
+  const envPin = env.AC_AS_OF;
+  if (envPin !== void 0 && envPin.trim() !== "") {
+    return { at: parsePin(envPin, "AC_AS_OF"), rung: "env", reproducible: true };
+  }
+  if (inCi(env)) {
+    const commit = (sources.commitDate ?? headCommitDate)();
+    if (commit !== null) {
+      return { at: commit, rung: "commit", reproducible: true };
+    }
+  }
+  const warn = sources.warn ?? ((line) => process2.stderr.write(line));
+  const at = (sources.wallClock ?? (() => /* @__PURE__ */ new Date()))();
+  warn(
+    `\u26A0\uFE0F  as-of: unpinned run \u2014 using the wall clock (${at.toISOString()}); this verdict is not reproducible. Pass --as-of <iso> or set AC_AS_OF to pin it.
+`
+  );
+  return { at, rung: "wall-clock", reproducible: false };
+}
+var cached = null;
+function asOfResolution() {
+  cached ??= resolveAsOf();
+  return cached;
+}
+function asOf() {
+  return new Date(asOfResolution().at.getTime());
+}
+function tsxBin() {
+  return path.join(
+    REPO_ROOT,
+    "node_modules",
+    ".bin",
+    process2.platform === "win32" ? "tsx.cmd" : "tsx"
+  );
+}
+function runSelf(args, env) {
+  const res = spawnSync(tsxBin(), [fileURLToPath(import.meta.url), ...args], {
+    cwd: REPO_ROOT,
+    encoding: "utf-8",
+    env
+  });
+  return {
+    status: res.status ?? 1,
+    stdout: res.stdout ?? "",
+    stderr: res.stderr ?? ""
+  };
+}
+function bareEnv() {
+  const env = { ...process2.env };
+  delete env.AC_AS_OF;
+  delete env.CI;
+  delete env.GITHUB_ACTIONS;
+  return env;
+}
+function selfTest(write) {
+  const commit = headCommitDate();
+  let failed = 0;
+  let checks = 0;
+  const expect = (name, ok, detail) => {
+    checks += 1;
+    if (ok) {
+      write(`\u2705  ${name}
+`);
+    } else {
+      write(`\u274C  ${name}: ${detail}
+`);
+      failed += 1;
+    }
+  };
+  const argvRun = runSelf(["--print", "--as-of", "2026-01-02T03:04:05Z"], bareEnv());
+  expect(
+    "rung 1 (argv) \u2014 an explicit --as-of wins",
+    argvRun.status === 0 && argvRun.stdout.includes("rung=argv") && argvRun.stdout.includes("at=2026-01-02T03:04:05.000Z"),
+    `exit ${String(argvRun.status)}, stdout ${JSON.stringify(argvRun.stdout)}`
+  );
+  const precedence = runSelf(["--print", "--as-of=2026-01-02T03:04:05Z"], {
+    ...bareEnv(),
+    AC_AS_OF: "2020-01-01T00:00:00Z"
+  });
+  expect(
+    "rung 1 precedence \u2014 --as-of= overrides AC_AS_OF",
+    precedence.status === 0 && precedence.stdout.includes("rung=argv") && precedence.stdout.includes("at=2026-01-02T03:04:05.000Z"),
+    `exit ${String(precedence.status)}, stdout ${JSON.stringify(precedence.stdout)}`
+  );
+  const envRun = runSelf(["--print"], { ...bareEnv(), AC_AS_OF: "2025-06-07T08:09:10Z" });
+  expect(
+    "rung 2 (env) \u2014 AC_AS_OF answers when argv is silent",
+    envRun.status === 0 && envRun.stdout.includes("rung=env") && envRun.stdout.includes("at=2025-06-07T08:09:10.000Z"),
+    `exit ${String(envRun.status)}, stdout ${JSON.stringify(envRun.stdout)}`
+  );
+  const ciRun = runSelf(["--print"], { ...bareEnv(), CI: "true" });
+  expect(
+    "rung 3 (commit) \u2014 CI pins to the tree under test",
+    ciRun.status === 0 && ciRun.stdout.includes("rung=commit") && commit !== null && ciRun.stdout.includes(`at=${commit.toISOString()}`),
+    `exit ${String(ciRun.status)}, stdout ${JSON.stringify(ciRun.stdout)}, HEAD date ${commit === null ? "UNAVAILABLE" : commit.toISOString()}`
+  );
+  const wallRun = runSelf(["--print"], bareEnv());
+  expect(
+    "rung 4 (wall-clock) \u2014 unpinned runs resolve and WARN once",
+    wallRun.status === 0 && wallRun.stdout.includes("rung=wall-clock") && wallRun.stdout.includes("reproducible=false") && wallRun.stderr.includes("not reproducible"),
+    `exit ${String(wallRun.status)}, stdout ${JSON.stringify(wallRun.stdout)}, stderr ${JSON.stringify(wallRun.stderr)}`
+  );
+  const badArgv = runSelf(["--print", "--as-of", "not-a-date"], bareEnv());
+  expect(
+    "malformed --as-of is rejected, not downgraded",
+    badArgv.status !== 0 && badArgv.stderr.includes("not a parseable date"),
+    `exit ${String(badArgv.status)}, stderr ${JSON.stringify(badArgv.stderr)}`
+  );
+  const badEnv = runSelf(["--print"], { ...bareEnv(), AC_AS_OF: "2026-13-45" });
+  expect(
+    "malformed AC_AS_OF is rejected, not downgraded",
+    badEnv.status !== 0 && badEnv.stderr.includes("not a parseable date"),
+    `exit ${String(badEnv.status)}, stderr ${JSON.stringify(badEnv.stderr)}`
+  );
+  const FLOOR = 7;
+  if (checks < FLOOR) {
+    write(
+      `\u274C  as_of --self-test: ${String(checks)} case(s) is below the declared floor of ${String(FLOOR)}.
+`
+    );
+    return 1;
+  }
+  write(
+    `
+as_of --self-test: ${String(checks - failed)}/${String(checks)} case(s) behaved (floor ${String(FLOOR)})
+`
+  );
+  return failed > 0 ? 1 : 0;
+}
+function main(argv) {
+  if (argv.includes("--self-test")) {
+    return selfTest((chunk) => process2.stdout.write(chunk));
+  }
+  let res;
+  try {
+    res = resolveAsOf({ argv });
+  } catch (e) {
+    if (e instanceof AsOfPinError) {
+      process2.stderr.write(`\u274C  as-of: ${e.message}
+`);
+      return 2;
+    }
+    throw e;
+  }
+  process2.stdout.write(
+    `rung=${res.rung} at=${res.at.toISOString()} reproducible=${String(res.reproducible)}
+`
+  );
+  return 0;
+}
+function isCliEntry() {
+  if (process2.argv[1] === void 0) return false;
+  try {
+    return fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(path.resolve(process2.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (isCliEntry()) {
+  process2.exit(main(process2.argv.slice(2)));
+}
+
+// src/scripts/_lib/gate_ledger.ts
+import process3 from "node:process";
 var SKIP_REASON_MESSAGE = {
   excluded_directory: "the target sits under a directory this gate deliberately does not walk",
   size_limit: "the target exceeds the size ceiling this gate reads within",
@@ -368,7 +593,7 @@ var GateLedger = class {
    *
    * @throws {UnaccountedTargetsError} via {@link finalize}.
    */
-  report(write = process2.stdout.write.bind(process2.stdout)) {
+  report(write = process3.stdout.write.bind(process3.stdout)) {
     const tally = this.finalize();
     const checked = tally.completed + tally.failed;
     const parts = [
@@ -389,27 +614,27 @@ var GateLedger = class {
 };
 
 // src/scripts/_lib/gate_self_test.ts
-import { spawnSync } from "node:child_process";
-import * as path from "node:path";
-import process3 from "node:process";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import * as path2 from "node:path";
+import process4 from "node:process";
 function runGateCli(repoRoot, scriptRelPath, args, cwd) {
-  const tsx = path.join(
+  const tsx = path2.join(
     repoRoot,
     "node_modules",
     ".bin",
-    process3.platform === "win32" ? "tsx.cmd" : "tsx"
+    process4.platform === "win32" ? "tsx.cmd" : "tsx"
   );
-  const res = spawnSync(tsx, [path.join(repoRoot, scriptRelPath), ...args], {
+  const res = spawnSync2(tsx, [path2.join(repoRoot, scriptRelPath), ...args], {
     cwd,
     encoding: "utf-8",
     maxBuffer: 64 * 1024 * 1024,
     // The child must not recurse into its own self-test.
-    env: { ...process3.env, GATE_SELF_TEST_CHILD: "1" }
+    env: { ...process4.env, GATE_SELF_TEST_CHILD: "1" }
   });
   return res.status ?? 1;
 }
 function runSelfTest(opts) {
-  const write = opts.write ?? process3.stdout.write.bind(process3.stdout);
+  const write = opts.write ?? process4.stdout.write.bind(process4.stdout);
   const minReject = opts.minRejectCases ?? 1;
   const rejectCases = opts.cases.filter((c) => c.expect === "reject").length;
   if (opts.cases.length < opts.minCases || rejectCases < minReject) {
@@ -451,10 +676,10 @@ ${opts.gate} --self-test: ${String(opts.cases.length - failed)}/${String(opts.ca
 }
 
 // src/scripts/adr_cite_check.ts
-var _HERE = path2.dirname(fileURLToPath(import.meta.url));
-var REPO_ROOT = path2.resolve(_HERE, "..", "..");
+var _HERE = path3.dirname(fileURLToPath2(import.meta.url));
+var REPO_ROOT2 = path3.resolve(_HERE, "..", "..");
 function scan_root() {
-  return process.env["ADR_CITE_CHECK_ROOT"] ?? REPO_ROOT;
+  return process.env["ADR_CITE_CHECK_ROOT"] ?? REPO_ROOT2;
 }
 var ADR_DIRS = ["docs/decisions", "docs/adrs"];
 var SURFACES_NOT_SCANNED = [
@@ -486,36 +711,36 @@ function normalise_ref(ref) {
   return { id: `ADR-${m[1].padStart(3, "0")}`, area: null, num: String(Number(m[1])) };
 }
 function walk_md(dir) {
-  if (!fs.existsSync(dir)) return [];
+  if (!fs2.existsSync(dir)) return [];
   const out = [];
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    const full = path2.join(dir, entry.name);
+  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    const full = path3.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...walk_md(full));
     else if (entry.name.endsWith(".md") && entry.name !== "INDEX.md") out.push(full);
   }
   return out.sort();
 }
-function adr_files(repo_root = REPO_ROOT) {
-  return ADR_DIRS.flatMap((d) => walk_md(path2.join(repo_root, d)));
+function adr_files(repo_root = REPO_ROOT2) {
+  return ADR_DIRS.flatMap((d) => walk_md(path3.join(repo_root, d)));
 }
 var CITATION_ROOTS = ["src/rules", "src/skills", "src/domains", "docs"];
 var CITATION_FILE_EXTS = /* @__PURE__ */ new Set([".md", ".ts", ".yml", ".yaml"]);
 var CITATION_RE = /ADR-(?:[a-z][a-z0-9]*-\d{1,4}|\d{1,4})(?![0-9A-Za-z])/g;
 function walk_citable(dir) {
-  if (!fs.existsSync(dir)) return [];
+  if (!fs2.existsSync(dir)) return [];
   const out = [];
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    const full = path2.join(dir, entry.name);
+  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    const full = path3.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...walk_citable(full));
-    else if (CITATION_FILE_EXTS.has(path2.extname(entry.name))) out.push(full);
+    else if (CITATION_FILE_EXTS.has(path3.extname(entry.name))) out.push(full);
   }
   return out.sort();
 }
-function cited_refs(repo_root = REPO_ROOT) {
+function cited_refs(repo_root = REPO_ROOT2) {
   const found = /* @__PURE__ */ new Set();
   for (const root of CITATION_ROOTS) {
-    for (const file of walk_citable(path2.join(repo_root, root))) {
-      for (const m of fs.readFileSync(file, "utf-8").matchAll(CITATION_RE)) {
+    for (const file of walk_citable(path3.join(repo_root, root))) {
+      for (const m of fs2.readFileSync(file, "utf-8").matchAll(CITATION_RE)) {
         found.add(m[0]);
       }
     }
@@ -535,7 +760,7 @@ function unresolved_basis_refs(basis, repo_root) {
   const missing = [];
   for (const ref of basis) {
     if (basis_ref_kind(ref) !== "path") continue;
-    if (!fs.existsSync(path2.join(repo_root, basis_ref_path(ref)))) missing.push(ref);
+    if (!fs2.existsSync(path3.join(repo_root, basis_ref_path(ref)))) missing.push(ref);
   }
   return missing;
 }
@@ -557,10 +782,13 @@ function amendment_blocks(body) {
   }
   return found;
 }
-function trigger_state(fm) {
+function trigger_state(fm, asOfDate) {
   const t = (fm["review_trigger"] ?? "").trim();
   if (t === "") return "none";
   if (t.toLowerCase() === "unclassified") return "none";
+  const day = dated_trigger_day(t);
+  if (day !== null) return iso_day(asOfDate ?? asOf()) >= day ? "fired" : "not-fired";
+  if (DATED_TRIGGER_PROBE.test(t)) return "dated-unparsed";
   return "indeterminate";
 }
 function verdict_for(r) {
@@ -582,12 +810,21 @@ function verdict_for(r) {
   if (r.trigger_state === "none") {
     return "LIVE, NO REOPEN CONDITION \u2014 the ADR records no `review_trigger`, so nothing would ever reopen it on its own. Treat that as a defect in the ADR, not as strength of the lock.";
   }
+  if (r.trigger_state === "fired") {
+    return "LIVE, TRIGGER FIRED \u2014 the reopen condition is a date and that date has passed. The record still binds until someone acts on it, and citing it without naming the fired trigger presents a lapsed review as a current one.";
+  }
+  if (r.trigger_state === "not-fired") {
+    return "LIVE, TRIGGER NOT YET FIRED \u2014 the reopen condition is a date still in the future. This is the one state in which a trigger genuinely adds nothing to the citation, and it stops being true on a known day.";
+  }
+  if (r.trigger_state === "dated-unparsed") {
+    return 'LIVE, DATED TRIGGER UNREADABLE \u2014 the reopen condition announces a date this tool could not parse. That is a defect in the record or in the parser, not a verdict: fix the trigger to open with `Expiry YYYY-MM-DD` rather than reading this as "unknown".';
+  }
   return "LIVE, TRIGGER INDETERMINATE \u2014 the reopen condition is semantic and this tool cannot decide it. Not an unqualified lock: evaluate the condition against the current tree and route the result.";
 }
-function cite_check(refs, repo_root = REPO_ROOT) {
+function cite_check(refs, repo_root = REPO_ROOT2) {
   const files = adr_files(repo_root);
   const contents = /* @__PURE__ */ new Map();
-  for (const f of files) contents.set(f, fs.readFileSync(f, "utf-8"));
+  for (const f of files) contents.set(f, fs2.readFileSync(f, "utf-8"));
   return refs.map((ref) => {
     const parsed = normalise_ref(ref);
     if (parsed === null) {
@@ -629,11 +866,11 @@ function cite_check(refs, repo_root = REPO_ROOT) {
     const bodyStart = text.indexOf("\n---\n", 4);
     const body = bodyStart === -1 ? text : text.slice(bodyStart + 5);
     const cited = area === null ? new RegExp(`ADR-0*${num}\\b`, "i") : new RegExp(`ADR-${area}-0*${Number(num)}\\b`, "i");
-    const referenced_by = files.filter((f) => f !== match && cited.test(contents.get(f) ?? "")).map((f) => path2.relative(repo_root, f));
+    const referenced_by = files.filter((f) => f !== match && cited.test(contents.get(f) ?? "")).map((f) => path3.relative(repo_root, f));
     const partial = {
       ref: id,
       resolved: true,
-      file: path2.relative(repo_root, match),
+      file: path3.relative(repo_root, match),
       ...fm["status"] !== void 0 ? { status: fm["status"] } : {},
       ...fm["date"] !== void 0 ? { date: fm["date"] } : {},
       ...fm["decision"] !== void 0 ? { decision: fm["decision"] } : {},
@@ -713,15 +950,15 @@ ${r.ref}${r.file !== void 0 ? `  \xB7  ${r.file}` : ""}`);
   }
   return lines.join("\n");
 }
-function selfTest() {
-  const tmp = fs.mkdtempSync(path2.join(os.tmpdir(), "acc-"));
+function selfTest2() {
+  const tmp = fs2.mkdtempSync(path3.join(os.tmpdir(), "acc-"));
   const mk = (adr, citation) => {
-    const root = fs.mkdtempSync(path2.join(tmp, "root-"));
-    fs.mkdirSync(path2.join(root, "docs", "decisions"), { recursive: true });
-    fs.mkdirSync(path2.join(root, "src", "rules"), { recursive: true });
+    const root = fs2.mkdtempSync(path3.join(tmp, "root-"));
+    fs2.mkdirSync(path3.join(root, "docs", "decisions"), { recursive: true });
+    fs2.mkdirSync(path3.join(root, "src", "rules"), { recursive: true });
     if (adr !== null) {
-      fs.writeFileSync(
-        path2.join(root, "docs", "decisions", `ADR-${adr}-probe.md`),
+      fs2.writeFileSync(
+        path3.join(root, "docs", "decisions", `ADR-${adr}-probe.md`),
         `---
 status: accepted
 date: 2026-08-21
@@ -733,8 +970,8 @@ decision: probe
         "utf-8"
       );
     }
-    fs.writeFileSync(
-      path2.join(root, "src", "rules", "probe.md"),
+    fs2.writeFileSync(
+      path3.join(root, "src", "rules", "probe.md"),
       citation === null ? "# Probe\n\nNo decision is named here.\n" : `# Probe
 
 See ${citation}.
@@ -746,7 +983,7 @@ See ${citation}.
   const run = (root) => {
     process.env["ADR_CITE_CHECK_ROOT"] = root;
     try {
-      return runGateCli(REPO_ROOT, "src/scripts/adr_cite_check.ts", ["--cited"], REPO_ROOT);
+      return runGateCli(REPO_ROOT2, "src/scripts/adr_cite_check.ts", ["--cited"], REPO_ROOT2);
     } finally {
       delete process.env["ADR_CITE_CHECK_ROOT"];
     }
@@ -775,18 +1012,18 @@ See ${citation}.
       ]
     });
   } finally {
-    fs.rmSync(tmp, { recursive: true, force: true });
+    fs2.rmSync(tmp, { recursive: true, force: true });
   }
 }
-var TRIGGER_VERDICTS = ["fired", "not-fired", "indeterminate"];
-function corpus_survey(repo_root = REPO_ROOT) {
+var TRIGGER_VERDICTS = ["fired", "not-fired", "indeterminate", "dated-unparsed"];
+function corpus_survey(repo_root = REPO_ROOT2) {
   const files = adr_files(repo_root);
   const cited_outside = /* @__PURE__ */ new Set();
   for (const root of CITATION_ROOTS) {
-    for (const file of walk_citable(path2.join(repo_root, root))) {
-      const rel = path2.relative(repo_root, file);
-      if (rel.startsWith(path2.join("docs", "decisions"))) continue;
-      for (const m of fs.readFileSync(file, "utf-8").matchAll(CITATION_RE)) {
+    for (const file of walk_citable(path3.join(repo_root, root))) {
+      const rel = path3.relative(repo_root, file);
+      if (rel.startsWith(path3.join("docs", "decisions"))) continue;
+      for (const m of fs2.readFileSync(file, "utf-8").matchAll(CITATION_RE)) {
         const parsed = normalise_ref(m[0]);
         if (parsed !== null) cited_outside.add(parsed.id);
       }
@@ -794,15 +1031,15 @@ function corpus_survey(repo_root = REPO_ROOT) {
   }
   const rows = [];
   for (const f of files) {
-    const text = fs.readFileSync(f, "utf-8");
+    const text = fs2.readFileSync(f, "utf-8");
     const fm = parse_frontmatter(text) ?? {};
-    const base = path2.basename(f);
-    const parsedSelf = normalise_ref(path2.relative(repo_root, f));
+    const base = path3.basename(f);
+    const parsedSelf = normalise_ref(path3.relative(repo_root, f));
     const num = parsedSelf?.id ?? base;
     const raw_trigger = (fm["review_trigger"] ?? "").trim();
     rows.push({
       ref: num,
-      file: path2.relative(repo_root, f),
+      file: path3.relative(repo_root, f),
       status: (fm["status"] ?? "(none)").trim(),
       successor: (fm["superseded_by"] ?? "\u2014").trim() || "\u2014",
       has_trigger: raw_trigger !== "" && raw_trigger.toLowerCase() !== "unclassified",
@@ -863,9 +1100,9 @@ function render_corpus(rows, sum) {
   out.push("  Reports only. This command decides nothing and gates nothing.");
   return out.join("\n") + "\n";
 }
-function main(argv) {
+function main2(argv) {
   const as_json = argv.includes("--json");
-  if (argv.includes("--self-test")) return selfTest();
+  if (argv.includes("--self-test")) return selfTest2();
   const corpus_mode = argv.includes("--cited");
   const survey_mode = argv.includes("--all");
   if (survey_mode) {
@@ -958,22 +1195,22 @@ function main(argv) {
 }
 if (process.argv[1] !== void 0) {
   try {
-    const here = fs.realpathSync(fileURLToPath(import.meta.url));
-    const argv1 = fs.realpathSync(path2.resolve(process.argv[1]));
+    const here = fs2.realpathSync(fileURLToPath2(import.meta.url));
+    const argv1 = fs2.realpathSync(path3.resolve(process.argv[1]));
     if (here === argv1) {
-      process.exitCode = main(process.argv.slice(2));
+      process.exitCode = main2(process.argv.slice(2));
     }
   } catch {
-    const argvUrl = pathToFileURL(path2.resolve(process.argv[1])).href;
+    const argvUrl = pathToFileURL(path3.resolve(process.argv[1])).href;
     if (import.meta.url === argvUrl) {
-      process.exitCode = main(process.argv.slice(2));
+      process.exitCode = main2(process.argv.slice(2));
     }
   }
 }
 
 // src/scripts/_cli/cmd_adr_effective.ts
-var _HERE2 = path3.dirname(fileURLToPath2(import.meta.url));
-var REPO_ROOT2 = path3.resolve(_HERE2, "..", "..", "..");
+var _HERE2 = path4.dirname(fileURLToPath3(import.meta.url));
+var REPO_ROOT3 = path4.resolve(_HERE2, "..", "..", "..");
 var ASSERTIVE_SECTIONS = ["decision", "consequences", "amendment"];
 var RETIRES_RE = /^>?\s*retires:\s*(.+)$/i;
 var CLAUSE_MARKER_RE = /\*\*\((?:Superseded|Narrowed|Reopened) by ([^—)]+?)\s*(?:—[^)]*)?\)\*\*/;
@@ -1099,7 +1336,7 @@ function resolveAdrFile(ref, repoRoot) {
   const match = area === null ? files.find((f) => new RegExp(`(^|/)ADR-0*${num}[-.]`, "i").test(f)) : files.find((f) => new RegExp(`/docs/adrs/${area}/0*${String(Number(num))}-`, "i").test(f));
   return match ?? null;
 }
-function effectiveState(ref, repoRoot = REPO_ROOT2) {
+function effectiveState(ref, repoRoot = REPO_ROOT3) {
   const parsed = normalise_ref(ref);
   const id = parsed?.id ?? ref;
   const match = resolveAdrFile(ref, repoRoot);
@@ -1115,7 +1352,7 @@ function effectiveState(ref, repoRoot = REPO_ROOT2) {
       effective_decision: []
     };
   }
-  const text = fs2.readFileSync(match, "utf-8");
+  const text = fs3.readFileSync(match, "utf-8");
   const scalars = parse_frontmatter(text) ?? {};
   const structured = readAdrFrontmatter(text);
   const provenance = structured === null ? null : provenanceOf(structured);
@@ -1130,7 +1367,7 @@ function effectiveState(ref, repoRoot = REPO_ROOT2) {
   return {
     ref: id,
     resolved: true,
-    file: path3.relative(repoRoot, match),
+    file: path4.relative(repoRoot, match),
     ...scalars["status"] !== void 0 ? { status: scalars["status"] } : {},
     ...scalars["date"] !== void 0 ? { date: scalars["date"] } : {},
     ...scalars["decision"] !== void 0 ? { decision: scalars["decision"] } : {},
@@ -1216,39 +1453,39 @@ function parseArgv(argv) {
     return { ok: false, message: "usage: agent-config adr:effective <ADR-NNN> [ADR-NNN \u2026] [--json]" };
   return { ok: true, refs, json };
 }
-function main2(argv = process4.argv.slice(2)) {
+function main3(argv = process5.argv.slice(2)) {
   const parsed = parseArgv(argv);
   if (!parsed.ok) {
-    process4.stderr.write(`${parsed.message ?? "usage error"}
+    process5.stderr.write(`${parsed.message ?? "usage error"}
 `);
     return 2;
   }
   const states = (parsed.refs ?? []).map((ref) => effectiveState(ref));
   if (parsed.json === true) {
-    process4.stdout.write(`${JSON.stringify(states, null, 2)}
+    process5.stdout.write(`${JSON.stringify(states, null, 2)}
 `);
   } else {
     for (const state of states) {
-      for (const line of render2(state)) process4.stdout.write(`${line}
+      for (const line of render2(state)) process5.stdout.write(`${line}
 `);
-      process4.stdout.write("\n");
+      process5.stdout.write("\n");
     }
   }
   const bad = states.filter((s) => !s.resolved || s.contradictions.length > 0);
   return bad.length > 0 ? 1 : 0;
 }
 function _isCliEntry() {
-  if (process4.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL2(path3.resolve(process4.argv[1])).href;
+  if (process5.argv[1] === void 0) return false;
+  const argvUrl = pathToFileURL2(path4.resolve(process5.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs2.realpathSync(fileURLToPath2(import.meta.url)) === fs2.realpathSync(path3.resolve(process4.argv[1]));
+    return fs3.realpathSync(fileURLToPath3(import.meta.url)) === fs3.realpathSync(path4.resolve(process5.argv[1]));
   } catch {
     return false;
   }
 }
 if (_isCliEntry()) {
-  process4.exitCode = main2();
+  process5.exitCode = main3();
 }
 export {
   ASSERTIVE_SECTIONS,
@@ -1256,7 +1493,7 @@ export {
   clauseFindings,
   decisionSection,
   effectiveState,
-  main2 as main,
+  main3 as main,
   parseArgv,
   render2 as render,
   resolveAdrFile,