@moonquake2004/dsh-security 0.1.7 → 0.2.0

package/src/integrations/plugin-reducer.mjs

@@ -2,68 +2,218 @@
  * dsh-plugin-reducer 集成
  *
  * 在检测到故障时，提供最小化故障插件集的能力。
- * 如果 dsh-plugin-reducer 已安装（PATH 中可执行），自动建议运行。
+ * 如果 dsh-plugin-reducer 已安装（PATH 中可执行），自动集成到安全检查流程。
  * 复审修复：不再用 `npx 包名` 探测/执行；执行失败返回 skip 而不是伪装通过。
+ *
+ * 复审修复（docs/ecosystem-audit-2026-09.md §3(c) EXT-RED-1 / §4.4）——**调用方式与结果路径都不对**：
+ *
+ * 1. `--profile` 收的是 profile **名**，不是路径（上游 `src/args.js` HELP：`--profile <name> (default: web)`、
+ *    `--dsh-home <path> Source DSH_HOME`）。旧代码传的是 profile 目录的绝对路径，
+ *    工具会把整条路径当成 profile 名 → 归约不了任何东西。现在从 registry 交付的 profile 目录
+ *    （`<dshHome>/profiles/<name>`）反推名字与 dsh home，两个参数分别传。
+ *
+ * 2. 结果路径。机器契约是 stdout 上**一个** envelope：
+ *      `{ schemaVersion, tool: {name, version}, operation, ok, report | candidates | error }`
+ *    （上游 `src/machine-output.js`），答案在 `report.result.minimalFailingSet`
+ *    （上游 `src/index.js`：`result: { status: 'minimal-failure-set-found', minimalFailingSet: reduced.minimal, … }`）。
+ *    旧代码读 `result.minimalSet` —— 永远 undefined，于是**找到故障集也判为通过**。
+ *
+ * 3. 便携性。旧代码把 `--report` 硬编码到 `/tmp`（Windows 无此路径）并用 `which` 探测
+ *    （Windows 无此命令 → 永久「未安装」）。现在 `--report` 落在 `os.tmpdir()` 下的一次性目录并在
+ *    finally 中清理；探测改用 tool-exec.mjs 的 PATH 扫描。
+ *
+ * 4. 语义收紧：`ok:true` 只可能出现在「确实归约出了最小故障集」的路径上
+ *    （上游 index.js 在 FULL_SET_PASSES / BASELINE_FAILS / FINAL_NOT_REPRODUCIBLE 等情况下抛 ReducerError
+ *     → envelope `ok:false` + `error.code` + exit 1）。因此 `ok:true` 但 `minimalFailingSet` 缺失/为空
+ *    属于契约矛盾 → 显式 skip，绝不判 pass。
  */
 
