@gordon.gan/specflow 1.8.0-beta → 1.8.2-beta

package/dist/core/document/extract.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Document Engine — deterministic contract extraction (grounding, engine-level).
+ *
+ * 从工程数据源**确定性**提取契约实体（接口/表），绕过 LLM 编造：
+ *  - OpenAPI 3.x (JSON/YAML) → 接口（method/path/operationId/请求响应字段/错误码）
+ *  - proto3 → 接口（rpc 名 + 服务名 + message 字段）
+ *  - SQL DDL (CREATE TABLE) → 表（表名/字段/类型/DDL 原文）
+ *
+ * 提取结果作为「工程契约候选」注入 outline 生成（Pass 1 冻结实体名）与章节填充
+ * （Pass 2 按 references 注入真实字段），让「接口字段少一个/表结构差一列」不再发生。
+ *
+ * 设计约束：
+ *  - **纯确定性**：不调 LLM，解析失败/文件缺失 → 静默跳过（提取是增强，不阻塞流程）。
+ *  - **输入源**：显式传入的 `--code` 文件 + 常见路径（openapi/proto/ddl 文件）。
+ *  - **按需加载**：只解析命中的文件，不递归全仓扫描（token/性能可控）。
+ */
+import type { SegmentableInput } from './input-digest.js';
+export interface ExtractedField {
+    name: string;
+    type: string;
+    required?: boolean;
+    desc?: string;
+}
+export interface ExtractedInterface {
+    id: string;
+    name: string;
+    method: string;
+    path: string;
+    request_fields?: ExtractedField[];
+    response_fields?: ExtractedField[];
+    errors?: Array<{
+        condition: string;
+        status: string;
+    }>;
+    source: string;
+}
+export interface ExtractedTable {
+    id: string;
+    name: string;
+    ddl: string;
+    fields?: ExtractedField[];
+    source: string;
+}
+export interface ExtractedContracts {
+    interfaces: ExtractedInterface[];
+    tables: ExtractedTable[];
+}
+export declare const EMPTY_CONTRACTS: ExtractedContracts;
+type SourceKind = 'openapi' | 'proto' | 'ddl';
+/** 候选文件：显式输入（--code/--design/--specs）+ 常见路径。只返回存在且可分类的文件。 */
+export declare function discoverContractFiles(inputs: SegmentableInput[], projectRoot?: string): Promise<Array<{
+    path: string;
+    kind: SourceKind;
+}>>;
+/**
+ * 从输入文件 + 工程常见路径确定性提取契约实体。
+ * - 解析失败/文件缺失 → 静默跳过（提取是增强，不阻塞流程）。
+ * - 返回稳定 id（I1…/T1…），供 outline references 使用。
+ */
+export declare function extractContracts(inputs: SegmentableInput[], projectRoot?: string): Promise<ExtractedContracts>;
+export {};

package/dist/core/document/extract.js

