@kodr/aiwrangler 0.0.0-stage → 0.1.0

package/dist/chunk-EAQASAXL.js

@@ -0,0 +1,1252 @@
+// src/types.ts
+var PRECEDENCE = {
+  ruling: 0,
+  paper: 1,
+  door: 1,
+  spec: 2,
+  doc: 3,
+  nonRuling: 4
+};
+
+// src/jsonc.ts
+function stripJsonc(text) {
+  let out = "";
+  let inString = false;
+  let inLine = false;
+  let inBlock = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i] ?? "";
+    const next = text[i + 1] ?? "";
+    if (inLine) {
+      if (c === "\n") {
+        inLine = false;
+        out += c;
+      }
+      continue;
+    }
+    if (inBlock) {
+      if (c === "*" && next === "/") {
+        inBlock = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      out += c;
+      if (c === "\\" && next !== "") {
+        out += next;
+        i++;
+        continue;
+      }
+      if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      out += c;
+      continue;
+    }
+    if (c === "/" && next === "/") {
+      inLine = true;
+      i++;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      inBlock = true;
+      i++;
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+function parseJsonc(text) {
+  const stripped = stripJsonc(text).replace(/,(\s*[}\]])/g, "$1");
+  return JSON.parse(stripped);
+}
+
+// src/overrides.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, unlinkSync, renameSync, mkdirSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { z as z2 } from "zod";
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join, dirname, resolve } from "path";
+import { z } from "zod";
+var bool = (def) => z.boolean().default(def);
+var GatesSchema = z.object({
+  plan: z.object({ inSpec: bool(true), ambiguity: bool(true), openQuestions: bool(true), oneWayDoors: bool(true) }).default({}),
+  retrieval: z.object({ rerank: bool(true), topK: z.number().int().min(1).max(20).default(6) }).default({}),
+  check: z.object({
+    deterministic: bool(true),
+    battery: bool(true),
+    selfReport: bool(true),
+    testQuality: bool(true),
+    docDrift: bool(true),
+    injectionDefense: bool(true)
+  }).default({}),
+  security: z.object({ trustBoundary: bool(true), severity: bool(true), alwaysHuman: z.array(z.string()).default(["keys", "seals", "digests"]) }).default({}),
+  loop: z.object({ retryProgress: bool(true), errorSalience: bool(true), maxCycles: z.number().int().min(1).default(3) }).default({}),
+  session: z.object({ endAudit: bool(true), nudge: bool(true), maxNudges: z.number().int().min(0).default(3) }).default({})
+});
+var ThresholdsSchema = z.object({
+  actionThreshold: z.number().min(0).max(1).default(0.8),
+  reviewThreshold: z.number().min(0).max(1).default(0.5)
+});
+var ConfigSchema = z.object({
+  model: z.string().default("jev-1.13.0"),
+  activePolicy: z.string().default("strict"),
+  egress: z.object({ semantic: bool(true), warnOncePerSession: bool(true) }).default({}),
+  corpus: z.object({
+    spec: z.string().default("corpus/spec.md"),
+    rules: z.string().default("corpus/rules.md"),
+    divergences: z.string().default("corpus/divergences.md"),
+    questions: z.string().default("corpus/questions.md"),
+    plan: z.string().default("corpus/plan.md"),
+    docs: z.array(z.string()).default([]),
+    whitepaper: z.string().default("corpus/whitepaper.pdf")
+  }).default({}),
+  gates: GatesSchema.default({}),
+  policies: z.record(z.string(), ThresholdsSchema).default({ strict: {}, permissive: { actionThreshold: 0.9, reviewThreshold: 0.35 } }),
+  cache: z.object({ dir: z.string().default(".aiwrangler") }).default({}),
+  ledger: z.object({ path: z.string().default(".aiwrangler/ledger.jsonl") }).default({}),
+  repos: z.object({
+    super: z.string().default("."),
+    members: z.array(z.string()).default([]),
+    reviewed: z.array(z.string()).default([])
+  }).default({})
+});
+function expandPath(p, root) {
+  if (p.startsWith("~")) return join(homedir(), p.slice(1));
+  if (isAbsolute(p)) return p;
+  return resolve(root, p);
+}
+function findConfigFile(startDir) {
+  let dir = resolve(startDir);
+  for (; ; ) {
+    const candidate = join(dir, "aiwrangler.config.json");
+    if (existsSync(candidate)) return { path: candidate, source: "discovered" };
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const user = join(homedir(), ".config", "aiwrangler", "aiwrangler.config.json");
+  if (existsSync(user)) return { path: user, source: "user" };
+  return null;
+}
+function flattenGates(config) {
+  const flat = /* @__PURE__ */ new Map();
+  const walk = (obj, prefix) => {
+    if (obj === null || typeof obj !== "object") return;
+    for (const [key, value] of Object.entries(obj)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      if (typeof value === "boolean") flat.set(path, value);
+      else if (typeof value === "object" && !Array.isArray(value)) walk(value, path);
+    }
+  };
+  walk(config.gates, "");
+  return flat;
+}
+function applyGateFlag(config, name, value) {
+  const flat = flattenGates(config);
+  const applied = [];
+  for (const path of flat.keys()) {
+    const leaf = path.split(".").pop() ?? path;
+    if (path === name || leaf === name) {
+      const parts = path.split(".");
+      let node = config.gates;
+      for (const part of parts.slice(0, -1)) node = node[part];
+      node[parts[parts.length - 1]] = value;
+      applied.push(path);
+    }
+  }
+  if (applied.length === 0) {
+    throw new Error(`unknown gate '${name}'. Known gates: ${[...flat.keys()].join(", ")}`);
+  }
+  return applied;
+}
+function applyFlagList(config, list, value) {
+  const applied = [];
+  const names = list.split(",").map((s) => s.trim()).filter(Boolean);
+  for (const name of names) {
+    applied.push(...applyGateFlag(config, name, value));
+  }
+  return applied;
+}
+function applyEnvOverrides(config, env = process.env) {
+  const next = structuredClone(config);
+  if (env.AIWRANGLER_MODEL) next.model = env.AIWRANGLER_MODEL;
+  if (env.AIWRANGLER_POLICY) {
+    if (!(env.AIWRANGLER_POLICY in next.policies)) {
+      throw new Error(`AIWRANGLER_POLICY: unknown policy '${env.AIWRANGLER_POLICY}'. Known: ${Object.keys(next.policies).join(", ")}`);
+    }
+    next.activePolicy = env.AIWRANGLER_POLICY;
+  }
+  if (env.AIWRANGLER_EGRESS) {
+    const on = ["1", "true", "on", "yes"].includes(env.AIWRANGLER_EGRESS.toLowerCase());
+    next.egress.semantic = on;
+  }
+  if (env.AIWRANGLER_DISABLE) applyFlagList(next, env.AIWRANGLER_DISABLE, false);
+  if (env.AIWRANGLER_ENABLE) applyFlagList(next, env.AIWRANGLER_ENABLE, true);
+  return next;
+}
+function loadConfig(startDir, env = process.env) {
+  const explicit = env.AIWRANGLER_CONFIG;
+  let raw;
+  let root;
+  let source;
+  let path;
+  if (explicit) {
+    path = expandPath(explicit, resolve(startDir));
+    if (!existsSync(path)) throw new Error(`AIWRANGLER_CONFIG: file not found: ${path}`);
+    raw = parseJsonc(readFileSync(path, "utf8"));
+    root = dirname(path);
+    source = "explicit";
+  } else {
+    const found = findConfigFile(startDir);
+    if (found) {
+      path = found.path;
+      raw = parseJsonc(readFileSync(found.path, "utf8"));
+      root = dirname(found.path);
+      source = found.source;
+    } else {
+      raw = {};
+      root = resolve(startDir);
+      source = "defaults";
+      path = null;
+    }
+  }
+  const parsed = ConfigSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    throw new Error(`invalid aiwrangler config at ${path ?? "defaults"}:
+${issues}`);
+  }
+  const { config, overrides } = applyRuntimeOverridesFromDisk(parsed.data, root);
+  return { config: applyEnvOverrides(config, env), root, source, path, overrides };
+}
+function activeThresholds(config) {
+  const policy = config.policies[config.activePolicy];
+  if (!policy) throw new Error(`activePolicy '${config.activePolicy}' not defined in policies`);
+  return policy;
+}
+
+// src/overrides.ts
+var OVERRIDES_FILENAME = "runtime-overrides.json";
+var RuntimeOverridesSchema = z2.object({
+  activePolicy: z2.string().optional(),
+  egressSemantic: z2.boolean().optional(),
+  actionThreshold: z2.number().min(0).max(1).optional(),
+  reviewThreshold: z2.number().min(0).max(1).optional(),
+  gates: z2.record(z2.string(), z2.boolean()).optional()
+});
+var OverridesFileSchema = z2.object({
+  version: z2.literal(1),
+  createdAt: z2.string(),
+  note: z2.string().optional(),
+  expiresOn: z2.enum(["pass", "manual"]),
+  overrides: RuntimeOverridesSchema
+});
+function overridesFilePath(config, root) {
+  return join2(expandPath(config.cache.dir, root), OVERRIDES_FILENAME);
+}
+function readRuntimeOverridesFile(config, root) {
+  const path = overridesFilePath(config, root);
+  if (!existsSync2(path)) return null;
+  try {
+    const parsed = OverridesFileSchema.safeParse(JSON.parse(readFileSync2(path, "utf8")));
+    if (!parsed.success) return null;
+    return parsed.data;
+  } catch {
+    return null;
+  }
+}
+function writeRuntimeOverridesFile(config, root, file) {
+  const path = overridesFilePath(config, root);
+  mkdirSync(dirname2(path), { recursive: true });
+  const tmp = path + ".tmp";
+  writeFileSync(tmp, JSON.stringify(file, null, 2) + "\n", "utf8");
+  renameSync(tmp, path);
+}
+function clearRuntimeOverrides(config, root) {
+  const path = overridesFilePath(config, root);
+  if (!existsSync2(path)) return false;
+  try {
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function applyRuntimeOverrides(config, overrides) {
+  const next = structuredClone(config);
+  const appliedGates = [];
+  if (overrides.activePolicy !== void 0) {
+    if (!(overrides.activePolicy in next.policies)) {
+      throw new Error(`runtime override activePolicy '${overrides.activePolicy}' is not a defined policy`);
+    }
+    next.activePolicy = overrides.activePolicy;
+  }
+  if (overrides.egressSemantic !== void 0) next.egress.semantic = overrides.egressSemantic;
+  if (overrides.actionThreshold !== void 0 || overrides.reviewThreshold !== void 0) {
+    const policy = next.policies[next.activePolicy];
+    if (!policy) throw new Error(`activePolicy '${next.activePolicy}' not defined in policies`);
+    next.policies[next.activePolicy] = {
+      actionThreshold: overrides.actionThreshold ?? policy.actionThreshold,
+      reviewThreshold: overrides.reviewThreshold ?? policy.reviewThreshold
+    };
+  }
+  for (const [name, value] of Object.entries(overrides.gates ?? {})) {
+    appliedGates.push(...applyGateFlag(next, name, value));
+  }
+  return { config: next, appliedGates };
+}
+function applyRuntimeOverridesFromDisk(config, root) {
+  const file = readRuntimeOverridesFile(config, root);
+  if (!file) return { config, overrides: null };
+  try {
+    return { config: applyRuntimeOverrides(config, file.overrides).config, overrides: file.overrides };
+  } catch {
+    return { config, overrides: null };
+  }
+}
+
+// src/hash.ts
+import { createHash } from "crypto";
+function sha256Hex(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function shortHash(text) {
+  return sha256Hex(text).slice(0, 12);
+}
+
+// src/groundtruth/sectionize.ts
+function splitMarkdown(md) {
+  const lines = md.split("\n");
+  const sections = [];
+  let current = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const m = line.match(/^(#{1,6})\s+(.*)$/);
+    if (m) {
+      if (current) sections.push(current);
+      current = { level: m[1].length, title: m[2].trim(), text: "", line: i + 1 };
+    } else if (current) {
+      current.text += line + "\n";
+    }
+  }
+  if (current) sections.push(current);
+  return sections.map((s) => ({ ...s, text: s.text.trim() }));
+}
+function slug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+
+// src/groundtruth/parsers.ts
+function section(partial) {
+  return { precedence: PRECEDENCE.doc, ...partial };
+}
+var ROMAN_RE = /^[IVX]+(?:-[A-Z])?$/;
+function parseSpec(md, source) {
+  const out = [];
+  for (const sec of splitMarkdown(md)) {
+    const m = sec.title.match(/^(\d+)\.\s+(.*)$/);
+    if (!m) continue;
+    const title = m[2];
+    const ref = title.match(/\(([^)]+)\)\s*$/);
+    const paperRef = ref && ROMAN_RE.test(ref[1]) ? ref[1] : void 0;
+    out.push(
+      section({
+        id: `SPEC-${m[1]}`,
+        kind: "spec",
+        title,
+        text: sec.text,
+        source,
+        status: "info",
+        ...paperRef ? { paperRef } : {},
+        precedence: PRECEDENCE.spec
+      })
+    );
+  }
+  return out;
+}
+function parseRules(md, source) {
+  const lines = md.split("\n");
+  const out = [];
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    out.push(
+      section({
+        id: `RULE-${current.n}`,
+        kind: "rule",
+        title: current.lines[0].trim(),
+        text: current.lines.join("\n").trim(),
+        source,
+        status: "info",
+        precedence: PRECEDENCE.spec
+      })
+    );
+    current = null;
+  };
+  for (const line of lines) {
+    const m = line.match(/^(\d+)\.\s+(.*)$/);
+    if (m) {
+      flush();
+      current = { n: m[1], lines: [m[2]] };
+      continue;
+    }
+    if (current && (/^\s{2,}/.test(line) || line.trim() === "")) {
+      if (line.trim() === "" && current.lines[current.lines.length - 1] === "") continue;
+      current.lines.push(line.trim() === "" ? "" : line.trim());
+      continue;
+    }
+    flush();
+  }
+  flush();
+  return out;
+}
+function parseDivergences(md, source) {
+  const lines = md.split("\n");
+  const out = [];
+  let topic = "";
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    const body = current.lines.join("\n").trim();
+    const marker = body.indexOf("**RULED");
+    const ruled = marker >= 0;
+    const ruling = ruled ? body.slice(marker).replace(/\*\*/g, "").replace(/\s+/g, " ").trim().slice(0, 800) : void 0;
+    out.push(
+      section({
+        id: `DIV-D-${current.id}`,
+        kind: "divergence",
+        title: `${current.topic ? current.topic + ": " : ""}${current.lines[0].trim()}`,
+        text: body,
+        source,
+        status: ruled ? "ruled" : "open",
+        ...ruled && ruling ? { ruling } : {},
+        precedence: ruled ? PRECEDENCE.ruling : PRECEDENCE.nonRuling
+      })
+    );
+    current = null;
+  };
+  for (const line of lines) {
+    const h = line.match(/^##\s+(.*)$/);
+    if (h) {
+      flush();
+      topic = h[1].trim();
+      continue;
+    }
+    const m = line.match(/^D-(\d+)\s+(.*)$/);
+    if (m) {
+      flush();
+      current = { id: m[1], lines: [m[2]], topic };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+  flush();
+  return out;
+}
+function parseQuestions(md, source) {
+  const lines = md.split("\n");
+  const out = [];
+  let heading = "";
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    const body = current.lines.join("\n").trim();
+    const marker = body.indexOf("**ANSWERED");
+    const answered = marker >= 0;
+    const ruling = answered ? body.slice(marker).replace(/\*\*/g, "").replace(/\s+/g, " ").trim().slice(0, 800) : void 0;
+    out.push(
+      section({
+        id: `Q-${current.n}`,
+        kind: "question",
+        title: current.lines[0].trim(),
+        text: body,
+        source,
+        status: answered ? "answered" : "open",
+        ...answered && ruling ? { ruling } : {},
+        precedence: answered ? PRECEDENCE.ruling : PRECEDENCE.nonRuling
+      })
+    );
+    current = null;
+  };
+  for (const line of lines) {
+    const h = line.match(/^##\s+(.*)$/);
+    if (h) {
+      flush();
+      heading = h[1].trim();
+      continue;
+    }
+    const m = line.match(/^(\d+)\.\s+(.*)$/);
+    if (m) {
+      flush();
+      current = { n: m[1], lines: [m[2]], heading };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+  flush();
+  return out;
+}
+function parsePlan(md, source) {
+  const out = [];
+  for (const sec of splitMarkdown(md)) {
+    if (!/one-way door|launch gate/i.test(sec.title)) continue;
+    out.push(
+      section({
+        id: `DOOR-${slug(sec.title) || out.length + 1}`,
+        kind: "door",
+        title: sec.title,
+        text: sec.text,
+        source,
+        status: "info",
+        precedence: PRECEDENCE.door
+      })
+    );
+  }
+  return out;
+}
+function parseDoc(md, source, label) {
+  return splitMarkdown(md).filter((s) => s.text.length > 0).map(
+    (sec, i) => section({
+      id: `DOC-${label}-${String(i + 1).padStart(2, "0")}`,
+      kind: "doc",
+      title: sec.title || "(intro)",
+      text: sec.text,
+      source,
+      status: "info",
+      precedence: PRECEDENCE.doc
+    })
+  );
+}
+var PAPER_HEADING_RE = /^([IVX]+(?:-[A-Z])?)?\.?\s{1,4}(.+)$/;
+var ROMAN_ONLY_RE = /^[IVX]+$/;
+function mergeSpacedCaps(title) {
+  const tokens = title.split(/\s+/).filter(Boolean);
+  const merged = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    const next = tokens[i + 1];
+    if (next !== void 0 && /^-?[A-Z]$/.test(tok) && /^[A-Z]/.test(next) && next.length > 1) {
+      merged.push((tok.startsWith("-") ? tok : "") + next);
+      i += 2;
+      continue;
+    }
+    if (tok.length === 1 && /^[A-Z]$/.test(tok) && next !== void 0 && /^[A-Z]/.test(next)) {
+      merged.push(tok + next);
+      i += 2;
+      continue;
+    }
+    merged.push(tok);
+    i++;
+  }
+  return merged.join(" ").replace(/ -/g, "-").replace(/\s+,/g, ",");
+}
+function capsRatio(s) {
+  const letters = s.replace(/[^A-Za-z]/g, "");
+  if (letters.length === 0) return 0;
+  const upper = letters.replace(/[^A-Z]/g, "");
+  return upper.length / letters.length;
+}
+function parsePaper(text, source) {
+  const lines = text.split("\n").map((l) => l.replace(/^\f/, ""));
+  const byId = /* @__PURE__ */ new Map();
+  let current = null;
+  const looksLikeCapsFragment = (line) => {
+    const t = line.trim();
+    return t.length >= 3 && t.length <= 40 && !/[.:;]$/.test(t) && !/\.\s*\.\s*\./.test(t) && capsRatio(t) >= 0.6;
+  };
+  const flush = () => {
+    if (!current) return;
+    const body = current.lines.join("\n").trim();
+    const existing = byId.get(current.id);
+    if (existing) {
+      existing.text = (existing.text + "\n" + body).trim();
+    } else {
+      byId.set(
+        current.id,
+        section({
+          id: `PAPER-${current.id}`,
+          kind: "paper",
+          title: current.title,
+          text: body,
+          source,
+          status: "info",
+          precedence: PRECEDENCE.paper
+        })
+      );
+    }
+    current = null;
+  };
+  for (let li = 0; li < lines.length; li++) {
+    const line = lines[li] ?? "";
+    if (/\.\s*\.\s*\./.test(line)) continue;
+    const m = line.match(PAPER_HEADING_RE);
+    if (m && m[1] && !ROMAN_ONLY_RE.test(m[2] ?? "") && !/^[ivx]+$/.test(m[1])) {
+      let title = mergeSpacedCaps(m[2] ?? "");
+      let consumed = 1;
+      while (li + consumed < lines.length && looksLikeCapsFragment(lines[li + consumed] ?? "") && title.split(/\s+/).length < 10) {
+        title = title + " " + mergeSpacedCaps((lines[li + consumed] ?? "").trim());
+        consumed++;
+      }
+      const letters = title.replace(/[^A-Za-z]/g, "");
+      if (letters.length >= 4 && capsRatio(title) >= 0.7) {
+        flush();
+        current = { id: m[1], title: title.replace(/\s{2,}/g, " ").trim(), lines: [] };
+        li += consumed - 1;
+        continue;
+      }
+    }
+    if (current) current.lines.push(line);
+  }
+  flush();
+  return [...byId.values()];
+}
+
+// src/groundtruth/whitepaper.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+function ensurePaperText(config, root) {
+  const pdf = expandPath(config.corpus.whitepaper, root);
+  const cacheDir = expandPath(config.cache.dir, root);
+  const cached = join3(cacheDir, "whitepaper.txt");
+  const pdfMtime = existsSync3(pdf) ? statSync(pdf).mtimeMs : 0;
+  if (existsSync3(cached) && statSync(cached).mtimeMs >= pdfMtime) {
+    return { text: readFileSync3(cached, "utf8"), extracted: false };
+  }
+  if (!existsSync3(pdf)) return { text: null, extracted: false };
+  const res = spawnSync("pdftotext", [pdf, "-"], { encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+  if (res.error || res.status !== 0) {
+    const reason = res.error ? res.error.message : `pdftotext exit ${res.status}`;
+    throw new Error(`whitepaper extraction failed (${reason}); is poppler-utils installed?`);
+  }
+  const text = res.stdout;
+  if (text.split(/\s+/).length < 1e3) throw new Error("whitepaper extraction produced suspiciously little text; refusing to cache");
+  mkdirSync2(cacheDir, { recursive: true });
+  writeFileSync2(cached, text, "utf8");
+  return { text, extracted: true };
+}
+
+// src/groundtruth/corpus.ts
+import { readFileSync as readFileSync4 } from "fs";
+function slugFromPath(rel) {
+  return rel.toLowerCase().replace(/\.[a-z0-9]+$/i, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+function readOr(path, fallback) {
+  try {
+    return { text: readFileSync4(path, "utf8"), sections: [] };
+  } catch {
+    return { text: null, sections: fallback };
+  }
+}
+function loadCorpus(config, root) {
+  const sections = [];
+  const sources = [];
+  const addFile = (path, parse) => {
+    const resolved = expandPath(path, root);
+    const { text } = readOr(resolved, []);
+    if (text === null) return;
+    sources.push({ path: resolved, hash: sha256Hex(text) });
+    sections.push(...parse(text, resolved));
+  };
+  addFile(config.corpus.spec, parseSpec);
+  addFile(config.corpus.rules, parseRules);
+  addFile(config.corpus.divergences, parseDivergences);
+  addFile(config.corpus.questions, parseQuestions);
+  addFile(config.corpus.plan, parsePlan);
+  for (const doc of config.corpus.docs) {
+    const resolved = expandPath(doc, root);
+    let label = doc.split("/").pop()?.replace(/\.[a-z]+$/i, "") ?? "doc";
+    const rel = resolved.startsWith(root + "/") ? resolved.slice(root.length + 1) : null;
+    if (rel && rel.includes("/")) label = slugFromPath(rel);
+    addFile(doc, (md, source) => parseDoc(md, source, label));
+  }
+  const paper = ensurePaperText(config, root);
+  if (paper.text !== null) {
+    const paperPath = expandPath(config.corpus.whitepaper, root);
+    sources.push({ path: paperPath, hash: sha256Hex(paper.text) });
+    sections.push(...parsePaper(paper.text, paperPath));
+  }
+  const hash = sha256Hex(JSON.stringify({ sources: sources.map((s) => [s.path, s.hash]).sort((a, b) => (a[0] ?? "").localeCompare(b[0] ?? "")), ids: sections.map((s) => s.id).sort() }));
+  return { sections, sources, hash, paperText: paper.text ?? "" };
+}
+function loadCorpusFrom(startDir) {
+  const loaded = loadConfig(startDir);
+  const corpus = loadCorpus(loaded.config, loaded.root);
+  return { loaded, corpus };
+}
+
+// src/git/diff.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
+function git(repoDir, args, timeoutMs = 3e4) {
+  const res = spawnSync2("git", ["-C", repoDir, ...args], { encoding: "utf8", timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 });
+  if (res.error) return { code: null, stdout: "", stderr: String(res.error) };
+  return { code: res.status, stdout: res.stdout ?? "", stderr: res.stderr ?? "" };
+}
+function parseUnifiedDiff(text) {
+  const files = [];
+  const lines = text.split("\n");
+  let file = null;
+  let hunk = null;
+  let newLine = 0;
+  let oldLine = 0;
+  for (const line of lines) {
+    const header = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (header) {
+      file = {
+        path: header[2],
+        ...header[1] !== header[2] ? { oldPath: header[1] } : {},
+        binary: false,
+        hunks: []
+      };
+      files.push(file);
+      hunk = null;
+      continue;
+    }
+    if (!file) continue;
+    if (line.startsWith("Binary files") || line.startsWith("GIT binary patch")) {
+      file.binary = true;
+      continue;
+    }
+    if (line.startsWith("new file mode") || line.startsWith("deleted file mode") || line.startsWith("index ") || line.startsWith("--- ") || line.startsWith("+++ ") || line.startsWith("rename from") || line.startsWith("rename to") || line.startsWith("similarity index") || line.startsWith("old mode") || line.startsWith("new mode")) {
+      continue;
+    }
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunkMatch) {
+      hunk = { header: line, lines: [] };
+      file.hunks.push(hunk);
+      oldLine = Number(hunkMatch[1]);
+      newLine = Number(hunkMatch[2]);
+      continue;
+    }
+    if (!hunk) continue;
+    if (line.startsWith("+")) {
+      hunk.lines.push({ kind: "add", text: line.slice(1), newLine });
+      newLine++;
+    } else if (line.startsWith("-")) {
+      hunk.lines.push({ kind: "del", text: line.slice(1), oldLine });
+      oldLine++;
+    } else if (line.startsWith(" ")) {
+      hunk.lines.push({ kind: "ctx", text: line.slice(1), newLine, oldLine });
+      newLine++;
+      oldLine++;
+    }
+  }
+  return files;
+}
+function addedLines(file) {
+  const out = [];
+  for (const hunk of file.hunks) {
+    for (const l of hunk.lines) {
+      if (l.kind === "add" && l.newLine !== void 0) out.push({ text: l.text, line: l.newLine });
+    }
+  }
+  return out;
+}
+function repoDirs(config, root) {
+  const superPath = expandPath(config.repos.super, root);
+  const dirs = [{ repo: "(super)", dir: superPath }];
+  for (const member of config.repos.members) {
+    const dir = join4(superPath, member);
+    if (existsSync4(join4(dir, ".git"))) dirs.push({ repo: member, dir });
+  }
+  return dirs;
+}
+function dirtyFiles(repoDir) {
+  const modified = [];
+  const untracked = [];
+  const res = git(repoDir, ["status", "--porcelain=v1"]);
+  if (res.code !== 0) return { modified, untracked };
+  for (const line of res.stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const xy = line.slice(0, 2);
+    const path = line.slice(3).trim().replace(/"(.*)"/, "$1");
+    if (!path) continue;
+    if (xy.includes("?")) untracked.push(path);
+    else modified.push(path);
+  }
+  if (untracked.length > 0) {
+    const ls = git(repoDir, ["ls-files", "--others", "--exclude-standard"]);
+    const dirs = untracked.filter((p) => p.endsWith("/"));
+    if (ls.code === 0 && dirs.length > 0) {
+      const exact = ls.stdout.split("\n").filter(Boolean);
+      const expanded = /* @__PURE__ */ new Set();
+      for (const p of untracked) {
+        if (!p.endsWith("/")) {
+          expanded.add(p);
+          continue;
+        }
+        const prefix = p.slice(0, -1);
+        for (const f of exact) {
+          if (f === prefix || f.startsWith(prefix + "/")) expanded.add(f);
+        }
+      }
+      untracked.length = 0;
+      untracked.push(...expanded);
+    }
+  }
+  return { modified, untracked };
+}
+function dirtySet(config, root) {
+  const out = [];
+  for (const { repo, dir } of repoDirs(config, root)) {
+    const { modified, untracked } = dirtyFiles(dir);
+    const files = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const path of [...modified, ...untracked]) {
+      if (seen.has(path)) continue;
+      seen.add(path);
+      if (untracked.includes(path)) {
+        try {
+          const content = readFileSync5(join4(dir, path), "utf8");
+          const lines = content.split("\n");
+          files.push({
+            path,
+            binary: false,
+            hunks: [{ header: "@@ new file @@", lines: lines.map((text, i) => ({ kind: "add", text, newLine: i + 1 })) }]
+          });
+        } catch {
+          files.push({ path, binary: true, hunks: [] });
+        }
+        continue;
+      }
+      const combined = git(dir, ["diff", "HEAD", "--", path]).stdout + git(dir, ["diff", "--cached", "--", path]).stdout;
+      const parsed = parseUnifiedDiff(combined);
+      files.push(...parsed);
+    }
+    if (files.length > 0) out.push({ repo, repoDir: dir, files });
+  }
+  return out;
+}
+
+// src/gates/deterministic/rules.ts
+var SILENT_DEFAULT_PATTERNS = [
+  { re: /\.unwrap_or_default\(\)/, note: "unwrap_or_default() silently substitutes a default; per RULE-1 malformed/missing values must be errors" },
+  { re: /\.unwrap_or\(\s*(0|false|true|None)\s*\)/, note: "unwrap_or(literal) silently substitutes a value; per RULE-1 malformed/missing values must be errors" },
+  { re: /\.unwrap_or\(\s*(String::new\(\)|Vec::new\(\)|vec!\[\]|Default::default\(\))\s*\)/, note: "unwrap_or(empty container) silently substitutes; per RULE-1 malformed/missing values must be errors" },
+  { re: /Ok\(\s*_\s*\)\s*=>\s*(0|false|true|None|Default::default\(\))/, note: "Ok(_) arm returns a literal default; per RULE-1 this maps a parsed value to a silent default" },
+  { re: /Err\(\s*_?\s*\)\s*=>\s*(0|false|true|None|Default::default\(\)|vec!\[\])/, note: "Err(_) arm returns a literal instead of propagating; per RULE-1 errors must not become values" },
+  { re: /\bcatch\s*\{\s*\}/, note: "empty catch block swallows failures; per RULE-1 unreadable/malformed input must be an error" }
+];
+var TODO_BARE = /TODO(?!\s*\([a-z0-9-]+\))/;
+var TODO_TAGGED = /TODO\([a-z0-9-]+\)/;
+var EM_DASH = /\u2014/;
+var AI_TRAILER = /^\s*(Co-Authored-By:.*\b(Claude|Copilot|GPT|ChatGPT|Gemini|Cursor)\b|Generated with)/i;
+var SENSITIVE_AREA = /(?<![A-Za-z])(sealed?|sealing|seals?|digests?|disclosure|keygen|keys?)(?![A-Za-z])/i;
+var FUEL_DECL = /((fn|const|static)\s+[A-Za-z_]*(fuel|budget|limit)[A-Za-z_]*|let\s+mut\s+[A-Za-z_]*(fuel|budget|limit)[A-Za-z_]*|:\s*(Fuel|Budget|Limit)[<\s>])/i;
+function checkFile(repo, file, config) {
+  const findings = [];
+  const adds = addedLines(file);
+  if (adds.length === 0) return findings;
+  const pathSensitive = SENSITIVE_AREA.test(file.path);
+  for (const { text, line } of adds) {
+    for (const { re, note } of SILENT_DEFAULT_PATTERNS) {
+      if (re.test(text)) {
+        findings.push({ rule: "RULE-1", severity: "review", repo, file: file.path, line, evidence: text.trim().slice(0, 120), note });
+      }
+    }
+    if (/TODO/.test(text) && TODO_BARE.test(text) && !TODO_TAGGED.test(text)) {
+      findings.push({
+        rule: "RULE-7",
+        severity: "review",
+        repo,
+        file: file.path,
+        line,
+        evidence: text.trim().slice(0, 120),
+        note: "TODO without a backend tag; every TODO must name the backend it waits on, e.g. TODO(node)"
+      });
+    }
+    if (EM_DASH.test(text)) {
+      findings.push({ rule: "RULE-6", severity: "block", repo, file: file.path, line, evidence: text.trim().slice(0, 120), note: "em dash in added line; house style bans em dashes" });
+    }
+    if (config.repos.members.some((m) => text.includes(`../${m}/`))) {
+      findings.push({
+        rule: "RULE-6",
+        severity: "review",
+        repo,
+        file: file.path,
+        line,
+        evidence: text.trim().slice(0, 120),
+        note: "relative path into a sibling repo; name the sibling instead of a relative path"
+      });
+    }
+    if (FUEL_DECL.test(text)) {
+      findings.push({
+        rule: "RULE-9",
+        severity: "review",
+        repo,
+        file: file.path,
+        line,
+        evidence: text.trim().slice(0, 120),
+        note: "fuel/budget/limit declaration; must state units and who pays"
+      });
+    }
+    if (pathSensitive || SENSITIVE_AREA.test(text) && /^(pub\s+)?(async\s+)?(fn|struct|enum|impl|trait|mod)\s/.test(text.trim())) {
+      findings.push({
+        rule: "RULE-10",
+        severity: "human",
+        repo,
+        file: file.path,
+        line,
+        evidence: text.trim().slice(0, 120),
+        note: "touches keys/seals/digests/disclosure; requires human eyes even if correct"
+      });
+    }
+    if (/^\s*pub\s+(async\s+)?(fn|struct|enum|trait|type|mod|const|static)\s/.test(text) && config.repos.reviewed.includes(repo)) {
+      findings.push({
+        rule: "RULE-2",
+        severity: "review",
+        repo,
+        file: file.path,
+        line,
+        evidence: text.trim().slice(0, 120),
+        note: `new public API in reviewed repo '${repo}'; requires an enumerated-surface argument listing existing public items that are missing`
+      });
+    }
+  }
+  return findings;
+}
+function checkRepoDiff(diff, config) {
+  const out = [];
+  for (const file of diff.files) {
+    if (file.binary) continue;
+    out.push(...checkFile(diff.repo, file, config));
+  }
+  const testsInDiff = diff.files.some(
+    (f) => f.path.includes("test") || f.path.startsWith("tests/") || f.path.endsWith("tests.rs")
+  );
+  if (!testsInDiff) {
+    for (const file of diff.files) {
+      if (!file.path.endsWith(".rs") || !/^src\//.test(file.path) || file.path.includes("test")) continue;
+      const adds = addedLines(file);
+      const behavioral = adds.filter((a) => /^(pub\s+)?(async\s+)?(fn|impl|struct|enum|trait)\s|^\s+(pub\s+)?fn\s/.test(a.text.trim()));
+      if (behavioral.length > 0) {
+        out.push({
+          rule: "RULE-8",
+          severity: "review",
+          repo: diff.repo,
+          file: file.path,
+          line: behavioral[0]?.line ?? null,
+          evidence: `${behavioral.length} behavioral line(s) added in ${file.path}; no test file anywhere in this diff`,
+          note: "new behavior ships with a test that fails without it; this repo-diff touches no tests"
+        });
+      }
+    }
+  }
+  return dedupe(out);
+}
+function checkCommitMessage(message, repo) {
+  const out = [];
+  for (const line of message.split("\n")) {
+    if (AI_TRAILER.test(line)) {
+      out.push({ rule: "RULE-6", severity: "block", repo, file: "(commit message)", line: null, evidence: line.trim().slice(0, 120), note: "AI-identifying trailer in commit message; house style bans them" });
+    }
+    if (EM_DASH.test(line)) {
+      out.push({ rule: "RULE-6", severity: "block", repo, file: "(commit message)", line: null, evidence: line.trim().slice(0, 120), note: "em dash in commit message; house style bans em dashes" });
+    }
+  }
+  return out;
+}
+function dedupe(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const f of findings) {
+    const key = `${f.rule}|${f.repo}|${f.file}|${f.line}|${f.evidence}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(f);
+  }
+  return out;
+}
+
+// src/gates/deterministic/cargo.ts
+import { spawn } from "child_process";
+function run(cmd, opts) {
+  return new Promise((resolve2) => {
+    let proc;
+    try {
+      proc = spawn(cmd[0], cmd.slice(1), { cwd: opts.cwd, stdio: ["ignore", "pipe", "pipe"], signal: opts.signal });
+    } catch (err) {
+      resolve2({ code: null, stdout: "", stderr: String(err), timedOut: false });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = opts.timeoutMs ? setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGKILL");
+    }, opts.timeoutMs) : void 0;
+    proc.stdout?.on("data", (d) => stdout += d.toString());
+    proc.stderr?.on("data", (d) => stderr += d.toString());
+    const done = (code, extra = "") => {
+      if (timer) clearTimeout(timer);
+      resolve2({ code, stdout, stderr: stderr + extra, timedOut });
+    };
+    proc.on("error", (err) => done(null, String(err)));
+    proc.on("close", (code) => done(code));
+  });
+}
+function summarizeTests(output) {
+  const passed = [...output.matchAll(/test result: \w+\. (\d+) passed/g)].reduce((n, m) => n + Number(m[1]), 0);
+  const failed = [...output.matchAll(/test result: \w+\. \d+ passed; (\d+) failed/g)].reduce((n, m) => n + Number(m[1]), 0);
+  const suites = (output.match(/test result:/g) ?? []).length;
+  return { passed, failed, suites };
+}
+async function cargoCheck(repoDir, opts = {}) {
+  const args = ["--color", "never"];
+  if (opts.package) args.push("-p", opts.package);
+  const steps = [];
+  const checkArgs = ["check", ...args];
+  const check = await run(["cargo", ...checkArgs], { cwd: repoDir, timeoutMs: opts.timeoutMs ?? 10 * 6e4, ...opts.signal ? { signal: opts.signal } : {} });
+  const checkOut = check.stdout + "\n" + check.stderr;
+  steps.push({
+    label: "cargo check",
+    ok: !check.timedOut && check.code === 0,
+    summary: check.timedOut ? "TIMED OUT" : check.code === 0 ? "OK" : `FAILED (exit ${check.code})`,
+    errors: errorLines(checkOut),
+    output: checkOut
+  });
+  if (!steps[0].ok) return steps;
+  if (opts.tests) {
+    const test = await run(["cargo", "test", ...args], { cwd: repoDir, timeoutMs: opts.timeoutMs ?? 10 * 6e4, ...opts.signal ? { signal: opts.signal } : {} });
+    const testOut = test.stdout + "\n" + test.stderr;
+    const t = summarizeTests(testOut);
+    steps.push({
+      label: "cargo test",
+      ok: !test.timedOut && test.code === 0,
+      summary: test.timedOut ? "TIMED OUT" : test.code === 0 ? `OK: ${t.suites} suite(s), ${t.passed} passed, ${t.failed} failed` : `FAILED (exit ${test.code})`,
+      errors: errorLines(testOut),
+      output: testOut
+    });
+  }
+  return steps;
+}
+function errorLines(output) {
+  return output.split("\n").filter((l) => /\berror(\[|:)/i.test(l) || /^failures:$/m.test(l) || /test result: FAILED/i.test(l)).slice(0, 30);
+}
+function parseCargoJson(output) {
+  const diags = [];
+  for (const line of output.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (msg?.reason !== "compiler-message" || !msg.message) continue;
+    const m = msg.message;
+    const spans = Array.isArray(m.spans) ? m.spans : [];
+    const primary = spans.find((s) => s.is_primary) ?? spans[0];
+    diags.push({
+      file: primary?.file_name ?? "",
+      line: primary?.line_start ?? null,
+      col: primary?.column_start ?? null,
+      severity: m.level ?? "unknown",
+      message: m.message ?? "",
+      code: m.code?.code ?? null,
+      isRootCauseCandidate: m.level === "error" && (!m.code || !CASCADING_CODES.includes(m.code.code)) || m.level === "error: aborting"
+    });
+  }
+  return diags;
+}
+var CASCADING_CODES = ["E0432", "E0433", "E0603", "E0560"];
+
+// src/gates/deterministic/index.ts
+async function runDeterministic(config, root, opts = {}) {
+  const repoDiffs = opts.diffs ?? dirtySet(config, root);
+  const findings = [];
+  for (const diff of repoDiffs) {
+    if (opts.repos && !opts.repos.includes(diff.repo)) continue;
+    findings.push(...checkRepoDiff(diff, config));
+  }
+  const cargo = [];
+  if (opts.cargo !== false) {
+    for (const diff of repoDiffs) {
+      if (opts.repos && !opts.repos.includes(diff.repo)) continue;
+      const rustTouched = diff.files.some((f) => f.path.endsWith(".rs") || f.path.endsWith("Cargo.toml"));
+      if (!rustTouched || diff.repo === "(super)") continue;
+      const steps = await cargoCheck(diff.repoDir, { tests: opts.tests ?? false });
+      cargo.push({ repo: diff.repo, steps });
+    }
+  }
+  return { repoDiffs, findings, cargo };
+}
+var SEVERITY_ORDER = { block: 0, human: 1, review: 2 };
+function formatFindings(findings) {
+  if (findings.length === 0) return "no deterministic findings";
+  const sorted = [...findings].sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);
+  const bySeverity = /* @__PURE__ */ new Map();
+  for (const f of sorted) bySeverity.set(f.severity, [...bySeverity.get(f.severity) ?? [], f]);
+  const out = [];
+  for (const [sev, fs] of bySeverity) {
+    out.push(`${sev.toUpperCase()} (${fs.length}):`);
+    for (const f of fs) {
+      out.push(`  ${f.rule} ${f.repo}/${f.file}:${f.line ?? "-"}: ${f.note}`);
+      out.push(`    | ${f.evidence}`);
+    }
+  }
+  return out.join("\n");
+}
+
+// src/loop.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+function diffFingerprint(diffText) {
+  return sha256Hex(diffText);
+}
+var LoopTracker = class {
+  path;
+  state;
+  constructor(statePath) {
+    this.path = statePath;
+    this.state = { cycles: [] };
+    if (existsSync5(statePath)) {
+      try {
+        this.state = JSON.parse(readFileSync6(statePath, "utf8"));
+      } catch {
+        this.state = { cycles: [] };
+      }
+    }
+  }
+  get history() {
+    return this.state.cycles;
+  }
+  record(cycle) {
+    this.state.cycles = [...this.state.cycles.slice(-9), cycle];
+    mkdirSync3(dirname3(this.path), { recursive: true });
+    writeFileSync3(this.path, JSON.stringify(this.state), "utf8");
+  }
+  reset() {
+    this.state = { cycles: [] };
+    if (existsSync5(this.path)) mkdirSync3(dirname3(this.path), { recursive: true });
+    writeFileSync3(this.path, JSON.stringify(this.state), "utf8");
+  }
+  evaluate(diffHash, reasons, maxCycles) {
+    const last = this.state.cycles[this.state.cycles.length - 1];
+    if (!last) return { cycle: 1, repeatedDiff: false, escalate: false };
+    const repeatedDiff = last.diffHash === diffHash;
+    const reasonsOverlap2 = reasons.filter((r) => last.topReasons.some((prev) => overlapTokens(prev, r) > 0.5)).length >= Math.min(2, reasons.length);
+    const cycle = repeatedDiff || reasonsOverlap2 ? this.consecutiveCount(diffHash, reasons) + 1 : 1;
+    if (cycle >= maxCycles) {
+      return {
+        cycle,
+        repeatedDiff,
+        escalate: true,
+        reason: `circuit breaker: ${cycle} consecutive wrangler cycles without progress (repeated diff: ${repeatedDiff}, same findings: ${reasonsOverlap2}); stop retrying and surface to the user`
+      };
+    }
+    return { cycle, repeatedDiff, escalate: false };
+  }
+  consecutiveCount(diffHash, reasons) {
+    let n = 0;
+    for (let i = this.state.cycles.length - 1; i >= 0; i--) {
+      const c = this.state.cycles[i];
+      if (c.diffHash === diffHash || reasonsOverlap(c.topReasons, reasons)) n++;
+      else break;
+    }
+    return n;
+  }
+};
+function overlapTokens(a, b) {
+  const ta = new Set(a.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 3));
+  const tb = new Set(b.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 3));
+  if (ta.size === 0 || tb.size === 0) return 0;
+  let shared = 0;
+  for (const t of tb) if (ta.has(t)) shared++;
+  return shared / Math.max(ta.size, tb.size);
+}
+function reasonsOverlap(a, b) {
+  return b.some((r) => a.some((prev) => overlapTokens(prev, r) > 0.5));
+}
+
+// src/ledger.ts
+import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname4 } from "path";
+var Ledger = class {
+  path;
+  constructor(config, root) {
+    this.path = expandPath(config.ledger.path, root);
+  }
+  get filePath() {
+    return this.path;
+  }
+  append(entry) {
+    mkdirSync4(dirname4(this.path), { recursive: true });
+    appendFileSync(this.path, JSON.stringify(entry) + "\n", "utf8");
+  }
+  read() {
+    if (!existsSync6(this.path)) return [];
+    return readFileSync7(this.path, "utf8").split("\n").filter(Boolean).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+  }
+  recent(kind, n = 20) {
+    return this.read().filter((e) => kind ? e.kind === kind : true).slice(-n);
+  }
+  acksFor(diffHash) {
+    return this.read().filter((e) => e.kind === "ack" && e.diffHash === diffHash);
+  }
+  latestAckFor(diffHash) {
+    const acks = this.acksFor(diffHash);
+    return acks.length > 0 ? acks[acks.length - 1] : null;
+  }
+};
+
+export {
+  PRECEDENCE,
+  stripJsonc,
+  parseJsonc,
+  RuntimeOverridesSchema,
+  readRuntimeOverridesFile,
+  writeRuntimeOverridesFile,
+  clearRuntimeOverrides,
+  applyRuntimeOverrides,
+  ConfigSchema,
+  expandPath,
+  findConfigFile,
+  flattenGates,
+  applyGateFlag,
+  applyEnvOverrides,
+  loadConfig,
+  activeThresholds,
+  sha256Hex,
+  shortHash,
+  splitMarkdown,
+  slug,
+  parseSpec,
+  parseRules,
+  parseDivergences,
+  parseQuestions,
+  parsePlan,
+  parseDoc,
+  parsePaper,
+  ensurePaperText,
+  loadCorpus,
+  loadCorpusFrom,
+  parseCargoJson,
+  checkRepoDiff,
+  checkCommitMessage,
+  runDeterministic,
+  formatFindings,
+  diffFingerprint,
+  LoopTracker,
+  Ledger
+};
+//# sourceMappingURL=chunk-EAQASAXL.js.map