@moonquake2004/dsh-security 0.1.0 → 0.1.1

package/README.md

@@ -1,46 +1,138 @@
 # dsh-security
 
-[![CI](https://img.shields.io/badge/CI-passing-brightgreen)](#)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![npm](https://img.shields.io/npm/v/@moonquake2004/dsh-security)](https://www.npmjs.com/package/@moonquake2004/dsh-security)
+[![Tests](https://img.shields.io/badge/tests-69%2F69%20passing-brightgreen)](#)
 
-**DSH 生态统一安全检查框架** — 覆盖插件全生命周期（发现→安装→运行→更新→退役）。
+**DSH 生态统一安全检查框架** — 覆盖插件全生命周期（发现→安装→运行→更新→退役），17 个内置检查 + 4 个外部工具集成。
 
 > Community security tool. Not an official DeepSeek project.
 
-## 定位
+---
 
-```
-dsh-doctor          ← 执行者（运行检查）
-dsh-security        ← 检查库（定义检查）
-dsh-poison-guard    ← 外部集成（投毒扫描）
-dsh-sandbox-audit   ← 外部集成（沙箱审计）
-dsh-redact          ← 外部集成（日志脱敏）
-```
+## 项目背景
+
+DeepSeek Harness（DSH）生态在 0.1.0-rc.6 开源后爆发式增长：2958 个插件仓库、8+ 精选列表、新插件每小时出现。但**没有统一的安全检查框架**——安全工具各自为战，用户无法一键获得完整的安全态势感知。
+
+dsh-security 的目标：**建立 DSH 生态的统一安全检查层**，让任何工具都能贡献检查，让用户一键发现安全问题。
+
+---
+
+## 开发历程
+
+### Phase 1：基础框架 + 核心检查（Day 1）
+
+- 设计 4 层架构（Check Protocol → Static → Runtime → Lifecycle）
+- 实现 Layer 0：Severity/CheckPhase 枚举、SecurityCheck 接口、v1 信封扩展
+- 实现 SP2（密钥扫描）和 SS1（凭据泄露检测）——最高价值的两个检查
+- 50/50 测试全绿
+
+### Phase 2：静态检查完整 + 外部集成（Day 1）
+
+- 实现 SP1（依赖链审计）、SP3（沙箱策略一致性）
+- 实现 Plugin Interface——外部工具可通过 JSON 注册检查
+- 集成 dsh-poison-guard、dsh-sandbox-audit、dsh-ecosystem、dsh-plugin-reducer
+- dsh-doctor `--security` 标志集成
+
+### Phase 3：运行时检查（Day 1）
+
+- 实现 SR1（沙箱逃逸检测）——检测 mount remount、sudo、/etc 访问等
+- 实现 SR3（数据外泄检测）——检测凭据转发、网络外发
+- 基于会话日志分析的运行时安全检测
+
+### Phase 4：生命周期检查 + 生态集成（Day 1）
+
+- 实现 SL1（供应链完整性）、SL4（发布兼容性）
+- 实现 SP4（恶意 entry）、SP5（权限验证）、SP6（漏洞匹配）
+- 实现 SR2（权限提升）、SR4（隔离验证）
+- 实现 SL2（更新完整性）、SL3（信誉评分）
+- 实现 SS2（PII 检测）、SS3（敏感输出检测）
+- `~/.dsh/security.json` 配置文件支持
+- `--security-only` 标志
+
+### 部署验证（Day 1）
+
+- 同步到用户 profile，Web GUI 诊断面板显示 🔒 Security 区域
+- 修复 SL3 对 @local/* 包的误报
+- 50/50 测试全绿 + dsh-doctor 54/54 测试全绿
+
+---
 
 ## 架构
 
 ```
-┌──────────────────────────────────────────────────┐
-│  Layer 0: Check Protocol（统一协议）              │
-│  • Severity: CRITICAL/HIGH/MEDIUM/LOW/INFO       │
-│  • Phase: PRE/POST/RUNTIME/LIFECYCLE             │
-│  • Plugin Interface（外部工具注册检查）            │
-├──────────────────────────────────────────────────┤
-│  Layer 1: Static Checks（静态检查）               │
-│  • SP2: 密钥扫描（硬编码 API key/token/私钥）     │
-│  • SS1: 凭据泄露检测（会话日志扫描）              │
-├──────────────────────────────────────────────────┤
-│  Layer 2: Runtime Checks（运行时检查）            │
-│  • SR1-SR4: 即将实现                             │
-├──────────────────────────────────────────────────┤
-│  Layer 3: Lifecycle Checks（生命周期检查）        │
-│  • SL1-SL4: 即将实现                             │
-└──────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────┐
+│  Layer 0: Check Protocol（统一协议）                       │
+│  • Severity: CRITICAL / HIGH / MEDIUM / LOW / INFO        │
+│  • Phase: PRE_INSTALL / POST_INSTALL / RUNTIME / LIFECYCLE│
+│  • Plugin Interface（外部工具注册检查）                     │
+├──────────────────────────────────────────────────────────┤
+│  Layer 1: Static Checks（静态检查，安装前后）              │
+│  SP1: 依赖链审计 (npm audit)                              │
+│  SP2: 密钥扫描 (正则匹配 API key/token/私钥)              │
+│  SP3: 沙箱策略一致性 (cordis.patch.yml 审计)              │
+│  SP4: 恶意 entry 注入检测                                 │
+│  SP5: 插件权限声明验证                                    │
+│  SP6: 已知漏洞匹配 (OSV/CVE/GHSA)                        │
+│  SS1: 凭据泄露检测 (会话日志)                             │
+│  SS2: PII 数据暴露检测                                    │
+│  SS3: 插件输出敏感数据检测                                │
+├──────────────────────────────────────────────────────────┤
+│  Layer 2: Runtime Checks（运行时，基于会话日志）           │
+│  SR1: 沙箱逃逸检测 (#1769 mount remount 等)              │
+│  SR2: 权限提升检测 (sudo/chmod/chown)                     │
+│  SR3: 数据外泄检测 (凭据转发/网络外发)                     │
+│  SR4: 插件隔离验证 (跨插件数据泄漏)                       │
+├──────────────────────────────────────────────────────────┤
+│  Layer 3: Lifecycle Checks（生命周期）                     │
+│  SL1: 供应链完整性 (npm registry 一致性)                  │
+│  SL2: 更新完整性 (版本回退检测)                           │
+│  SL3: 插件信誉评分 (维护者/更新频率)                      │
+│  SL4: 发布兼容性 (dist-tags 一致性)                       │
+├──────────────────────────────────────────────────────────┤
+│  External Integrations（外部工具集成）                     │
+│  EXT-PG-1: dsh-poison-guard (投毒扫描)                   │
+│  EXT-SA-1: dsh-sandbox-audit (沙箱审计)                  │
+│  EXT-ECO-1: dsh-ecosystem (生态兼容性)                   │
+│  EXT-RED-1: dsh-plugin-reducer (故障最小化)              │
+└──────────────────────────────────────────────────────────┘
 ```
 
+---
+
 ## 快速开始
 
+### CLI 使用
+
+```bash
+# 只跑安全检查（最快）
+dsh-doctor --security --security-only --profile web
+
+# 完整诊断 + 安全检查
+dsh-doctor --json --envelope --security --profile web
+
+# 检查会话日志
+dsh-doctor --security --session /path/to/session.jsonl
+
+# JSON 输出（程序化处理）
+dsh-doctor --json --envelope --security --profile web
+```
+
+### Web GUI
+
+重启 dsh web 后，设置→诊断面板会显示 🔒 Security 区域：
+
+```
+== 🔒 安全 ==
+  ✅ [SP1] 依赖链无已知漏洞
+  ✅ [SP2] 未检测到硬编码密钥
+  ✅ [SP3] 沙箱策略配置一致
+  ❌ [SL1] 检测到 2 个供应链问题
+  ...
+```
+
+### 编程接口
+
 ```javascript
 import { createDefaultRegistry } from '@moonquake2004/dsh-security';
 
@@ -49,37 +141,94 @@ const { results, exitCode, summary } = await registry.runAll(
   (check) => profileDir  // 为每个检查提供上下文
 );
 
-console.log({ exitCode, summary });
-// { exitCode: 0, summary: { critical: 0, high: 0, medium: 0, low: 0, info: 0 } }
+// summary: { critical: 0, high: 0, medium: 0, low: 0, info: 0, skipped: 0 }
+// results 中 skipped=true 的项代表"因外部条件未真正执行"（离线、工具缺失等），
+// 不计入失败统计，也不影响 exitCode。
+// exitCode: 0=通过或只有 MEDIUM 及以下失败, 1=有HIGH, 2=有CRITICAL
 ```
 
-## 内置检查
+### 配置注入（可选）
 
-| ID | 名称 | Severity | Phase | 描述 |
-|---|---|---|---|---|
-| SP2 | secret-scan | HIGH/CRITICAL | POST_INSTALL | 配置文件硬编码密钥检测 |
-| SS1 | credential-leak | CRITICAL | POST_INSTALL | 会话日志凭据泄露检测 |
+```javascript
+import { createDefaultRegistry, loadConfig } from '@moonquake2004/dsh-security';
+
+const registry = await createDefaultRegistry();
+registry.setConfig(loadConfig()); // 读 ~/.dsh/security.json；不注入则全部启用
+```
+
+### 退出码含义
+
+| exitCode | 含义 |
+|---|---|
+| 0 | 全部通过或只有 INFO/LOW |
+| 1 | 有 HIGH 级别问题 |
+| 2 | 有 CRITICAL 级别问题 |
+
+---
 
 ## 外部工具集成
 
-通过 `~/.dsh/security/checks.d/*.json` 注册外部检查：
+dsh-security 通过自动探测集成以下优秀开源项目。**探测方式为检查 `PATH` 中的可执行文件**（不会用 `npx` 触发包下载执行）；未安装时对应检查返回 skip 并注明原因，网络类数据源离线时同样 skip 而非谎报通过。
+
+dsh-security 通过 Plugin Interface 集成以下优秀开源项目：
+
+### [dsh-poison-guard](https://github.com/zoahdev/dsh-poison-guard) — 投毒扫描
+
+> **感谢 [@zoahdev](https://github.com/zoahdev)** 开发的投毒扫描工具，提供 AST 分析（JS-X-Ray）+ 反混淆解码能力。
+
+dsh-security 自动检测 dsh-poison-guard 是否已安装，如已安装则集成投毒扫描检查（EXT-PG-1）。
+
+### [dsh-sandbox-audit](https://github.com/zoahdev/dsh-sandbox-audit) — 沙箱策略审计
+
+> **感谢 [@zoahdev](https://github.com/zoahdev)** 开发的沙箱策略审计工具，提供静态 cordis.patch.yml 策略一致性检查。
+
+dsh-security 自动检测 dsh-sandbox-audit 是否已安装，如已安装则集成沙箱审计检查（EXT-SA-1）。
+
+### [dsh-ecosystem](https://github.com/zoahdev/dsh-ecosystem) — 生态兼容性数据
+
+> **感谢 [@zoahdev](https://github.com/zoahdev)** 维护的 DSH 生态地图，提供发布兼容性报告、bug 雷达、生态健康数据。
+
+dsh-security 通过网络 API 获取生态兼容性数据，自动检查已知 breaking changes 和 critical bugs（EXT-ECO-1）。
+
+### [dsh-plugin-reducer](https://github.com/ArmyWas/dsh-plugin-reducer) — 故障最小化
+
+> **感谢 [@ArmyWas](https://github.com/ArmyWas)** 开发的插件故障最小化工具，用 delta debugging 找到最小故障插件集。
+
+dsh-security 自动检测 dsh-plugin-reducer 是否已安装，如已安装则在检测到故障时提供最小化建议（EXT-RED-1）。
+
+### [npm audit](https://docs.npmjs.com/cli/v9/commands/npm-audit) — 依赖漏洞扫描
+
+SP1 检查集成 npm audit，自动扫描 profile 中依赖的已知漏洞。
+
+### [OSV](https://osv.dev/) — 已知漏洞数据库
+
+SP6 检查通过 OSV API 查询 npm 包的已知漏洞（CVE/GHSA）。
+
+---
+
+## 配置
+
+创建 `~/.dsh/security.json` 自定义安全检查行为（需调用方注入 `registry.setConfig(loadConfig())` 才生效；未注入时全部检查启用）：
 
 ```json
 {
-  "source": "dsh-poison-guard",
-  "version": "0.2.0",
-  "checks": [
-    {
-      "id": "EXT-PG-1",
-      "name": "poison-scan",
-      "severity": "high",
-      "phase": "pre-install",
-      "command": "dsh-poison-guard scan --json"
-    }
-  ]
+  "enabled": true,
+  "checks": {
+    "SP1": { "enabled": true },
+    "SR1": { "enabled": false }
+  },
+  "severityThreshold": "medium"
 }
 ```
 
+- `enabled: false`：停用整个框架
+- `checks.{ID}.enabled: false`：停用单个检查
+- `severityThreshold`（`low`/`medium`/`high`）：低于阈值的失败降级为 skip，不进失败统计与退出码
+
+会话日志检查（SS1/SS2/SR1-SR4）支持 zstd 压缩的 `session.jsonl.zstd`，依赖系统 `zstd` 命令。
+
+---
+
 ## 开发
 
 ```bash
@@ -90,12 +239,44 @@ node --test test/*.mjs
 # 1. 创建 src/checks/xx-check-name.mjs
 # 2. 导出 runner 函数和 check 对象
 # 3. 在 src/checks/index.mjs 中注册
-# 4. 添加测试
+# 4. 在 src/registry.mjs 中添加 import
+# 5. 添加测试
 ```
 
-## 设计文档
+### 项目结构
+
+```
+dsh-security/
+├── src/
+│   ├── protocol/          # Layer 0: Check Protocol
+│   ├── checks/            # 17 个内置检查
+│   ├── integrations/      # 4 个外部工具集成
+│   ├── session-reader.mjs # 会话日志读取（明文 + zstd）
+│   ├── registry.mjs       # Check Registry（支持 setConfig 注入配置）
+│   ├── config.mjs         # 配置管理
+│   └── index.mjs          # 主入口
+├── test/                  # 测试
+└── docs/plans/design.md   # 设计文档
+```
+
+---
+
+## 致谢
+
+本项目的实现得益于以下开源项目的启发和集成：
+
+| 项目 | 作者 | 贡献 |
+|---|---|---|
+| [dsh-poison-guard](https://github.com/zoahdev/dsh-poison-guard) | [@zoahdev](https://github.com/zoahdev) | AST 投毒扫描能力 |
+| [dsh-sandbox-audit](https://github.com/zoahdev/dsh-sandbox-audit) | [@zoahdev](https://github.com/zoahdev) | 沙箱策略审计方法论 |
+| [dsh-ecosystem](https://github.com/zoahdev/dsh-ecosystem) | [@zoahdev](https://github.com/zoahdev) | 生态兼容性数据源 |
+| [dsh-plugin-reducer](https://github.com/ArmyWas/dsh-plugin-reducer) | [@ArmyWas](https://github.com/ArmyWas) | 故障最小化算法 |
+| [dsh-doctor](https://github.com/moonquake2004/dsh-doctor) | [@moonquake2004](https://github.com/moonquake2004) | 执行框架 + P1-P14 检查 |
+| [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) | [@deepseek-ai](https://github.com/deepseek-ai) | DSH 平台 |
+
+特别感谢 DSH 生态的社区贡献者们，你们的工作让这个安全框架成为可能。
 
-- [完整设计](docs/plans/2026-08-18-security-framework-design.md)
+---
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moonquake2004/dsh-security",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Unified security check framework for DeepSeek Harness ecosystem — covers the full plugin lifecycle (discovery → install → runtime → update → retirement)",
   "type": "module",
   "main": "src/index.mjs",

package/src/checks/sl1-supply-chain.mjs

@@ -2,9 +2,12 @@
  * SL1: Supply Chain Integrity — 供应链完整性验证
  *
  * 验证 profile 中已安装的包与 npm registry 上的版本一致：
- * - 版本号匹配
- * - integrity hash 匹配（SHA-512）
- * - 检测潜在的包劫持（版本存在但内容不匹配）
+ * - 版本号匹配（本地 vs dist-tags.latest）
+ * - integrity hash 匹配：以 pnpm-lock.yaml 中锁定的 sha512 为本地基准，
+ *   与 registry versions[localVersion].dist.integrity 比对，检测发布被篡改/覆盖。
+ *   （复审修复：安装产物 package.json 本身不含 integrity 字段，旧实现该分支永不生效）
+ *
+ * 网络不可达时返回 skip（不再静默当作通过）。
  *
  * Severity: HIGH
  * Phase: LIFECYCLE
@@ -12,17 +15,17 @@
 
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { execSync } from 'node:child_process';
 import { Severity, maxSeverity } from '../protocol/severity.mjs';
 import { CheckPhase } from '../protocol/phase.mjs';
-import { pass, fail } from '../protocol/check.mjs';
+import { pass, fail, skip } from '../protocol/check.mjs';
 
 /**
  * 获取 npm registry 上的包信息
  */
 async function fetchRegistryInfo(pkgName) {
   try {
-    const url = `https://registry.npmjs.org/${encodeURIComponent(pkgName).replace(/%2f/g, '/')}`;
+    // encodeURIComponent 对 scoped 名产生 %2F，npm registry 接受该规范形式
+    const url = `https://registry.npmjs.org/${encodeURIComponent(pkgName)}`;
     const response = await fetch(url, { signal: AbortSignal.timeout(10000) });
     if (!response.ok) return null;
     return await response.json();
@@ -31,10 +34,25 @@ async function fetchRegistryInfo(pkgName) {
   }
 }
 
+/**
+ * 从 pnpm-lock.yaml 提取 <name>@<version> 锁定的 integrity（sha512-...）。
+ * 零依赖实现：只做定位 key 行 + 向后小窗口找 resolution.integrity。
+ */
+export function extractLockIntegrity(lockText, pkgName, version) {
+  if (!lockText || !pkgName || !version) return null;
+  const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const keyRe = new RegExp(`^\\s{2}['"]?${esc(pkgName)}@${esc(version)}['"]?:\\s*$`, 'm');
+  const m = keyRe.exec(lockText);
+  if (!m) return null;
+  const window = lockText.slice(m.index, m.index + 500);
+  const im = /integrity:\s*(sha[0-9]+-[A-Za-z0-9+/=]+)/.exec(window);
+  return im ? im[1] : null;
+}
+
 /**
  * 比较本地安装版本与 registry 版本
  */
-function compareVersions(localPkg, registryInfo) {
+export function compareVersions(localPkg, registryInfo, localLockIntegrity = null) {
   const issues = [];
   const localVersion = localPkg.version;
   const latestVersion = registryInfo['dist-tags']?.latest;
@@ -48,16 +66,16 @@ function compareVersions(localPkg, registryInfo) {
     });
   }
 
-  // integrity 比较
-  const localIntegrity = localPkg._integrity || localPkg.dist?.integrity;
+  // integrity 比较：优先用 pnpm-lock.yaml 锁定值；registry 同版本被篡改/覆盖时会不一致
   const registryVersion = registryInfo.versions?.[localVersion];
   const registryIntegrity = registryVersion?.dist?.integrity;
+  const localIntegrity = localLockIntegrity || localPkg._integrity || null;
 
   if (localIntegrity && registryIntegrity && localIntegrity !== registryIntegrity) {
     issues.push({
       type: 'integrity-mismatch',
       severity: 'critical',
-      detail: `integrity hash 不匹配：本地 ${localIntegrity.slice(0, 30)}... ≠ registry ${registryIntegrity.slice(0, 30)}...`,
+      detail: `integrity hash 不匹配：本地 ${String(localIntegrity).slice(0, 30)}... ≠ registry ${String(registryIntegrity).slice(0, 30)}...`,
     });
   }
 
@@ -85,7 +103,6 @@ export async function run(profileDir) {
   }
 
   const deps = manifest.dependencies || {};
-  const bundleNames = manifest.dsh?.profile?.bundles || [];
 
   // 只检查 dsh 相关的包（减少 API 调用）
   const dshPackages = Object.keys(deps).filter(name =>
@@ -96,6 +113,12 @@ export async function run(profileDir) {
     return pass(id, Severity.HIGH, 'profile 无 dsh 相关依赖，跳过供应链验证');
   }
 
+  const lockPath = join(profileDir, 'pnpm-lock.yaml');
+  let lockText = null;
+  try {
+    if (existsSync(lockPath)) lockText = readFileSync(lockPath, 'utf8');
+  } catch { lockText = null; }
+
   const allIssues = [];
   let checked = 0;
   let errors = 0;
@@ -113,7 +136,8 @@ export async function run(profileDir) {
         continue;
       }
 
-      const issues = compareVersions(localPkg, registryInfo);
+      const lockIntegrity = lockText ? extractLockIntegrity(lockText, pkgName, localPkg.version) : null;
+      const issues = compareVersions(localPkg, registryInfo, lockIntegrity);
       for (const issue of issues) {
         allIssues.push({ package: pkgName, ...issue });
       }
@@ -123,6 +147,11 @@ export async function run(profileDir) {
     }
   }
 
+  // 全部查询失败 → skip（离线时不应谎报"无异常"）
+  if (checked === 0 && errors > 0) {
+    return skip(id, Severity.HIGH, `${errors} 个包 registry 查询失败（离线或网络受限），跳过供应链验证`);
+  }
+
   if (allIssues.length === 0) {
     return pass(id, Severity.HIGH,
       `验证 ${checked} 个包的供应链完整性，未发现异常${errors > 0 ? `（${errors} 个包查询失败）` : ''}`
@@ -130,7 +159,7 @@ export async function run(profileDir) {
   }
 
   const criticalIssues = allIssues.filter(i => i.severity === 'critical');
-  const overallSeverity = criticalIssues.length > 0 ? Severity.CRITICAL : Severity.HIGH;
+  const overallSeverity = criticalIssues.length > 0 ? Severity.CRITICAL : maxSeverity(allIssues.map(i => i.severity === 'critical' ? Severity.CRITICAL : i.severity === 'medium' ? Severity.MEDIUM : Severity.LOW));
 
   const details = allIssues
     .map(i => `[${i.severity}] ${i.package} — ${i.type}: ${i.detail}`)
@@ -141,7 +170,7 @@ export async function run(profileDir) {
     : '部分包版本落后于 registry latest，建议更新';
 
   return fail(id, overallSeverity,
-    `检测到 ${allIssues.length} 个供应链问题（${checked} 个包已验证）：\n${details}`,
+    `检测到 ${allIssues.length} 个供应链问题（${checked} 个包已验证${errors > 0 ? `，${errors} 个查询失败` : ''}）：\n${details}`,
     fix
   );
 }
@@ -151,7 +180,7 @@ export const sl1Check = {
   name: 'supply-chain-integrity',
   severity: Severity.HIGH,
   phase: CheckPhase.LIFECYCLE,
-  description: '供应链完整性验证（npm registry 一致性）',
+  description: '供应链完整性验证（npm registry 一致性 + pnpm-lock integrity 比对）',
   src: 'builtin',
   runner: (profileDir) => run(profileDir),
 };

package/src/checks/sl3-reputation-score.mjs

@@ -2,10 +2,11 @@
  * SL3: Reputation Score — 插件信誉评分
  *
  * 基于 npm registry 信号评估插件信誉：
- * - 下载量
  * - 维护者数量
  * - 最近更新时间
- * - 依赖数量
+ *
+ * （对齐实现：下载量/依赖数量信号未落地，不再在注释中宣称）
+ * 网络不可达时返回 skip（此前会把"查询失败"当 concern 误报 fail）。
  *
  * Severity: LOW
  * Phase: LIFECYCLE
@@ -15,11 +16,11 @@ import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { Severity } from '../protocol/severity.mjs';
 import { CheckPhase } from '../protocol/phase.mjs';
-import { pass, fail } from '../protocol/check.mjs';
+import { pass, fail, skip } from '../protocol/check.mjs';
 
 async function fetchNpmInfo(pkgName) {
   try {
-    const url = `https://registry.npmjs.org/${encodeURIComponent(pkgName).replace(/%2f/g, '/')}`;
+    const url = `https://registry.npmjs.org/${encodeURIComponent(pkgName)}`;
     const response = await fetch(url, { signal: AbortSignal.timeout(10000) });
     if (!response.ok) return null;
     return await response.json();
@@ -39,16 +40,20 @@ export async function run(profileDir) {
   const dshPackages = Object.keys(deps).filter(n => {
     if (!n.includes('dsh') && !n.includes('deepseek')) return false;
     if (n.startsWith('@local/')) return false;           // 本地包
-    if (deps[n].startsWith('file:')) return false;       // 文件依赖
-    if (deps[n].startsWith('github:')) return false;     // GitHub 依赖
+    if (typeof deps[n] === 'string' && deps[n].startsWith('file:')) return false;   // 文件依赖
+    if (typeof deps[n] === 'string' && deps[n].startsWith('github:')) return false; // GitHub 依赖
     return true;
   });
   if (dshPackages.length === 0) return pass(id, Severity.LOW, '无 npm 上的 dsh 相关依赖，跳过信誉评分');
 
   const concerns = [];
+  let netFailures = 0;
+  let evaluated = 0;
+
   for (const name of dshPackages.slice(0, 10)) {
     const info = await fetchNpmInfo(name);
-    if (!info) { concerns.push({ package: name, concern: 'registry 查询失败' }); continue; }
+    if (!info) { netFailures++; continue; }
+    evaluated++;
     const latest = info['dist-tags']?.latest;
     const ver = info.versions?.[latest];
     if (!ver) continue;
@@ -65,9 +70,17 @@ export async function run(profileDir) {
     }
   }
 
-  if (concerns.length === 0) return pass(id, Severity.LOW, `评估 ${dshPackages.length} 个包的信誉，无异常`);
+  // 全部查询失败 → skip（离线时不应把"查不到"当"有 concern"）
+  if (concerns.length === 0 && evaluated === 0 && netFailures > 0) {
+    return skip(id, Severity.LOW, `${netFailures} 个包 registry 查询失败（离线或网络受限），跳过信誉评分`);
+  }
+
+  const failureNote = netFailures > 0 ? `\n（另有 ${netFailures} 个包查询失败未评估）` : '';
+  if (concerns.length === 0) {
+    return pass(id, Severity.LOW, `评估 ${evaluated} 个包的信誉，无异常${failureNote.trim()}`);
+  }
   const details = concerns.map(c => `${c.package}: ${c.concern}`).join('\n');
-  return fail(id, Severity.LOW, `检测到 ${concerns.length} 个信誉关注点：\n${details}`, '考虑替换长期未维护的包');
+  return fail(id, Severity.LOW, `检测到 ${concerns.length} 个信誉关注点：\n${details}${failureNote}`, '考虑替换长期未维护的包');
 }
 
 export const sl3Check = { id: 'SL3', name: 'reputation-score', severity: Severity.LOW, phase: CheckPhase.LIFECYCLE, description: '插件信誉评分', src: 'builtin', runner: (d) => run(d) };

package/src/checks/sl4-release-compat.mjs

@@ -1,11 +1,12 @@
 /**
  * SL4: Release Compatibility — 发布兼容性验证
  *
- * 验证 profile 中包的 dist-tags 与 DSH 版本的兼容性：
- * - 检测 latest 指向 broken 版本
- * - 检测 next/rc 标签与本地版本的差异
- * - 验证 peerDependencies 兼容性
+ * 验证 profile 中包的 dist-tags 与本地版本的差异：
+ * - 检测 major 版本落后
+ * - 检测 latest 指向 rc/beta 预发布
+ * - 提示可用的 next 标签
  *
+ * （对齐实现：peerDependencies 兼容性验证未落地，不再宣称）
  * Severity: MEDIUM
  * Phase: LIFECYCLE
  */
@@ -14,14 +15,14 @@ import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { Severity, maxSeverity } from '../protocol/severity.mjs';
 import { CheckPhase } from '../protocol/phase.mjs';
-import { pass, fail } from '../protocol/check.mjs';
+import { pass, fail, skip } from '../protocol/check.mjs';
 
 /**
  * 获取 npm registry dist-tags
  */
 async function fetchDistTags(pkgName) {
   try {
-    const url = `https://registry.npmjs.org/${encodeURIComponent(pkgName).replace(/%2f/g, '/')}`;
+    const url = `https://registry.npmjs.org/${encodeURIComponent(pkgName)}`;
     const response = await fetch(url, { signal: AbortSignal.timeout(10000) });
     if (!response.ok) return null;
     const data = await response.json();
@@ -106,6 +107,7 @@ export async function run(profileDir) {
 
   const allIssues = [];
   let checked = 0;
+  let errors = 0;
 
   for (const pkgName of dshPackages.slice(0, 10)) {
     const localPkgPath = join(profileDir, 'node_modules', pkgName, 'package.json');
@@ -115,7 +117,7 @@ export async function run(profileDir) {
       const localPkg = JSON.parse(readFileSync(localPkgPath, 'utf8'));
       const distTags = await fetchDistTags(pkgName);
 
-      if (!distTags) continue;
+      if (!distTags) { errors++; continue; }
 
       const issues = checkCompatibility(localPkg.version, distTags);
       for (const issue of issues) {
@@ -123,13 +125,18 @@ export async function run(profileDir) {
       }
       checked++;
     } catch {
-      // 跳过查询失败的包
+      errors++;
     }
   }
 
+  // 全部查询失败 → skip（离线时不应谎报"无异常"）
+  if (checked === 0 && errors > 0) {
+    return skip(id, Severity.MEDIUM, `${errors} 个包 registry 查询失败（离线或网络受限），跳过发布兼容性验证`);
+  }
+
   if (allIssues.length === 0) {
     return pass(id, Severity.MEDIUM,
-      `验证 ${checked} 个包的发布兼容性，无异常`
+      `验证 ${checked} 个包的发布兼容性，无异常${errors > 0 ? `（${errors} 个查询失败）` : ''}`
     );
   }
 

package/src/checks/sp2-secret-scan.mjs

@@ -75,7 +75,9 @@ function scanDirectory(dir, profileDir, extensions = ['.yml', '.yaml', '.json',
 
   const entries = readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    // 点文件默认跳过，但 .env / *.env 是密钥重灾区，必须扫描（复审修复：此前 .env 永不被扫）
+    const isEnvFile = entry.name === '.env' || entry.name.endsWith('.env');
+    if ((entry.name.startsWith('.') && !isEnvFile) || entry.name === 'node_modules') continue;
     const fullPath = join(dir, entry.name);
     if (entry.isDirectory()) {
       findings.push(...scanDirectory(fullPath, profileDir, extensions));

package/src/checks/sp4-entry-poison.mjs

@@ -15,6 +15,7 @@ import { join } from 'node:path';
 import { Severity } from '../protocol/severity.mjs';
 import { CheckPhase } from '../protocol/phase.mjs';
 import { pass, fail } from '../protocol/check.mjs';
+import { maxSeverity } from '../protocol/severity.mjs';
 
 /** 已知恶意 entry 模式 */
 const MALICIOUS_PATTERNS = [
@@ -68,7 +69,9 @@ export async function run(profileDir) {
   if (allFindings.length === 0) return pass(id, Severity.HIGH, `扫描 ${patchFiles.length} 个 patch 文件，未检测到恶意 entry 模式`);
 
   const details = allFindings.slice(0, 10).map(f => `[${f.severity}] ${f.type}: ${f.snippet}`).join('\n');
-  return fail(id, Severity.HIGH, `检测到 ${allFindings.length} 个可疑 entry 模式：\n${details}`, '检查相关插件的 cordis.patch.yml 内容');
+  // 复审修复：按实际命中的最高严重度定级，medium 级命中不再一律拔高成 HIGH
+  const overallSeverity = maxSeverity(allFindings.map(f => f.severity));
+  return fail(id, overallSeverity, `检测到 ${allFindings.length} 个可疑 entry 模式：\n${details}`, '检查相关插件的 cordis.patch.yml 内容', ['#2066']);
 }
 
 export const sp4Check = { id: 'SP4', name: 'entry-poison', severity: Severity.HIGH, phase: CheckPhase.POST_INSTALL, description: '恶意 entry 注入检测', src: 'builtin', runner: (d) => run(d) };