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

package/dist/core/approval/index-schema.js

@@ -1,193 +0,0 @@
-import { z } from 'zod';
-const tableRefSchema = z.object({
-    id: z.string().min(1),
-    name: z.string().min(1),
-    action: z.string().min(1),
-    part: z.string().min(1),
-    repo: z.string().min(1).optional(),
-});
-const interfaceFrozenSchema = z.object({
-    rpc: z.string().min(1).optional(),
-    http_path: z.string().min(1).optional(),
-    status_enum: z.array(z.string().min(1)).optional(),
-});
-const interfaceRefSchema = z.object({
-    id: z.string().min(1),
-    short: z.string().min(1),
-    change: z.string().min(1),
-    part: z.string().min(1),
-    repo: z.string().min(1).optional(),
-    layers: z.array(z.string().min(1)).optional(),
-    pairs_with: z.string().min(1).optional(),
-    feature_slice: z.string().min(1).optional(),
-    frozen: interfaceFrozenSchema.optional(),
-});
-const pageRefSchema = z.object({
-    id: z.string().min(1),
-    route: z.string().min(1),
-    apis: z.array(z.string()).default([]),
-    part: z.string().min(1),
-    repo: z.string().min(1).optional(),
-});
-const capabilityRefSchema = z.object({
-    id: z.string().min(1),
-    part: z.string().min(1),
-});
-const outputRefSchema = z.object({
-    repo: z.string().min(1),
-    change: z.string().min(1),
-    path: z.string().min(1),
-});
-const multiRepoSchema = z
-    .object({
-    enabled: z.boolean(),
-    document_mode: z.enum(['unified', 'per_repo']).optional(),
-    primary_repo: z.string().min(1).optional(),
-    repos: z
-        .array(z.object({
-        id: z.string().min(1),
-        label: z.string().min(1),
-        role: z.enum(['platform', 'web', 'worker', 'hub', 'other']).optional(),
-        change: z.string().min(1),
-        root_hint: z.string().min(1).optional(),
-    }))
-        .min(1),
-    outputs: z
-        .object({
-        unified: outputRefSchema.optional(),
-        per_repo: z.array(outputRefSchema).optional(),
-    })
-        .optional(),
-    bundle: z
-        .object({
-        enabled: z.boolean().optional(),
-        playbook: z.string().min(1).optional(),
-        output: z.string().min(1).optional(),
-        readonly: z.boolean().optional(),
-    })
-        .optional(),
-})
-    .superRefine((value, ctx) => {
-    if (!value.enabled) {
-        return;
-    }
-    if (value.repos.length < 2) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'multi_repo.repos must have at least 2 entries when enabled',
-            path: ['repos'],
-        });
-    }
-    if (value.document_mode === 'unified' && !value.primary_repo) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'multi_repo.primary_repo is required when document_mode is unified',
-            path: ['primary_repo'],
-        });
-    }
-    if (value.primary_repo && !value.repos.some((r) => r.id === value.primary_repo)) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'multi_repo.primary_repo must match a repos[].id',
-            path: ['primary_repo'],
-        });
-    }
-    if (value.bundle?.enabled === true && !value.primary_repo) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'multi_repo.primary_repo is required when bundle.enabled is true',
-            path: ['primary_repo'],
-        });
-    }
-});
-export const approvalIndexSchema = z.object({
-    schema: z.literal('specflow.approval.index/v1'),
-    change: z.string().min(1),
-    generated_at: z.preprocess((val) => (val instanceof Date ? val.toISOString() : val), z.string().min(1)),
-    mode: z.enum(['segmented', 'monolithic']).default('segmented'),
-    ui_in_scope: z.boolean().default(false),
-    db_in_scope: z.boolean().default(false),
-    api_in_scope: z.boolean().default(false),
-    optional: z
-        .object({
-        s5: z.boolean().default(false),
-        s7: z.boolean().default(false),
-        s8: z.boolean().default(false),
-    })
-        .default({ s5: false, s7: false, s8: false }),
-    parts_order: z.array(z.string().min(1)).min(1),
-    design_points: z.array(z.string()).default([]),
-    decisions: z.array(z.string()).default([]),
-    tables: z.array(tableRefSchema).default([]),
-    interfaces: z.array(interfaceRefSchema).default([]),
-    pages: z.array(pageRefSchema).default([]),
-    capabilities: z.array(capabilityRefSchema).default([]),
-    batching: z
-        .object({
-        tables_per_call: z.number().int().positive().default(3),
-        interfaces_per_call: z.number().int().positive().default(3),
-        pages_per_call: z.number().int().positive().default(3),
-        capabilities_per_call: z.number().int().positive().default(1),
-    })
-        .default({
-        tables_per_call: 3,
-        interfaces_per_call: 3,
-        pages_per_call: 3,
-        capabilities_per_call: 1,
-    }),
-    conventions: z
-        .object({
-        architecture: z.array(z.string()).optional(),
-        database: z.array(z.string()).optional(),
-        api: z.array(z.string()).optional(),
-        frontend: z.array(z.string()).optional(),
-    })
-        .default({}),
-    meta: z
-        .object({
-        language: z.string().optional(),
-        tech_stack: z.string().optional(),
-        project_mode: z.string().optional(),
-    })
-        .optional(),
-    multi_repo: multiRepoSchema.optional(),
-    acp: z
-        .object({
-        pipeline: z.enum(['acp/v1', 'acp/v2']).optional(),
-        context_budget_tokens: z.number().int().positive().optional(),
-        output_budget_tokens: z.number().int().positive().optional(),
-        feature_slices: z
-            .array(z.object({
-            id: z.string().min(1),
-            repos: z.array(z.string()).optional(),
-            interfaces: z.array(z.string()).optional(),
-            pages: z.array(z.string()).optional(),
-            design_points: z.array(z.string()).optional(),
-            parts: z.array(z.string().min(1)).min(1),
-        }))
-            .optional(),
-        review: z
-            .object({
-            enabled: z.boolean().optional(),
-            required_pass: z.boolean().optional(),
-        })
-            .optional(),
-    })
-        .optional(),
-});
-export function parseApprovalIndex(raw) {
-    return approvalIndexSchema.parse(raw);
-}
-/** Returns true when segmented fast-path (monolithic) is allowed. */
-export function isLightweightApproval(index) {
-    return (index.tables.length <= 2 &&
-        index.interfaces.length <= 3 &&
-        index.pages.length <= 2 &&
-        !index.optional.s5);
-}
-export function shouldForceSegmented(index) {
-    if (index.mode === 'monolithic') {
-        return false;
-    }
-    return !isLightweightApproval(index);
-}

