@dommaker/harness 1.3.0 → 1.5.0

package/src/core/constraints/usage-report.ts

@@ -13,6 +13,7 @@ import * as path from 'path';
 import type { Constraint } from '../../types/constraint';
 import type { ExecutionTrace } from '../../types/trace';
 import { DEFAULT_TRACE_FILE } from '../../types/trace';
+import { readJsonl } from '../../utils/jsonl';
 import { getEffectiveConstraints, lintEffectiveConfig } from '../effective-constraints';
 import type { EffectiveConfigLint } from '../effective-constraints';
 
@@ -67,6 +68,14 @@ export interface RetireCandidate {
   reason: string;
 }
 
+/** 候选种类的呈现名（constraints report / retire 共用） */
+export const CANDIDATE_KIND_LABEL: Record<RetireCandidateKind, string> = {
+  zero_trigger: '零触发',
+  unevaluable: '不可评估',
+  high_noise: '高噪',
+  zero_intercept: '零拦截',
+};
+
 /**
  * 候选诊断阈值（CLI 可覆盖）
  */
@@ -99,27 +108,36 @@ export interface ConstraintsUsageReport {
   lint: EffectiveConfigLint;
   /** trace 文件是否存在 */
   traceFileExists: boolean;
+  /**
+   * trace 文件被跳过的坏行数（harness#100，与 `traceFileExists` 同一降级维度）
+   *
+   * 恒有值，0 = 无损坏。文件级口径：坏行没有 timestamp，归不进任何统计窗口。
+   */
+  skippedLines: number;
 }
 
 /**
- * 读取项目 traces.log（只读，容错：坏行跳过）
+ * 读取项目 traces.log 并带出坏行计数（只读，harness#100 报告入口）
+ *
+ * 坏行策略：skip（原语义不变——report 只读，不因单行损坏失败）；
+ * 计数去向：透传——`skippedLines` 随本方法返回，进 `ConstraintsUsageReport.skippedLines`，
+ * 消费面为 `constraints report` 的文本行 / `--json` 字段 / `--export` 摘要。
+ */
+export function readProjectTracesReport(projectRoot: string): { traces: ExecutionTrace[]; skippedLines: number } {
+  const { records, skippedLines } = readJsonl<ExecutionTrace>(
+    path.join(projectRoot, DEFAULT_TRACE_FILE),
+    'skip'
+  );
+  return { traces: records, skippedLines };
+}
+
+/**
+ * 读取项目 traces.log（只读）
+ *
+ * 兼容签名：只返回记录数组、丢坏行计数，需要计数的消费方走 `readProjectTracesReport()`。
  */
 export function readProjectTraces(projectRoot: string): ExecutionTrace[] {
-  const tracePath = path.join(projectRoot, DEFAULT_TRACE_FILE);
-  if (!fs.existsSync(tracePath)) return [];
-
-  const content = fs.readFileSync(tracePath, 'utf-8');
-  const traces: ExecutionTrace[] = [];
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      traces.push(JSON.parse(trimmed) as ExecutionTrace);
-    } catch {
-      // 坏行跳过（report 只读，不因单行损坏失败）
-    }
-  }
-  return traces;
+  return readProjectTracesReport(projectRoot).traces;
 }
 
 /**
@@ -234,7 +252,7 @@ export function buildConstraintsUsageReport(
   const activePromptIds = effective.filter(c => c.kind === 'prompt').map(c => c.id);
 
   const tracePath = path.join(projectRoot, DEFAULT_TRACE_FILE);
-  const traces = readProjectTraces(projectRoot);
+  const { traces, skippedLines } = readProjectTracesReport(projectRoot);
   const usage = collectUsageByConstraint(traces);
 
   const stats = checkConstraints.map(c => toStats(c.id, c.level, usage.get(c.id)));
@@ -247,5 +265,6 @@ export function buildConstraintsUsageReport(
     activePromptIds,
     lint,
     traceFileExists: fs.existsSync(tracePath),
+    skippedLines,
   };
 }

package/src/core/index.ts

@@ -84,13 +84,15 @@ export type {
   SpecType,
 } from '../types/spec';
 
-// 项目配置加载器
+// 项目配置加载器（governance 段读取一律经访问器，禁止消费方手写钻取）
 export {
   ProjectConfigLoader,
   loadRawProjectConfig,
+  getGovernanceConfig,
+  resolveContextFiles,
   getCapabilitiesMode,
 } from './project-config-loader';
-export type { CapabilitiesMode } from './project-config-loader';
+export type { CapabilitiesMode, ContextFilesResolution } from './project-config-loader';
 
 // 生效约束集（ADR-0001：唯一生效集来源）
 export {

package/src/core/project-config-loader.ts

@@ -14,6 +14,7 @@ import type {
   CustomConstraintDefinition,
   MergedConstraintsConfig,
   CapabilitiesConfig,
+  GovernanceConfig,
 } from '../types/project-config';
 import { IRON_LAWS, GUIDELINES, PROMPTS } from './constraints/definitions';
 import { PRESETS_BY_NAME, STANDARD_PRESET } from '../presets';
@@ -78,20 +79,59 @@ export function loadRawProjectConfig(projectPath: string): Record<string, unknow
 export type CapabilitiesMode = NonNullable<CapabilitiesConfig['mode']>;
 
 /**
- * 读取 governance.capabilities.mode（缺省 'file'，向后兼容）
+ * 读取 governance 段（全仓唯一手写钻取点，工单 84）
  *
- * 配置缺失/解析失败/取值非法时一律回落 'file'。
+ * 基于 loadRawProjectConfig 的进程级 memoize，不引入第二次 yaml 解析。
+ * 配置缺失 / 解析失败 / 形状不符时返回 undefined，由调用方按未配置处理。
  */
