@dommaker/harness 1.7.0 → 1.8.1

package/src/utils/__tests__/numeric-flag.test.ts

@@ -0,0 +1,80 @@
+/**
+ * 数值旗帜装配解析器测试（harness#154）
+ *
+ * 口径正本：src/cli/commands/CONTEXT.md「数值旗帜装配口径（harness#152）」条目——
+ * commander 给到命令侧恒是字符串、数值只在装配点转一次、转不出来 fail-loud。
+ * 本模块是全部数值旗帜的唯一解析器：定义表 mapActionArgs 走 requireNumericFlag（抛
+ * NumericFlagError，bin 映射 usage-error），命令模块入口走 parseNumericFlag（返回值
+ * 判别，就地 logError + usage-error）。
+ */
+
+import {
+  NumericFlagError,
+  numericFlagMessage,
+  parseNumericFlag,
+  requireNumericFlag,
+} from '../numeric-flag';
+
+describe('parseNumericFlag：int 形', () => {
+  it('合法：十进制整数字符串 → 数值；undefined → 未传（落下游缺省）', () => {
+    expect(parseNumericFlag('20', 'int')).toEqual({ ok: true, value: 20 });
+    expect(parseNumericFlag(' 7 ', 'int')).toEqual({ ok: true, value: 7 });
+    expect(parseNumericFlag(undefined, 'int')).toEqual({ ok: true });
+  });
+
+  it('显式 "0" 是合法零值，不当「未传」兜掉', () => {
+    expect(parseNumericFlag('0', 'int')).toEqual({ ok: true, value: 0 });
+  });
+
+  it.each(['abc', '30abc', '1e2', '0.7', '-5', '', ' ', 'NaN', 'Infinity', '0x10'])(
+    '脏输入 %o → ok:false（parseInt 会静默误读的形一并拒）',
+    (raw) => {
+      expect(parseNumericFlag(raw, 'int')).toEqual({ ok: false, raw });
+    },
+  );
+
+  it('数值溢出（位数字符串超 double 上限）→ ok:false，不放 Infinity 进判定槽', () => {
+    const raw = '9'.repeat(400);
+    expect(parseNumericFlag(raw, 'int')).toEqual({ ok: false, raw });
+  });
+});
+
+describe('parseNumericFlag：float 形', () => {
+  it('合法：整数与小数字符串 → 数值', () => {
+    expect(parseNumericFlag('0.8', 'float')).toEqual({ ok: true, value: 0.8 });
+    expect(parseNumericFlag('1', 'float')).toEqual({ ok: true, value: 1 });
+    expect(parseNumericFlag('0', 'float')).toEqual({ ok: true, value: 0 });
+  });
+
+  it.each(['abc', '0.8.1', '1.', '.5', '1e-3', '-0.5', '', 'NaN', 'Infinity'])(
+    '脏输入 %o → ok:false',
+    (raw) => {
+      expect(parseNumericFlag(raw, 'float')).toEqual({ ok: false, raw });
+    },
+  );
+});
+
+describe('numericFlagMessage / requireNumericFlag', () => {
+  it('报错文案点名旗帜与原值（可定位）', () => {
+    expect(numericFlagMessage('--limit', 'abc', 'int')).toBe('错误：--limit 需要非负整数，收到 "abc"');
+    expect(numericFlagMessage('--noise-fail-rate', 'x', 'float')).toBe('错误：--noise-fail-rate 需要非负数值，收到 "x"');
+  });
+
+  it('合法值原样返回；未传 → undefined', () => {
+    expect(requireNumericFlag('--limit', '20', 'int')).toBe(20);
+    expect(requireNumericFlag('--limit', '0', 'int')).toBe(0);
+    expect(requireNumericFlag('--limit', undefined, 'int')).toBeUndefined();
+  });
+
+  it('脏输入抛 NumericFlagError（bin 据 name/instanceof 映射 usage-error）', () => {
+    let caught: unknown;
+    try {
+      requireNumericFlag('--zero-intercept-min', 'abc', 'int');
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(NumericFlagError);
+    expect((caught as Error).name).toBe('NumericFlagError');
+    expect((caught as Error).message).toBe('错误：--zero-intercept-min 需要非负整数，收到 "abc"');
+  });
+});

package/src/utils/__tests__/package-version.test.ts

@@ -9,6 +9,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { getHarnessPackageVersion } from '../package-version';
 
 const REAL_VERSION = JSON.parse(
@@ -21,8 +22,7 @@ describe('getHarnessPackageVersion', () => {
   });
 
   it('cwd 是消费者项目时仍读 harness 版本，不误读消费者 package.json', () => {
-    const consumerDir = path.join(process.cwd(), 'temp-test-pkg-version-consumer');
-    fs.mkdirSync(consumerDir, { recursive: true });
+    const consumerDir = fs.mkdtempSync(path.join(os.tmpdir(), 'temp-test-pkg-version-consumer-'));
     fs.writeFileSync(
       path.join(consumerDir, 'package.json'),
       JSON.stringify({ name: 'consumer-app', version: '9.9.9' })

package/src/utils/exec.ts

@@ -1,7 +1,10 @@
 /**
  * 通用工具模块
  *
- * 提供命令执行、数组规范化、延迟等公共函数，减少各子系统重复代码。
+ * 提供命令执行的公共函数，减少各子系统重复代码。
+ * 约束域谓词不在本模块（harness#137：`normalizeTriggers`/`matchesTrigger` 已迁
+ * `core/constraints/triggers.ts`；`isCommandAvailable`/`delay` 双仓零生产消费者，已删；
+ * `runCommand` 零生产调用点且不在包公共面，按 ADR-0022 同判据随 harness#162 删除）。
  */
 
 import { exec } from 'child_process';
@@ -11,66 +14,3 @@ import { promisify } from 'util';
  * Promisified exec
  */
 export const execAsync = promisify(exec);
-
-/**
- * 执行命令并返回 stdout（忽略 stderr）
- */
-export async function runCommand(command: string, cwd?: string): Promise<string> {
-  try {
-    const { stdout } = await execAsync(command, {
-      cwd,
-      maxBuffer: 1024 * 1024, // 1MB buffer
-    });
-    return stdout.trim();
-  } catch {
-    return '';
-  }
-}
-
-/**
- * 检查命令是否可用
- */
-export async function isCommandAvailable(command: string): Promise<boolean> {
-  try {
-    // 使用 execFile 避免命令注入（不通过 shell 解析）
-    const { execFile: execFileCb } = await import('child_process');
-    const execFileAsync = promisify(execFileCb);
-    await execFileAsync('which', [command]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * 将单值或数组统一为数组（用于 trigger 等字段）
- */
-export function normalizeTriggers<T>(
-  value: T | T[] | undefined,
-  fallback: T[] = []
-): T[] {
-  if (value === undefined || value === null) return fallback;
-  return Array.isArray(value) ? value : [value];
-}
-
-/**
- * 判断约束是否匹配当前操作集合（#105：trigger 匹配语义单一来源）
- *
- * 语义 = normalizeTriggers（undefined → [] 不匹配任何操作）+ 交集判定，
- * 任一 operation 命中任一 trigger 即匹配。checker 与 prompt 渲染共用本函数，
- * 禁止就地重写。
- */
-export function matchesTrigger<T>(
-  constraint: { trigger: T | T[] | undefined },
-  operations: T[]
-): boolean {
-  const triggers = normalizeTriggers(constraint.trigger);
-  return operations.some(op => triggers.includes(op));
-}
-
-/**
- * 异步延迟
- */
-export function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/utils/jsonl.ts

@@ -11,9 +11,12 @@
  * 也不反转既有容错调用点的语义。坏行指非空但 JSON.parse 失败的行
  * （半写入截断、手工编辑、磁盘满等）。
  *
- * tail / head：只解析尾部 / 头部 N 个非空行（文件仍全量读取，parse 才是大头），
- * 供「只看最近 K 条」的调用点避免全量 parse（check 等热路径）。
- * countJsonlLines 供纯计数消费方（完全不 parse）。
+ * tail：从文件末尾倒着分块 seek，只把够数的尾部行读进内存。2026-09-14 量数据推翻本文件
+ * 早先「文件仍全量读取，parse 才是大头」的断言：6.7MB / 32723 行的 traces.log 上，
+ * 完全不 parse 的整读单次仍 16.6–21.1ms——成本在 split('\n') 与空白行过滤。
+ * head：从文件头正向分块读，够数即停——供「有没有至少 N 条」这类阈值消费方，不再为
+ * 一个比较符把全文捞进内存。
+ * 两者同给或都不给时才整读后截断（head→tail 顺序即既有语义）。
  *
  * 计数去向（harness#100）：本模块是坏行计数的唯一正本，但正本≠终点——凡以 'skip'
  * 策略读，调用点必须把 skippedLines 带到该消费面的用户可见输出（CLI 走 stderr，
@@ -69,24 +72,106 @@ function readNonEmptyLines(filePath: string): string[] {
     .filter(line => line.trim().length > 0);
 }
 
+/** tail 倒读的分块大小：trace 行约 200B，一块即够几十行 */
+const TAIL_CHUNK_BYTES = 64 * 1024;
+
+/** head 正读的分块大小 */
+const HEAD_CHUNK_BYTES = 64 * 1024;
+
 /**
- * 读取 JSONL 文件：exists → read → split → parse → filter（正本读链）
+ * 从文件头正向分块读，只返回前 want 个非空行（够数即停，不整读）
  *
- * policy 必填无缺省（裁决 1）；缺文件返回空结果，不抛。
+ * 与「整读后 slice(0, want)」逐字同语义：行以 `\n` 界定，末块无尾换行时整段收尾算一行，
+ * 纯空白行不计数。块边界切在多字节字符中间时，残段按字节留在缓冲里等下一块拼齐再解码。
+ * 供「有没有至少 N 条记录」这类阈值消费方——它要的是够不够，不是总数。
  */
-export function readJsonl<T>(
-  filePath: string,
-  policy: JsonlBadLinePolicy,
-  options?: JsonlReadOptions
-): JsonlReadResult<T> {
-  let lines = readNonEmptyLines(filePath);
-  if (options?.head !== undefined) {
-    lines = options.head > 0 ? lines.slice(0, options.head) : [];
+function readHeadNonEmptyLines(filePath: string, want: number): string[] {
+  if (want <= 0) return [];
+  if (!fs.existsSync(filePath)) return [];
+
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const size = fs.fstatSync(fd).size;
+    const kept: string[] = [];
+    let acc = Buffer.alloc(0);
+    let pos = 0;
+    while (kept.length < want) {
+      const end = Math.min(size, pos + HEAD_CHUNK_BYTES);
+      if (end > pos) {
+        const chunk = Buffer.alloc(end - pos);
+        fs.readSync(fd, chunk, 0, end - pos, pos);
+        acc = Buffer.concat([acc, chunk]);
+      }
+      let cursor = 0;
+      for (let i = 0; i < acc.length && kept.length < want; i++) {
+        if (acc[i] !== 0x0a) continue;
+        const line = acc.subarray(cursor, i).toString('utf-8');
+        if (line.trim().length > 0) kept.push(line);
+        cursor = i + 1;
+      }
+      if (end >= size) {
+        // 读到文件末尾：最后一段没有换行收尾，但它就是一行
+        if (kept.length < want && cursor < acc.length) {
+          const last = acc.subarray(cursor).toString('utf-8');
+          if (last.trim().length > 0) kept.push(last);
+        }
+        break;
+      }
+      pos = end;
+      acc = acc.subarray(cursor);
+    }
+    return kept;
+  } finally {
+    fs.closeSync(fd);
   }
-  if (options?.tail !== undefined) {
-    lines = options.tail > 0 ? lines.slice(-options.tail) : [];
+}
+
+/**
+ * 从文件末尾倒着分块读，只返回末尾 want 个非空行（文件顺序）
+ *
+ * 与「整读后 slice(-want)」逐字同语义：行以 `\n` 界定，末行允许无换行，`\r` 随行进文本，
+ * 纯空白行不计数。左侧残段（块边界切在多字节字符中间）不解码，按字节留到下一轮——
+ * UTF-8 的多字节序列不含 0x0a，故按 `\n` 切字节再解码不会破坏字符。
+ */
+function readTailNonEmptyLines(filePath: string, want: number): string[] {
+  if (want <= 0) return [];
+  if (!fs.existsSync(filePath)) return [];
+
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    let pos = fs.fstatSync(fd).size;
+    let acc = Buffer.alloc(0);
+    for (;;) {
+      const start = Math.max(0, pos - TAIL_CHUNK_BYTES);
+      if (pos > start) {
+        const chunk = Buffer.alloc(pos - start);
+        fs.readSync(fd, chunk, 0, pos - start, start);
+        acc = Buffer.concat([chunk, acc]);
+      }
+      pos = start;
+
+      const lines: string[] = [];
+      let cursor = pos === 0 ? 0 : -1;
+      for (let i = 0; i < acc.length; i++) {
+        if (acc[i] !== 0x0a) continue;
+        if (cursor >= 0) lines.push(acc.subarray(cursor, i).toString('utf-8'));
+        cursor = i + 1;
+      }
+      if (cursor >= 0 && cursor < acc.length) lines.push(acc.subarray(cursor).toString('utf-8'));
+
+      const kept = lines
+        .filter(line => line.trim().length > 0)
+        .slice(-want);
+      // 已到文件头 → 全部行都在手里；否则末尾 want 个非空行已凑齐，左侧只可能是更早的行
+      if (pos === 0 || kept.length >= want) return kept;
+    }
+  } finally {
+    fs.closeSync(fd);
   }
+}
 
+/** parse 非空行文本（读链的末段；坏行策略同 readJsonl） */
+function parseJsonlLines<T>(lines: string[], policy: JsonlBadLinePolicy): JsonlReadResult<T> {
   const records: T[] = [];
   let skippedLines = 0;
   for (const line of lines) {
@@ -101,13 +186,67 @@ export function readJsonl<T>(
 }
 
 /**
- * 统计非空行数（含坏行，完全不 parse）
+ * 读取 JSONL 文件：exists → read → split → parse → filter（正本读链）
+ *
+ * policy 必填无缺省（裁决 1）；缺文件返回空结果，不抛。
+ * 只给 head 走有界正读、只给 tail 走倒读 seek；两者同给或都不给走整读后截断
+ * （head→tail 的截断顺序即既有语义）。
+ */
+export function readJsonl<T>(
+  filePath: string,
+  policy: JsonlBadLinePolicy,
+  options?: JsonlReadOptions
+): JsonlReadResult<T> {
+  let lines: string[];
+  if (options?.head !== undefined && options.tail === undefined) {
+    lines = readHeadNonEmptyLines(filePath, options.head);
+  } else if (options?.tail !== undefined && options.head === undefined) {
+    lines = readTailNonEmptyLines(filePath, options.tail);
+  } else {
+    lines = applyHeadTail(readNonEmptyLines(filePath), options);
+  }
+  return parseJsonlLines<T>(lines, policy);
+}
+
+/**
+ * 尾部窗口：一次分块读行文本，之后按不同 tail 口径反复取用
  *
- * 供只关心记录条数的调用点（如 check 智能提示）避免全量 parse；
- * 缺文件返回 0。
+ * 供「同一次运行里有多个消费方、各看不同长度的尾部」的场景（ADR-0023 run 内共享），
+ * 取一份行文本而不是各捞一遍。`take(limit)` 与 `readJsonl(..., { tail: limit })` 逐字
+ * 同口径：**先按行文本截窗再 parse**——坏行占尾部槽位不占 records 名额，若改拿大窗口的
+ * records 再切，窗口内有坏行时小窗口会多收更老的有效记录，判定就变了。
  */
-export function countJsonlLines(filePath: string): number {
-  return readNonEmptyLines(filePath).length;
+export interface JsonlWindow<T> {
+  take(limit: number): JsonlReadResult<T>;
+}
+
+export function readJsonlWindow<T>(
+  filePath: string,
+  policy: JsonlBadLinePolicy,
+  maxLines: number
+): JsonlWindow<T> {
+  const lines = readTailNonEmptyLines(filePath, maxLines);
+  return {
+    take: (limit: number) => {
+      if (limit > maxLines) {
+        throw new Error(
+          `尾部窗口上限 ${maxLines} 行，无法取 ${limit} 行——建窗口时按最大消费方取值，或改上限（不静默少给）`
+        );
+      }
+      return parseJsonlLines<T>(limit > 0 ? lines.slice(-limit) : [], policy);
+    },
+  };
+}
+
+/** 整读路径上的 head → tail 截断（顺序即既有语义：先截头再截尾） */
+function applyHeadTail(lines: string[], options?: JsonlReadOptions): string[] {
+  if (options?.head !== undefined) {
+    lines = options.head > 0 ? lines.slice(0, options.head) : [];
+  }
+  if (options?.tail !== undefined) {
+    lines = options.tail > 0 ? lines.slice(-options.tail) : [];
+  }
+  return lines;
 }
 
 export interface JsonlEndsResult<T> {

package/src/utils/numeric-flag.ts

@@ -0,0 +1,64 @@
+/**
+ * 数值旗帜装配解析器（harness#154；口径正本 = src/cli/commands/CONTEXT.md
+ * 「数值旗帜装配口径（harness#152）」条目，本模块是该条目指名的唯一解析器）
+ *
+ * 背景：commander 给到命令侧的数值旗帜恒是字符串（`defaultValue: '50'` 也是），
+ * 数值只在装配点转一次，转不出来必须 fail-loud——下游兜底多是 `??`/`||`，
+ * NaN 穿透后比较恒 false，一道质量判定被静默关掉而退出码仍是 0（#152 病灶）。
+ * `parseInt`/`parseFloat` 不可用：它们前缀截断（'30abc'→30、'1e2'→1）同属静默误读。
+ *
+ * 两个消费形（同一条判定规则，不建第二套解析器）：
+ * - `requireNumericFlag`：定义表 `mapActionArgs` 装配点用，脏值抛 `NumericFlagError`，
+ *   bin/harness.js 捕获后映射 usage-error（非零退出）；
+ * - `parseNumericFlag`：命令模块入口装配点用（knowledge/failure/passes-gate），
+ *   返回值判别，就地 `logError` + `usage-error`。
+ */
+
+/** 数值形：int = 非负整数；float = 非负十进制（不收指数/符号/前后缀） */
+export type NumericFlagKind = 'int' | 'float';
+
+/** 装配结果：`ok: false` = 脏输入，由装配点 fail-loud（不得往判定槽塞 NaN） */
+export type NumericFlagAssembly = { ok: true; value?: number } | { ok: false; raw: string };
+
+/**
+ * 装配窄化：`undefined` = 未传（落下游缺省）；`'0'` 是显式零值，不当「未传」兜掉。
+ * 规则与 #152 `assembleShortContentThreshold` 同源：trim 后全数字（float 允许一段小数），
+ * 溢出 double 上限（→ Infinity）同脏值处理。
+ */
+export function parseNumericFlag(raw: string | undefined, kind: NumericFlagKind): NumericFlagAssembly {
+  if (raw === undefined) return { ok: true };
+  const text = raw.trim();
+  const pattern = kind === 'int' ? /^\d+$/ : /^\d+(\.\d+)?$/;
+  if (!pattern.test(text)) return { ok: false, raw };
+  const value = Number(text);
+  if (!Number.isFinite(value)) return { ok: false, raw };
+  return { ok: true, value };
+}
+
+/** 报错文案模板：点名旗帜与原值（可定位），int/float 措辞一致收敛 */
+export function numericFlagMessage(flag: string, raw: string, kind: NumericFlagKind): string {
+  return `错误：${flag} 需要非负${kind === 'int' ? '整数' : '数值'}，收到 "${raw}"`;
+}
+
+/** 定义表装配失败的专用错误：bin/harness.js 凭它映射 usage-error（非零退出） */
+export class NumericFlagError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NumericFlagError';
+  }
+}
+
+/**
+ * 定义表 `mapActionArgs` 装配点用：脏值抛 `NumericFlagError`。
+ * 定义表是纯数据模块，返回不了 CommandResult；退出码映射唯一出口在 bin，
+ * 故以抛出表达失败、bin 就地捕获映射，不新增第二条失败通道。
+ */
+export function requireNumericFlag(
+  flag: string,
+  raw: string | undefined,
+  kind: NumericFlagKind,
+): number | undefined {
+  const result = parseNumericFlag(raw, kind);
+  if (!result.ok) throw new NumericFlagError(numericFlagMessage(flag, result.raw, kind));
+  return result.value;
+}

package/dist/failure/types.d.ts

@@ -1,9 +0,0 @@
-/**
- * 失败处理类型定义（兼容再导出）
- *
- * 工单 14：类型定义本体已归位 types 层（src/types/failure.ts），
- * 以消除 types/index.ts 对 ../failure 的反向 import。
- * 此文件保留原模块路径，供既有引用方（classifier/recorder/index 与外部消费者）继续工作。
- */
-export * from '../types/failure';
-//# sourceMappingURL=types.d.ts.map

package/dist/failure/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/failure/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,kBAAkB,CAAC"}

package/dist/failure/types.js

@@ -1,25 +0,0 @@
-"use strict";
-/**
- * 失败处理类型定义（兼容再导出）
- *
- * 工单 14：类型定义本体已归位 types 层（src/types/failure.ts），
- * 以消除 types/index.ts 对 ../failure 的反向 import。
- * 此文件保留原模块路径，供既有引用方（classifier/recorder/index 与外部消费者）继续工作。
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("../types/failure"), exports);
-//# sourceMappingURL=types.js.map

package/dist/failure/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/failure/types.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;AAEH,mDAAiC"}

package/dist/gates/effective-gates.d.ts

@@ -1,30 +0,0 @@
-/**
- * 生效门禁集（G1）：对齐 getEffectiveConstraints 的 config 裁剪模式
- *
- * 单一来源：注册表（默认 order）→ config.yml `gates.order` 声明式重排 →
- * `gates.<id>.enabled:false` 裁剪移除。
- *
- * 闭环：config.yml gates 配置引用了未注册的门禁 id → 抛错
- * （与注册表「引用未注册」同款闭环；gates 配置段为新增面，
- * 不存在历史残留配置，故不需静默忽略）。
- */
-import type { Gate } from './types';
-/**
- * config.yml `gates` 段
- */
-export interface GatesConfig {
-    /** 声明式顺序（门禁 id 列表）；未列出的按默认顺序排后 */
-    order?: string[];
-    /** 每个门禁的启用开关（gates.<id>.enabled: false = 裁剪） */
-    [gateId: string]: {
-        enabled?: boolean;
-    } | string[] | undefined;
-}
-/**
- * 获取项目当前生效的门禁集（按 order 升序）
- *
- * @param projectRoot 项目根路径（缺省 process.cwd()）
- * @throws config.yml gates 段引用未注册门禁 id 时抛错
- */
-export declare function getEffectiveGates(projectRoot?: string): Gate[];
-//# sourceMappingURL=effective-gates.d.ts.map

package/dist/gates/effective-gates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"effective-gates.d.ts","sourceRoot":"","sources":["../../src/gates/effective-gates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAKpC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,gDAAgD;IAChD,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;CAChE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,GAAE,MAAsB,GAAG,IAAI,EAAE,CA8D7E"}

package/dist/gates/effective-gates.js

@@ -1,81 +0,0 @@
-"use strict";
-/**
- * 生效门禁集（G1）：对齐 getEffectiveConstraints 的 config 裁剪模式
- *
- * 单一来源：注册表（默认 order）→ config.yml `gates.order` 声明式重排 →
- * `gates.<id>.enabled:false` 裁剪移除。
- *
- * 闭环：config.yml gates 配置引用了未注册的门禁 id → 抛错
- * （与注册表「引用未注册」同款闭环；gates 配置段为新增面，
- * 不存在历史残留配置，故不需静默忽略）。
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEffectiveGates = getEffectiveGates;
-const registry_1 = require("./registry");
-const project_config_loader_1 = require("../core/project-config-loader");
-const effective_set_1 = require("../core/effective-set");
-/**
- * 获取项目当前生效的门禁集（按 order 升序）
- *
- * @param projectRoot 项目根路径（缺省 process.cwd()）
- * @throws config.yml gates 段引用未注册门禁 id 时抛错
- */
-function getEffectiveGates(projectRoot = process.cwd()) {
-    const raw = (0, project_config_loader_1.loadRawProjectConfig)(projectRoot);
-    const config = raw?.gates;
-    const gates = (0, registry_1.listRegisteredGates)();
-    const known = new Set(gates.map(g => g.id));
-    if (!config) {
-        return sortByOrder(gates);
-    }
-    // ========================================
-    // 闭环校验（order 重排与重复 id 检测留门禁侧；
-    // enabled 段的未注册校验走共享筛选器 throw 模式）
-    // ========================================
-    const orderIds = Array.isArray(config.order) ? config.order : undefined;
-    if (orderIds) {
-        const seen = new Set();
-        for (const id of orderIds) {
-            if (!known.has(id)) {
-                throw new Error(`[harness] config.yml gates.order 引用了未注册的门禁 "${id}"。` +
-                    `可用门禁: ${[...known].join(', ')}。`);
-            }
-            if (seen.has(id)) {
-                throw new Error(`[harness] config.yml gates.order 中门禁 "${id}" 重复。`);
-            }
-            seen.add(id);
-        }
-    }
-    // ========================================
-    // enabled 裁剪（与 getEffectiveConstraints 的 enabled:false 删除同效）
-    // ========================================
-    const enabledEntries = {};
-    for (const [key, value] of Object.entries(config)) {
-        if (key === 'order')
-            continue;
-        enabledEntries[key] = value;
-    }
-    const { disabledIds } = (0, effective_set_1.filterEnabledEntries)(known, enabledEntries, {
-        onUnknownId: 'throw',
-        unknownIdError: id => `[harness] config.yml gates.${id} 引用了未注册的门禁。` +
-            `可用门禁: ${[...known].join(', ')}。`,
-    });
-    const disabled = new Set(disabledIds);
-    const effective = gates.filter(g => !disabled.has(g.id));
-    // ========================================
-    // order 重排：列出的按列表顺序，未列出的按默认顺序排后
-    // ========================================
-    if (orderIds) {
-        const position = new Map(orderIds.map((id, i) => [id, i]));
-        return effective.sort((a, b) => {
-            const pa = position.has(a.id) ? position.get(a.id) : orderIds.length + a.order;
-            const pb = position.has(b.id) ? position.get(b.id) : orderIds.length + b.order;
-            return pa - pb;
-        });
-    }
-    return sortByOrder(effective);
-}
-function sortByOrder(gates) {
-    return gates.sort((a, b) => a.order - b.order);
-}
-//# sourceMappingURL=effective-gates.js.map

package/dist/gates/effective-gates.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"effective-gates.js","sourceRoot":"","sources":["../../src/gates/effective-gates.ts"],"names":[],"mappings":"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"}

package/src/failure/types.ts

@@ -1,9 +0,0 @@
-/**
- * 失败处理类型定义（兼容再导出）
- *
- * 工单 14：类型定义本体已归位 types 层（src/types/failure.ts），
- * 以消除 types/index.ts 对 ../failure 的反向 import。
- * 此文件保留原模块路径，供既有引用方（classifier/recorder/index 与外部消费者）继续工作。
- */
-
-export * from '../types/failure';