border-customs 0.7.1 → 0.8.1

package/dist/index.js

@@ -13029,7 +13029,7 @@ var require_micromatch = __commonJS({
 
 // src/index.ts
 import { realpathSync } from "node:fs";
-import { fileURLToPath as fileURLToPath6, pathToFileURL } from "node:url";
+import { fileURLToPath as fileURLToPath7, pathToFileURL } from "node:url";
 
 // src/cli.ts
 import { parseArgs } from "node:util";
@@ -37459,6 +37459,19 @@ function matchHostProfile(text, _o) {
   flush();
   return hits;
 }
+var BINDING_TOKEN = String.raw`\b(?:q` + "wen" + String.raw`|deep` + "seek" + String.raw`|kimi|g` + "lm" + String.raw`|ernie|dou` + "bao" + String.raw`|hunyuan|sp` + "ark" + String.raw`)[-\.\d][\w.-]*\b`;
+var BINDING_VENDOR_RE = new RegExp(BINDING_TOKEN, "gi");
+var BINDING_CONTEXT_RE = /(?:model|模型|default|默认|provider)/i;
+function matchMachineBinding(text, _o) {
+  const hits = [];
+  text.split("\n").forEach((body, idx) => {
+    if (!BINDING_CONTEXT_RE.test(body)) return;
+    for (const m of body.matchAll(BINDING_VENDOR_RE)) {
+      hits.push({ rule: "exfil-machine-binding", matched: m[0] ?? "", line: idx + 1, message: "Machine binding: a vendor inference-model id pinned next to model/default/provider context \u2014 device authorization belongs in operator-local config, not portable surfaces (L-MACHINE-LOCAL)." });
+    }
+  });
+  return hits;
+}
 
 // src/exfil/rules.ts
 var OCTET = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])";
@@ -38093,12 +38106,12 @@ function packOnce(o) {
     throw new EngineRunError(`npm pack reported '${report.filename}' but no tarball landed in ${o.distDir}`, null);
   }
   const data = readFileSync3(tarballAbs);
-  const sha2564 = createHash3("sha256").update(data).digest("hex");
+  const sha2563 = createHash3("sha256").update(data).digest("hex");
   const sha1 = createHash3("sha1").update(data).digest("hex");
   if (sha1 !== report.shasum || data.byteLength !== report.size) {
     throw new EngineRunError(`npm pack report disagrees with the tarball bytes for ${report.filename} \u2014 corrupted or swapped artifact, failing closed`, null);
   }
