mocode-ai 0.7.1 → 0.7.3

package/dist/verification/discovery.js

@@ -1,7 +1,8 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { discoverProjectProfile } from './profile.js';
-const SCRIPT_PRIORITY = ['typecheck', 'test', 'build'];
+const COMPATIBILITY_PRIORITY = ['typecheck', 'test', 'build'];
+const LAYERED_ORDER = ['typecheck', 'build', 'test'];
 const isWindows = process.platform === 'win32';
 function samePath(left, right) {
     const normalizedLeft = path.resolve(left);
@@ -10,11 +11,7 @@ function samePath(left, right) {
         ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
         : normalizedLeft === normalizedRight;
 }
-/** Discover one lowest-cost validation command for a package in a project profile. */
-export function discoverPackageValidationCommand(profile, packageProfile) {
-    const script = SCRIPT_PRIORITY.find((name) => typeof packageProfile.scripts[name] === 'string');
-    if (!script)
-        return null;
+function commandFor(profile, packageProfile, script) {
     return {
         script,
         command: `${profile.packageManager} run ${script}`,
@@ -22,6 +19,17 @@ export function discoverPackageValidationCommand(profile, packageProfile) {
         cwd: packageProfile.root,
     };
 }
+/** Discover every available V3 command in increasing-cost order. */
+export function discoverPackageValidationCommands(profile, packageProfile) {
+    return LAYERED_ORDER
+        .filter((script) => typeof packageProfile.scripts[script] === 'string')
+        .map((script) => commandFor(profile, packageProfile, script));
+}
+/** Compatibility API retained for callers that intentionally want one command. */
+export function discoverPackageValidationCommand(profile, packageProfile) {
+    const script = COMPATIBILITY_PRIORITY.find((name) => typeof packageProfile.scripts[name] === 'string');
+    return script ? commandFor(profile, packageProfile, script) : null;
+}
 /** Compatibility wrapper that discovers the root package validation command. */
 export function discoverValidationCommand(root) {
     const resolvedRoot = path.resolve(root);

package/dist/verification/fingerprint.js

@@ -0,0 +1,54 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function normalizeText(value, root) {
+    const normalizedRoot = path.resolve(root).replace(/\\/g, '/');
+    return value
+        .replace(/\u001b\[[0-9;]*m/g, '')
+        .replace(/\\/g, '/')
+        .replaceAll(normalizedRoot, '<root>')
+        .replace(/\r\n?/g, '\n')
+        .trim();
+}
+/** Fingerprint the relevant on-disk inputs, so rewriting identical content can reuse validation. */
+export function fingerprintFiles(root, files) {
+    const entries = [...new Set(files)].sort().map((file) => {
+        const absolute = path.resolve(process.cwd(), file);
+        const display = path.relative(root, absolute).replace(/\\/g, '/');
+        try {
+            const stat = statSync(absolute);
+            if (!stat.isFile())
+                return `${display}\0<${stat.isDirectory() ? 'directory' : 'other'}>`;
+            return `${display}\0${sha256(readFileSync(absolute))}`;
+        }
+        catch {
+            return `${display}\0<missing>`;
+        }
+    });
+    return sha256(entries.join('\n'));
+}
+export function fingerprintValidation(input) {
+    const diagnostics = [...input.diagnostics]
+        .map((item) => ({
+        source: item.source,
+        severity: item.severity,
+        code: item.code ?? '',
+        file: item.file ? normalizeText(item.file, input.root) : '',
+        line: item.line ?? 0,
+        column: item.column ?? 0,
+        message: normalizeText(item.message, input.root),
+        packageName: item.packageName ?? '',
+    }))
+        .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    return sha256(JSON.stringify({
+        level: input.level ?? '',
+        status: input.status,
+        adapter: input.adapter ?? '',
+        command: input.command ? normalizeText(input.command, input.root) : '',
+        diagnostics,
+        output: diagnostics.length === 0 ? normalizeText(input.output ?? '', input.root) : '',
+    }));
+}

package/dist/verification/index.js

@@ -4,10 +4,14 @@ import { checkPermission } from '../permissions/index.js';
 import { beginWorkspaceMutation, endWorkspaceMutation, getCurrentTurnMutationState, } from '../rollback/index.js';
 import { formatCommandResult, runCommandRaw, runCommandTool, } from '../tools/builtins/run-command.js';
 import { resolveAffectedPackages } from './affected.js';
-import { discoverPackageValidationCommand } from './discovery.js';
+import { discoverPackageValidationCommands } from './discovery.js';
+import { runChangedFileDiagnostics } from './diagnostics.js';
+import { fingerprintFiles, fingerprintValidation } from './fingerprint.js';
+import { runFilePostconditions } from './postconditions.js';
 import { discoverProjectProfile } from './profile.js';
+import { discoverTargetedTestCommands } from './targeted-tests.js';
 export { resolveAffectedPackages } from './affected.js';
-export { discoverPackageValidationCommand, discoverValidationCommand } from './discovery.js';
+export { discoverPackageValidationCommand, discoverPackageValidationCommands, discoverValidationCommand, } from './discovery.js';
 export { clearProjectProfileCache, discoverProjectProfile } from './profile.js';
 const NON_CODE_EXTENSIONS = new Set([
     '.md', '.mdx', '.txt', '.rst', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp',
@@ -16,14 +20,14 @@ function isNonCodePath(file) {
     return NON_CODE_EXTENSIONS.has(path.extname(file).toLowerCase());
 }
 function affectedSummary(affected) {
-    return affected.packages.map((item) => ({
+    return affected?.packages.map((item) => ({
         name: item.package.name,
         root: item.package.root,
         reasons: item.reasons,
-    }));
+    })) ?? [];
 }
 function selectionOutput(affected) {
-    if (affected.packages.length === 0)
+    if (!affected || affected.packages.length === 0)
         return '';
     return [
         'Affected packages:',
@@ -33,131 +37,297 @@ function selectionOutput(affected) {
         }),
     ].join('\n');
 }
-function skipped(reason, patch = {}) {
+function stageOutput(stage) {
+    const scope = stage.packageName ? ` ${stage.packageName}` : '';
+    return `[${stage.level}${scope}] ${stage.status} (${stage.adapter})${stage.output ? `\n${stage.output}` : ''}`;
+}
+function highestLevel(stages) {
+    return stages.at(-1)?.level;
+}
+function aggregate(options) {
     const state = getCurrentTurnMutationState();
+    const diagnostics = options.stages.flatMap((stage) => stage.diagnostics);
+    const terminal = options.stages.find((stage) => stage.status === 'failed' || stage.status === 'aborted');
+    const blockingSkip = options.stages.find((stage) => stage.status === 'skipped' && [
+        'permission_denied', 'no_validation_script', 'no_package_json',
+        'no_affected_package', 'invalid_changed_path',
+    ].includes(stage.skipReason ?? ''));
+    const v3Passed = options.stages.some((stage) => stage.level === 'V3' && stage.status === 'passed');
+    const substantivePassed = options.stages.some((stage) => stage.level !== 'V0' && stage.status === 'passed');
+    const status = terminal?.status ?? (blockingSkip || !substantivePassed ? 'skipped' : 'passed');
+    const level = terminal?.level ?? highestLevel(options.stages);
+    const output = [selectionOutput(options.affected), ...options.stages.map(stageOutput)].filter(Boolean).join('\n\n');
+    const commands = options.stages.flatMap((stage) => stage.command ? [stage.command] : []);
+    const skipReason = options.skipReason
+        ?? blockingSkip?.skipReason
+        ?? (status === 'skipped' ? 'no_applicable_validator' : undefined);
+    const fingerprint = fingerprintValidation({
+        root: options.root,
+        level,
+        status,
+        adapter: terminal?.adapter,
+        command: commands.join(' | '),
+        diagnostics,
+        output,
+    });
+    return {
+        status,
+        level,
+        script: commands.length === 1 ? options.packageResults?.[0]?.script : undefined,
+        command: commands.length > 0 ? commands.join(' | ') : undefined,
+        exitCode: terminal?.exitCode,
+        output,
+        durationMs: options.stages.reduce((sum, stage) => sum + stage.durationMs, 0),
+        skipReason,
+        diagnostics,
+        stages: options.stages,
+        verificationComplete: status === 'passed' && v3Passed && !blockingSkip,
+        fingerprint,
+        inputFingerprint: options.inputFingerprint,
+        inputMutationVersion: options.inputMutationVersion,
+        affectedPackages: affectedSummary(options.affected),
+        rejectedChangedFiles: options.affected?.rejected,
+        packageResults: options.packageResults,
+        changedFiles: state.changedFiles.map((item) => item.path),
+        mutationVersion: state.version,
+    };
+}
+function emptyResult(root, reason, inputMutationVersion, changedFiles) {
+    const inputFingerprint = fingerprintFiles(root, changedFiles);
+    return aggregate({ root, inputMutationVersion, inputFingerprint, stages: [], skipReason: reason });
+}
+function skippedStage(level, adapter, reason, output, inputFingerprint, packageName) {
     return {
+        level,
         status: 'skipped',
-        output: '',
+        adapter,
+        packageName,
+        diagnostics: [],
+        output,
         durationMs: 0,
         skipReason: reason,
-        changedFiles: state.changedFiles.map((item) => item.path),
-        mutationVersion: state.version,
-        ...patch,
+        inputFingerprint,
+    };
+}
+function commandSource(command) {
+    return command.script;
+}
+async function executeSelectedCommand(item, root, inputFingerprint, signal, callbacks) {
+    const relativeCwd = path.relative(root, item.command.cwd) || '.';
+    const permissionArgs = { command: item.command.command, path: relativeCwd };
+    const permission = await checkPermission(runCommandTool, permissionArgs, signal, { projectRoot: root });
+    callbacks.onPermissionDecision?.({
+        decision: permission,
+        tool: runCommandTool.name,
+        arguments: permissionArgs,
+    });
+    if (signal?.aborted) {
+        return {
+            stage: {
+                level: item.level, status: 'aborted', adapter: item.adapter,
+                packageName: item.affected.package.name, command: item.command.command,
+                diagnostics: [], output: 'Validation aborted.', durationMs: 0, inputFingerprint,
+            },
+        };
+    }
+    if (permission === 'deny') {
+        return {
+            stage: skippedStage(item.level, item.adapter, 'permission_denied', 'Validation command permission was denied.', inputFingerprint, item.affected.package.name),
+        };
+    }
+    callbacks.onCommandStart?.(`[${item.level} ${item.affected.package.name}] ${item.command.command}`);
+    const capture = beginWorkspaceMutation();
+    let raw;
+    try {
+        raw = await runCommandRaw(item.command.command, 120000, signal, item.command.cwd);
+    }
+    finally {
+        endWorkspaceMutation(capture, 'automatic_validation');
+    }
+    const status = raw.status === 'passed' ? 'passed' : raw.status === 'aborted' ? 'aborted' : 'failed';
+    const output = formatCommandResult(raw);
+    const diagnostics = status === 'failed'
+        ? [{
+                level: item.level,
+                source: commandSource(item.command),
+                severity: 'error',
+                code: raw.status.toUpperCase(),
+                packageName: item.affected.package.name,
+                message: output,
+            }]
+        : [];
+    const stage = {
+        level: item.level,
+        status,
+        adapter: item.adapter,
+        packageName: item.affected.package.name,
+        command: item.command.command,
+        exitCode: raw.exitCode,
+        diagnostics,
+        output,
+        durationMs: raw.durationMs,
+        inputFingerprint,
+    };
+    stage.fingerprint = fingerprintValidation({
+        root,
+        level: stage.level,
+        status: stage.status,
+        adapter: stage.adapter,
+        command: stage.command,
+        diagnostics,
+        output,
+    });
+    return {
+        stage,
+        packageResult: {
+            packageName: item.affected.package.name,
+            packageRoot: item.affected.package.root,
+            level: item.level,
+            status,
+            script: item.command.script,
+            command: item.command.command,
+            exitCode: raw.exitCode,
+            output,
+            durationMs: raw.durationMs,
+        },
     };
 }
-function commandSummary(selected) {
-    return selected.map((item) => `${item.affected.package.name}: ${item.command.command}`).join(' | ');
+async function runCommands(selected, root, inputFingerprint, signal, callbacks, stages, packageResults) {
+    for (const item of selected) {
+        const result = await executeSelectedCommand(item, root, inputFingerprint, signal, callbacks);
+        stages.push(result.stage);
+        if (result.packageResult)
+            packageResults.push(result.packageResult);
+        if (result.stage.status !== 'passed')
+            return false;
+    }
+    return true;
+}
+function resolveProfile(root, validationPaths) {
+    try {
+        const profile = discoverProjectProfile(root);
+        return {
+            profile,
+            affected: resolveAffectedPackages(profile, validationPaths, { changedFilesBase: process.cwd() }),
+        };
+    }
+    catch {
+        return {};
+    }
 }
-/** Run the lowest-cost validation command for each package affected by this turn's code changes. */
+/** Run V0→V3 in cost order and stop at the first actionable failure. */
 export async function runAutomaticValidation(signal, callbacks = {}) {
     const before = getCurrentTurnMutationState();
+    const root = path.resolve(getSandboxRoot() ?? process.cwd());
     const changedPaths = before.changedFiles.map((item) => item.path);
     if (changedPaths.length === 0)
-        return skipped('no_changes');
+        return emptyResult(root, 'no_changes', before.version, changedPaths);
     const validationPaths = changedPaths.filter((item) => !isNonCodePath(item));
-    if (validationPaths.length === 0)
-        return skipped('non_code_changes');
-    const root = path.resolve(getSandboxRoot() ?? process.cwd());
-    let affected;
-    let selected;
-    try {
-        const profile = discoverProjectProfile(root);
-        affected = resolveAffectedPackages(profile, validationPaths, { changedFilesBase: process.cwd() });
-        selected = affected.packages.flatMap((item) => {
-            const command = discoverPackageValidationCommand(profile, item.package);
-            return command ? [{ affected: item, command }] : [];
-        });
+    if (validationPaths.length === 0) {
+        return emptyResult(root, 'non_code_changes', before.version, changedPaths);
     }
-    catch {
-        return skipped('no_validation_script');
+    const inputFingerprint = fingerprintFiles(root, validationPaths);
+    const { profile, affected } = resolveProfile(root, validationPaths);
+    const stages = [];
+    const packageResults = [];
+    const finish = (skipReason) => aggregate({
+        root,
+        inputMutationVersion: before.version,
+        inputFingerprint,
+        stages,
+        affected,
+        packageResults,
+        skipReason,
+    });
+    const v0 = await runFilePostconditions(root, validationPaths, inputFingerprint);
+    stages.push(v0);
+    if (v0.status === 'failed')
+        return finish();
+    const v1 = await runChangedFileDiagnostics(root, validationPaths, inputFingerprint);
+    stages.push(v1);
+    if (v1.status === 'failed')
+        return finish();
+    if (!profile || !affected) {
+        stages.push(skippedStage('V3', 'package-scripts', 'no_package_json', 'No project package profile is available.', inputFingerprint));
+        return finish('no_package_json');
     }
-    const summary = affectedSummary(affected);
-    const selectedOutput = selectionOutput(affected);
     if (affected.rejected.length > 0) {
-        return skipped('invalid_changed_path', {
-            output: [
-                selectedOutput,
-                ...affected.rejected.map((item) => `Rejected changed path: ${item.input} (${item.reason})`),
-            ].filter(Boolean).join('\n'),
-            affectedPackages: summary,
-            rejectedChangedFiles: affected.rejected,
-        });
+        stages.push(skippedStage('V3', 'affected-packages', 'invalid_changed_path', affected.rejected.map((item) => `Rejected changed path: ${item.input} (${item.reason})`).join('\n'), inputFingerprint));
+        return finish('invalid_changed_path');
     }
     if (affected.packages.length === 0) {
-        return skipped('no_affected_package', { output: selectedOutput, affectedPackages: summary });
+        stages.push(skippedStage('V3', 'affected-packages', 'no_affected_package', 'No package owns the changed files.', inputFingerprint));
+        return finish('no_affected_package');
+    }
+    const targeted = discoverTargetedTestCommands(profile, affected.packages).map((item) => ({
+        affected: item.affected,
+        command: item.command,
+        level: 'V2',
+        adapter: item.adapter,
+    }));
+    if (targeted.length === 0) {
+        stages.push(skippedStage('V2', 'targeted-tests', 'no_targeted_tests', 'No reliable targeted tests were found.', inputFingerprint));
     }
-    if (selected.length === 0) {
-        return skipped('no_validation_script', { output: selectedOutput, affectedPackages: summary });
+    else if (!await runCommands(targeted, root, inputFingerprint, signal, callbacks, stages, packageResults)) {
+        return finish(stages.at(-1)?.skipReason === 'permission_denied' ? 'permission_denied' : undefined);
     }
-    const commands = commandSummary(selected);
-    for (const item of selected) {
-        const relativeCwd = path.relative(root, item.command.cwd) || '.';
-        const permission = await checkPermission(runCommandTool, { command: item.command.command, path: relativeCwd }, signal, { projectRoot: root });
-        if (signal?.aborted) {
-            const state = getCurrentTurnMutationState();
+    const selected = [];
+    for (const item of affected.packages) {
+        const commands = discoverPackageValidationCommands(profile, item.package);
+        if (commands.length === 0) {
+            stages.push(skippedStage('V3', 'package-scripts', 'no_validation_script', 'Affected package has no typecheck, build, or test script.', inputFingerprint, item.package.name));
+            continue;
+        }
+        selected.push(...commands.map((command) => ({
+            affected: item,
+            command,
+            level: 'V3',
+            adapter: `package-${command.script}`,
+        })));
+    }
+    const scriptOrder = { typecheck: 0, build: 1, test: 2 };
+    selected.sort((left, right) => scriptOrder[left.command.script] - scriptOrder[right.command.script]);
+    if (selected.length === 0)
+        return finish('no_validation_script');
+    await runCommands(selected, root, inputFingerprint, signal, callbacks, stages, packageResults);
+    return finish(stages.at(-1)?.skipReason === 'permission_denied' ? 'permission_denied' : undefined);
+}
+/** Create a run-scoped verifier cache; identical content never repeats expensive validation. */
+export function createAutomaticValidator() {
+    const cache = new Map();
+    const failureCounts = new Map();
+    return async (signal, callbacks = {}) => {
+        const state = getCurrentTurnMutationState();
+        const root = path.resolve(getSandboxRoot() ?? process.cwd());
+        const changedFiles = state.changedFiles.map((item) => item.path);
+        const inputFingerprint = fingerprintFiles(root, changedFiles);
+        const cacheKey = `${root}\0${inputFingerprint}`;
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            const count = cached.status === 'failed'
+                ? (failureCounts.get(cached.fingerprint) ?? 1) + 1
+                : 1;
+            if (cached.status === 'failed')
+                failureCounts.set(cached.fingerprint, count);
             return {
-                status: 'aborted',
-                command: commands,
-                output: selectedOutput,
+                ...cached,
+                output: `${cached.output}\n\n[validation cache] Identical inputs reused; failure occurrence ${count}.`,
+                stages: cached.stages.map((stage) => ({ ...stage, cached: true, durationMs: 0 })),
                 durationMs: 0,
-                affectedPackages: summary,
-                changedFiles: state.changedFiles.map((change) => change.path),
+                inputMutationVersion: state.version,
+                changedFiles,
                 mutationVersion: state.version,
             };
         }
-        if (permission === 'deny') {
-            return skipped('permission_denied', {
-                command: commands,
-                output: selectedOutput,
-                affectedPackages: summary,
-            });
-        }
-    }
-    const packageResults = [];
-    const capture = beginWorkspaceMutation();
-    try {
-        for (const item of selected) {
-            callbacks.onCommandStart?.(`[${item.affected.package.name}] ${item.command.command}`);
-            const raw = await runCommandRaw(item.command.command, 120000, signal, item.command.cwd);
-            const status = raw.status === 'passed'
-                ? 'passed'
-                : raw.status === 'aborted'
-                    ? 'aborted'
-                    : 'failed';
-            packageResults.push({
-                packageName: item.affected.package.name,
-                packageRoot: item.affected.package.root,
-                status,
-                script: item.command.script,
-                command: item.command.command,
-                exitCode: raw.exitCode,
-                output: formatCommandResult(raw),
-                durationMs: raw.durationMs,
-            });
-            if (status !== 'passed')
-                break;
+        const result = await runAutomaticValidation(signal, callbacks);
+        if (result.status === 'failed') {
+            const count = (failureCounts.get(result.fingerprint) ?? 0) + 1;
+            failureCounts.set(result.fingerprint, count);
+            if (count > 1) {
+                result.output += `\n\n[validation thrashing] The same failure fingerprint occurred ${count} times; change strategy before retrying.`;
+            }
         }
-    }
-    finally {
-        endWorkspaceMutation(capture, 'automatic_validation');
-    }
-    const after = getCurrentTurnMutationState();
-    const terminal = packageResults.find((item) => item.status !== 'passed')
-        ?? packageResults[packageResults.length - 1];
-    const output = [
-        selectedOutput,
-        ...packageResults.map((item) => `[${item.packageName}] ${item.command} (cwd: ${path.relative(root, item.packageRoot) || '.'})\n${item.output}`),
-    ].filter(Boolean).join('\n\n');
-    return {
-        status: terminal.status,
-        script: selected.length === 1 ? selected[0]?.command.script : undefined,
-        command: commands,
-        exitCode: terminal.exitCode,
-        output,
-        durationMs: packageResults.reduce((total, item) => total + item.durationMs, 0),
-        affectedPackages: summary,
-        packageResults,
-        changedFiles: after.changedFiles.map((item) => item.path),
-        mutationVersion: after.version,
+        cache.set(cacheKey, result);
+        return result;
     };
 }

package/dist/verification/postconditions.js

@@ -0,0 +1,98 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+function hash(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function diagnostic(file, code, message) {
+    return {
+        level: 'V0',
+        source: 'postcondition',
+        severity: 'error',
+        code,
+        file,
+        message,
+    };
+}
+function parseJson(file, content) {
+    if (path.extname(file).toLowerCase() !== '.json')
+        return [];
+    try {
+        JSON.parse(content);
+        return [];
+    }
+    catch (error) {
+        return [diagnostic(file, 'INVALID_JSON', error instanceof Error ? error.message : String(error))];
+    }
+}
+/** Immediate read-after-write verification used by write_file and edit_file. */
+export async function verifyWrittenFile(file, expectedContent) {
+    const expectedHash = hash(Buffer.from(expectedContent, 'utf8'));
+    let actual;
+    try {
+        actual = await readFile(file);
+    }
+    catch (error) {
+        return {
+            status: 'failed',
+            expectedHash,
+            diagnostics: [diagnostic(file, 'POSTCONDITION_READ_FAILED', error instanceof Error ? error.message : String(error))],
+        };
+    }
+    const actualHash = hash(actual);
+    const diagnostics = actualHash === expectedHash
+        ? parseJson(file, actual.toString('utf8'))
+        : [diagnostic(file, 'CONTENT_HASH_MISMATCH', 'Content read after writing differs from the requested content.')];
+    return {
+        status: diagnostics.length === 0 ? 'passed' : 'failed',
+        expectedHash,
+        actualHash,
+        diagnostics,
+    };
+}
+/** Re-check current changed files before more expensive validation layers. */
+export async function runFilePostconditions(root, changedFiles, inputFingerprint) {
+    const startedAt = Date.now();
+    const diagnostics = [];
+    const hashes = [];
+    let checked = 0;
+    for (const changedFile of changedFiles) {
+        const absolute = path.resolve(process.cwd(), changedFile);
+        const relative = path.relative(root, absolute);
+        if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            diagnostics.push(diagnostic(changedFile, 'OUTSIDE_PROJECT', 'Changed path is outside the project root.'));
+            continue;
+        }
+        try {
+            const fileStat = await stat(absolute);
+            if (!fileStat.isFile())
+                continue;
+            const content = await readFile(absolute);
+            checked += 1;
+            hashes.push(`${relative.replace(/\\/g, '/')}: ${hash(content)}`);
+            diagnostics.push(...parseJson(relative, content.toString('utf8')));
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT') {
+                diagnostics.push(diagnostic(relative, 'POSTCONDITION_READ_FAILED', error instanceof Error ? error.message : String(error)));
+            }
+        }
+    }
+    const status = diagnostics.some((item) => item.severity === 'error') ? 'failed' : checked > 0 ? 'passed' : 'skipped';
+    return {
+        level: 'V0',
+        status,
+        adapter: 'file-postconditions',
+        diagnostics,
+        output: status === 'skipped' ? 'No current files require V0 postconditions.' : hashes.join('\n'),
+        durationMs: Date.now() - startedAt,
+        skipReason: status === 'skipped' ? 'no_current_files' : undefined,
+        inputFingerprint,
+    };
+}
+export function formatPostconditionFailure(result) {
+    return result.diagnostics
+        .map((item) => `[${item.code ?? 'V0_FAILED'}] ${item.file ?? ''}: ${item.message}`)
+        .join('\n');
+}