@dommaker/harness 1.2.3 → 1.4.0

package/src/failure/recorder.ts

@@ -6,6 +6,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
+import { readJsonl, appendJsonl } from '../utils/jsonl';
 import type { FailureRecord } from './types';
 
 /**
@@ -25,7 +26,7 @@ export interface FailureRecorderConfig {
  *
  * 用法：
  * ```typescript
- * const recorder = new FailureRecorder({ logFile: '.harness/logs/failures.log' });
+ * const recorder = new FailureRecorder({ logFile: DEFAULT_FAILURE_LOG_FILE });
  * await recorder.record({
  *   type: ErrorType.TEST_FAILED,
  *   level: FailureLevel.L1,
@@ -58,9 +59,8 @@ export class FailureRecorder {
     // 检查文件大小，必要时滚动
     await this.rotateIfNeeded();
 
-    // 追加写入（单行 JSON）
-    const line = JSON.stringify(record) + '\n';
-    fs.appendFileSync(this.logFile, line, 'utf-8');
+    // 追加写入单行 JSON（写链收口：ensureDir + append，harness#82）
+    appendJsonl(this.logFile, record);
   }
 
   /**
@@ -74,17 +74,19 @@ export class FailureRecorder {
 
   /**
    * 获取历史记录
+   *
+   * 坏行策略：显式 skip（harness#96 定稿：跳过 + stderr 一次性计数警告，
+   * stdout 含 --json 逐字节不变、退出码 0——#82 只把本调用点改走 jsonl
+   * 读链正本并吸收 #96 的局部跳过实现，对外行为不变）。
+   * 计数去向：透传（harness#100 四消费点之一）——skippedLines 进下面那句 console.error，
+   * #96 定稿的文案与退出码本票逐字不动。
    */
   async getHistory(limit?: number): Promise<FailureRecord[]> {
-    if (!fs.existsSync(this.logFile)) {
-      return [];
+    const { records, skippedLines } = readJsonl<FailureRecord>(this.logFile, 'skip');
+    if (skippedLines > 0) {
+      console.error(`[harness] ${path.basename(this.logFile)} 跳过 ${skippedLines} 行损坏记录`);
     }
 
-    const content = fs.readFileSync(this.logFile, 'utf-8');
-    const lines = content.trim().split('\n').filter(Boolean);
-
-    const records = lines.map((line) => JSON.parse(line) as FailureRecord);
-
     if (limit && limit > 0) {
       return records.slice(-limit);
     }

package/src/gates/CONTEXT.md

@@ -10,8 +10,8 @@
 - 执行器：`runGates`（`runner.ts`）——按 order 升序；deny 单调（下游 abstain 不得改回 allow）+ ask 枚举预留 fail-closed = deny；决策浅冻结
 - 生效集：`getEffectiveGates(projectRoot)`（`effective-gates.ts`）——对齐 getEffectiveConstraints 裁剪模式：config.yml `gates.order` 重排 + `gates.<id>.enabled:false` 移除；enabled 段未注册校验与裁剪走 core/effective-set 共享筛选器（throw 模式），order 重排与重复 id 检测留本侧
 - checker-as-guard 接线点：`createCheckerGate(check)`（`checker-gate.ts`）——ConstraintCheck → Gate（studio #129 随动）；false→deny，true/'skip'→abstain；env 经 `buildCheckEnv(..., 'none')` 构造（显式不接证据，语义见 core/constraints/checkers/types.ts 工厂 doc）
-- 门禁类：`ReviewGate` / `SecurityGate` / `PerformanceGate` / `ContractGate` / `SpecAcceptanceGate` / `CommandGate`（各自执行细节私有，保留 `check()`/`scan()` 报告方法）
-- `types.ts` — GateResult（报告结构，保留）/ GateContext / GateDecision 等公共类型
+- 门禁类：`ReviewGate` / `SecurityGate` / `PerformanceGate` / `ContractGate` / `SpecAcceptanceGate` / `CommandGate`（各自执行细节私有，保留 `check()`/`scan()` 报告方法）；SpecAcceptanceGate 的 runner 输出解读与 e2e 判负都从 `core/validators/test-output.ts` 的 `judgeTestRun` 取（解析收口 ADR-0012、判定依据 ADR-0014，本层既不自带正则也不自写判定 `if`）
+- `types.ts` — GateResult（报告结构，保留）/ GateContext / GateDecision 等公共类型 + 报告构造器 `pass` / `fail` / `fromError`（动态 passed 走 `gateResult`）：timestamp 与 duration 口径唯一落点，门禁实现禁止手写 GateResult 字面量（duration 是可选字段，漏写无编译期报错）
 - 便捷工厂函数：createReviewGate / createSecurityGate / createPerformanceGate / createContractGate / createSpecAcceptanceGate / createCommandGate
 
 ## 依赖关系
@@ -19,12 +19,15 @@
 - 依赖 `src/types/` 公共类型
 
 ## 约定
-- 新门禁必须：① 在 `definitions.ts` 补 GateDefinition（含 CLI 元数据）② 在 `registry.ts` IMPLEMENTATIONS 注册实现（缺一 → 加载期抛错）③ 实现统一 Gate 接口（evaluate 产三态决策，报告走 GateResult）④ 配 CLI 命令（命令实现文件 + CLI 元数据的 module+export 引用，bin 由定义表驱动生成，不再手写块）+ 测试文件
+- 新门禁必须：① 在 `definitions.ts` 补 GateDefinition（含 CLI 元数据）② 在 `registry.ts` IMPLEMENTATIONS 注册实现（缺一 → 加载期抛错）③ 实现统一 Gate 接口（evaluate 产三态决策，报告由 `types.ts` 的 `pass`/`fail`/`fromError`/`gateResult` 构造，不手写字面量）④ 配 CLI 命令（命令实现文件 + CLI 元数据的 module+export 引用，bin 由定义表驱动生成，不再手写块）+ 测试文件
 - deny 单调是接口契约：决策浅冻结，下游不得改写上游决策
+- `runGates` 是 Gate 链语义的**参考实现**（deny 单调 / ask fail-closed / 全决策浅冻结）：仓内暂无生产调用方（harness CLI 文件驱动逐命令执行，studio `runCompletionGuards` 经 checker-gate 复用语义但不 import），消费方只有测试。「deny 后短路跳过剩余门禁」类优化在出现真实消费者前不做——它与「按执行顺序的全部决策」报告契约直接冲突，短路等于改 GateResult 语义（harness#115 裁决，防后续评审重复提议）
 - ask 枚举预留：暂无实现，runGates fail-closed 按 deny 计
+- **收到的根要传到自己每个 IO/执行点（harness#95）**：门禁只认 `context.projectPath`，内部相对子路径一律锚到它（`SpecAcceptanceGate` 的 tasksPath、`ContractGate` 的 contractPath、e2e/scan/benchmark 的 `cwd`），禁止「根已传入却又取 cwd」、禁止 `xxxPath: './…'` 相对默认值——否则 `-p` 半失效且表现为假绿（acceptance 的「无 tasks.yml 即跳过」= passed:true）。本层唯一保留的 cwd 站点是 `checker-gate` 对 `ctx.projectPath` 的缺省兜底（豁免理由见守护表）。约定正本与两道机器可检的闸见 `src/cli/commands/CONTEXT.md`
 
 ## 注意事项
 - 门禁系统不包含业务逻辑，只提供检查能力
+- `acceptance.ts` 的 13 处 return 是 `AcceptanceGateResult`（无 gate/duration 字段，`evaluate()` 归一化为 GateResult 报告——设计如此，见该方法注释），不是 GateResult 字面量，故不套 `pass`/`fail` 构造器；改成 GateResult 会动公共类型形状
 - 统一的是决策协议（id/order/三态），执行细节（gh pr view/正则黑名单/OpenAPI diff/benchmark）私有——不要把执行细节塞进 Gate 接口
 - config.yml gates 段为新增面：引用未注册 id 直接抛错（无历史残留配置需兼容）
 - CommandGate 为命令黑名单检查(SEC-006)

package/src/gates/__tests__/acceptance-types-single-source.test.ts

@@ -0,0 +1,68 @@
+/**
+ * AcceptanceGate 类型单一正本（harness#101，架构评审 A1）
+ *
+ * 钉住三条：
+ * 1. 公共导出面（gates/types.ts）的 SpecAcceptanceGateConfig 并入 e2e 字段——
+ *    修前窄版会在类型层面拒绝 e2eTestCommand/e2eTestTimeout/projectPath（编译即红）。
+ * 2. 测试与公共面走同一 seam：工厂从 gates/index 取，acceptance.ts 侧工厂已删。
+ * 3. acceptance.ts 不再持有三类型/工厂的双份定义（源码扫描闸，防双正本回潮）。
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { SpecAcceptanceGate, createSpecAcceptanceGate } from '../index';
+import type {
+  SpecAcceptanceGateConfig,
+  AcceptanceGateContext,
+  AcceptanceCriteria,
+} from '../types';
+
+describe('AcceptanceGate 类型单一正本（#101）', () => {
+  it('公共面 SpecAcceptanceGateConfig 接受 e2eTestCommand/e2eTestTimeout/projectPath', () => {
+    const config: SpecAcceptanceGateConfig = {
+      tasksPath: 'tasks.yml',
+      checkAllTasks: true,
+      e2eTestCommand: 'npx playwright test',
+      e2eTestTimeout: 60000,
+      projectPath: '/tmp/proj',
+    };
+    expect(config.e2eTestCommand).toBe('npx playwright test');
+    expect(config.e2eTestTimeout).toBe(60000);
+    expect(config.projectPath).toBe('/tmp/proj');
+  });
+
+  it('公共面 AcceptanceGateContext / AcceptanceCriteria 形状不变', () => {
+    const context: AcceptanceGateContext = {
+      projectPath: '/tmp/proj',
+      taskId: 'TASK-001',
+      tasksPath: 'tasks.yml',
+    };
+    const criteria: AcceptanceCriteria = {
+      id: 'AC-1',
+      description: 'desc',
+      type: 'automated',
+      required: true,
+      checked: true,
+      notes: 'n',
+    };
+    expect(context.projectPath).toBe('/tmp/proj');
+    expect(criteria.type).toBe('automated');
+  });
+
+  it('gates/index 工厂接受并入后的宽版配置（与公共面同一 seam）', () => {
+    const gate = createSpecAcceptanceGate({
+      e2eTestCommand: 'npx playwright test',
+      e2eTestTimeout: 60000,
+      projectPath: '/tmp/proj',
+    });
+    expect(gate).toBeInstanceOf(SpecAcceptanceGate);
+  });
+
+  it('acceptance.ts 不再持有三类型与工厂的双份定义', () => {
+    const source = fs.readFileSync(path.join(__dirname, '../acceptance.ts'), 'utf-8');
+    expect(source).not.toMatch(
+      /export interface (SpecAcceptanceGateConfig|AcceptanceGateContext|AcceptanceCriteria)\b/,
+    );
+    expect(source).not.toMatch(/export function createSpecAcceptanceGate\b/);
+  });
+});

package/src/gates/__tests__/acceptance.test.ts

@@ -2,7 +2,9 @@
  * SpecAcceptanceGate 测试
  */
 
-import { SpecAcceptanceGate, createSpecAcceptanceGate } from '../acceptance';
+import { SpecAcceptanceGate } from '../acceptance';
+// 工厂与公共面同一 seam：gates/index 是唯一出口（harness#101）
+import { createSpecAcceptanceGate } from '../index';
 import * as fs from 'fs/promises';
 import { exec } from 'child_process';
 
@@ -377,7 +379,7 @@ tasks:
     });
   });
 
