dsh-plugin-compat-check 0.1.6 → 0.1.7

package/kernel/lib/api-semantics.mjs

@@ -0,0 +1,223 @@
+/** Small, version-bound semantic checks. No plugin execution or argument contents. */
+import { CATALOG_REFERENCES } from "./contracts.mjs";
+const policyValues = new Set(["keep", "replace", "append"]);
+const optionNames = [
+  "prompt",
+  "agentPreset",
+  "clearPreviousDraft",
+  "whenDraftExists",
+];
+export const semanticTarget = (service, method) =>
+  (service === "uiWorkspace" && method === "startSession") ||
+  (service === "timer" && ["setTimeout", "setInterval"].includes(method)) ||
+  (service === "sessions" && method === "retain");
+const unknown = () => ({ kind: "unknown" });
+function scalar(value, name, generation) {
+  if (value?.kind !== "constant" || value.semanticGeneration !== generation)
+    return unknown();
+  const kind = typeof value.value;
+  if (!["string", "number", "boolean"].includes(kind)) return unknown();
+  return {
+    kind,
+    ...(name === "whenDraftExists" && kind === "string"
+      ? { policy: policyValues.has(value.value) ? value.value : "invalid" }
+      : name === "clearPreviousDraft" && kind === "boolean"
+        ? { enabled: value.value }
+        : {}),
+  };
+}
+/** Called after all argument expressions; copies facts, never mutable references. */
+export function captureSemanticArguments(
+  service,
+  method,
+  values,
+  nodes,
+  unboundUndefined,
+  generation,
+) {
+  if (service !== "uiWorkspace" || method !== "startSession") return null;
+  if (nodes.some((node) => node.type === "SpreadElement")) return unknown();
+  const value = values[1],
+    node = nodes[1];
+  if (!node || unboundUndefined(node)) return { kind: "omitted" };
+  if (
+    value?.kind !== "object" ||
+    value.opaque ||
+    value.semanticGeneration !== generation
+  )
+    return unknown();
+  const fields = Object.create(null);
+  for (const name of optionNames)
+    if (value.fields.has(name))
+      fields[name] = scalar(value.fields.get(name), name, generation);
+  return { kind: "options", fields };
+}
+export function mergeSemanticArguments(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b) ? a : unknown();
+}
+
+const record = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const digest = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v);
+/** Metadata governance, not a substitute for source review or runtime acceptance. */
+export function validateSemanticBaselines(rules) {
+  const group = rules.apiSemantics;
+  if (!record(group) || group.schemaVersion !== 1 || !record(group.baselines))
+    return ["Invalid semantic baseline schema"];
+  const errors = [],
+    versions = CATALOG_REFERENCES.map((v) => v.version);
+  const entries = Object.entries(group.baselines);
+  if (!entries.length || entries.length > versions.length)
+    return ["Invalid semantic version count"];
+  for (const [version, b] of entries) {
+    if (
+      !versions.includes(version) ||
+      !record(b) ||
+      b.sourceTag !== "dsh-v" + version ||
+      !digest(b.sourceArchiveSha256) ||
+      !record(b.sources) ||
+      Object.keys(b.sources).length > 16 ||
+      !Object.keys(b.sources).length ||
+      Object.entries(b.sources).some(
+        ([p, h]) =>
+          !/^packages\/(?:[a-z0-9-]+\/)+[a-z0-9-]+\.ts$/.test(p) || !digest(h),
+      ) ||
+      !record(b.startSession) ||
+      !Object.hasOwn(b.sources, b.startSession.source) ||
+      !record(b.startSession.options) ||
+      !Object.keys(b.startSession.options).length ||
+      Object.entries(b.startSession.options).some(
+        ([k, v]) =>
+          !optionNames.includes(k) ||
+          v !== (k === "clearPreviousDraft" ? "boolean" : "string"),
+      ) ||
+      !record(b.notices) ||
+      Object.keys(b.notices).length > 3 ||
+      Object.entries(b.notices).some(
+        ([api, n]) =>
+          ![
+            "timer.setTimeout",
+            "timer.setInterval",
+            "sessions.retain",
+          ].includes(api) ||
+          !record(n) ||
+          !["弃用", "生命周期"].includes(n.kind) ||
+          typeof n.message !== "string" ||
+          !n.message ||
+          n.message.length > 1024 ||
+          !Object.hasOwn(b.sources, n.source),
+      )
+    )
+      errors.push("Invalid semantic baseline: " + version);
+  }
+  return errors;
+}
+
+/** Findings are nonfatal contract risks; maintenance/lifetime notices stay limitations. */
+export function checkApiSemantics(plugin, rules, version) {
+  const findings = [],
+    limitations = [];
+  const baseline =
+    validateSemanticBaselines(rules).length === 0 &&
+    Object.hasOwn(rules.apiSemantics.baselines, version)
+      ? rules.apiSemantics.baselines[version]
+      : null;
+  for (const site of plugin.callSites || []) {
+    if (
+      !site.sides?.includes("client") ||
+      !semanticTarget(site.service, site.method)
+    )
+      continue;
+    const api = `${site.service}.${site.method}`;
+    const at = `${site.file}:${site.line}`;
+    const context = `${api} @ ${at} [DSH ${version ?? "未知"}]`;
+    if (!baseline) {
+      limitations.push(
+        `语义未审查（参数/弃用/生命周期）：${context}；不借用邻近版本或回退目录认证`,
+      );
+      continue;
+    }
+    const notice = baseline.notices[api];
+    if (notice)
+      limitations.push(
+        `语义提示·${notice.kind}：${context}；${notice.message}`,
+      );
+    if (api !== "uiWorkspace.startSession") continue;
+    const args = site.semanticArguments;
+    if (!args || args.kind === "unknown") {
+      limitations.push(
+        `参数未能静态确定：${context}；动态、展开、访问器或合并值不证明参数正确`,
+      );
+      continue;
+    }
+    const add = (option, category, message) =>
+      findings.push({
+        category,
+        service: site.service,
+        method: site.method,
+        severity: "degraded",
+        certainty: site.inferredReceiver ? "suspected" : "certain",
+        impactBasis: "inferred",
+        location: {
+          file: site.file,
+          line: site.line,
+          column: site.column,
+          start: site.start,
+          end: site.end,
+        },
+        impact: `${option} ${message}；可能改变或忽略草稿处理，未实测业务失败`,
+        basis: `固定官方源码的客户端参数契约，精确版本 ${version}；方法存在或能力守卫不验证参数`,
+        ruleSource: "rule",
+        ruleRef: `apiSemantics.baselines.${version}.startSession.${option}`,
+        evidence: {
+          dshVersion: version,
+          side: "client",
+          option,
+          sourceArchiveSha256: baseline.sourceArchiveSha256,
+          source: baseline.startSession.source,
+        },
+      });
+    if (args.kind === "options") {
+      for (const [name, value] of Object.entries(args.fields)) {
+        if (value.kind === "unknown") {
+          limitations.push(
+            `参数未能静态确定：${context} 的 ${name}；不猜测运行时值`,
+          );
+          continue;
+        }
+        const expected = baseline.startSession.options[name];
+        if (!expected) {
+          add(
+            name,
+            "api-option-unsupported",
+            "不在此版本已审查的选项中，官方实现未使用该字段",
+          );
+        } else if (
+          value.kind !== expected ||
+          (name === "whenDraftExists" && value.policy === "invalid")
+        ) {
+          add(
+            name,
+            "api-argument-invalid",
+            "参数不符：类型或枚举值不符合公开契约",
+          );
+        }
+      }
+      if (baseline.startSession.options.whenDraftExists) {
+        const explicit = args.fields.whenDraftExists;
+        if (
+          explicit?.kind === "string" &&
+          explicit.policy !== "invalid" &&
+          args.fields.clearPreviousDraft
+        )
+          limitations.push(
+            `语义提示·选项：${context}；whenDraftExists 优先于兼容选项 clearPreviousDraft，后者仍受支持`,
+          );
+        else if (!explicit && args.fields.prompt?.kind === "string")
+          limitations.push(
+            `语义提示·选项：${context}；未显式提供 whenDraftExists 时默认保留已有草稿，clearPreviousDraft 为 true 才采用 replace；不证明已提交或创建了新会话`,
+          );
+      }
+    }
+  }
+  return { findings, limitations };
+}