package/dist/core/approval/index.d.ts

@@ -1,12 +0,0 @@
-export type { ApprovalAssembleResult, ApprovalDiagnostic, ApprovalIndex, ApprovalManifest, ApprovalGenerationMode, ApprovalMultiRepo, ApprovalDocumentMode, ApprovalPlaybook, ApprovalBundleResult, ApprovalReviewPacket, ApprovalReviewResult, ApprovalAcpBlock, ApprovalFeatureSlice, } from './types.js';
-export { parseApprovalIndex, isLightweightApproval, shouldForceSegmented, approvalIndexSchema, } from './index-schema.js';
-export { parseApprovalPlaybook, parseApprovalReviewResult } from './playbook-schema.js';
-export { getChangeDirectory, getApprovalWorkspaceDir, getApprovalIndexPath, getApprovalManifestPath, getApprovalPartsDir, getApprovalPartPath, getApprovalOutputPath, getApprovalAnalysisPath, getApprovalReviewPacketPath, getApprovalReviewPath, getApprovalPlaybookPath, getApprovalBundleOutputPath, } from './paths.js';
-export { assembleApprovalDocument, readApprovalIndex, readApprovalManifest, } from './assemble.js';
-export { lintApprovalDocument } from './lint.js';
-export { bundleApprovalDocument, resolvePlaybookPath } from './bundle.js';
-export { generateReviewPacket, checkApprovalReview, computeReviewPartHashes } from './review-pack.js';
-export { finalizeApprovalDocument } from './pipeline.js';
-export type { FinalizeApprovalResult, FinalizeApprovalOptions, ApprovalFinalizeStage } from './pipeline.js';
-export { renderApprovalDocument, resolveApprovalRenderPaths } from './render.js';
-export type { RenderApprovalOptions, RenderApprovalResult } from './render.js';

package/dist/core/approval/index.js

