@gordon.gan/specflow 1.7.0-beta → 1.8.0-alpha

package/dist/core/document/outline.js

@@ -0,0 +1,128 @@
+/**
+ * Document Engine — Pass 1 outline generation + lint + freeze (decisions 6/8/9).
+ *
+ * Generates the Outline from the global input digest + profile constraints,
+ * lints it (required/forbidden, references forward + reverse, kind consistency),
+ * then freezes to work/outline.yaml.
+ */
+import { promises as fs } from 'node:fs';
+import yaml from 'js-yaml';
+import { parseOutline } from './schemas.js';
+const DEFAULT_PROMPT = '你是文档大纲设计专家。基于全局输入摘要与场景 Profile 约束，生成结构化文档大纲。见 prompts/document/outline/general.md。';
+const OUTLINE_SYSTEM = '你是文档大纲设计专家。严格按输入要求输出 JSON 大纲，满足所有硬规则（章节约束/要点 kind/references 完整性/source_segments）。';
+// ============= Generation (T5.2) =============
+export async function generateOutline(llm, options) {
+    const { profile, inputDigest } = options;
+    const prompt = options.prompt ?? DEFAULT_PROMPT;
+    const input = {
+        system: OUTLINE_SYSTEM,
+        messages: [
+            { role: 'user', content: prompt },
+            {
+                role: 'user',
+                content: [
+                    `Profile: ${JSON.stringify(profile)}`,
+                    `全局输入摘要: ${inputDigest.summary}`,
+                    `段摘要: ${inputDigest.segments.map((s) => `[${s.id}] ${s.summary}`).join('\n')}`,
+                ].join('\n\n'),
+            },
+        ],
+    };
+    // Retry up to 2 times on parse failure.
+    let lastErr;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+            const res = await llm.complete(input);
+            const outline = parseOutline(JSON.parse(res.content));
+            return outline;
+        }
+        catch (e) {
+            lastErr = e;
+        }
+    }
+    throw new Error(`generateOutline: failed to parse outline after retries: ${lastErr}`);
+}
+// ============= Lint (T5.3) =============
+export function lintOutline(outline, profile) {
+    const diags = [];
+    // 1. Required chapters all present.
+    for (const id of profile.required) {
+        if (!outline.chapters.some((c) => c.id === id)) {
+            diags.push({ code: 'required_missing', severity: 'error', message: `Required chapter "${id}" missing from outline` });
+        }
+    }
+    // 2. Forbidden chapters absent.
+    for (const id of profile.forbidden) {
+        if (outline.chapters.some((c) => c.id === id)) {
+            diags.push({ code: 'forbidden_present', severity: 'error', chapter: id, message: `Forbidden chapter "${id}" present in outline` });
+        }
+    }
+    // 3. Duplicate chapter ids.
+    const seenCh = new Set();
+    for (const ch of outline.chapters) {
+        if (seenCh.has(ch.id))
+            diags.push({ code: 'duplicate_chapter', severity: 'error', chapter: ch.id, message: `Duplicate chapter "${ch.id}"` });
+        seenCh.add(ch.id);
+    }
+    // 4. Duplicate point ids within a chapter.
+    for (const ch of outline.chapters) {
+        const seenP = new Set();
+        for (const p of ch.points) {
+            if (seenP.has(p.id))
+                diags.push({ code: 'duplicate_point', severity: 'error', chapter: ch.id, message: `Duplicate point "${p.id}"` });
+            seenP.add(p.id);
+        }
+    }
+    const entityIds = new Set(outline.entities.map((e) => e.id));
+    // 5. References forward: point references must exist in entity registry.
+    // 6. Kind consistency: references present → kind must not be narrative; ≤3 refs per point.
+    for (const ch of outline.chapters) {
+        for (const p of ch.points) {
+            const refs = p.references ?? [];
+            if (refs.length > 3) {
+                diags.push({ code: 'too_many_references', severity: 'error', chapter: ch.id, message: `Point "${p.id}" references >3 entities` });
+            }
+            for (const ref of refs) {
+                if (!entityIds.has(ref)) {
+                    diags.push({ code: 'reference_unknown', severity: 'error', chapter: ch.id, message: `Point "${p.id}" references unknown entity "${ref}"` });
+                }
+            }
+            if (refs.length > 0 && p.kind === 'narrative') {
+                diags.push({ code: 'kind_inconsistent', severity: 'error', chapter: ch.id, message: `Point "${p.id}" has references but kind=narrative` });
+            }
+        }
+    }
+    // 7. References reverse (decision 9): every non-standalone entity must be referenced by ≥1 point.
+    const referenced = new Set();
+    for (const ch of outline.chapters) {
+        for (const p of ch.points) {
+            for (const ref of p.references ?? [])
+                referenced.add(ref);
+        }
+    }
+    for (const ent of outline.entities) {
+        if (!ent.standalone && !referenced.has(ent.id)) {
+            diags.push({ code: 'entity_unreferenced', severity: 'error', message: `Entity "${ent.id}" not referenced by any point (mark standalone to exempt)` });
+        }
+    }
+    // 8. Every chapter must have ≥1 point.
+    for (const ch of outline.chapters) {
+        if (ch.points.length === 0) {
+            diags.push({ code: 'chapter_no_points', severity: 'error', chapter: ch.id, message: `Chapter "${ch.id}" has no points` });
+        }
+    }
+    return diags;
+}
+export function outlineHasErrors(diags) {
+    return diags.some((d) => d.severity === 'error');
+}
+// ============= Freeze (T5.4/T5.5) =============
+export async function freezeOutline(workRoot, outline) {
+    const path = `${workRoot}/outline.yaml`;
+    await fs.writeFile(path, yaml.dump(outline, { noRefs: true }), 'utf-8');
+    return path;
+}
+export async function readOutline(workRoot) {
+    const raw = yaml.load(await fs.readFile(`${workRoot}/outline.yaml`, 'utf-8'));
+    return parseOutline(raw);
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Document Engine — injectable path resolution.
+ *
+ * Replaces ACP's hardcoded `specflow/changes` + `validateChangeName`. The
+ * caller supplies a `workRoot`; all artifact paths derive from it.
+ */
+export interface DocumentPaths {
+    workRoot: string;
+    outline: string;
+    entities: string;
+    chaptersDir: string;
+    segmentsDir: string;
+    digestsDir: string;
+    hashes: string;
+    reviewResult: string;
+    documentMd: string;
+    documentHtml: string;
+}
+/** Resolve all engine artifact paths under a caller-provided work root. */
+export declare function resolvePaths(workRoot: string): DocumentPaths;
+export declare function chapterPath(workRoot: string, chapterId: string): string;
+export declare function digestPath(workRoot: string, chapterId: string): string;
+export declare function segmentIndexPath(workRoot: string): string;

package/dist/core/document/paths.js

@@ -0,0 +1,31 @@
+/**
+ * Document Engine — injectable path resolution.
+ *
+ * Replaces ACP's hardcoded `specflow/changes` + `validateChangeName`. The
+ * caller supplies a `workRoot`; all artifact paths derive from it.
+ */
+import { join } from 'node:path';
+/** Resolve all engine artifact paths under a caller-provided work root. */
+export function resolvePaths(workRoot) {
+    return {
+        workRoot,
+        outline: join(workRoot, 'outline.yaml'),
+        entities: join(workRoot, 'entities.json'),
+        chaptersDir: join(workRoot, 'chapters'),
+        segmentsDir: join(workRoot, 'segments'),
+        digestsDir: join(workRoot, 'digests'),
+        hashes: join(workRoot, 'hashes.json'),
+        reviewResult: join(workRoot, 'review-result.json'),
+        documentMd: join(workRoot, 'document.md'),
+        documentHtml: join(workRoot, 'document.html'),
+    };
+}
+export function chapterPath(workRoot, chapterId) {
+    return join(workRoot, 'chapters', `${chapterId}.md`);
+}
+export function digestPath(workRoot, chapterId) {
+    return join(workRoot, 'digests', `${chapterId}.md`);
+}
+export function segmentIndexPath(workRoot) {
+    return join(workRoot, 'segments', 'index.json');
+}

package/dist/core/document/profile-validator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Document Engine — Profile static validator (decision 8 · P1-H).
+ *
+ * Validates a ScenarioProfile at load time (fail-fast) before any generation:
+ *  1. Existence     — every required/optional chapter id exists in the library
+ *  2. Required met  — required is non-empty and fully present
+ *  3. Closure       — every depends_on target is in the profile (or declared shared)
+ *  4. Acyclic       — depends_on forms a DAG (topological sort, cycle → error)
+ *  5. When-usable   — when expressions reference known input features
+ */
+import { ScenarioProfile, ChapterComponent } from './schemas.js';
+export interface ValidationDiagnostic {
+    code: string;
+    severity: 'error' | 'warning';
+    message: string;
+    chapter?: string;
+}
+export interface ProfileValidationOptions {
+    profile: ScenarioProfile;
+    library: Map<string, ChapterComponent>;
+}
+export declare function validateProfile(options: ProfileValidationOptions): ValidationDiagnostic[];
+export declare function hasErrors(diags: ValidationDiagnostic[]): boolean;

package/dist/core/document/profile-validator.js

@@ -0,0 +1,127 @@
+/**
+ * Document Engine — Profile static validator (decision 8 · P1-H).
+ *
+ * Validates a ScenarioProfile at load time (fail-fast) before any generation:
+ *  1. Existence     — every required/optional chapter id exists in the library
+ *  2. Required met  — required is non-empty and fully present
+ *  3. Closure       — every depends_on target is in the profile (or declared shared)
+ *  4. Acyclic       — depends_on forms a DAG (topological sort, cycle → error)
+ *  5. When-usable   — when expressions reference known input features
+ */
+import { isKnownFeature, parseWhen, featuresInWhen } from './input-features.js';
+export function validateProfile(options) {
+    const { profile, library } = options;
+    const diags = [];
+    const declared = new Set([
+        ...profile.required,
+        ...profile.optional_candidates,
+        ...profile.forbidden,
+        ...profile.shared,
+    ]);
+    // 1. Existence: every referenced chapter id exists in the library.
+    for (const id of declared) {
+        if (!library.has(id)) {
+            diags.push({
+                code: 'chapter_not_found',
+                severity: 'error',
+                message: `Chapter "${id}" referenced by profile "${profile.id}" does not exist in the library`,
+            });
+        }
+    }
+    // 2. Required non-empty + all present.
+    if (profile.required.length === 0) {
+        diags.push({
+            code: 'required_empty',
+            severity: 'error',
+            message: `Profile "${profile.id}" must declare at least one required chapter`,
+        });
+    }
+    // 3+4. Dependency closure + acyclic over the selected chapters.
+    //    A chapter may depend on: another selected chapter, a shared chapter, or a chapter in
+    //    required/optional that we include in the closure graph.
+    const closureNodes = new Set([...profile.required, ...profile.optional_candidates, ...profile.shared]);
+    for (const id of profile.required) {
+        const ch = library.get(id);
+        if (!ch)
+            continue;
+        for (const dep of ch.depends_on) {
+            if (!closureNodes.has(dep)) {
+                diags.push({
+                    code: 'dependency_unclosed',
+                    severity: 'error',
+                    chapter: id,
+                    message: `Chapter "${id}" depends on "${dep}" which is not in the profile's required/optional/shared set`,
+                });
+            }
+        }
+    }
+    // Acyclic check via Kahn's algorithm on selected + shared nodes.
+    const nodes = [...closureNodes].filter((n) => library.has(n));
+    const indegree = new Map();
+    const adj = new Map();
+    for (const n of nodes) {
+        indegree.set(n, 0);
+        adj.set(n, []);
+    }
+    for (const n of nodes) {
+        const ch = library.get(n);
+        for (const dep of ch.depends_on) {
+            if (closureNodes.has(dep) && library.has(dep) && dep !== n) {
+                adj.get(dep).push(n);
+                indegree.set(n, (indegree.get(n) ?? 0) + 1);
+            }
+        }
+    }
+    const queue = nodes.filter((n) => indegree.get(n) === 0);
+    const seen = new Set();
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        seen.add(cur);
+        for (const next of adj.get(cur) ?? []) {
+            indegree.set(next, (indegree.get(next) ?? 1) - 1);
+            if (indegree.get(next) === 0)
+                queue.push(next);
+        }
+    }
+    for (const n of nodes) {
+        if (!seen.has(n)) {
+            diags.push({
+                code: 'dependency_cycle',
+                severity: 'error',
+                chapter: n,
+                message: `Dependency cycle detected involving chapter "${n}"`,
+            });
+        }
+    }
+    // 5. When-usable: every when expression must parse and reference known features.
+    for (const id of [...profile.required, ...profile.optional_candidates]) {
+        const ch = library.get(id);
+        if (!ch?.when)
+            continue;
+        try {
+            parseWhen(ch.when);
+            for (const f of featuresInWhen(ch.when)) {
+                if (!isKnownFeature(f)) {
+                    diags.push({
+                        code: 'when_unknown_feature',
+                        severity: 'warning',
+                        chapter: id,
+                        message: `when expression of chapter "${id}" references unknown input feature "${f}"`,
+                    });
+                }
+            }
+        }
+        catch (e) {
+            diags.push({
+                code: 'when_invalid',
+                severity: 'error',
+                chapter: id,
+                message: `when expression of chapter "${id}" is invalid: ${e instanceof Error ? e.message : String(e)}`,
+            });
+        }
+    }
+    return diags;
+}
+export function hasErrors(diags) {
+    return diags.some((d) => d.severity === 'error');
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Document Engine — scenario profile loader + expansion.
+ * Loads templates/document/profiles/*.yaml, validates via profile-validator,
+ * and expands a profile into the concrete chapter selection given input features.
+ */
+import { ScenarioProfile } from './schemas.js';
+import { ValidationDiagnostic } from './profile-validator.js';
+import { ChapterComponent } from './schemas.js';
+export interface ExpandedProfile {
+    profile: ScenarioProfile;
+    /** Chapters in render order: required first (in order), then selected optional candidates. */
+    chapters: string[];
+    diagnostics: ValidationDiagnostic[];
+}
+export declare function loadProfile(profileId: string, dir?: string): Promise<ScenarioProfile>;
+/**
+ * Expand a profile against input features:
+ *  - required chapters always included (in declared order)
+ *  - optional candidates included when their `when` (if any) evaluates true, or when no `when`
+ *  - forbidden chapters never included
+ *  - output respects dependency order (topological) so dependents come after dependencies
+ */
+export declare function expandProfile(profile: ScenarioProfile, library: Map<string, ChapterComponent>, features: Record<string, boolean>): ExpandedProfile;

package/dist/core/document/profiles.js

@@ -0,0 +1,69 @@
+/**
+ * Document Engine — scenario profile loader + expansion.
+ * Loads templates/document/profiles/*.yaml, validates via profile-validator,
+ * and expands a profile into the concrete chapter selection given input features.
+ */
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import yaml from 'js-yaml';
+import { parseScenarioProfile } from './schemas.js';
+import { validateProfile, hasErrors } from './profile-validator.js';
+import { evaluateWhen } from './input-features.js';
+const DEFAULT_PROFILES_DIR = join(process.cwd(), 'templates', 'document', 'profiles');
+export async function loadProfile(profileId, dir = DEFAULT_PROFILES_DIR) {
+    const raw = yaml.load(await fs.readFile(join(dir, `${profileId}.yaml`), 'utf-8'));
+    return parseScenarioProfile(raw);
+}
+/**
+ * Expand a profile against input features:
+ *  - required chapters always included (in declared order)
+ *  - optional candidates included when their `when` (if any) evaluates true, or when no `when`
+ *  - forbidden chapters never included
+ *  - output respects dependency order (topological) so dependents come after dependencies
+ */
+export function expandProfile(profile, library, features) {
+    const diags = validateProfile({ profile, library });
+    if (hasErrors(diags)) {
+        return { profile, chapters: [], diagnostics: diags };
+    }
+    const selected = new Set(profile.required);
+    for (const id of profile.optional_candidates) {
+        const ch = library.get(id);
+        if (!ch)
+            continue;
+        if (ch.when && !evaluateWhen(ch.when, features))
+            continue;
+        selected.add(id);
+    }
+    for (const id of profile.forbidden)
+        selected.delete(id);
+    // Topological order over selected chapters (dependencies first).
+    const ordered = [];
+    const visited = new Set();
+    const stack = new Set();
+    const visit = (id) => {
+        if (visited.has(id))
+            return;
+        if (stack.has(id))
+            return; // cycle — validator should have caught it
+        stack.add(id);
+        const ch = library.get(id);
+        if (ch) {
+            for (const dep of ch.depends_on) {
+                if (selected.has(dep))
+                    visit(dep);
+            }
+        }
+        stack.delete(id);
+        visited.add(id);
+        if (selected.has(id))
+            ordered.push(id);
+    };
+    for (const id of profile.required)
+        visit(id);
+    for (const id of profile.optional_candidates) {
+        if (selected.has(id))
+            visit(id);
+    }
+    return { profile, chapters: ordered, diagnostics: diags };
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Document Engine — Pass 4 deterministic rendering (decisions 7/9).
+ *
+ * Renders the final document by concatenating chapters in outline order (NOT assemble):
+ * contract entities → Markdown tables/code blocks; narrative → verbatim into its chapter.
+ * Optional HTML render reuses `marked`.
+ */
+import { Outline, Entities, InterfaceEntity, TableEntity } from './schemas.js';
+export declare function renderInterface(i: InterfaceEntity): string;
+export declare function renderTable(t: TableEntity): string;
+export declare function renderEntities(entities: Entities): string;
+export interface RenderDocumentInput {
+    outline: Outline;
+    entities: Entities;
+    /** chapterId → narrative markdown */
+    narratives: Map<string, string>;
+}
+export declare function renderDocument(input: RenderDocumentInput): string;
+export declare function renderHtml(markdown: string, title?: string): Promise<string>;

package/dist/core/document/render.js

@@ -0,0 +1,97 @@
+/**
+ * Document Engine — Pass 4 deterministic rendering (decisions 7/9).
+ *
+ * Renders the final document by concatenating chapters in outline order (NOT assemble):
+ * contract entities → Markdown tables/code blocks; narrative → verbatim into its chapter.
+ * Optional HTML render reuses `marked`.
+ */
+import { marked } from 'marked';
+// ============= Contract entity → Markdown (T9.1) =============
+export function renderInterface(i) {
+    const rows = [
+        `##### ${i.id} · ${i.name}（${i.method} ${i.path}）`,
+        '',
+        '**字段表**',
+        '',
+        '| 字段 | 类型 | 必填 | 说明 |',
+        '|------|------|------|------|',
+        ...[...i.request_fields ?? [], ...i.response_fields ?? []].map((f) => `| ${f.name} | ${f.type} | ${f.required ? '是' : '否'} | ${f.desc ?? ''} |`),
+        '',
+        '**成功示例**',
+        '',
+        '```http',
+        `${i.method} ${i.path}`,
+        '```',
+        '',
+        '**失败示例**',
+        '',
+        ...i.failure_examples.map((ex) => `- ${ex}`),
+        '',
+        '**错误**',
+        '',
+        '| 条件 | 状态 | 说明 |',
+        '|------|------|------|',
+        ...i.errors.map((e) => `| ${e.condition} | ${e.status} | ${e.note ?? ''} |`),
+    ];
+    return rows.join('\n');
+}
+export function renderTable(t) {
+    return [
+        `##### ${t.id} · ${t.name}`,
+        '',
+        '```sql',
+        t.ddl,
+        '```',
+        '',
+        ...(t.migration ? ['**存量填充策略**', '', t.migration, ''] : []),
+        ...(t.rollback ? ['**回滚兼容**', '', t.rollback, ''] : []),
+    ].join('\n');
+}
+export function renderEntities(entities) {
+    const parts = [];
+    for (const i of entities.interfaces)
+        parts.push(renderInterface(i));
+    for (const t of entities.tables)
+        parts.push(renderTable(t));
+    return parts.join('\n\n');
+}
+export function renderDocument(input) {
+    const { outline, entities, narratives } = input;
+    const body = [`# 方案文档：${outline.profile}`, ''];
+    for (const ch of outline.chapters) {
+        body.push(`## ${ch.title}`, '');
+        const narrative = narratives.get(ch.id) ?? '';
+        if (narrative.trim())
+            body.push(narrative.trim(), '');
+    }
+    // Contract entities: append to the chapters that reference them (simplified: append in a
+    // final "契约" section, since entities are cross-chapter).
+    const contractMd = renderEntities(entities);
+    if (contractMd.trim()) {
+        body.push('---', '', '## 契约实体', '', contractMd, '');
+    }
+    // 产物溯源附录 (borrowed from approval · appendix A): each chapter's data source.
+    body.push('---', '', '## 附录 A: 产物溯源', '');
+    body.push('| 章节 | 数据来源 | 处理方式 |');
+    body.push('|------|---------|---------|');
+    for (const ch of outline.chapters) {
+        body.push(`| ${ch.title} | 输入素材 / 项目规约 / 大纲要点 | LLM 生成 + 引擎校验 |`);
+    }
+    body.push('', '');
+    return body.join('\n').replace(/\n{3,}/g, '\n\n').trim() + '\n';
+}
+// ============= HTML (T9.3) =============
+export async function renderHtml(markdown, title = '方案文档') {
+    const bodyHtml = await marked.parse(markdown);
+    const hasMermaid = bodyHtml.includes('class="language-mermaid"') || bodyHtml.includes('mermaid');
+    const mermaidScript = hasMermaid
+        ? '<script type="module">\nimport mermaid from "https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs";\nmermaid.initialize({ startOnLoad: true });\n</script>'
+        : '';
+    return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${title}</title>
+<style>body{max-width:920px;margin:0 auto;padding:2rem;font-family:system-ui,sans-serif;line-height:1.65}table{border-collapse:collapse;width:100%}th,td{border:1px solid #ddd;padding:.4rem}pre{background:#f6f8fa;padding:1rem;overflow-x:auto}</style>
+</head>
+<body><h1>${title}</h1><article>${bodyHtml}</article>${mermaidScript}</body></html>`;
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Document Engine — Pass 3 AI review (decision 9 · target + max_rounds + part_hashes).
+ *
+ * Fresh-context reviewer (separate from generator) produces findings with a `target`
+ * (entity|narrative|mixed). Findings apply by target; review-result is validated against
+ * part_hashes (post-review tamper detection) and max_rounds (infinite-loop guard).
+ */
+import { ReviewResult, ReviewFinding, Outline } from './schemas.js';
+import type { DocumentLLM } from './llm.js';
+export declare const AI_REVIEW_CHECKLIST: readonly ["R1 跨章命名一致", "R2 决策落地", "R3 实体↔正文", "R4 深度均衡", "R5 交叉引用稳定", "R6 图文一致", "R7 契约完整", "R8 枚举闭合", "R9 分支闭合", "R10 UI↔API 对齐", "R11 场景一致", "R12 stub 清除", "R13 结论一致", "R14 大纲要点覆盖"];
+export interface ReviewPacket {
+    schema: 'specflow.document.review-packet/v1';
+    change: string;
+    outline: Outline;
+    chapters: Map<string, string>;
+    checklist: readonly string[];
+    /** decision 8/9 · P1-B: concrete narrative/mixed points the reviewer must verify (semantic channel). */
+    semanticChecklist: Array<{
+        chapter: string;
+        pointId: string;
+        text: string;
+    }>;
+}
+export declare function buildReviewPacket(workRoot: string, change: string, outline: Outline): Promise<ReviewPacket>;
+export declare function reviewWithAgent(llm: DocumentLLM, packet: ReviewPacket, prompt?: string): Promise<ReviewResult>;
+export declare function applyFindings(workRoot: string, findings: ReviewFinding[], apply: (finding: ReviewFinding) => Promise<void>): Promise<void>;
+export declare function sha256(content: string): string;
+export declare function computePartHashes(workRoot: string, chapterIds: string[]): Promise<{
+    id: string;
+    sha256: string;
+}[]>;
+export interface ReviewCheckResult {
+    ok: boolean;
+    diagnostics: Array<{
+        code: string;
+        severity: 'error' | 'warning';
+        message: string;
+    }>;
+}
+export declare function checkReviewResult(workRoot: string, review: ReviewResult, outline: Outline): Promise<ReviewCheckResult>;
+export declare function writeReviewResult(workRoot: string, review: ReviewResult): Promise<void>;
+export declare function readReviewResult(workRoot: string): Promise<ReviewResult | null>;