package/kernel/lib/author-ci-budget.mjs

@@ -0,0 +1,25 @@
+/** One budget for emitted evidence, saved reports and previous matrices. */
+const reportBytes = 8 * 1024 * 1024;
+export const AUTHOR_CI_LIMITS = Object.freeze({
+  versions: 4,
+  timeoutMs: 30000,
+  previousBytes: reportBytes,
+  reportBytes,
+  cellBytes: 2 * 1024 * 1024,
+  policyBytes: 65536,
+});
+export function checkCIOutput(text) {
+  if (Buffer.byteLength(text + "\n") > AUTHOR_CI_LIMITS.reportBytes)
+    throw Error("Author CI output exceeds the shared output budget");
+  return text;
+}
+export function ciJSON(value, { cell = false } = {}) {
+  const text = JSON.stringify(value, null, cell ? 0 : 2);
+  if (typeof text !== "string") throw Error("Invalid author CI evidence");
+  if (cell) {
+    if (Buffer.byteLength(text) > AUTHOR_CI_LIMITS.cellBytes)
+      throw Error("Author CI cell exceeds output budget");
+    return text;
+  }
+  return checkCIOutput(text);
+}

package/kernel/lib/author-ci-output.mjs

@@ -186,3 +186,25 @@ export function renderJUnit(matrix) {
       "",
     )}</properties>${cases.map((c) => c.xml).join("")}</testsuite></testsuites>\n`;
 }
+
+/** A self-contained, inert view. All report-controlled values become text. */
+export function renderHTML(matrix) {
+  const pretty = (v) => xml(JSON.stringify(v, null, 2));
+  const cells = (matrix.cells || [])
+    .map((c) => {
+      const plugins = Object.entries(c.report?.plugins || {})
+        .map(
+          ([name, p]) =>
+            `<h3>${xml(name)}</h3><p>Verdict: ${xml(p.verdict)}; Coverage: ${xml(p.coverage?.status)}; Vacuous: ${xml(p.vacuous)}</p><pre>${pretty({ coverage: p.coverage, findings: p.findings })}</pre>`,
+        )
+        .join("");
+      return `<section><h2>DSH ${xml(c.dshVersion)} — ${xml(c.status)}</h2><p>Kernel exit code: ${xml(c.kernelExitCode)}</p>${c.error ? `<p>${xml(c.error)}</p>` : ""}<h3>Identity</h3><pre>${pretty(c.identity)}</pre>${plugins}</section>`;
+    })
+    .join("");
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'"><title>Plugin author CI evidence</title><style>body{font:16px system-ui,sans-serif;max-width:1000px;margin:2rem auto;padding:0 1rem;color:#202124;background:#fff}pre{white-space:pre-wrap;overflow-wrap:anywhere;background:#f3f4f5;padding:1rem}section{border-top:1px solid #aaa;margin-top:2rem}h1,h2,h3{overflow-wrap:anywhere}</style></head><body>
+<h1>Plugin author CI evidence</h1><p>Policy gate: ${xml(matrix.gate.status)}; exit code: ${xml(matrix.gate.exitCode)}.</p><p>Static evidence only. Policy pass is not business acceptance. Saved reports are not signed; validate their provenance before using them as CI inputs.</p>
+<h2>Selected package identity</h2><pre>${pretty(matrix.identity)}</pre><h2>Policy and gate reasons</h2><pre>${pretty({ policy: matrix.policy, gate: matrix.gate })}</pre>
+<h2>Limitations</h2><ul>${(matrix.limitations || []).map((s) => `<li>${xml(s)}</li>`).join("")}</ul>${cells}
+<h2>Complete canonical evidence</h2><p>This is the same JSON snapshot, including extraction, coverage, vacuous status, findings, identities and kernel results for every version.</p><pre id="evidence">${pretty(matrix)}</pre></body></html>`;
+}