@@ -1,9 +0,0 @@
-export { parseApprovalIndex, isLightweightApproval, shouldForceSegmented, approvalIndexSchema, } from './index-schema.js';
-export { parseApprovalPlaybook, parseApprovalReviewResult } from './playbook-schema.js';
-export { getChangeDirectory, getApprovalWorkspaceDir, getApprovalIndexPath, getApprovalManifestPath, getApprovalPartsDir, getApprovalPartPath, getApprovalOutputPath, getApprovalAnalysisPath, getApprovalReviewPacketPath, getApprovalReviewPath, getApprovalPlaybookPath, getApprovalBundleOutputPath, } from './paths.js';
-export { assembleApprovalDocument, readApprovalIndex, readApprovalManifest, } from './assemble.js';
-export { lintApprovalDocument } from './lint.js';
-export { bundleApprovalDocument, resolvePlaybookPath } from './bundle.js';
-export { generateReviewPacket, checkApprovalReview, computeReviewPartHashes } from './review-pack.js';
-export { finalizeApprovalDocument } from './pipeline.js';
-export { renderApprovalDocument, resolveApprovalRenderPaths } from './render.js';

package/dist/core/approval/lint.d.ts

@@ -1,10 +0,0 @@
-import type { ApprovalDiagnostic } from './types.js';
-export interface ApprovalLintOptions {
-    readonly changeDir: string;
-    readonly strict?: boolean;
-}
-export interface ApprovalLintResult {
-    readonly ok: boolean;
-    readonly diagnostics: readonly ApprovalDiagnostic[];
-}
-export declare function lintApprovalDocument(options: ApprovalLintOptions): Promise<ApprovalLintResult>;

package/dist/core/approval/lint.js