-import { execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { Severity } from '../protocol/severity.mjs';
 import { CheckPhase } from '../protocol/phase.mjs';
-import { skip } from '../protocol/check.mjs';
+import { skip, fail } from '../protocol/check.mjs';
+import { findExecutable, execCapture, parseJson, describeFailure, typeName } from './tool-exec.mjs';
+
+export const REDUCER_ID = 'EXT-RED-1';
+const BIN = 'dsh-plugin-reducer';
+const SUPPORTED_SCHEMA_VERSION = 1;
+const PROBE_KINDS = new Set(['config', 'web', 'command']);
+/** 沿用旧实现的默认探针；工具自身的默认是 config（见 src/args.js HELP） */
+const DEFAULT_PROBE = 'web';
 
+/**
+ * 检测 dsh-plugin-reducer 是否可用（跨平台 PATH 扫描，不启动子进程）
+ */
 export function isAvailable() {
-  try {
-    execFileSync('which', ['dsh-plugin-reducer'], { encoding: 'utf8', stdio: 'pipe' });
-    return true;
-  } catch {
-    return false;
+  return findExecutable(BIN) !== null;
+}
+
+/**
+ * 从 profile 目录反推工具需要的 `{ dshHome, profile }`。
+ *
+ * registry 交给 EXT-* 的是 profile 目录（如 `~/.dsh/profiles/web`），而 CLI 要的是
+ * `--dsh-home <path> --profile <name>`。规则：
+ *   `<home>/profiles/<name>` → { dshHome: '<home>', profile: '<name>' }
+ *   纯名字（不含路径分隔符，如 `web`）→ { dshHome: null, profile: 'web' }（由工具走 DSH_HOME/~/.dsh）
+ *   其它任意目录 → null（无法安全推断，调用方应 skip）
+ *
+ * @param {string} profileDir
+ * @returns {{dshHome: string|null, profile: string}|null}
+ */
+export function deriveProfileArgs(profileDir) {
+  if (!profileDir || typeof profileDir !== 'string') return null;
+  const normalized = profileDir.replace(/\\/g, '/').replace(/\/+$/, '');
+  if (normalized === '') return null;
+
+  const matched = normalized.match(/^(.*)\/profiles\/([^/]+)$/);
+  if (matched) {
+    const [, home, name] = matched;
+    return { dshHome: home || null, profile: name };
   }
+  // 不含路径分隔符 → 视为 profile 名本身
+  if (!normalized.includes('/')) return { dshHome: null, profile: normalized };
+  return null;
 }
 
-export async function runReducer(profileDir, probeType = 'web') {
-  const id = 'EXT-RED-1';
+/**
+ * 解释 dsh-plugin-reducer 的 stdout envelope（纯函数，便于单测）。
+ *
+ * @param {unknown} raw
+ * @returns {import('../protocol/check.mjs').SecurityCheckResult}
+ */
+export function interpretEnvelope(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `dsh-plugin-reducer 输出的 JSON 不是 envelope 对象（实际：${typeName(raw)}），跳过故障最小化`);
+  }
 
-  if (!isAvailable()) {
-    return skip(id, Severity.LOW, 'dsh-plugin-reducer 未安装，跳过故障最小化');
+  if (raw.schemaVersion !== SUPPORTED_SCHEMA_VERSION) {
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `dsh-plugin-reducer envelope 的 schemaVersion=${JSON.stringify(raw.schemaVersion ?? null)} 不是受支持版本 ${SUPPORTED_SCHEMA_VERSION}，契约已变化，跳过故障最小化`);
   }
 
+  const operation = typeof raw.operation === 'string' ? raw.operation : 'unknown';
+
+  if (raw.ok === false) {
+    const code = typeof raw.error?.code === 'string' ? raw.error.code : 'UNKNOWN';
+    const message = typeof raw.error?.message === 'string' ? raw.error.message.slice(0, 120) : '';
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `dsh-plugin-reducer 未能完成归约（operation=${operation}, ok=false, code=${code}${message ? `：${message}` : ''}），跳过故障最小化`);
+  }
+
+  if (raw.ok !== true) {
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `dsh-plugin-reducer envelope 缺少布尔 ok（operation=${operation}），契约已变化，跳过故障最小化`);
+  }
+
+  const set = raw.report?.result?.minimalFailingSet;
+  if (!Array.isArray(set)) {
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `dsh-plugin-reducer envelope ok=true 但 report.result.minimalFailingSet 缺失或不是数组（实际：${typeName(set)}），契约已变化，跳过故障最小化`);
+  }
+
+  if (set.length === 0) {
+    // ok:true 在本工具语义下意味着「确实找到了最小故障集」（见文件头第 4 点），空集与契约矛盾
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      'dsh-plugin-reducer envelope ok=true 但最小故障集为空——与「ok=true 即已找到最小故障集」的契约矛盾，跳过故障最小化（不外推为通过）');
+  }
+
+  const plugins = set.map(entry => (typeof entry === 'string' ? entry : JSON.stringify(entry)));
+  const result = fail(
+    REDUCER_ID,
+    Severity.MEDIUM,
+    `dsh-plugin-reducer 找到最小故障插件集（${plugins.length} 个）：${plugins.join(', ')}`,
+    '移除或禁用故障插件集中的插件；该集合是 1-minimal 的，逐个排查会掩盖交互故障（A+B 组合失败）',
+  );
+  result.evidence = {
+    schemaVersion: raw.schemaVersion,
+    tool: raw.tool,
+    operation,
+    minimalFailingSet: plugins,
+  };
+  return result;
+}
+
+/**
+ * 运行 dsh-plugin-reducer
+ *
+ * @param {string} profileDir - profile 目录（`<dshHome>/profiles/<name>`）或 profile 名
+ * @param {'config'|'web'|'command'} [probeType] - 探针类型
+ * @param {{isAvailable?: () => boolean, exec?: typeof execCapture, tmpRoot?: string}} [deps] - 测试注入点
+ * @returns {Promise<import('../protocol/check.mjs').SecurityCheckResult>}
+ */
+export async function runReducer(profileDir, probeType = DEFAULT_PROBE, deps = {}) {
+  const available = deps.isAvailable ? deps.isAvailable() : isAvailable();
+  if (!available) {
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `dsh-plugin-reducer 未安装（PATH 中找不到 ${BIN}），跳过故障最小化；安装后可在启动故障时定位到最小插件集`);
+  }
+
+  const profile = deriveProfileArgs(profileDir);
+  if (!profile) {
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `无法从 "${String(profileDir)}" 推断 profile 名（期望 <dshHome>/profiles/<name>）——dsh-plugin-reducer 的 --profile 收名字而非路径，跳过故障最小化`);
+  }
+
+  if (!PROBE_KINDS.has(probeType)) {
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `未知的探针类型 "${String(probeType)}"（支持：${[...PROBE_KINDS].join('/')}），跳过故障最小化`);
+  }
+
+  // --report 落在 os.tmpdir() 下的一次性目录（不再硬编码 /tmp），执行后清理
+  let reportDir = null;
+  let reportPath = null;
   try {
-    const output = execFileSync(
-      'dsh-plugin-reducer',
-      ['--profile', String(profileDir), '--probe', String(probeType), '--report', '/tmp/reducer-report.json', '--json'],
-      {
-        encoding: 'utf8',
-        timeout: 120000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }
-    );
-
-    const result = JSON.parse(output);
-
-    if (result.minimalSet && result.minimalSet.length > 0) {
-      return {
-        id,
-        ok: false,
-        severity: Severity.MEDIUM,
-        detail: `dsh-plugin-reducer 找到最小故障插件集：${result.minimalSet.join(', ')}`,
-        fix: '移除或禁用故障插件集中的插件',
-        evidence: result,
-      };
-    }
-
-    return { id, ok: true, severity: Severity.LOW, detail: 'dsh-plugin-reducer 未发现故障插件集' };
-  } catch (e) {
-    return skip(id, Severity.LOW, `dsh-plugin-reducer 执行失败，跳过：${e.message.slice(0, 80)}`);
+    reportDir = mkdtempSync(join(deps.tmpRoot ?? tmpdir(), 'dsh-security-reducer-'));
+    reportPath = join(reportDir, 'reducer-report.json');
+  } catch {
+    reportDir = null; // 建不了临时目录就不传 --report：stdout 的 envelope 才是机器契约
+    reportPath = null;
   }