-  return { filename: report.filename, sha256: sha2564, bytes: data.byteLength, tarballAbs };
+  return { filename: report.filename, sha256: sha2563, bytes: data.byteLength, tarballAbs };
 }
 function publintFinding(o, tarballAbs, identity) {
   const candidates = o.publintBinPath !== void 0 ? [o.publintBinPath] : [
@@ -39141,7 +39154,7 @@ async function runNpmArtifactStage(o) {
   const stateDir = join10(repoDir, BORDER_STATE_DIR);
   const distDir = join10(stateDir, "dist");
   mkdirSync3(distDir, { recursive: true });
-  const { filename, sha256: sha2564, bytes, tarballAbs } = packOnce({
+  const { filename, sha256: sha2563, bytes, tarballAbs } = packOnce({
     repoDir,
     distDir,
     ...o.env !== void 0 ? { env: o.env } : {},
@@ -39149,7 +39162,7 @@ async function runNpmArtifactStage(o) {
     ...o.npmTimeoutMs !== void 0 ? { npmTimeoutMs: o.npmTimeoutMs } : {}
   });
   const findings = [];
-  const extractDir = join10(stateDir, "tmp", sha2564.slice(0, 8));
+  const extractDir = join10(stateDir, "tmp", sha2563.slice(0, 8));
   rmSync3(extractDir, { recursive: true, force: true });
   mkdirSync3(extractDir, { recursive: true });
   try {
@@ -39254,7 +39267,7 @@ async function runNpmArtifactStage(o) {
   if (publint !== null) findings.push(publint);
   return {
     findings,
-    artifact: { file: `${BORDER_STATE_DIR}/dist/${filename}`, sha256: sha2564, bytes }
+    artifact: { file: `${BORDER_STATE_DIR}/dist/${filename}`, sha256: sha2563, bytes }
   };
 }
 
@@ -39649,8 +39662,9 @@ async function computeCheckRulesHash(input2) {
     promptTemplatePaths: existsSync7(template) ? [template] : []
   });
 }
+var CHECK_LENS_ID = "range+tip-tree/1";
 function computeCheckKey(input2) {
-  return sha256(stableStringify({ ...input2 }));
+  return sha256(stableStringify({ ...input2, lens: CHECK_LENS_ID }));
 }
 
 // src/engines/trufflehog.ts
@@ -40354,9 +40368,9 @@ async function runRubygemsArtifactStage(o) {
     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 = readFileSync7(dist);
-  const sha2564 = createHash6("sha256").update(bytes).digest("hex");
+  const sha2563 = createHash6("sha256").update(bytes).digest("hex");
   const findings = [];
-  const extractDir = join12(stateDir, "tmp", sha2564.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`;
@@ -40434,7 +40448,7 @@ async function runRubygemsArtifactStage(o) {
   }
   return {
     findings,
-    artifact: { file: `${BORDER_STATE_DIR}/dist/${gemName}`, sha256: sha2564, bytes: bytes.length }
+    artifact: { file: `${BORDER_STATE_DIR}/dist/${gemName}`, sha256: sha2563, bytes: bytes.length }
   };
 }
 
@@ -41996,9 +42010,9 @@ async function runCargoArtifactStage(o) {
     const dist = join18(distDir, crateName);
     renameSync(packed, dist);
     const bytes = readFileSync11(dist);
-    const sha2564 = createHash11("sha256").update(bytes).digest("hex");
+    const sha2563 = createHash11("sha256").update(bytes).digest("hex");
     const findings = [];
-    const extractDir = join18(stateDir, "tmp", sha2564.slice(0, 8));
+    const extractDir = join18(stateDir, "tmp", sha2563.slice(0, 8));
     rmSync8(extractDir, { recursive: true, force: true });
     mkdirSync8(extractDir, { recursive: true });
     try {
@@ -42051,7 +42065,7 @@ async function runCargoArtifactStage(o) {
     }
     return {
       findings,
-      artifact: { file: `${BORDER_STATE_DIR}/dist/${crateName}`, sha256: sha2564, bytes: bytes.length }
+      artifact: { file: `${BORDER_STATE_DIR}/dist/${crateName}`, sha256: sha2563, bytes: bytes.length }
     };
   } finally {
     rmSync8(targetDir, { recursive: true, force: true });
@@ -42866,7 +42880,8 @@ function exposureSet(cfg, options = {}) {
 }
 
 // src/check.ts
-import { join as join23 } from "node:path";
+import { createHash as createHash15 } from "node:crypto";
+import { join as join25 } from "node:path";
 
 // src/rules/aiArtifacts.ts
 import { spawnSync as spawnSync12 } from "node:child_process";
@@ -43050,6 +43065,7 @@ function scanAiArtifacts(o) {
 
 // src/check/exclusions.ts
 import { resolve as resolve11 } from "node:path";
+var PATH_PATTERN_RULE_PREFIX = "path-pattern:";
 function toRepoRelative(path4, repoDir) {
   if (path4 === void 0 || path4 === "") return null;
   const abs = resolve11(repoDir, path4);
@@ -43062,6 +43078,21 @@ function isBorderStatePath(repoRelPath) {
 function filterBorderStateFindings(findings, repoDir) {
   return findings.filter((f) => !isBorderStatePath(toRepoRelative(f.path, repoDir)));
 }
+function suppressGateConfigPathPatterns(findings, repoDir, configSource) {
+  const kept = [];
+  let suppressed = 0;
+  const cfgAbs = configSource === void 0 ? "" : resolve11(configSource);
+  if (cfgAbs === "") return { kept: [...findings], suppressed: 0 };
+  for (const f of findings) {
+    const outer = (f.path ?? "").split("!")[0] ?? "";
+    if (f.rule.startsWith(PATH_PATTERN_RULE_PREFIX) && outer !== "" && resolve11(repoDir, outer) === cfgAbs) {
+      suppressed += 1;
+      continue;
+    }
+    kept.push(f);
+  }
+  return { kept, suppressed };
+}
 
 // src/check/allow.ts
 function scopePath(finding, repoDir) {
@@ -43122,7 +43153,8 @@ var EXFIL_RULE_IDS = [
   "exfil-ssh-target",
   "exfil-home-path",
   "exfil-cred-location",
-  "exfil-host-profile"
+  "exfil-host-profile",
+  "exfil-machine-binding"
 ];
 var EXFIL_MESSAGE_ID_SUFFIX = ":message";
 var EXFIL_TABLE_SEVERITY = {
@@ -43130,7 +43162,8 @@ var EXFIL_TABLE_SEVERITY = {
   "exfil-ssh-target": "HIGH",
   "exfil-home-path": "MEDIUM",
   "exfil-cred-location": "MEDIUM",
-  "exfil-host-profile": "MEDIUM"
+  "exfil-host-profile": "MEDIUM",
+  "exfil-machine-binding": "MEDIUM"
 };
 var EXFIL_HIGH_FAMILY = ["exfil-rfc1918", "exfil-ssh-target"];
 var EXFIL_SECRET_VALUE_RULES = EXFIL_HIGH_FAMILY;
@@ -43139,19 +43172,21 @@ var TWIN_HIGH = {
   "exfil-ssh-target": "CRITICAL",
   "exfil-home-path": null,
   "exfil-cred-location": null,
-  "exfil-host-profile": null
+  "exfil-host-profile": null,
+  "exfil-machine-binding": null
 };
 var NULL_ROW = {
   "exfil-rfc1918": null,
   "exfil-ssh-target": null,
   "exfil-home-path": null,
   "exfil-cred-location": null,
-  "exfil-host-profile": null
+  "exfil-host-profile": null,
+  "exfil-machine-binding": null
 };
 var EXFIL_MATRIX = {
   tree: {
     // native tree leg = MEDIUM family补发 only (v2 double-emission revoked).
-    native: { ...NULL_ROW, "exfil-home-path": "MEDIUM", "exfil-cred-location": "MEDIUM", "exfil-host-profile": "MEDIUM" },
+    native: { ...NULL_ROW, "exfil-home-path": "MEDIUM", "exfil-cred-location": "MEDIUM", "exfil-host-profile": "MEDIUM", "exfil-machine-binding": "MEDIUM" },
     // gitleaks.ts:81 hardcodes CRITICAL for every ingested finding.
     "gitleaks-twin": TWIN_HIGH,
     // secretlint.ts:299-309 has no HIGH rung — error maps to CRITICAL as-is.
@@ -43202,7 +43237,8 @@ var PREDICATES = {
   "exfil-ssh-target": matchSshTarget,
   "exfil-home-path": matchHomePath,
   "exfil-cred-location": matchCredLocation,
-  "exfil-host-profile": matchHostProfile
+  "exfil-host-profile": matchHostProfile,
+  "exfil-machine-binding": matchMachineBinding
 };
 function scanFacet(input2, facet) {
   const channel = "native";
@@ -43287,6 +43323,17 @@ function scanExfilTree(o) {
   return findings;
 }
 
+// src/check/tipTreeLens.ts
+import { mkdtempSync as mkdtempSync5, rmSync as rmSync12 } from "node:fs";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join24 } from "node:path";
+
+// src/commands/exfil.ts
+import { createHash as createHash14 } from "node:crypto";
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync4, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync5 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { dirname as dirname12, join as join23 } from "node:path";
+
 // src/check/messageScan.ts
 import { spawnSync as spawnSync13 } from "node:child_process";
 import { dirname as dirname10, resolve as resolve13 } from "node:path";
@@ -43404,44 +43451,6 @@ function scanCommitMessages(o) {
   return findings;
 }
 
-// src/check/proofValve.ts
-var ROUNDTRIP_PROOF_MISSING_RULE = "roundtrip-proof-missing";
-var ROUNDTRIP_PROOF_STALE_RULE = "roundtrip-proof-stale";
-var RESIDUE_RULE_IDS = new Set(Object.keys(RESIDUE_SEVERITIES));
-function hasBlockingResidueCapability(findings) {
-  return findings.some((f) => RESIDUE_RULE_IDS.has(f.rule) && isBlocking(f.severity));
-}
-function proofFinding(rule, art, cause) {
-  return {
-    rule,
-    severity: "CRITICAL",
-    target: "artifact",
-    path: art.file,
-    engine: "native",
-    message: `${art.file} (sha256 ${art.sha256.slice(0, 12)}\u2026) tripped the residue scan while residue.requireProof is on, but ${cause}. Run 'border roundtrip <spec>' for exactly these bytes to mint the ledger proof.`,
-    ...redact(`${art.sha256}:${cause}`),
-    snippet: `${art.file} ${art.sha256.slice(0, 12)}`
-  };
-}
-function proofFindings(o) {
-  const out = [];
-  for (const art of o.artifacts) {
-    const rec = latestRoundtripForSha(o.records, art.sha256);
-    if (rec === null) {
-      out.push(proofFinding(ROUNDTRIP_PROOF_MISSING_RULE, art, "no roundtrip proof record exists for its digest"));
-    } else if (rec.rulesHash !== o.rulesHash) {
-      out.push(
-        proofFinding(
-          ROUNDTRIP_PROOF_STALE_RULE,
-          art,
-          `its proof record predates the current rules policy (recorded ${rec.rulesHash.slice(0, 12)}\u2026, required ${o.rulesHash.slice(0, 12)}\u2026)`
-        )
-      );
-    }
-  }
-  return out;
-}
-
 // src/check/tagScan.ts
 import { spawnSync as spawnSync14 } from "node:child_process";
 import { mkdtempSync as mkdtempSync3, rmSync as rmSync10, writeFileSync as writeFileSync4 } from "node:fs";
@@ -43556,266 +43565,6 @@ function scanTagMessages(o) {
   }
 }
 
-// src/check.ts
-var TRACKED_BORDER_RULE = "repo-tracks-border-state";
-var GUARD_PATH_CAP = 50;
-function trackedBorderStateFinding(repoDir, headSha, env2) {
-  const listing = runGitChecked(repoDir, ["ls-files", "--", `${BORDER_STATE_DIR}/`], { ...env2 !== void 0 ? { env: env2 } : {} }).split("\n").filter((p) => p !== "");
-  if (listing.length === 0) return null;
-  const shown = listing.slice(0, GUARD_PATH_CAP);
-  const rest = listing.length - shown.length;
-  const [first = `${BORDER_STATE_DIR}/`] = shown;
-  const message = `repository tracks ${String(listing.length)} file(s) under ${BORDER_STATE_DIR}/ \u2014 border's state directory must stay untracked: ${shown.join(", ")}${rest > 0 ? ` (+${String(rest)} more)` : ""}. Remove with 'git rm -r --cached ${BORDER_STATE_DIR}/'.`;
-  return {
-    rule: TRACKED_BORDER_RULE,
-    severity: "CRITICAL",
-    target: "git",
-    path: first,
-    commit: headSha,
-    engine: "native",
-    message,
-    ...redact(`${headSha}:${BORDER_STATE_DIR}`),
-    snippet: `${BORDER_STATE_DIR}/ tracked`
-  };
-}
-function legOptions(o, sanitizer) {
-  return {
-    ...o.env !== void 0 ? { env: o.env } : {},
-    sanitizer
-  };
-}
-function historyRefRange(ctx) {
-  return ctx.refSet.length > 0 ? ctx.refSet.join(" ") : ctx.headSha;
-}
-async function executeCheck(o) {
-  const envOpt = o.env !== void 0 ? { env: o.env } : {};
-  const ctx = gatherContext(o.repoDir, envOpt);
-  const { handle, warning } = acquireLock(o.repoDir);
-  try {
-    return await runPipeline(o, ctx, warning);
-  } finally {
-    releaseLock(handle);
-  }
-}
-async function runPipeline(o, ctx, lockWarning) {
-  const repoDir = ctx.repoDir;
-  const envOpt = o.env !== void 0 ? { env: o.env } : {};
-  const findings = [];
-  const guard = trackedBorderStateFinding(repoDir, ctx.headSha, o.env);
-  const probe = await probeEngines(o.cfg, {
-    ...envOpt,
-    ...o.requireOverride !== void 0 ? { requireOverride: o.requireOverride } : {}
-  });
-  findings.push(...probe.findings);
-  if (guard !== null) findings.push(guard);
-  const broken = new Set(probe.findings.map((f) => f.engine));
-  const sanitizer = new TextSanitizer();
-  findings.push(...filterBorderStateFindings(detectHostileConfig({ repoDir, target: "git", ...envOpt }), repoDir));
-  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: join23(repoDir, BORDER_STATE_DIR), target: "tree", ...eng }), repoDir));
-    findings.push(...filterBorderStateFindings(scanTagMessages({ repoDir, target: "git", ...eng }), repoDir));
-  }
-  if (!broken.has("secretlint")) {
-    findings.push(...await scanGitTrackedFiles({ repoDir, target: "git", rules: o.cfg.rules, ...legOptions(o, sanitizer) }));
-  }
-  if (o.cfg.engines.trufflehog && !broken.has("trufflehog")) {
-    findings.push(...scanTrufflehog({ repoDir, target: "git", ...legOptions(o, sanitizer) }));
-  }
-  findings.push(...scanAiArtifacts({ repoDir, refSet: [...ctx.refSet], cfg: o.cfg.rules, ...envOpt }));
-  findings.push(...scanIdentity({ repoDir, refSet: [...ctx.refSet], cfg: o.cfg, ...envOpt }));
-  findings.push(...filterBorderStateFindings(scanExfilTree({ repoDir, hosts: o.cfg.rules.hosts, ...legOptions(o, sanitizer) }), repoDir));
-  findings.push(...filterBorderStateFindings(
-    scanCommitMessages({
-      repoDir,
-      refSet: ctx.refSet.length > 0 ? [...ctx.refSet] : [ctx.headSha],
-      remotes: o.cfg.targets.git.remotes,
-      hosts: o.cfg.rules.hosts,
-      ...legOptions(o, sanitizer)
-    }),
-    repoDir
-  ));
-  const ledgerArtifacts = [];
-  for (const channel of publishChannels()) {
-    if (!o.effectiveTargets.includes(channel.id) || !channel.configured(o.cfg)) continue;
-    const stage = await channel.stage({
-      repoDir,
-      cfg: o.cfg,
-      sanitizer,
-      ...envOpt,
-      skipGitleaks: broken.has("gitleaks"),
-      skipSecretlint: broken.has("secretlint")
-    });
-    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) {
-      const f = findings[i];
-      if (f !== void 0 && RESIDUE_RULE_IDS.has(f.rule)) findings.splice(i, 1);
-    }
-  }
-  const rulesHash = await computeCheckRulesHash({
-    engineVersions: probe.engineVersions,
-    configDigest: o.configDigest,
-    ...o.env !== void 0 ? { env: o.env } : {}
-  });
-  if (o.cfg.residue?.requireProof === true && ledgerArtifacts.length > 0 && hasBlockingResidueCapability(findings)) {
-    findings.push(...proofFindings({ artifacts: ledgerArtifacts, records: readLedger(repoDir).records, rulesHash }));
-  }
-  const exposure = [...exposureSet(o.cfg, { cwd: repoDir })];
-  const allow = applyAllowList(findings, o.cfg.allow, repoDir);
-  const report = {
-    schemaVersion: 1,
-    key: computeCheckKey({
-      headSha: ctx.headSha,
-      porcelainDigest: ctx.porcelainDigest,
-      rulesHash,
-      exposureSet: exposure,
-      refSet: ctx.refSet,
-      effectiveTargets: o.effectiveTargets
-    }),
-    head: ctx.headSha,
-    dirty: ctx.dirty,
-    exposureSet: exposure,
-    refSet: ctx.refSet,
-    rulesHash,
-    verdict: computeVerdict(allow.kept),
-    counts: countFindings(allow.kept),
-    findings: allow.kept,
-    ...allow.allowHits.length > 0 ? { allowHits: allow.allowHits } : {},
-    ts: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  return {
-    report,
-    ctx,
-    degraded: probe.degraded,
-    sanitizedSummary: sanitizeSummary(report, sanitizer),
-    lockWarning,
-    artifacts: ledgerArtifacts.length > 0 ? ledgerArtifacts : null
-  };
-}
-function sanitizeSummary(report, sanitizer) {
-  const lines = report.findings.map(
-    (f) => sanitizer.sanitize(`${f.severity} ${f.rule} ${f.engine} ${f.path ?? ""} ${f.commit ?? ""} ${f.message}`.replace(/\s+/g, " ").trim())
-  );
-  lines.unshift(sanitizer.sanitize(`border check ${report.verdict}: ${String(report.counts.total)} finding(s), ${String(report.counts.blocking)} blocking`));
-  return lines.join("\n");
-}
-
-// src/commands/check.ts
-async function runCheck(ctx) {
-  const env2 = ctx.env;
-  const load = loadConfig({
-    cwd: ctx.cwd,
-    ...ctx.flags.config !== void 0 ? { configPath: ctx.flags.config } : {},
-    ...env2 !== void 0 ? { env: env2 } : {}
-  });
-  for (const warning of load.warnings) ctx.stderr(`border: ${warning}`);
-  let effective;
-  if (load.kind === "loaded") {
-    effective = load;
-  } else if (load.explicit !== void 0) {
-    effective = { kind: "loaded", config: load.explicit.config, warnings: [], source: load.explicit.source };
-  } else {
-    if (ctx.flags.requireEngine !== void 0 && ctx.flags.requireEngine.length > 0) {
-      const probe = await probeEngines(NO_TARGETS_PROBE_CFG, {
-        requireOverride: ctx.flags.requireEngine,
-        ...env2 !== void 0 ? { env: env2 } : {}
-      });
-      if (probe.degraded) {
-        for (const finding of probe.findings) ctx.stderr(`border: ${finding.message}`);
-        return EXIT_ERROR;
-      }
-    }
-    ctx.stdout(`border: ${NO_OP_MESSAGE}`);
-    return EXIT_PASS;
-  }
-  const configDigest = computeConfigDigest(effective);
-  const repoDir = resolveRepoDir(ctx.cwd, { env: env2 });
-  const effectiveTargets = computeEffectiveTargets(effective.config, ctx.flags.targets);
-  if (!ctx.flags.force) {
-    const decision = await consultSkipLedger({
-      repoDir,
-      cfg: effective.config,
-      configDigest,
-      effectiveTargets,
-      llm: ctx.flags.llm,
-      ...env2 !== void 0 ? { env: env2 } : {},
-      ...ctx.flags.requireEngine !== void 0 && ctx.flags.requireEngine.length > 0 ? { requireOverride: ctx.flags.requireEngine } : {}
-    });
-    for (const warning of decision.warnings) ctx.stderr(`border: WARNING ${warning}`);
-    if (decision.skip !== null) {
-      ctx.stdout(formatSkipLine(decision.skip));
-      return exitCodeFromVerdict(decision.skip.verdict);
-    }
-  }
-  let outcome;
-  try {
-    outcome = await executeCheck({
-      repoDir,
-      cfg: effective.config,
-      configDigest,
-      effectiveTargets,
-      ...env2 !== void 0 ? { env: env2 } : {},
-      ...ctx.flags.requireEngine !== void 0 && ctx.flags.requireEngine.length > 0 ? { requireOverride: ctx.flags.requireEngine } : {}
-    });
-  } catch (err) {
-    if (err instanceof BorderLockHeldError) {
-      ctx.stderr(`border: ${err.message}`);
-      return EXIT_ERROR;
-    }
-    throw err;
-  }
-  if (outcome.lockWarning !== null) ctx.stderr(`border: WARNING ${outcome.lockWarning}`);
-  if (outcome.ctx.dirty) ctx.stderr("border: working tree is dirty \u2014 findings may reference uncommitted files");
-  if (ctx.flags.json) {
-    ctx.stdout(renderReportJson(outcome.report));
-  } else {
-    for (const line of outcome.sanitizedSummary.split("\n")) ctx.stdout(`border: ${line}`);
-  }
-  if (outcome.degraded) {
-    ctx.stderr("border: required engine(s) degraded \u2014 verdict is UNTRUSTWORTHY (exit 2 regardless of findings)");
-    return EXIT_ERROR;
-  }
-  recordCheckRun({
-    repoDir,
-    report: outcome.report,
-    ctx: outcome.ctx,
-    effectiveTargets,
-    llm: ctx.flags.llm,
-    artifacts: outcome.artifacts,
-    ...env2 !== void 0 ? { env: env2 } : {}
-  });
-  return exitCodeFromVerdict(outcome.report.verdict);
-}
-var NO_TARGETS_PROBE_CFG = {
-  version: 1,
-  targets: { git: { remotes: [] } },
-  rules: { authors: { emails: [], names: [] }, hosts: [], ips: [], pathPatterns: [], maxFileKB: 500 },
-  allow: [],
-  engines: { require: [], trufflehog: false }
-};
-
-// src/commands/exfil.ts
-import { createHash as createHash14 } from "node:crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync4, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync5 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname12, join as join24 } from "node:path";
-
 // src/commands/exfilGit.ts
 import { spawnSync as spawnSync15 } from "node:child_process";
 import { dirname as dirname11, resolve as resolve15 } from "node:path";
@@ -43933,7 +43682,7 @@ function scanBlobsNative(git, blobs) {
   }
   return findings;
 }
