@moonquake2004/dsh-security 0.1.0 → 0.1.1

package/src/checks/sp5-permission-model.mjs

@@ -37,21 +37,39 @@ export async function run(profileDir) {
   const issues = [];
   for (const entry of readdirSync(nmDir, { withFileTypes: true })) {
     if (entry.name.startsWith('.') || entry.name === '.bin') continue;
-    const pkgPath = join(nmDir, entry.name, 'package.json');
-    if (!existsSync(pkgPath)) continue;
+    // scoped 包（@scope/pkg）：复审修复——此前把 @scope 当包名拼路径，scoped 插件全部漏扫
+    if (entry.isDirectory() && entry.name.startsWith('@')) {
+      const scopeDir = join(nmDir, entry.name);
+      let pkgs = [];
+      try { pkgs = readdirSync(scopeDir, { withFileTypes: true }); } catch { continue; }
+      for (const pkg of pkgs) {
+        if (!pkg.isDirectory()) continue;
+        issues.push(...inspectPackage(join(scopeDir, pkg.name), join(entry.name, pkg.name)));
+      }
+      continue;
+    }
+    if (!entry.isDirectory()) continue;
+    issues.push(...inspectPackage(join(nmDir, entry.name), entry.name));
+  }
+
+  function inspectPackage(pkgDir, displayName) {
+    const found = [];
+    const pkgPath = join(pkgDir, 'package.json');
+    if (!existsSync(pkgPath)) return found;
     try {
       const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
-      if (!pkg.dsh?.bundle) continue;
-      const patchPath = join(nmDir, entry.name, 'cordis.patch.yml');
+      if (!pkg.dsh?.bundle) return found;
+      const patchPath = join(pkgDir, 'cordis.patch.yml');
       if (existsSync(patchPath)) {
         const content = readFileSync(patchPath, 'utf8');
-        issues.push(...scanForUndeclaredCapabilities(content, pkg.name));
+        found.push(...scanForUndeclaredCapabilities(content, pkg.name || displayName));
       }
     } catch { /* skip */ }
+    return found;
   }
 
   if (issues.length === 0) return pass(id, Severity.MEDIUM, '插件权限声明一致');
-  const details = issues.slice(0, 10).map(i => `[${i.severity}] ${i.detail}`).join('\n');
+  const details = issues.slice(0, 10).map(i => `[${i.severity}] ${i.type}: ${i.detail}`).join('\n');
   return fail(id, Severity.MEDIUM, `检测到 ${issues.length} 个权限声明问题：\n${details}`, '为插件显式声明所需的权限范围');
 }
 

package/src/checks/sp6-vuln-match.mjs

@@ -3,8 +3,8 @@
  *
  * 通过 OSV API 查询已知漏洞（CVE/GHSA）：
  * - 查询 npm 包的已知漏洞
- * - 过滤 critical/high 级别
- * - 输出受影响的包和修复版本
+ * - 按 OSV 严重级别映射整体结果严重度，detail 标注 critical/high 数量
+ * - 输出受影响的包与漏洞编号（references）
  *
  * Severity: HIGH
  * Phase: POST_INSTALL
@@ -14,8 +14,12 @@ 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';
 