-export function getCapabilitiesMode(projectPath: string): CapabilitiesMode {
+export function getGovernanceConfig(projectPath: string): GovernanceConfig | undefined {
   try {
     const raw = loadRawProjectConfig(projectPath);
-    const governance = raw?.governance as Record<string, unknown> | undefined;
-    const capabilities = governance?.capabilities as Record<string, unknown> | undefined;
-    const mode = capabilities?.mode;
-    if (mode === 'file' || mode === 'module' || mode === 'listing') return mode;
+    const governance = raw?.governance;
+    if (governance === null || typeof governance !== 'object') return undefined;
+    return governance as GovernanceConfig;
   } catch {
-    // 配置缺失或解析失败，按默认 file 处理
+    return undefined;
   }
+}
+
+/**
+ * governance.context_files 三态分辨率（工单 84 triage 裁决口径）
+ *
+ * - unconfigured：段缺失 / enabled 为假 / 解析失败——约定未采用
+ * - enabled-empty：enabled 但 required_dirs 缺失、非数组、含非字符串项或空——
+ *   约定已立但无可用目标
+ * - enabled：enabled 且 required_dirs 为非空字符串数组——约定有效
+ */
+export type ContextFilesResolution =
+  | { state: 'unconfigured' }
+  | { state: 'enabled-empty' }
+  | { state: 'enabled'; dirs: string[] };
+
+/**
+ * 分辨 governance.context_files 三态（语义见 ContextFilesResolution）
+ *
+ * 消费方约定：约束 checker 对前两态一律 skip（与 ADR-0001 存在性探测同构）；
+ * init / 扫描类工具流的自动探测回落保留在调用方，不进本访问器。
+ * 元素类型在此收口：脏配置（如 required_dirs: [1]）不得流入调用方 path.join。
+ */
+export function resolveContextFiles(projectPath: string): ContextFilesResolution {
+  const contextFiles = getGovernanceConfig(projectPath)?.context_files;
+  if (!contextFiles?.enabled) return { state: 'unconfigured' };
+  const dirs = contextFiles.required_dirs;
+  if (!Array.isArray(dirs) || dirs.length === 0) return { state: 'enabled-empty' };
+  if (!dirs.every(dir => typeof dir === 'string')) return { state: 'enabled-empty' };
+  return { state: 'enabled', dirs };
+}
+
+/**
+ * 读取 governance.capabilities.mode（缺省 'file'，向后兼容）
+ *
+ * 配置缺失/解析失败/取值非法时一律回落 'file'。
+ */
+export function getCapabilitiesMode(projectPath: string): CapabilitiesMode {
+  const mode = getGovernanceConfig(projectPath)?.capabilities?.mode;
+  if (mode === 'file' || mode === 'module' || mode === 'listing') return mode;
   return 'file';
 }
 
@@ -228,7 +268,7 @@ export class ProjectConfigLoader {
 
     // 2. 添加自定义约束（config.yml 禁用的 id 不追加：step 1 已将其
     // 收集进 disabled，custom 在 step 1 时尚未入桶，须在此兜底跳过；
-    // 条目带 retired 元数据的同样不追加——#82 D6 退役落点在条目自身）
+    // 条目带 retired 元数据的同样不追加——studio#82 D6 退役落点在条目自身）
     for (const [id, customDef] of Object.entries(this.customConstraints)) {
       if (result.disabled.includes(id) || customDef.retired) {
         continue;

package/src/core/validators/__tests__/passes-gate.test.ts

@@ -1,8 +1,9 @@
 /**
  * Tests for passes-gate.ts
  *
- * Priority: test pure logic methods (check, extractCoverage, extractFailures, extension management)
+ * Priority: test pure logic methods (check)
  * Skip methods that do real file I/O / exec (setPasses, runTests, runTest, detectTestCommand, etc.)
+ * 测试产物解析判定不在此面：见 test-output.test.ts（ADR-0012）
  */
 
 import { PassesGate, createPassesGate } from '../passes-gate';
@@ -67,65 +68,10 @@ describe('PassesGate', () => {
     });
   });
 
-  describe('extension management', () => {
-    it('registerExtension adds an extension', () => {
-      const gate = createPassesGate();
-      const ext = { name: 'e2e', run: async () => ({ passed: true, command: 'e2e' }) };
-      gate.registerExtension('e2e', ext);
-      expect(gate.getExtensionNames()).toContain('e2e');
-    });
-
-    it('unregisterExtension removes an extension', () => {
-      const gate = createPassesGate();
-      const ext = { name: 'e2e', run: async () => ({ passed: true, command: 'e2e' }) };
-      gate.registerExtension('e2e', ext);
-      const removed = gate.unregisterExtension('e2e');
-      expect(removed).toBe(true);
-      expect(gate.getExtensionNames()).not.toContain('e2e');
-    });
-
-    it('unregisterExtension returns false for non-existent extension', () => {
-      const gate = createPassesGate();
-      const removed = gate.unregisterExtension('nonexistent');
-      expect(removed).toBe(false);
-    });
-
-    it('getExtensionNames returns empty array when no extensions', () => {
-      const gate = createPassesGate();
-      expect(gate.getExtensionNames()).toEqual([]);
-    });
-
-    it('getExtensionNames returns multiple extension names', () => {
-      const gate = createPassesGate();
-      gate.registerExtension('a', { name: 'a', run: async () => ({ passed: true, command: 'a' }) });
-      gate.registerExtension('b', { name: 'b', run: async () => ({ passed: true, command: 'b' }) });
-      const names = gate.getExtensionNames();
-      expect(names).toContain('a');
-      expect(names).toContain('b');
-      expect(names).toHaveLength(2);
-    });
-  });
-
   describe('getTestResult', () => {
     it('returns undefined for unknown task', () => {
       const gate = createPassesGate();
       expect(gate.getTestResult('unknown')).toBeUndefined();
     });
   });
-
-  describe('extractCoverage (via extractCoverage private method behavior check)', () => {
-    // extractCoverage is private but we can infer behavior through public API
-    // runTest uses it internally — but that method is not easily testable without mocking exec
-    it('PassesGate instance is properly constructed', () => {
-      const gate = createPassesGate({ testCommand: 'npm test' });
-      expect(gate).toBeInstanceOf(PassesGate);
-    });
-  });
-
-  describe('extractFailures (via extractFailures private method behavior check)', () => {
-    it('PassesGate handles config properly', () => {
-      const gate = createPassesGate({ allowPartialPass: true, maxRetries: 0, retryDelay: 0 });
-      expect(gate).toBeInstanceOf(PassesGate);
-    });
-  });
 });