@@ -1,302 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { findForbiddenMatch, findInconsistencyHints } from './forbidden-patterns.js';
-import { readApprovalIndex } from './assemble.js';
-import { getApprovalAnalysisPath, getApprovalPartPath } from './paths.js';
-async function readPartContents(changeDir, index) {
-    const parts = new Map();
-    for (const partId of index.parts_order) {
-        try {
-            parts.set(partId, await fs.readFile(getApprovalPartPath(changeDir, partId), 'utf-8'));
-        }
-        catch {
-            // missing parts handled by assemble check
-        }
-    }
-    return parts;
-}
-function allPartsText(parts) {
-    return [...parts.values()].join('\n');
-}
-export async function lintApprovalDocument(options) {
-    const diagnostics = [];
-    const { changeDir, strict = false } = options;
-    let index;
-    try {
-        index = await readApprovalIndex(changeDir);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            ok: false,
-            diagnostics: [
-                {
-                    code: 'missing_index',
-                    severity: 'error',
-                    message: `Cannot read approval/index.yaml: ${message}`,
-                },
-            ],
-        };
-    }
-    const partContents = await readPartContents(changeDir, index);
-    const combined = allPartsText(partContents);
-    // C3: design_points referenced somewhere in parts
-    for (const point of index.design_points) {
-        const id = point.replace(/^P/, 'P');
-        const pattern = new RegExp(`\\b${escapeRegExp(id)}\\b`);
-        if (!pattern.test(combined)) {
-            diagnostics.push({
-                code: 'design_point_unreferenced',
-                severity: strict ? 'error' : 'warning',
-                message: `Design point "${id}" listed in index but not referenced in any part`,
-            });
-        }
-    }
-    // C3b: decisions referenced in parts
-    for (const decision of index.decisions) {
-        const id = decision.replace(/^D/, 'D');
-        const pattern = new RegExp(`\\b${escapeRegExp(id)}\\b`);
-        if (!pattern.test(combined)) {
-            diagnostics.push({
-                code: 'decision_unreferenced',
-                severity: strict ? 'error' : 'warning',
-                message: `Decision "${id}" listed in index but not referenced in any part`,
-            });
-        }
-    }
-    // C3c: tables / capabilities referenced in assigned parts
-    for (const table of index.tables) {
-        const partText = partContents.get(table.part) ?? '';
-        if (partText.length === 0) {
-            continue;
-        }
-        const hasRef = partText.includes(table.id) ||
-            partText.includes(table.name) ||
-            new RegExp(`\\b${escapeRegExp(table.id)}\\b`).test(partText);
-        if (!hasRef) {
-            diagnostics.push({
-                code: 'table_unreferenced',
-                severity: strict ? 'error' : 'warning',
-                message: `Table "${table.id}" (${table.name}) not referenced in part "${table.part}"`,
-                part: table.part,
-            });
-        }
-    }
-    for (const cap of index.capabilities) {
-        const partText = partContents.get(cap.part) ?? '';
-        if (partText.length === 0) {
-            continue;
-        }
-        if (!partText.includes(cap.id)) {
-            diagnostics.push({
-                code: 'capability_unreferenced',
-                severity: strict ? 'error' : 'warning',
-                message: `Capability "${cap.id}" not referenced in part "${cap.part}"`,
-                part: cap.part,
-            });
-        }
-    }
-    // C4: page apis exist as interface ids
-    const interfaceIds = new Set(index.interfaces.map((i) => i.id));
-    for (const page of index.pages) {
-        for (const apiId of page.apis) {
-            if (!interfaceIds.has(apiId)) {
-                diagnostics.push({
-                    code: 'page_api_missing',
-                    severity: 'error',
-                    message: `Page "${page.id}" references api "${apiId}" not in index.interfaces`,
-                    part: page.part,
-                });
-            }
-        }
-    }
-    // C1 + C2: frozen fields and pairs_with
-    for (const iface of index.interfaces) {
-        const frozen = iface.frozen;
-        const partText = partContents.get(iface.part) ?? '';
-        if (frozen?.rpc) {
-            const rpcShort = frozen.rpc.split('.').pop() ?? frozen.rpc;
-            if (partText.length > 0 && !partText.includes(frozen.rpc) && !partText.includes(rpcShort)) {
-                diagnostics.push({
-                    code: 'frozen_rpc_missing',
-                    severity: 'error',
-                    message: `Interface "${iface.id}" frozen.rpc "${frozen.rpc}" not found in part "${iface.part}"`,
-                    part: iface.part,
-                });
-            }
-        }
-        if (frozen?.http_path) {
-            const pathOnly = frozen.http_path.replace(/^(GET|POST|PUT|PATCH|DELETE)\s+/i, '');
-            if (partText.length > 0 && !partText.includes(pathOnly)) {
-                diagnostics.push({
-                    code: 'frozen_http_path_missing',
-                    severity: 'error',
-                    message: `Interface "${iface.id}" frozen.http_path "${frozen.http_path}" not found in part "${iface.part}"`,
-                    part: iface.part,
-                });
-            }
-        }
-        if (frozen?.status_enum && frozen.status_enum.length > 0) {
-            for (const status of frozen.status_enum) {
-                if (partText.length > 0 && !partText.includes(status)) {
-                    diagnostics.push({
-                        code: 'frozen_status_enum_missing',
-                        severity: strict ? 'error' : 'warning',
-                        message: `Interface "${iface.id}" frozen status "${status}" not mentioned in part "${iface.part}"`,
-                        part: iface.part,
-                    });
-                }
-            }
-        }
-        if (iface.pairs_with) {
-            const pair = index.interfaces.find((i) => i.id === iface.pairs_with);
-            if (!pair) {
-                diagnostics.push({
-                    code: 'pairs_with_missing',
-                    severity: 'error',
-                    message: `Interface "${iface.id}" pairs_with "${iface.pairs_with}" not in index.interfaces`,
-                    part: iface.part,
-                });
-            }
-            else if (!partContents.has(pair.part)) {
-                diagnostics.push({
-                    code: 'pairs_with_part_missing',
-                    severity: 'error',
-                    message: `Interface "${iface.id}" pairs_with part "${pair.part}" file missing`,
-                    part: iface.part,
-                });
-            }
-            else {
-                const pairText = partContents.get(pair.part) ?? '';
-                if (partText.length > 0 && !partText.includes(iface.pairs_with)) {
-                    diagnostics.push({
-                        code: 'pairs_with_unref',
-                        severity: 'warning',
-                        message: `Interface "${iface.id}" part does not cross-ref pairs_with "${iface.pairs_with}"`,
-                        part: iface.part,
-                    });
-                }
-                if (pairText.length > 0 && !pairText.includes(iface.id)) {
-                    diagnostics.push({
-                        code: 'pairs_with_unref',
-                        severity: 'warning',
-                        message: `Interface "${iface.pairs_with}" part does not cross-ref pair "${iface.id}"`,
-                        part: pair.part,
-                    });
-                }
-            }
-        }
-    }
-    // C6: feature_slices — all listed parts exist + depth parity
-    if (index.acp?.feature_slices) {
-        for (const slice of index.acp.feature_slices) {
-            const byteLengths = [];
-            for (const partId of slice.parts) {
-                const content = partContents.get(partId);
-                if (!content) {
-                    diagnostics.push({
-                        code: 'feature_slice_part_missing',
-                        severity: 'error',
-                        message: `Feature slice "${slice.id}" references missing part "${partId}"`,
-                        part: partId,
-                    });
-                }
-                else {
-                    byteLengths.push(Buffer.byteLength(content, 'utf8'));
-                }
-            }
-            if (byteLengths.length >= 2) {
-                const min = Math.min(...byteLengths);
-                const max = Math.max(...byteLengths);
-                if (min > 0 && max / min >= 8) {
-                    diagnostics.push({
-                        code: 'feature_slice_depth_imbalance',
-                        severity: strict ? 'error' : 'warning',
-                        message: `Feature slice "${slice.id}" has large depth imbalance across parts (max/min bytes ≥ 8)`,
-                    });
-                }
-            }
-        }
-    }
-    // C6b: context budget hint (acp/v2)
-    const budget = index.acp?.context_budget_tokens;
-    if (budget && budget > 0) {
-        const approxTokens = Math.ceil(combined.length / 4);
-        if (approxTokens > budget * 1.5) {
-            diagnostics.push({
-                code: 'context_budget_exceeded',
-                severity: 'warning',
-                message: `Combined parts ~${approxTokens} tokens exceed acp.context_budget_tokens (${budget}) — consider smaller Map batches`,
-            });
-        }
-    }
-    // C7: analysis.json frozen_rpc aligns with index
-    try {
-        const analysisRaw = JSON.parse(await fs.readFile(getApprovalAnalysisPath(changeDir), 'utf-8'));
-        if (analysisRaw.frozen_rpc) {
-            const rpcInterfaces = index.interfaces.filter((i) => i.frozen?.rpc);
-            if (rpcInterfaces.length > 0) {
-                const mismatch = rpcInterfaces.some((i) => i.frozen.rpc !== analysisRaw.frozen_rpc);
-                if (mismatch) {
-                    diagnostics.push({
-                        code: 'analysis_frozen_rpc_mismatch',
-                        severity: 'warning',
-                        message: `analysis.json frozen_rpc "${analysisRaw.frozen_rpc}" differs from index interface frozen.rpc values`,
-                    });
-                }
-            }
-        }
-    }
-    catch {
-        // analysis optional for lint
-    }
-    // C8: multi_repo — each repo has at least one entity or part tagged
-    if (index.multi_repo?.enabled) {
-        for (const repo of index.multi_repo.repos) {
-            const hasEntity = index.interfaces.some((i) => i.repo === repo.id) ||
-                index.pages.some((p) => p.repo === repo.id) ||
-                index.tables.some((t) => t.repo === repo.id);
-            if (!hasEntity && index.multi_repo.document_mode === 'per_repo') {
-                diagnostics.push({
-                    code: 'multi_repo_repo_unrepresented',
-                    severity: 'warning',
-                    message: `Multi-repo entry "${repo.id}" has no interfaces/pages/tables with repo tag`,
-                });
-            }
-        }
-    }
-    // C5: forbidden patterns per part
-    for (const [partId, content] of partContents) {
-        const forbidden = findForbiddenMatch(content);
-        if (forbidden) {
-            diagnostics.push({
-                code: 'forbidden_pattern',
-                severity: 'error',
-                message: `Part "${partId}": forbidden stub pattern (${forbidden.source})`,
-                part: partId,
-            });
-        }
-        for (const hint of findInconsistencyHints(content)) {
-            diagnostics.push({
-                code: 'inconsistency_hint',
-                severity: strict ? 'error' : 'warning',
-                message: `Part "${partId}": possible semantic inconsistency (${hint.source})`,
-                part: partId,
-            });
-        }
-    }
-    // C9: appendix duplication in signoff
-    const signoff = partContents.get('10-signoff') ?? '';
-    if (/附录\s*A/i.test(signoff)) {
-        diagnostics.push({
-            code: 'appendix_in_signoff',
-            severity: 'warning',
-            message: 'Part "10-signoff" contains 附录 A; assemble will skip auto-appendix — ensure no duplicate in output',
-            part: '10-signoff',
-        });
-    }
-    const hasError = diagnostics.some((d) => d.severity === 'error');
-    return { ok: !hasError, diagnostics };
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

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