+
+  const args = [];
+  if (profile.dshHome) args.push('--dsh-home', profile.dshHome);
+  args.push('--profile', profile.profile, '--probe', probeType, '--json');
+  if (reportPath) args.push('--report', reportPath, '--force');
+
+  let res;
+  try {
+    const exec = deps.exec ?? execCapture;
+    res = exec(BIN, args, { timeoutMs: 120000 });
+  } finally {
+    if (reportDir) rmSync(reportDir, { recursive: true, force: true });
+  }
+
+  // 上游退出码契约：0 = 归约完成；1 = 执行/归约失败；2 = 参数非法。
+  // 后两者**仍然输出可解析的 envelope**（ok:false + error.code），所以先按契约判定退出码，
+  // 再解析 stdout —— 只要 envelope 能解析出来，就走 interpretEnvelope 给出带原因的判断。
+  const expectedExit = res.status === 0 || res.status === 1 || res.status === 2;
+  const parsed = parseJson(res.stdout);
+
+  if (!parsed.ok) {
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `dsh-plugin-reducer 的 stdout 无法解析为 JSON envelope（${describeFailure(res)}），跳过故障最小化`);
+  }
+  if (!expectedExit) {
+    return skip(REDUCER_ID, Severity.MEDIUM,
+      `dsh-plugin-reducer 以非预期退出码结束（${describeFailure(res)}），跳过故障最小化`);
+  }
+
+  return interpretEnvelope(parsed.value);
 }
 