package/src/core/validators/__tests__/test-output.test.ts

@@ -0,0 +1,372 @@
+/**
+ * test-output 表驱动旁测（架构评审候选1 / #80 → ADR-0012；判定口径 #93 → ADR-0014；
+ * 覆盖率取数路删除 #94）
+ *
+ * runner 输出解读口的唯一测试面：真实 stdout 样本进、判定值出。
+ * 迁移前 extractCoverage / extractFailures / parseTestOutput 是 PassesGate 与
+ * SpecAcceptanceGate 的 private 方法，分支覆盖率 0%——passes-gate.test.ts 里只剩
+ * toBeInstanceOf 占位断言，acceptance.test.ts 要写 6 份近重复 exec mock 才碰得到分支。
+ *
+ * extractFailures 的期望值钉的是**迁移前的既有行为**（ADR-0012 硬门槛：行为零变更），
+ * 标 ⚠ 的行是已知的粗糙解析，原样钉住不代表认可。
+ *
+ * judgeTestRun 是 #93 裁决后的**判定唯一入口**（退出码为主 + 文本交叉否决），取代
+ * 原 parseTestOutput（纯文本判定，可被测试名里的 FAIL 反转）；两门禁消费同一函数的
+ * 一致性用例在 gates/__tests__/test-verdict-consistency.test.ts。
+ *
+ * extractCoverage 曾在此有 8 条表驱动用例，#94 裁决 B（harness 核心判定不管覆盖率）
+ * 连同函数一起删除，只剩下面那条导出面守卫钉住「不再导出」。
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { extractFailures, judgeTestRun } from '../test-output';
+
+// ========================================
+// 真实输出样本（各 runner 家族的原始 stdout）
+// ========================================
+
+/** jest --coverage：文本表 + 汇总行 */
+const JEST_COV = `PASS src/app.test.ts
+----------------|---------|----------|---------|---------|-------------------
+File            | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
+----------------|---------|----------|---------|---------|-------------------
+All files       |   80.50 |    70.21 |   83.33 |   79.59 |
+ app.ts         |   80.50 |    70.21 |   83.33 |   79.59 | 12-13
+----------------|---------|----------|---------|---------|-------------------
+Test Suites: 1 passed, 1 total
+Tests:       5 passed, 5 total
+`;
+
+const MOCHA_PLAIN = `  2 passing (11ms)
+  1 failing
+`;
+
+/** jest verbose 失败清单 */
+const JEST_FAILURES = `FAIL src/app.test.ts
+  App
+    ✕ renders title (23 ms)
+    ✓ renders subtitle (5 ms)
+    ✕ handles click (12 ms)
+
+Test Suites: 1 failed, 1 total
+Tests:       2 failed, 1 passed, 3 total
+`;
+
+/** jest 失败详情带堆栈行 */
+const JEST_FAILURES_WITH_STACK = `FAIL src/app.test.ts
+  App
+    ✕ renders title (23 ms)
+
+  ● App › renders title
+
+    expect(received).toBe(expected)
+
+      at Object.<anonymous> (src/app.test.ts:12:15)
+
+Test Suites: 1 failed, 1 total
+`;
+
+/**
+ * PR #117 实发样本（2026-09-08）：全绿 jest 输出混 console 噪音——init/sync-docs 测试
+ * 直接打印的 ✅ 日志行（行尾 (v1.0.0)）与失败路径测试的 stack trace（行尾 :213:23)）。
+ * 行尾「数字+)」+ 下一行含 ":" 是旧 mocha 正则（\s+ 跨行）的诱饵：它在同形状的真实输出
+ * 上捕出 24 条假失败，governance 门禁因此对 exit 0 的绿色 npm test 误判失败。
+ */
+const JEST_GREEN_WITH_CONSOLE_NOISE = `PASS src/cli/commands/__tests__/init-injection.test.ts
+✅ 已创建 AGENTS.md 并写入治理契约 PRESERVE:governance 段 (v1.0.0)
+✅ 已创建 AGENTS.md 并写入治理契约 PRESERVE:governance 段 (v1.0.0)
+✅ 已更新 CLAUDE.md 治理约束 (v1.0.0)
+PASS src/__tests__/skip-semantics.test.ts
+      at Object.evaluate (src/core/constraints/checkers/docs-freshness.ts:100:15)
+      at ConstraintChecker.checkPrecondition (src/core/constraints/checker.ts:213:23)
+      at Object.<anonymous> (src/__tests__/skip-semantics.test.ts:152:36)
+PASS src/failure/__tests__/recorder.test.ts
+
+Test Suites: 156 passed, 156 total
+Tests:       7 skipped, 2182 passed, 2189 total
+`;
+
+/** mocha 单行形状：编号 + 套件 + 标题同行，末尾带冒号（正则认的形状） */
+const MOCHA_ONE_LINE = `  1) Account "should open":
+     AssertionError: expected false to be true
+
+  2) Account "should close":
+     Error: timeout of 2000ms exceeded
+`;
+
+/** mocha 10 spec reporter 实际形状：编号行与标题行分两行 */
+const MOCHA_TWO_LINE = `  1) Account
+       should open:
+     AssertionError: expected false to be true
+
+  2) Account
+       should close:
+     Error: timeout of 2000ms exceeded
+`;
+
+const MOCHA_TWO_LINE_WITH_STACK = `  1) Account
+       should open:
+     AssertionError: expected false to be true
+      at Context.<anonymous> (test/account.test.js:14:16)
+      at processImmediate (node:internal/timers:476:21)
+
+  2) Account
+       should close:
+     Error: timeout of 2000ms exceeded
+`;
+
+const PYTEST_FAILURES = `FAILED tests/test_app.py::TestLogin::test_empty_password - AssertionError: 400 != 200
+FAILED tests/test_app.py::test_logout - assert False
+2 failed, 5 passed in 0.88s
+`;
+
+const GO_FAILURES = `=== RUN   TestLogin
+--- FAIL: TestLogin (0.00s)
+    app_test.go:24: expected 200, got 401
+=== RUN   TestLogout
+--- FAIL: TestLogout (0.01s)
+FAIL
+exit status 1
+FAIL    example.com/app    0.014s
+`;
+
+const PW_PASS = `Running 3 tests using 1 worker
+
+  ✓  1 example.spec.ts:5:5 › should have title (1.2s)
+  ✓  2 example.spec.ts:8:5 › should navigate (0.6s)
+  ✓  3 example.spec.ts:12:5 › should submit (0.3s)
+
+  3 passed (2.1s)
+`;
+
+const PW_FAIL = `Running 3 tests using 1 worker
+
+  ✓  1 example.spec.ts:5:5 › should have title (1.2s)
+  ✘  2 example.spec.ts:10:5 › should fail (0.9s)
+  ✓  3 example.spec.ts:12:5 › should submit (0.3s)
+
+
+  1) example.spec.ts:10:5 › should fail ─────────────────────────────
+
+    Error: expect(received).toBe(expected)
+
+  1 failed
+    example.spec.ts:10:5 › should fail
+  2 passed (3.1s)
+`;
+
+const JEST_SUITES_PASS = `Test Suites: 5 passed, 5 total
+Tests:       42 passed, 42 total
+`;
+
+const JEST_SUITES_FAIL = `Test Suites: 2 failed, 3 passed, 5 total
+`;
+
+/** 零套件通过时 jest 的汇总形状（只有 failed/total，无 "passed" 字样 → 走 Jest 分支） */
+const JEST_ALL_FAILED = `Test Suites: 2 failed, 2 total
+Tests:       3 failed, 3 total
+`;
+
+/** jest 汇总行零失败，但输出里没有 "passed" 字样（截断/过滤后的形状） */
+const JEST_SUITES_NO_PASSED_WORD = `Test Suites: 0 failed, 2 total
+`;
+
+const GENERIC_PASS = `PASS src/a.test.js
+PASS src/b.test.js
+`;
+
+const GENERIC_MIXED = `PASS src/a.test.js
+FAIL src/b.test.js
+`;
+
+/** 全绿输出，但通过的测试标题里带大写 FAIL 字样 */
+const GENERIC_FAIL_IN_TEST_NAME = `PASS src/a.test.js
+  ✓ does not FAIL here (3 ms)
+`;
+
+// ========================================
+// 模块导出面（harness#94 裁决 B：extractCoverage 已删除）
+// ========================================
+
+describe('test-output 导出面', () => {
+  it('运行时只有 extractFailures 与 judgeTestRun，不含 extractCoverage', async () => {
+    const mod = await import('../test-output');
+    expect(Object.keys(mod).sort()).toEqual(['extractFailures', 'judgeTestRun']);
+  });
+});
+
+// ========================================
+// extractFailures
+// ========================================
+
+type FailuresCase = { name: string; output: string; expected: string[] };
+
+const FAILURES_CASES: FailuresCase[] = [
+  { name: 'jest ✕ 行 → 两个用例名', output: JEST_FAILURES, expected: ['renders title', 'handles click'] },
+  {
+    name: 'jest 带堆栈行 → 只有 ✕ 用例名（旧跨行 mocha 误捕 "Test Suites"，PR #117 已修）',
+    output: JEST_FAILURES_WITH_STACK,
+    expected: ['renders title'],
+  },
+  {
+    name: 'mocha 单行形状 → 套件 + 标题',
+    output: MOCHA_ONE_LINE,
+    expected: ['Account "should open"', 'Account "should close"'],
+  },
+  { name: '⚠ mocha 10 两行形状 → 识别不到任何失败', output: MOCHA_TWO_LINE, expected: [] },
+  {
+    name: 'mocha 两行 + 堆栈 → []（旧跨行误捕堆栈帧 "at processImmediate (node"，PR #117 已修）',
+    output: MOCHA_TWO_LINE_WITH_STACK,
+    expected: [],
+  },
+  {
+    name: '全绿 jest 输出混 console 噪音（行尾数字+")" 跨行诱饵）→ []（PR #117 实发误否决）',
+    output: JEST_GREEN_WITH_CONSOLE_NOISE,
+    expected: [],
+  },
+  {
+    name: '⚠ pytest 节点 id 在首个 :: 前截断 → 同文件多条失败重复且丢测试名',
+    output: PYTEST_FAILURES,
+    expected: ['tests/test_app.py', 'tests/test_app.py'],
+  },
+  { name: 'go test --- FAIL: → 函数名', output: GO_FAILURES, expected: ['TestLogin', 'TestLogout'] },
+  { name: '无匹配：全绿 jest 输出 → []', output: JEST_COV, expected: [] },
+  { name: '无匹配：空字符串 → []', output: '', expected: [] },
+];
+
+describe('extractFailures', () => {
+  for (const c of FAILURES_CASES) {
+    it(c.name, () => {
+      expect(extractFailures(c.output)).toEqual(c.expected);
+    });
+  }
+});
+
+// ========================================
+// judgeTestRun — 判定唯一入口（ADR-0014 / #93）
+// ========================================
+
+type JudgeCase = {
+  name: string;
+  exitCode: number;
+  output: string;
+  allowPartialPass?: boolean;
+  expected: boolean;
+};
+
+const JUDGE_CASES: JudgeCase[] = [
+  // ── 退出码为主：文本不能把非零退出救成 pass ──
+  { name: 'exit 1 + 全绿 jest 输出 → false（文本不赦免非零退出）', exitCode: 1, output: JEST_COV, expected: false },
+  { name: 'exit 1 + 空输出 → false', exitCode: 1, output: '', expected: false },
+  {
+    name: 'exit 2 + allowPartialPass → false（部分通过不碰退出码这一维）',
+    exitCode: 2,
+    output: JEST_COV,
+    allowPartialPass: true,
+    expected: false,
+  },
+  // ── 后果1：exit 0 但输出印着失败 → 文本交叉否决 ──
+  { name: 'exit 0 + jest ✕ 用例清单 → false', exitCode: 0, output: JEST_FAILURES, expected: false },
+  { name: 'exit 0 + jest 带堆栈失败清单 → false', exitCode: 0, output: JEST_FAILURES_WITH_STACK, expected: false },
+  {
+    name: 'exit 0 + 只有 jest 汇总行（无 ✕ 行，非 verbose）→ false（统一用结构化汇总行）',
+    exitCode: 0,
+    output: JEST_ALL_FAILED,
+    expected: false,
+  },
+  {
+    name: 'exit 0 + jest 汇总行有 failed 也有 passed → false',
+    exitCode: 0,
+    output: JEST_SUITES_FAIL,
+    expected: false,
+  },
+  { name: 'exit 0 + 套件级 FAIL 行 → false', exitCode: 0, output: GENERIC_MIXED, expected: false },
+  { name: 'exit 0 + mocha 汇总行 1 failing → false', exitCode: 0, output: MOCHA_PLAIN, expected: false },
+  { name: 'exit 0 + pytest FAILED 行 → false', exitCode: 0, output: PYTEST_FAILURES, expected: false },
+  { name: 'exit 0 + go --- FAIL: 行 → false', exitCode: 0, output: GO_FAILURES, expected: false },
+  { name: 'exit 0 + playwright 失败汇总 → false', exitCode: 0, output: PW_FAIL, expected: false },
+  // ── 后果2：裸 includes(FAIL) 兜底弃用后不再误伤 ──
+  {
+    name: 'exit 0 + 全绿但通过的用例名里带大写 FAIL → true（旧兜底子串反转已修）',
+    exitCode: 0,
+    output: GENERIC_FAIL_IN_TEST_NAME,
+    expected: true,
+  },
+  {
+    name: 'exit 0 + 路径含大写 FAIL 目录名 → true（子串兜底已弃用）',
+    exitCode: 0,
+    output: 'PASS src/fixtures/FAIL/app.test.js\nTests:       3 passed, 3 total\n',
+    expected: true,
+  },
+  // ── 全绿样本 ──
+  { name: 'exit 0 + jest 全绿带覆盖率表 → true', exitCode: 0, output: JEST_COV, expected: true },
+  { name: 'exit 0 + jest 全绿汇总行 → true', exitCode: 0, output: JEST_SUITES_PASS, expected: true },
+  {
+    name: 'exit 0 + jest 零失败但无 "passed" 字样 → true（旧判定要求该字样，误伤）',
+    exitCode: 0,
+    output: JEST_SUITES_NO_PASSED_WORD,
+    expected: true,
+  },
+  { name: 'exit 0 + playwright 全过 → true', exitCode: 0, output: PW_PASS, expected: true },
+  { name: 'exit 0 + 通用 PASS 行 → true', exitCode: 0, output: GENERIC_PASS, expected: true },
+  {
+    name: 'exit 0 + 全绿输出混 console 噪音 → true（PR #117 实发：extractFailures 跨行误捕曾否决绿色输出）',
+    exitCode: 0,
+    output: JEST_GREEN_WITH_CONSOLE_NOISE,
+    expected: true,
+  },
+  // ── allowPartialPass 的新位置：只作用于文本否决这一维 ──
+  {
+    name: 'exit 0 + jest ✕ 清单 + allowPartialPass → true（部分通过 = 放弃文本否决）',
+    exitCode: 0,
+    output: JEST_FAILURES,
+    allowPartialPass: true,
+    expected: true,
+  },
+  // ── 退出码权威的边界：文本否决只管「看出失败」，不管「没跑出测试」 ──
+  {
+    name: '⚠ exit 0 + 空输出 → true（零测试识别不属本判定，另票）',
+    exitCode: 0,
+    output: '',
+    expected: true,
+  },
+  {
+    name: '⚠ exit 0 + 零测试汇总 "0 passed" → true（同上）',
+    exitCode: 0,
+    output: '  0 passed (1.0s)\n',
+    expected: true,
+  },
+  {
+    name: '⚠ exit 0 + 畸形 "X passed X failed"（计数位非数字）→ true（同上：无结构化失败信号）',
+    exitCode: 0,
+    output: '  X passed X failed\n',
+    expected: true,
+  },
+  { name: 'exit 0 + 仅覆盖率表格分隔线 → true（无失败信号）', exitCode: 0, output: '----------|---------|\n', expected: true },
+];
+
+describe('judgeTestRun', () => {
+  for (const c of JUDGE_CASES) {
+    it(c.name, () => {
+      expect(judgeTestRun({ exitCode: c.exitCode, output: c.output, allowPartialPass: c.allowPartialPass })).toEqual(
+        expect.objectContaining({ passed: c.expected }),
+      );
+    });
+  }
+
+  it('allowPartialPass 缺省 = false（否决默认生效）', () => {
+    expect(judgeTestRun({ exitCode: 0, output: JEST_FAILURES }).passed).toBe(false);
+  });
+
+  it('否决时 failures 带出用例名（判负有据）', () => {
+    expect(judgeTestRun({ exitCode: 0, output: JEST_FAILURES }).failures).toEqual(['renders title', 'handles click']);
+  });
+
+  it('全绿时 failures 为空数组', () => {
+    expect(judgeTestRun({ exitCode: 0, output: GENERIC_FAIL_IN_TEST_NAME }).failures).toEqual([]);
+  });
+
+  it('非零退出时仍带出文本里的失败名（供上层拼错误信息）', () => {
+    expect(judgeTestRun({ exitCode: 1, output: GO_FAILURES }).failures).toEqual(['TestLogin', 'TestLogout']);
+  });
+});