border-customs 0.4.0 → 0.4.2

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,126 +38386,624 @@ 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 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 bad(msg) {
+  throw new Error(msg);
 }
-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 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 out;
+  return o;
 }
-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 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")
+    };
   }
-  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);
+  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")
+    };
   }
-  const manifest = parseNpmManifest(readFileSync5(manifestPath, "utf8"));
-  const identity = `${manifest.name ?? "?"}@${manifest.version ?? "?"}`;
-  if (manifest.isPrivate) {
+  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 {
-      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
+      t: "roundtrip",
+      artifactSha256: needHex(o, "artifactSha256", HEX64),
+      verdict,
+      rulesHash: needHex(o, "rulesHash", HEX64),
+      rows,
+      ts: needString(o, "ts")
     };
   }
-  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 });
-  mkdirSync3(extractDir, { recursive: true });
+  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 {
-    extractArchive(tarballAbs, extractDir, {
-      ...o.env !== void 0 ? { env: o.env } : {},
-      ...o.timeoutMs !== void 0 ? { timeoutMs: o.timeoutMs } : {}
-    });
-    const relPaths = listFiles(extractDir).map((p) => relative2(extractDir, p));
-    if (relPaths.length === 0) throw new EngineRunError("extracted artifact is empty \u2014 unusable npm pack output", null);
-    const root = relPaths[0]?.split("/")[0] ?? "package";
-    if (!relPaths.every((p) => p.startsWith(`${root}/`))) {
-      throw new EngineRunError("extracted artifact mixes multiple top-level roots \u2014 unexpected tar layout, failing closed", null);
+    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`);
     }
-    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 residueCtx = { root, identity, ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {} };
-    for (const key of LIFECYCLE_SCRIPT_KEYS) {
-      const cmd = packedManifest.scripts[key];
-      if (cmd === void 0) continue;
-      const scan = scanNpmLifecycleHook({ pkgDir, hook: cmd });
-      if (scan.signatureId !== null) {
-        findings.push(nativeFinding(
-          RESIDUE_T1_RULE,
-          "MEDIUM",
-          `package.json script '${key}' matches closed safe signature '${scan.signatureId}' (T1: install-root writes only, frozen probe/fallback argv literals, zero network/out-of-tree/persistence/cross-manager hits) \u2014 allowed but audit-visible; any deviation keeps the blocking lifecycle-script CRITICAL`,
-          packedManifestRel,
-          `${identity}:residue:t1:${key}`,
-          o.sanitizer
-        ));
-      } else {
-        findings.push(nativeFinding(
-          NPM_LIFECYCLE_RULE,
-          "CRITICAL",
-          `package.json script '${key}' is a lifecycle hook \u2014 npm executes it on every consumer install (G33): ${tail(sanitizeOut(o.sanitizer, cmd))}`,
-          packedManifestRel,
+  });
+  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));
+}
+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;
+  }
+  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" };
+    }
+  }
+  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 {
+      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
+    };
+  });
+}
+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, {
+      ...o.env !== void 0 ? { env: o.env } : {},
+      ...o.timeoutMs !== void 0 ? { timeoutMs: o.timeoutMs } : {}
+    });
+    const relPaths = listFiles(extractDir).map((p) => relative2(extractDir, p));
+    if (relPaths.length === 0) throw new EngineRunError("extracted artifact is empty \u2014 unusable npm pack output", null);
+    const root = relPaths[0]?.split("/")[0] ?? "package";
+    if (!relPaths.every((p) => p.startsWith(`${root}/`))) {
+      throw new EngineRunError("extracted artifact mixes multiple top-level roots \u2014 unexpected tar layout, failing closed", null);
+    }
+    const packedManifestRel = `${root}/package.json`;
+    if (!relPaths.includes(packedManifestRel)) throw new EngineRunError("extracted artifact has no package/package.json", null);
+    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];
+      if (cmd === void 0) continue;
+      const scan = scanNpmLifecycleHook({ pkgDir, hook: cmd });
+      if (scan.signatureId !== null) {
+        findings.push(nativeFinding(
+          RESIDUE_T1_RULE,
+          "MEDIUM",
+          `package.json script '${key}' matches closed safe signature '${scan.signatureId}' (T1: install-root writes only, frozen probe/fallback argv literals, zero network/out-of-tree/persistence/cross-manager hits) \u2014 allowed but audit-visible; any deviation keeps the blocking lifecycle-script CRITICAL`,
+          packedManifestRel,
+          `${identity}:residue:t1:${key}`,
+          o.sanitizer
+        ));
+      } else {
+        findings.push(nativeFinding(
+          NPM_LIFECYCLE_RULE,
+          "CRITICAL",
+          `package.json script '${key}' is a lifecycle hook \u2014 npm executes it on every consumer install (G33): ${tail(sanitizeOut(o.sanitizer, cmd))}`,
+          packedManifestRel,
           `${identity}:lifecycle:${key}`,
           o.sanitizer
         ));
@@ -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,24 @@ 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";
+import { gunzipSync as gunzipSync2 } from "node:zlib";
 
 // 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 +39966,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 +40065,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 +40078,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 +40114,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 +40125,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 +40144,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,362 +40186,240 @@ 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 } : {}
-      });
-      const dataRels = listFiles2(dataDir).map((p) => relative3(dataDir, p));
-      let hits;
-      try {
-        hits = residueGemHits(dataDir, dataRels, metadata);
-      } catch (e) {
-        throw new EngineRunError(`${gemName}: ${e instanceof Error ? e.message : String(e)} \u2014 failing closed`, null);
-      }
-      for (const f of residueFindings(hits, {
-        root: "data.tar.gz",
-        sep: "!",
-        identity: gemName,
-        ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {}
-      })) {
-        findings.push(f);
-      }
-    }
-  } finally {
-    removeSandbox(extractDir);
-    removeSandbox(dataDir);
-  }
-  return {
-    findings,
-    artifact: { file: `${BORDER_STATE_DIR}/dist/${gemName}`, sha256: sha2563, bytes: bytes.length }
-  };
-}
-
-// src/ledger/freshness.ts
-function artifactTargets() {
-  return publishChannels().map((c) => c.id);
-}
-function sha256File(path4) {
-  return createHash7("sha256").update(readFileSync7(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)}`);
-  mkdirSync5(dest, { recursive: true });
-  try {
-    const r = spawnSync6("npm", ["pack", "--ignore-scripts", "--silent", `--pack-destination=${dest}`], {
-      cwd: repoDir,
-      encoding: "utf8",
-      env: { ...o.env ?? process.env },
-      timeout: 12e4
-    });
-    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)) }));
-  } 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)}`);
-  mkdirSync5(dest, { recursive: true });
-  try {
-    const r = spawnSync6("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 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)) }));
-  } finally {
-    rmSync5(dest, { recursive: true, force: true });
-  }
-}
-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)}`);
-  mkdirSync5(dest, { recursive: true });
-  try {
-    const gemName = `${ident.name}-${ident.version}.gem`;
-    const r = spawnSync6("gem", ["build", ident.path, "-o", join11(dest, gemName)], {
-      cwd: repoDir,
-      encoding: "utf8",
-      env: { ...o.env ?? process.env },
-      timeout: 12e4
-    });
-    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)) }));
-  } finally {
-    rmSync5(dest, { recursive: true, force: true });
-  }
-}
-var REPACKERS = {
-  npm: packNpmArtifacts,
-  crates: packCrateArtifacts,
-  rubygems: packRubygemsArtifacts
-};
-function repackChannels() {
-  return publishChannels().filter((c) => c.freshness === "repack").map((c) => c.id);
-}
-function sameArtifacts(a, b, extensions) {
-  const digests = (xs) => xs.filter((x) => extensions.some((ext) => x.file.slice(x.file.lastIndexOf("/") + 1).endsWith(ext))).map((x) => `${x.file.slice(x.file.lastIndexOf("/") + 1)}\0${x.sha256}`).sort();
-  const ka = digests(a);
-  const kb = digests(b);
-  return ka.length === kb.length && ka.every((x, i) => x === kb[i]);
-}
-function verifyArtifactFreshness(record2, ctx, repoDir, o = {}) {
-  if (!record2.effectiveTargets.some((t) => artifactTargets().includes(t))) return true;
-  if (ctx.dirty) return false;
-  const needed = repackChannels().filter((t) => record2.effectiveTargets.includes(t));
-  if (needed.length === 0) return true;
-  if (record2.artifacts === null) return false;
-  const now = [];
-  for (const id of needed) {
-    const pack = REPACKERS[id];
-    if (pack === void 0) return false;
-    const got = pack(repoDir, o);
-    if (got === null) return false;
-    now.push(...got);
-  }
-  return sameArtifacts(
-    record2.artifacts,
-    now,
-    needed.flatMap((id) => {
-      const channel = publishChannels().find((c) => c.id === id);
-      return channel?.artifactExtensions ?? [];
-    })
-  );
-}
-
-// 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()
-  };
-}
-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 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")
-    };
-  }
-  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")
-    };
+        ...o.timeoutMs !== void 0 ? { timeoutMs: o.timeoutMs } : {}
+      });
+      const dataRels = listFiles2(dataDir).map((p) => relative3(dataDir, p));
+      let hits;
+      try {
+        hits = residueGemHits(dataDir, dataRels, metadata);
+      } catch (e) {
+        throw new EngineRunError(`${gemName}: ${e instanceof Error ? e.message : String(e)} \u2014 failing closed`, null);
+      }
+      for (const f of residueFindings(hits, {
+        root: "data.tar.gz",
+        sep: "!",
+        identity: gemName,
+        ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {}
+      })) {
+        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);
+    removeSandbox(dataDir);
   }