-  describe('parseTestOutput()', () => {
+  describe('runE2ETest 判定接线（解析分支矩阵见 core/validators/__tests__/test-output.test.ts）', () => {
     it('should detect passed Playwright test', async () => {
       mockFs.readFile.mockResolvedValueOnce(`
 tasks:
@@ -419,90 +421,6 @@ tasks:
 
       expect(result.passed).toBe(false);
     });
-
-    it('should detect passed Jest test', async () => {
-      mockFs.readFile.mockResolvedValueOnce(`
-tasks:
-  - id: TASK-001
-    acceptance:
-      - description: Test
-        e2e_test: test.spec.ts
-`);
-
-      mockExec.mockImplementationOnce((cmd, opts, callback) => {
-        callback(null, { stdout: 'Test Suites: 0 failed, 5 passed', stderr: '' });
-      });
-
-      const result = await gate.check({
-        projectPath: '/test/project',
-        taskId: 'TASK-001',
-      });
-
-      expect(result.passed).toBe(true);
-    });
-
-    it('should detect failed Jest test', async () => {
-      mockFs.readFile.mockResolvedValueOnce(`
-tasks:
-  - id: TASK-001
-    acceptance:
-      - description: Test
-        e2e_test: test.spec.ts
-`);
-
-      mockExec.mockImplementationOnce((cmd, opts, callback) => {
-        callback(null, { stdout: 'Test Suites: 2 failed, 3 passed', stderr: '' });
-      });
-
-      const result = await gate.check({
-        projectPath: '/test/project',
-        taskId: 'TASK-001',
-      });
-
-      expect(result.passed).toBe(false);
-    });
-
-    it('should detect PASS in generic output', async () => {
-      mockFs.readFile.mockResolvedValueOnce(`
-tasks:
-  - id: TASK-001
-    acceptance:
-      - description: Test
-        e2e_test: test.spec.ts
-`);
-
-      mockExec.mockImplementationOnce((cmd, opts, callback) => {
-        callback(null, { stdout: 'PASS test.js', stderr: '' });
-      });
-
-      const result = await gate.check({
-        projectPath: '/test/project',
-        taskId: 'TASK-001',
-      });
-
-      expect(result.passed).toBe(true);
-    });
-
-    it('should detect FAIL in generic output', async () => {
-      mockFs.readFile.mockResolvedValueOnce(`
-tasks:
-  - id: TASK-001
-    acceptance:
-      - description: Test
-        e2e_test: test.spec.ts
-`);
-
-      mockExec.mockImplementationOnce((cmd, opts, callback) => {
-        callback(null, { stdout: 'PASS test1.js\nFAIL test2.js', stderr: '' });
-      });
-
-      const result = await gate.check({
-        projectPath: '/test/project',
-        taskId: 'TASK-001',
-      });
-
-      expect(result.passed).toBe(false);
-    });
   });
 
   describe('E2E test configuration', () => {

package/src/gates/__tests__/effective-gates.test.ts

@@ -3,9 +3,8 @@
  */
 
 import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
 import { getEffectiveGates } from '../effective-gates';
+import { createProjectFixture, writeProjectConfig } from '../../test-setup/project-fixture';
 
 const DEFAULT_ORDER = ['acceptance', 'command', 'contract', 'performance', 'review', 'security'];
 
@@ -13,18 +12,14 @@ describe('getEffectiveGates', () => {
   let dir: string;
 
   beforeEach(() => {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-gates-'));
+    dir = createProjectFixture({ name: 'harness-gates' });
   });
 
   afterEach(() => {
     fs.rmSync(dir, { recursive: true, force: true });
   });
 
-  function writeConfig(yamlText: string): void {
-    const harnessDir = path.join(dir, '.harness');
-    fs.mkdirSync(harnessDir, { recursive: true });
-    fs.writeFileSync(path.join(harnessDir, 'config.yml'), yamlText);
-  }
+  const writeConfig = (yamlText: string): void => writeProjectConfig(dir, yamlText);
 
   it('无 config.yml → 6 门禁按默认 order', () => {
     expect(getEffectiveGates(dir).map(g => g.id)).toEqual(DEFAULT_ORDER);

package/src/gates/__tests__/test-verdict-consistency.test.ts

@@ -0,0 +1,140 @@
+/**
+ * 两门禁判「过没过」的一致性（#93，ADR-0014）
+ *
+ * PassesGate 的 runTest 与 SpecAcceptanceGate 的 e2e 分支过去判定依据不同：前者成功分支
+ * 只看退出码（exit 0 即过，输出里的 ✕ 清单不参与），后者只看 stdout 文本（裸 includes('FAIL')
+ * 兜底能被测试名字反转）。同一份 runner 输出可以一处判过、另一处判不过。
+ *
+ * 裁决后两者从同一判定入口出结果，本文件从两个门禁的**公开面**（PassesGate.runTests() /
+ * SpecAcceptanceGate.check()）喂同一份样本 + 同一个退出码，断言结论一致且等于裁决值。
+ * 判定矩阵本身（各 runner 家族、畸形输入、allowPartialPass）见
+ * core/validators/__tests__/test-output.test.ts。
+ *
+ * 落点在 gates/ 不选 core/：单向分层禁止 src/core/** 值导入 gates/（#88，ADR-0012 落点理由同源）。
+ */
+
+import { describe, it, expect, beforeEach, jest } from '@jest/globals';
+import { exec } from 'child_process';
+import * as fs from 'fs/promises';
+import { PassesGate } from '../../core/validators/passes-gate';
+import { SpecAcceptanceGate } from '../acceptance';
+
+jest.mock('child_process', () => ({ exec: jest.fn() }));
+jest.mock('fs/promises');
+
+const mockExec = exec as unknown as jest.Mock;
+const mockFs = fs as unknown as jest.Mocked<typeof fs>;
+
+// ========================================
+// runner 输出样本
+// ========================================
+
+/** jest verbose 失败清单：✕ 用例名 + 结构化汇总行，全在 stdout 里 */
+const JEST_FAILED_CASES = `FAIL src/app.test.ts
+  App
+    ✕ renders title (23 ms)
+    ✓ renders subtitle (5 ms)
+
+Test Suites: 1 failed, 1 total
+Tests:       1 failed, 1 passed, 2 total
+`;
+
+/** jest 非 verbose：没有 ✕ 行，只有汇总行说失败了 */
+const JEST_SUMMARY_ONLY_FAILURE = `Test Suites: 2 failed, 2 total
+Tests:       3 failed, 3 total
+`;
+
+/**
+ * 全绿输出，但通过的用例名里带大写 FAIL 字样。
+ * 不带汇总行 / 无 "passed" 字样 —— 这正是旧 acceptance 落到裸 includes('FAIL') 兜底那一支的形状。
+ */
+const JEST_GREEN_WITH_FAIL_IN_NAME = `PASS src/a.test.js
+  App
+    ✓ FAIL 时应该重试 (3 ms)
+`;
+
+/** jest 全绿 */
+const JEST_GREEN = `PASS src/a.test.js
+Test Suites: 1 passed, 1 total
+Tests:       3 passed, 3 total
+`;
+
+type Sample = { name: string; exitCode: number; output: string; expected: boolean };
+
+const SAMPLES: Sample[] = [
+  { name: 'exit 0 + jest ✕ 失败清单', exitCode: 0, output: JEST_FAILED_CASES, expected: false },
+  { name: 'exit 0 + jest 汇总行只有 failed', exitCode: 0, output: JEST_SUMMARY_ONLY_FAILURE, expected: false },
+  { name: 'exit 0 + 全绿但用例名含 FAIL', exitCode: 0, output: JEST_GREEN_WITH_FAIL_IN_NAME, expected: true },
+  { name: 'exit 0 + jest 全绿', exitCode: 0, output: JEST_GREEN, expected: true },
+  { name: 'exit 1 + 全绿文本（文本不赦免非零退出）', exitCode: 1, output: JEST_GREEN, expected: false },
+];
+
+// ========================================
+// 两个门禁的公开面
+// ========================================
+
+/** 退出结果：数字 = 退出码；'killed' = 超时/信号杀掉，reject 的 error 上没有数字退出码 */
+type ExitResult = number | 'killed';
+type VerdictSample = { exitCode: ExitResult; output: string };
+
+/** 同一份样本 + 同一退出结果喂给 exec mock：0 → resolve，其余 → reject */
+function stubRunner(exitCode: ExitResult, stdout: string): void {
+  mockExec.mockImplementationOnce((...args: unknown[]) => {
+    const callback = args[2] as (err: unknown, res?: unknown) => void;
+    if (exitCode === 0) {
+      callback(null, { stdout, stderr: '' });
+      return;
+    }
+    const error = Object.assign(
+      new Error(exitCode === 'killed' ? 'test timed out after 120000ms' : 'Command failed: npm test'),
+      { stdout, stderr: '', ...(exitCode === 'killed' ? {} : { code: exitCode }) },
+    );
+    callback(error);
+  });
+}
+
+async function verdictFromPassesGate(sample: VerdictSample): Promise<boolean> {
+  stubRunner(sample.exitCode, sample.output);
+  const gate = new PassesGate({ testCommand: 'npm test', requireEvidence: false });
+  return (await gate.runTests('/test/project')).passed;
+}
+
+async function verdictFromAcceptance(sample: VerdictSample): Promise<boolean> {
+  mockFs.readFile.mockResolvedValueOnce(`
+tasks:
+  - id: TASK-001
+    acceptance:
+      - description: 验收条件
+        e2e_test: tests/example.spec.ts
+`);
+  stubRunner(sample.exitCode, sample.output);
+  const gate = new SpecAcceptanceGate();
+  const result = await gate.check({ projectPath: '/test/project', taskId: 'TASK-001' });
+  return result.passed;
+}
+
+describe('两门禁对同一份 runner 输出给出同一结论', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  for (const sample of SAMPLES) {
+    it(`${sample.name} → 同判「${sample.expected ? '过' : '不过'}」`, async () => {
+      const fromPassesGate = await verdictFromPassesGate(sample);
+      const fromAcceptance = await verdictFromAcceptance(sample);
+
+      expect({ fromPassesGate, fromAcceptance }).toEqual({
+        fromPassesGate: sample.expected,
+        fromAcceptance: sample.expected,
+      });
+      expect(fromAcceptance).toBe(fromPassesGate);
+    });
+  }
+
+  it('runner 被超时杀掉（无数字退出码）→ 同判「不过」', async () => {
+    const sample: VerdictSample = { exitCode: 'killed', output: JEST_GREEN };
+
+    expect(await verdictFromPassesGate(sample)).toBe(false);
+    expect(await verdictFromAcceptance(sample)).toBe(false);
+  });
+});

package/src/gates/acceptance.ts

@@ -18,56 +18,24 @@
  */
 
 import { execAsync } from '../utils/exec';
+import { judgeTestRun } from '../core/validators/test-output';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as yaml from 'js-yaml';
-import type { Gate, GateContext, GateDecision } from './types';
+import type {
+  Gate,
+  GateContext,
+  GateDecision,
+  SpecAcceptanceGateConfig,
+  AcceptanceGateContext,
+  AcceptanceCriteria,
+} from './types';
 import { decisionFromResult } from './decision';
 
 
 // ==================== 类型定义 ====================
-
-/**
- * 验收标准门禁配置
- */
-export interface SpecAcceptanceGateConfig {
-  /** tasks.yml 路径 */
-  tasksPath?: string;
-  /** 是否检查所有任务 */
-  checkAllTasks?: boolean;
-  /** 自定义验收条件 */
-  customAcceptanceCriteria?: Record<string, (task: any) => Promise<boolean>>;
-  /** E2E 测试命令模板 */
-  e2eTestCommand?: string;
-  /** E2E 测试超时时间（毫秒） */
-  e2eTestTimeout?: number;
-  /** 项目路径 */
-  projectPath?: string;
-}
-
-/**
- * 验收标准门禁上下文
- */
-export interface AcceptanceGateContext {
-  /** 项目路径 */
-  projectPath: string;
-  /** 任务 ID */
-  taskId?: string;
-  /** tasks.yml 路径 */
-  tasksPath?: string;
-}
-
-/**
- * 验收标准（旧格式，向后兼容）
- */
-export interface AcceptanceCriteria {
-  id: string;
-  description: string;
-  type: 'manual' | 'automated' | 'test';
-  required: boolean;
-  checked?: boolean;
-  notes?: string;
-}
+// SpecAcceptanceGateConfig / AcceptanceGateContext / AcceptanceCriteria 正本在 ./types
+// （harness#101：本文件不再持有双份定义与工厂，测试与公共面同走 gates/index seam）
 
 /**
  * 验收条件（新格式，支持 E2E 测试关联）
@@ -144,7 +112,6 @@ export class SpecAcceptanceGate implements Gate {
 
   constructor(config?: Partial<SpecAcceptanceGateConfig>) {
     this.config = {
-      tasksPath: './tasks.yml',
       checkAllTasks: false,
       e2eTestCommand: 'npx playwright test',
       e2eTestTimeout: 120000,
@@ -176,10 +143,11 @@ export class SpecAcceptanceGate implements Gate {
    */
   async check(context: AcceptanceGateContext): Promise<AcceptanceGateResult> {
     try {
-      // 确定 tasks.yml 路径
-      const tasksPath = context.tasksPath ?? 
-        this.config.tasksPath ?? 
-        path.join(context.projectPath, 'tasks.yml');
+      // 确定 tasks.yml 路径：相对值一律锚在 projectPath（此处不取 cwd）
+      const tasksPath = path.resolve(
+        context.projectPath,
+        context.tasksPath ?? this.config.tasksPath ?? 'tasks.yml',
+      );
 
       // 加载 tasks 文件
       const tasks = await this.loadTasks(tasksPath);
@@ -458,7 +426,8 @@ export class SpecAcceptanceGate implements Gate {
       });
 
       const output = stdout + stderr;
-      const passed = this.parseTestOutput(output);
+      // 退出码为 0 的分支：文本只能否决，不能反向加分（与 passes-gate 同一判定入口，ADR-0014）
+      const { passed } = judgeTestRun({ exitCode: 0, output });
 
       return {
         criteria: testFile,
@@ -468,7 +437,7 @@ export class SpecAcceptanceGate implements Gate {
         output: output.substring(0, 2000),
       };
     } catch (error: any) {
-      // 超时或执行失败
+      // 超时或非零退出的分支：判负，文本不参与（文本救不回非零退出，ADR-0014）
       return {
         criteria: testFile,
         testFile,
@@ -479,38 +448,4 @@ export class SpecAcceptanceGate implements Gate {
       };
     }
   }
-
-  /**
-   * 解析测试输出判断是否通过
-   */
-  private parseTestOutput(output: string): boolean {
-    // Playwright 格式
-    if (output.includes('passed')) {
-      // 检查是否有失败
-      const failedMatch = output.match(/(\d+)\s+failed/);
-      if (failedMatch && parseInt(failedMatch[1]) > 0) {
-        return false;
-      }
-      return true;
-    }
-    
-    // Jest 格式
-    if (output.includes('Test Suites:')) {
-      const match = output.match(/Test Suites:\s+(\d+)\s+failed/);
-      if (match && parseInt(match[1]) > 0) {
-        return false;
-      }
-      return output.includes('passed');
-    }
-    
-    // 通用格式
-    return output.includes('PASS') && !output.includes('FAIL');
-  }
-}
-
-/**
- * 创建验收标准门禁（便捷函数）
- */
-export function createSpecAcceptanceGate(config?: Partial<SpecAcceptanceGateConfig>): SpecAcceptanceGate {
-  return new SpecAcceptanceGate(config);
 }

package/src/gates/checker-gate.ts

@@ -10,6 +10,7 @@
 import type { ConstraintCheck } from '../core/constraints/checkers';
 import { buildCheckEnv } from '../core/constraints/checkers';
 import type { Gate, GateContext, GateDecision } from './types';
+import { gateResult } from './types';
 import { decisionFromResult } from './decision';
 
 /**
@@ -29,18 +30,18 @@ export function createCheckerGate(check: ConstraintCheck, order = 0): Gate {
       const projectPath = ctx.projectPath || process.cwd();
       const env = buildCheckEnv({ operation: 'manual', projectPath }, 'none');
       const outcome = await check.evaluate(env);
-      return decisionFromResult({
-        gate: check.id,
-        passed: outcome !== false,
-        message:
+      return decisionFromResult(
+        gateResult(
+          check.id,
+          outcome !== false,
           outcome === false
             ? `checker "${check.id}" 判定违规`
             : outcome === 'skip'
               ? `checker "${check.id}" 跳过（证据未接线）`
               : `checker "${check.id}" 通过`,
-        timestamp: new Date().toISOString(),
-        duration: Date.now() - startTime,
-      });
+          startTime
+        )
+      );
     },
   };
 }

package/src/gates/command.ts

@@ -5,6 +5,7 @@
  * 检查命令是否安全，防止执行危险操作
  */
 
+import { pass, gateResult } from './types';
 import type { GateResult, CommandGateConfig, CommandBlacklistRule, Gate, GateContext, GateDecision } from './types';
 import { decisionFromResult } from './decision';
 
@@ -232,32 +233,25 @@ export class CommandGate implements Gate {
     const startTime = Date.now();
 
     if (!this.config.enabled) {
-      return {
-        gate: 'command',
-        passed: true,
-        message: '命令门禁已禁用',
-        timestamp: new Date().toISOString(),
-        duration: Date.now() - startTime,
-      };
+      return pass('command', '命令门禁已禁用', startTime);
     }
 
     const result = this.checkBlacklist(command);
 
-    return {
-      gate: 'command',
-      passed: result.allowed,
-      message: result.allowed
+    return gateResult(
+      'command',
+      result.allowed,
+      result.allowed
         ? this.formatSuccessMessage(result)
         : this.formatBlockMessage(result),
-      details: {
+      startTime,
+      {
         blocked: result.blocked,
         warnings: result.warnings,
         audits: result.audits,
         command,
-      },
-      timestamp: new Date().toISOString(),
-      duration: Date.now() - startTime,
-    };
+      }
+    );
   }
 
   /**