@@ -1,13 +0,0 @@
-export declare function getChangeDirectory(projectRoot: string, changeName: string): string;
-export declare function getApprovalWorkspaceDir(changeDir: string): string;
-export declare function getApprovalIndexPath(changeDir: string): string;
-export declare function getApprovalManifestPath(changeDir: string): string;
-export declare function getApprovalPartsDir(changeDir: string): string;
-export declare function getApprovalPartPath(changeDir: string, partId: string): string;
-export declare function getApprovalOutputPath(changeDir: string): string;
-export declare function getApprovalAnalysisPath(changeDir: string): string;
-export declare function getApprovalReviewPacketPath(changeDir: string): string;
-export declare function getApprovalReviewPath(changeDir: string): string;
-export declare function getApprovalPlaybookPath(changeDir: string): string;
-export declare function getApprovalBundleOutputPath(changeDir: string, relativePath: string): string;
-export declare function getApprovalHtmlOutputPath(changeDir: string): string;

package/dist/core/approval/paths.js

@@ -1,43 +0,0 @@
-import { join } from 'node:path';
-import { validateChangeName } from '../../utils/change-utils.js';
-const CHANGES_REL = 'specflow/changes';
-export function getChangeDirectory(projectRoot, changeName) {
-    validateChangeName(changeName);
-    return join(projectRoot, CHANGES_REL, changeName);
-}
-export function getApprovalWorkspaceDir(changeDir) {
-    return join(changeDir, 'approval');
-}
-export function getApprovalIndexPath(changeDir) {
-    return join(getApprovalWorkspaceDir(changeDir), 'index.yaml');
-}
-export function getApprovalManifestPath(changeDir) {
-    return join(getApprovalWorkspaceDir(changeDir), 'manifest.json');
-}
-export function getApprovalPartsDir(changeDir) {
-    return join(getApprovalWorkspaceDir(changeDir), 'parts');
-}
-export function getApprovalPartPath(changeDir, partId) {
-    return join(getApprovalPartsDir(changeDir), `${partId}.md`);
-}
-export function getApprovalOutputPath(changeDir) {
-    return join(changeDir, 'approval.md');
-}
-export function getApprovalAnalysisPath(changeDir) {
-    return join(getApprovalWorkspaceDir(changeDir), 'analysis.json');
-}
-export function getApprovalReviewPacketPath(changeDir) {
-    return join(getApprovalWorkspaceDir(changeDir), 'review-packet.json');
-}
-export function getApprovalReviewPath(changeDir) {
-    return join(getApprovalWorkspaceDir(changeDir), 'review-result.json');
-}
-export function getApprovalPlaybookPath(changeDir) {
-    return join(getApprovalWorkspaceDir(changeDir), 'approval-playbook.yaml');
-}
-export function getApprovalBundleOutputPath(changeDir, relativePath) {
-    return join(changeDir, relativePath);
-}
-export function getApprovalHtmlOutputPath(changeDir) {
-    return join(changeDir, 'approval.html');
-}