-  return bad(`unknown record type ${JSON.stringify(t)}`);
+  return {
+    findings,
+    artifact: { file: `${BORDER_STATE_DIR}/dist/${gemName}`, sha256: sha2563, bytes: bytes.length }
+  };
 }
-function codeOf2(err) {
-  return typeof err === "object" && err !== null ? err.code : void 0;
+
+// src/ledger/freshness.ts
+function artifactTargets() {
+  return publishChannels().map((c) => c.id);
 }
-function readLedger(repoDir) {
-  let text;
+function sha256File(path4) {
+  return createHash7("sha256").update(readFileSync8(path4)).digest("hex");
+}
+function octalField(block, start, end) {
+  const text = block.subarray(start, end).toString("utf8").replace(/[\0 ].*$/, "");
+  if (text === "") return 0;
+  if (!/^[0-7]+$/.test(text)) return null;
+  return Number.parseInt(text, 8);
+}
+function tarEntries(buf) {
+  const magic = buf.subarray(257, 263).toString("latin1");
+  if (!magic.startsWith("ustar")) return null;
+  const out = [];
+  let off = 0;
+  while (off + 512 <= buf.length) {
+    const header = buf.subarray(off, off + 512);
+    if (header.every((b) => b === 0)) return out;
+    const size = octalField(header, 124, 136);
+    if (size === null) return null;
+    const mode = octalField(header, 100, 108);
+    if (mode === null) return null;
+    const typeFlag = header[156] ?? 48;
+    const body = off + 512;
+    if (body + size > buf.length) return null;
+    const name = header.subarray(0, 100).toString("utf8").replace(/\0.*$/, "");
+    const linkName = header.subarray(157, 257).toString("utf8").replace(/\0.*$/, "");
+    if (typeFlag !== 120 && typeFlag !== 103 && typeFlag !== 76 && typeFlag !== 75) {
+      out.push({ name, member: { content: buf.subarray(body, body + size), typeFlag, mode, linkName } });
+    }
+    off = body + Math.ceil(size / 512) * 512;
+  }
+  return out;
+}
+var GEM_METADATA_STAMP_RE = /^(rubygems_version|gem_version|date):/;
+var GEM_LEGACY_EMPTY_RE = /^(autorequire|description|email|homepage|post_install_message|signing_key):[ ]*$/;
+function sha256Hex(buf) {
+  return createHash7("sha256").update(buf).digest("hex");
+}
+function gemContentDigest(bytes) {
+  const outer = tarEntries(bytes);
+  if (outer === null) return null;
+  const meta3 = outer.find((e) => e.name === "metadata.gz")?.member;
+  const data = outer.find((e) => e.name === "data.tar.gz")?.member;
+  if (meta3 === void 0 || data === void 0) return null;
+  let metadata;
+  let inner;
   try {
-    text = readFileSync8(ledgerPath(repoDir), "utf8");
-  } catch (err) {
-    if (codeOf2(err) === "ENOENT") return { records: [], warnings: [] };
-    throw err;
+    metadata = gunzipSync2(meta3.content).toString("utf8");
+    inner = gunzipSync2(data.content);
+  } catch {
+    return null;
   }
-  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 };
+  const innerEntries = tarEntries(inner);
+  if (innerEntries === null) return null;
+  const chain = createHash7("sha256");
+  for (const { name, member: m } of innerEntries) {
+    chain.update(name).update("\0").update(String(m.typeFlag)).update("\0").update(String(m.mode & 73)).update("\0").update(m.linkName).update("\0").update(sha256Hex(m.content)).update("\0");
+  }
+  const metaStripped = metadata.split("\n").filter((line) => !GEM_METADATA_STAMP_RE.test(line) && !GEM_LEGACY_EMPTY_RE.test(line)).join("\n");
+  return createHash7("sha256").update("border-gem-content-v1\0").update(chain.digest("hex")).update("\0").update(metaStripped).digest("hex");
 }
-function appendRecord(repoDir, record2) {
-  ensureStateDir(repoDir);
-  appendFileSync(ledgerPath(repoDir), `${JSON.stringify(record2)}
-`, "utf8");
+var packSeq = 0;
+function packNpmArtifacts(repoDir, o = {}) {
+  packSeq += 1;
+  const dest = join13(repoDir, BORDER_STATE_DIR, "tmp", `pack-${String(process.pid)}-${String(packSeq)}`);
+  mkdirSync5(dest, { recursive: true });
+  try {
+    const r = spawnSync7("npm", ["pack", "--ignore-scripts", "--silent", `--pack-destination=${dest}`], {
+      cwd: repoDir,
+      encoding: "utf8",
+      env: { ...o.env ?? process.env },
+      timeout: 12e4
+    });
+    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(join13(dest, f)) }));
+  } finally {
+    rmSync5(dest, { recursive: true, force: true });
+  }
 }