package/kernel/lib/author-ci-policy.mjs

@@ -1,5 +1,6 @@
 /** Pure author CI gate. Kernel reports remain unchanged and independently useful. */
 import { assertReportBody, CATALOG_REFERENCES } from "./contracts.mjs";
+import { AUTHOR_CI_LIMITS, ciJSON } from "./author-ci-budget.mjs";
 const severities = ["fatal", "feature-dead", "degraded"];
 const certainties = ["certain", "suspected"];
 export const DEFAULT_POLICY = Object.freeze({
@@ -60,7 +61,9 @@ function validIdentity(i) {
 }
 function validateCells(cells, { baseline = false } = {}) {
   need(
-    Array.isArray(cells) && cells.length > 0,
+    Array.isArray(cells) &&
+      cells.length > 0 &&
+      cells.length <= AUTHOR_CI_LIMITS.versions,
     "Matrix requires at least one version cell",
   );
   const seen = new Set();
@@ -84,6 +87,7 @@ function validateCells(cells, { baseline = false } = {}) {
       c.error === null && validIdentity(c.identity),
       "Invalid analyzed cell identity",
     );
+    ciJSON(c.report, { cell: true });
     assertReportBody(c.report);
     need(
       c.kernelExitCode === c.report.exitCode,
@@ -121,6 +125,7 @@ function validateCells(cells, { baseline = false } = {}) {
   }
 }
 function validatePrevious(previous, cells) {
+  ciJSON(previous);
   need(
     record(previous) &&
       previous.schemaVersion === 1 &&

package/kernel/lib/baseline.mjs

@@ -1,4 +1,4 @@
-import { validateBaseline } from "./contracts.mjs";
+import { validateBaseline, terminalText } from "./contracts.mjs";
 /**
  * 基线：回答「**变了没有**」，以及变了多少、往哪个方向变。
  *
@@ -41,7 +41,7 @@ export function snapshotForBaseline(verdict, dshVersion, identity = {}) {
   const names = Object.keys(verdict.plugins || {}).sort();
   for (const name of names) {
     const p = verdict.plugins[name];
-    plugins[name] = {
+    const plugin = {
       version: p.version ?? null,
       verdict: p.verdict,
       vacuous: p.vacuous === true,
@@ -53,25 +53,97 @@ export function snapshotForBaseline(verdict, dshVersion, identity = {}) {
               ? `${f.service}.${f.method}`
               : f.service
             : "(declaration)",
+          ...(f.category === "host-entry-inactive"
+            ? {
+                entryId:
+                  typeof f.evidence?.entryId === "string"
+                    ? f.evidence.entryId
+                    : null,
+              }
+            : {}),
+          ...(Number.isSafeInteger(f.location?.column)
+            ? { column: f.location.column }
+            : {}),
           category: f.category,
           severity: f.severity,
           certainty: f.certainty,
           location: f.location ? `${f.location.file}:${f.location.line}` : null,
         }))
-        .sort(
-          (a, b) =>
-            a.key.localeCompare(b.key) || a.category.localeCompare(b.category),
-        ),
+        .sort(compareFinding),
     };
+    Object.defineProperty(plugins, name, {
+      value: plugin,
+      enumerable: true,
+      writable: true,
+      configurable: true,
+    });
   }
   return {
     schemaVersion: BASELINE_SCHEMA,
     dshVersion: dshVersion ?? null,
-    identity: { mode: verdict.observation?.mode ?? "unspecified", ...identity },
+    identity: {
+      mode: verdict.observation?.mode ?? "unspecified",
+      ...identity,
+      findingKeyVersion: 1,
+    },
     plugins,
   };
 }
 
+// Identity is structured, so delimiters in malformed metadata cannot collide.
+const groupKey = (f) => JSON.stringify([f.key, f.category, f.entryId ?? null]);
+const compareFinding = (a, b) => {
+  const key = (f) =>
+    JSON.stringify([
+      groupKey(f),
+      f.location,
+      f.column ?? null,
+      f.severity,
+      f.certainty,
+    ]);
+  const x = key(a),
+    y = key(b);
+  return x < y ? -1 : x > y ? 1 : 0;
+};
+/** Match exact occurrences first, then same location, then equal evidence,
+ * then deterministic remaining occurrences. Every row is consumed once. */
+function matchFindings(before, after) {
+  const a = [...before].sort(compareFinding),
+    b = [...after].sort(compareFinding);
+  const usedA = new Set(),
+    usedB = new Set(),
+    pairs = [];
+  for (const detail of [
+    (f) => [f.location, f.column ?? null, f.severity, f.certainty],
+    (f) => [f.location, f.column ?? null],
+    (f) => [f.severity, f.certainty],
+    () => [],
+  ]) {
+    const queues = new Map();
+    const key = (f) => JSON.stringify([groupKey(f), ...detail(f)]);
+    for (let i = 0; i < a.length; i++) {
+      if (usedA.has(i)) continue;
+      const k = key(a[i]);
+      if (!queues.has(k)) queues.set(k, { indices: [], offset: 0 });
+      queues.get(k).indices.push(i);
+    }
+    for (let j = 0; j < b.length; j++) {
+      if (usedB.has(j)) continue;
+      const queue = queues.get(key(b[j]));
+      if (!queue || queue.offset === queue.indices.length) continue;
+      const i = queue.indices[queue.offset++];
+      usedA.add(i);
+      usedB.add(j);
+      pairs.push({ from: a[i], to: b[j] });
+    }
+  }
+  return {
+    pairs,
+    added: b.filter((_, i) => !usedB.has(i)),
+    removed: a.filter((_, i) => !usedA.has(i)),
+  };
+}
+
 /** 结论档位的"好坏"序：用于判断某个变化是变好还是变差 */
 const RANK = { broken: 0, partial: 1, unknown: 2, ok: 3 };
 
@@ -144,30 +216,20 @@ export function diffAgainstBaseline(prev, next) {
     const worseVerdict = RANK[y.verdict] < RANK[x.verdict];
     const betterVerdict = RANK[y.verdict] > RANK[x.verdict];
 
-    const xk = new Set(x.findings.map((f) => `${f.key}|${f.category}`));
-    const yk = new Set(y.findings.map((f) => `${f.key}|${f.category}`));
-    const newFindings = y.findings.filter(
-      (f) => !xk.has(`${f.key}|${f.category}`),
-    );
-    const goneFindings = x.findings.filter(
-      (f) => !yk.has(`${f.key}|${f.category}`),
-    );
+    const {
+      added: newFindings,
+      removed: goneFindings,
+      pairs,
+    } = matchFindings(x.findings, y.findings);
     const severityRank = { degraded: 0, "feature-dead": 1, fatal: 2 };
     const certaintyRank = { suspected: 0, certain: 1 };
-    const changes = y.findings
-      .map((f) => ({
-        from: x.findings.find(
-          (g) => g.key === f.key && g.category === f.category,
-        ),
-        to: f,
-      }))
-      .filter(
-        (c) =>
-          c.from &&
-          (c.from.severity !== c.to.severity ||
-            c.from.certainty !== c.to.certainty ||
-            c.from.location !== c.to.location),
-      );
+    const changes = pairs.filter(
+      ({ from, to }) =>
+        from.severity !== to.severity ||
+        from.certainty !== to.certainty ||
+        from.location !== to.location ||
+        from.column !== to.column,
+    );
     const evidenceWorse = changes.some(
       (c) =>
         severityRank[c.to.severity] > severityRank[c.from.severity] ||
@@ -289,21 +351,30 @@ export function badgeFor(diff) {
  * 而坏消息被"另外还发现两个插件变好了"稀释掉，就等于没说。
  */
 export function describeDiff(diff) {
-  if (!diff || !diff.comparable) return diff ? diff.reason : "没有基线";
+  if (!diff || !diff.comparable)
+    return terminalText(diff ? diff.reason : "没有基线");
   const badge = badgeFor(diff);
-  if (!badge.show) return badge.detail;
+  if (!badge.show) return terminalText(badge.detail);
   const L = [badge.text];
   for (const e of diff.worsened) {
-    L.push(`  ↓ ${e.name}@${e.versionFrom}→${e.versionTo}：${e.reason}`);
+    L.push(
+      `  ↓ ${terminalText(e.name)}@${terminalText(e.versionFrom)}→${terminalText(e.versionTo)}：${terminalText(e.reason)}`,
+    );
     for (const f of e.newFindings)
-      L.push(`      新增：${f.key} @ ${f.location || "—"}`);
+      L.push(
+        `      新增：${terminalText(f.key)} @ ${terminalText(f.location || "—")}`,
+      );
   }
   for (const e of diff.improved) {
-    L.push(`  ↑ ${e.name}：${e.reason}`);
-    for (const f of e.goneFindings) L.push(`      不再报：${f.key}`);
+    L.push(`  ↑ ${terminalText(e.name)}：${terminalText(e.reason)}`);
+    for (const f of e.goneFindings)
+      L.push(`      不再报：${terminalText(f.key)}`);
   }
-  for (const e of diff.added) L.push(`  + ${e.name}@${e.version}`);
-  for (const e of diff.removed) L.push(`  − ${e.name}@${e.version}`);
-  for (const e of diff.updated || []) L.push(`  • ${e.name}：${e.reason}`);
+  for (const e of diff.added)
+    L.push(`  + ${terminalText(e.name)}@${terminalText(e.version)}`);
+  for (const e of diff.removed)
+    L.push(`  − ${terminalText(e.name)}@${terminalText(e.version)}`);
+  for (const e of diff.updated || [])
+    L.push(`  • ${terminalText(e.name)}：${terminalText(e.reason)}`);
   return L.join("\n");
 }

package/kernel/lib/catalog.mjs

@@ -1,12 +1,16 @@
 /** Keep the frozen legacy catalogue available for older targets and overrides. */
 import path from "node:path";
 import semver from "semver";
-import fs from "node:fs";
 import { createHash } from "node:crypto";
 import { CATALOG_REFERENCES, describeCatalog } from "./contracts.mjs";
+import { readStaticFile } from "./static-input.mjs";
 
 export function catalogPathFor(root, version, override) {
   if (override) return override;
+  const newest =
+    typeof version === "string" &&
+    semver.valid(version) &&
+    semver.gte(version, "0.2.1-rc.3");
   const modern =
     typeof version === "string" &&
     semver.valid(version) &&
@@ -14,14 +18,18 @@ export function catalogPathFor(root, version, override) {
   return path.join(
     root,
     "rules",
-    modern ? "dsh-api-catalog-0.2.1-rc.2.json" : "dsh-api-catalog.json",
+    newest
+      ? "dsh-api-catalog-0.2.1-rc.3.json"
+      : modern
+        ? "dsh-api-catalog-0.2.1-rc.2.json"
+        : "dsh-api-catalog.json",
   );
 }
 
 /** Read once: the reported digest always describes the bytes used to judge. */
 export function loadCatalog(root, version, override) {
   const file = catalogPathFor(root, version, override),
-    bytes = fs.readFileSync(file);
+    bytes = readStaticFile(file, 8 * 1024 * 1024);
   const sha256 = createHash("sha256").update(bytes).digest("hex");
   const known = CATALOG_REFERENCES.find(
     (c) => c.file === path.basename(file) && c.sha256 === sha256,

package/kernel/lib/contracts.mjs

@@ -8,6 +8,14 @@
 export const REPORT_SCHEMA = 1;
 export const REPORT_KIND = "plugin-compat-check/result";
 export const ENVELOPE_KIND = "plugin-compat-check/report";
+/** Escape untrusted single-line display text; callers supply layout newlines.
+ * JSON identities remain untouched. Visible escapes are safe to render again. */
+export function terminalText(value) {
+  return String(value).replace(
+    /[\x00-\x1f\x7f-\x9f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069]/g,
+    (c) => "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0"),
+  );
+}
 /** Reviewed catalogue bytes, not a promise of plugin business compatibility.
  * Adding a version requires source verification, rule review and integration
  * evidence; extraction alone must never extend this list. */
@@ -22,6 +30,11 @@ export const CATALOG_REFERENCES = Object.freeze([
     file: "dsh-api-catalog-0.2.1-rc.2.json",
     sha256: "90b4ae484ebc6660c53e5c9ad14ba657581534b30e8222c636c759e19587f743",
   }),
+  Object.freeze({
+    version: "0.2.1-rc.3",
+    file: "dsh-api-catalog-0.2.1-rc.3.json",
+    sha256: "dd253bc418a787d881e402f3650857c2d8e7631b818927743a5f2b81104f25a5",
+  }),
 ]);
 export function describeCatalog({
   targetVersion = null,
@@ -102,7 +115,9 @@ function snapshotFinding(f) {
     text(f.category) &&
     severities.includes(f.severity) &&
     certainties.includes(f.certainty) &&
-    nullableText(f.location)
+    nullableText(f.location) &&
+    (f.entryId === undefined || nullableText(f.entryId)) &&
+    (f.column === undefined || integer(f.column))
   );
 }
 function checkedEntry(v) {

package/kernel/lib/execution-environment.mjs

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/** Private runner state and a minimal inherited environment; not an OS sandbox.
+ * PATH still selects trusted executables. Copied profile configuration and
+ * explicitly selected local dependencies remain readable by the host/plugin.
+ */
+export function isolatedEnvironment(root) {
+  const env = {};
+  for (const key of [
+    "PATH",
+    "SystemRoot",
+    "COMSPEC",
+    "PATHEXT",
+    "LANG",
+    "LC_ALL",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+  ]) {
+    if (process.env[key]) env[key] = process.env[key];
+  }
+  Object.assign(env, {
+    HOME: path.join(root, "user"),
+    USERPROFILE: path.join(root, "user"),
+    XDG_CONFIG_HOME: path.join(root, "config"),
+    XDG_CACHE_HOME: path.join(root, "cache"),
+    DSH_HOME: path.join(root, "home"),
+    DSH_AGENTS_HOME: path.join(root, "agents"),
+    npm_config_cache: path.join(root, "npm-cache"),
+    npm_config_store_dir: path.join(root, "pnpm-store"),
+    npm_config_ignore_scripts: "true",
+  });
+  for (const directory of new Set([
+    env.HOME,
+    env.XDG_CONFIG_HOME,
+    env.XDG_CACHE_HOME,
+    env.DSH_HOME,
+    env.DSH_AGENTS_HOME,
+    env.npm_config_cache,
+    env.npm_config_store_dir,
+  ]))
+    fs.mkdirSync(directory, { mode: 0o700 });
+  for (const [key, name] of [
+    ["npm_config_userconfig", "npm-user.rc"],
+    ["npm_config_globalconfig", "npm-global.rc"],
+  ]) {
+    env[key] = path.join(root, name);
+    fs.writeFileSync(env[key], "", { mode: 0o600, flag: "wx" });
+  }
+  return env;
+}