-async function scanTipTree(git, treeRoot, rev, env2) {
+async function scanTipTree(git, treeRoot, rev, env2, opts) {
   const blobs = tipTree(git, rev);
   const texts = blobTexts(git, blobs);
   const native = [];
@@ -43941,16 +43690,23 @@ async function scanTipTree(git, treeRoot, rev, env2) {
   for (const b of blobs) {
     const text = texts.get(b.sha);
     if (text === void 0) continue;
-    for (const f of scanTreeText({ text, source: b.path })) native.push(toTreeFinding(f));
+    for (const f of scanTreeText({
+      text,
+      source: b.path,
+      ...opts?.sanitizer !== void 0 ? { onMatch: (rawValue, valueDigest) => opts.sanitizer?.register(valueDigest, rawValue) } : {}
+    })) {
+      native.push(toTreeFinding(f));
+    }
     if (b.path.split("/").includes("..") || b.path === "") continue;
-    const abs = join24(treeRoot, b.path);
+    const abs = join23(treeRoot, b.path);
     if (existsSync15(abs)) continue;
     mkdirSync10(dirname12(abs), { recursive: true });
     writeFileSync5(abs, text, "utf8");
     written.push(b.path);
   }
-  const lint = (await scanPaths({ dir: treeRoot, files: written, target: "tree", env: env2 })).filter((f) => isExfilId(f.rule));
-  const gl = scanTree({ dir: treeRoot, stateDir: join24(treeRoot, ".border-state"), target: "tree", env: env2 }).filter((f) => isExfilId(f.rule)).map((f) => f.path !== void 0 && f.path.startsWith(`${treeRoot}/`) ? { ...f, path: f.path.slice(treeRoot.length + 1) } : f);
+  const eng = { ...opts?.sanitizer !== void 0 ? { sanitizer: opts.sanitizer } : {} };
+  const lint = opts?.skipSecretlint === true ? [] : (await scanPaths({ dir: treeRoot, files: written, target: "tree", env: env2, ...eng })).filter((f) => isExfilId(f.rule));
+  const gl = opts?.skipGitleaks === true ? [] : scanTree({ dir: treeRoot, stateDir: join23(treeRoot, ".border-state"), target: "tree", env: env2, ...eng }).filter((f) => isExfilId(f.rule)).map((f) => f.path !== void 0 && f.path.startsWith(`${treeRoot}/`) ? { ...f, path: f.path.slice(treeRoot.length + 1) } : f);
   return [...native, ...lint, ...gl];
 }
 function exfilRulesDigest() {
@@ -43983,7 +43739,7 @@ async function runExfilCore(ctx) {
     if (isUrl) {
       const url2 = first;
       exposure = [sanitizeUrl(url2)];
-      sandbox.dir = mkdtempSync4(join24(tmpdir3(), "border-exfil-"));
+      sandbox.dir = mkdtempSync4(join23(tmpdir3(), "border-exfil-"));
       const git2 = makeGit(sandbox.dir, ctx.env);
       git2.run(["init", "-q"]);
       git2.run(["remote", "add", "origin", url2]);
@@ -44000,7 +43756,7 @@ async function runExfilCore(ctx) {
       units = positionals.map((ref) => ({ label: ref, rev: git2.run(["rev-parse", "--verify", ref]).trim() }));
     }
     const git = makeGit(repoDir, ctx.env);
-    sandbox.tree = mkdtempSync4(join24(tmpdir3(), "border-exfil-tree-"));
+    sandbox.tree = mkdtempSync4(join23(tmpdir3(), "border-exfil-tree-"));
     const findings = [];
     const seenBlob = /* @__PURE__ */ new Set();
     for (const unit of units) {
@@ -44060,15 +43816,361 @@ async function runExfilCore(ctx) {
 }
 var runExfil = (ctx) => runExfilCore(ctx);
 
+// src/check/tipTreeLens.ts
+async function scanTipTreeLens(o) {
+  const env2 = o.env ?? process.env;
+  const git = makeGit(o.repoDir, env2);
+  const treeRoot = mkdtempSync5(join24(tmpdir4(), "border-check-tip-tree-"));
+  try {
+    return await scanTipTree(git, treeRoot, o.rev, env2, {
+      ...o.sanitizer !== void 0 ? { sanitizer: o.sanitizer } : {},
+      ...o.skipGitleaks === true ? { skipGitleaks: true } : {},
+      ...o.skipSecretlint === true ? { skipSecretlint: true } : {}
+    });
+  } finally {
+    rmSync12(treeRoot, { recursive: true, force: true });
+  }
+}
+
+// src/check/proofValve.ts
+var ROUNDTRIP_PROOF_MISSING_RULE = "roundtrip-proof-missing";
+var ROUNDTRIP_PROOF_STALE_RULE = "roundtrip-proof-stale";
+var RESIDUE_RULE_IDS = new Set(Object.keys(RESIDUE_SEVERITIES));
+function hasBlockingResidueCapability(findings) {
+  return findings.some((f) => RESIDUE_RULE_IDS.has(f.rule) && isBlocking(f.severity));
+}
+function proofFinding(rule, art, cause) {
+  return {
+    rule,
+    severity: "CRITICAL",
+    target: "artifact",
+    path: art.file,
+    engine: "native",
+    message: `${art.file} (sha256 ${art.sha256.slice(0, 12)}\u2026) tripped the residue scan while residue.requireProof is on, but ${cause}. Run 'border roundtrip <spec>' for exactly these bytes to mint the ledger proof.`,
+    ...redact(`${art.sha256}:${cause}`),
+    snippet: `${art.file} ${art.sha256.slice(0, 12)}`
+  };
+}
+function proofFindings(o) {
+  const out = [];
+  for (const art of o.artifacts) {
+    const rec = latestRoundtripForSha(o.records, art.sha256);
+    if (rec === null) {
+      out.push(proofFinding(ROUNDTRIP_PROOF_MISSING_RULE, art, "no roundtrip proof record exists for its digest"));
+    } else if (rec.rulesHash !== o.rulesHash) {
+      out.push(
+        proofFinding(
+          ROUNDTRIP_PROOF_STALE_RULE,
+          art,
+          `its proof record predates the current rules policy (recorded ${rec.rulesHash.slice(0, 12)}\u2026, required ${o.rulesHash.slice(0, 12)}\u2026)`
+        )
+      );
+    }
+  }
+  return out;
+}
+
+// src/check.ts
+var TRACKED_BORDER_RULE = "repo-tracks-border-state";
+var GUARD_PATH_CAP = 50;
+function trackedBorderStateFinding(repoDir, headSha, env2) {
+  const listing = runGitChecked(repoDir, ["ls-files", "--", `${BORDER_STATE_DIR}/`], { ...env2 !== void 0 ? { env: env2 } : {} }).split("\n").filter((p) => p !== "");
+  if (listing.length === 0) return null;
+  const shown = listing.slice(0, GUARD_PATH_CAP);
+  const rest = listing.length - shown.length;
+  const [first = `${BORDER_STATE_DIR}/`] = shown;
+  const message = `repository tracks ${String(listing.length)} file(s) under ${BORDER_STATE_DIR}/ \u2014 border's state directory must stay untracked: ${shown.join(", ")}${rest > 0 ? ` (+${String(rest)} more)` : ""}. Remove with 'git rm -r --cached ${BORDER_STATE_DIR}/'.`;
+  return {
+    rule: TRACKED_BORDER_RULE,
+    severity: "CRITICAL",
+    target: "git",
+    path: first,
+    commit: headSha,
+    engine: "native",
+    message,
+    ...redact(`${headSha}:${BORDER_STATE_DIR}`),
+    snippet: `${BORDER_STATE_DIR}/ tracked`
+  };
+}
+function legOptions(o, sanitizer) {
+  return {
+    ...o.env !== void 0 ? { env: o.env } : {},
+    sanitizer
+  };
+}
+function lensIdentity(f) {
+  return `${f.rule}\0${f.engine}\0${f.path ?? ""}\0${String(f.line ?? -1)}\0${f.valueDigest}`;
+}
+function historyRefRange(ctx) {
+  return ctx.refSet.length > 0 ? ctx.refSet.join(" ") : ctx.headSha;
+}
+async function executeCheck(o) {
+  const envOpt = o.env !== void 0 ? { env: o.env } : {};
+  const ctx = gatherContext(o.repoDir, envOpt);
+  const { handle, warning } = acquireLock(o.repoDir);
+  try {
+    return await runPipeline(o, ctx, warning);
+  } finally {
+    releaseLock(handle);
+  }
+}
+async function runPipeline(o, ctx, lockWarning) {
+  const repoDir = ctx.repoDir;
+  const envOpt = o.env !== void 0 ? { env: o.env } : {};
+  const findings = [];
+  const guard = trackedBorderStateFinding(repoDir, ctx.headSha, o.env);
+  const probe = await probeEngines(o.cfg, {
+    ...envOpt,
+    ...o.requireOverride !== void 0 ? { requireOverride: o.requireOverride } : {}
+  });
+  findings.push(...probe.findings);
+  if (guard !== null) findings.push(guard);
+  const broken = new Set(probe.findings.map((f) => f.engine));
+  const sanitizer = new TextSanitizer();
+  findings.push(...filterBorderStateFindings(detectHostileConfig({ repoDir, target: "git", ...envOpt }), repoDir));
+  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: join25(repoDir, BORDER_STATE_DIR), target: "tree", ...eng }), repoDir));
+    findings.push(...filterBorderStateFindings(scanTagMessages({ repoDir, target: "git", ...eng }), repoDir));
+  }
+  if (!broken.has("secretlint")) {
+    findings.push(...await scanGitTrackedFiles({ repoDir, target: "git", rules: o.cfg.rules, ...legOptions(o, sanitizer) }));
+  }
+  if (o.cfg.engines.trufflehog && !broken.has("trufflehog")) {
+    findings.push(...scanTrufflehog({ repoDir, target: "git", ...legOptions(o, sanitizer) }));
+  }
+  findings.push(...scanAiArtifacts({ repoDir, refSet: [...ctx.refSet], cfg: o.cfg.rules, ...envOpt }));
+  findings.push(...scanIdentity({ repoDir, refSet: [...ctx.refSet], cfg: o.cfg, ...envOpt }));
+  findings.push(...filterBorderStateFindings(scanExfilTree({ repoDir, hosts: o.cfg.rules.hosts, ...legOptions(o, sanitizer) }), repoDir));
+  findings.push(...filterBorderStateFindings(
+    scanCommitMessages({
+      repoDir,
+      refSet: ctx.refSet.length > 0 ? [...ctx.refSet] : [ctx.headSha],
+      remotes: o.cfg.targets.git.remotes,
+      hosts: o.cfg.rules.hosts,
+      ...legOptions(o, sanitizer)
+    }),
+    repoDir
+  ));
+  if (o.effectiveTargets.includes("git")) {
+    const tip = await scanTipTreeLens({
+      repoDir,
+      rev: ctx.headSha,
+      ...envOpt,
+      sanitizer,
+      skipGitleaks: broken.has("gitleaks"),
+      skipSecretlint: broken.has("secretlint")
+    });
+    const seen = new Set(findings.map(lensIdentity));
+    for (const f of filterBorderStateFindings(tip, repoDir)) {
+      const id = lensIdentity(f);
+      if (seen.has(id)) continue;
+      seen.add(id);
+      findings.push(f);
+    }
+  }
+  const ledgerArtifacts = [];
+  for (const channel of publishChannels()) {
+    if (!o.effectiveTargets.includes(channel.id) || !channel.configured(o.cfg)) continue;
+    const stage = await channel.stage({
+      repoDir,
+      cfg: o.cfg,
+      sanitizer,
+      ...envOpt,
+      skipGitleaks: broken.has("gitleaks"),
+      skipSecretlint: broken.has("secretlint")
+    });
+    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) {
+      const f = findings[i];
+      if (f !== void 0 && RESIDUE_RULE_IDS.has(f.rule)) findings.splice(i, 1);
+    }
+  }
+  const rulesHash = await computeCheckRulesHash({
+    engineVersions: probe.engineVersions,
+    configDigest: o.configDigest,
+    ...o.env !== void 0 ? { env: o.env } : {}
+  });
+  if (o.cfg.residue?.requireProof === true && ledgerArtifacts.length > 0 && hasBlockingResidueCapability(findings)) {
+    findings.push(...proofFindings({ artifacts: ledgerArtifacts, records: readLedger(repoDir).records, rulesHash }));
+  }
+  const exposure = [...exposureSet(o.cfg, { cwd: repoDir })];
+  const cfgExempt = suppressGateConfigPathPatterns(findings, repoDir, o.configSource);
+  if (cfgExempt.suppressed > 0) {
+    findings.length = 0;
+    findings.push(...cfgExempt.kept);
+    findings.push({
+      rule: "gate-config-path-exempt",
+      severity: "INFO",
+      target: "config",
+      ...o.configSource !== void 0 ? { path: o.configSource } : {},
+      engine: "native",
+      message: `${String(cfgExempt.suppressed)} path-pattern finding(s) suppressed for the gate's own config file (self-referential rule-ID bytes; credential engines still cover it)`,
+      valueDigest: createHash15("sha256").update(`gate-config-exempt:${String(o.configSource)}`).digest("hex"),
+      snippet: "gate-config-path-exempt"
+    });
+  }
+  const allow = applyAllowList(findings, o.cfg.allow, repoDir);
+  const report = {
+    schemaVersion: 1,
+    key: computeCheckKey({
+      headSha: ctx.headSha,
+      porcelainDigest: ctx.porcelainDigest,
+      rulesHash,
+      exposureSet: exposure,
+      refSet: ctx.refSet,
+      effectiveTargets: o.effectiveTargets
+    }),
+    head: ctx.headSha,
+    dirty: ctx.dirty,
+    exposureSet: exposure,
+    refSet: ctx.refSet,
+    rulesHash,
+    verdict: computeVerdict(allow.kept),
+    counts: countFindings(allow.kept),
+    findings: allow.kept,
+    ...allow.allowHits.length > 0 ? { allowHits: allow.allowHits } : {},
+    ts: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    report,
+    ctx,
+    degraded: probe.degraded,
+    sanitizedSummary: sanitizeSummary(report, sanitizer),
+    lockWarning,
+    artifacts: ledgerArtifacts.length > 0 ? ledgerArtifacts : null
+  };
+}
+function sanitizeSummary(report, sanitizer) {
+  const lines = report.findings.map(
+    (f) => sanitizer.sanitize(`${f.severity} ${f.rule} ${f.engine} ${f.path ?? ""} ${f.commit ?? ""} ${f.message}`.replace(/\s+/g, " ").trim())
+  );
+  lines.unshift(sanitizer.sanitize(`border check ${report.verdict}: ${String(report.counts.total)} finding(s), ${String(report.counts.blocking)} blocking`));
+  return lines.join("\n");
+}
+
+// src/commands/check.ts
+async function runCheck(ctx) {
+  const env2 = ctx.env;
+  const load = loadConfig({
+    cwd: ctx.cwd,
+    ...ctx.flags.config !== void 0 ? { configPath: ctx.flags.config } : {},
+    ...env2 !== void 0 ? { env: env2 } : {}
+  });
+  for (const warning of load.warnings) ctx.stderr(`border: ${warning}`);
+  let effective;
+  if (load.kind === "loaded") {
+    effective = load;
+  } else if (load.explicit !== void 0) {
+    effective = { kind: "loaded", config: load.explicit.config, warnings: [], source: load.explicit.source };
+  } else {
+    if (ctx.flags.requireEngine !== void 0 && ctx.flags.requireEngine.length > 0) {
+      const probe = await probeEngines(NO_TARGETS_PROBE_CFG, {
+        requireOverride: ctx.flags.requireEngine,
+        ...env2 !== void 0 ? { env: env2 } : {}
+      });
+      if (probe.degraded) {
+        for (const finding of probe.findings) ctx.stderr(`border: ${finding.message}`);
+        return EXIT_ERROR;
+      }
+    }
+    ctx.stdout(`border: ${NO_OP_MESSAGE}`);
+    return EXIT_PASS;
+  }
+  const configDigest = computeConfigDigest(effective);
+  const repoDir = resolveRepoDir(ctx.cwd, { env: env2 });
+  const effectiveTargets = computeEffectiveTargets(effective.config, ctx.flags.targets);
+  if (!ctx.flags.force) {
+    const decision = await consultSkipLedger({
+      repoDir,
+      cfg: effective.config,
+      configDigest,
+      effectiveTargets,
+      llm: ctx.flags.llm,
+      ...env2 !== void 0 ? { env: env2 } : {},
+      ...ctx.flags.requireEngine !== void 0 && ctx.flags.requireEngine.length > 0 ? { requireOverride: ctx.flags.requireEngine } : {}
+    });
+    for (const warning of decision.warnings) ctx.stderr(`border: WARNING ${warning}`);
+    if (decision.skip !== null) {
+      ctx.stdout(formatSkipLine(decision.skip));
+      return exitCodeFromVerdict(decision.skip.verdict);
+    }
+  }
+  let outcome;
+  try {
+    outcome = await executeCheck({
+      repoDir,
+      cfg: effective.config,
+      configDigest,
+      effectiveTargets,
+      ...env2 !== void 0 ? { env: env2 } : {},
+      ...ctx.flags.requireEngine !== void 0 && ctx.flags.requireEngine.length > 0 ? { requireOverride: ctx.flags.requireEngine } : {},
+      // config self-exemption binds to a REAL file path only — the "git-remote"/
+      // "<...>" source sentinels must never resolve onto a scanned content path.
+      .../^\/.*$/.test(effective.source) && !effective.source.startsWith("<") ? { configSource: effective.source } : {}
+    });
+  } catch (err) {
+    if (err instanceof BorderLockHeldError) {
+      ctx.stderr(`border: ${err.message}`);
+      return EXIT_ERROR;
+    }
+    throw err;
+  }
+  if (outcome.lockWarning !== null) ctx.stderr(`border: WARNING ${outcome.lockWarning}`);
+  if (outcome.ctx.dirty) ctx.stderr("border: working tree is dirty \u2014 findings may reference uncommitted files");
+  if (ctx.flags.json) {
+    ctx.stdout(renderReportJson(outcome.report));
+  } else {
+    for (const line of outcome.sanitizedSummary.split("\n")) ctx.stdout(`border: ${line}`);
+  }
+  if (outcome.degraded) {
+    ctx.stderr("border: required engine(s) degraded \u2014 verdict is UNTRUSTWORTHY (exit 2 regardless of findings)");
+    return EXIT_ERROR;
+  }
+  recordCheckRun({
+    repoDir,
+    report: outcome.report,
+    ctx: outcome.ctx,
+    effectiveTargets,
+    llm: ctx.flags.llm,
+    artifacts: outcome.artifacts,
+    ...env2 !== void 0 ? { env: env2 } : {}
+  });
+  return exitCodeFromVerdict(outcome.report.verdict);
+}
+var NO_TARGETS_PROBE_CFG = {
+  version: 1,
+  targets: { git: { remotes: [] } },
+  rules: { authors: { emails: [], names: [] }, hosts: [], ips: [], pathPatterns: [], maxFileKB: 500 },
+  allow: [],
+  engines: { require: [], trufflehog: false }
+};
+
 // src/llm/bundle.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname14, join as join26 } from "node:path";