-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;
+function packCrateArtifacts(repoDir, o = {}) {
+  packSeq += 1;
+  const dest = join13(repoDir, BORDER_STATE_DIR, "tmp", `cargo-pack-${String(process.pid)}-${String(packSeq)}`);
+  mkdirSync5(dest, { recursive: true });
+  try {
+    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 = 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(join13(dir, f)) }));
+  } finally {
+    rmSync5(dest, { recursive: true, force: true });
   }
-  return null;
 }
-function isSkippable(r) {
-  return r !== null && r.verdict === "PASS" && r.degraded === false;
+function packRubygemsArtifacts(repoDir, o = {}) {
+  packSeq += 1;
+  const ident = singleTreeGemspec(repoDir);
+  if (ident === null) return null;
+  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 = spawnSync7("gem", ["build", ident.path, "-o", join13(dest, gemName)], {
+      cwd: repoDir,
+      encoding: "utf8",
+      env: { ...o.env ?? process.env },
+      timeout: 12e4
+    });
+    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) => {
+      const raw = readFileSync8(join13(dest, f));
+      return { file: f, sha256: sha256Hex(raw), contentDigest: gemContentDigest(raw) };
+    });
+  } finally {
+    rmSync5(dest, { recursive: true, force: true });
+  }
 }
-function lookupSkipRecord(records, key, llm) {
-  const newest = newestRecordOf(records, key);
-  return isSkippable(newest) && newest.llm === llm ? newest : null;
+var REPACKERS = {
+  npm: packNpmArtifacts,
+  crates: packCrateArtifacts,
+  rubygems: packRubygemsArtifacts
+};
+function repackChannels() {
+  return publishChannels().filter((c) => c.freshness === "repack").map((c) => c.id);
 }
-function latestPassCoveringTargets(records, key, targets) {
-  const newest = newestRecordOf(records, key);
-  return isSkippable(newest) && targets.every((t) => newest.effectiveTargets.includes(t)) ? newest : null;
+function gemParity(entry, repoDir) {
+  if (entry.contentDigest !== void 0) return entry.contentDigest;
+  try {
+    return gemContentDigest(readFileSync8(join13(repoDir, entry.file)));
+  } catch {
+    return null;
+  }
 }
-function pushRecords(records, key) {
-  return records.filter((r) => r.t === "push" && (key === void 0 || r.key === key));
+function sameArtifacts(a, b, extensions, repoDir) {
+  const digests = (xs) => {
+    const out = [];
+    for (const x of xs) {
+      const base = x.file.slice(x.file.lastIndexOf("/") + 1);
+      const ext = extensions.find((e) => base.endsWith(e));
+      if (ext === void 0) continue;
+      const parity = ext === ".gem" ? gemParity(x, repoDir) : x.sha256;
+      if (parity === null) return null;
+      out.push(`${base}\0${parity}`);
+    }
+    return out.sort();
+  };
+  const ka = digests(a);
+  const kb = digests(b);
+  return ka !== null && kb !== null && ka.length === kb.length && ka.every((x, i) => x === kb[i]);
 }
-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;
+function verifyArtifactFreshness(record2, ctx, repoDir, o = {}) {
+  if (!record2.effectiveTargets.some((t) => artifactTargets().includes(t))) return true;
+  if (ctx.dirty) return false;
+  const needed = repackChannels().filter((t) => record2.effectiveTargets.includes(t));
+  if (needed.length === 0) return true;
+  if (record2.artifacts === null) return false;
+  const now = [];
+  for (const id of needed) {
+    const pack = REPACKERS[id];
+    if (pack === void 0) return false;
+    const got = pack(repoDir, o);
+    if (got === null) return false;
+    now.push(...got);
   }
-  return null;
+  return sameArtifacts(
+    record2.artifacts,
+    now,
+    needed.flatMap((id) => {
+      const channel = publishChannels().find((c) => c.id === id);
+      return channel?.artifactExtensions ?? [];
+    }),
+    repoDir
+  );
 }
 
 // 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";
+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;
@@ -40035,13 +40430,13 @@ function runDirName(key8, ts) {
 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) {
+  for (let n = 2; existsSync9(join14(runsDir(repoDir), name)) && n < 1e3; n += 1) {
     name = `${base}-r${String(n)}`;
   }
   return name;
 }
 function ensureRunDir(repoDir, name) {
-  const dir = join13(runsDir(repoDir), name);
+  const dir = join14(runsDir(repoDir), name);
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
@@ -40060,7 +40455,7 @@ function pruneRunDirs(repoDir, key8, keep = KEEP_RUN_DIRS_PER_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 });
+    rmSync6(join14(runsDir(repoDir), dir), { recursive: true, force: true });
   }
   return doomed;
 }
@@ -40126,9 +40521,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,
@@ -40153,13 +40548,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) {
@@ -40223,13 +40618,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) {
@@ -40240,13 +40635,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"));
@@ -40259,7 +40654,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) {
@@ -40276,7 +40671,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() ?? "";
@@ -40291,7 +40686,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);
@@ -40343,7 +40738,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);
@@ -40364,10 +40759,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) => {
@@ -40376,16 +40771,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));
@@ -40394,9 +40789,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 ?? "");
@@ -40418,7 +40827,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;
@@ -40459,7 +40868,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}
@@ -40488,8 +40897,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`);
@@ -40665,7 +41074,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 } }
@@ -40980,7 +41389,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 }
@@ -40999,7 +41408,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 });
     });
   });
 }
@@ -41095,14 +41504,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) {
@@ -41301,7 +41710,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);
     }
@@ -41309,7 +41718,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);
   }
@@ -41337,7 +41746,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 } }
@@ -41348,14 +41757,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,
@@ -41370,17 +41779,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 {
@@ -41419,6 +41828,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);
     }
@@ -41574,11 +41992,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,
@@ -41590,14 +42008,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 };
     }
@@ -42001,6 +42419,21 @@ function buildBorderConfigSchema() {
     residue: external_exports.object({
       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();
 }
@@ -42088,7 +42521,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) {
@@ -42148,7 +42581,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");
@@ -42163,7 +42596,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) };
@@ -42208,10 +42641,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;
@@ -42230,7 +42663,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,
@@ -42490,10 +42923,10 @@ function proofFindings(o) {
 }
 
 // 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";
@@ -42513,7 +42946,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,
@@ -42584,8 +43017,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 = [];
@@ -42661,7 +43094,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")) {
@@ -42686,6 +43119,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) {
@@ -42838,16 +43282,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,
@@ -42940,18 +43384,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)
@@ -43009,7 +43453,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;
@@ -43068,7 +43512,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");
@@ -43080,7 +43524,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"]);
@@ -43099,7 +43543,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 {
@@ -43112,7 +43556,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";
 }
@@ -43257,7 +43701,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"];
@@ -43292,7 +43736,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 }
   });
@@ -43327,7 +43771,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
@@ -43524,14 +43968,14 @@ async function executeYesPush(ctx, loaded) {
 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 join25 } from "node:path";
+import { join as join26 } from "node:path";
 
 // 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.4.0 (+https://github.com/sumteclab/border; border scan)";
+var SCAN_USER_AGENT = "border-customs/0.4.2 (+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);
@@ -43607,7 +44051,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) {
@@ -43656,7 +44100,7 @@ async function fetchArtifact(spec, o) {
     }
   }
 }
-function sha256Hex(data) {
+function sha256Hex2(data) {
   return createHash15("sha256").update(data).digest("hex");
 }
 
@@ -43699,6 +44143,109 @@ function parseScanSpec(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;
@@ -43743,8 +44290,171 @@ function realDockerExec() {
   };
 }
 
+// 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 createHash16 } from "node:crypto";
+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";
@@ -43795,10 +44505,24 @@ var PERSISTENCE_PATTERNS = [
 function isPersistenceSurface(path4) {
   return PERSISTENCE_PATTERNS.some((re) => re.test(path4));
 }
-var digestOf = (what) => createHash16("sha256").update(what).digest("hex");
-function classifyResidue(label, diff) {
+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",
@@ -43828,7 +44552,7 @@ function classifyResidue(label, diff) {
 
 // src/roundtrip/orchestrate.ts
 function containerNameFor(label, rand = randomBytes(3).toString("hex")) {
-  return `rt-${sha256Hex(label).slice(0, 8)}-${rand}`;
+  return `rt-${sha256Hex2(label).slice(0, 8)}-${rand}`;
 }
 var shArgv = (name) => {
   if (!/^[A-Za-z0-9@._+/-]+$/.test(name)) {
@@ -43889,7 +44613,46 @@ function execChecked(exec, args, timeoutMs, what) {
   }
   return r;
 }
-function runPipeline2(exec, profile, spec, label, hostPath, container) {
+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");
@@ -43906,10 +44669,11 @@ function runPipeline2(exec, profile, spec, label, hostPath, container) {
     }
     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)),
+      findings: classifyResidue(label, diffManifests(m1, m3), attribution),
       installDelta,
-      baselineDigest: sha256Hex([...m1.keys()].join("\n"))
+      baselineDigest: sha256Hex2([...m1.keys()].join("\n"))
     };
   } finally {
     try {
@@ -43930,36 +44694,45 @@ 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 <spec> argument (got ${String(ctx.positionals.length)}); ${SCAN_SPEC_USAGE}`
+      `border roundtrip expects exactly one argument \u2014 a registry spec or a local artifact file (got ${String(ctx.positionals.length)}); ${SCAN_SPEC_USAGE}`
     );
   }