+/**
+ * dsh-plugin-reducer 集成检查对象
+ */
 export const pluginReducerCheck = {
-  id: 'EXT-RED-1',
+  id: REDUCER_ID,
   name: 'plugin-reducer',
   severity: Severity.MEDIUM,
   phase: CheckPhase.LIFECYCLE,
   description: 'dsh-plugin-reducer 故障最小化',
   src: 'external',
-  source: 'dsh-plugin-reducer',
+  source: BIN,
   runner: (profileDir) => runReducer(profileDir),
 };

package/src/integrations/poison-guard.mjs

@@ -3,75 +3,198 @@
  *
  * 如果 dsh-poison-guard 已安装（PATH 中可执行），自动集成到安全检查流程。
  * 复审修复：不再用 `npx 包名` 探测/执行；执行失败返回 skip 而不是伪装通过。
+ *
+ * 复审修复（docs/ecosystem-audit-2026-09.md §3(c) EXT-PG-1 / §4.4）——**真实发现曾被判为通过**：
+ *
+ * 1. 字段读错。工具的真实报告是
+ *      `{ verdict: 'MALICIOUS'|'SUSPICIOUS'|'CLEAN', findings[{rule,severity,file,line,hint}], summary, stats }`
+ *    （已核对上游 zoahdev/dsh-poison-guard@master `lib/index.js`：
+ *     `const verdict = high.length > 0 ? 'MALICIOUS' : medium.length > 0 ? 'SUSPICIOUS' : 'CLEAN'`），
+ *    旧代码读的是 `result.clean || result.vulnerabilities?.length === 0` —— 这两个字段工具都不产出，
+ *    所以 `findings[]` 从未被使用。两种实际后果（均不会把发现报成 fail）：
+ *      · 有发现 → 工具 exit 1 → execFileSync 抛异常 → catch 变成一句无信息的 skip
+ *        （我们的协议里 skip 带 ok:true，只计入「跳过」，所以真发现在报告里彻底消失）；
+ *      · 若同一份报告带 exit 0 返回 → 落到 `vulns = result.vulnerabilities || []` 分支，
+ *        输出「检测到 0 个投毒模式：」——一个计数为空、毫无线索的 fail。
+ *    现在一律以 `findings[]` 为准，`verdict` 只做交叉校验。
+ *
+ * 2. 退出码即契约。上游 `bin/poison-guard.mjs` 末行是
+ *      `process.exit(report.verdict === 'CLEAN' ? 0 : 1)`
+ *    也就是说**有发现时退出码是 1**。旧代码用 execFileSync，exit 1 会抛出异常，
+ *    结构化 stdout 一起丢掉 → 真发现又退化成一句「执行失败，跳过」。
+ *    现在 exit 0/1 都解析 stdout；其余退出码视为未知 → 显式 skip。
+ *
+ * 3. 「形状变了」必须 skip。verdict 缺失/未知、findings 存在但不是数组 —— 都是契约漂移，
+ *    一律 skip 并带上原因，绝不外推成 pass。
  */
 
-import { execFileSync } from 'node:child_process';
 import { Severity } from '../protocol/severity.mjs';
 import { CheckPhase } from '../protocol/phase.mjs';