+import { dirname as dirname14, join as join27 } from "node:path";
 
 // src/llm/diff.ts
 import { spawnSync as spawnSync16 } from "node:child_process";
-import { mkdtempSync as mkdtempSync5, rmSync as rmSync12, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname13, join as join25, resolve as resolve16 } from "node:path";
+import { mkdtempSync as mkdtempSync6, rmSync as rmSync13, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname13, join as join26, resolve as resolve16 } from "node:path";
 var GIT_DIFF_MAX_BUFFER = 64 * 1024 * 1024;
 function gitOut(repoDir, args, o, allowFail = false) {
   const abs = resolve16(repoDir);
@@ -44165,24 +44267,24 @@ function collectRawDeltas(repoDir, baseSha, headSha, o = {}) {
 var MASK_CHUNK_CHARS = 2e6;
 function maskViaEngineDetection(repoDir, texts, o = {}) {
   const sanitizer = new TextSanitizer();
-  const sandbox = mkdtempSync5(join25(repoDir, BORDER_STATE_DIR, "llm-mask-"));
+  const sandbox = mkdtempSync6(join26(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) {
-        writeFileSync6(join25(sandbox, `detect-${String(idx)}.txt`), text.slice(off, off + MASK_CHUNK_CHARS), "utf8");
+        writeFileSync6(join26(sandbox, `detect-${String(idx)}.txt`), text.slice(off, off + MASK_CHUNK_CHARS), "utf8");
       }
     }
     scanTree({
       dir: sandbox,
-      stateDir: join25(repoDir, BORDER_STATE_DIR),
+      stateDir: join26(repoDir, BORDER_STATE_DIR),
       target: "llm-mask",
       sanitizer,
       ...engineEnv(o)
     });
   } finally {
-    rmSync12(sandbox, { recursive: true, force: true });
+    rmSync13(sandbox, { recursive: true, force: true });
   }
   return (text) => sanitizer.sanitize(text);
 }
@@ -44234,7 +44336,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 = join26(repoDir, record2.reportPath);
+  const absReport = join27(repoDir, record2.reportPath);
   if (!existsSync16(absReport)) {
     ctx.stderr(`border: llm-request: report archive missing (${record2.reportPath} pruned?) \u2014 run 'border check' again`);
     return EXIT_ERROR;
@@ -44291,9 +44393,9 @@ async function runLlmRequestCore(ctx) {
     fileDeltas,
     artifacts: record2.artifacts,
     deterministic: { verdict: report.verdict, counts: report.counts, findings: report.findings },
-    promptTemplate: { path: templatePath, sha256: createHash15("sha256").update(readFileSync16(templatePath)).digest("hex") }
+    promptTemplate: { path: templatePath, sha256: createHash16("sha256").update(readFileSync16(templatePath)).digest("hex") }
   };
-  const outPath = join26(dirname14(absReport), "llm-request.json");
+  const outPath = join27(dirname14(absReport), "llm-request.json");
   mkdirSync11(dirname14(outPath), { recursive: true });
   writeFileSync7(outPath, `${JSON.stringify(bundle, null, 2)}
 `, "utf8");
@@ -44303,14 +44405,14 @@ async function runLlmRequestCore(ctx) {
 }
 
 // src/llm/ingest.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 import { existsSync as existsSync17, readFileSync as readFileSync17, readdirSync as readdirSync9 } from "node:fs";
-import { isAbsolute, join as join27, resolve as resolve17 } from "node:path";
+import { isAbsolute, join as join28, resolve as resolve17 } 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"]);
 function sha2562(text) {
-  return createHash16("sha256").update(text, "utf8").digest("hex");
+  return createHash17("sha256").update(text, "utf8").digest("hex");
 }
 function usageError(ctx, why) {
   ctx.stderr(`border: llm-ingest: ${why}`);
@@ -44324,7 +44426,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 = join27(runsDir(repoDir), d, "llm-request.json");
+    const p = join28(runsDir(repoDir), d, "llm-request.json");
     if (!existsSync17(p)) continue;
     let parsed;
     try {
@@ -44337,7 +44439,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: join27(runsDir(repoDir), d), bundle: b };
+    return { dir: join28(runsDir(repoDir), d), bundle: b };
   }
   return "no llm-request bundle found \u2014 run 'border llm-request' first";
 }
@@ -44482,43 +44584,551 @@ async function runLlmRequest(ctx) {
 }
 
 // src/commands/opencode.ts
-import { createHash as createHash17 } from "node:crypto";
-import { existsSync as existsSync18, lstatSync, mkdirSync as mkdirSync12, readFileSync as readFileSync18, rmSync as rmSync13, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync22, lstatSync, mkdirSync as mkdirSync12, readFileSync as readFileSync20, rmSync as rmSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname16, join as join32 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+
+// src/opencode/inspect.ts
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "node:fs";
+import { join as join31 } from "node:path";
+
+// src/opencode/jsonconfig.ts
+import { existsSync as existsSync19, readdirSync as readdirSync10, readFileSync as readFileSync18 } from "node:fs";
+import { join as join30 } from "node:path";
+
+// src/opencode/contract.ts
+import { createHash as createHash18 } from "node:crypto";
+import { existsSync as existsSync18 } from "node:fs";
 import os3 from "node:os";
-import { dirname as dirname15, join as join28 } from "node:path";
+import { dirname as dirname15, join as join29 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 var PLUGIN_MARKER = "// border-opencode-plugin v";
 var COMMAND_MARKER = "<!-- border-opencode-command -->";
+var BORDER_PACKAGE = "border-customs";
+var DEFAULT_REGISTRY_BASE = "https://registry.npmjs.org";
+var REGISTRY_TIMEOUT_MS2 = 15e3;
+function sha256Hex3(bytes) {
+  return createHash18("sha256").update(bytes).digest("hex");
+}
+function firstLine(bytes) {
+  const text = bytes.toString("utf8");
+  const newline = text.indexOf("\n");
+  return newline < 0 ? text : text.slice(0, newline);
+}
 function opencodeConfigRoot(env2) {
   const xdg = env2["XDG_CONFIG_HOME"] ?? "";
   if (xdg.length > 0) return xdg;
   const home = env2["HOME"] ?? "";
-  return join28(home.length > 0 ? home : os3.homedir(), ".config");
+  return join29(home.length > 0 ? home : os3.homedir(), ".config");
 }
-function resolvePluginAsset(moduleUrl, fileName) {
+function opencodeCacheRoot(env2) {
+  const xdg = env2["XDG_CACHE_HOME"] ?? "";
+  const base = xdg.length > 0 ? xdg : join29(env2["HOME"] ?? os3.homedir(), ".cache");
+  return join29(base, "opencode", "packages");
+}
+function routeAPluginPath(env2) {
+  return join29(opencodeConfigRoot(env2), "opencode", "plugins", "border.ts");
+}
+function packagedAssetPath(moduleUrl, fileName) {
   const here = dirname15(fileURLToPath5(moduleUrl));
   const candidates = [
-    join28(here, "..", "plugin", fileName),
-    // dist mode (bundled): <root>/plugin/<f>
-    join28(here, "..", "..", "plugin", fileName)
+    join29(here, "..", "plugin", fileName),
+    // dist (bundled) mode: <root>/plugin/<f>
+    join29(here, "..", "..", "plugin", fileName)
     // src mode: <root>/plugin/<f>
   ];
   return candidates.find((p) => existsSync18(p)) ?? candidates[1];
 }
-function targetsFor(env2) {
-  const root = join28(opencodeConfigRoot(env2), "opencode");
-  return [
-    { fileName: "border.ts", destination: join28(root, "plugins", "border.ts"), marker: PLUGIN_MARKER },
-    { fileName: "border-command.md", destination: join28(root, "commands", "border.md"), marker: COMMAND_MARKER }
+function packagedDistEntry(moduleUrl) {
+  const here = dirname15(fileURLToPath5(moduleUrl));
+  const candidates = [
+    join29(here, "index.js"),
+    // dist (bundled) mode: <root>/dist/index.js
+    join29(here, "..", "dist", "index.js"),
+    // src/opencode mode one level under root
+    join29(here, "..", "..", "dist", "index.js")
+    // src mode: <root>/dist/index.js
   ];
+  return candidates.find((p) => existsSync18(p)) ?? candidates[2];
 }
-function sha2563(bytes) {
-  return createHash17("sha256").update(bytes).digest("hex");
+
+// src/opencode/jsonconfig.ts
+function stripJsoncComments(text) {
+  let out = "";
+  let inString = false;
+  let inLine = false;
+  let inBlock = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    const next = text[i + 1] ?? "";
+    if (inLine) {
+      if (ch === "\n") {
+        inLine = false;
+        out += ch;
+      }
+      continue;
+    }
+    if (inBlock) {
+      if (ch === "*" && next === "/") {
+        inBlock = false;
+        i += 1;
+        out += " ";
+      }
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") {
+        out += ch + next;
+        i += 1;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      out += ch;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLine = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlock = true;
+      i += 1;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
 }
-function firstLine(bytes) {
-  const text = bytes.toString("utf8");
-  const newline = text.indexOf("\n");
-  return newline < 0 ? text : text.slice(0, newline);
+function parseJsonc(text) {
+  return JSON.parse(stripJsoncComments(text).replace(/,(\s*[}\]])/g, "$1"));
+}
+var isRecord2 = (v) => typeof v === "object" && v !== null;
+function splitNpmSpec(entry) {
+  const at = entry.lastIndexOf("@");
+  if (at <= 0) return { name: entry, spec: null };
+  return { name: entry.slice(0, at), spec: entry.slice(at + 1) };
+}
+function readPluginDeclarations(path4, pkg) {
+  const none = { path: path4, status: "absent", specs: [] };
+  let text;
+  try {
+    if (!existsSync19(path4)) return none;
+    text = readFileSync18(path4, "utf8");
+  } catch {
+    return { path: path4, status: "error", specs: [] };
+  }
+  let parsed;
+  try {
+    parsed = parseJsonc(text);
+  } catch {
+    return { path: path4, status: "error", specs: [] };
+  }
+  if (!isRecord2(parsed)) return { path: path4, status: "error", specs: [] };
+  const plugin = Array.isArray(parsed["plugin"]) ? parsed["plugin"] : [];
+  const specs = plugin.filter((e) => typeof e === "string" && splitNpmSpec(e).name === pkg);
+  return { path: path4, status: "ok", specs };
+}
+function listCacheDirs(cacheRoot, pkg) {
+  let names;
+  try {
+    names = readdirSync10(cacheRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith(`${pkg}@`)).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+  return names.map((name) => {
+    const pkgRoot = join30(cacheRoot, name, "node_modules", pkg);
+    let packageVersion = null;
+    try {
+      const meta3 = parseJsonc(readFileSync18(join30(pkgRoot, "package.json"), "utf8"));
+      if (isRecord2(meta3) && typeof meta3["version"] === "string") packageVersion = meta3["version"];
+    } catch {
+      packageVersion = null;
+    }
+    let markerLine = null;
+    try {
+      markerLine = firstLine(readFileSync18(join30(pkgRoot, "plugin", "border.ts")));
+    } catch {
+      markerLine = null;
+    }
+    const markerVersion = markerLine !== null && markerLine.startsWith(PLUGIN_MARKER) ? markerLine.slice(PLUGIN_MARKER.length).trim() : null;
+    return { dir: join30(cacheRoot, name), tag: name.slice(pkg.length + 1), packageVersion, markerVersion, markerLine };
+  });
+}
+
+// src/opencode/aspects/cacheVersion.ts
+var isExactVersion = (spec) => /^\d+\.\d+\.\d+([-+].*)?$/.test(spec);
+function verifyCacheVersion(facts) {
+  const id = "cache-version";
+  const { cacheDirs, configs, cacheRoot, pkg } = facts;
+  const errored = configs.filter((c) => c.status === "error").map((c) => c.path);
+  const declared = configs.some((c) => c.specs.length > 0);
+  const where = configs.map((c) => `${c.path} [${c.status}]`).join(", ");
+  if (cacheDirs.length === 0) {
+    if (errored.length > 0) {
+      return { id, verdict: "CANNOT", detail: `no cache directory under ${cacheRoot} and the configuration is unreadable (${errored.join(", ")}) \u2014 cannot tell whether a Route-B load is claimed` };
+    }
+    if (declared) {
+      return { id, verdict: "CANNOT", detail: `NOT-CACHED: ${pkg} is declared (${configs.flatMap((c) => [...c.specs]).join(", ")}) but no cache directory exists under ${cacheRoot} \u2014 the load claim has no bytes behind it` };
+    }
+    return { id, verdict: "PASS", detail: `no ${pkg} cache directory under ${cacheRoot} and none declared (${where}) \u2014 Route B not in use, nothing to be stale` };
+  }
+  const pins = new Set(
+    configs.flatMap((c) => [...c.specs]).map((s) => splitNpmSpec(s).spec).filter((s) => s !== null && isExactVersion(s))
+  );
+  const problems = [];
+  for (const d of cacheDirs) {
+    if (d.packageVersion === null) {
+      problems.push(`${d.dir}: package.json missing or unreadable`);
+    }
+    if (d.markerLine === null) {
+      problems.push(`${d.dir}: plugin/border.ts missing or unreadable in the cached package`);
+    } else if (d.markerVersion === null) {
+      problems.push(`${d.dir}: plugin/border.ts first line lacks the marker '${PLUGIN_MARKER}'`);
+    } else if (d.packageVersion !== null && d.markerVersion !== d.packageVersion) {
+      problems.push(`${d.dir}: marker says ${d.markerVersion}, package.json says ${d.packageVersion}`);
+    }
+    if (pins.has(d.tag) && d.packageVersion !== null && d.packageVersion !== d.tag) {
+      problems.push(`${d.dir}: cached under exact spec '${d.tag}' but the package reports ${d.packageVersion}`);
+    }
+  }
+  if (problems.length > 0) {
+    return { id, verdict: "FAIL", detail: problems.join("; ") };
+  }
+  return {
+    id,
+    verdict: "PASS",
+    detail: `cache self-consistent: ${cacheDirs.map((d) => `${d.tag}->${d.packageVersion ?? "?"}`).join(", ")}`
+  };
+}
+
+// src/opencode/aspects/dualRoute.ts
+function verifyDualRoute(facts) {
+  const id = "dual-route";
+  const { configs, routeAInstalled, routeAPlugin, pkg } = facts;
+  const errored = configs.filter((c) => c.status === "error").map((c) => c.path);
+  if (errored.length > 0) {
+    return { id, verdict: "CANNOT", detail: `configuration unreadable (${errored.join(", ")}) \u2014 Route B presence cannot be counted` };
+  }
+  const declared = configs.flatMap((c) => [...c.specs]);
+  const hasB = declared.length > 0;
+  if (routeAInstalled && hasB) {
+    return {
+      id,
+      verdict: "FAIL",
+      detail: `both routes registered: Route A drop at ${routeAPlugin} AND Route B declaration ${declared.map((d) => `'${d}'`).join(", ")} \u2014 pick exactly one route (the dual-registration window blueprint \xA77 forbids)`
+    };
+  }
+  if (routeAInstalled) {
+    return { id, verdict: "PASS", detail: `Route A only: drop at ${routeAPlugin}, no ${pkg} config declaration` };
+  }
+  if (hasB) {
+    return { id, verdict: "PASS", detail: `Route B only: ${declared.map((d) => `'${d}'`).join(", ")}, no file drop at ${routeAPlugin}` };
+  }
+  return { id, verdict: "PASS", detail: "neither route registered \u2014 no border plugin load claimed on the V1 surface" };
+}
+
+// src/opencode/aspects/identity.ts
+import { execFile } from "node:child_process";
+import { existsSync as existsSync20 } from "node:fs";
+var HANDSHAKE_ARGV = ["--help"];
+var HANDSHAKE_BANNER_PREFIX = "border";
+var HANDSHAKE_USAGE_NEEDLE = "usage: border";
+var HANDSHAKE_TIMEOUT_MS = 2e4;
+var MAX_OUTPUT_BYTES = 64 * 1024;
+var defaultInspectRunner = (target, argv) => new Promise((resolve20) => {
+  execFile(
+    target.bin,
+    [...target.prefix, ...argv],
+    { timeout: HANDSHAKE_TIMEOUT_MS, maxBuffer: MAX_OUTPUT_BYTES, shell: false },
+    (error61, stdout, stderr) => {
+      const out = stdout.slice(0, MAX_OUTPUT_BYTES);
+      const err = stderr.slice(0, MAX_OUTPUT_BYTES);
+      if (error61 === null) {
+        resolve20({ status: 0, stdout: out, stderr: err });
+        return;
+      }
+      const failure = error61;
+      if (failure.code === "ENOENT" || failure.code === "EACCES" || failure.code === "ENOEXEC") {
+        resolve20({ status: null, stdout: out, stderr: err });
+        return;
+      }
+      const status = typeof failure.code === "number" ? failure.code : failure.killed === true || failure.signal != null ? 124 : -1;
+      resolve20({ status, stdout: out, stderr: err });
+    }
+  );
+});
+function passesHandshake(outcome) {
+  if (outcome.status !== 0) return false;
+  const firstLine2 = (outcome.stdout.match(/^\s*(.*)/) ?? ["", ""])[1] ?? "";
+  return firstLine2.startsWith(HANDSHAKE_BANNER_PREFIX) && outcome.stdout.includes(HANDSHAKE_USAGE_NEEDLE);
+}
+function identityCandidates(env2, distEntry) {
+  const configured = env2["BORDER_BIN"];
+  if (configured !== void 0 && configured.length > 0) {
+    return [{ bin: configured, prefix: [], label: `BORDER_BIN=${configured}` }];
+  }
+  const candidates = [];
+  if (existsSync20(distEntry)) {
+    candidates.push({ bin: distEntry, prefix: [], label: "packaged dist/index.js (shebang exec)" });
+    candidates.push({ bin: "node", prefix: [distEntry], label: "packaged dist/index.js under PATH node" });
+  }
+  candidates.push({ bin: "border", prefix: [], label: "border on PATH" });
+  return candidates;
+}
+async function verifyIdentity(deps) {
+  const id = "identity-handshake";
+  const runner = deps.runner ?? defaultInspectRunner;
+  const candidates = identityCandidates(deps.env, deps.distEntry);
+  const reasons = [];
+  let anySpawned = false;
+  for (const candidate of candidates) {
+    const probe = await runner(candidate, HANDSHAKE_ARGV);
+    if (passesHandshake(probe)) {
+      return { id, verdict: "PASS", detail: `${candidate.label} passed the identity handshake` };
+    }
+    if (probe.status !== null) {
+      anySpawned = true;
+      reasons.push(`${candidate.label}: spawned but --help did not answer as border (impostor?)`);
+    } else {
+      reasons.push(`${candidate.label}: unspawnable (ENOENT/EACCES/ENOEXEC)`);
+    }
+  }
+  if (anySpawned) {
+    return { id, verdict: "FAIL", detail: `a border binary was reachable but failed the identity handshake \u2014 impersonation shape: ${reasons.join("; ")}` };
+  }
+  return { id, verdict: "CANNOT", detail: `no border binary reachable \u2014 tried: ${reasons.join("; ")}` };
+}
+
+// src/opencode/aspects/routeA.ts
+function verifyRouteAParity(facts) {
+  const id = "route-a-parity";
+  const { routeAPlugin, routeAInstalled } = facts;
+  if (!routeAInstalled) {
+    return { id, verdict: "PASS", detail: `${routeAPlugin}: absent \u2014 Route A not installed, nothing to be stale` };
+  }
+  if (facts.packagedPlugin === null) {
+    return { id, verdict: "CANNOT", detail: "the packaged plugin asset is unreadable \u2014 the border install itself looks broken, parity cannot be judged" };
+  }
+  const installed = facts.routeABytes;
+  if (installed === null) {
+    return { id, verdict: "CANNOT", detail: `${routeAPlugin}: present but unreadable \u2014 parity cannot be judged` };
+  }
+  const installedSha = sha256Hex3(installed);
+  const packagedSha = sha256Hex3(facts.packagedPlugin);
+  if (installedSha === packagedSha) {
+    return { id, verdict: "PASS", detail: `${routeAPlugin}: up-to-date installed=${installedSha} packaged=${packagedSha}` };
+  }
+  const ours = firstLine(installed).startsWith(PLUGIN_MARKER);
+  const shape = ours ? "outdated (marker ours, bytes differ)" : "foreign (first line lacks the marker)";
+  return { id, verdict: "FAIL", detail: `${routeAPlugin}: ${shape} installed=${installedSha} packaged=${packagedSha}` };
+}
+
+// src/opencode/aspects/scope.ts
+var SCOPE_ID = "scope";
+var SCOPE_NAME = "v1-load-surface";
+var SCOPE_UNCOVERED = [
+  "V2 project-local .opencode/plugins/",
+  "V2 npm-prefix/node_modules installs",
+  "V2 lazy activation state"
+];
+function verifyScope() {
+  return {
+    id: SCOPE_ID,
+    verdict: "PASS",
+    detail: `verdict scope = ${SCOPE_NAME}; NOT covered (declared blind, separate ledger item): ${SCOPE_UNCOVERED.join(", ")}`
+  };
+}
+
+// src/opencode/registry.ts
+var isRecord3 = (v) => typeof v === "object" && v !== null;
+var defaultRegistryFetcher = async (url2, init) => {
+  if (!/^https?:\/\//.test(url2)) throw new Error(`border opencode inspect refuses non-http(s) URL: ${url2}`);
+  const res = await fetch(url2, {
+    redirect: "follow",
+    signal: init.signal,
+    headers: { "user-agent": "border-customs (+https://github.com/TachikomaGundam/Border-Customs; border opencode inspect)" }
+  });
+  const raw = res.headers.get("content-length");
+  const parsed = raw === null ? Number.NaN : Number(raw);
+  return {
+    status: res.status,
+    contentLength: Number.isFinite(parsed) && parsed >= 0 ? parsed : null,
+    chunks: () => {
+      if (res.body === null) {
+        return {
+          async *[Symbol.asyncIterator]() {
+          }
+        };
+      }
+      return res.body;
+    }
+  };
+};
+function npmTagUrl(pkg, tag, base = DEFAULT_REGISTRY_BASE) {
+  const enc = pkg.startsWith("@") ? pkg.replace("/", "%2F") : encodeURIComponent(pkg);
+  return `${base}/${enc}/${encodeURIComponent(tag)}`;
+}
+var REGISTRY_BODY_CAP = 8 * 1024 * 1024;
+async function fetchRegistryVersion(fetcher, url2, timeoutMs) {
+  const res = await fetcher(url2, { signal: AbortSignal.timeout(timeoutMs) });
+  if (res.status !== 200) throw new Error(`HTTP ${String(res.status)} from ${url2}`);
+  const parts = [];
+  let total = 0;
+  for await (const chunk of res.chunks()) {
+    total += chunk.byteLength;
+    if (total > REGISTRY_BODY_CAP) throw new Error(`${url2} exceeds the ${String(REGISTRY_BODY_CAP)} B metadata cap`);
+    parts.push(Buffer.from(chunk));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.concat(parts).toString("utf8"));
+  } catch {
+    throw new Error(`metadata response from ${url2} is not valid JSON`);
+  }
+  if (!isRecord3(parsed) || typeof parsed["version"] !== "string" || parsed["version"].length === 0) {
+    throw new Error(`metadata response from ${url2} carries no "version" string`);
+  }
+  return parsed["version"];
+}
+
+// src/opencode/aspects/specFreshness.ts
+var isExactVersion2 = (spec) => /^\d+\.\d+\.\d+([-+].*)?$/.test(spec);
+async function verifySpecFreshness(facts, deps = {}) {
+  const id = "spec-freshness";
+  const { configs, cacheDirs, pkg } = facts;
+  const errored = configs.filter((c) => c.status === "error").map((c) => c.path);
+  if (errored.length > 0) {
+    return { id, verdict: "CANNOT", detail: `configuration unreadable (${errored.join(", ")}) \u2014 the expected version cannot be determined` };
+  }
+  const specs = [...new Set(configs.flatMap((c) => [...c.specs]).map((s) => splitNpmSpec(s).spec).filter((s) => s !== null))];
+  if (specs.length === 0) {
+    return { id, verdict: "PASS", detail: `no ${pkg} spec declared in opencode config \u2014 nothing to be fresh` };
+  }
+  const expected = /* @__PURE__ */ new Map();
+  const fetcher = deps.fetcher ?? defaultRegistryFetcher;
+  const timeoutMs = deps.timeoutMs ?? REGISTRY_TIMEOUT_MS2;
+  for (const spec of specs) {
+    if (isExactVersion2(spec)) {
+      expected.set(spec, spec);
+      continue;
+    }
+    try {
+      expected.set(spec, await fetchRegistryVersion(fetcher, npmTagUrl(pkg, spec, deps.registryBase), timeoutMs));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { id, verdict: "CANNOT", detail: `registry unreachable for spec '${pkg}@${spec}': ${message} \u2014 border never reads silence as fresh` };
+    }
+  }
+  if (cacheDirs.length === 0) {
+    return { id, verdict: "PASS", detail: `nothing cached to compare (see cache-version); spec resolves to ${[...new Set(expected.values())].join(", ")}` };
+  }
+  const wanted = new Set(expected.values());
+  const judged = cacheDirs.filter((d) => d.packageVersion !== null);
+  const stale = judged.filter((d) => !wanted.has(d.packageVersion));
+  if (judged.length > 0 && stale.length > 0) {
+    return {
+      id,
+      verdict: "FAIL",
+      detail: `cache holds ${stale.map((d) => `${d.tag}->${d.packageVersion}`).join(",")}, spec expects ${[...wanted].join(",")}`
+    };
+  }
+  return { id, verdict: "PASS", detail: `cache matches spec: ${[...wanted].join(",")}` };
+}
+
+// src/opencode/inspect.ts
+function aggregateVerdict(aspects) {
+  if (aspects.some((a) => a.verdict === "FAIL")) return "FAIL";
+  if (aspects.some((a) => a.verdict === "CANNOT")) return "CANNOT";
+  return "PASS";
+}
+function inspectExit(verdict) {
+  switch (verdict) {
+    case "FAIL":
+      return EXIT_BLOCKED;
+    case "CANNOT":
+      return EXIT_ERROR;
+    case "PASS":
+      return EXIT_PASS;
+  }
+}
+function readPackagedPlugin(path4) {
+  try {
+    return readFileSync19(path4);
+  } catch {
+    return null;
+  }
+}
+function gatherFacts(env2, cwd, deps) {
+  const pkg = deps.package ?? BORDER_PACKAGE;
+  const pluginDrop = routeAPluginPath(env2);
+  const cacheRoot = deps.cacheRoot ?? opencodeCacheRoot(env2);
+  const globalPath = deps.globalConfigPath ?? join31(opencodeConfigRoot(env2), "opencode", "opencode.jsonc");
+  const routeAInstalled = existsSync21(pluginDrop);
+  return {
+    pkg,
+    env: env2,
+    cacheRoot,
+    cacheDirs: listCacheDirs(cacheRoot, pkg),
+    configs: [readPluginDeclarations(globalPath, pkg), readPluginDeclarations(join31(cwd, "opencode.jsonc"), pkg)],
+    packagedPlugin: readPackagedPlugin(packagedAssetPath(import.meta.url, "border.ts")),
+    routeAPlugin: pluginDrop,
+    routeAInstalled,
+    routeABytes: routeAInstalled ? readPackagedPlugin(pluginDrop) : null
+  };
+}
+async function runInspectCore(ctx, deps = {}) {
+  const facts = gatherFacts(ctx.env, ctx.cwd, deps);
+  const aspects = [
+    verifyCacheVersion(facts),
+    await verifySpecFreshness(facts, {
+      ...deps.registryFetcher !== void 0 ? { fetcher: deps.registryFetcher } : {},
+      ...deps.registryBase !== void 0 ? { registryBase: deps.registryBase } : {}
+    }),
+    await verifyIdentity({
+      ...deps.runner !== void 0 ? { runner: deps.runner } : {},
+      distEntry: deps.distEntry ?? packagedDistEntry(import.meta.url),
+      env: facts.env
+    }),
+    verifyRouteAParity(facts),
+    verifyDualRoute(facts),
+    verifyScope()
+  ];
+  const verdict = aggregateVerdict(aspects);
+  const report = { schemaVersion: 1, scope: "v1", verdict, aspects };
+  if (ctx.flags.json) {
+    ctx.stdout(JSON.stringify(report));
+  } else {
+    ctx.stdout(`border opencode inspect [${report.scope}] ${verdict}`);
+    for (const a of aspects) {
+      ctx.stdout(`  ${a.verdict.padEnd(6)} ${a.id}: ${a.detail}`);
+    }
+  }
+  return inspectExit(verdict);
+}
+
+// src/commands/opencode.ts
+function resolvePluginAsset(moduleUrl, fileName) {
+  const here = dirname16(fileURLToPath6(moduleUrl));
+  const candidates = [
+    join32(here, "..", "plugin", fileName),
+    // dist mode (bundled): <root>/plugin/<f>
+    join32(here, "..", "..", "plugin", fileName)
+    // src mode: <root>/plugin/<f>
+  ];
+  return candidates.find((p) => existsSync22(p)) ?? candidates[1];
+}
+function targetsFor(env2) {
+  const root = join32(opencodeConfigRoot(env2), "opencode");
+  return [
+    { fileName: "border.ts", destination: join32(root, "plugins", "border.ts"), marker: PLUGIN_MARKER },
+    { fileName: "border-command.md", destination: join32(root, "commands", "border.md"), marker: COMMAND_MARKER }
+  ];
 }
 function carriesMarker(bytes, marker) {
   return firstLine(bytes).startsWith(marker);
@@ -44530,7 +45140,7 @@ function fail(ctx, message) {
 function readPackagedAsset(ctx, fileName) {
   const source = resolvePluginAsset(import.meta.url, fileName);
   try {
-    return readFileSync18(source);
+    return readFileSync20(source);
   } catch {
     ctx.stderr(`border: opencode: packaged asset is missing (${source})`);
     ctx.stderr("border: opencode: the border install looks broken \u2014 `npm i -g border-customs` or a fresh checkout should carry plugin/.");
@@ -44539,7 +45149,7 @@ function readPackagedAsset(ctx, fileName) {
 }
 function readTarget(destination) {
   try {
-    return readFileSync18(destination);
+    return readFileSync20(destination);
   } catch {
     return null;
   }
@@ -44606,7 +45216,7 @@ function opencodeInstall(ctx) {
       ctx.stdout(`${target.destination}: up to date`);
       continue;
     }
-    mkdirSync12(dirname15(target.destination), { recursive: true });
+    mkdirSync12(dirname16(target.destination), { recursive: true });
     writeFileSync8(target.destination, packaged);
     ctx.stdout(`${target.destination}: ${state === "outdated" ? "updated" : "installed"}`);
   }
@@ -44620,8 +45230,8 @@ function opencodeStatus(ctx) {
   for (const { target, packaged } of prepared) {
     const current = readTarget(target.destination);
     const state = classify(target, current, packaged);
-    const installedSha = current === null ? "-" : sha2563(current);
-    ctx.stdout(`${target.destination}: ${state}  installed=${installedSha}  packaged=${sha2563(packaged)}`);
+    const installedSha = current === null ? "-" : sha256Hex3(current);
+    ctx.stdout(`${target.destination}: ${state}  installed=${installedSha}  packaged=${sha256Hex3(packaged)}`);
   }
   return EXIT_PASS;
 }
@@ -44641,30 +45251,34 @@ function opencodeUninstall(ctx) {
         `refusing to remove ${target.destination} \u2014 the file is not ours (its first line lacks the marker '${target.marker}'); nothing was removed anywhere`
       );
     }
-    rmSync13(target.destination);
+    rmSync14(target.destination);
     ctx.stdout(`${target.destination}: removed`);
   }
   ctx.stdout("note: restart opencode for the tool and command to disappear.");
   return EXIT_PASS;
 }
 function runOpencode(ctx) {
-  const [sub, ...rest] = ctx.positionals;
-  if (rest.length > 0) {
-    throw new UnknownArgError(
-      `opencode ${sub ?? "<none>"}: unexpected argument '${rest[0] ?? ""}' \u2014 usage: border opencode install | status | uninstall`
-    );
-  }
+  const [sub, ...restAll] = ctx.positionals;
+  const rest = restAll.filter((arg) => arg !== "--json");
+  const USAGE = "usage: border opencode install | status | uninstall | inspect";
   switch (sub) {
     case "install":
-      return opencodeInstall(ctx);
     case "status":
-      return opencodeStatus(ctx);
     case "uninstall":
-      return opencodeUninstall(ctx);
+    case "inspect": {
+      if (rest.length > 0) {
+        throw new UnknownArgError(`opencode ${sub}: unexpected argument '${rest[0] ?? ""}' \u2014 ${USAGE}`);
+      }
+      const table2 = {
+        install: opencodeInstall,
+        status: opencodeStatus,
+        uninstall: opencodeUninstall,
+        inspect: runInspectCore
+      };
+      return table2[sub](ctx);
+    }
     default:
-      throw new UnknownArgError(
-        `opencode: unknown subcommand '${sub ?? "<none>"}' \u2014 usage: border opencode install | status | uninstall`
-      );
+      throw new UnknownArgError(`opencode: unknown subcommand '${sub ?? "<none>"}' \u2014 ${USAGE}`);
   }
 }
 
@@ -44766,9 +45380,9 @@ function confirmRemoteBranch(i) {
 
 // src/push/landing.ts
 import { spawnSync as spawnSync18 } from "node:child_process";
-import { mkdtempSync as mkdtempSync6, rmSync as rmSync14 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname16, join as join29, resolve as resolve18 } from "node:path";
+import { mkdtempSync as mkdtempSync7, rmSync as rmSync15 } from "node:fs";
+import { tmpdir as tmpdir5 } from "node:os";
+import { dirname as dirname17, join as join33, resolve as resolve18 } from "node:path";
 var LANDINGS_REF_PREFIX = "refs/border-landings/";
 async function runLandingVerification(o) {
   if (o.legs.length === 0) return null;
@@ -44791,6 +45405,12 @@ async function runLandingVerification(o) {
       );
       return EXIT_ERROR;
     }
+    const allow = applyAllowList(findings, o.allow ?? [], o.repoDir);
+    findings = allow.kept;
+    if (allow.allowHits.length > 0) {
+      const hits = allow.allowHits.map((h) => `${h.rule}#entry${String(h.entryIndex)}:${String(h.count)}`).join(", ");
+      o.err(`border: ${leg.target.target} landing: ${String(allow.allowHits.reduce((n, h) => n + h.count, 0))} tip finding(s) exempted by config allow pins (${hits}) \u2014 same entries the check verdict honored, echoed loud`);
+    }
     const blocking = findings.filter((f) => isBlocking(f.severity)).length;
     const verdict = blocking > 0 ? "blocked" : "clean";
     sink(buildLandingRecord({ key: o.key, target: leg.target.target, ref: `refs/heads/${leg.branch}`, remoteSha: sha, verdict, blocking, rulesHash }));
@@ -44818,7 +45438,7 @@ function gitPlain(repoDir, env2, args) {
   for (const [name, value] of Object.entries(env2)) {
     if (!name.startsWith("GIT_")) clean[name] = value;
   }
-  clean.GIT_CEILING_DIRECTORIES = dirname16(resolve18(repoDir));
+  clean.GIT_CEILING_DIRECTORIES = dirname17(resolve18(repoDir));
   clean.GIT_OPTIONAL_LOCKS = "0";
   clean.GIT_TERMINAL_PROMPT = "0";
   const r = spawnSync18("git", ["-C", resolve18(repoDir), ...args], { encoding: "utf8", env: clean, timeout: 55e3, maxBuffer: 32 * 1024 * 1024 });
@@ -44843,11 +45463,11 @@ async function defaultScanRemoteTip(o, remote, branch, remoteSha) {
       ownedTempRef = landingRef;
       rev = git.run(["rev-parse", landingRef]).trim();
     }
-    const treeRoot = mkdtempSync6(join29(tmpdir4(), "border-landing-tree-"));
+    const treeRoot = mkdtempSync7(join33(tmpdir5(), "border-landing-tree-"));
     try {
       return await scanTipTree(git, treeRoot, rev, o.env);
     } finally {
-      rmSync14(treeRoot, { recursive: true, force: true });
+      rmSync15(treeRoot, { recursive: true, force: true });
     }
   } finally {
     if (ownedTempRef !== null) {
@@ -45027,6 +45647,9 @@ async function executeYesPush(ctx, loaded) {
       key: state.key,
       legs: legs.map((leg) => ({ target: leg, branch })),
       env: env2,
+      // the SAME allow entries the certifying check honored — one standard
+      // across faces (2026-10-04 incident fix; see push/landing.ts doctrine).
+      allow: loaded.config.allow,
       out: ctx.stdout,
       err: ctx.stderr
     });
@@ -45049,17 +45672,17 @@ async function executeYesPush(ctx, loaded) {
 }
 
 // src/roundtrip/orchestrate.ts
-import { mkdtempSync as mkdtempSync7, rmSync as rmSync15, writeFileSync as writeFileSync9 } from "node:fs";
+import { mkdtempSync as mkdtempSync8, rmSync as rmSync16, writeFileSync as writeFileSync9 } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { tmpdir as tmpdir5 } from "node:os";
-import { join as join30 } from "node:path";
+import { tmpdir as tmpdir6 } from "node:os";
+import { join as join34 } from "node:path";
 
 // src/scan/fetch.ts
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 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.7.1 (+https://github.com/sumteclab/border; border scan)";
+var SCAN_USER_AGENT = "border-customs/0.8.1 (+https://github.com/gate-corp/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);
@@ -45113,7 +45736,7 @@ async function fetchJson(fetcher, url2, timeoutMs) {
     fail2(`metadata response from ${url2} is not valid JSON`);
   }
 }
-var isRecord2 = (v) => typeof v === "object" && v !== null;
+var isRecord4 = (v) => typeof v === "object" && v !== null;
 function channelBaseUrl(eco) {
   const ch = publishChannels().find((c) => c.id === eco);
   if (ch === void 0 || ch.defaultUrl.length === 0) {
@@ -45144,7 +45767,7 @@ async function fetchArtifact(spec, o) {
   switch (spec.ecosystem) {
     case "npm": {
       const meta3 = await fetchJson(o.fetcher, npmMetadataUrl(spec.name, spec.version), timeoutMs);
-      const dist = isRecord2(meta3) && isRecord2(meta3["dist"]) ? meta3["dist"] : {};
+      const dist = isRecord4(meta3) && isRecord4(meta3["dist"]) ? meta3["dist"] : {};
       const tarball = dist["tarball"];
       if (typeof tarball !== "string" || tarball.length === 0) fail2(`npm metadata for ${label} has no dist.tarball`);
       if (!/^https?:\/\//.test(tarball)) fail2(`npm dist.tarball for ${label} is not an http(s) URL`);
@@ -45155,8 +45778,8 @@ async function fetchArtifact(spec, o) {
     }
     case "pypi": {
       const meta3 = await fetchJson(o.fetcher, pypiMetadataUrl(spec.name, spec.version), timeoutMs);
-      const urls = isRecord2(meta3) && Array.isArray(meta3["urls"]) ? meta3["urls"] : [];
-      const files = urls.filter(isRecord2);
+      const urls = isRecord4(meta3) && Array.isArray(meta3["urls"]) ? meta3["urls"] : [];
+      const files = urls.filter(isRecord4);
       const sdists = files.filter((f) => f["packagetype"] === "sdist");
       const sdist = sdists.find((f) => typeof f["filename"] === "string" && f["filename"].endsWith(".tar.gz"));
       if (sdist === void 0) {
@@ -45184,8 +45807,8 @@ async function fetchArtifact(spec, o) {
     }
   }
 }
-function sha256Hex3(data) {
-  return createHash18("sha256").update(data).digest("hex");
+function sha256Hex4(data) {
+  return createHash19("sha256").update(data).digest("hex");
 }
 
 // src/scan/spec.ts
@@ -45228,8 +45851,8 @@ function parseScanSpec(raw) {
 }
 
 // src/roundtrip/localArtifact.ts
-import { createReadStream, existsSync as existsSync19, statSync as statSync3 } from "node:fs";
-import { createHash as createHash19 } from "node:crypto";
+import { createReadStream, existsSync as existsSync23, statSync as statSync3 } from "node:fs";
+import { createHash as createHash20 } from "node:crypto";
 import { basename as basename6, resolve as resolve19 } from "node:path";
 var EXT_TABLE = /* @__PURE__ */ new Map([
   [".whl", "pypi"],
@@ -45277,7 +45900,7 @@ var GRAMMAR_HINT = {
 };
 function classifyLocalInput(raw, cwd, parsesAsRegistrySpec) {
   const abs = resolve19(cwd, raw);
-  if (existsSync19(abs)) {
+  if (existsSync23(abs)) {
     const st = statSync3(abs);
     if (st.isDirectory()) {
       bad3(`'${raw}' resolves to a directory (${abs}) \u2014 local mode needs a single artifact FILE, not a directory`);
@@ -45312,7 +45935,7 @@ function classifyLocalInput(raw, cwd, parsesAsRegistrySpec) {
   return null;
 }
 async function readLocalArtifact(absPath, cap = SCAN_MAX_ARTIFACT_BYTES) {
-  const hash2 = createHash19("sha256");
+  const hash2 = createHash20("sha256");
   const parts = [];
   let total = 0;
   for await (const chunk of createReadStream(absPath)) {
@@ -45538,7 +46161,7 @@ var CLAIM_SCANNER_PY = [
 ].join("\n");
 
 // src/roundtrip/manifest.ts
-import { createHash as createHash20 } from "node:crypto";
+import { createHash as createHash21 } from "node:crypto";
 var RT_ENGINE = "roundtrip";
 var RT_RESIDUE_RULE = "roundtrip-residue-file";
 var RT_MODIFY_RULE = "roundtrip-modified-file";
@@ -45589,7 +46212,7 @@ var PERSISTENCE_PATTERNS = [
 function isPersistenceSurface(path4) {
   return PERSISTENCE_PATTERNS.some((re) => re.test(path4));
 }
-var digestOf = (what) => createHash20("sha256").update(what).digest("hex");
+var digestOf = (what) => createHash21("sha256").update(what).digest("hex");
 function classifyResidue(label, diff, attribution = null) {
   const findings = [];
   for (const e of diff.added) {
@@ -45636,7 +46259,7 @@ function classifyResidue(label, diff, attribution = null) {
 
 // src/roundtrip/orchestrate.ts
 function containerNameFor(label, rand = randomBytes(3).toString("hex")) {
-  return `rt-${sha256Hex3(label).slice(0, 8)}-${rand}`;
+  return `rt-${sha256Hex4(label).slice(0, 8)}-${rand}`;
 }
 var shArgv = (name) => {
   if (!/^[A-Za-z0-9@._+/-]+$/.test(name)) {
@@ -45757,7 +46380,7 @@ function runPipeline2(exec, profile, spec, label, hostPath, container, closure,
     return {
       findings: classifyResidue(label, diffManifests(m1, m3), attribution),
       installDelta,
-      baselineDigest: sha256Hex3([...m1.keys()].join("\n"))
+      baselineDigest: sha256Hex4([...m1.keys()].join("\n"))
     };
   } finally {
     try {
@@ -45791,12 +46414,12 @@ async function runRoundtripCore(ctx, deps = {}) {
     ctx.stderr("roundtrip: docker unavailable \u2014 cannot verify");
     return EXIT_ERROR;
   }
-  const baseDir = mkdtempSync7(join30(tmpdir5(), "border-roundtrip-"));
+  const baseDir = mkdtempSync8(join34(tmpdir6(), "border-roundtrip-"));
   try {
     const localRead = local !== null ? await readLocalArtifact(local.absPath) : null;
     const bytes = localRead?.bytes ?? (await fetchArtifact(spec, { fetcher: deps.fetcher ?? defaultScanFetcher })).bytes;
-    const artifactSha256 = localRead !== null ? localRead.sha256 : sha256Hex3(bytes);
-    const hostPath = join30(baseDir, "artifact");
+    const artifactSha256 = localRead !== null ? localRead.sha256 : sha256Hex4(bytes);
+    const hostPath = join34(baseDir, "artifact");
     writeFileSync9(hostPath, bytes);
     const container = containerNameFor(label);
     const closure = spec.ecosystem === "pypi" ? resolvePipClosure(exec, profile, hostPath, label, spec) : null;
@@ -45804,12 +46427,12 @@ async function runRoundtripCore(ctx, deps = {}) {
     const verdict = computeVerdict(findings);
     const report = {
       schemaVersion: 1,
-      key: sha256Hex3(`roundtrip:${label}:${baselineDigest}:${verdict}`),
+      key: sha256Hex4(`roundtrip:${label}:${baselineDigest}:${verdict}`),
       head: baselineDigest.slice(0, 40),
       dirty: false,
       exposureSet: [label],
       refSet: [],
-      rulesHash: sha256Hex3(`${profile.image}|${profile.install(profile.artifactPath, spec).join(" ")}|${profile.uninstall(spec).join(" ")}`),
+      rulesHash: sha256Hex4(`${profile.image}|${profile.install(profile.artifactPath, spec).join(" ")}|${profile.uninstall(spec).join(" ")}`),
       verdict,
       counts: countFindings(findings),
       findings,
@@ -45841,7 +46464,7 @@ async function runRoundtripCore(ctx, deps = {}) {
     }
     return exitCodeFromVerdict(verdict);
   } finally {
-    rmSync15(baseDir, { recursive: true, force: true });
+    rmSync16(baseDir, { recursive: true, force: true });
   }
 }
 function parsesRegistrySpec(raw) {
@@ -45897,9 +46520,9 @@ function dockerAvailableGuard(exec) {
 var runRoundtrip = (ctx) => runRoundtripCore(ctx);
 
 // src/scan/scan.ts
-import { mkdtempSync as mkdtempSync8 } from "node:fs";
-import { tmpdir as tmpdir6 } from "node:os";
-import { join as join32 } from "node:path";
+import { mkdtempSync as mkdtempSync9 } from "node:fs";
+import { tmpdir as tmpdir7 } from "node:os";
+import { join as join36 } from "node:path";
 
 // src/scan/config.ts
 function buildScanConfigYaml(eco) {
@@ -45926,8 +46549,8 @@ function synthesizeScanConfig(eco) {
 }
 
 // src/scan/materialize.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync13, readdirSync as readdirSync10, readFileSync as readFileSync19, rmSync as rmSync16, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join31 } from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync13, readdirSync as readdirSync11, readFileSync as readFileSync21, rmSync as rmSync17, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join35 } from "node:path";
 var CRATES_ENVELOPE_FILES = ["Cargo.toml.orig", ".cargo-ok", ".cargo_vcs_info.json"];
 var fail3 = (why) => {
   throw new Error(`border scan cannot materialize the artifact (${why}) \u2014 refusing to stage an unusable tree (fail-closed)`);
@@ -45941,15 +46564,15 @@ function extractFlat(archive, destDir) {
   }
 }
 function unwrapSingleDir(dir) {
-  const entries = readdirSync10(dir, { withFileTypes: true });
+  const entries = readdirSync11(dir, { withFileTypes: true });
   const dirs = entries.filter((e) => e.isDirectory());
   if (entries.length === 1 && dirs.length === 1 && dirs[0] !== void 0) {
-    return join31(dir, dirs[0].name);
+    return join35(dir, dirs[0].name);
   }
   return dir;
 }
 function requireManifest(repoDir, ecosystem, candidates) {
-  if (!candidates.some((rel) => existsSync20(join31(repoDir, rel)))) {
+  if (!candidates.some((rel) => existsSync24(join35(repoDir, rel)))) {
     fail3(`${ecosystem} package tree has none of [${candidates.join(", ")}] at its root`);
   }
 }
@@ -45959,18 +46582,18 @@ function materializePackage(o) {
 `);
   });
   const safe = safeArtifactName(o.filename, `${o.ecosystem}-artifact`);
-  const archive = join31(o.baseDir, safe);
+  const archive = join35(o.baseDir, safe);
   writeFileSync10(archive, o.bytes);
-  const extractDir = join31(o.baseDir, "extract");
+  const extractDir = join35(o.baseDir, "extract");
   mkdirSync13(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] ?? join31(outer, "data.tar.gz");
-    if (!existsSync20(inner)) fail3(".gem archive contains no data.tar.gz");
-    const gemTree = join31(o.baseDir, "gem-tree");
+    const inner = dataCandidates[0] ?? join35(outer, "data.tar.gz");
+    if (!existsSync24(inner)) fail3(".gem archive contains no data.tar.gz");
+    const gemTree = join35(o.baseDir, "gem-tree");
     mkdirSync13(gemTree, { recursive: true });
     extractFlat(inner, gemTree);
     repoDir = unwrapSingleDir(gemTree);
@@ -45981,11 +46604,11 @@ function materializePackage(o) {
   } else {
     requireManifest(repoDir, o.ecosystem, ["Cargo.toml"]);
     for (const file2 of CRATES_ENVELOPE_FILES) {
-      const path4 = join31(repoDir, file2);
-      if (!existsSync20(path4)) continue;
-      const original = readFileSync19(path4);
-      rmSync16(path4, { force: true });
-      note(`border scan: crates envelope normalized: ${file2} sha256=${sha256Hex3(original)}`);
+      const path4 = join35(repoDir, file2);
+      if (!existsSync24(path4)) continue;
+      const original = readFileSync21(path4);
+      rmSync17(path4, { force: true });
+      note(`border scan: crates envelope normalized: ${file2} sha256=${sha256Hex4(original)}`);
     }
   }
   const env2 = o.env;
@@ -46011,7 +46634,7 @@ async function runScanCore(ctx, deps = {}) {
   }
   const cfg = synthesizeScanConfig(spec.ecosystem);
   const fetcher = deps.fetcher ?? defaultScanFetcher;
-  const baseDir = mkdtempSync8(join32(tmpdir6(), "border-scan-"));
+  const baseDir = mkdtempSync9(join36(tmpdir7(), "border-scan-"));
   try {
     const { bytes, filename } = await fetchArtifact(spec, { fetcher });
     const env2 = { ...ctx.env };
@@ -46022,12 +46645,12 @@ async function runScanCore(ctx, deps = {}) {
     const verdict = computeVerdict(findings);
     const report = {
       schemaVersion: 1,
-      key: sha256Hex3(`scan:${spec.ecosystem}:${spec.name}@${spec.version}:${head}`),
+      key: sha256Hex4(`scan:${spec.ecosystem}:${spec.name}@${spec.version}:${head}`),
       head,
       dirty: false,
       exposureSet: [`${spec.ecosystem}:${spec.name}@${spec.version}`],
       refSet: [],
-      rulesHash: sha256Hex3(buildScanConfigYaml(spec.ecosystem)),
+      rulesHash: sha256Hex4(buildScanConfigYaml(spec.ecosystem)),
       verdict,
       counts: countFindings(findings),
       findings,
@@ -46168,7 +46791,7 @@ function usage() {
     "  llm-ingest     record provenance captured by the harness",
     "  scan           inspect a third-party package ([ecosystem:]name@version) for residue",
     "  roundtrip      install+uninstall a package (registry spec or local artifact file) in a throwaway container, report uninstall residue",
-    "  opencode       install|status|uninstall the official opencode plugin adapter (files under $XDG_CONFIG_HOME/opencode)",
+    "  opencode       install|status|uninstall|inspect the official opencode plugin adapter (files under $XDG_CONFIG_HOME/opencode; inspect = read-only V1 load-surface audit)",
     "  exfil          read-only exfil-lens scan of <ref|url> [ref...]: tip tree + tag notes (--deep adds reachable-history blobs + commit messages)",
     "",
     "flags:",
@@ -46311,7 +46934,7 @@ function isMainModule({ argv1, moduleUrl, realpath }) {
       return p;
     }
   };
-  return pathToFileURL(canonical(argv1)).href === pathToFileURL(canonical(fileURLToPath6(moduleUrl))).href;
+  return pathToFileURL(canonical(argv1)).href === pathToFileURL(canonical(fileURLToPath7(moduleUrl))).href;
 }
 if (isMainModule({ argv1: process.argv[1], moduleUrl: import.meta.url, realpath: realpathSync.native })) {
   const outcome = run(process.argv.slice(2));