+/**
+ * 查询 OSV API。
+ * @returns {Promise<Array|null>} 成功返回漏洞数组（可能为空）；网络失败返回 null
+ */
 async function queryOSV(packageName, version) {
   try {
     const response = await fetch('https://api.osv.dev/v1/query', {
@@ -24,15 +28,22 @@ async function queryOSV(packageName, version) {
       body: JSON.stringify({ package: { name: packageName, ecosystem: 'npm' }, version }),
       signal: AbortSignal.timeout(10000),
     });
-    if (!response.ok) return [];
+    if (!response.ok) return null;
     const data = await response.json();
     return (data.vulns || []).map(v => ({
       id: v.id,
       summary: v.summary || v.details?.slice(0, 100) || 'No summary',
       severity: v.database_specific?.severity || v.severity?.[0]?.score || 'unknown',
-      fixed: v.fix_versions?.[0] || 'unknown',
     }));
-  } catch { return []; }
+  } catch { return null; }
+}
+
+function osvSeverityToLevel(sev) {
+  const s = String(sev).toUpperCase();
+  if (s.includes('CRITICAL')) return Severity.CRITICAL;
+  if (s.includes('HIGH')) return Severity.HIGH;
+  if (s.includes('MODERATE') || s.includes('MEDIUM')) return Severity.MEDIUM;
+  return Severity.LOW;
 }
 
 export async function run(profileDir) {
@@ -48,19 +59,37 @@ export async function run(profileDir) {
   if (dshPackages.length === 0) return pass(id, Severity.HIGH, '无 dsh 相关依赖，跳过漏洞匹配');
 
   const allVulns = [];
+  const refs = new Set();
+  let okQueries = 0;
+  let failedQueries = 0;
   for (const [name, version] of dshPackages.slice(0, 10)) {
+    // 只去掉首个范围前缀字符；workspace:/catalog:/file: 等协议版本无法映射，原样传给 OSV（查询无结果）
     const cleanVersion = version.replace(/^[~^>=<]/, '');
     const vulns = await queryOSV(name, cleanVersion);
+    if (vulns === null) { failedQueries++; continue; }
+    okQueries++;
     allVulns.push(...vulns.map(v => ({ package: name, ...v })));
+    for (const v of vulns) if (v.id) refs.add(v.id);
+  }
+
+  // 全部查询失败 → skip（离线时不应谎报"未发现已知漏洞"）
+  if (okQueries === 0 && failedQueries > 0) {
+    return skip(id, Severity.HIGH, `OSV API 不可达（${failedQueries} 个包全部查询失败），跳过已知漏洞匹配`);
+  }
+
+  if (allVulns.length === 0) {
+    const note = failedQueries > 0 ? `（${failedQueries} 个包查询失败未覆盖）` : '';
+    return pass(id, Severity.HIGH, `成功查询 ${okQueries}/${dshPackages.length} 个包，未发现已知漏洞${note}`);
   }
 
-  if (allVulns.length === 0) return pass(id, Severity.HIGH, `查询 ${dshPackages.length} 个包，未发现已知漏洞`);
+  const details = allVulns.slice(0, 10).map(v => `${v.package} — ${v.id}: ${v.summary}（severity: ${v.severity}）`).join('\n');
+  const overallSeverity = maxSeverity(allVulns.map(v => osvSeverityToLevel(v.severity)));
+  const criticalHigh = allVulns.filter(v => ['critical', 'high'].includes(osvSeverityToLevel(v.severity))).length;
 
-  const details = allVulns.slice(0, 10).map(v => `${v.package} — ${v.id}: ${v.summary}（fixed: ${v.fixed}）`).join('\n');
-  const fixable = allVulns.filter(v => v.fixed !== 'unknown').length;
-  return fail(id, Severity.HIGH,
-    `检测到 ${allVulns.length} 个已知漏洞（${fixable} 个可修复）：\n${details}`,
-    fixable > 0 ? '升级受影响的包到修复版本' : '关注上游修复进展'
+  return fail(id, overallSeverity,
+    `检测到 ${allVulns.length} 个已知漏洞（critical/high ${criticalHigh} 个）：\n${details}`,
+    '按 OSV 建议升级受影响的包到修复版本',
+    [...refs].slice(0, 5)
   );
 }
 

package/src/checks/sr1-sandbox-violation.mjs

@@ -1,20 +1,22 @@
 /**
  * SR1: Sandbox Violation — 沙箱逃逸检测
  *
- * 分析会话日志中的工具调用，检测潜在的沙箱逃逸行为：
- * - 写操作超出 workspace 范围
- * - 访问系统级资源（/etc, /proc, 环境变量）
+ * 分析会话日志中的工具调用（tool/call），检测潜在的沙箱逃逸行为：
+ * - 访问系统级资源（/etc, /proc）
  * - 已知逃逸模式匹配（#1769 mount remount 等）
+ * - 管道执行远程脚本
+ *
+ * 支持明文与 zstd 压缩会话日志（session-reader）。
  *
  * Severity: CRITICAL
  * Phase: RUNTIME
  */
 
-import { readFileSync, existsSync, createReadStream } from 'node:fs';
-import { createInterface } from 'node:readline';
+import { existsSync } from 'node:fs';
 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';
+import { scanSessionLines } from '../session-reader.mjs';
 
 /** 已知逃逸模式（#1769 及同类） */
 const ESCAPE_PATTERNS = [
@@ -28,7 +30,8 @@ const ESCAPE_PATTERNS = [
 const SYSTEM_RESOURCE_PATTERNS = [
   { name: '/etc access', regex: /\/etc\/(passwd|shadow|sudoers|hosts)/gi, severity: 'high' },
   { name: '/proc access', regex: /\/proc\/(self|1|environ|cmdline)/gi, severity: 'high' },
-  { name: 'env dump', regex: /env\b|printenv|set\b.*\|/gi, severity: 'medium' },
+  // 复审修复：旧正则 /env\b|set\b.*\|/ 几乎命中一切文本；改为命令位置的 env/printenv 转储
+  { name: 'env dump', regex: /(?:^|["'|;&]\s*)(?:printenv|env)\s*(?:[|;"']|$)/gm, severity: 'medium' },
   { name: 'sudo usage', regex: /sudo\s+/gi, severity: 'high' },
   { name: 'curl/wget to unknown', regex: /curl\s+.*\|\s*(bash|sh|node)|wget\s+.*\|\s*(bash|sh|node)/gi, severity: 'critical' },
 ];
@@ -38,31 +41,30 @@ const WORKSPACE_ESCAPE_PATTERNS = [
   { name: 'write to /tmp', regex: /writeFileSync|writeFile|fs\.write|echo\s+.*>\s*\/tmp/gi, severity: 'low' },
   { name: 'write to home', regex: /writeFileSync|writeFile.*\/Users\/|\/home\//gi, severity: 'low' },
   { name: 'pipe to shell', regex: /\|\s*(bash|sh|zsh)\b/gi, severity: 'high' },
-  { name: 'exec subprocess', regex: /child_process|execSync|spawnSync|exec\b/gi, severity: 'medium' },
+  // 复审修复：去掉过宽的 exec\b（命中 "execute" 等普通词），保留具体进程 API
+  { name: 'exec subprocess', regex: /child_process|execSync|spawnSync/gi, severity: 'medium' },
 ];
 
 /**
- * 从一行 JSONL 中提取工具调用信息
+ * 从一行 JSONL 中提取工具调用信息（只看 tool/call：result 是数据不是行为）
  */
 function extractToolCalls(line) {
   try {
     const event = JSON.parse(line);
-    if (event.type !== 'tool/call' && event.type !== 'tool/result') return [];
+    if (event.type !== 'tool/call') return [];
 
-    const calls = [];
     const data = event.data || {};
     const name = data.name || data.tool || '';
     const args = data.args || data.input || {};
     const text = typeof args === 'string' ? args : JSON.stringify(args);
 
-    calls.push({
+    return [{
       type: event.type,
       name,
       text,
       seq: event.seq,
       turn: event.turn,
-    });
-    return calls;
+    }];
   } catch {
     return [];
   }
@@ -74,7 +76,8 @@ function extractToolCalls(line) {
 function scanPatterns(text, patterns) {
   const findings = [];
   for (const pattern of patterns) {
-    const matches = text.matchAll(new RegExp(pattern.regex.source, 'gi'));
+    const flags = [...new Set((pattern.regex.flags + 'g').split(''))].join('');
+    const matches = text.matchAll(new RegExp(pattern.regex.source, flags));
     for (const match of matches) {
       findings.push({
         type: pattern.name,
@@ -89,7 +92,7 @@ function scanPatterns(text, patterns) {
 
 /**
  * SR1 检查：分析会话日志中的沙箱逃逸行为
- * @param {string} sessionFile - 会话日志文件路径
+ * @param {string} sessionFile - 会话日志文件路径（.jsonl 或 .jsonl.zstd）
  * @returns {Promise<import('../protocol/check.mjs').SecurityCheckResult>}
  */
 export async function run(sessionFile) {
@@ -99,35 +102,26 @@ export async function run(sessionFile) {
     return pass(id, Severity.CRITICAL, '无会话日志，跳过运行时安全检查');
   }
 
-  if (sessionFile.endsWith('.zstd')) {
-    return pass(id, Severity.CRITICAL, 'zstd 压缩的会话文件需先解压再检查');
-  }
-
   const findings = [];
   let lineCount = 0;
 
-  const fileStream = createReadStream(sessionFile, { encoding: 'utf8' });
-  const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
-
-  for await (const line of rl) {
-    lineCount++;
-    if (!line.trim()) continue;
-
-    const calls = extractToolCalls(line);
-    for (const call of calls) {
-      // 扫描工具参数中的危险模式
-      const allPatterns = [...ESCAPE_PATTERNS, ...SYSTEM_RESOURCE_PATTERNS, ...WORKSPACE_ESCAPE_PATTERNS];
-      const textFindings = scanPatterns(call.text, allPatterns);
-      for (const f of textFindings) {
-        findings.push({
-          ...f,
-          line: lineCount,
-          tool: call.name,
-          seq: call.seq,
-          turn: call.turn,
-        });
+  try {
+    lineCount = await scanSessionLines(sessionFile, (line, lineNo) => {
+      if (!line.trim()) return;
+      const calls = extractToolCalls(line);
+      for (const call of calls) {
+        const allPatterns = [...ESCAPE_PATTERNS, ...SYSTEM_RESOURCE_PATTERNS, ...WORKSPACE_ESCAPE_PATTERNS];
+        const textFindings = scanPatterns(call.text, allPatterns);
+        for (const f of textFindings) {
+          findings.push({ ...f, line: lineNo, tool: call.name, seq: call.seq, turn: call.turn });
+        }
       }
+    });
+  } catch (e) {
+    if (e.code === 'ZSTD_UNAVAILABLE') {
+      return skip(id, Severity.CRITICAL, 'zstd 命令不可用，无法解压压缩会话日志，跳过沙箱逃逸检测');
     }
+    throw e;
   }
 
   if (findings.length === 0) {
@@ -171,7 +165,7 @@ export const sr1Check = {
   name: 'sandbox-violation',
   severity: Severity.CRITICAL,
   phase: CheckPhase.RUNTIME,
-  description: '沙箱逃逸行为检测（会话日志分析）',
+  description: '沙箱逃逸行为检测（会话日志分析，支持 zstd）',
   src: 'builtin',
   runner: (sessionFile) => run(sessionFile),
 };

package/src/checks/sr2-privilege-escalation.mjs

@@ -1,23 +1,26 @@
 /**
  * SR2: Privilege Escalation — 权限提升检测
  *
- * 分析会话日志中的权限提升行为：
+ * 分析会话日志中的工具调用（tool/call）中的权限提升行为：
  * - sudo/doas 使用
  * - 文件权限变更（chmod/chown）
- * - 特权端口绑定
+ * - setuid/setgid、Linux capability 操作
+ *
+ * 支持明文与 zstd 压缩会话日志（session-reader）。
  *
  * Severity: HIGH
  * Phase: RUNTIME
  */
 
-import { existsSync, createReadStream } from 'node:fs';
-import { createInterface } from 'node:readline';
+import { existsSync } from 'node:fs';
 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';
+import { scanSessionLines } from '../session-reader.mjs';
 
 const PRIVILEGE_PATTERNS = [
   { name: 'sudo usage', regex: /sudo\s+/gi, severity: 'high' },
+  { name: 'doas usage', regex: /\bdoas\s+/gi, severity: 'high' },
   { name: 'chmod', regex: /chmod\s+[^/]*\s+[0-7]*7[0-7][0-7]/gi, severity: 'medium' },
   { name: 'chown', regex: /chown\s+/gi, severity: 'medium' },
   { name: 'setuid', regex: /setuid|setgid/gi, severity: 'high' },
@@ -36,22 +39,26 @@ function extractToolCalls(line) {
 export async function run(sessionFile) {
   const id = 'SR2';
   if (!sessionFile || !existsSync(sessionFile)) return pass(id, Severity.HIGH, '无会话文件，跳过权限提升检测');
-  if (sessionFile.endsWith('.zstd')) return pass(id, Severity.HIGH, 'zstd 文件需先解压');
 
   const findings = [];
   let lineCount = 0;
-  const rl = createInterface({ input: createReadStream(sessionFile, { encoding: 'utf8' }), crlfDelay: Infinity });
 
-  for await (const line of rl) {
-    lineCount++;
-    if (!line.trim()) continue;
-    for (const call of extractToolCalls(line)) {
-      for (const pattern of PRIVILEGE_PATTERNS) {
-        for (const match of call.text.matchAll(new RegExp(pattern.regex.source, 'gi'))) {
-          findings.push({ type: pattern.name, severity: pattern.severity, line: lineCount, tool: call.name, snippet: match[0].slice(0, 40) });
+  try {
+    lineCount = await scanSessionLines(sessionFile, (line, lineNo) => {
+      if (!line.trim()) return;
+      for (const call of extractToolCalls(line)) {
+        for (const pattern of PRIVILEGE_PATTERNS) {
+          for (const match of call.text.matchAll(new RegExp(pattern.regex.source, 'gi'))) {
+            findings.push({ type: pattern.name, severity: pattern.severity, line: lineNo, tool: call.name, snippet: match[0].slice(0, 40) });
+          }
         }
       }
+    });
+  } catch (e) {
+    if (e.code === 'ZSTD_UNAVAILABLE') {
+      return skip(id, Severity.HIGH, 'zstd 命令不可用，无法解压压缩会话日志，跳过权限提升检测');
     }
+    throw e;
   }
 
   if (findings.length === 0) return pass(id, Severity.HIGH, `扫描 ${lineCount} 行，未检测到权限提升行为`);
@@ -64,4 +71,4 @@ export async function run(sessionFile) {
   );
 }
 
-export const sr2Check = { id: 'SR2', name: 'privilege-escalation', severity: Severity.HIGH, phase: CheckPhase.RUNTIME, description: '权限提升行为检测', src: 'builtin', runner: (f) => run(f) };
+export const sr2Check = { id: 'SR2', name: 'privilege-escalation', severity: Severity.HIGH, phase: CheckPhase.RUNTIME, description: '权限提升行为检测（支持 zstd）', src: 'builtin', runner: (f) => run(f) };

package/src/checks/sr3-data-exfiltration.mjs

@@ -1,20 +1,21 @@
 /**
  * SR3: Data Exfiltration — 数据外泄检测
  *
- * 分析会话日志中的工具调用，检测潜在的数据外泄行为：
- * - 大量文件读取后接网络请求
- * - 凭据转发（将密钥传递给外部工具）
- * - 异常的数据流模式
+ * 分析会话日志中的工具调用与结果，检测潜在的数据外泄行为：
+ * - 凭据转发（API key / token / Bearer 出现在命令或返回内容中）
+ * - 网络外发模式（curl POST、fetch 等）
+ *
+ * 支持明文与 zstd 压缩会话日志（session-reader）。
  *
  * Severity: HIGH
  * Phase: RUNTIME
  */
 
-import { existsSync, createReadStream } from 'node:fs';
-import { createInterface } from 'node:readline';
+import { existsSync } from 'node:fs';
 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';
+import { scanSessionLines } from '../session-reader.mjs';
 
 /** 凭据转发模式 */
 const CREDENTIAL_FORWARD_PATTERNS = [
@@ -31,36 +32,25 @@ const NETWORK_EXFIL_PATTERNS = [
   { name: 'HTTP request with data', regex: /http\.request|https\.request|axios\.post/gi, severity: 'low' },
 ];
 
-/** 大量数据读取模式 */
-const BULK_READ_PATTERNS = [
-  { name: 'read entire file', regex: /readFileSync|readFile\b|cat\s+[^|]+$/gm, severity: 'low' },
-  { name: 'directory listing', regex: /readdirSync|readdir\b|ls\s+-[la]*/gi, severity: 'low' },
-];
-
 /**
- * 从一行 JSONL 中提取工具调用信息
+ * 从一行 JSONL 中提取文本信息（call 与 result 都扫：凭据出现在返回内容中同样是泄露）
  */
 function extractToolCalls(line) {
   try {
     const event = JSON.parse(line);
     if (event.type !== 'tool/call' && event.type !== 'tool/result') return [];
 
-    const calls = [];
     const data = event.data || {};
     const name = data.name || data.tool || '';
-    const args = data.args || data.input || {};
+    const args = data.args || data.input || data.output || data.result || data.text || {};
     const text = typeof args === 'string' ? args : JSON.stringify(args);
 
-    calls.push({ type: event.type, name, text, seq: event.seq, turn: event.turn });
-    return calls;
+    return [{ type: event.type, name, text, seq: event.seq, turn: event.turn }];
   } catch {
     return [];
   }
 }
 
-/**
- * 扫描文本中的危险模式
- */
 function scanPatterns(text, patterns) {
   const findings = [];
   for (const pattern of patterns) {
@@ -76,11 +66,6 @@ function scanPatterns(text, patterns) {
   return findings;
 }
 
-/**
- * SR3 检查：分析会话日志中的数据外泄行为
- * @param {string} sessionFile - 会话日志文件路径
- * @returns {Promise<import('../protocol/check.mjs').SecurityCheckResult>}
- */
 export async function run(sessionFile) {
   const id = 'SR3';
 
@@ -88,34 +73,26 @@ export async function run(sessionFile) {
     return pass(id, Severity.HIGH, '无会话日志，跳过数据外泄检查');
   }
 
-  if (sessionFile.endsWith('.zstd')) {
-    return pass(id, Severity.HIGH, 'zstd 压缩的会话文件需先解压再检查');
-  }
-
   const findings = [];
   let lineCount = 0;
 
-  const fileStream = createReadStream(sessionFile, { encoding: 'utf8' });
-  const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
-
-  for await (const line of rl) {
-    lineCount++;
-    if (!line.trim()) continue;
-
-    const calls = extractToolCalls(line);
-    for (const call of calls) {
-      // 扫描凭据转发
-      const credFindings = scanPatterns(call.text, CREDENTIAL_FORWARD_PATTERNS);
-      for (const f of credFindings) {
-        findings.push({ ...f, line: lineCount, tool: call.name, category: 'credential-forward' });
-      }
-
-      // 扫描网络外发
-      const netFindings = scanPatterns(call.text, NETWORK_EXFIL_PATTERNS);
-      for (const f of netFindings) {
-        findings.push({ ...f, line: lineCount, tool: call.name, category: 'network-exfil' });
+  try {
+    lineCount = await scanSessionLines(sessionFile, (line, lineNo) => {
+      if (!line.trim()) return;
+      for (const call of extractToolCalls(line)) {
+        for (const f of scanPatterns(call.text, CREDENTIAL_FORWARD_PATTERNS)) {
+          findings.push({ ...f, line: lineNo, tool: call.name, category: 'credential-forward' });
+        }
+        for (const f of scanPatterns(call.text, NETWORK_EXFIL_PATTERNS)) {
+          findings.push({ ...f, line: lineNo, tool: call.name, category: 'network-exfil' });
+        }
       }
+    });
+  } catch (e) {
+    if (e.code === 'ZSTD_UNAVAILABLE') {
+      return skip(id, Severity.HIGH, 'zstd 命令不可用，无法解压压缩会话日志，跳过数据外泄检查');
     }
+    throw e;
   }
 
   if (findings.length === 0) {
@@ -157,7 +134,7 @@ export const sr3Check = {
   name: 'data-exfiltration',
   severity: Severity.HIGH,
   phase: CheckPhase.RUNTIME,
-  description: '数据外泄行为检测（会话日志分析）',
+  description: '数据外泄行为检测（会话日志分析，支持 zstd）',
   src: 'builtin',
   runner: (sessionFile) => run(sessionFile),
 };

package/src/checks/sr4-isolation-verify.mjs

@@ -9,11 +9,11 @@
  * Phase: RUNTIME
  */
 
-import { existsSync, createReadStream } from 'node:fs';
-import { createInterface } from 'node:readline';
+import { existsSync } from 'node:fs';
 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';
+import { scanSessionLines } from '../session-reader.mjs';
 
 function extractToolCalls(line) {
   try {
@@ -27,19 +27,24 @@ function extractToolCalls(line) {
 export async function run(sessionFile) {
   const id = 'SR4';
   if (!sessionFile || !existsSync(sessionFile)) return pass(id, Severity.MEDIUM, '无会话文件，跳过隔离验证');
-  if (sessionFile.endsWith('.zstd')) return pass(id, Severity.MEDIUM, 'zstd 文件需先解压');
 
   const toolCalls = [];
   let lineCount = 0;
-  const rl = createInterface({ input: createReadStream(sessionFile, { encoding: 'utf8' }), crlfDelay: Infinity });
 
-  for await (const line of rl) {
-    lineCount++;
-    if (!line.trim()) continue;
-    toolCalls.push(...extractToolCalls(line));
+  try {
+    lineCount = await scanSessionLines(sessionFile, (line) => {
+      if (!line.trim()) return;
+      toolCalls.push(...extractToolCalls(line));
+    });
+  } catch (e) {
+    if (e.code === 'ZSTD_UNAVAILABLE') {
+      return skip(id, Severity.MEDIUM, 'zstd 命令不可用，无法解压压缩会话日志，跳过隔离验证');
+    }
+    throw e;
   }
 
   // 简单的隔离检查：检测同一 turn 内不同工具的数据传递
+  // 复审修复：正常工作流一个 turn 用 4-5 个工具很常见，阈值 3→6 降低误报
   const findings = [];
   const byTurn = {};
   for (const call of toolCalls) {
@@ -49,13 +54,13 @@ export async function run(sessionFile) {
   }
 
   for (const [turn, calls] of Object.entries(byTurn)) {
-    const tools = new Set(calls.map(c => c.name));
-    if (tools.size > 3) {
-      findings.push({ type: 'multi-tool-turn', severity: 'low', detail: `turn ${turn} 使用了 ${tools.size} 个不同工具：${[...tools].join(', ')}` });
+    const tools = [...new Set(calls.map(c => c.name).filter(Boolean))];
+    if (tools.size > 6) {
+      findings.push({ type: 'multi-tool-turn', severity: 'low', detail: `turn ${turn} 使用了 ${tools.size} 个不同工具：${tools.slice(0, 8).join(', ')}` });
     }
   }
 
-  if (findings.length === 0) return pass(id, Severity.MEDIUM, `分析 ${toolCalls.length} 个工具调用，未检测到隔离问题`);
+  if (findings.length === 0) return pass(id, Severity.MEDIUM, `分析 ${toolCalls.length} 个工具调用（${lineCount} 行），未检测到隔离问题`);
 
   const details = findings.slice(0, 10).map(f => `[${f.severity}] ${f.detail}`).join('\n');
   return fail(id, Severity.MEDIUM, `检测到 ${findings.length} 个潜在隔离问题：\n${details}`, '检查工具间的数据流是否在预期范围内');