-import { skip } from '../protocol/check.mjs';
+import { skip, fail, pass } from '../protocol/check.mjs';
+import { findExecutable, execCapture, parseJson, describeFailure, typeName } from './tool-exec.mjs';
+
+export const POISON_GUARD_ID = 'EXT-PG-1';
+const BIN = 'dsh-poison-guard';
+
+/** 工具自报「干净」的 verdict（上游仅产出 'CLEAN'；大小写不敏感以容忍 shape 微调） */
+const CLEAN_VERDICTS = new Set(['clean']);
+/** 工具自报「有问题」的 verdict（上游：HIGH→MALICIOUS，MEDIUM→SUSPICIOUS） */
+const BAD_VERDICTS = new Set(['malicious', 'suspicious']);
 
 /**
- * 检测 dsh-poison-guard 是否可用
+ * 检测 dsh-poison-guard 是否可用（跨平台 PATH 扫描，不启动子进程）
  */
 export function isAvailable() {
-  try {
-    execFileSync('which', ['dsh-poison-guard'], { encoding: 'utf8', stdio: 'pipe' });
-    return true;
-  } catch {
-    return false;
+  return findExecutable(BIN) !== null;
+}
+
+/** 把工具 severity（HIGH/MEDIUM/LOW）映射到我们的词汇表 */
+function normalizeSeverity(value) {
+  const v = typeof value === 'string' ? value.trim().toLowerCase() : '';
+  return v === 'high' || v === 'medium' || v === 'low' ? v : 'unknown';
+}
+
+/**
+ * 把一条工具 finding 映射到我们的结果形状。
+ * 工具 finding：`{ rule, severity, file, line, hint }`
+ */
+export function mapFinding(finding, index = 0) {
+  const f = finding && typeof finding === 'object' && !Array.isArray(finding) ? finding : {};
+  const line = Number.isFinite(f.line)
+    ? f.line
+    : (typeof f.line === 'string' && /^\d+$/.test(f.line) ? Number(f.line) : null);
+  return {
+    rule: typeof f.rule === 'string' && f.rule ? f.rule : `unknown-rule-${index + 1}`,
+    severity: normalizeSeverity(f.severity),
+    file: typeof f.file === 'string' && f.file ? f.file : null,
+    line,
+    hint: typeof f.hint === 'string' ? f.hint : '',
+  };
+}
+
+/** 渲染一条已映射的 finding */
+function renderFinding(f) {
+  const where = f.file ? ` (${f.file}${f.line ? `:${f.line}` : ''})` : '';
+  return `[${f.severity}] ${f.rule}: ${f.hint || '(无 hint)'}${where}`;
+}
+
+/**
+ * 解释 dsh-poison-guard 的 JSON 报告（纯函数，便于单测）。
+ *
+ * 判定优先级：
+ *   findings 非空 → FAIL（不管 verdict 说什么）
+ *   findings 为空/缺失 + verdict=CLEAN → PASS
+ *   findings 为空 + verdict=MALICIOUS/SUSPICIOUS → FAIL（非 CLEAN 的 verdict 永不判 pass）
+ *   其余（verdict 缺失/未知、findings 类型异常、不是对象）→ skip + 原因
+ *
+ * @param {unknown} raw
+ * @returns {import('../protocol/check.mjs').SecurityCheckResult}
+ */
+export function interpretReport(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    return skip(POISON_GUARD_ID, Severity.HIGH,
+      `dsh-poison-guard 输出的 JSON 不是对象（实际：${typeName(raw)}），无法解释报告，跳过投毒扫描`);
+  }
+
+  const verdict = typeof raw.verdict === 'string' ? raw.verdict.trim() : null;
+  const hasFindingsKey = raw.findings !== undefined;
+
+  if (hasFindingsKey && !Array.isArray(raw.findings)) {
+    return skip(POISON_GUARD_ID, Severity.HIGH,
+      `dsh-poison-guard 输出的 findings 不是数组（实际：${typeName(raw.findings)}），契约已变化，跳过投毒扫描`);
+  }
+
+  const findings = Array.isArray(raw.findings) ? raw.findings : [];
+
+  if (findings.length > 0) {
+    const mapped = findings.map((f, i) => mapFinding(f, i));
+    const shown = mapped.slice(0, 10).map(renderFinding).join('\n');
+    const more = mapped.length > 10 ? `\n…另有 ${mapped.length - 10} 条未展开` : '';
+    const verdictNote = verdict ? `，verdict=${verdict}` : '';
+    const result = fail(
+      POISON_GUARD_ID,
+      Severity.HIGH,
+      `dsh-poison-guard 检测到 ${mapped.length} 个投毒发现${verdictNote}：\n${shown}${more}`,
+      '检查相关插件源码，移除恶意/混淆代码；保留安装脚本审计结果作为 pre-install 阻断依据',
+      ['#2961', '#5498'],
+    );
+    result.evidence = { verdict, findings: mapped };
+    return result;
+  }
+
+  // findings 为空 → 只能靠 verdict 判定
+  if (verdict === null) {
+    return skip(POISON_GUARD_ID, Severity.HIGH,
+      'dsh-poison-guard 输出既无 findings 也无 verdict（契约已变化），跳过投毒扫描（不外推为通过）');
   }
+
+  const normalized = verdict.toLowerCase();
+  if (CLEAN_VERDICTS.has(normalized)) {
+    const result = pass(POISON_GUARD_ID, Severity.HIGH,
+      `dsh-poison-guard 扫描通过：verdict=${verdict}，无 findings`);
+    result.evidence = { verdict, findings: [] };
+    return result;
+  }
+  if (BAD_VERDICTS.has(normalized)) {
+    const result = fail(
+      POISON_GUARD_ID,
+      Severity.HIGH,
+      `dsh-poison-guard 报告 verdict=${verdict} 但未给出 findings，按非 CLEAN 判定为发现`,
+      '重新运行 dsh-poison-guard 获取完整 findings，或人工审查该插件源码',
+    );
+    result.evidence = { verdict, findings: [] };
+    return result;
+  }
+
+  return skip(POISON_GUARD_ID, Severity.HIGH,
+    `dsh-poison-guard 输出了无法识别的 verdict=${verdict}（已知：CLEAN/MALICIOUS/SUSPICIOUS），跳过投毒扫描`);
 }
 
 /**
  * 运行 dsh-poison-guard 扫描
  * @param {string} targetPath - 要扫描的目录或包路径
+ * @param {{isAvailable?: () => boolean, exec?: typeof execCapture}} [deps] - 测试注入点
  * @returns {Promise<import('../protocol/check.mjs').SecurityCheckResult>}
  */
