@birdie_moblie/open_spec 2.1.7

package/dist/core/verify.d.ts

@@ -0,0 +1,229 @@
+import { z } from 'zod';
+import type { ProjectConfig } from '../config/schema.js';
+import { requireChange } from './change.js';
+import { type ChangeState } from './types.js';
+declare const CommandRunSchema: z.ZodObject<{
+    verifyRunId: z.ZodString;
+    id: z.ZodString;
+    command: z.ZodString;
+    code: z.ZodNumber;
+    ok: z.ZodBoolean;
+    skipped: z.ZodBoolean;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    log: z.ZodOptional<z.ZodString>;
+    plugin: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        binding: z.ZodObject<{
+            use: z.ZodString;
+            kind: z.ZodEnum<{
+                hook: "hook";
+                adapter: "adapter";
+            }>;
+            operation: z.ZodEnum<{
+                preview: "preview";
+                hook: "hook";
+                read: "read";
+            }>;
+            identity: z.ZodObject<{
+                name: z.ZodString;
+                marketplace: z.ZodString;
+                resolvedSha: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            inputFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            inputDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        workerId: z.ZodOptional<z.ZodString>;
+        stepId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    context: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const EvidenceRecordSchema: z.ZodObject<{
+    verifyRunId: z.ZodString;
+    hookId: z.ZodString;
+    type: z.ZodEnum<{
+        skill: "skill";
+        file: "file";
+        check: "check";
+    }>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        skipped: "skipped";
+    }>;
+    notes: z.ZodOptional<z.ZodString>;
+    digest: z.ZodOptional<z.ZodString>;
+    plugin: z.ZodOptional<z.ZodObject<{
+        use: z.ZodString;
+        kind: z.ZodEnum<{
+            hook: "hook";
+            adapter: "adapter";
+        }>;
+        operation: z.ZodEnum<{
+            preview: "preview";
+            hook: "hook";
+            read: "read";
+        }>;
+        identity: z.ZodObject<{
+            name: z.ZodString;
+            marketplace: z.ZodString;
+            resolvedSha: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        inputFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        inputDescription: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const QaReportSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    verifyRunId: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+    }>;
+    commands: z.ZodArray<z.ZodObject<{
+        verifyRunId: z.ZodString;
+        id: z.ZodString;
+        command: z.ZodString;
+        code: z.ZodNumber;
+        ok: z.ZodBoolean;
+        skipped: z.ZodBoolean;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        log: z.ZodOptional<z.ZodString>;
+        plugin: z.ZodOptional<z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+            binding: z.ZodObject<{
+                use: z.ZodString;
+                kind: z.ZodEnum<{
+                    hook: "hook";
+                    adapter: "adapter";
+                }>;
+                operation: z.ZodEnum<{
+                    preview: "preview";
+                    hook: "hook";
+                    read: "read";
+                }>;
+                identity: z.ZodObject<{
+                    name: z.ZodString;
+                    marketplace: z.ZodString;
+                    resolvedSha: z.ZodString;
+                    digest: z.ZodString;
+                }, z.core.$strict>;
+                input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                inputFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                inputDescription: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            workerId: z.ZodOptional<z.ZodString>;
+            stepId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        context: z.ZodOptional<z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    evidences: z.ZodArray<z.ZodObject<{
+        verifyRunId: z.ZodString;
+        hookId: z.ZodString;
+        type: z.ZodEnum<{
+            skill: "skill";
+            file: "file";
+            check: "check";
+        }>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            skipped: "skipped";
+        }>;
+        notes: z.ZodOptional<z.ZodString>;
+        digest: z.ZodOptional<z.ZodString>;
+        plugin: z.ZodOptional<z.ZodObject<{
+            use: z.ZodString;
+            kind: z.ZodEnum<{
+                hook: "hook";
+                adapter: "adapter";
+            }>;
+            operation: z.ZodEnum<{
+                preview: "preview";
+                hook: "hook";
+                read: "read";
+            }>;
+            identity: z.ZodObject<{
+                name: z.ZodString;
+                marketplace: z.ZodString;
+                resolvedSha: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            inputFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            inputDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    blockingIssues: z.ZodArray<z.ZodString>;
+    changedFiles: z.ZodArray<z.ZodString>;
+    digest: z.ZodString;
+    pendingWork: z.ZodOptional<z.ZodObject<{
+        changeName: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            source: z.ZodEnum<{
+                code: "code";
+                worker: "worker";
+            }>;
+            file: z.ZodString;
+            line: z.ZodNumber;
+            text: z.ZodString;
+            marker: z.ZodOptional<z.ZodEnum<{
+                TODO: "TODO";
+                FIXME: "FIXME";
+            }>>;
+            workerId: z.ZodOptional<z.ZodString>;
+            stepId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        skippedFiles: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    visualAdvisories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            resolved: "resolved";
+        }>;
+        description: z.ZodString;
+        advisory: z.ZodOptional<z.ZodLiteral<true>>;
+        evidence: z.ZodOptional<z.ZodString>;
+        evidenceDigest: z.ZodOptional<z.ZodString>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        stepId: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type CommandRun = z.infer<typeof CommandRunSchema>;
+export type EvidenceRecord = z.infer<typeof EvidenceRecordSchema>;
+export type QaReport = z.infer<typeof QaReportSchema>;
+export declare function runVerifyCommands(projectRoot: string, changeName: string, config: ProjectConfig, changedFiles: string[]): CommandRun[];
+export declare function recordEvidence(projectRoot: string, changeName: string, input: Omit<EvidenceRecord, 'verifyRunId'>, config: ProjectConfig): EvidenceRecord;
+export declare function writeReport(projectRoot: string, changeName: string, config: ProjectConfig, extra?: {
+    commands?: CommandRun[];
+    changedFiles?: string[];
+}): {
+    status: 'passed' | 'failed';
+    report: QaReport;
+};
+export declare function loadVerifiedReport(projectRoot: string, changeName: string, verifyRunId: string): QaReport;
+export declare function renderReportMarkdown(report: QaReport): string;
+export declare function requestFix(projectRoot: string, changeName: string, reason: string): ChangeState;
+export declare function changedFilesFromState(state: ReturnType<typeof requireChange>): string[];
+export {};
+//# sourceMappingURL=verify.d.ts.map

package/dist/core/verify.js

@@ -0,0 +1,391 @@
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { savePluginEvidence, PluginEvidenceSchema, PluginBindingSchema, pluginBindingCurrent, pluginEvidenceCurrent, runPluginCommand } from '../hooks/plugin-runtime.js';
+import { operationContext } from './source-operations.js';
+import { z } from 'zod';
+import { exists, readJson, writeJson } from '../shared/fs.js';
+import { splitCommand } from '../shared/exec.js';
+import { matchPattern } from '../shared/paths.js';
+import { runLoggedCommand } from '../shared/command-log.js';
+import { AppError } from '../shared/errors.js';
+import { sha256 } from '../shared/hash.js';
+import { hookDescriptor, fileHookDigest, fileHookState, hooksFor } from '../hooks/engine.js';
+import { artifactPath, requireChange } from './change.js';
+import { appendEvent, saveState } from './state.js';
+import { NODES } from './types.js';
+import { collectPendingWork, PendingWorkSchema, reviewScopedFiles } from './todo.js';
+import { CommandContextEvidenceSchema, commandContextCurrent, prepareCommandContext } from '../hooks/command-context.js';
+import { visualAdvisories, VisualAdvisorySchema } from './worker-evidence.js';
+const StatusSchema = z.enum(['passed', 'failed', 'skipped']);
+const CommandRunSchema = z.object({
+    verifyRunId: z.string(),
+    id: z.string(),
+    command: z.string(),
+    code: z.number().int(),
+    ok: z.boolean(),
+    skipped: z.boolean(),
+    stdout: z.string(),
+    stderr: z.string(),
+    truncated: z.boolean().optional(),
+    log: z.string().optional(),
+    plugin: PluginEvidenceSchema.optional(),
+    context: CommandContextEvidenceSchema.optional(),
+}).strict();
+const EvidenceRecordSchema = z.object({
+    verifyRunId: z.string(),
+    hookId: z.string(),
+    type: z.enum(['skill', 'file', 'check']),
+    status: StatusSchema,
+    notes: z.string().optional(),
+    digest: z.string().optional(),
+    plugin: PluginBindingSchema.optional(),
+}).strict();
+const QaReportSchema = z.object({
+    version: z.literal(1),
+    verifyRunId: z.string(),
+    status: z.enum(['passed', 'failed']),
+    commands: z.array(CommandRunSchema),
+    evidences: z.array(EvidenceRecordSchema),
+    blockingIssues: z.array(z.string()),
+    changedFiles: z.array(z.string()),
+    digest: z.string(),
+    pendingWork: PendingWorkSchema.optional(),
+    visualAdvisories: z.array(VisualAdvisorySchema).optional(),
+}).strict();
+export function runVerifyCommands(projectRoot, changeName, config, changedFiles) {
+    const verifyRunId = requireActiveVerifyRun(projectRoot, changeName);
+    const scoped = reviewScopedFiles(config, changedFiles);
+    const runs = [];
+    for (const hook of hooksFor(config, 'verify').filter((item) => item.type === 'command')) {
+        const descriptor = hookDescriptor(projectRoot, hook, config);
+        if (descriptor.type !== 'command')
+            throw new AppError('hook_type_mismatch', `需要 command: ${hook.id}`);
+        const files = targetFiles(hook, scoped);
+        let run;
+        if (hook.target === 'inScopeChangedFiles' && files.length === 0) {
+            run = {
+                verifyRunId,
+                id: hook.id,
+                command: descriptor.command,
+                code: hook.allowEmpty ? 0 : 2,
+                ok: Boolean(hook.allowEmpty),
+                skipped: Boolean(hook.allowEmpty),
+                stdout: '',
+                truncated: false,
+                stderr: hook.allowEmpty ? '' : 'inScopeChangedFiles 为空且 allowEmpty 未开启',
+            };
+        }
+        else if (descriptor.plugin) {
+            const outputDir = artifactPath(projectRoot, changeName, `.opsx/verify/${verifyRunId}/${hook.id}-${randomUUID()}`);
+            const prepared = operationContext(projectRoot, changeName, descriptor.plugin, outputDir, undefined, { workerId: verifyRunId, stepId: 'verify' });
+            if (hook.target === 'inScopeChangedFiles')
+                prepared.context.input.files = files;
+            const result = runPluginCommand(projectRoot, descriptor.plugin, prepared.context, [...prepared.files, ...files]);
+            run = { verifyRunId, id: hook.id, command: descriptor.command, code: result.code, ok: result.ok, skipped: false, stdout: `完整结果: ${path.relative(projectRoot, result.stdoutPath)}`, stderr: `诊断: ${path.relative(projectRoot, result.stderrPath)}`, log: path.relative(artifactPath(projectRoot, changeName, '.'), result.stdoutPath), plugin: savePluginEvidence(projectRoot, outputDir, result.receipt) };
+        }
+        else {
+            const command = descriptor.command;
+            const { bin, args } = splitCommand(command);
+            const expanded = expandFiles(args, files);
+            const log = `.opsx/verify/${verifyRunId}/${hook.id}.log`;
+            const context = prepareCommandContext(projectRoot, changeName, path.relative(projectRoot, artifactPath(projectRoot, changeName, `.opsx/verify/${verifyRunId}/${hook.id}.context.json`)), verifyRunId, hook.id);
+            const result = runLoggedCommand(bin, expanded, projectRoot, artifactPath(projectRoot, changeName, log), undefined, context.env);
+            run = {
+                verifyRunId,
+                id: hook.id,
+                command,
+                code: result.code,
+                ok: result.ok,
+                skipped: false,
+                stdout: result.stdout,
+                stderr: result.stderr,
+                truncated: result.truncated,
+                log,
+                context: context.evidence,
+            };
+        }
+        const parsed = CommandRunSchema.parse(run);
+        runs.push(parsed);
+        writeJson(commandRunPath(projectRoot, changeName, verifyRunId, hook.id), parsed);
+    }
+    appendEvent(projectRoot, changeName, 'verify.commands', { verifyRunId, count: runs.length });
+    return runs;
+}
+export function recordEvidence(projectRoot, changeName, input, config) {
+    const verifyRunId = requireActiveVerifyRun(projectRoot, changeName);
+    const hook = hooksFor(config, 'verify').find((item) => item.id === input.hookId);
+    if (!hook)
+        throw new AppError('unknown_hook', `找不到 hook: ${input.hookId}`);
+    if (hook.type === 'command')
+        throw new AppError('command_evidence_managed', 'command evidence 由 verify commands 生成');
+    if (hook.type !== input.type) {
+        throw new AppError('hook_type_mismatch', `hook ${hook.id} 的类型是 ${String(hook.type)}，不是 ${input.type}`);
+    }
+    const record = { ...input, verifyRunId };
+    if (hook.use)
+        record.plugin = hookDescriptor(projectRoot, hook, config).plugin;
+    if (hook.type === 'file') {
+        const digest = fileHookDigest(projectRoot, hook);
+        if (!digest && input.status === 'passed') {
+            throw new AppError('hook_file_missing', `file hook 文件不存在，不能记录 passed: ${hook.path ?? hook.id}`);
+        }
+        if (input.status === 'passed' && hook.path && fileHookState(projectRoot, hook.path) === 'unfilled') {
+            throw new AppError('hook_file_unfilled', `file hook 仍是未填写的模板（含 openspec:fill-me 标记），不能记录 passed: ${hook.path}`);
+        }
+        if (digest)
+            record.digest = digest;
+    }
+    const parsed = EvidenceRecordSchema.parse(record);
+    writeJson(evidencePath(projectRoot, changeName, verifyRunId, hook.id), parsed);
+    appendEvent(projectRoot, changeName, 'verify.evidence', { verifyRunId, hookId: hook.id, type: hook.type });
+    return parsed;
+}
+export function writeReport(projectRoot, changeName, config, extra) {
+    const verifyRunId = requireActiveVerifyRun(projectRoot, changeName);
+    const commands = validateCommandRuns(extra?.commands ?? loadCommandRuns(projectRoot, changeName, verifyRunId, config), verifyRunId, config);
+    const evidences = loadEvidences(projectRoot, changeName, verifyRunId, config);
+    const blocking = [];
+    const failOnHook = config.verify?.failurePolicy?.failOnHookFailure ?? true;
+    const failOnCmd = config.verify?.failurePolicy?.failOnRequiredCommandFailure ?? true;
+    for (const hook of hooksFor(config, 'verify')) {
+        // TODO 清单是信息回执，不受严格 failurePolicy 提升为阻塞。
+        if (hook.type === 'check' && hook.category === 'todo' && hook.required === false)
+            continue;
+        if (hook.type === 'command') {
+            const descriptor = hookDescriptor(projectRoot, hook, config);
+            if (descriptor.type !== 'command')
+                throw new AppError('hook_type_mismatch', `需要 command: ${hook.id}`);
+            const run = commands.find((item) => item.id === hook.id && item.verifyRunId === verifyRunId);
+            if (!run) {
+                if (hook.required || failOnCmd)
+                    blocking.push(`missing:${hook.id}`);
+            }
+            else if (hook.use && run.skipped && run.ok && hook.allowEmpty && hook.target === 'inScopeChangedFiles'
+                && targetFiles(hook, reviewScopedFiles(config, extra?.changedFiles ?? requireChange(projectRoot, changeName).engineChangedFiles)).length === 0
+                && run.command === descriptor.command) {
+                continue; // Explicit empty scope is not an applicable command execution.
+            }
+            else if (hook.use && (!run.plugin || run.plugin.workerId !== verifyRunId || run.plugin.stepId !== 'verify' || JSON.stringify(run.plugin.binding) !== JSON.stringify(hookDescriptor(projectRoot, hook, config).plugin) || !pluginEvidenceCurrent(projectRoot, run.plugin))) {
+                if (hook.required !== false || failOnCmd)
+                    blocking.push(`stale:${hook.id}`);
+            }
+            else if (run.context && !commandContextCurrent(projectRoot, run.context)) {
+                if (hook.required !== false || failOnCmd)
+                    blocking.push(`stale:${hook.id}`);
+            }
+            else if (!run.ok && (hook.required || failOnCmd)) {
+                blocking.push(`command:${hook.id}`);
+            }
+            continue;
+        }
+        const evidence = evidences.find((item) => item.hookId === hook.id && item.verifyRunId === verifyRunId);
+        if (!evidence) {
+            if (hook.required || failOnHook)
+                blocking.push(`missing:${hook.id}`);
+            continue;
+        }
+        const blocks = Boolean(hook.required || failOnHook);
+        if (hook.use && (!evidence.plugin || !pluginBindingCurrent(projectRoot, evidence.plugin)
+            || JSON.stringify(evidence.plugin) !== JSON.stringify(hookDescriptor(projectRoot, hook, config).plugin))) {
+            if (blocks)
+                blocking.push(`stale:${hook.id}`);
+            continue;
+        }
+        if (evidence.type !== hook.type) {
+            if (blocks)
+                blocking.push(`invalid:${hook.id}`);
+            continue;
+        }
+        if (hook.type === 'file') {
+            const currentDigest = fileHookDigest(projectRoot, hook);
+            if (!currentDigest || evidence.digest !== currentDigest) {
+                if (blocks)
+                    blocking.push(`file:${hook.id}`);
+                continue;
+            }
+        }
+        if (evidence.status !== 'passed' && blocks)
+            blocking.push(`hook:${hook.id}`);
+    }
+    const reportWithoutDigest = QaReportSchema.omit({ digest: true }).parse({
+        version: 1,
+        verifyRunId,
+        status: blocking.length > 0 ? 'failed' : 'passed',
+        commands,
+        evidences,
+        blockingIssues: blocking,
+        changedFiles: reviewScopedFiles(config, extra?.changedFiles ?? requireChange(projectRoot, changeName).engineChangedFiles),
+        pendingWork: collectPendingWork(projectRoot, changeName, config),
+        visualAdvisories: visualAdvisories(projectRoot, changeName),
+    });
+    const report = QaReportSchema.parse({
+        ...reportWithoutDigest,
+        digest: sha256(JSON.stringify(reportWithoutDigest)),
+    });
+    writeJson(reportPath(projectRoot, changeName, verifyRunId), report);
+    writeJson(artifactPath(projectRoot, changeName, 'reports/qa-report.json'), report);
+    appendEvent(projectRoot, changeName, 'verify.report', { verifyRunId, status: report.status, digest: report.digest });
+    return { status: report.status, report };
+}
+export function loadVerifiedReport(projectRoot, changeName, verifyRunId) {
+    const file = reportPath(projectRoot, changeName, verifyRunId);
+    if (!exists(file))
+        throw new AppError('qa_report_missing', `缺少当前 verify run 的 QA report: ${verifyRunId}`);
+    const parsed = QaReportSchema.safeParse(readJson(file));
+    if (!parsed.success)
+        throw new AppError('invalid_qa_report', 'QA report 不合法', parsed.error.issues);
+    const { digest, ...withoutDigest } = parsed.data;
+    if (sha256(JSON.stringify(withoutDigest)) !== digest)
+        throw new AppError('qa_report_digest_mismatch', 'QA report digest 不匹配');
+    if (parsed.data.verifyRunId !== verifyRunId)
+        throw new AppError('qa_report_run_mismatch', 'QA report 不属于当前 verify run');
+    for (const run of parsed.data.commands) {
+        if (run.context && !commandContextCurrent(projectRoot, run.context))
+            throw new AppError('command_evidence_stale', `命令上下文已变化: ${run.id}`);
+        if (run.plugin && (run.plugin.workerId !== verifyRunId || !pluginEvidenceCurrent(projectRoot, run.plugin)))
+            throw new AppError('command_evidence_stale', `插件验证回执已变化: ${run.id}`);
+    }
+    for (const evidence of parsed.data.evidences) {
+        if (evidence.plugin && !pluginBindingCurrent(projectRoot, evidence.plugin))
+            throw new AppError('hook_evidence_stale', `插件技能回执已变化: ${evidence.hookId}`);
+    }
+    return parsed.data;
+}
+export function renderReportMarkdown(report) {
+    const lines = [
+        '# QA Report',
+        '',
+        `Run: ${report.verifyRunId}`,
+        `状态: ${report.status}`,
+        '',
+        '## Commands',
+        ...report.commands.map((run) => `- ${run.id}: ${run.skipped ? 'skipped' : run.ok ? 'ok' : `fail (${run.code})`}`),
+        '',
+        '## Evidence',
+        ...report.evidences.map((item) => `- ${item.hookId} (${item.type}): ${item.status}`),
+    ];
+    if (report.blockingIssues.length > 0) {
+        lines.push('', '## Blocking', ...report.blockingIssues.map((item) => `- ${item}`));
+    }
+    if (report.visualAdvisories?.length) {
+        lines.push('', '## 未修复的视觉偏差（已披露，不代表完全还原）', ...report.visualAdvisories.map(item => `- ${item.stepId} / ${item.id}: ${item.description}；证据: ${item.evidence}`));
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function requestFix(projectRoot, changeName, reason) {
+    const state = requireChange(projectRoot, changeName);
+    if (state.node !== NODES.VERIFY || state.lastIssue?.type !== 'worker_failed' || !state.lastIssue.fixable) {
+        throw new AppError('fix_not_allowed', '当前不在可修复的验证失败状态');
+    }
+    if (!state.verifyRunId)
+        throw new AppError('verify_run_missing', '验证失败状态缺少 verify run');
+    state.repair = {
+        sourceVerifyRunId: state.verifyRunId,
+        requestedAt: new Date().toISOString(),
+        reason,
+    };
+    state.node = NODES.CODE;
+    state.lastIssue = null;
+    state.activeWorker = null;
+    saveState(projectRoot, state);
+    appendEvent(projectRoot, changeName, 'verify.fix_requested', { reason, verifyRunId: state.verifyRunId });
+    return state;
+}
+function targetFiles(hook, changedFiles) {
+    if (hook.target !== 'inScopeChangedFiles')
+        return [];
+    return changedFiles.filter((file) => {
+        if (hook.include && hook.include.length > 0 && !hook.include.some((pattern) => matchPattern(file, pattern)))
+            return false;
+        if (hook.exclude?.some((pattern) => matchPattern(file, pattern)))
+            return false;
+        return true;
+    });
+}
+function expandFiles(args, files) {
+    const expanded = [];
+    for (const arg of args) {
+        if (arg === '{files}') {
+            expanded.push(...files);
+            continue;
+        }
+        if (arg.includes('{files}'))
+            throw new AppError('invalid_files_placeholder', '{files} 必须是独立 command 参数');
+        expanded.push(arg);
+    }
+    return expanded;
+}
+function requireActiveVerifyRun(projectRoot, changeName) {
+    const state = requireChange(projectRoot, changeName);
+    if (state.node !== NODES.VERIFY || state.activeWorker?.stepId !== 'verify' || !state.verifyRunId) {
+        throw new AppError('verify_run_inactive', '请先创建当前 verify Worker');
+    }
+    if (state.activeWorker.workerId !== state.verifyRunId)
+        throw new AppError('verify_run_mismatch', 'active Worker 与 verify run 不一致');
+    return state.verifyRunId;
+}
+function verifyRoot(projectRoot, changeName, verifyRunId) {
+    return artifactPath(projectRoot, changeName, `.opsx/verify/${verifyRunId}`);
+}
+function commandRunPath(projectRoot, changeName, verifyRunId, hookId) {
+    return path.join(verifyRoot(projectRoot, changeName, verifyRunId), 'commands', `${hookId}.json`);
+}
+function evidencePath(projectRoot, changeName, verifyRunId, hookId) {
+    return path.join(verifyRoot(projectRoot, changeName, verifyRunId), 'evidence', `${hookId}.json`);
+}
+function reportPath(projectRoot, changeName, verifyRunId) {
+    return path.join(verifyRoot(projectRoot, changeName, verifyRunId), 'qa-report.json');
+}
+function loadCommandRuns(projectRoot, changeName, verifyRunId, config) {
+    const runs = [];
+    for (const hook of hooksFor(config, 'verify').filter((item) => item.type === 'command')) {
+        const file = commandRunPath(projectRoot, changeName, verifyRunId, hook.id);
+        if (!exists(file))
+            continue;
+        const parsed = CommandRunSchema.safeParse(readJson(file));
+        if (!parsed.success)
+            throw new AppError('invalid_command_evidence', `command evidence 不合法: ${hook.id}`, parsed.error.issues);
+        if (parsed.data.verifyRunId !== verifyRunId || parsed.data.id !== hook.id) {
+            throw new AppError('invalid_command_evidence', `command evidence 与当前 run/hook 不匹配: ${hook.id}`);
+        }
+        runs.push(parsed.data);
+    }
+    return runs;
+}
+function loadEvidences(projectRoot, changeName, verifyRunId, config) {
+    const records = [];
+    for (const hook of hooksFor(config, 'verify')) {
+        if (hook.type === 'command')
+            continue;
+        const file = evidencePath(projectRoot, changeName, verifyRunId, hook.id);
+        if (!exists(file))
+            continue;
+        const parsed = EvidenceRecordSchema.safeParse(readJson(file));
+        if (!parsed.success)
+            throw new AppError('invalid_hook_evidence', `hook evidence 不合法: ${hook.id}`, parsed.error.issues);
+        if (parsed.data.verifyRunId !== verifyRunId || parsed.data.hookId !== hook.id || parsed.data.type !== hook.type) {
+            throw new AppError('invalid_hook_evidence', `hook evidence 与当前 run/hook 不匹配: ${hook.id}`);
+        }
+        records.push(parsed.data);
+    }
+    return records;
+}
+function validateCommandRuns(runs, verifyRunId, config) {
+    const known = new Set(hooksFor(config, 'verify').filter((hook) => hook.type === 'command').map((hook) => hook.id));
+    const seen = new Set();
+    return runs.map((input) => {
+        const run = CommandRunSchema.parse(input);
+        if (run.verifyRunId !== verifyRunId)
+            throw new AppError('command_run_mismatch', `command run 不属于当前 verify: ${run.id}`);
+        if (!known.has(run.id))
+            throw new AppError('unknown_command_run', `未知 command run: ${run.id}`);
+        if (seen.has(run.id))
+            throw new AppError('duplicate_command_run', `重复 command run: ${run.id}`);
+        seen.add(run.id);
+        return run;
+    });
+}
+export function changedFilesFromState(state) {
+    return [...new Set(state.engineChangedFiles)].sort();
+}
+//# sourceMappingURL=verify.js.map