border-customs 0.3.2 → 0.4.1

package/dist/index.js

@@ -13036,9 +13036,9 @@ import { parseArgs } from "node:util";
 
 // src/config.ts
 var import_yaml = __toESM(require_dist(), 1);
-import { spawnSync as spawnSync10 } from "node:child_process";
+import { spawnSync as spawnSync11 } from "node:child_process";
 import { existsSync as existsSync14, readFileSync as readFileSync13 } from "node:fs";
-import { dirname as dirname8, join as join19, resolve as resolve9 } from "node:path";
+import { dirname as dirname8, join as join20, resolve as resolve9 } from "node:path";
 
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -32047,8 +32047,8 @@ var gitChannel = {
 import { spawn as spawn2 } from "node:child_process";
 
 // src/artifacts/npm.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
-import { join as join8, relative as relative2 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
+import { join as join10, relative as relative2 } from "node:path";
 
 // src/check/lock.ts
 import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
@@ -38386,90 +38386,580 @@ function sweepResidueNpmArtifact(o) {
   return hits;
 }
 
-// src/artifacts/npm.ts
-function nativeFinding(rule, severity, message, path4, identity, sanitizer) {
-  const digest2 = redact(identity);
+// src/rules/releaseCoherence.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { basename, join as join9 } from "node:path";
+
+// src/ledger/records.ts
+import { appendFileSync, readFileSync as readFileSync5 } from "node:fs";
+import { join as join8 } from "node:path";
+var LEDGER_FILE = "ledger.jsonl";
+var RUNS_SUBDIR = "runs";
+var HEX64 = /^[0-9a-f]{64}$/;
+var HEX40 = /^[0-9a-f]{40}$/;
+var HEX8 = /^[0-9a-f]{8}$/;
+var PUSH_CONFIRMED_VIA = ["ls-remote", "npm-view", "pypi-json", "crates-json", "rubygems-json"];
+function ledgerPath(repoDir) {
+  return join8(repoDir, BORDER_STATE_DIR, LEDGER_FILE);
+}
+function runsDir(repoDir) {
+  return join8(repoDir, BORDER_STATE_DIR, RUNS_SUBDIR);
+}
+function formatSkipLine(record2) {
+  return `SKIP ${record2.key8} \u2014 PASS ${record2.ts} report ${record2.reportPath}`;
+}
+function buildPushRecord(i) {
   return {
-    rule,
-    severity,
-    target: NPM_TARGET_LABEL,
-    path: path4,
-    engine: "native",
-    message: sanitizeOut(sanitizer, message),
-    valueDigest: digest2.valueDigest,
-    snippet: digest2.snippet
+    t: "push",
+    key: i.key,
+    target: i.target,
+    remoteName: i.remoteName,
+    url: sanitizeUrl(i.url),
+    localSha: i.localSha,
+    ...i.remoteSha !== void 0 ? { remoteSha: i.remoteSha } : {},
+    ...i.version !== void 0 ? { version: i.version } : {},
+    confirmedVia: i.confirmedVia,
+    ts: i.ts ?? (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function attributeToTarball(findings, artifact) {
-  if (artifact === null) return findings;
-  const name = artifact.file.slice(artifact.file.lastIndexOf("/") + 1);
-  return findings.map((f) => {
-    const p = f.path ?? "";
-    const rel = p === "package.json" ? p : p.startsWith("package/") ? p.slice("package/".length) : null;
-    return rel === null || rel === "" ? f : { ...f, path: `${name}!${rel}` };
+function buildRoundtripRecord(i) {
+  if (!HEX64.test(i.artifactSha256)) bad("artifactSha256 is not hex-shaped");
+  if (!HEX64.test(i.rulesHash)) bad("rulesHash is not hex-shaped");
+  if (i.verdict !== "clean" && i.verdict !== "residue") bad(`verdict must be clean or residue, got '${i.verdict}'`);
+  if (!Number.isInteger(i.rows) || i.rows < 0) bad("rows must be a non-negative integer");
+  return {
+    t: "roundtrip",
+    artifactSha256: i.artifactSha256,
+    verdict: i.verdict,
+    rulesHash: i.rulesHash,
+    rows: i.rows,
+    ts: i.ts ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function bad(msg) {
+  throw new Error(msg);
+}
+function needString(o, field) {
+  const v = o[field];
+  if (typeof v !== "string" || v === "") bad(`${field} must be a non-empty string`);
+  return v;
+}
+function needHex(o, field, re) {
+  const v = needString(o, field);
+  if (!re.test(v)) bad(`${field} is not hex-shaped`);
+  return v;
+}
+function needStringArray(o, field) {
+  const v = o[field];
+  if (!Array.isArray(v) || !v.every((x) => typeof x === "string")) bad(`${field} must be an array of strings`);
+  return v;
+}
+function parseCounts(value) {
+  if (typeof value !== "object" || value === null) bad("counts must be an object");
+  const o = value;
+  for (const field of ["INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL", "total", "blocking", "warnings"]) {
+    if (typeof o[field] !== "number" || !Number.isInteger(o[field])) bad(`counts.${field} must be an integer`);
+  }
+  return o;
+}
+function parseArtifacts(o) {
+  if (o.artifacts === null) return null;
+  const v = o.artifacts;
+  if (!Array.isArray(v)) bad("artifacts must be null or an array");
+  return v.map((item, i) => {
+    if (typeof item !== "object" || item === null) bad(`artifacts[${String(i)}] must be an object`);
+    const a = item;
+    return { file: needString(a, "file"), sha256: needHex(a, "sha256", HEX64) };
   });
 }
-function scopeFindingPath(f, extractDir) {
-  if (f.path === void 0) return f;
-  const bang = f.path.indexOf("!");
-  if (bang > 0) {
-    const rel2 = relative2(extractDir, f.path.slice(0, bang));
-    if (!rel2.startsWith("..")) return { ...f, path: rel2 === "" ? f.path.slice(bang + 1) : `${rel2}${f.path.slice(bang)}` };
+function parseLedgerRecord(value) {
+  if (typeof value !== "object" || value === null) bad("record must be an object");
+  const o = value;
+  const t = o.t;
+  if (t === "check") {
+    const key = needHex(o, "key", HEX64);
+    const key8 = needHex(o, "key8", HEX8);
+    if (key.slice(0, 8) !== key8) bad("key8 must be the first 8 hex chars of key");
+    const verdict = needString(o, "verdict");
+    if (verdict !== "PASS" && verdict !== "FAIL") bad(`verdict must be PASS or FAIL, got '${verdict}'`);
+    if (o.degraded !== false) bad("degraded must be false \u2014 degraded runs are never ledgered");
+    if (typeof o.llm !== "boolean") bad("llm must be a boolean");
+    return {
+      t: "check",
+      key,
+      key8,
+      head: needHex(o, "head", HEX40),
+      dirtyDigest: needHex(o, "dirtyDigest", HEX64),
+      refSetHash: needHex(o, "refSetHash", HEX64),
+      exposureSet: needStringArray(o, "exposureSet"),
+      effectiveTargets: needStringArray(o, "effectiveTargets"),
+      rulesHash: needHex(o, "rulesHash", HEX64),
+      artifacts: parseArtifacts(o),
+      llm: o.llm,
+      verdict,
+      counts: parseCounts(o.counts),
+      reportPath: needString(o, "reportPath"),
+      degraded: false,
+      ts: needString(o, "ts")
+    };
   }
-  const rel = relative2(extractDir, f.path);
-  return rel === "" || rel.startsWith("..") ? f : { ...f, path: rel };
+  if (t === "push") {
+    const confirmedVia = needString(o, "confirmedVia");
+    if (!PUSH_CONFIRMED_VIA.includes(confirmedVia)) {
+      bad(`confirmedVia must be one of ${PUSH_CONFIRMED_VIA.join("|")}`);
+    }
+    const remoteSha = o.remoteSha;
+    const version2 = o.version;
+    if (remoteSha === void 0 && version2 === void 0) bad("push record needs remoteSha or version");
+    if (remoteSha !== void 0 && typeof remoteSha !== "string") bad("remoteSha must be a string");
+    if (version2 !== void 0 && typeof version2 !== "string") bad("version must be a string");
+    return {
+      t: "push",
+      key: needHex(o, "key", HEX64),
+      target: needString(o, "target"),
+      remoteName: needString(o, "remoteName"),
+      url: needString(o, "url"),
+      localSha: needString(o, "localSha"),
+      ...remoteSha !== void 0 ? { remoteSha } : {},
+      ...version2 !== void 0 ? { version: version2 } : {},
+      confirmedVia,
+      ts: needString(o, "ts")
+    };
+  }
+  if (t === "roundtrip") {
+    const verdict = needString(o, "verdict");
+    if (verdict !== "clean" && verdict !== "residue") bad(`verdict must be clean or residue, got '${verdict}'`);
+    const rows = o.rows;
+    if (typeof rows !== "number" || !Number.isInteger(rows) || rows < 0) bad("rows must be a non-negative integer");
+    return {
+      t: "roundtrip",
+      artifactSha256: needHex(o, "artifactSha256", HEX64),
+      verdict,
+      rulesHash: needHex(o, "rulesHash", HEX64),
+      rows,
+      ts: needString(o, "ts")
+    };
+  }
+  return bad(`unknown record type ${JSON.stringify(t)}`);
 }
-function listFiles(dir) {
-  const out = [];
-  const stack = [dir];
-  while (stack.length > 0) {
-    const cur = stack.pop();
-    for (const ent of readdirSync2(cur, { withFileTypes: true })) {
-      const p = join8(cur, ent.name);
-      if (ent.isDirectory()) stack.push(p);
-      else if (ent.isFile()) out.push(p);
+function codeOf2(err) {
+  return typeof err === "object" && err !== null ? err.code : void 0;
+}
+function readLedger(repoDir) {
+  let text;
+  try {
+    text = readFileSync5(ledgerPath(repoDir), "utf8");
+  } catch (err) {
+    if (codeOf2(err) === "ENOENT") return { records: [], warnings: [] };
+    throw err;
+  }
+  const records = [];
+  const warnings = [];
+  text.split("\n").forEach((line, i) => {
+    if (line.trim() === "") return;
+    try {
+      records.push(parseLedgerRecord(JSON.parse(line)));
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      warnings.push(`ledger line ${String(i + 1)} unreadable (${reason.slice(0, 160)}) \u2014 line skipped`);
     }
+  });
+  return { records, warnings };
+}
+function appendRecord(repoDir, record2) {
+  ensureStateDir(repoDir);
+  appendFileSync(ledgerPath(repoDir), `${JSON.stringify(record2)}
+`, "utf8");
+}
+function newestRecordOf(records, key) {
+  for (let i = records.length - 1; i >= 0; i -= 1) {
+    const r = records[i];
+    if (r.t === "check" && r.key === key) return r;
   }
-  return out;
+  return null;
 }
-async function runNpmArtifactStage(o) {
-  if (o.cfg.targets.npm === void 0) {
-    throw new EngineRunError("runNpmArtifactStage invoked without targets.npm configured \u2014 pipeline bug", null);
+function isSkippable(r) {
+  return r !== null && r.verdict === "PASS" && r.degraded === false;
+}
+function lookupSkipRecord(records, key, llm) {
+  const newest = newestRecordOf(records, key);
+  return isSkippable(newest) && newest.llm === llm ? newest : null;
+}
+function latestPassCoveringTargets(records, key, targets) {
+  const newest = newestRecordOf(records, key);
+  return isSkippable(newest) && targets.every((t) => newest.effectiveTargets.includes(t)) ? newest : null;
+}
+function pushRecords(records, key) {
+  return records.filter((r) => r.t === "push" && (key === void 0 || r.key === key));
+}
+function latestRoundtripForSha(records, artifactSha256) {
+  for (let i = records.length - 1; i >= 0; i -= 1) {
+    const r = records[i];
+    if (r !== void 0 && r.t === "roundtrip" && r.artifactSha256 === artifactSha256) return r;
   }
-  const { repoDir } = o;
-  const manifestPath = join8(repoDir, "package.json");
-  if (!existsSync6(manifestPath)) {
-    throw new EngineRunError("targets.npm is configured but the repo has no package.json to pack", null);
+  return null;
+}
+
+// src/rules/releaseCoherence.ts
+var RELEASE_COHERENCE_DRIFT_RULE = "release-coherence-version-drift";
+var RELEASE_COHERENCE_TWIN_RULE = "release-coherence-twin-drift";
+var RELEASE_COHERENCE_UNVERIFIABLE_RULE = "release-coherence-unverifiable-source";
+var RELEASE_COHERENCE_SEVERITIES = {
+  [RELEASE_COHERENCE_DRIFT_RULE]: "CRITICAL",
+  [RELEASE_COHERENCE_TWIN_RULE]: "CRITICAL",
+  [RELEASE_COHERENCE_UNVERIFIABLE_RULE]: "MEDIUM"
+};
+var TARGET = "artifact";
+var ENGINE = "native";
+var FOUNDING = "version truth must AGREE across every source packed in the artifact (aihr: a wheel named 0.2.2 shipped __version__ 0.2.1)";
+function probeDunderVersion(text) {
+  for (const line of text.split(/\r?\n/)) {
+    const assign = /^\s*__version__\s*=\s*(.+?)\s*$/.exec(line);
+    if (assign?.[1] !== void 0) {
+      const lit = /^(['"])((?:(?!\1).)+)\1(?:\s*#.*)?$/.exec(assign[1]);
+      return lit?.[2] !== void 0 ? { status: "literal", value: lit[2] } : { status: "dynamic", reason: `__version__ assigned a non-literal (${assign[1].slice(0, 60)})` };
+    }
+    if (/^\s*(?:from\s+\S+\s+)?import\b.*\b__version__\b/.test(line)) {
+      return { status: "dynamic", reason: "__version__ imported from another module" };
+    }
   }
-  const manifest = parseNpmManifest(readFileSync5(manifestPath, "utf8"));
-  const identity = `${manifest.name ?? "?"}@${manifest.version ?? "?"}`;
-  if (manifest.isPrivate) {
+  return null;
+}
+function probeHeaderVersion(text) {
+  const m = /^Version:[ \t]*(.*?)[ \t]*$/m.exec(text);
+  if (m === null) return null;
+  return m[1] !== void 0 && m[1] !== "" ? { status: "literal", value: m[1] } : { status: "dynamic", reason: "Version: header present but empty" };
+}
+function probePyprojectVersion(text) {
+  const lines = text.split(/\r?\n/);
+  let inProject = false;
+  const slice = [];
+  for (const line of lines) {
+    if (/^\s*\[/.test(line)) {
+      if (inProject) break;
+      inProject = /^\s*\[project\]\s*$/.test(line);
+      continue;
+    }
+    if (inProject) slice.push(line);
+  }
+  if (!inProject && slice.length === 0 && !text.includes("[project]")) return null;
+  const body = slice.join("\n");
+  const lit = /^\s*version\s*=\s*(['"])((?:(?!\1).)+)\1\s*(?:#.*)?$/m.exec(body);
+  if (lit?.[2] !== void 0) return { status: "literal", value: lit[2] };
+  const dyn = /dynamic\s*=\s*\[([\s\S]*?)\]/.exec(`${body}
+]`);
+  if (dyn?.[1] !== void 0 && /["']version["']/.test(dyn[1])) return { status: "dynamic", reason: 'project.version listed in dynamic = ["version"]' };
+  return { status: "dynamic", reason: "[project] declares no statically-readable version" };
+}
+function probeSetupCfgVersion(text) {
+  const lines = text.split(/\r?\n/);
+  let inSection = false;
+  const slice = [];
+  for (const line of lines) {
+    if (/^\s*\[/.test(line)) {
+      if (inSection) break;
+      inSection = /^\s*\[metadata\]\s*$/.test(line);
+      continue;
+    }
+    if (inSection) slice.push(line);
+  }
+  const v = /^[ \t]*version[ \t]*=[ \t]*(.+?)[ \t]*$/m.exec(slice.join("\n"));
+  if (v?.[1] === void 0) return null;
+  return /^[\w.+-]+$/.test(v[1]) ? { status: "literal", value: v[1] } : { status: "dynamic", reason: `setup.cfg version = '${v[1].slice(0, 40)}' is not a bare literal` };
+}
+function probeSetupPyVersion(text) {
+  const lit = /(?:^|[,(]\s*)version\s*=\s*(['"])((?:(?!\1).)+)\1/.exec(text);
+  if (lit?.[2] !== void 0) return { status: "literal", value: lit[2] };
+  return /(?:^|[,(]\s*)version\s*=/.test(text) ? { status: "dynamic", reason: "setup.py version= is not a string literal" } : null;
+}
+function parseWheelFilenameVersion(fileName) {
+  const base = basename(fileName).replace(/\.whl$/i, "");
+  const parts = base.split("-");
+  if (parts.length < 5) return null;
+  const name = parts[0];
+  const version2 = parts[1];
+  return name !== "" && version2 !== "" ? { name, version: version2 } : null;
+}
+function parseDistInfoDirVersion(relPath) {
+  const dir = /(?:^|\/)([^/]+\.dist-info)\//.exec(relPath)?.[1];
+  if (dir === void 0) return null;
+  const stem = dir.slice(0, -".dist-info".length);
+  const idx = stem.lastIndexOf("-");
+  return idx >= 0 ? stem.slice(idx + 1) : null;
+}
+var normName = (s) => s.toLowerCase().replace(/[-_.]+/g, "_");
+function toFindings2(hits, identity, sanitizer) {
+  return hits.map((hit) => {
+    const { valueDigest, snippet } = redact(`${identity}:release-coherence:${hit.rule}:${hit.disc}`);
     return {
-      findings: [nativeFinding(
-        NPM_PRIVATE_RULE,
-        "CRITICAL",
-        `package.json is private:true but border.yaml configures targets.npm \u2014 nothing can ever publish from this repo; drop the private flag or the npm target`,
-        "package.json",
-        `${identity}:private`,
-        o.sanitizer
-      )],
-      artifact: null
+      rule: hit.rule,
+      severity: RELEASE_COHERENCE_SEVERITIES[hit.rule],
+      target: TARGET,
+      path: hit.path,
+      engine: ENGINE,
+      message: sanitizer?.sanitize(hit.message) ?? hit.message,
+      valueDigest,
+      snippet
     };
-  }
-  ensureStateDir(repoDir);
-  const stateDir = join8(repoDir, BORDER_STATE_DIR);
-  const distDir = join8(stateDir, "dist");
-  mkdirSync3(distDir, { recursive: true });
-  const { filename, sha256: sha2563, bytes, tarballAbs } = packOnce({
-    repoDir,
-    distDir,
-    ...o.env !== void 0 ? { env: o.env } : {},
-    ...o.npmBinPath !== void 0 ? { npmBinPath: o.npmBinPath } : {},
-    ...o.npmTimeoutMs !== void 0 ? { npmTimeoutMs: o.npmTimeoutMs } : {}
   });
-  const findings = [];
-  const extractDir = join8(stateDir, "tmp", sha2563.slice(0, 8));
-  rmSync3(extractDir, { recursive: true, force: true });
+}
+function analyze(sources, pathPrefix, hits) {
+  const primary = sources.find((s) => s.probe?.status === "literal");
+  for (const s of sources) {
+    if (s.probe === null) continue;
+    if (s.probe.status === "dynamic") {
+      hits.push({
+        rule: RELEASE_COHERENCE_UNVERIFIABLE_RULE,
+        message: `release coherence: ${s.label} (${s.path}) carries a version that cannot be verified statically \u2014 ${s.probe.reason}; surfaced, never silent-clean`,
+        path: `${pathPrefix}${s.path}`,
+        disc: `${s.path}:unverifiable`
+      });
+      continue;
+    }
+    if (primary === void 0 || s === primary) continue;
+    if (s.probe.value !== primary.probe.value) {
+      hits.push({
+        rule: RELEASE_COHERENCE_DRIFT_RULE,
+        message: `release coherence: ${primary.label} '${primary.probe.value}' disagrees with ${s.label} '${s.probe.value}' \u2014 ${FOUNDING}`,
+        path: `${pathPrefix}${s.path}`,
+        disc: `${s.path}:vs:${primary.label}`
+      });
+    }
+  }
+}
+function npmPackCoherenceFindings(o) {
+  if (o.lockText === null || o.packedVersion === null) return [];
+  let lock;
+  try {
+    lock = JSON.parse(o.lockText);
+  } catch {
+    return toFindings2([{ rule: RELEASE_COHERENCE_UNVERIFIABLE_RULE, message: `release coherence: ${o.lockRelPath} is packed but not parseable JSON \u2014 cannot verify, never silent-clean`, path: o.lockRelPath, disc: "malformed" }], o.identity, o.sanitizer);
+  }
+  const hits = [];
+  const rootVer = typeof lock["version"] === "string" ? lock["version"] : null;
+  const pkgs = lock["packages"];
+  const rootPkg = typeof pkgs === "object" && pkgs !== null ? pkgs[""] : void 0;
+  const pkgEmptyVer = typeof rootPkg === "object" && rootPkg !== null ? rootPkg["version"] : null;
+  const cmp = (label, value, disc) => {
+    if (value !== null && value !== o.packedVersion) {
+      hits.push({ rule: RELEASE_COHERENCE_DRIFT_RULE, message: `release coherence: packed package.json version '${String(o.packedVersion)}' disagrees with ${label} '${value}' \u2014 ${FOUNDING}`, path: o.lockRelPath, disc });
+    }
+  };
+  cmp("package-lock.json root version", rootVer, "root");
+  cmp('package-lock.json packages[""] version', typeof pkgEmptyVer === "string" ? pkgEmptyVer : null, "packages-empty");
+  return toFindings2(hits, o.identity, o.sanitizer);
+}
+function pypiArtifactCoherenceFindings(o) {
+  const sources = [];
+  const inTree = (rel) => o.files.includes(rel);
+  const textOf = (rel) => inTree(rel) ? o.read(rel) : null;
+  if (o.kind === "wheel") {
+    const metaRel = o.files.find((f) => /\.dist-info\/METADATA$/.test(f));
+    if (metaRel !== void 0) {
+      const body = o.read(metaRel);
+      sources.push({ label: "wheel METADATA Version:", path: metaRel, probe: body === null ? null : probeHeaderVersion(body) ?? { status: "dynamic", reason: "METADATA has no Version: header" } });
+      const dirVer = parseDistInfoDirVersion(metaRel);
+      if (dirVer !== null) sources.push({ label: "wheel .dist-info directory name", path: metaRel, probe: { status: "literal", value: dirVer } });
+    }
+    const fn = parseWheelFilenameVersion(o.archiveName);
+    if (fn !== null) sources.push({ label: "wheel filename", path: metaRel ?? o.archiveName, probe: { status: "literal", value: fn.version } });
+  } else {
+    const pyproject = textOf("pyproject.toml");
+    if (pyproject !== null) sources.push({ label: "pyproject [project].version", path: "pyproject.toml", probe: probePyprojectVersion(pyproject) });
+    const cfg = textOf("setup.cfg");
+    if (cfg !== null) sources.push({ label: "setup.cfg [metadata] version", path: "setup.cfg", probe: probeSetupCfgVersion(cfg) });
+    const py = textOf("setup.py");
+    if (py !== null) sources.push({ label: "setup.py version literal", path: "setup.py", probe: probeSetupPyVersion(py) });
+    const pkgInfoRel = o.files.find((f) => f === "PKG-INFO" || f.endsWith(".egg-info/PKG-INFO"));
+    if (pkgInfoRel !== void 0) {
+      const body = o.read(pkgInfoRel);
+      if (body !== null) sources.push({ label: "PKG-INFO Version:", path: pkgInfoRel, probe: probeHeaderVersion(body) ?? { status: "dynamic", reason: "PKG-INFO has no Version: header" } });
+    }
+  }
+  for (const initRel of o.files.filter((f) => /(?:^|\/)__init__\.py$/.test(f)).sort()) {
+    const body = o.read(initRel);
+    if (body === null) continue;
+    const probe = probeDunderVersion(body);
+    if (probe !== null) sources.push({ label: `__version__ literal in ${initRel}`, path: initRel, probe });
+  }
+  const hits = [];
+  analyze(sources, `${o.archiveName}!`, hits);
+  return toFindings2(hits, o.identity, o.sanitizer);
+}
+function cratesCoherenceFindings(o) {
+  if (o.lockText === null) return [];
+  const entries = o.lockText.split(/^\[\[package\]\][ \t]*$/m).map((block) => ({ name: /^\s*name\s*=\s*"([^"]*)"/m.exec(block)?.[1], version: /^\s*version\s*=\s*"([^"]*)"/m.exec(block)?.[1] })).filter((e) => e.name !== void 0 && e.version !== void 0).filter((e) => e.name === o.name);
+  if (entries.length === 0) {
+    return toFindings2([{ rule: RELEASE_COHERENCE_UNVERIFIABLE_RULE, message: `release coherence: ${o.lockRelPath} is packed but names no [[package]] '${o.name}' \u2014 cannot verify, never silent-clean`, path: o.lockRelPath, disc: "no-entry" }], o.identity, o.sanitizer);
+  }
+  const hits = [];
+  for (const v of [...new Set(entries.map((e) => e.version))].sort()) {
+    if (v !== o.version) {
+      hits.push({ rule: RELEASE_COHERENCE_DRIFT_RULE, message: `release coherence: Cargo.toml [package].version '${o.version}' disagrees with Cargo.lock entry '${o.name}' version '${v}' \u2014 ${FOUNDING}`, path: o.lockRelPath, disc: v });
+    }
+  }
+  return toFindings2(hits, o.identity, o.sanitizer);
+}
+function gemCoherenceFindings(o) {
+  if (o.metadataText === null) return [];
+  const name = /^name:[ \t]*(\S+)[ \t]*$/m.exec(o.metadataText)?.[1];
+  const version2 = /^version:[ \t]*!ruby\/object:Gem::Version[ \t]*\n[ \t]+version:[ \t]*(\S+)[ \t]*$/m.exec(o.metadataText)?.[1];
+  if (name === void 0 || version2 === void 0) {
+    return toFindings2([{ rule: RELEASE_COHERENCE_UNVERIFIABLE_RULE, message: "release coherence: metadata.gz is present but its Gem::Specification name/version could not be read statically \u2014 cannot verify, never silent-clean", path: "metadata.gz", disc: "unparseable" }], o.identity, o.sanitizer);
+  }
+  const hits = [];
+  if (name !== o.specName) hits.push({ rule: RELEASE_COHERENCE_DRIFT_RULE, message: `release coherence: built gem '${o.identity}' names '${o.specName}' but metadata.gz Gem::Specification name is '${name}' \u2014 ${FOUNDING}`, path: "metadata.gz", disc: "name" });
+  if (version2 !== o.specVersion) hits.push({ rule: RELEASE_COHERENCE_DRIFT_RULE, message: `release coherence: built gem '${o.identity}' names version '${o.specVersion}' but metadata.gz Gem::Version is '${version2}' \u2014 ${FOUNDING}`, path: "metadata.gz", disc: "version" });
+  return toFindings2(hits, o.identity, o.sanitizer);
+}
+function packedNpmIdentity(archiveAbs, env2) {
+  const opts = { encoding: "utf8", timeout: 3e4, ...env2 !== void 0 ? { env: env2 } : {} };
+  const listing = spawnSync3("tar", ["-tzf", archiveAbs], opts);
+  if (listing.status !== 0) return null;
+  const members2 = (listing.stdout ?? "").split("\n").filter((l) => /^[^/]+\/package\.json$/.test(l));
+  const member = members2.includes("package/package.json") ? "package/package.json" : members2.length === 1 ? members2[0] : void 0;
+  if (member === void 0) return null;
+  const body = spawnSync3("tar", ["-xzOf", archiveAbs, member], opts);
+  if (body.status !== 0) return null;
+  try {
+    const pkg = JSON.parse(body.stdout);
+    return typeof pkg["name"] === "string" && typeof pkg["version"] === "string" ? { name: pkg["name"], version: pkg["version"] } : null;
+  } catch {
+    return null;
+  }
+}
+async function twinCoherenceFindings(o) {
+  const wheels = o.artifacts.filter((a) => a.file.endsWith(".whl")).sort((a, b) => a.file.localeCompare(b.file));
+  const tgzs = o.artifacts.filter((a) => a.file.endsWith(".tgz")).sort((a, b) => a.file.localeCompare(b.file));
+  const hits = [];
+  for (const pair of o.pairs) {
+    const wh = wheels.find((a) => {
+      const parsed = parseWheelFilenameVersion(basename(a.file));
+      return parsed !== null && normName(parsed.name) === normName(pair.pypi);
+    });
+    if (wh === void 0) {
+      hits.push({ rule: RELEASE_COHERENCE_UNVERIFIABLE_RULE, message: `release coherence: release.twin pair '${pair.pypi}'/'${pair.npm}' \u2014 no staged wheel for '${pair.pypi}' in this run, so the declared cross-manager equality cannot be verified`, path: `${pair.pypi}(missing).whl`, disc: `twin:${pair.pypi}:no-wheel` });
+      continue;
+    }
+    const wheelVersion = parseWheelFilenameVersion(basename(wh.file)).version;
+    let npmSide = null;
+    let npmUnreadable = false;
+    for (const t of tgzs) {
+      const id = packedNpmIdentity(join9(o.repoDir, t.file), o.env);
+      if (id === null) {
+        npmUnreadable = true;
+        continue;
+      }
+      if (id.name === pair.npm) {
+        npmSide = { file: t.file, version: id.version };
+        break;
+      }
+    }
+    if (npmSide === null) {
+      hits.push({
+        rule: RELEASE_COHERENCE_UNVERIFIABLE_RULE,
+        message: `release coherence: release.twin pair '${pair.pypi}'/'${pair.npm}' \u2014 ${npmUnreadable ? `npm twin '${pair.npm}' is staged but its package.json could not be read from the tarball bytes` : `no staged npm artifact for twin '${pair.npm}' in this run`}, so the declared cross-manager equality cannot be verified`,
+        path: basename(wh.file),
+        disc: `twin:${pair.pypi}:no-npm`
+      });
+      continue;
+    }
+    if (wheelVersion !== npmSide.version) {
+      hits.push({
+        rule: RELEASE_COHERENCE_TWIN_RULE,
+        message: `release coherence: release.twin pair '${pair.pypi}'/'${pair.npm}' \u2014 wheel '${basename(wh.file)}' says version '${wheelVersion}' but npm twin '${basename(npmSide.file)}' packed package.json says '${npmSide.version}' \u2014 ${FOUNDING}`,
+        path: basename(wh.file),
+        disc: `twin:${pair.pypi}:${basename(npmSide.file)}`
+      });
+    }
+  }
+  return toFindings2(hits, "release.twin", o.sanitizer);
+}
+
+// src/artifacts/npm.ts
+function nativeFinding(rule, severity, message, path4, identity, sanitizer) {
+  const digest2 = redact(identity);
+  return {
+    rule,
+    severity,
+    target: NPM_TARGET_LABEL,
+    path: path4,
+    engine: "native",
+    message: sanitizeOut(sanitizer, message),
+    valueDigest: digest2.valueDigest,
+    snippet: digest2.snippet
+  };
+}
+function attributeToTarball(findings, artifact) {
+  if (artifact === null) return findings;
+  const name = artifact.file.slice(artifact.file.lastIndexOf("/") + 1);
+  return findings.map((f) => {
+    const p = f.path ?? "";
+    const rel = p === "package.json" ? p : p.startsWith("package/") ? p.slice("package/".length) : null;
+    return rel === null || rel === "" ? f : { ...f, path: `${name}!${rel}` };
+  });
+}
+function scopeFindingPath(f, extractDir) {
+  if (f.path === void 0) return f;
+  const bang = f.path.indexOf("!");
+  if (bang > 0) {
+    const rel2 = relative2(extractDir, f.path.slice(0, bang));
+    if (!rel2.startsWith("..")) return { ...f, path: rel2 === "" ? f.path.slice(bang + 1) : `${rel2}${f.path.slice(bang)}` };
+  }
+  const rel = relative2(extractDir, f.path);
+  return rel === "" || rel.startsWith("..") ? f : { ...f, path: rel };
+}
+function listFiles(dir) {
+  const out = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    for (const ent of readdirSync2(cur, { withFileTypes: true })) {
+      const p = join10(cur, ent.name);
+      if (ent.isDirectory()) stack.push(p);
+      else if (ent.isFile()) out.push(p);
+    }
+  }
+  return out;
+}
+async function runNpmArtifactStage(o) {
+  if (o.cfg.targets.npm === void 0) {
+    throw new EngineRunError("runNpmArtifactStage invoked without targets.npm configured \u2014 pipeline bug", null);
+  }
+  const { repoDir } = o;
+  const manifestPath = join10(repoDir, "package.json");
+  if (!existsSync6(manifestPath)) {
+    throw new EngineRunError("targets.npm is configured but the repo has no package.json to pack", null);
+  }
+  const manifest = parseNpmManifest(readFileSync6(manifestPath, "utf8"));
+  const identity = `${manifest.name ?? "?"}@${manifest.version ?? "?"}`;
+  if (manifest.isPrivate) {
+    return {
+      findings: [nativeFinding(
+        NPM_PRIVATE_RULE,
+        "CRITICAL",
+        `package.json is private:true but border.yaml configures targets.npm \u2014 nothing can ever publish from this repo; drop the private flag or the npm target`,
+        "package.json",
+        `${identity}:private`,
+        o.sanitizer
+      )],
+      artifact: null
+    };
+  }
+  ensureStateDir(repoDir);
+  const stateDir = join10(repoDir, BORDER_STATE_DIR);
+  const distDir = join10(stateDir, "dist");
+  mkdirSync3(distDir, { recursive: true });
+  const { filename, sha256: sha2563, bytes, tarballAbs } = packOnce({
+    repoDir,
+    distDir,
+    ...o.env !== void 0 ? { env: o.env } : {},
+    ...o.npmBinPath !== void 0 ? { npmBinPath: o.npmBinPath } : {},
+    ...o.npmTimeoutMs !== void 0 ? { npmTimeoutMs: o.npmTimeoutMs } : {}
+  });
+  const findings = [];
+  const extractDir = join10(stateDir, "tmp", sha2563.slice(0, 8));
+  rmSync3(extractDir, { recursive: true, force: true });
   mkdirSync3(extractDir, { recursive: true });
   try {
     extractArchive(tarballAbs, extractDir, {
@@ -38484,8 +38974,16 @@ async function runNpmArtifactStage(o) {
     }
     const packedManifestRel = `${root}/package.json`;
     if (!relPaths.includes(packedManifestRel)) throw new EngineRunError("extracted artifact has no package/package.json", null);
-    const packedManifest = parseNpmManifest(readFileSync5(join8(extractDir, packedManifestRel), "utf8"));
-    const pkgDir = join8(extractDir, root);
+    const packedManifest = parseNpmManifest(readFileSync6(join10(extractDir, packedManifestRel), "utf8"));
+    const lockRel = `${root}/package-lock.json`;
+    findings.push(...npmPackCoherenceFindings({
+      packedVersion: packedManifest.version,
+      lockText: relPaths.includes(lockRel) ? readFileSync6(join10(extractDir, lockRel), "utf8") : null,
+      lockRelPath: lockRel,
+      identity,
+      ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {}
+    }));
+    const pkgDir = join10(extractDir, root);
     const residueCtx = { root, identity, ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {} };
     for (const key of LIFECYCLE_SCRIPT_KEYS) {
       const cmd = packedManifest.scripts[key];
@@ -38570,7 +39068,7 @@ async function runNpmArtifactStage(o) {
 }
 
 // src/check/context.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import { dirname as dirname4, resolve as resolve4 } from "node:path";
 
@@ -38597,7 +39095,7 @@ function isRecord(value) {
 // src/check/context.ts
 function gitSpawn(repoDir, args, o = {}) {
   const abs = resolve4(repoDir);
-  const r = spawnSync3("git", ["-C", abs, ...args], {
+  const r = spawnSync4("git", ["-C", abs, ...args], {
     encoding: "utf8",
     env: { ...o.env ?? process.env, GIT_CEILING_DIRECTORIES: dirname4(abs) },
     timeout: 6e4
@@ -38656,7 +39154,7 @@ function computeEffectiveTargets(cfg, requested) {
 }
 
 // src/rules/identity.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
 import { dirname as dirname5, resolve as resolve5 } from "node:path";
 
 // src/rules/allowlist.ts
@@ -38721,7 +39219,7 @@ function addRole(entries, key, entry, obj, role) {
   found.objects.set(obj, prev === void 0 ? role : `${prev}+${role}`);
 }
 function runGit2(repoDir, args) {
-  const r = spawnSync4("git", args, {
+  const r = spawnSync5("git", args, {
     cwd: repoDir,
     encoding: "utf8",
     env: { ...process.env, GIT_CEILING_DIRECTORIES: dirname5(resolve5(repoDir)) }
@@ -38767,7 +39265,7 @@ function collectCommits(s, revs) {
   }
 }
 function revExists(repoDir, rev) {
-  const r = spawnSync4("git", ["rev-parse", "--verify", "--quiet", rev], {
+  const r = spawnSync5("git", ["rev-parse", "--verify", "--quiet", rev], {
     cwd: repoDir,
     encoding: "utf8",
     env: { ...process.env, GIT_CEILING_DIRECTORIES: dirname5(resolve5(repoDir)) }
@@ -38871,12 +39369,12 @@ function scanIdentity(o) {
 // src/ledger.ts
 import { createHash as createHash8 } from "node:crypto";
 import { writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 
 // src/check/rulesHash.ts
 import { createHash as createHash5 } from "node:crypto";
 import { existsSync as existsSync7 } from "node:fs";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { dirname as dirname6, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var RESIDUE_FINGERPRINT_SOURCES = [
   { dir: "rules", base: "residueMatchers.ts" },
@@ -38894,12 +39392,26 @@ function resolveResidueFingerprintFiles(env2 = process.env) {
   const here = dirname6(fileURLToPath4(import.meta.url));
   const seam = env2.BORDER_RESIDUE_SRC_DIR;
   return RESIDUE_FINGERPRINT_SOURCES.map(({ dir, base }) => {
-    if (seam !== void 0) return join9(seam, base);
-    const live = join9(here, "..", dir, base);
+    if (seam !== void 0) return join11(seam, base);
+    const live = join11(here, "..", dir, base);
     if (existsSync7(live)) return live;
     return resolveAsset(import.meta.url, ["residue-src", base]);
   });
 }
+var RELEASE_FINGERPRINT_SOURCES = [
+  { dir: "rules", base: "releaseCoherence.ts" }
+];
+var RELEASE_FINGERPRINT_BASENAMES = RELEASE_FINGERPRINT_SOURCES.map((s) => s.base);
+function resolveReleaseFingerprintFiles(env2 = process.env) {
+  const here = dirname6(fileURLToPath4(import.meta.url));
+  const seam = env2.BORDER_RELEASE_SRC_DIR;
+  return RELEASE_FINGERPRINT_SOURCES.map(({ dir, base }) => {
+    if (seam !== void 0) return join11(seam, base);
+    const live = join11(here, "..", dir, base);
+    if (existsSync7(live)) return live;
+    return resolveAsset(import.meta.url, ["release-src", base]);
+  });
+}
 function resolvePromptTemplatePath(env2 = process.env) {
   return env2.BORDER_PROMPT_TEMPLATE_PATH ?? resolveAsset(import.meta.url, ["prompts", "llm-review.md"]);
 }
@@ -38918,7 +39430,11 @@ function computeConfigDigest(load) {
 async function computeCheckRulesHash(input2) {
   const template = resolvePromptTemplatePath(input2.env ?? process.env);
   return computeRulesHash({
-    bundledRulePaths: [GITLEAKS_VENDORED_CONFIG, ...resolveResidueFingerprintFiles(input2.env ?? process.env)],
+    bundledRulePaths: [
+      GITLEAKS_VENDORED_CONFIG,
+      ...resolveResidueFingerprintFiles(input2.env ?? process.env),
+      ...resolveReleaseFingerprintFiles(input2.env ?? process.env)
+    ],
     configDigest: input2.configDigest,
     engineVersions: input2.engineVersions,
     promptTemplatePaths: existsSync7(template) ? [template] : []
@@ -39187,23 +39703,23 @@ function renderReportMd(report) {
 }
 
 // src/ledger/freshness.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, readdirSync as readdirSync4, rmSync as rmSync5 } from "node:fs";
-import { join as join11 } from "node:path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, readdirSync as readdirSync4, rmSync as rmSync5 } from "node:fs";
+import { join as join13 } from "node:path";
 
 // src/artifacts/rubygems.ts
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, readdirSync as readdirSync3, rmSync as rmSync4 } from "node:fs";
-import { join as join10, relative as relative3 } from "node:path";
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync7, readdirSync as readdirSync3, rmSync as rmSync4 } from "node:fs";
+import { join as join12, relative as relative3 } from "node:path";
+import { spawnSync as spawnSync6 } from "node:child_process";
 import { gunzipSync } from "node:zlib";
 
 // src/artifacts/residueGem.ts
-import { basename } from "node:path";
+import { basename as basename2 } from "node:path";
 var GEM_WORDING = { what: "gem install-time", ledger: "gem" };
 function gemPersistenceHit(rel, text) {
-  if (GEM_PERSISTENCE_BASENAMES.includes(basename(rel))) {
+  if (GEM_PERSISTENCE_BASENAMES.includes(basename2(rel))) {
     return {
       rule: RESIDUE_T4_RULE,
       severity: "CRITICAL",
@@ -39449,7 +39965,7 @@ function residueGemHits(pkgDir, rels, metadata) {
     const rel = normalizeRel(raw);
     const text = readText(pkgDir, rel);
     if (text === null) continue;
-    const base = basename(rel);
+    const base = basename2(rel);
     const isExtconf = base === GEM_EXTCONF_BASENAME;
     const persistence = gemPersistenceHit(rel, text);
     if (persistence !== null) hits.push(persistence);
@@ -39548,7 +40064,7 @@ function listFiles2(dir) {
   while (stack.length > 0) {
     const cur = stack.pop();
     for (const ent of readdirSync3(cur, { withFileTypes: true })) {
-      const p = join10(cur, ent.name);
+      const p = join12(cur, ent.name);
       if (ent.isDirectory()) stack.push(p);
       else if (ent.isFile()) out.push(p);
     }
@@ -39561,11 +40077,11 @@ function treeGemspecCandidates(repoDir) {
   while (stack.length > 0) {
     const cur = stack.pop();
     for (const ent of readdirSync3(cur, { withFileTypes: true })) {
-      const p = join10(cur, ent.name);
+      const p = join12(cur, ent.name);
       if (ent.isDirectory()) {
         if (!SKIP_DIRECTORIES2.has(ent.name)) stack.push(p);
       } else if (ent.isFile() && ent.name.toLowerCase().endsWith(".gemspec")) {
-        out.push({ path: relative3(repoDir, p), body: readFileSync6(p, "utf8") });
+        out.push({ path: relative3(repoDir, p), body: readFileSync7(p, "utf8") });
       }
     }
   }
@@ -39597,7 +40113,7 @@ async function runRubygemsArtifactStage(o) {
     throw e;
   }
   const gemName = `${identity.name}-${identity.version}.gem`;
-  const versionCheck = spawnSync5(bin, ["--version"], {
+  const versionCheck = spawnSync6(bin, ["--version"], {
     encoding: "utf8",
     stdio: "ignore",
     ...o.env === void 0 ? {} : { env: { ...o.env } }
@@ -39608,11 +40124,11 @@ async function runRubygemsArtifactStage(o) {
     );
   }
   ensureStateDir(repoDir);
-  const stateDir = join10(repoDir, BORDER_STATE_DIR);
-  const distDir = join10(stateDir, "dist");
+  const stateDir = join12(repoDir, BORDER_STATE_DIR);
+  const distDir = join12(stateDir, "dist");
   mkdirSync4(distDir, { recursive: true });
-  const dist = join10(distDir, gemName);
-  const result = spawnSync5(bin, ["build", candidates[0].path, "-o", dist], {
+  const dist = join12(distDir, gemName);
+  const result = spawnSync6(bin, ["build", candidates[0].path, "-o", dist], {
     cwd: repoDir,
     encoding: "utf8",
     timeout: o.gemTimeoutMs ?? 12e4,
@@ -39627,10 +40143,10 @@ async function runRubygemsArtifactStage(o) {
   if (!existsSync8(dist)) {
     throw new EngineRunError(`gem build produced no ${gemName} in ${relative3(repoDir, distDir)} \u2014 failing closed (was the gemspec's literal name/version re-read?)`, null);
   }
-  const bytes = readFileSync6(dist);
+  const bytes = readFileSync7(dist);
   const sha2563 = createHash6("sha256").update(bytes).digest("hex");
   const findings = [];
-  const extractDir = join10(stateDir, "tmp", sha2563.slice(0, 8));
+  const extractDir = join12(stateDir, "tmp", sha2563.slice(0, 8));
   rmSync4(extractDir, { recursive: true, force: true });
   mkdirSync4(extractDir, { recursive: true });
   const dataDir = `${extractDir}-data`;
@@ -39669,13 +40185,13 @@ async function runRubygemsArtifactStage(o) {
     if (members2.has("metadata.gz") && members2.has("data.tar.gz")) {
       let metadata;
       try {
-        metadata = gunzipSync(readFileSync6(join10(extractDir, "metadata.gz"))).toString("utf8");
+        metadata = gunzipSync(readFileSync7(join12(extractDir, "metadata.gz"))).toString("utf8");
       } catch {
         throw new EngineRunError(`${gemName}: metadata.gz is not gunzip-readable \u2014 the extensions declaration cannot be verified, failing closed`, null);
       }
       rmSync4(dataDir, { recursive: true, force: true });
       mkdirSync4(dataDir, { recursive: true });
-      extractArchive(join10(extractDir, "data.tar.gz"), dataDir, {
+      extractArchive(join12(extractDir, "data.tar.gz"), dataDir, {
         ...o.env !== void 0 ? { env: o.env } : {},
         ...o.timeoutMs !== void 0 ? { timeoutMs: o.timeoutMs } : {}
       });
@@ -39694,6 +40210,13 @@ async function runRubygemsArtifactStage(o) {
       })) {
         findings.push(f);
       }
+      findings.push(...gemCoherenceFindings({
+        specName: identity.name,
+        specVersion: identity.version,
+        metadataText: metadata,
+        identity: gemName,
+        ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {}
+      }));
     }
   } finally {
     removeSandbox(extractDir);
@@ -39710,15 +40233,15 @@ function artifactTargets() {
   return publishChannels().map((c) => c.id);
 }
 function sha256File(path4) {
-  return createHash7("sha256").update(readFileSync7(path4)).digest("hex");
+  return createHash7("sha256").update(readFileSync8(path4)).digest("hex");
 }
 var packSeq = 0;
 function packNpmArtifacts(repoDir, o = {}) {
   packSeq += 1;
-  const dest = join11(repoDir, BORDER_STATE_DIR, "tmp", `pack-${String(process.pid)}-${String(packSeq)}`);
+  const dest = join13(repoDir, BORDER_STATE_DIR, "tmp", `pack-${String(process.pid)}-${String(packSeq)}`);
   mkdirSync5(dest, { recursive: true });
   try {
-    const r = spawnSync6("npm", ["pack", "--ignore-scripts", "--silent", `--pack-destination=${dest}`], {
+    const r = spawnSync7("npm", ["pack", "--ignore-scripts", "--silent", `--pack-destination=${dest}`], {
       cwd: repoDir,
       encoding: "utf8",
       env: { ...o.env ?? process.env },
@@ -39727,27 +40250,27 @@ function packNpmArtifacts(repoDir, o = {}) {
     if (r.error !== void 0 || r.status !== 0) return null;
     const files = readdirSync4(dest).filter((f) => f.endsWith(".tgz")).sort();
     if (files.length === 0) return null;
-    return files.map((f) => ({ file: f, sha256: sha256File(join11(dest, f)) }));
+    return files.map((f) => ({ file: f, sha256: sha256File(join13(dest, f)) }));
   } finally {
     rmSync5(dest, { recursive: true, force: true });
   }
 }
 function packCrateArtifacts(repoDir, o = {}) {
   packSeq += 1;
-  const dest = join11(repoDir, BORDER_STATE_DIR, "tmp", `cargo-pack-${String(process.pid)}-${String(packSeq)}`);
+  const dest = join13(repoDir, BORDER_STATE_DIR, "tmp", `cargo-pack-${String(process.pid)}-${String(packSeq)}`);
   mkdirSync5(dest, { recursive: true });
   try {
-    const r = spawnSync6("cargo", ["package", "--allow-dirty", "--no-verify"], {
+    const r = spawnSync7("cargo", ["package", "--allow-dirty", "--no-verify"], {
       cwd: repoDir,
       encoding: "utf8",
       env: { ...o.env ?? process.env, CARGO_TARGET_DIR: dest },
       timeout: 12e4
     });
     if (r.error !== void 0 || r.status !== 0) return null;
-    const dir = join11(dest, "package");
+    const dir = join13(dest, "package");
     const files = readdirSync4(dir).filter((f) => f.endsWith(".crate")).sort();
     if (files.length === 0) return null;
-    return files.map((f) => ({ file: f, sha256: sha256File(join11(dir, f)) }));
+    return files.map((f) => ({ file: f, sha256: sha256File(join13(dir, f)) }));
   } finally {
     rmSync5(dest, { recursive: true, force: true });
   }
@@ -39756,11 +40279,11 @@ function packRubygemsArtifacts(repoDir, o = {}) {
   packSeq += 1;
   const ident = singleTreeGemspec(repoDir);
   if (ident === null) return null;
-  const dest = join11(repoDir, BORDER_STATE_DIR, "tmp", `gem-pack-${String(process.pid)}-${String(packSeq)}`);
+  const dest = join13(repoDir, BORDER_STATE_DIR, "tmp", `gem-pack-${String(process.pid)}-${String(packSeq)}`);
   mkdirSync5(dest, { recursive: true });
   try {
     const gemName = `${ident.name}-${ident.version}.gem`;
-    const r = spawnSync6("gem", ["build", ident.path, "-o", join11(dest, gemName)], {
+    const r = spawnSync7("gem", ["build", ident.path, "-o", join13(dest, gemName)], {
       cwd: repoDir,
       encoding: "utf8",
       env: { ...o.env ?? process.env },
@@ -39769,7 +40292,7 @@ function packRubygemsArtifacts(repoDir, o = {}) {
     if (r.error !== void 0 || r.status !== 0) return null;
     const files = readdirSync4(dest).filter((f) => f.endsWith(".gem")).sort();
     if (files.length === 0) return null;
-    return files.map((f) => ({ file: f, sha256: sha256File(join11(dest, f)) }));
+    return files.map((f) => ({ file: f, sha256: sha256File(join13(dest, f)) }));
   } finally {
     rmSync5(dest, { recursive: true, force: true });
   }
@@ -39812,231 +40335,56 @@ function verifyArtifactFreshness(record2, ctx, repoDir, o = {}) {
   );
 }
 
-// src/ledger/records.ts
-import { appendFileSync, readFileSync as readFileSync8 } from "node:fs";
-import { join as join12 } from "node:path";
-var LEDGER_FILE = "ledger.jsonl";
-var RUNS_SUBDIR = "runs";
-var HEX64 = /^[0-9a-f]{64}$/;
-var HEX40 = /^[0-9a-f]{40}$/;
-var HEX8 = /^[0-9a-f]{8}$/;
-var PUSH_CONFIRMED_VIA = ["ls-remote", "npm-view", "pypi-json", "crates-json", "rubygems-json"];
-function ledgerPath(repoDir) {
-  return join12(repoDir, BORDER_STATE_DIR, LEDGER_FILE);
-}
-function runsDir(repoDir) {
-  return join12(repoDir, BORDER_STATE_DIR, RUNS_SUBDIR);
-}
-function formatSkipLine(record2) {
-  return `SKIP ${record2.key8} \u2014 PASS ${record2.ts} report ${record2.reportPath}`;
-}
-function buildPushRecord(i) {
-  return {
-    t: "push",
-    key: i.key,
-    target: i.target,
-    remoteName: i.remoteName,
-    url: sanitizeUrl(i.url),
-    localSha: i.localSha,
-    ...i.remoteSha !== void 0 ? { remoteSha: i.remoteSha } : {},
-    ...i.version !== void 0 ? { version: i.version } : {},
-    confirmedVia: i.confirmedVia,
-    ts: i.ts ?? (/* @__PURE__ */ new Date()).toISOString()
-  };
+// src/ledger/retention.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync5, rmSync as rmSync6 } from "node:fs";
+import { join as join14 } from "node:path";
+var KEEP_RUN_DIRS_PER_KEY8 = 20;
+function codeOf3(err) {
+  return typeof err === "object" && err !== null ? err.code : void 0;
 }
-function bad(msg) {
-  throw new Error(msg);
+function runDirName(key8, ts) {
+  return `${key8}-${ts.replace(/[:.]/g, "-")}`;
 }
-function needString(o, field) {
-  const v = o[field];
-  if (typeof v !== "string" || v === "") bad(`${field} must be a non-empty string`);
-  return v;
+function uniqueRunDirName(repoDir, key8, ts) {
+  const base = runDirName(key8, ts);
+  let name = base;
+  for (let n = 2; existsSync9(join14(runsDir(repoDir), name)) && n < 1e3; n += 1) {
+    name = `${base}-r${String(n)}`;
+  }
+  return name;
 }
-function needHex(o, field, re) {
-  const v = needString(o, field);
-  if (!re.test(v)) bad(`${field} is not hex-shaped`);
-  return v;
+function ensureRunDir(repoDir, name) {
+  const dir = join14(runsDir(repoDir), name);
+  mkdirSync6(dir, { recursive: true });
+  return dir;
 }
-function needStringArray(o, field) {
-  const v = o[field];
-  if (!Array.isArray(v) || !v.every((x) => typeof x === "string")) bad(`${field} must be an array of strings`);
-  return v;
+function reportRelPath(name) {
+  return `${RUNS_SUBDIR}/${name}/report.json`;
 }
-function parseCounts(value) {
-  if (typeof value !== "object" || value === null) bad("counts must be an object");
-  const o = value;
-  for (const field of ["INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL", "total", "blocking", "warnings"]) {
-    if (typeof o[field] !== "number" || !Number.isInteger(o[field])) bad(`counts.${field} must be an integer`);
+function pruneRunDirs(repoDir, key8, keep = KEEP_RUN_DIRS_PER_KEY8) {
+  let entries;
+  try {
+    entries = readdirSync5(runsDir(repoDir));
+  } catch (err) {
+    if (codeOf3(err) === "ENOENT") return [];
+    throw err;
   }
-  return o;
+  const prefix = `${key8}-`;
+  const mine = entries.filter((e) => e.startsWith(prefix)).sort();
+  const doomed = mine.slice(0, Math.max(0, mine.length - keep));
+  for (const dir of doomed) {
+    rmSync6(join14(runsDir(repoDir), dir), { recursive: true, force: true });
+  }
+  return doomed;
 }
-function parseArtifacts(o) {
-  if (o.artifacts === null) return null;
-  const v = o.artifacts;
-  if (!Array.isArray(v)) bad("artifacts must be null or an array");
-  return v.map((item, i) => {
-    if (typeof item !== "object" || item === null) bad(`artifacts[${String(i)}] must be an object`);
-    const a = item;
-    return { file: needString(a, "file"), sha256: needHex(a, "sha256", HEX64) };
-  });
-}
-function parseLedgerRecord(value) {
-  if (typeof value !== "object" || value === null) bad("record must be an object");
-  const o = value;
-  const t = o.t;
-  if (t === "check") {
-    const key = needHex(o, "key", HEX64);
-    const key8 = needHex(o, "key8", HEX8);
-    if (key.slice(0, 8) !== key8) bad("key8 must be the first 8 hex chars of key");
-    const verdict = needString(o, "verdict");
-    if (verdict !== "PASS" && verdict !== "FAIL") bad(`verdict must be PASS or FAIL, got '${verdict}'`);
-    if (o.degraded !== false) bad("degraded must be false \u2014 degraded runs are never ledgered");
-    if (typeof o.llm !== "boolean") bad("llm must be a boolean");
-    return {
-      t: "check",
-      key,
-      key8,
-      head: needHex(o, "head", HEX40),
-      dirtyDigest: needHex(o, "dirtyDigest", HEX64),
-      refSetHash: needHex(o, "refSetHash", HEX64),
-      exposureSet: needStringArray(o, "exposureSet"),
-      effectiveTargets: needStringArray(o, "effectiveTargets"),
-      rulesHash: needHex(o, "rulesHash", HEX64),
-      artifacts: parseArtifacts(o),
-      llm: o.llm,
-      verdict,
-      counts: parseCounts(o.counts),
-      reportPath: needString(o, "reportPath"),
-      degraded: false,
-      ts: needString(o, "ts")
-    };
-  }
-  if (t === "push") {
-    const confirmedVia = needString(o, "confirmedVia");
-    if (!PUSH_CONFIRMED_VIA.includes(confirmedVia)) {
-      bad(`confirmedVia must be one of ${PUSH_CONFIRMED_VIA.join("|")}`);
-    }
-    const remoteSha = o.remoteSha;
-    const version2 = o.version;
-    if (remoteSha === void 0 && version2 === void 0) bad("push record needs remoteSha or version");
-    if (remoteSha !== void 0 && typeof remoteSha !== "string") bad("remoteSha must be a string");
-    if (version2 !== void 0 && typeof version2 !== "string") bad("version must be a string");
-    return {
-      t: "push",
-      key: needHex(o, "key", HEX64),
-      target: needString(o, "target"),
-      remoteName: needString(o, "remoteName"),
-      url: needString(o, "url"),
-      localSha: needString(o, "localSha"),
-      ...remoteSha !== void 0 ? { remoteSha } : {},
-      ...version2 !== void 0 ? { version: version2 } : {},
-      confirmedVia,
-      ts: needString(o, "ts")
-    };
-  }
-  return bad(`unknown record type ${JSON.stringify(t)}`);
-}
-function codeOf2(err) {
-  return typeof err === "object" && err !== null ? err.code : void 0;
-}
-function readLedger(repoDir) {
-  let text;
-  try {
-    text = readFileSync8(ledgerPath(repoDir), "utf8");
-  } catch (err) {
-    if (codeOf2(err) === "ENOENT") return { records: [], warnings: [] };
-    throw err;
-  }
-  const records = [];
-  const warnings = [];
-  text.split("\n").forEach((line, i) => {
-    if (line.trim() === "") return;
-    try {
-      records.push(parseLedgerRecord(JSON.parse(line)));
-    } catch (err) {
-      const reason = err instanceof Error ? err.message : String(err);
-      warnings.push(`ledger line ${String(i + 1)} unreadable (${reason.slice(0, 160)}) \u2014 line skipped`);
-    }
-  });
-  return { records, warnings };
-}
-function appendRecord(repoDir, record2) {
-  ensureStateDir(repoDir);
-  appendFileSync(ledgerPath(repoDir), `${JSON.stringify(record2)}
-`, "utf8");
-}
-function newestRecordOf(records, key) {
-  for (let i = records.length - 1; i >= 0; i -= 1) {
-    const r = records[i];
-    if (r.t === "check" && r.key === key) return r;
-  }
-  return null;
-}
-function isSkippable(r) {
-  return r !== null && r.verdict === "PASS" && r.degraded === false;
-}
-function lookupSkipRecord(records, key, llm) {
-  const newest = newestRecordOf(records, key);
-  return isSkippable(newest) && newest.llm === llm ? newest : null;
-}
-function latestPassCoveringTargets(records, key, targets) {
-  const newest = newestRecordOf(records, key);
-  return isSkippable(newest) && targets.every((t) => newest.effectiveTargets.includes(t)) ? newest : null;
-}
-function pushRecords(records, key) {
-  return records.filter((r) => r.t === "push" && (key === void 0 || r.key === key));
-}
-
-// src/ledger/retention.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync5, rmSync as rmSync6 } from "node:fs";
-import { join as join13 } from "node:path";
-var KEEP_RUN_DIRS_PER_KEY8 = 20;
-function codeOf3(err) {
-  return typeof err === "object" && err !== null ? err.code : void 0;
-}
-function runDirName(key8, ts) {
-  return `${key8}-${ts.replace(/[:.]/g, "-")}`;
-}
-function uniqueRunDirName(repoDir, key8, ts) {
-  const base = runDirName(key8, ts);
-  let name = base;
-  for (let n = 2; existsSync9(join13(runsDir(repoDir), name)) && n < 1e3; n += 1) {
-    name = `${base}-r${String(n)}`;
-  }
-  return name;
-}
-function ensureRunDir(repoDir, name) {
-  const dir = join13(runsDir(repoDir), name);
-  mkdirSync6(dir, { recursive: true });
-  return dir;
-}
-function reportRelPath(name) {
-  return `${RUNS_SUBDIR}/${name}/report.json`;
-}
-function pruneRunDirs(repoDir, key8, keep = KEEP_RUN_DIRS_PER_KEY8) {
-  let entries;
-  try {
-    entries = readdirSync5(runsDir(repoDir));
-  } catch (err) {
-    if (codeOf3(err) === "ENOENT") return [];
-    throw err;
-  }
-  const prefix = `${key8}-`;
-  const mine = entries.filter((e) => e.startsWith(prefix)).sort();
-  const doomed = mine.slice(0, Math.max(0, mine.length - keep));
-  for (const dir of doomed) {
-    rmSync6(join13(runsDir(repoDir), dir), { recursive: true, force: true });
-  }
-  return doomed;
-}
-
-// src/ledger.ts
-async function computeFingerprint(repoDir, cfg, configDigest, effectiveTargets, o = {}) {
-  const envOpt = o.env !== void 0 ? { env: o.env } : {};
-  const ctx = await gatherContext(repoDir, envOpt);
-  const probe = await probeEngines(cfg, {
-    ...envOpt,
-    ...o.requireOverride !== void 0 ? { requireOverride: o.requireOverride } : {}
+
+// src/ledger.ts
+async function computeFingerprint(repoDir, cfg, configDigest, effectiveTargets, o = {}) {
+  const envOpt = o.env !== void 0 ? { env: o.env } : {};
+  const ctx = await gatherContext(repoDir, envOpt);
+  const probe = await probeEngines(cfg, {
+    ...envOpt,
+    ...o.requireOverride !== void 0 ? { requireOverride: o.requireOverride } : {}
   });
   const rulesHash = await computeCheckRulesHash({
     engineVersions: probe.engineVersions,
@@ -40091,9 +40439,9 @@ function recordCheckRun(i) {
   const envOpt = i.env !== void 0 ? { env: i.env } : {};
   const artifacts = i.artifacts ?? (i.report.verdict === "PASS" && !i.ctx.dirty && i.effectiveTargets.includes("npm") ? packNpmArtifacts(i.repoDir, envOpt) : null);
   const persisted = artifacts !== null ? { ...i.report, artifacts } : i.report;
-  writeFileSync3(join14(i.repoDir, BORDER_STATE_DIR, relReport), `${JSON.stringify(persisted, null, 2)}
+  writeFileSync3(join15(i.repoDir, BORDER_STATE_DIR, relReport), `${JSON.stringify(persisted, null, 2)}
 `, "utf8");
-  writeFileSync3(join14(i.repoDir, BORDER_STATE_DIR, relReport.replace("report.json", "report.md")), renderReportMd(i.report), "utf8");
+  writeFileSync3(join15(i.repoDir, BORDER_STATE_DIR, relReport.replace("report.json", "report.md")), renderReportMd(i.report), "utf8");
   const record2 = {
     t: "check",
     key: i.report.key,
@@ -40118,13 +40466,13 @@ function recordCheckRun(i) {
 }
 
 // src/channels/pypi.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 import { relative as relative5 } from "node:path";
 
 // src/artifacts/pypi.ts
 import { createHash as createHash9 } from "node:crypto";
 import { existsSync as existsSync10, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, readFileSync as readFileSync9, readdirSync as readdirSync6, rmdirSync as rmdirSync2, rmSync as rmSync7 } from "node:fs";
-import { basename as basename2, dirname as dirname7, join as join15, relative as relative4, resolve as resolve7 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join16, relative as relative4, resolve as resolve7 } from "node:path";
 
 // src/artifacts/residuePy.ts
 function residuePypiHits(pkgDir, innerRels) {
@@ -40188,13 +40536,13 @@ function requireModule(o, module) {
 function buildPypiArtifacts(o) {
   requireModule(o, "build");
   const repoDir = resolve7(o.repoDir);
-  if (!existsSync10(join15(repoDir, "pyproject.toml"))) {
+  if (!existsSync10(join16(repoDir, "pyproject.toml"))) {
     throw new PypiPrerequisiteError(`no pyproject.toml in the repo root \u2014 the PyPI pipeline builds from pyproject's own [build-system]`);
   }
-  const distDir = join15(resolve7(o.stateDir ?? join15(repoDir, ".border")), "dist");
+  const distDir = join16(resolve7(o.stateDir ?? join16(repoDir, ".border")), "dist");
   mkdirSync7(distDir, { recursive: true });
   for (const name of readdirSync6(distDir)) {
-    if (name.endsWith(".tar.gz") || name.endsWith(".whl")) rmSync7(join15(distDir, name), { force: true });
+    if (name.endsWith(".tar.gz") || name.endsWith(".whl")) rmSync7(join16(distDir, name), { force: true });
   }
   const out = spawnEngine(binaryCandidates("python3", o), ["-m", "build", "--no-isolation", "--outdir", distDir, repoDir], o);
   if (out.status !== 0) {
@@ -40205,13 +40553,13 @@ function buildPypiArtifacts(o) {
     throw new EngineRunError(`\`python3 -m build\` produced no .tar.gz/.whl in ${distDir} (border exit 2)`, null);
   }
   const artifacts = names.map((name) => {
-    const path4 = join15(distDir, name);
+    const path4 = join16(distDir, name);
     return { path: path4, kind: name.endsWith(".whl") ? "wheel" : "sdist", sha256: createHash9("sha256").update(readFileSync9(path4)).digest("hex") };
   });
   return { artifacts, distDir };
 }
 function walkFilesRel(root) {
-  return readdirSync6(root, { withFileTypes: true }).flatMap((e) => e.isDirectory() ? walkFilesRel(join15(root, e.name)).map((r) => `${e.name}/${r}`) : e.isFile() ? [e.name] : []);
+  return readdirSync6(root, { withFileTypes: true }).flatMap((e) => e.isDirectory() ? walkFilesRel(join16(root, e.name)).map((r) => `${e.name}/${r}`) : e.isFile() ? [e.name] : []);
 }
 function stripWrapper(entries) {
   const tops = new Set(entries.map((e) => e.includes("/") ? e.slice(0, e.indexOf("/")) : "\0"));
@@ -40224,7 +40572,7 @@ function toInner(findingPath, scanRoot) {
   const head = bang === -1 ? findingPath : findingPath.slice(0, bang);
   const rest = bang === -1 ? "" : findingPath.slice(bang + 1);
   const rel = relative4(scanRoot, head);
-  const inner = rel !== "" && !rel.startsWith("..") ? rel : basename2(head);
+  const inner = rel !== "" && !rel.startsWith("..") ? rel : basename3(head);
   return rest === "" ? inner : `${inner}!${rest}`;
 }
 function gitTracked(o, repoDir) {
@@ -40241,7 +40589,7 @@ function toRe(globs) {
 function explainMatchers(repoDir) {
   const inc = [];
   const exc = [];
-  const manifest = join15(repoDir, "MANIFEST.in");
+  const manifest = join16(repoDir, "MANIFEST.in");
   if (existsSync10(manifest)) {
     for (const line of readFileSync9(manifest, "utf8").split(/\r?\n/)) {
       const t = line.split("#")[0]?.trim() ?? "";
@@ -40256,7 +40604,7 @@ function explainMatchers(repoDir) {
       else if (cmd === "prune") exc.push(`${dir}/**`);
     }
   }
-  const pyproject = join15(repoDir, "pyproject.toml");
+  const pyproject = join16(repoDir, "pyproject.toml");
   if (existsSync10(pyproject)) {
     const text = readFileSync9(pyproject, "utf8");
     const readme = /^\s*readme\s*=\s*"([^"]+)"/m.exec(text);
@@ -40308,7 +40656,7 @@ ${out.stderr}`.replace(ANSI_RE, "");
   }
   return failed.map((m) => {
     const abs = m[1] ?? "";
-    const base = basename2(abs);
+    const base = basename3(abs);
     const idx = text.indexOf(m[0]);
     const next = text.indexOf("Checking ", idx + m[0].length);
     const block = tail2(text.slice(idx, next === -1 ? void 0 : next), 400).replaceAll(abs, base);
@@ -40329,10 +40677,10 @@ async function scanPyPiArtifacts(o) {
   requireModule(o, "build");
   requireModule(o, "twine");
   const repoDir = resolve7(o.repoDir);
-  const stateDir = resolve7(o.stateDir ?? join15(repoDir, ".border"));
+  const stateDir = resolve7(o.stateDir ?? join16(repoDir, ".border"));
   const target = o.target ?? "artifact";
   const { artifacts } = buildPypiArtifacts(o);
-  const tmpParent = join15(stateDir, "tmp");
+  const tmpParent = join16(stateDir, "tmp");
   mkdirSync7(tmpParent, { recursive: true });
   const merged = /* @__PURE__ */ new Map();
   const absorb = (f, path4) => {
@@ -40341,16 +40689,16 @@ async function scanPyPiArtifacts(o) {
   };
   try {
     for (const artifact of artifacts) {
-      const sandbox = mkdtempSync2(join15(tmpParent, "pypi-"));
+      const sandbox = mkdtempSync2(join16(tmpParent, "pypi-"));
       try {
         if (artifact.kind === "wheel") {
           const z2 = spawnEngine(binaryCandidates("python3", o), ["-m", "zipfile", "-e", artifact.path, sandbox], o);
-          if (z2.status !== 0) throw new EngineRunError(`\`python3 -m zipfile -e ${basename2(artifact.path)}\` exited ${String(z2.status)} (border exit 2): ${tail2(z2.stderr)}`, z2.status);
+          if (z2.status !== 0) throw new EngineRunError(`\`python3 -m zipfile -e ${basename3(artifact.path)}\` exited ${String(z2.status)} (border exit 2): ${tail2(z2.stderr)}`, z2.status);
         } else {
           extractArchive(artifact.path, sandbox, o);
         }
         const { root, rest } = artifact.kind === "sdist" ? stripWrapper(walkFilesRel(sandbox)) : { root: "", rest: walkFilesRel(sandbox) };
-        const scanRoot = join15(sandbox, root);
+        const scanRoot = join16(sandbox, root);
         const scanOpts = { ...o, target };
         if (o.skipGitleaks !== true) {
           for (const f of scanTree({ ...scanOpts, dir: scanRoot, stateDir })) absorb(f, toInner(f.path, scanRoot));
@@ -40359,9 +40707,23 @@ async function scanPyPiArtifacts(o) {
           for (const f of await scanPaths({ ...scanOpts, ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {}, ...o.rules !== void 0 ? { rules: o.rules } : {}, dir: scanRoot, files: rest })) absorb(f, f.path ?? "");
         }
         for (const f of residueFindings(residuePypiHits(scanRoot, rest), {
-          root: basename2(artifact.path),
+          root: basename3(artifact.path),
           sep: "!",
-          identity: basename2(artifact.path),
+          identity: basename3(artifact.path),
+          ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {}
+        })) absorb(f, f.path ?? "");
+        for (const f of pypiArtifactCoherenceFindings({
+          kind: artifact.kind,
+          archiveName: basename3(artifact.path),
+          files: rest,
+          read: (rel) => {
+            try {
+              return readFileSync9(join16(scanRoot, rel), "utf8");
+            } catch {
+              return null;
+            }
+          },
+          identity: basename3(artifact.path),
           ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {}
         })) absorb(f, f.path ?? "");
         if (artifact.kind === "sdist") for (const f of manifestFindings(o, rest, target)) absorb(f, f.path ?? "");
@@ -40383,7 +40745,7 @@ async function scanPyPiArtifacts(o) {
 import { spawn } from "node:child_process";
 import { createHash as createHash10 } from "node:crypto";
 import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
-import { basename as basename3, join as join16 } from "node:path";
+import { basename as basename4, join as join17 } from "node:path";
 
 // src/cli/exit.ts
 var EXIT_PASS = 0;
@@ -40424,7 +40786,7 @@ function translateError(err) {
 
 // src/push/core.ts
 var PUBLISH_WARNING = "WARNING: published versions cannot be re-uploaded unchanged; deletion windows differ per registry \u2014 verify version bump policy";
-var DIST_DIR = join16(BORDER_STATE_DIR, "dist");
+var DIST_DIR = join17(BORDER_STATE_DIR, "dist");
 var defaultOut = (line) => void process.stdout.write(`${line}
 `);
 var defaultErr = (line) => void process.stderr.write(`${line}
@@ -40453,8 +40815,8 @@ function rehashRecordedArtifacts(kind, extensions, record2, repoDir) {
   }
   const files = [];
   for (const a of entries) {
-    const rel = join16(DIST_DIR, basename3(a.file));
-    const abs = join16(repoDir, rel);
+    const rel = join17(DIST_DIR, basename4(a.file));
+    const abs = join17(repoDir, rel);
     if (!existsSync11(abs)) return fail3(`${rel} is missing from the working tree`);
     const digest2 = createHash10("sha256").update(readFileSync10(abs)).digest("hex");
     if (digest2 !== a.sha256) return fail3(`${rel} no longer hashes to the digest recorded by the check`);
@@ -40630,7 +40992,7 @@ function twineAvailable(i, command) {
   let status = null;
   let failed = false;
   try {
-    const res = spawnSync7(command.bin, args, {
+    const res = spawnSync8(command.bin, args, {
       encoding: "utf8",
       stdio: "ignore",
       ...i.env === void 0 ? {} : { env: { ...i.env } }
@@ -40945,7 +41307,7 @@ function npmNameClaimed(o) {
   return true;
 }
 function npmViewJson(args, registry2, timeoutMs, env2) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const child = spawn2("npm", ["view", ...args, "--registry", registry2, "--fetch-retries=0", "--json"], {
       stdio: ["ignore", "pipe", "pipe"],
       ...env2 === void 0 ? {} : { env: env2 }
@@ -40964,7 +41326,7 @@ function npmViewJson(args, registry2, timeoutMs, env2) {
     });
     child.on("close", (status) => {
       clearTimeout(timer);
-      resolve15({ status: status ?? -1, stdout, stderr });
+      resolve16({ status: status ?? -1, stdout, stderr });
     });
   });
 }
@@ -41060,14 +41422,14 @@ var npmChannel = {
 // src/channels/crates.ts
 import { createHash as createHash12 } from "node:crypto";
 import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync12, readdirSync as readdirSync8, rmSync as rmSync9 } from "node:fs";
-import { join as join18, resolve as resolve8 } from "node:path";
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { join as join19, resolve as resolve8 } from "node:path";
+import { spawnSync as spawnSync10 } from "node:child_process";
 
 // src/artifacts/crates.ts
 import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync11, readdirSync as readdirSync7, renameSync, rmSync as rmSync8 } from "node:fs";
 import { createHash as createHash11 } from "node:crypto";
-import { join as join17, relative as relative6 } from "node:path";
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { join as join18, relative as relative6 } from "node:path";
+import { spawnSync as spawnSync9 } from "node:child_process";
 
 // src/artifacts/residueRust.ts
 function residueCratesHits(pkgDir, innerRels) {
@@ -41266,7 +41628,7 @@ function listFiles3(dir) {
   while (stack.length > 0) {
     const cur = stack.pop();
     for (const ent of readdirSync7(cur, { withFileTypes: true })) {
-      const p = join17(cur, ent.name);
+      const p = join18(cur, ent.name);
       if (ent.isDirectory()) stack.push(p);
       else if (ent.isFile()) out.push(p);
     }
@@ -41274,7 +41636,7 @@ function listFiles3(dir) {
   return out;
 }
 function manifestIdentity(repoDir, cfg) {
-  const manifestPath = join17(repoDir, "Cargo.toml");
+  const manifestPath = join18(repoDir, "Cargo.toml");
   if (!existsSync12(manifestPath)) {
     throw new EngineRunError("targets.crates is configured but the repo has no Cargo.toml to package", null);
   }
@@ -41302,7 +41664,7 @@ async function runCargoArtifactStage(o) {
   const bin = o.cargoBinPath ?? "cargo";
   const identity = manifestIdentity(repoDir, o.cfg);
   const crateName = `${identity.name}-${identity.version}.crate`;
-  const versionCheck = spawnSync8(bin, ["--version"], {
+  const versionCheck = spawnSync9(bin, ["--version"], {
     encoding: "utf8",
     stdio: "ignore",
     ...o.env === void 0 ? {} : { env: { ...o.env } }
@@ -41313,14 +41675,14 @@ async function runCargoArtifactStage(o) {
     );
   }
   ensureStateDir(repoDir);
-  const stateDir = join17(repoDir, BORDER_STATE_DIR);
-  const distDir = join17(stateDir, "dist");
-  const targetDir = join17(stateDir, "tmp", "cargo-target");
+  const stateDir = join18(repoDir, BORDER_STATE_DIR);
+  const distDir = join18(stateDir, "dist");
+  const targetDir = join18(stateDir, "tmp", "cargo-target");
   mkdirSync8(distDir, { recursive: true });
   rmSync8(targetDir, { recursive: true, force: true });
   mkdirSync8(targetDir, { recursive: true });
   try {
-    const result = spawnSync8(bin, ["package", "--allow-dirty", "--no-verify"], {
+    const result = spawnSync9(bin, ["package", "--allow-dirty", "--no-verify"], {
       cwd: repoDir,
       encoding: "utf8",
       timeout: o.cargoTimeoutMs ?? 12e4,
@@ -41335,17 +41697,17 @@ async function runCargoArtifactStage(o) {
         result.status
       );
     }
-    const packedDir = join17(targetDir, "package");
-    const packed = join17(packedDir, crateName);
+    const packedDir = join18(targetDir, "package");
+    const packed = join18(packedDir, crateName);
     if (!existsSync12(packed)) {
       throw new EngineRunError(`cargo package produced no ${crateName} in ${relative6(repoDir, packedDir)} \u2014 failing closed`, null);
     }
-    const dist = join17(distDir, crateName);
+    const dist = join18(distDir, crateName);
     renameSync(packed, dist);
     const bytes = readFileSync11(dist);
     const sha2563 = createHash11("sha256").update(bytes).digest("hex");
     const findings = [];
-    const extractDir = join17(stateDir, "tmp", sha2563.slice(0, 8));
+    const extractDir = join18(stateDir, "tmp", sha2563.slice(0, 8));
     rmSync8(extractDir, { recursive: true, force: true });
     mkdirSync8(extractDir, { recursive: true });
     try {
@@ -41384,6 +41746,15 @@ async function runCargoArtifactStage(o) {
         identity: crateName,
         ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {}
       }));
+      const lockRel = `${identity.name}-${identity.version}/Cargo.lock`;
+      findings.push(...cratesCoherenceFindings({
+        name: identity.name,
+        version: identity.version,
+        lockText: relPaths.includes(lockRel) ? readFileSync11(join18(extractDir, lockRel), "utf8") : null,
+        lockRelPath: lockRel,
+        identity: crateName,
+        ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {}
+      }));
     } finally {
       removeSandbox(extractDir);
     }
@@ -41539,11 +41910,11 @@ function cratesPublishArgv(files, _cfg) {
   return files.map(() => ["publish", "--allow-dirty", "--no-verify"]);
 }
 function repackageSameBytes(i, bin) {
-  const targetDir = join18(resolve8(i.repoDir), BORDER_STATE_DIR, "tmp", "publish-repackage");
+  const targetDir = join19(resolve8(i.repoDir), BORDER_STATE_DIR, "tmp", "publish-repackage");
   rmSync9(targetDir, { recursive: true, force: true });
   mkdirSync9(targetDir, { recursive: true });
   try {
-    const r = spawnSync9(bin, ["package", "--allow-dirty", "--no-verify"], {
+    const r = spawnSync10(bin, ["package", "--allow-dirty", "--no-verify"], {
       cwd: i.repoDir,
       encoding: "utf8",
       timeout: 12e4,
@@ -41555,14 +41926,14 @@ function repackageSameBytes(i, bin) {
     if (r.status !== 0) {
       return { ok: false, message: `cargo package --allow-dirty --no-verify (pre-publish repackage) exited ${String(r.status)} \u2014 no retry loop, push blocked (fail-closed): ${(r.stderr ?? "").trim().slice(0, 300)}`, exit: EXIT_ERROR };
     }
-    const packedDir = join18(targetDir, "package");
+    const packedDir = join19(targetDir, "package");
     const crates = readdirSync8(packedDir).filter((f) => f.endsWith(".crate")).sort();
     if (crates.length !== 1) {
       return { ok: false, message: `pre-publish repackage produced ${String(crates.length)} .crate file(s) \u2014 expected exactly 1, push blocked (fail-closed)`, exit: EXIT_ERROR };
     }
     const crateFile = crates[0] ?? "";
-    const freshSha = createHash12("sha256").update(readFileSync12(join18(packedDir, crateFile))).digest("hex");
-    const staged = join18(resolve8(i.repoDir), BORDER_STATE_DIR, "dist", crateFile);
+    const freshSha = createHash12("sha256").update(readFileSync12(join19(packedDir, crateFile))).digest("hex");
+    const staged = join19(resolve8(i.repoDir), BORDER_STATE_DIR, "dist", crateFile);
     if (!existsSync13(staged)) {
       return { ok: false, message: `${crateFile} is missing from .border/dist \u2014 the PASSED check recorded no such crate; re-run border check (push blocked)`, exit: EXIT_ERROR };
     }
@@ -41955,8 +42326,32 @@ function buildBorderConfigSchema() {
     // of the residue scan is this toggle; a scan that cannot RUN is a FAIL
     // (fail-closed doctrine), and the digest seam keeps every cached PASS
     // honest about the residue sources it was certified against.
+    // W2.2 (border-inspect-roadmap): requireProof arms the PROOF VALVE — a
+    // blocking residue-* row on a staged artifact then additionally demands a
+    // fresh `t:"roundtrip"` ledger record for that artifact's sha256 before
+    // the channel may PASS. Default FALSE (0.3.x behavior byte-identical);
+    // the valve reads `residue?.requireProof === true`, so absence IS the
+    // false default — same construction contract as the outer key. The flag
+    // rides the whole-object configDigest (stableStringify), so flipping it
+    // rotates the check rulesHash and the ledger refuses every cached PASS.
     residue: external_exports.object({
-      enabled: external_exports.boolean().default(true)
+      enabled: external_exports.boolean().default(true),
+      requireProof: external_exports.boolean().default(false)
+    }).strict().optional(),
+    // W4.1 release-coherence twin obligations (plan border-inspect-roadmap §127-138):
+    // the ONLY cross-manager declaration border can statically enforce — when a project
+    // ships a PyPI/npm twin pair under one release train, their versions must be equal.
+    // The per-artifact internal coherence rules (release-coherence-*) are ALWAYS on and
+    // need no opt-in; this list is opt-in and strict — unknown keys fail typed exit 2.
+    // The pair list rides the whole-object configDigest, so editing it rotates the check
+    // rulesHash exactly like the residue block above.
+    release: external_exports.object({
+      twin: external_exports.array(
+        external_exports.object({
+          pypi: external_exports.string().min(1),
+          npm: external_exports.string().min(1)
+        }).strict()
+      ).default([])
     }).strict().optional()
   }).strict();
 }
@@ -42044,7 +42439,7 @@ function deepMergeRaw(base, overlay) {
   return overlay;
 }
 function runGit3(cwd, args) {
-  const r = spawnSync10("git", args, { cwd, encoding: "utf8" });
+  const r = spawnSync11("git", args, { cwd, encoding: "utf8" });
   return { ok: r.status === 0, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
 }
 function gitToplevel(cwd) {
@@ -42104,7 +42499,7 @@ function loadConfig(options = {}) {
       throw new ConfigError("unreadable", `config file not found: ${basePath}`);
     }
   } else {
-    for (const candidate of [join19(cwd, "border.yaml"), toplevel === void 0 ? "" : join19(toplevel, "border.yaml")]) {
+    for (const candidate of [join20(cwd, "border.yaml"), toplevel === void 0 ? "" : join20(toplevel, "border.yaml")]) {
       if (candidate !== "" && existsSync14(candidate)) {
         basePath = candidate;
         baseText = readFileSync13(candidate, "utf8");
@@ -42119,7 +42514,7 @@ function loadConfig(options = {}) {
   ])];
   let overlay;
   for (const dir of overlayDirs) {
-    const p = join19(dir, ".border", "config.local.yaml");
+    const p = join20(dir, ".border", "config.local.yaml");
     const text = readFileOrUndefined(p);
     if (text !== void 0) {
       overlay = { path: p, doc: yamlToJson(text, p) };
@@ -42164,10 +42559,10 @@ function exposureSet(cfg, options = {}) {
 }
 
 // src/check.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 
 // src/rules/aiArtifacts.ts
-import { spawnSync as spawnSync11 } from "node:child_process";
+import { spawnSync as spawnSync12 } from "node:child_process";
 import { dirname as dirname9, resolve as resolve10 } from "node:path";
 var AI_ARTIFACTS_ENGINE = "ai-artifacts";
 var BINARY_SNIFF_BYTES = 8e3;
@@ -42186,7 +42581,7 @@ function makeCtx(o) {
   return { repoDir, env: env2, timeoutMs: o.timeoutMs ?? 3e5, maxBufferBytes: o.maxBufferBytes ?? 32 * 1024 * 1024 };
 }
 function gitSpawn2(c, args, input2) {
-  const r = spawnSync11("git", ["-C", c.repoDir, ...args], {
+  const r = spawnSync12("git", ["-C", c.repoDir, ...args], {
     encoding: "buffer",
     timeout: c.timeoutMs,
     maxBuffer: c.maxBufferBytes,
@@ -42407,11 +42802,49 @@ function applyAllowList(findings, allow, repoDir) {
   return { kept, allowHits: [...hits.values()] };
 }
 
+// src/check/proofValve.ts
+var ROUNDTRIP_PROOF_MISSING_RULE = "roundtrip-proof-missing";
+var ROUNDTRIP_PROOF_STALE_RULE = "roundtrip-proof-stale";
+var RESIDUE_RULE_IDS = new Set(Object.keys(RESIDUE_SEVERITIES));
+function hasBlockingResidueCapability(findings) {
+  return findings.some((f) => RESIDUE_RULE_IDS.has(f.rule) && isBlocking(f.severity));
+}
+function proofFinding(rule, art, cause) {
+  return {
+    rule,
+    severity: "CRITICAL",
+    target: "artifact",
+    path: art.file,
+    engine: "native",
+    message: `${art.file} (sha256 ${art.sha256.slice(0, 12)}\u2026) tripped the residue scan while residue.requireProof is on, but ${cause}. Run 'border roundtrip <spec>' for exactly these bytes to mint the ledger proof.`,
+    ...redact(`${art.sha256}:${cause}`),
+    snippet: `${art.file} ${art.sha256.slice(0, 12)}`
+  };
+}
+function proofFindings(o) {
+  const out = [];
+  for (const art of o.artifacts) {
+    const rec = latestRoundtripForSha(o.records, art.sha256);
+    if (rec === null) {
+      out.push(proofFinding(ROUNDTRIP_PROOF_MISSING_RULE, art, "no roundtrip proof record exists for its digest"));
+    } else if (rec.rulesHash !== o.rulesHash) {
+      out.push(
+        proofFinding(
+          ROUNDTRIP_PROOF_STALE_RULE,
+          art,
+          `its proof record predates the current rules policy (recorded ${rec.rulesHash.slice(0, 12)}\u2026, required ${o.rulesHash.slice(0, 12)}\u2026)`
+        )
+      );
+    }
+  }
+  return out;
+}
+
 // src/check/tagScan.ts
-import { spawnSync as spawnSync12 } from "node:child_process";
+import { spawnSync as spawnSync13 } from "node:child_process";
 import { mkdtempSync as mkdtempSync3, rmSync as rmSync10, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join20, resolve as resolve12 } from "node:path";
+import { join as join21, resolve as resolve12 } from "node:path";
 var TAG_MESSAGE_RULE = "tag-message-secret";
 function isEnoent2(error61) {
   return typeof error61 === "object" && error61 !== null && error61.code === "ENOENT";
@@ -42431,7 +42864,7 @@ function stdinFindings(text, ignorePath, o) {
   ];
   let lastError;
   for (const bin of binaryCandidates("gitleaks", o)) {
-    const r = spawnSync12(bin, args, {
+    const r = spawnSync13(bin, args, {
       encoding: "utf8",
       input: text,
       timeout: o.timeoutMs ?? 3e5,
@@ -42502,8 +42935,8 @@ function scanTagMessages(o) {
   const gitOpts = { ...o.env !== void 0 ? { env: o.env } : {} };
   const refs = runGitChecked(repoDir, ["for-each-ref", "--format=%(refname)", "refs/tags"], gitOpts).split("\n").filter((ref) => ref !== "");
   if (refs.length === 0) return [];
-  const ignoreDir = mkdtempSync3(join20(tmpdir2(), "border-gitleaks-ignore-"));
-  const ignorePath = join20(ignoreDir, ".gitleaksignore");
+  const ignoreDir = mkdtempSync3(join21(tmpdir2(), "border-gitleaks-ignore-"));
+  const ignorePath = join21(ignoreDir, ".gitleaksignore");
   writeFileSync4(ignorePath, "");
   try {
     const findings = [];
@@ -42523,7 +42956,6 @@ function scanTagMessages(o) {
 
 // src/check.ts
 var TRACKED_BORDER_RULE = "repo-tracks-border-state";
-var RESIDUE_RULE_IDS = new Set(Object.keys(RESIDUE_SEVERITIES));
 var GUARD_PATH_CAP = 50;
 function trackedBorderStateFinding(repoDir, headSha, env2) {
   const listing = runGitChecked(repoDir, ["ls-files", "--", `${BORDER_STATE_DIR}/`], { ...env2 !== void 0 ? { env: env2 } : {} }).split("\n").filter((p) => p !== "");
@@ -42580,7 +43012,7 @@ async function runPipeline(o, ctx, lockWarning) {
   if (!broken.has("gitleaks")) {
     const eng = legOptions(o, sanitizer);
     findings.push(...filterBorderStateFindings(scanGitHistory({ repoDir, refRange: historyRefRange(ctx), target: "git", ...eng }), repoDir));
-    findings.push(...filterBorderStateFindings(scanTree({ dir: repoDir, stateDir: join21(repoDir, BORDER_STATE_DIR), target: "tree", ...eng }), repoDir));
+    findings.push(...filterBorderStateFindings(scanTree({ dir: repoDir, stateDir: join22(repoDir, BORDER_STATE_DIR), target: "tree", ...eng }), repoDir));
     findings.push(...filterBorderStateFindings(scanTagMessages({ repoDir, target: "git", ...eng }), repoDir));
   }
   if (!broken.has("secretlint")) {
@@ -42605,6 +43037,17 @@ async function runPipeline(o, ctx, lockWarning) {
     findings.push(...stage.findings);
     ledgerArtifacts.push(...stage.artifacts);
   }
+  if ((o.cfg.release?.twin.length ?? 0) > 0) {
+    findings.push(
+      ...await twinCoherenceFindings({
+        pairs: o.cfg.release?.twin ?? [],
+        artifacts: ledgerArtifacts,
+        repoDir,
+        ...envOpt,
+        sanitizer
+      })
+    );
+  }
   findings.push(...await runRegistryProbes({ repoDir, cfg: o.cfg, effectiveTargets: o.effectiveTargets, ...envOpt }));
   if (o.cfg.residue?.enabled === false) {
     for (let i = findings.length - 1; i >= 0; i -= 1) {
@@ -42612,13 +43055,16 @@ async function runPipeline(o, ctx, lockWarning) {
       if (f !== void 0 && RESIDUE_RULE_IDS.has(f.rule)) findings.splice(i, 1);
     }
   }
-  const exposure = [...exposureSet(o.cfg, { cwd: repoDir })];
-  const allow = applyAllowList(findings, o.cfg.allow, repoDir);
   const rulesHash = await computeCheckRulesHash({
     engineVersions: probe.engineVersions,
     configDigest: o.configDigest,
     ...o.env !== void 0 ? { env: o.env } : {}
   });
+  if (o.cfg.residue?.requireProof === true && ledgerArtifacts.length > 0 && hasBlockingResidueCapability(findings)) {
+    findings.push(...proofFindings({ artifacts: ledgerArtifacts, records: readLedger(repoDir).records, rulesHash }));
+  }
+  const exposure = [...exposureSet(o.cfg, { cwd: repoDir })];
+  const allow = applyAllowList(findings, o.cfg.allow, repoDir);
   const report = {
     schemaVersion: 1,
     key: computeCheckKey({
@@ -42754,16 +43200,16 @@ var NO_TARGETS_PROBE_CFG = {
 // src/llm/bundle.ts
 import { createHash as createHash13 } from "node:crypto";
 import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync14, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname11, join as join23 } from "node:path";
+import { dirname as dirname11, join as join24 } from "node:path";
 
 // src/llm/diff.ts
-import { spawnSync as spawnSync13 } from "node:child_process";
+import { spawnSync as spawnSync14 } from "node:child_process";
 import { mkdtempSync as mkdtempSync4, rmSync as rmSync11, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname10, join as join22, resolve as resolve13 } from "node:path";
+import { dirname as dirname10, join as join23, resolve as resolve13 } from "node:path";
 var GIT_DIFF_MAX_BUFFER = 64 * 1024 * 1024;
 function gitOut(repoDir, args, o, allowFail = false) {
   const abs = resolve13(repoDir);
-  const r = spawnSync13("git", ["-C", abs, ...args], {
+  const r = spawnSync14("git", ["-C", abs, ...args], {
     encoding: "utf8",
     env: { ...o.env ?? process.env, GIT_CEILING_DIRECTORIES: dirname10(abs) },
     timeout: 12e4,
@@ -42856,18 +43302,18 @@ function collectRawDeltas(repoDir, baseSha, headSha, o = {}) {
 var MASK_CHUNK_CHARS = 2e6;
 function maskViaEngineDetection(repoDir, texts, o = {}) {
   const sanitizer = new TextSanitizer();
-  const sandbox = mkdtempSync4(join22(repoDir, BORDER_STATE_DIR, "llm-mask-"));
+  const sandbox = mkdtempSync4(join23(repoDir, BORDER_STATE_DIR, "llm-mask-"));
   try {
     let idx = 0;
     for (const text of texts) {
       if (text === "") continue;
       for (let off = 0; off < text.length; off += MASK_CHUNK_CHARS, idx += 1) {
-        writeFileSync5(join22(sandbox, `detect-${String(idx)}.txt`), text.slice(off, off + MASK_CHUNK_CHARS), "utf8");
+        writeFileSync5(join23(sandbox, `detect-${String(idx)}.txt`), text.slice(off, off + MASK_CHUNK_CHARS), "utf8");
       }
     }
     scanTree({
       dir: sandbox,
-      stateDir: join22(repoDir, BORDER_STATE_DIR),
+      stateDir: join23(repoDir, BORDER_STATE_DIR),
       target: "llm-mask",
       sanitizer,
       ...engineEnv(o)
@@ -42925,7 +43371,7 @@ async function runLlmRequestCore(ctx) {
     ctx.stderr("border: llm-request: no check record for the current state \u2014 run 'border check' first (the bundle derives from the recorded ctx)");
     return EXIT_ERROR;
   }
-  const absReport = join23(repoDir, record2.reportPath);
+  const absReport = join24(repoDir, record2.reportPath);
   if (!existsSync15(absReport)) {
     ctx.stderr(`border: llm-request: report archive missing (${record2.reportPath} pruned?) \u2014 run 'border check' again`);
     return EXIT_ERROR;
@@ -42984,7 +43430,7 @@ async function runLlmRequestCore(ctx) {
     deterministic: { verdict: report.verdict, counts: report.counts, findings: report.findings },
     promptTemplate: { path: templatePath, sha256: createHash13("sha256").update(readFileSync14(templatePath)).digest("hex") }
   };
-  const outPath = join23(dirname11(absReport), "llm-request.json");
+  const outPath = join24(dirname11(absReport), "llm-request.json");
   mkdirSync10(dirname11(outPath), { recursive: true });
   writeFileSync6(outPath, `${JSON.stringify(bundle, null, 2)}
 `, "utf8");
@@ -42996,7 +43442,7 @@ async function runLlmRequestCore(ctx) {
 // src/llm/ingest.ts
 import { createHash as createHash14 } from "node:crypto";
 import { existsSync as existsSync16, readFileSync as readFileSync15, readdirSync as readdirSync9 } from "node:fs";
-import { isAbsolute, join as join24, resolve as resolve14 } from "node:path";
+import { isAbsolute, join as join25, resolve as resolve14 } from "node:path";
 var RULE_RE = /^[a-z0-9-]+$/;
 var MAX_TEXT = 4e3;
 var ALLOWED_KEYS = /* @__PURE__ */ new Set(["rule", "severity", "target", "path", "line", "commit", "message", "snippet", "engine", "valueDigest"]);
@@ -43015,7 +43461,7 @@ function findLatestBundle(repoDir) {
     return "no llm-request bundle found \u2014 run 'border llm-request' first";
   }
   for (const d of dirs.sort().reverse()) {
-    const p = join24(runsDir(repoDir), d, "llm-request.json");
+    const p = join25(runsDir(repoDir), d, "llm-request.json");
     if (!existsSync16(p)) continue;
     let parsed;
     try {
@@ -43028,7 +43474,7 @@ function findLatestBundle(repoDir) {
     if (b.schemaVersion !== 1 || typeof b.key !== "string" || !/^[0-9a-f]{64}$/.test(b.key) || typeof b.head !== "string" || !/^[0-9a-f]{40}$/.test(b.head) || !Array.isArray(b.fileDeltas) || b.deterministic === void 0) {
       return `bundle ${p} fails its own schema \u2014 re-run 'border llm-request'`;
     }
-    return { dir: join24(runsDir(repoDir), d), bundle: b };
+    return { dir: join25(runsDir(repoDir), d), bundle: b };
   }
   return "no llm-request bundle found \u2014 run 'border llm-request' first";
 }
@@ -43173,7 +43619,7 @@ async function runLlmRequest(ctx) {
 }
 
 // src/push/git.ts
-import { spawnSync as spawnSync14 } from "node:child_process";
+import { spawnSync as spawnSync15 } from "node:child_process";
 var DIVERGED_MESSAGE = "history diverged; border never force-pushes; resolve manually";
 function pushArgv(url2, branch, mode) {
   return mode === "dry-run" ? ["push", "--dry-run", url2, branch, "--follow-tags"] : ["push", url2, branch, "--follow-tags"];
@@ -43208,7 +43654,7 @@ function lsRemoteMap(repoDir, remote, env2) {
   return parseLsRemote(text, remote.target);
 }
 function isAncestor(repoDir, remoteSha, localSha, env2) {
-  const r = spawnSync14("git", ["-C", repoDir, "merge-base", "--is-ancestor", remoteSha, localSha], {
+  const r = spawnSync15("git", ["-C", repoDir, "merge-base", "--is-ancestor", remoteSha, localSha], {
     encoding: "utf8",
     env: { ...env2, GIT_CEILING_DIRECTORIES: repoDir }
   });
@@ -43243,7 +43689,7 @@ function pushTimeoutMs(env2) {
 }
 function executePush(i) {
   const timeoutMs = pushTimeoutMs(i.env);
-  const r = spawnSync14("git", ["-C", i.repoDir, ...pushArgv(i.remote.url, i.branch, "execute")], {
+  const r = spawnSync15("git", ["-C", i.repoDir, ...pushArgv(i.remote.url, i.branch, "execute")], {
     stdio: "inherit",
     env: i.env,
     timeout: timeoutMs
@@ -43436,41 +43882,18 @@ async function executeYesPush(ctx, loaded) {
   return EXIT_PASS;
 }
 
-// src/scan/scan.ts
-import { mkdtempSync as mkdtempSync5 } from "node:fs";
+// src/roundtrip/orchestrate.ts
+import { mkdtempSync as mkdtempSync5, rmSync as rmSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { randomBytes } from "node:crypto";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join26 } from "node:path";
 
-// src/scan/config.ts
-function buildScanConfigYaml(eco) {
-  return [
-    "version: 1",
-    "targets:",
-    "  git:",
-    "    remotes: []",
-    `  ${eco}: {}`,
-    "rules:",
-    "  authors:",
-    "    emails: []",
-    "    names: []",
-    "  hosts: []",
-    "  ips: []",
-    "  pathPatterns: []",
-    "residue:",
-    "  enabled: true",
-    ""
-  ].join("\n");
-}
-function synthesizeScanConfig(eco) {
-  return parseConfig(buildScanConfigYaml(eco), "<border scan>");
-}
-
 // src/scan/fetch.ts
 import { createHash as createHash15 } from "node:crypto";
-import { basename as basename4 } from "node:path";
+import { basename as basename5 } from "node:path";
 var SCAN_MAX_ARTIFACT_BYTES = 200 * 1024 * 1024;
 var SCAN_REQUEST_TIMEOUT_MS = 6e4;
-var SCAN_USER_AGENT = "border-customs/0.3.2 (+https://github.com/sumteclab/border; border scan)";
+var SCAN_USER_AGENT = "border-customs/0.4.1 (+https://github.com/sumteclab/border; border scan)";
 var CRATES_DOWNLOAD_HOST = "https://static.crates.io";
 var defaultScanFetcher = async (url2, init) => {
   if (!/^https?:\/\//.test(url2)) throw new EngineRunError(`border scan refuses non-http(s) URL: ${url2}`, null);
@@ -43546,7 +43969,7 @@ function rubygemsDownloadUrl(name, version2, base = channelBaseUrl("rubygems"))
   return `${base}/downloads/${name}-${version2}.gem`;
 }
 function safeArtifactName(raw, fallback) {
-  const base = basename4(raw.split("?")[0] ?? "").replace(/[^A-Za-z0-9._+-]/g, "_");
+  const base = basename5(raw.split("?")[0] ?? "").replace(/[^A-Za-z0-9._+-]/g, "_");
   return base.length > 0 && base !== "." && base !== ".." ? base : fallback;
 }
 async function fetchArtifact(spec, o) {
@@ -43599,9 +44022,746 @@ function sha256Hex(data) {
   return createHash15("sha256").update(data).digest("hex");
 }
 
+// src/scan/spec.ts
+var ECOSYSTEMS = ["npm", "pypi", "crates", "rubygems"];
+var SCAN_SPEC_USAGE = "usage: border scan <[ecosystem:]name@version> \u2014 e.g. border scan puppeteer@23.11.1 | pypi:requests@2.32.3 | crates:serde@1.0.219 | rubygems:rails@7.1.1";
+var PLAIN_NAME = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+var SCOPED_NAME = /^@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+var VERSION = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+var bad2 = (why) => {
+  throw new UnknownArgError(`${why}; ${SCAN_SPEC_USAGE}`);
+};
+function parseScanSpec(raw) {
+  const text = raw.trim();
+  if (text.length === 0) return bad2("empty spec");
+  let ecosystem = "npm";
+  let rest = text;
+  const colon = text.indexOf(":");
+  if (colon >= 0) {
+    const prefix = text.slice(0, colon);
+    const found = ECOSYSTEMS.find((e) => e === prefix);
+    if (found === void 0) {
+      return bad2(`unknown ecosystem '${prefix}' \u2014 expected one of: ${ECOSYSTEMS.join(", ")}`);
+    }
+    ecosystem = found;
+    rest = text.slice(colon + 1);
+    if (rest.length === 0) return bad2("missing package name after the ecosystem prefix");
+  }
+  const scoped = rest.startsWith("@");
+  const at = rest.lastIndexOf("@");
+  if (at <= 0) return bad2(`spec '${raw}' is missing '@version'`);
+  const name = rest.slice(0, at);
+  const version2 = rest.slice(at + 1);
+  if (!(scoped ? SCOPED_NAME : PLAIN_NAME).test(name)) {
+    return bad2(`invalid package name '${name}'`);
+  }
+  if (!VERSION.test(version2)) {
+    return bad2(`invalid version '${version2}' in spec '${raw}'`);
+  }
+  return { ecosystem, name, version: version2 };
+}
+
+// src/roundtrip/localArtifact.ts
+import { createReadStream, existsSync as existsSync17, statSync as statSync2 } from "node:fs";
+import { createHash as createHash16 } from "node:crypto";
+import { basename as basename6, resolve as resolve15 } from "node:path";
+var EXT_TABLE = /* @__PURE__ */ new Map([
+  [".whl", "pypi"],
+  [".tgz", "npm"],
+  [".crate", "crates"],
+  [".gem", "rubygems"]
+]);
+var EXT_LIST = ".whl (pypi), .tgz (npm), .crate (crates), .gem (rubygems)";
+var CONTAINER_NAME = /* @__PURE__ */ new Map([
+  [".tgz", "/root/p.tgz"],
+  [".crate", "/root/p.crate"],
+  [".gem", "/root/p.gem"]
+]);
+var wheelContainerPath = (base, name, version2) => `/root/${safeArtifactName(base, `${name}-${version2}-py3-none-any.whl`)}`;
+var bad3 = (why) => {
+  throw new UnknownArgError(`border roundtrip: ${why}`);
+};
+function identityFromFilename(base, eco) {
+  if (eco === "pypi") {
+    const parts = base.slice(0, -".whl".length).split("-");
+    const name = parts[0] ?? "";
+    const version2 = parts[1] ?? "";
+    if (parts.length < 5 || !/^[A-Za-z0-9][A-Za-z0-9._]*$/.test(name) || !/^\d[A-Za-z0-9._+!]*$/.test(version2)) return null;
+    return { name, version: version2 };
+  }
+  if (eco === "npm") {
+    const m2 = /^(.+)-(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)\.tgz$/i.exec(base);
+    if (m2 === null || m2[1] === void 0 || m2[2] === void 0) return null;
+    return { name: m2[1], version: m2[2] };
+  }
+  if (eco === "crates") {
+    const m2 = /^([a-z0-9_][a-z0-9._-]*?)-(\d[A-Za-z0-9._+-]*)\.crate$/i.exec(base);
+    if (m2 === null || m2[1] === void 0 || m2[2] === void 0) return null;
+    return { name: m2[1], version: m2[2] };
+  }
+  const m = /^([A-Za-z0-9][A-Za-z0-9._-]*?)-(\d[A-Za-z0-9._+-]*)\.gem$/i.exec(base);
+  if (m === null || m[1] === void 0 || m[2] === void 0) return null;
+  return { name: m[1], version: m[2] };
+}
+var GRAMMAR_HINT = {
+  pypi: "PEP 427 wheel names, e.g. jupyter_core-5.8.1-py3-none-any.whl",
+  npm: "npm pack names, e.g. node-fetch-2.6.1.tgz (scoped packages flatten to scope-pkg-1.0.0.tgz)",
+  crates: "cargo package names, e.g. rt-crate-1.0.0.crate",
+  rubygems: "gem package names, e.g. rt-gem-1.0.0.gem"
+};
+function classifyLocalInput(raw, cwd, parsesAsRegistrySpec) {
+  const abs = resolve15(cwd, raw);
+  if (existsSync17(abs)) {
+    const st = statSync2(abs);
+    if (st.isDirectory()) {
+      bad3(`'${raw}' resolves to a directory (${abs}) \u2014 local mode needs a single artifact FILE, not a directory`);
+    }
+    if (!st.isFile()) {
+      bad3(`'${raw}' resolves to something that is not a regular file (${abs})`);
+    }
+    const lower = basename6(abs).toLowerCase();
+    const ext = [...EXT_TABLE.keys()].find((e) => lower.endsWith(e)) ?? null;
+    if (ext === null) {
+      const known = [...EXT_TABLE.keys()].map((e) => `\`${e}\``).join(", ");
+      bad3(`'${basename6(abs)}' exists but its extension is not in the closed local-artifact table (${known}) \u2014 no content sniffing is done; supported: ${EXT_LIST}`);
+    }
+    const eco = EXT_TABLE.get(ext);
+    const identity = identityFromFilename(basename6(abs), eco);
+    if (identity === null) {
+      bad3(`cannot derive package identity from '${basename6(abs)}' \u2014 expected ${GRAMMAR_HINT[eco]}`);
+    }
+    return {
+      absPath: abs,
+      ecosystem: eco,
+      name: identity.name,
+      version: identity.version,
+      containerPath: ext === ".whl" ? wheelContainerPath(basename6(abs), identity.name, identity.version) : CONTAINER_NAME.get(ext),
+      source: `local:${abs}`
+    };
+  }
+  const looksLocal = raw.includes("/") || [...EXT_TABLE.keys()].some((e) => raw.toLowerCase().endsWith(e));
+  if (looksLocal && !parsesAsRegistrySpec(raw)) {
+    bad3(`'${raw}' (resolved: ${abs}) is not an existing file \u2014 a path-shaped argument is LOCAL mode and is never fetched; fix the path or pass a registry spec`);
+  }
+  return null;
+}
+async function readLocalArtifact(absPath, cap = SCAN_MAX_ARTIFACT_BYTES) {
+  const hash2 = createHash16("sha256");
+  const parts = [];
+  let total = 0;
+  for await (const chunk of createReadStream(absPath)) {
+    const b = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    total += b.byteLength;
+    if (total > cap) {
+      throw new EngineRunError(
+        `border roundtrip: ${absPath} streams past the 200 MiB artifact size cap after ${String(total)} bytes \u2014 refusing to prove a partial read (fail-closed)`,
+        null
+      );
+    }
+    hash2.update(b);
+    parts.push(b);
+  }
+  return { bytes: Buffer.concat(parts), sha256: hash2.digest("hex") };
+}
+
+// src/roundtrip/docker.ts
+var DOCKER_PROBE_TIMEOUT_MS = 15e3;
+var DOCKER_RUN_TIMEOUT_MS = 12e4;
+var DOCKER_CP_TIMEOUT_MS = 12e4;
+var SNAPSHOT_TIMEOUT_MS = 12e4;
+var PHASE_TIMEOUT_MS = 6e5;
+var DOCKER_RM_TIMEOUT_MS = 6e4;
+var CONTAINER_TTL_SEC = 900;
+var BASE_EXCLUDES = [
+  "/proc",
+  "/sys",
+  "/dev",
+  "/root/.npm",
+  "/tmp/node-compile-cache",
+  "/etc/hostname",
+  "/etc/resolv.conf",
+  "/etc/hosts"
+];
+var PYTHON_EXCLUDES = ["/root/.cache", "/var/log", "/var/lib/apt/lists", "*/__pycache__"];
+var CARGO_EXCLUDES = ["/root/.cargo", "/usr/local/cargo", "/usr/local/.crates2.json", "/usr/local/.crates.toml"];
+function snapshotScript(excludes) {
+  const prune = `"(" ${excludes.map((p) => `-path "${p}"`).join(" -o ")} ")" -prune -o`;
+  return [
+    "set -e",
+    'T=/dev/shm/rt-snap.$$; mkdir -p "$T"',
+    `find / -xdev ${prune} -type f -print0 > "$T/f0"`,
+    // || true: a file can vanish between find passes (package managers churn
+    // temp state); the missing row is consistent noise, not a false residue.
+    `xargs -0 -r sha256sum < "$T/f0" 2>/dev/null > "$T/hashes" || true`,
+    // sha256sum text mode = 64 hex + 2 spaces + path; substr keeps spaced paths whole.
+    `awk '{ printf "F\\t%s\\t%s\\n", substr($0,67), substr($0,1,64) }' "$T/hashes" > "$T/files"`,
+    `find / -xdev ${prune} -type l -printf 'L\\t%p\\t%l\\n' > "$T/links"`,
+    `find / -xdev ${prune} -type d -printf 'D\\t%p\\t-\\n' > "$T/dirs"`,
+    'LC_ALL=C sort "$T/files" "$T/links" "$T/dirs"',
+    'rm -rf "$T"'
+  ].join("\n");
+}
+function realDockerExec() {
+  return (args, timeoutMs) => {
+    const r = spawnEngine(binaryCandidates("docker", {}), [...args], { timeoutMs });
+    return { status: r.status, stdout: r.stdout, stderr: r.stderr };
+  };
+}
+
+// src/roundtrip/calibrate.ts
+var RT_DEP_RULE = "residue-roundtrip-dep-owned";
+var PIP_REPORT_PATH = "/dev/shm/rt-report.json";
+function normalizePipName(name) {
+  return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+function parsePipReport(text) {
+  const die = (why) => {
+    throw new EngineRunError(`roundtrip: pypi closure report unusable (${why}) \u2014 cannot verify (fail-closed)`, null);
+  };
+  let doc;
+  try {
+    doc = JSON.parse(text);
+  } catch {
+    die("not JSON");
+  }
+  if (typeof doc !== "object" || doc === null) die("not an object");
+  const rec = doc;
+  if (String(rec.version) !== "1") die(`report format v${String(rec.version)} is not the v1 surface we validated on pip 25.0.1`);
+  if (!Array.isArray(rec.install)) die("install is not an array");
+  const closure = /* @__PURE__ */ new Map();
+  for (const item of rec.install) {
+    const name = item?.metadata?.name;
+    const version2 = item?.metadata?.version;
+    if (typeof name !== "string" || name.length === 0 || typeof version2 !== "string" || version2.length === 0) {
+      throw new EngineRunError("roundtrip: pypi closure report unusable (an install entry lacks metadata.name/version) \u2014 cannot verify (fail-closed)", null);
+    }
+    closure.set(normalizePipName(name), version2);
+  }
+  if (closure.size === 0) die("empty install list \u2014 a resolvable target must report at least itself");
+  return closure;
+}
+function claim2(map2, ambiguous, path4, owner) {
+  if (ambiguous.has(path4)) return;
+  const cur = map2.get(path4);
+  if (cur === void 0) map2.set(path4, owner);
+  else if (cur !== owner) {
+    map2.delete(path4);
+    ambiguous.add(path4);
+  }
+}
+function parentOf(path4) {
+  const cut = path4.lastIndexOf("/");
+  return cut <= 0 ? "/" : path4.slice(0, cut);
+}
+function buildAttribution(claimText, guard) {
+  const exactOwners = /* @__PURE__ */ new Map();
+  const dirOwners = /* @__PURE__ */ new Map();
+  const ambiguous = /* @__PURE__ */ new Set();
+  const claimants = /* @__PURE__ */ new Map();
+  const normCount = /* @__PURE__ */ new Map();
+  const lines = claimText.split("\n");
+  if (guard !== void 0) {
+    for (const line of lines) {
+      if (!line.startsWith("@	")) continue;
+      const f = line.slice(2).split("	");
+      if (f.length !== 6) continue;
+      const [owner, norm, ver, di] = f;
+      normCount.set(norm, (normCount.get(norm) ?? 0) + 1);
+      if (!claimants.has(owner)) claimants.set(owner, { owner, norm, ver, di, root: parentOf(di), dirName: f[4], dirVer: f[5] });
+    }
+  }
+  const legit = (owner) => {
+    if (guard === void 0) return {};
+    const c = claimants.get(owner);
+    if (c === void 0) return void 0;
+    if (c.norm === guard.target) return void 0;
+    if (guard.pins.get(c.norm) !== c.ver) return void 0;
+    if (c.dirName !== c.norm || c.dirVer !== c.ver) return void 0;
+    if ((normCount.get(c.norm) ?? 0) !== 1) return void 0;
+    return c;
+  };
+  for (const line of lines) {
+    if (line.trim().length === 0 || line.startsWith("@	")) continue;
+    const tab = line.indexOf("	");
+    if (tab <= 0 || line.indexOf("	", tab + 1) !== -1) continue;
+    const owner = line.slice(0, tab);
+    const path4 = line.slice(tab + 1);
+    if (!path4.startsWith("/") || path4.length === 1) continue;
+    if (guard !== void 0) {
+      const c = legit(owner);
+      if (c === void 0 || c.root === void 0 || !path4.startsWith(`${c.root}/`)) continue;
+    }
+    claim2(exactOwners, ambiguous, path4, owner);
+    for (let dir = parentOf(path4); dir.length > 1; dir = parentOf(dir)) {
+      claim2(dirOwners, ambiguous, dir, owner);
+    }
+  }
+  return { exactOwners, dirOwners, ambiguous };
+}
+function ownerOf(entry, attribution) {
+  const exact = attribution.exactOwners.get(entry.path);
+  if (exact !== void 0) return exact;
+  return entry.kind === "D" ? attribution.dirOwners.get(entry.path) : void 0;
+}
+var CLAIM_SCANNER_PY = [
+  "import csv, json, os, re, site, sys",
+  "try:",
+  "    closure = json.loads(os.environ['BORDER_CLOSURE'])",
+  "    assert isinstance(closure, dict) and closure",
+  "except Exception:",
+  "    sys.exit(4)",
+  "def norm(n):",
+  "    return re.sub(r'[-_.]+', '-', n).lower()",
+  "def read_meta(di):",
+  "    name = ''",
+  "    ver = ''",
+  "    try:",
+  "        f = open(os.path.join(di, 'METADATA'), encoding='utf-8', errors='replace')",
+  "    except OSError:",
+  "        return None",
+  "    with f:",
+  "        for raw in f:",
+  "            line = raw.rstrip('\\n')",
+  "            if line == '':",
+  "                break",
+  "            if not name and line.startswith('Name:'):",
+  "                name = line[5:].strip()",
+  "            elif not ver and line.startswith('Version:'):",
+  "                ver = line[8:].strip()",
+  "    return (name, ver) if name and ver else None",
+  "roots = []",
+  "try:",
+  "    roots.extend(site.getsitepackages())",
+  "except Exception:",
+  "    pass",
+  "out = []",
+  "seen = set()",
+  "for root in roots:",
+  "    if not os.path.isdir(root) or root in seen:",
+  "        continue",
+  "    seen.add(root)",
+  "    for d in sorted(os.listdir(root)):",
+  "        if not d.endswith('.dist-info'):",
+  "            continue",
+  "        di = os.path.join(root, d)",
+  "        meta = read_meta(di)",
+  "        if meta is None or norm(meta[0]) not in closure:",
+  "            continue",
+  "        owner = meta[0] + '==' + meta[1]",
+  "        core = d[:-10]",
+  "        cut = core.rfind('-')",
+  "        dn = norm(core[:cut]) if cut > 0 else ''",
+  "        dv = core[cut + 1:] if cut > 0 else ''",
+  "        out.append('@\\t' + owner + '\\t' + norm(meta[0]) + '\\t' + meta[1] + '\\t' + di + '\\t' + dn + '\\t' + dv)",
+  "        out.append(owner + '\\t' + di)",
+  "        for base, _dirs, files in os.walk(di):",
+  "            for fn in sorted(files):",
+  "                out.append(owner + '\\t' + os.path.join(base, fn))",
+  "        try:",
+  "            rf = open(os.path.join(di, 'RECORD'), newline='', encoding='utf-8', errors='replace')",
+  "            with rf:",
+  "                for row in csv.reader(rf):",
+  "                    if not row or not row[0].strip():",
+  "                        continue",
+  "                    p = os.path.normpath(os.path.join(root, row[0].strip()))",
+  "                    if p.startswith(root + os.sep):",
+  "                        out.append(owner + '\\t' + p)",
+  "        except Exception:",
+  "            pass",
+  "sys.stdout.write(''.join(x + '\\n' for x in out))"
+].join("\n");
+
+// src/roundtrip/manifest.ts
+import { createHash as createHash17 } from "node:crypto";
+var RT_ENGINE = "roundtrip";
+var RT_RESIDUE_RULE = "roundtrip-residue-file";
+var RT_MODIFY_RULE = "roundtrip-modified-file";
+var RT_PERSIST_RULE = "roundtrip-modified-persistence";
+var KEY_SEP = "";
+var keyOf = (kind, path4) => `${kind}${KEY_SEP}${path4}`;
+function parseManifest(text) {
+  const out = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    if (line.length === 0) continue;
+    const parts = line.split("	");
+    if (parts.length < 3) continue;
+    const kind = parts[0];
+    const path4 = parts[1];
+    const value = parts.slice(2).join("	");
+    if (kind !== "F" && kind !== "L" && kind !== "D") continue;
+    out.set(keyOf(kind, path4), { kind, path: path4, value });
+  }
+  return out;
+}
+function diffManifests(before, after) {
+  const added = [];
+  const removed = [];
+  const modified = [];
+  for (const [key, entry] of after) {
+    const old = before.get(key);
+    if (old === void 0) added.push(entry);
+    else if (old.value !== entry.value) modified.push(entry);
+  }
+  for (const [key, entry] of before) {
+    if (!after.has(key)) removed.push(entry);
+  }
+  return { added, removed, modified };
+}
+var PERSISTENCE_PATTERNS = [
+  /(^|\/)\.(bashrc|bash_profile|bash_login|profile|zshrc|zprofile|zshenv|kshrc|cshrc|login\.sh)$/,
+  /^\/etc\/profile\.d\//,
+  /^\/etc\/(bash\.bashrc|profile|environment|zsh\/zshrc|inputrc)$/,
+  /^\/etc\/systemd\//,
+  /(^|\/)\.config\/systemd\//,
+  /(^|\/)systemd\/system\//,
+  /(^|\/)(cron|cron\.d|cron\.[0-9dhmwy]+|spool\/cron)\//,
+  /^\/etc\/crontab$/,
+  /(^|\/)\.config\/fish\//,
+  /^\/(usr\/)?(local\/)?(s?bin)\//,
+  /(^|\/)\.local\/bin\//
+];
+function isPersistenceSurface(path4) {
+  return PERSISTENCE_PATTERNS.some((re) => re.test(path4));
+}
+var digestOf = (what) => createHash17("sha256").update(what).digest("hex");
+function classifyResidue(label, diff, attribution = null) {
+  const findings = [];
+  for (const e of diff.added) {
+    const owner = attribution !== null ? ownerOf(e, attribution) : void 0;
+    if (owner !== void 0) {
+      findings.push({
+        rule: RT_DEP_RULE,
+        severity: "LOW",
+        target: label,
+        path: e.path,
+        engine: RT_ENGINE,
+        message: `ADDED path survives uninstall but is claimed by still-installed dependency '${owner}' (pip-accountable) \u2014 demoted, non-blocking`,
+        valueDigest: digestOf(`ADDED:${e.path}:${e.value}`),
+        snippet: `dep-owned: ${e.path}`
+      });
+      continue;
+    }
+    findings.push({
+      rule: RT_RESIDUE_RULE,
+      severity: "HIGH",
+      target: label,
+      path: e.path,
+      engine: RT_ENGINE,
+      message: `installed file survived uninstall (ADDED in post-uninstall manifest)`,
+      valueDigest: digestOf(`ADDED:${e.path}:${e.value}`),
+      snippet: `residue: ${e.path}`
+    });
+  }
+  for (const e of diff.modified) {
+    const persist = isPersistenceSurface(e.path);
+    findings.push({
+      rule: persist ? RT_PERSIST_RULE : RT_MODIFY_RULE,
+      severity: persist ? "CRITICAL" : "HIGH",
+      target: label,
+      path: e.path,
+      engine: RT_ENGINE,
+      message: persist ? `uninstall mutated a persistence surface (rc/systemd/cron/PATH) \u2014 content differs pre-install vs post-uninstall` : `file content differs pre-install vs post-uninstall (MODIFIED, not reverted by uninstall)`,
+      valueDigest: digestOf(`MODIFIED:${e.path}:${e.value}`),
+      snippet: persist ? `persistence: ${e.path}` : `modified: ${e.path}`
+    });
+  }
+  return findings;
+}
+
+// src/roundtrip/orchestrate.ts
+function containerNameFor(label, rand = randomBytes(3).toString("hex")) {
+  return `rt-${sha256Hex(label).slice(0, 8)}-${rand}`;
+}
+var shArgv = (name) => {
+  if (!/^[A-Za-z0-9@._+/-]+$/.test(name)) {
+    throw new EngineRunError(`roundtrip: package name '${name}' rejected for shell composition`, null);
+  }
+  return [name];
+};
+var PROFILES = {
+  npm: {
+    image: "node:24-slim",
+    artifactPath: "/root/p.tgz",
+    excludes: BASE_EXCLUDES,
+    install: (p) => ["npm", "install", "-g", "--foreground-scripts", "--no-audit", "--no-fund", p],
+    uninstall: (s) => ["npm", "uninstall", "-g", shArgv(s.name)[0]]
+  },
+  pypi: {
+    image: "python:3.12-slim",
+    artifactPath: "/root/p.tar.gz",
+    excludes: [...BASE_EXCLUDES, ...PYTHON_EXCLUDES],
+    install: (p) => ["pip", "install", "--no-input", "--root-user-action=ignore", p],
+    uninstall: (s) => ["pip", "uninstall", "-y", shArgv(s.name)[0]]
+  },
+  rubygems: {
+    image: "ruby:3.4-slim",
+    artifactPath: "/root/p.gem",
+    excludes: BASE_EXCLUDES,
+    install: (p) => ["gem", "install", "--no-document", p],
+    uninstall: (s) => ["gem", "uninstall", shArgv(s.name)[0], "-x", "--force"]
+  },
+  crates: {
+    image: "rust:1-slim",
+    artifactPath: "/root/p.crate",
+    excludes: [...BASE_EXCLUDES, ...CARGO_EXCLUDES],
+    // W2.1 docker legs, verified on rust:1-slim / cargo 1.98: a bare positional
+    // is parsed as a CRATE@VER spec (a directory 400s on "invalid character `/`"),
+    // so the unpacked staging dir goes through --path; --no-track must NOT be
+    // used because it suppresses the $ROOT/.crates2.json install record, which is
+    // the only thing `cargo uninstall` reads (with it, every uninstall dies on
+    // "package ID specification did not match"); and border's own /opt/<dir>
+    // staging tree is never owned by cargo, so the chain that creates it removes
+    // it — after `cargo install` succeeded, keeping install failure fail-closed.
+    install: (p, s) => {
+      const name = shArgv(s.name)[0];
+      const dir = `${name}-${s.version}`;
+      return ["sh", "-c", `tar xf ${p} -C /opt && cargo install --root /usr/local --path "/opt/${dir}" && rm -rf "/opt/${dir}"`];
+    },
+    uninstall: (s) => ["cargo", "uninstall", "--root", "/usr/local", shArgv(s.name)[0]]
+  }
+};
+function profileFor(eco) {
+  return PROFILES[eco];
+}
+function execChecked(exec, args, timeoutMs, what) {
+  const r = exec(args, timeoutMs);
+  if (r.status !== 0) {
+    const tail3 = r.stderr.replace(/\s+/g, " ").slice(-240);
+    throw new EngineRunError(`roundtrip: ${what} failed (exit ${String(r.status)})${tail3 ? `: ${tail3}` : ""} \u2014 cannot verify (fail-closed)`, r.status);
+  }
+  return r;
+}
+function resolvePipClosure(exec, profile, hostPath, label, spec) {
+  const ctr = containerNameFor(`${label}#closure`);
+  try {
+    execChecked(exec, ["run", "-d", "--name", ctr, profile.image, "sleep", String(CONTAINER_TTL_SEC)], DOCKER_RUN_TIMEOUT_MS, "closure resolver start");
+    execChecked(exec, ["cp", hostPath, `${ctr}:${profile.artifactPath}`], DOCKER_CP_TIMEOUT_MS, "resolver artifact copy");
+    execChecked(
+      exec,
+      ["exec", ctr, "pip", "install", "--dry-run", "--report", PIP_REPORT_PATH, "--no-input", "--root-user-action=ignore", profile.artifactPath],
+      PHASE_TIMEOUT_MS,
+      "pypi closure dry-run"
+    );
+    const rep = execChecked(exec, ["exec", ctr, "cat", PIP_REPORT_PATH], SNAPSHOT_TIMEOUT_MS, "pypi closure report read");
+    const closure = parsePipReport(rep.stdout);
+    if (!closure.has(normalizePipName(spec.name))) {
+      throw new EngineRunError(`roundtrip: pip closure report does not list the target ${spec.name} \u2014 cannot verify (fail-closed)`, null);
+    }
+    return closure;
+  } finally {
+    try {
+      exec(["rm", "-f", ctr], DOCKER_RM_TIMEOUT_MS);
+    } catch {
+    }
+  }
+}
+function scanDepClaims(exec, container, closure, target, note) {
+  const guard = { pins: closure, target };
+  const argv = ["exec", "-e", `BORDER_CLOSURE=${JSON.stringify(Object.fromEntries(closure))}`, container, "python3", "-c", CLAIM_SCANNER_PY];
+  try {
+    const r = exec(argv, SNAPSHOT_TIMEOUT_MS);
+    if (r.status !== 0) {
+      note(`roundtrip: dep-attribution scan failed (exit ${String(r.status)}) \u2014 every row keeps its blocking grade (over-report tolerated)`);
+      return buildAttribution("", guard);
+    }
+    return buildAttribution(r.stdout, guard);
+  } catch {
+    note("roundtrip: dep-attribution scan could not run \u2014 every row keeps its blocking grade (over-report tolerated)");
+    return buildAttribution("", guard);
+  }
+}
+function runPipeline2(exec, profile, spec, label, hostPath, container, closure, note) {
+  execChecked(exec, ["run", "-d", "--name", container, profile.image, "sleep", String(CONTAINER_TTL_SEC)], DOCKER_RUN_TIMEOUT_MS, "container start");
+  try {
+    execChecked(exec, ["cp", hostPath, `${container}:${profile.artifactPath}`], DOCKER_CP_TIMEOUT_MS, "artifact copy");
+    const m1 = parseManifest(takeSnapshot(exec, container, profile.excludes));
+    execChecked(exec, ["exec", container, ...profile.install(profile.artifactPath, spec)], PHASE_TIMEOUT_MS, `install ${label}`);
+    const m2 = parseManifest(takeSnapshot(exec, container, profile.excludes));
+    const installDiff = diffManifests(m1, m2);
+    const installDelta = installDiff.added.length + installDiff.removed.length + installDiff.modified.length;
+    if (installDelta === 0) {
+      throw new EngineRunError(
+        `roundtrip: install of ${label} produced an empty filesystem delta \u2014 cannot verify it ran, refusing to grade a no-op`,
+        null
+      );
+    }
+    execChecked(exec, ["exec", container, ...profile.uninstall(spec)], PHASE_TIMEOUT_MS, `uninstall ${label}`);
+    const m3 = parseManifest(takeSnapshot(exec, container, profile.excludes));
+    const attribution = closure !== null ? scanDepClaims(exec, container, closure, normalizePipName(spec.name), note) : null;
+    return {
+      findings: classifyResidue(label, diffManifests(m1, m3), attribution),
+      installDelta,
+      baselineDigest: sha256Hex([...m1.keys()].join("\n"))
+    };
+  } finally {
+    try {
+      exec(["rm", "-f", container], DOCKER_RM_TIMEOUT_MS);
+    } catch {
+    }
+  }
+}
+function takeSnapshot(exec, container, excludes) {
+  return execChecked(
+    exec,
+    ["exec", container, "sh", "-c", snapshotScript(excludes)],
+    SNAPSHOT_TIMEOUT_MS,
+    "manifest snapshot"
+  ).stdout;
+}
+async function runRoundtripCore(ctx, deps = {}) {
+  const raw = ctx.positionals[0];
+  if (ctx.positionals.length !== 1 || raw === void 0) {
+    throw new UnknownArgError(
+      `border roundtrip expects exactly one argument \u2014 a registry spec or a local artifact file (got ${String(ctx.positionals.length)}); ${SCAN_SPEC_USAGE}`
+    );
+  }
+  const local = classifyLocalInput(raw, ctx.cwd, parsesRegistrySpec);
+  const spec = local !== null ? { ecosystem: local.ecosystem, name: local.name, version: local.version } : parseScanSpec(raw);
+  const laneProfile = profileFor(spec.ecosystem);
+  const profile = local !== null ? { ...laneProfile, artifactPath: local.containerPath } : laneProfile;
+  const label = `${spec.ecosystem}:${spec.name}@${spec.version}`;
+  const exec = deps.exec ?? realDockerExec();
+  if (!dockerAvailableGuard(exec)) {
+    ctx.stderr("roundtrip: docker unavailable \u2014 cannot verify");
+    return EXIT_ERROR;
+  }
+  const baseDir = mkdtempSync5(join26(tmpdir3(), "border-roundtrip-"));
+  try {
+    const localRead = local !== null ? await readLocalArtifact(local.absPath) : null;
+    const bytes = localRead?.bytes ?? (await fetchArtifact(spec, { fetcher: deps.fetcher ?? defaultScanFetcher })).bytes;
+    const artifactSha256 = localRead !== null ? localRead.sha256 : sha256Hex(bytes);
+    const hostPath = join26(baseDir, "artifact");
+    writeFileSync7(hostPath, bytes);
+    const container = containerNameFor(label);
+    const closure = spec.ecosystem === "pypi" ? resolvePipClosure(exec, profile, hostPath, label, spec) : null;
+    const { findings, installDelta, baselineDigest } = runPipeline2(exec, profile, spec, label, hostPath, container, closure, (msg) => ctx.stderr(msg));
+    const verdict = computeVerdict(findings);
+    const report = {
+      schemaVersion: 1,
+      key: sha256Hex(`roundtrip:${label}:${baselineDigest}:${verdict}`),
+      head: baselineDigest.slice(0, 40),
+      dirty: false,
+      exposureSet: [label],
+      refSet: [],
+      rulesHash: sha256Hex(`${profile.image}|${profile.install(profile.artifactPath, spec).join(" ")}|${profile.uninstall(spec).join(" ")}`),
+      verdict,
+      counts: countFindings(findings),
+      findings,
+      // W2.4(b) provenance honesty: a local run proves ITS OWN bytes. The
+      // fields are absent (byte-identical JSON) on the registry lane and
+      // never phrase the artifact as registry-verified.
+      ...local !== null ? { source: local.source, artifactSha256 } : {},
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const sanitizer = new TextSanitizer();
+    const line = (text) => sanitizer.sanitize(text).replace(/\s+/g, " ").trim();
+    if (ctx.flags.json) {
+      ctx.stdout(renderReportJson(report));
+    } else {
+      if (local !== null) {
+        ctx.stdout(line(`roundtrip: source ${local.source} artifact sha256 ${artifactSha256}`));
+      }
+      for (const f of report.findings) {
+        ctx.stdout(line(`  ${f.severity} ${f.rule} [${f.engine}] ${f.path ?? f.target} ${f.message}`));
+      }
+      const depOwned = findings.reduce((n, f) => n + (f.rule === RT_DEP_RULE ? 1 : 0), 0);
+      if (depOwned > 0) {
+        ctx.stdout(line(`roundtrip: ${String(depOwned)} row(s) attributed to still-installed pip dependencies \u2014 demoted to ${RT_DEP_RULE} (non-blocking, informational)`));
+      }
+      ctx.stdout(line(`roundtrip: ${String(report.findings.length)} residue row(s); install-delta ${String(installDelta)} files`));
+    }
+    if (ctx.flags.record !== false) {
+      await recordRoundtripProof(ctx, artifactSha256, report.findings.length, report.findings.length === 0 ? "clean" : "residue");
+    }
+    return exitCodeFromVerdict(verdict);
+  } finally {
+    rmSync12(baseDir, { recursive: true, force: true });
+  }
+}
+function parsesRegistrySpec(raw) {
+  try {
+    parseScanSpec(raw);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function recordRoundtripProof(ctx, artifactSha256, rows, verdict) {
+  const notice = (msg) => ctx.stderr(`roundtrip: ${msg}`);
+  try {
+    const env2 = ctx.env;
+    const load = loadConfig({
+      cwd: ctx.cwd,
+      ...ctx.flags.config !== void 0 ? { configPath: ctx.flags.config } : {},
+      ...env2 !== void 0 ? { env: env2 } : {}
+    });
+    let effective = null;
+    if (load.kind === "loaded") effective = load;
+    else if (load.explicit !== void 0) effective = { kind: "loaded", config: load.explicit.config, warnings: [], source: load.explicit.source };
+    if (effective === null) {
+      notice("no border.yaml here \u2014 proof NOT recorded");
+      return;
+    }
+    const repoDir = resolveRepoDir(ctx.cwd, { ...env2 !== void 0 ? { env: env2 } : {} });
+    const probe = await probeEngines(effective.config, { ...env2 !== void 0 ? { env: env2 } : {} });
+    if (probe.degraded) {
+      notice("engine probe degraded \u2014 cannot mint the rulesHash this proof must match; proof NOT recorded");
+      return;
+    }
+    const rulesHash = await computeCheckRulesHash({
+      engineVersions: probe.engineVersions,
+      configDigest: computeConfigDigest(effective),
+      ...env2 !== void 0 ? { env: env2 } : {}
+    });
+    appendRecord(repoDir, buildRoundtripRecord({ artifactSha256, verdict, rulesHash, rows }));
+    notice(`proof recorded for ${artifactSha256.slice(0, 12)}\u2026 (verdict ${verdict}, ${String(rows)} residue row(s))`);
+  } catch (err) {
+    notice(`proof NOT recorded (${err instanceof Error ? err.message : String(err)}) \u2014 'border check' with residue.requireProof will treat this artifact as unproven`);
+  }
+}
+function dockerAvailableGuard(exec) {
+  try {
+    return exec(["--version"], DOCKER_PROBE_TIMEOUT_MS).status === 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/roundtrip.ts
+var runRoundtrip = (ctx) => runRoundtripCore(ctx);
+
+// src/scan/scan.ts
+import { mkdtempSync as mkdtempSync6 } from "node:fs";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join28 } from "node:path";
+
+// src/scan/config.ts
+function buildScanConfigYaml(eco) {
+  return [
+    "version: 1",
+    "targets:",
+    "  git:",
+    "    remotes: []",
+    `  ${eco}: {}`,
+    "rules:",
+    "  authors:",
+    "    emails: []",
+    "    names: []",
+    "  hosts: []",
+    "  ips: []",
+    "  pathPatterns: []",
+    "residue:",
+    "  enabled: true",
+    ""
+  ].join("\n");
+}
+function synthesizeScanConfig(eco) {
+  return parseConfig(buildScanConfigYaml(eco), "<border scan>");
+}
+
 // src/scan/materialize.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync11, readdirSync as readdirSync10, readFileSync as readFileSync16, rmSync as rmSync12, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readdirSync as readdirSync10, readFileSync as readFileSync16, rmSync as rmSync13, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join27 } from "node:path";
 var CRATES_ENVELOPE_FILES = ["Cargo.toml.orig", ".cargo-ok", ".cargo_vcs_info.json"];
 var fail2 = (why) => {
   throw new Error(`border scan cannot materialize the artifact (${why}) \u2014 refusing to stage an unusable tree (fail-closed)`);
@@ -43618,12 +44778,12 @@ function unwrapSingleDir(dir) {
   const entries = readdirSync10(dir, { withFileTypes: true });
   const dirs = entries.filter((e) => e.isDirectory());
   if (entries.length === 1 && dirs.length === 1 && dirs[0] !== void 0) {
-    return join25(dir, dirs[0].name);
+    return join27(dir, dirs[0].name);
   }
   return dir;
 }
 function requireManifest(repoDir, ecosystem, candidates) {
-  if (!candidates.some((rel) => existsSync17(join25(repoDir, rel)))) {
+  if (!candidates.some((rel) => existsSync18(join27(repoDir, rel)))) {
     fail2(`${ecosystem} package tree has none of [${candidates.join(", ")}] at its root`);
   }
 }
@@ -43633,18 +44793,18 @@ function materializePackage(o) {
 `);
   });
   const safe = safeArtifactName(o.filename, `${o.ecosystem}-artifact`);
-  const archive = join25(o.baseDir, safe);
-  writeFileSync7(archive, o.bytes);
-  const extractDir = join25(o.baseDir, "extract");
+  const archive = join27(o.baseDir, safe);
+  writeFileSync8(archive, o.bytes);
+  const extractDir = join27(o.baseDir, "extract");
   mkdirSync11(extractDir, { recursive: true });
   extractFlat(archive, extractDir);
   let repoDir = unwrapSingleDir(extractDir);
   if (o.ecosystem === "rubygems") {
     const outer = repoDir;
     const dataCandidates = findNativeMissArchives(outer).filter((f) => f.endsWith("data.tar.gz"));
-    const inner = dataCandidates[0] ?? join25(outer, "data.tar.gz");
-    if (!existsSync17(inner)) fail2(".gem archive contains no data.tar.gz");
-    const gemTree = join25(o.baseDir, "gem-tree");
+    const inner = dataCandidates[0] ?? join27(outer, "data.tar.gz");
+    if (!existsSync18(inner)) fail2(".gem archive contains no data.tar.gz");
+    const gemTree = join27(o.baseDir, "gem-tree");
     mkdirSync11(gemTree, { recursive: true });
     extractFlat(inner, gemTree);
     repoDir = unwrapSingleDir(gemTree);
@@ -43655,10 +44815,10 @@ function materializePackage(o) {
   } else {
     requireManifest(repoDir, o.ecosystem, ["Cargo.toml"]);
     for (const file2 of CRATES_ENVELOPE_FILES) {
-      const path4 = join25(repoDir, file2);
-      if (!existsSync17(path4)) continue;
+      const path4 = join27(repoDir, file2);
+      if (!existsSync18(path4)) continue;
       const original = readFileSync16(path4);
-      rmSync12(path4, { force: true });
+      rmSync13(path4, { force: true });
       note(`border scan: crates envelope normalized: ${file2} sha256=${sha256Hex(original)}`);
     }
   }
@@ -43670,45 +44830,6 @@ function materializePackage(o) {
   return repoDir;
 }
 
-// src/scan/spec.ts
-var ECOSYSTEMS = ["npm", "pypi", "crates", "rubygems"];
-var SCAN_SPEC_USAGE = "usage: border scan <[ecosystem:]name@version> \u2014 e.g. border scan puppeteer@23.11.1 | pypi:requests@2.32.3 | crates:serde@1.0.219 | rubygems:rails@7.1.1";
-var PLAIN_NAME = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
-var SCOPED_NAME = /^@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
-var VERSION = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
-var bad2 = (why) => {
-  throw new UnknownArgError(`${why}; ${SCAN_SPEC_USAGE}`);
-};
-function parseScanSpec(raw) {
-  const text = raw.trim();
-  if (text.length === 0) return bad2("empty spec");
-  let ecosystem = "npm";
-  let rest = text;
-  const colon = text.indexOf(":");
-  if (colon >= 0) {
-    const prefix = text.slice(0, colon);
-    const found = ECOSYSTEMS.find((e) => e === prefix);
-    if (found === void 0) {
-      return bad2(`unknown ecosystem '${prefix}' \u2014 expected one of: ${ECOSYSTEMS.join(", ")}`);
-    }
-    ecosystem = found;
-    rest = text.slice(colon + 1);
-    if (rest.length === 0) return bad2("missing package name after the ecosystem prefix");
-  }
-  const scoped = rest.startsWith("@");
-  const at = rest.lastIndexOf("@");
-  if (at <= 0) return bad2(`spec '${raw}' is missing '@version'`);
-  const name = rest.slice(0, at);
-  const version2 = rest.slice(at + 1);
-  if (!(scoped ? SCOPED_NAME : PLAIN_NAME).test(name)) {
-    return bad2(`invalid package name '${name}'`);
-  }
-  if (!VERSION.test(version2)) {
-    return bad2(`invalid version '${version2}' in spec '${raw}'`);
-  }
-  return { ecosystem, name, version: version2 };
-}
-
 // src/scan/scan.ts
 async function runScanCore(ctx, deps = {}) {
   const raw = ctx.positionals[0];
@@ -43724,7 +44845,7 @@ async function runScanCore(ctx, deps = {}) {
   }
   const cfg = synthesizeScanConfig(spec.ecosystem);
   const fetcher = deps.fetcher ?? defaultScanFetcher;
-  const baseDir = mkdtempSync5(join26(tmpdir3(), "border-scan-"));
+  const baseDir = mkdtempSync6(join28(tmpdir4(), "border-scan-"));
   try {
     const { bytes, filename } = await fetchArtifact(spec, { fetcher });
     const env2 = { ...ctx.env };
@@ -43848,11 +44969,12 @@ var handlers = {
   status: runStatus,
   "llm-request": runLlmRequest,
   "llm-ingest": runLlmIngest,
-  scan: runScan2
+  scan: runScan2,
+  roundtrip: runRoundtrip
 };
 
 // src/cli/types.ts
-var SUBCOMMANDS = ["check", "push", "status", "llm-request", "llm-ingest", "scan"];
+var SUBCOMMANDS = ["check", "push", "status", "llm-request", "llm-ingest", "scan", "roundtrip"];
 
 // src/cli.ts
 var VALID_TARGETS = targetIds();
@@ -43869,6 +44991,7 @@ function usage() {
     "  llm-request    emit the provenance request for LLM-authored commits",
     "  llm-ingest     record provenance captured by the harness",
     "  scan           inspect a third-party package ([ecosystem:]name@version) for residue",
+    "  roundtrip      install+uninstall a package (registry spec or local artifact file) in a throwaway container, report uninstall residue",
     "",
     "flags:",
     "  --config <path>             config file (default: ./border.yaml, then git-remote fallback)",
@@ -43878,11 +45001,12 @@ function usage() {
     "  --require-engine <list>     comma-separated engines that must be healthy (else exit 2)",
     "  --llm                       include the optional LLM review layer",
     "  --json                      machine-readable report on stdout",
+    "  --record / --no-record      `border roundtrip` records a ledger proof by default; --no-record opts out",
     "  --help, -h                  this table",
     "",
     "exit codes: 0 pass (MEDIUM/INFO/LOW allowed) | 1 gate-blocked (CRITICAL/HIGH) or partial push | 2 config/tool error",
     "",
-    "subcommands: check, push, status, llm-request, llm-ingest, scan"
+    "subcommands: check, push, status, llm-request, llm-ingest, scan, roundtrip"
   ].join("\n");
 }
 function isSubcommand(value) {
@@ -43913,10 +45037,15 @@ function parseFlags(argv) {
         "require-engine": { type: "string" },
         llm: { type: "boolean" },
         json: { type: "boolean" },
+        record: { type: "boolean" },
+        "no-record": { type: "boolean" },
         help: { type: "boolean" }
       }
     });
     const { config: config2, targets, force, yes, llm, json: json2 } = values;
+    if (values.record === true && values["no-record"] === true) {
+      throw new UnknownArgError("--record and --no-record contradict each other");
+    }
     const requireEngine = values["require-engine"];
     const flags = {
       ...config2 !== void 0 ? { config: config2 } : {},
@@ -43925,7 +45054,8 @@ function parseFlags(argv) {
       yes: yes === true,
       ...requireEngine !== void 0 ? { requireEngine: splitList(requireEngine, { flag: "--require-engine", item: "engine" }) } : {},
       llm: llm === true,
-      json: json2 === true
+      json: json2 === true,
+      ...values["no-record"] === true ? { record: false } : values.record === true ? { record: true } : {}
     };
     return { flags, positionals, help: values.help === true };
   } catch (err) {