-export async function runScan(targetPath) {
-  const id = 'EXT-PG-1';
+export async function runScan(targetPath, deps = {}) {
+  const available = deps.isAvailable ? deps.isAvailable() : isAvailable();
+  if (!available) {
+    return skip(POISON_GUARD_ID, Severity.HIGH,
+      `dsh-poison-guard 未安装（PATH 中找不到 ${BIN}），跳过投毒扫描；安装后可覆盖 pre-install 投毒检测`);
+  }
 
-  if (!isAvailable()) {
-    return skip(id, Severity.HIGH, 'dsh-poison-guard 未安装，跳过投毒扫描');
+  if (!targetPath) {
+    return skip(POISON_GUARD_ID, Severity.HIGH, '未提供待扫描的插件目录，跳过投毒扫描');
   }
 
-  try {
-    const output = execFileSync('dsh-poison-guard', ['scan', String(targetPath), '--json'], {
-      encoding: 'utf8',
-      timeout: 60000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    const result = JSON.parse(output);
-
-    if (result.clean || result.vulnerabilities?.length === 0) {
-      return { id, ok: true, severity: Severity.HIGH, detail: 'dsh-poison-guard 扫描通过：未检测到投毒模式' };
-    }
-
-    const vulns = result.vulnerabilities || [];
-    const details = vulns.slice(0, 10).map(v => `[${v.severity}] ${v.type}: ${v.message}`).join('\n');
-
-    return {
-      id,
-      ok: false,
-      severity: Severity.HIGH,
-      detail: `dsh-poison-guard 检测到 ${vulns.length} 个投毒模式：\n${details}`,
-      fix: '检查相关插件的源码，移除恶意代码',
-    };
-  } catch (e) {
-    return skip(id, Severity.HIGH, `dsh-poison-guard 执行失败，跳过：${e.message.slice(0, 80)}`);
+  const exec = deps.exec ?? execCapture;
+  const res = exec(BIN, ['scan', String(targetPath), '--json'], { timeoutMs: 60000 });
+
+  // 上游退出码契约：0 = CLEAN，1 = 至少一个发现；其余（2 = 用法错误）为未知
+  if (res.status !== 0 && res.status !== 1) {
+    return skip(POISON_GUARD_ID, Severity.HIGH,
+      `dsh-poison-guard 以非预期退出码结束（${describeFailure(res)}），跳过投毒扫描`);
+  }
+
+  const parsed = parseJson(res.stdout);
+  if (!parsed.ok) {
+    return skip(POISON_GUARD_ID, Severity.HIGH,
+      `dsh-poison-guard 的 stdout 无法解析为 JSON（${describeFailure(res)}），跳过投毒扫描`);
   }
+
+  return interpretReport(parsed.value);
 }
 
 /**
  * dsh-poison-guard 集成检查对象
  */
 export const poisonGuardCheck = {
-  id: 'EXT-PG-1',
+  id: POISON_GUARD_ID,
   name: 'poison-scan',
   severity: Severity.HIGH,
   phase: CheckPhase.POST_INSTALL,
   description: 'dsh-poison-guard 投毒扫描（AST + 反混淆）',
   src: 'external',
-  source: 'dsh-poison-guard',
+  source: BIN,
   runner: (targetPath) => runScan(targetPath),
 };

package/src/integrations/sandbox-audit.mjs

@@ -1,67 +1,71 @@
 /**
- * dsh-sandbox-audit 集成
+ * dsh-sandbox-audit 集成 —— **已退役（RETIRED）**
  *
- * 如果 dsh-sandbox-audit 已安装（PATH 中可执行），自动集成到安全检查流程。
- * 复审修复：不再用 `npx 包名` 探测可用性——那会在用户机器上触发任意包的下载执行；
- * 执行失败现在返回 skip 而不是伪装成通过。
+ * 决策（docs/ecosystem-audit-2026-09.md §3(c) 首行 / §4.4）：审计给了两个选项——
+ * (a) 按真实 CLI 契约重写为「逐个 YAML 文件调用」，或 (b) 退役该集成并记录原因。
+ * 本项目选择 **(b) 退役**，理由：
+ *
+ *   1. 这个二进制从未发布到 npm：`registry.npmjs.org/dsh-sandbox-audit` → HTTP 404，
+ *      仓库（zoahdev/dsh-sandbox-audit）无 tag、无 release，未声明 license，最后推送 2026-08-16。
+ *      `isAvailable()` 只有在用户手工 clone + link 之后才可能为 true —— 对任何正常安装的用户，
+ *      这个检查都是死代码，而它同时把「工具不在」伪装成「无需检查」。
+ *   2. 契约本身也是错的：真实 CLI 收的是 YAML **文件路径**（cordis.patch.yml / agent.cordis.yml），
+ *      不是 profile 目录；报告形状是 `{source, defaultMode, tools[], findings[{severity,title}]}`，
+ *      旧代码读的 `findings[].tool` / `findings[].finding` 根本不存在 → 即便手工装上了也只会输出空列表，
+ *      即「装上了也读不出东西」。
+ *   3. 覆盖面无损失：sp3（`src/checks/sp3-sandbox-consistency.mjs`）已经离线、静态地覆盖了同一片
+ *      「沙箱接线与策略声明不一致」的检查域（其文件头即写明「轻量版 dsh-sandbox-audit」，含
+ *      HIGH: 变文件系统工具共享 bare fs-local backend / MEDIUM: 搜索工具越权读取 / LOW: 多余权限），
+ *      且不依赖任何第三方二进制或网络。与其维护一个永远跑不起来的集成，不如让 sp3 作为唯一 owner。
+ *
+ * 保留导出只是为了不破坏公开 API：`src/index.mjs` 仍然 `export { sandboxAuditCheck }`，
+ * 而 `sandboxAuditCheck` 是 src/** 之外的消费者可能 import 的名字。所以这里不删文件，
+ * 而是把它变成「永不判 pass、也永不判 fail」的退役桩：
+ *   · `isAvailable()` 恒为 false —— 它不会再被注册，也就不会再出现在任何报告里；
+ *   · 直接调用 runner 时返回带原因的 skip，而不是 throw 或静默通过。
+ * `getAvailableIntegrations()` 已不再注册本检查（EXT-SA-1 从 dsh-doctor 输出中消失）。
  */
 
-import { execFileSync } from 'node:child_process';
 import { Severity } from '../protocol/severity.mjs';
 import { CheckPhase } from '../protocol/phase.mjs';
 import { skip } from '../protocol/check.mjs';
 
-export function isAvailable() {
-  try {
-    execFileSync('which', ['dsh-sandbox-audit'], { encoding: 'utf8', stdio: 'pipe' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function runAudit(profileDir) {
-  const id = 'EXT-SA-1';
-
-  if (!isAvailable()) {
-    return skip(id, Severity.MEDIUM, 'dsh-sandbox-audit 未安装，跳过沙箱策略审计');
-  }
-
-  try {
-    const output = execFileSync('dsh-sandbox-audit', [String(profileDir), '--json'], {
-      encoding: 'utf8',
-      timeout: 60000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    const result = JSON.parse(output);
+export const SANDBOX_AUDIT_ID = 'EXT-SA-1';
 
-    if (result.clean || result.findings?.length === 0) {
-      return { id, ok: true, severity: Severity.MEDIUM, detail: 'dsh-sandbox-audit 审计通过：沙箱策略配置一致' };
-    }
+/** 退役原因（同时用于 skip 的 reason，便于报告里说明「为什么这行不见了」） */
+export const RETIRED_REASON =
+  'dsh-sandbox-audit 集成已退役：该工具从未发布到 npm（registry 404）、仓库无 tag/release、' +
+  '自 2026-08-16 停更且未声明 license，契约（YAML 文件入参 + findings[].title）也与旧实现不符；' +
+  '沙箱策略一致性现由离线检查 SP3 覆盖，不再运行 EXT-SA-1';
 
-    const findings = result.findings || [];
-    const details = findings.slice(0, 10).map(f => `[${f.severity}] ${f.tool}: ${f.finding}`).join('\n');
+/**
+ * 恒为 false：退役后不再探测、不再注册。
+ * （保留函数签名是为了兼容既有调用方，避免它们从「检查被跳过」变成 TypeError。）
+ */
+export function isAvailable() {
+  return false;
+}
 
-    return {
-      id,
-      ok: false,
-      severity: Severity.MEDIUM,
-      detail: `dsh-sandbox-audit 检测到 ${findings.length} 个沙箱策略不一致：\n${details}`,
-      fix: '参考 dsh-sandbox-audit 文档修复沙箱配置',
-    };
-  } catch (e) {
-    return skip(id, Severity.MEDIUM, `dsh-sandbox-audit 执行失败，跳过：${e.message.slice(0, 80)}`);
-  }
+/**
+ * 退役桩：任何调用都返回带原因的 skip，绝不 pass / fail / throw。
+ * @returns {Promise<import('../protocol/check.mjs').SecurityCheckResult>}
+ */
+export async function runAudit() {
+  return skip(SANDBOX_AUDIT_ID, Severity.MEDIUM, RETIRED_REASON);
 }
 
+/**
+ * @deprecated 已退役，仅保留以兼容 `src/index.mjs` 的 re-export。
+ * 该对象不会被 getAvailableIntegrations() 注册。
+ */
 export const sandboxAuditCheck = {
-  id: 'EXT-SA-1',
+  id: SANDBOX_AUDIT_ID,
   name: 'sandbox-audit',
   severity: Severity.MEDIUM,
   phase: CheckPhase.POST_INSTALL,
-  description: 'dsh-sandbox-audit 沙箱策略审计',
+  description: '（已退役）dsh-sandbox-audit 沙箱策略审计 —— 由离线检查 SP3 覆盖',
   src: 'external',
   source: 'dsh-sandbox-audit',
-  runner: (profileDir) => runAudit(profileDir),
+  retired: true,
+  runner: () => runAudit(),
 };