@@ -0,0 +1,437 @@
+/**
+ * Document Engine — deterministic contract extraction (grounding, engine-level).
+ *
+ * 从工程数据源**确定性**提取契约实体（接口/表），绕过 LLM 编造：
+ *  - OpenAPI 3.x (JSON/YAML) → 接口（method/path/operationId/请求响应字段/错误码）
+ *  - proto3 → 接口（rpc 名 + 服务名 + message 字段）
+ *  - SQL DDL (CREATE TABLE) → 表（表名/字段/类型/DDL 原文）
+ *
+ * 提取结果作为「工程契约候选」注入 outline 生成（Pass 1 冻结实体名）与章节填充
+ * （Pass 2 按 references 注入真实字段），让「接口字段少一个/表结构差一列」不再发生。
+ *
+ * 设计约束：
+ *  - **纯确定性**：不调 LLM，解析失败/文件缺失 → 静默跳过（提取是增强，不阻塞流程）。
+ *  - **输入源**：显式传入的 `--code` 文件 + 常见路径（openapi/proto/ddl 文件）。
+ *  - **按需加载**：只解析命中的文件，不递归全仓扫描（token/性能可控）。
+ */
+import { promises as fs } from 'node:fs';
+import { join, basename, extname } from 'node:path';
+import yaml from 'js-yaml';
+export const EMPTY_CONTRACTS = { interfaces: [], tables: [] };
+// ============= 文件发现 =============
+const OPENAPI_PATTERNS = [/openapi/i, /swagger/i];
+const PROTO_PATTERNS = [/(^|[\\/])[^\\/]*\.proto$/, /\.proto$/];
+const DDL_PATTERNS = [/ddl/i, /schema/i, /migration/i, /create\.sql/i];
+function classifySource(path) {
+    const base = basename(path);
+    const ext = extname(base).toLowerCase();
+    if (ext === '.json' || ext === '.yaml' || ext === '.yml') {
+        if (OPENAPI_PATTERNS.some((re) => re.test(base)))
+            return 'openapi';
+    }
+    if (ext === '.proto')
+        return 'proto';
+    if (ext === '.sql') {
+        if (DDL_PATTERNS.some((re) => re.test(base)))
+            return 'ddl';
+    }
+    return null;
+}
+/** 候选文件：显式输入（--code/--design/--specs）+ 常见路径。只返回存在且可分类的文件。 */
+export async function discoverContractFiles(inputs, projectRoot) {
+    const candidates = [];
+    for (const input of inputs) {
+        if (input.type === 'code' || input.type === 'design' || input.type === 'specs') {
+            candidates.push(input.source);
+        }
+    }
+    if (projectRoot) {
+        for (const rel of [
+            'openapi.yaml', 'openapi.yml', 'openapi.json', 'swagger.json', 'swagger.yaml',
+            'api/openapi.yaml', 'api/openapi.json', 'api/swagger.json',
+            'schema.sql', 'ddl.sql', 'migrations', 'proto', 'api/proto',
+        ]) {
+            candidates.push(join(projectRoot, rel));
+        }
+    }
+    const found = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        const kind = classifySource(candidate);
+        if (!kind)
+            continue;
+        try {
+            const stat = await fs.stat(candidate);
+            if (stat.isFile())
+                found.push({ path: candidate, kind });
+        }
+        catch {
+            // missing → skip (only explicit code/design/specs files that don't exist fall here)
+            if (candidate === inputs.find((i) => i.source === candidate)?.source) {
+                // explicit input file missing: keep silent, extraction is best-effort
+            }
+        }
+    }
+    return found;
+}
+// ============= OpenAPI 解析 =============
+/** 展开 $ref → 内联对象（仅支持同文件 ref，跨文件 ref 跳过）。 */
+function resolveRef(ref, doc) {
+    if (!ref.startsWith('#/'))
+        return null;
+    const parts = ref.slice(2).split('/').filter(Boolean);
+    let cur = doc;
+    for (const p of parts) {
+        if (cur && typeof cur === 'object' && p in cur) {
+            cur = cur[p];
+        }
+        else
+            return null;
+    }
+    return cur && typeof cur === 'object' ? cur : null;
+}
+function schemaToFields(schema, doc, depth = 0) {
+    if (depth > 3)
+        return undefined;
+    if (!schema || typeof schema !== 'object')
+        return undefined;
+    const s = schema;
+    if (s.$ref) {
+        const resolved = resolveRef(String(s.$ref), doc);
+        return resolved ? schemaToFields(resolved, doc, depth + 1) : undefined;
+    }
+    const props = s.properties;
+    if (!props || typeof props !== 'object')
+        return undefined;
+    const fields = [];
+    const requiredList = Array.isArray(s.required) ? s.required : [];
+    for (const [name, raw] of Object.entries(props)) {
+        const f = (raw ?? {});
+        const resolved = f.$ref ? resolveRef(String(f.$ref), doc) : f;
+        fields.push({
+            name,
+            type: String(resolved?.type ?? (resolved?.$ref ? String(resolved.$ref) : 'object')),
+            required: requiredList.includes(name),
+            desc: typeof resolved?.description === 'string' ? resolved.description : undefined,
+        });
+    }
+    return fields;
+}
+function parseOpenApiDoc(raw, source, doc) {
+    const out = { interfaces: [], tables: [] };
+    const paths = doc.paths;
+    if (!paths || typeof paths !== 'object')
+        return out;
+    const seenIds = new Set();
+    let n = 0;
+    for (const [path, pathItemRaw] of Object.entries(paths)) {
+        const pathItem = (pathItemRaw ?? {});
+        for (const method of ['get', 'post', 'put', 'patch', 'delete']) {
+            const op = pathItem[method];
+            if (!op || typeof op !== 'object')
+                continue;
+            const opObj = op;
+            n += 1;
+            const id = `I${n}`;
+            const name = typeof opObj.operationId === 'string'
+                ? opObj.operationId
+                : `${method.toUpperCase()} ${path}`;
+            if (seenIds.has(name))
+                continue;
+            seenIds.add(name);
+            const ext = {
+                id,
+                name,
+                method: method.toUpperCase(),
+                path,
+                source,
+            };
+            // 请求体字段
+            const rb = opObj.requestBody;
+            if (rb && rb.content && typeof rb.content === 'object') {
+                const jsonContent = rb.content['application/json'];
+                if (jsonContent && typeof jsonContent === 'object') {
+                    const schema = jsonContent.schema;
+                    ext.request_fields = schemaToFields(schema, doc);
+                }
+            }
+            // 响应字段（200/201 的 application/json）
+            const responses = opObj.responses;
+            if (responses && typeof responses === 'object') {
+                const okResp = responses['200'] ?? responses['201'];
+                if (okResp && typeof okResp === 'object') {
+                    const c = okResp.content;
+                    const jc = c?.['application/json'];
+                    if (jc?.schema)
+                        ext.response_fields = schemaToFields(jc.schema, doc);
+                }
+                // 错误码：非 2xx 响应
+                ext.errors = Object.entries(responses)
+                    .filter(([code]) => !/^2/.test(code) && /^\d{3}$/.test(code))
+                    .map(([code]) => ({ condition: `${code} 响应`, status: code }));
+            }
+            out.interfaces.push(ext);
+        }
+    }
+    return out;
+}
+// ============= proto3 解析（括号配平，支持嵌套 message / service 内 option） =============
+/** 从 `{` 起始位置用括号配平取回闭合的 body（忽略行注释、块注释与引号字符串）。 */
+function balancedBraceBody(raw, openIdx) {
+    let depth = 0;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let inString = null;
+    for (let i = openIdx; i < raw.length; i++) {
+        const c = raw[i];
+        const next = raw[i + 1];
+        if (inLineComment) {
+            if (c === '\n')
+                inLineComment = false;
+            continue;
+        }
+        if (inBlockComment) {
+            if (c === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            if (c === '\\') {
+                i++;
+                continue;
+            }
+            if (c === inString)
+                inString = null;
+            continue;
+        }
+        if (c === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (c === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            inString = c;
+            continue;
+        }
+        if (c === '{')
+            depth++;
+        else if (c === '}') {
+            depth--;
+            if (depth === 0)
+                return raw.slice(openIdx + 1, i);
+        }
+    }
+    return null; // 未闭合
+}
+function parseProto(raw, source) {
+    const out = { interfaces: [], tables: [] };
+    const messages = new Map();
+    // 收集 message 字段（嵌套 message 也递归收集，且外层字段不因嵌套截断）
+    const messageNameRe = /message\s+(\w+)\s*\{/g;
+    let m;
+    while ((m = messageNameRe.exec(raw)) !== null) {
+        const name = m[1];
+        const openIdx = raw.indexOf('{', m.index);
+        const body = balancedBraceBody(raw, openIdx);
+        if (body === null)
+            continue; // 未闭合 → 跳过
+        const fields = [];
+        for (const line of body.split('\n')) {
+            const fm = line.match(/^\s*(repeated\s+)?([\w.]+)\s+(\w+)\s*=\s*(\d+)/);
+            if (fm) {
+                fields.push({ name: fm[3], type: fm[2], required: !fm[1] });
+            }
+        }
+        messages.set(name, fields);
+    }
+    // 收集 rpc（service 体用括号配平，内嵌 option/http 不影响）
+    const serviceNameRe = /service\s+(\w+)\s*\{/g;
+    let n = 0;
+    while ((m = serviceNameRe.exec(raw)) !== null) {
+        const service = m[1];
+        const openIdx = raw.indexOf('{', m.index);
+        const body = balancedBraceBody(raw, openIdx);
+        if (body === null)
+            continue;
+        const rpcRe = /rpc\s+(\w+)\s*\(\s*([\w.]+)\s*\)\s*returns\s*\(\s*([\w.]+)\s*\)/g;
+        let r;
+        while ((r = rpcRe.exec(body)) !== null) {
+            n += 1;
+            const [, rpcName, reqMsg, respMsg] = r;
+            out.interfaces.push({
+                id: `I${n}`,
+                name: `${service}.${rpcName}`,
+                method: 'POST',
+                path: `/${service}/${rpcName}`,
+                request_fields: messages.get(reqMsg) ?? [],
+                response_fields: messages.get(respMsg) ?? [],
+                source,
+            });
+        }
+    }
+    // 无 service 时，message 也能作为表候选（简单映射）
+    if (n === 0) {
+        let t = 0;
+        for (const [name, fields] of messages) {
+            t += 1;
+            out.tables.push({
+                id: `T${t}`,
+                name,
+                ddl: `-- proto message ${name}（无 SQL DDL，字段见下方）`,
+                fields,
+                source,
+            });
+        }
+    }
+    return out;
+}
+// ============= SQL DDL 解析（括号配平，支持 DEFAULT/COMMENT 子句） =============
+function parseDdl(raw, source) {
+    const out = { interfaces: [], tables: [] };
+    const tableNameRe = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"]?([\w.]+)[`"]?\s*\(/gi;
+    let m;
+    let n = 0;
+    while ((m = tableNameRe.exec(raw)) !== null) {
+        const name = m[1];
+        const openIdx = raw.indexOf('(', m.index);
+        const body = balancedParenBody(raw, openIdx);
+        if (body === null)
+            continue; // 未闭合 → 跳过
+        n += 1;
+        const fields = [];
+        for (const line of body.split('\n')) {
+            const fm = line.match(/^\s*[`"]?(\w+)[`"]?\s+([\w()]+)\s*(?:NOT\s+NULL)?/i);
+            if (fm && !/^(PRIMARY|FOREIGN|UNIQUE|KEY|CONSTRAINT|INDEX)/i.test(fm[1])) {
+                fields.push({ name: fm[1], type: fm[2], required: /NOT\s+NULL/i.test(line) });
+            }
+        }
+        // 取完整 CREATE TABLE ... 语句（到顶层右括号后的第一个 ; 或行尾）
+        const closeIdx = findParenClose(raw, openIdx);
+        const stmtEnd = closeIdx >= 0 ? raw.indexOf(';', closeIdx) : -1;
+        const stmt = raw.slice(m.index, stmtEnd >= 0 ? stmtEnd + 1 : closeIdx >= 0 ? closeIdx + 1 : undefined).trim();
+        out.tables.push({
+            id: `T${n}`,
+            name,
+            ddl: stmt || `CREATE TABLE ${name} (...);`,
+            fields,
+            source,
+        });
+    }
+    return out;
+}
+/** 从 `(` 起始位置用括号配平取回 body（忽略引号字符串内的括号）。 */
+function balancedParenBody(raw, openIdx) {
+    let depth = 0;
+    let inString = null;
+    for (let i = openIdx; i < raw.length; i++) {
+        const c = raw[i];
+        if (inString) {
+            if (c === '\\') {
+                i++;
+                continue;
+            }
+            if (c === inString)
+                inString = null;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            inString = c;
+            continue;
+        }
+        if (c === '(')
+            depth++;
+        else if (c === ')') {
+            depth--;
+            if (depth === 0)
+                return raw.slice(openIdx + 1, i);
+        }
+    }
+    return null;
+}
+function findParenClose(raw, openIdx) {
+    let depth = 0;
+    let inString = null;
+    for (let i = openIdx; i < raw.length; i++) {
+        const c = raw[i];
+        if (inString) {
+            if (c === '\\') {
+                i++;
+                continue;
+            }
+            if (c === inString)
+                inString = null;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            inString = c;
+            continue;
+        }
+        if (c === '(')
+            depth++;
+        else if (c === ')') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+// ============= 主入口 =============
+/**
+ * 从输入文件 + 工程常见路径确定性提取契约实体。
+ * - 解析失败/文件缺失 → 静默跳过（提取是增强，不阻塞流程）。
+ * - 返回稳定 id（I1…/T1…），供 outline references 使用。
+ */
+export async function extractContracts(inputs, projectRoot) {
+    const files = await discoverContractFiles(inputs, projectRoot);
+    const out = { interfaces: [], tables: [] };
+    for (const { path, kind } of files) {
+        try {
+            const raw = await fs.readFile(path, 'utf-8');
+            if (kind === 'openapi') {
+                const doc = (await parseYamlOrJson(raw));
+                const parsed = parseOpenApiDoc(raw, path, doc);
+                out.interfaces.push(...parsed.interfaces);
+                out.tables.push(...parsed.tables);
+            }
+            else if (kind === 'proto') {
+                const parsed = parseProto(raw, path);
+                out.interfaces.push(...parsed.interfaces);
+                out.tables.push(...parsed.tables);
+            }
+            else if (kind === 'ddl') {
+                const parsed = parseDdl(raw, path);
+                out.tables.push(...parsed.tables);
+            }
+        }
+        catch {
+            // best-effort: skip unparseable file
+        }
+    }
+    // 稳定全局编号（避免不同文件各自 I1 冲突）
+    const merged = { interfaces: [], tables: [] };
+    let i = 0;
+    for (const it of out.interfaces)
+        merged.interfaces.push({ ...it, id: `I${++i}` });
+    let t = 0;
+    for (const tb of out.tables)
+        merged.tables.push({ ...tb, id: `T${++t}` });
+    return merged;
+}
+async function parseYamlOrJson(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        return JSON.parse(raw);
+    }
+    return yaml.load(raw);
+}

package/dist/core/{approval → document}/forbidden-patterns.d.ts

@@ -1,6 +1,8 @@
-/** Shared stub / inconsistency patterns for assemble lazy-check and approval lint. */
+/**
+ * Document Engine — anti-lazy patterns (carried over from ACP, reworked).
+ * Used by lint.ts to reject stub / lazy content in narratives and digests.
+ */
 export declare const FORBIDDEN_STUB_PATTERNS: readonly RegExp[];
-/** Semantic inconsistency hints (warnings unless strict mode) — long-document generic. */
 export declare const INCONSISTENCY_HINT_PATTERNS: readonly RegExp[];
 export declare function findForbiddenMatch(content: string): RegExp | null;
 export declare function findInconsistencyHints(content: string): readonly RegExp[];

package/dist/core/document/forbidden-patterns.js

@@ -0,0 +1,36 @@
+/**
+ * Document Engine — anti-lazy patterns (carried over from ACP, reworked).
+ * Used by lint.ts to reject stub / lazy content in narratives and digests.
+ */
+export const FORBIDDEN_STUB_PATTERNS = [
+    /\bTODO\b/i,
+    /待补充/,
+    /此处省略/,
+    // § 豁免限定在同段落（≤120 字符）内，避免跨行误报（P2）
+    /详见\s*(?:上文|下文|附件)(?![\s\S]{0,120}§)/,
+    // 「略」必须是独立占位短语，避免「策略/战略/忽略/省略」结尾误报（P2）
+    /(?:从略|暂略|略去|其余略|此处略)\s*[。.]?$/,
+    /\bTBD\b\s*[。.]?$/,
+    /(?:^|\n)\s*(?:同上|同前)\s*[。.]?\s*(?:\n|$)/,
+    /实现时(?:命名|对齐)/,
+    /(?:RPC|rpc).*暂定/,
+    /暂定\s*[`']?\w+[`']?/,
+];
+export const INCONSISTENCY_HINT_PATTERNS = [
+    // 去掉 \b（ASCII 语义在中文相邻处永不成立，P2）；靠尾部标点约束避免误伤「等级/等待/等于」
+    /等\s*[。.)]/,
+    /(?:status|状态|enum|枚举)[^.\n]{0,30}(?:等|etc)/i,
+    /(?:^|[\s，。；])同前(?!缀)/,
+    /(?:^|[\s，。；])同上(?!所述)/,
+    /待定|未定/,
+];
+export function findForbiddenMatch(content) {
+    for (const p of FORBIDDEN_STUB_PATTERNS) {
+        if (p.test(content))
+            return p;
+    }
+    return null;
+}
+export function findInconsistencyHints(content) {
+    return INCONSISTENCY_HINT_PATTERNS.filter((p) => p.test(content));
+}

package/dist/core/document/gates.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Document Engine — gate orchestration (T10.4).
+ * Runs lint → structured coverage → review check → budget → zod, collecting diagnostics.
+ */
+import { Outline, Entities, ReviewResult, ChapterComponent } from './schemas.js';
+export interface GateDiagnostic {
+    gate: string;
+    code: string;
+    severity: 'error' | 'warning';
+    message: string;
+    chapter?: string;
+}
+export interface GatesInput {
+    outline: Outline;
+    chapterNarratives: Map<string, string>;
+    chapterEntities: Map<string, Entities>;
+    chapterTokens: Map<string, number>;
+    chapterBudget: Map<string, number | undefined>;
+    entities: Entities;
+    review?: ReviewResult;
+    workRoot: string;
+    /** Chapter component library (for per-chapter gates like 架构图/时序图). */
+    library?: Map<string, ChapterComponent>;
+    /** Multi-repo synthesize repo list (from repos.json). When ≥2, every required chapter must
+     *  contain per-repo sections (`### <repo>`) — enforced in runGates for the library pipeline,
+     *  matching validateWork (Agent mode). */
+    repos?: readonly string[];
+    /** 审查篡改校验用的当前哈希快照（P2）：persist=false 时磁盘无章节，由调用方传内存哈希；
+     *  缺省时 checkReviewResult 回退读磁盘。 */
+    currentHashes?: Array<{
+        id: string;
+        sha256: string;
+    }>;
+}
+export interface GatesResult {
+    ok: boolean;
+    diagnostics: GateDiagnostic[];
+}
+export declare function runGates(input: GatesInput): Promise<GatesResult>;

package/dist/core/document/gates.js

@@ -0,0 +1,75 @@
+/**
+ * Document Engine — gate orchestration (T10.4).
+ * Runs lint → structured coverage → review check → budget → zod, collecting diagnostics.
+ */
+import { lintNarrative, checkBudget, checkDiagramPresence, checkNumericPresence, checkGoldenSignals, checkRepoSectionCoverage } from './lint.js';
+import { checkStructuredCoverage } from './coverage.js';
+import { checkReviewResult } from './review.js';
+export async function runGates(input) {
+    const diags = [];
+    // lint: narrative stub/short + budget per chapter
+    // 遍历 outline 全部章节（P2）：只遍历 chapterNarratives 会让缺失的必写章节
+    // 静默跳过全部门禁——现在缺失章节显式报 chapter_missing。
+    for (const ch of input.outline.chapters) {
+        const chId = ch.id;
+        const narrative = input.chapterNarratives.get(chId);
+        if (narrative === undefined || narrative.trim().length === 0) {
+            diags.push({ gate: 'lint', code: 'chapter_missing', severity: 'error', message: `Chapter "${chId}" has no narrative content`, chapter: chId });
+            continue;
+        }
+        for (const d of lintNarrative(chId, narrative)) {
+            diags.push({ gate: 'lint', code: d.code, severity: d.severity, message: d.message, chapter: chId });
+        }
+        // diagram-presence gates (README §1.7): Mermaid/时序图 must be present + 有文字说明
+        const gates = input.library?.get(chId)?.gates;
+        if (gates) {
+            for (const d of checkDiagramPresence(chId, narrative, gates)) {
+                diags.push({ gate: 'lint', code: d.code, severity: d.severity, message: d.message, chapter: chId });
+            }
+            // numeric-presence gates (反AI决策 #2): benchmark/research 必须含数字
+            for (const d of checkNumericPresence(chId, narrative, gates)) {
+                diags.push({ gate: 'lint', code: d.code, severity: d.severity, message: d.message, chapter: chId });
+            }
+            // ops golden-signals gates (SRE 四金信号，f1 §2.6.3)：缺一报 warning
+            for (const d of checkGoldenSignals(chId, narrative, gates)) {
+                diags.push({ gate: 'lint', code: d.code, severity: d.severity, message: d.message, chapter: chId });
+            }
+        }
+        // 预算检查：token 记录缺失时不再当作 0（P2：欠计会静默绕过 budget_exceeded），
+        // 显式报数据缺口；仅在有 token 记录时执行预算门禁。
+        const tokens = input.chapterTokens.get(chId);
+        const budget = input.chapterBudget.get(chId);
+        if (tokens === undefined) {
+            diags.push({ gate: 'budget', code: 'chapter_tokens_missing', severity: 'warning', message: `Chapter "${chId}" has no token estimate; budget check skipped`, chapter: chId });
+        }
+        else {
+            for (const b of checkBudget(chId, tokens, budget)) {
+                diags.push({ gate: 'budget', code: b.code, severity: b.severity, message: b.message, chapter: chId });
+            }
+        }
+    }
+    // Multi-repo synthesize gate (library pipeline): every non-optional chapter must have per-repo
+    // sections (`### <repo>`) when repos ≥2 — matches validateWork (Agent mode) enforcement.
+    if (input.repos && input.repos.length >= 2) {
+        const requiredById = new Map(input.outline.chapters.filter((c) => !c.optional).map((c) => [c.id, c]));
+        for (const [chId, narrative] of input.chapterNarratives) {
+            if (!requiredById.has(chId))
+                continue;
+            for (const d of checkRepoSectionCoverage(chId, narrative, input.repos)) {
+                diags.push({ gate: 'synthesize', code: d.code, severity: d.severity, message: d.message, chapter: chId });
+            }
+        }
+    }
+    // structured coverage
+    for (const d of checkStructuredCoverage(input.outline, input.chapterEntities)) {
+        diags.push({ gate: 'coverage', code: d.code, severity: d.severity, message: d.message, chapter: d.chapter });
+    }
+    // review check (semantic channel + tamper + verdict)
+    if (input.review) {
+        const r = await checkReviewResult(input.workRoot, input.review, input.outline, input.currentHashes);
+        for (const d of r.diagnostics) {
+            diags.push({ gate: 'review', code: d.code, severity: d.severity, message: d.message });
+        }
+    }
+    return { ok: diags.every((d) => d.severity !== 'error'), diagnostics: diags };
+}