-  const spec = parseScanSpec(raw);
-  const profile = profileFor(spec.ecosystem);
+  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(join25(tmpdir3(), "border-roundtrip-"));
+  const baseDir = mkdtempSync5(join26(tmpdir3(), "border-roundtrip-"));
   try {
-    const { bytes } = await fetchArtifact(spec, { fetcher: deps.fetcher ?? defaultScanFetcher });
-    const hostPath = join25(baseDir, "artifact");
+    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 : sha256Hex2(bytes);
+    const hostPath = join26(baseDir, "artifact");
     writeFileSync7(hostPath, bytes);
     const container = containerNameFor(label);
-    const { findings, installDelta, baselineDigest } = runPipeline2(exec, profile, spec, label, hostPath, container);
+    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}`),
+      key: sha256Hex2(`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(" ")}`),
+      rulesHash: sha256Hex2(`${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();
@@ -43967,19 +44740,34 @@ async function runRoundtripCore(ctx, deps = {}) {
     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, sha256Hex(bytes), report.findings.length, report.findings.length === 0 ? "clean" : "residue");
+      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 {
@@ -44027,7 +44815,7 @@ 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 join27 } from "node:path";
+import { join as join28 } from "node:path";
 
 // src/scan/config.ts
 function buildScanConfigYaml(eco) {
@@ -44054,8 +44842,8 @@ function synthesizeScanConfig(eco) {
 }
 
 // src/scan/materialize.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync11, readdirSync as readdirSync10, readFileSync as readFileSync16, rmSync as rmSync13, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join26 } 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)`);
@@ -44072,12 +44860,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 join26(dir, dirs[0].name);
+    return join27(dir, dirs[0].name);
   }
   return dir;
 }
 function requireManifest(repoDir, ecosystem, candidates) {
-  if (!candidates.some((rel) => existsSync17(join26(repoDir, rel)))) {
+  if (!candidates.some((rel) => existsSync18(join27(repoDir, rel)))) {
     fail2(`${ecosystem} package tree has none of [${candidates.join(", ")}] at its root`);
   }
 }
@@ -44087,18 +44875,18 @@ function materializePackage(o) {
 `);
   });
   const safe = safeArtifactName(o.filename, `${o.ecosystem}-artifact`);
-  const archive = join26(o.baseDir, safe);
+  const archive = join27(o.baseDir, safe);
   writeFileSync8(archive, o.bytes);
-  const extractDir = join26(o.baseDir, "extract");
+  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] ?? join26(outer, "data.tar.gz");
-    if (!existsSync17(inner)) fail2(".gem archive contains no data.tar.gz");
-    const gemTree = join26(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);
@@ -44109,11 +44897,11 @@ function materializePackage(o) {
   } else {
     requireManifest(repoDir, o.ecosystem, ["Cargo.toml"]);
     for (const file2 of CRATES_ENVELOPE_FILES) {
-      const path4 = join26(repoDir, file2);
-      if (!existsSync17(path4)) continue;
+      const path4 = join27(repoDir, file2);
+      if (!existsSync18(path4)) continue;
       const original = readFileSync16(path4);
       rmSync13(path4, { force: true });
-      note(`border scan: crates envelope normalized: ${file2} sha256=${sha256Hex(original)}`);
+      note(`border scan: crates envelope normalized: ${file2} sha256=${sha256Hex2(original)}`);
     }
   }
   const env2 = o.env;
@@ -44139,7 +44927,7 @@ async function runScanCore(ctx, deps = {}) {
   }
   const cfg = synthesizeScanConfig(spec.ecosystem);
   const fetcher = deps.fetcher ?? defaultScanFetcher;
-  const baseDir = mkdtempSync6(join27(tmpdir4(), "border-scan-"));
+  const baseDir = mkdtempSync6(join28(tmpdir4(), "border-scan-"));
   try {
     const { bytes, filename } = await fetchArtifact(spec, { fetcher });
     const env2 = { ...ctx.env };
@@ -44150,12 +44938,12 @@ async function runScanCore(ctx, deps = {}) {
     const verdict = computeVerdict(findings);
     const report = {
       schemaVersion: 1,
-      key: sha256Hex(`scan:${spec.ecosystem}:${spec.name}@${spec.version}:${head}`),
+      key: sha256Hex2(`scan:${spec.ecosystem}:${spec.name}@${spec.version}:${head}`),
       head,
       dirty: false,
       exposureSet: [`${spec.ecosystem}:${spec.name}@${spec.version}`],
       refSet: [],
-      rulesHash: sha256Hex(buildScanConfigYaml(spec.ecosystem)),
+      rulesHash: sha256Hex2(buildScanConfigYaml(spec.ecosystem)),
       verdict,
       counts: countFindings(findings),
       findings,
@@ -44285,7 +45073,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 in a throwaway container, report uninstall 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)",