package/dist/core/approval/pipeline.d.ts

@@ -1,28 +0,0 @@
-import type { ApprovalDiagnostic } from './types.js';
-export type ApprovalFinalizeStage = 'lint' | 'review-pack' | 'review-required' | 'review-check' | 'check' | 'assemble' | 'bundle' | 'done';
-export interface FinalizeApprovalOptions {
-    readonly changeDir: string;
-    readonly workspaceRoot?: string;
-    readonly strict?: boolean;
-    readonly skipReview?: boolean;
-    readonly force?: boolean;
-    readonly bundle?: boolean | 'auto';
-    readonly playbook?: string;
-    readonly dryRun?: boolean;
-    readonly validateLazy?: boolean;
-}
-export interface FinalizeApprovalResult {
-    readonly ok: boolean;
-    readonly paused?: boolean;
-    readonly stage: ApprovalFinalizeStage;
-    readonly change: string;
-    readonly outputPath?: string;
-    readonly bundlePath?: string;
-    readonly reviewPacketPath?: string;
-    readonly diagnostics: readonly ApprovalDiagnostic[];
-}
-/**
- * One-shot ACP finalize: lint → review gate → check → assemble → optional bundle.
- * When AI review is required but review-result.json is missing, pauses after review-pack.
- */
-export declare function finalizeApprovalDocument(options: FinalizeApprovalOptions): Promise<FinalizeApprovalResult>;