mustflow 1.18.16 → 1.31.0

package/dist/cli/commands/verify.js

@@ -1,14 +1,16 @@
-import { readFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
+import { createClassifyOutput } from './classify.js';
 import { runRun } from './run.js';
 import { createChangeVerificationReport, } from '../../core/change-verification.js';
-import { createVerificationPlan } from '../../core/verification-plan.js';
 import { readCommandContract } from '../../core/config-loading.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
 import { readLocalCommandEffectGraph, readLocalPathSurfaces, } from '../lib/local-index.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 const VERIFY_SCHEMA_VERSION = '1';
+const VERIFY_RUN_DIR = path.join('.mustflow', 'state', 'runs', 'verify-latest');
+const LATEST_RUN_RECEIPT_PATH = path.join('.mustflow', 'state', 'runs', 'latest.json');
 function createBufferedOutput() {
     const stdout = [];
     const stderr = [];
@@ -31,11 +33,13 @@ function createBufferedOutput() {
 }
 export function getVerifyHelp(lang = 'en') {
     return renderHelp({
-        usage: 'mf verify --reason <event> [options] | mf verify --from-plan <path> [options]',
+        usage: 'mf verify --reason <event> [options] | mf verify --from-plan <path> [options] | mf verify --changed [options]',
         summary: t(lang, 'verify.help.summary'),
         options: [
             { label: '--reason <event>', description: t(lang, 'verify.help.option.reason') },
             { label: '--from-plan <path>', description: t(lang, 'verify.help.option.fromPlan') },
+            { label: '--changed', description: t(lang, 'verify.help.option.changed') },
+            { label: '--write-plan <path>', description: t(lang, 'verify.help.option.writePlan') },
             { label: '--plan-only', description: t(lang, 'verify.help.option.planOnly') },
             { label: '--json', description: t(lang, 'cli.option.json') },
             { label: '-h, --help', description: t(lang, 'cli.option.help') },
@@ -45,6 +49,8 @@ export function getVerifyHelp(lang = 'en') {
             'mf verify --reason docs_change --json',
             'mf verify --reason docs_change --plan-only --json',
             'mf verify --from-plan verify-plan.json --json',
+            'mf verify --changed --plan-only --json',
+            'mf verify --changed --write-plan .mustflow/state/change-plan.json --json',
             'mf verify --reason mustflow_docs_change',
         ],
         exitCodes: [
@@ -56,8 +62,10 @@ export function getVerifyHelp(lang = 'en') {
 function parseVerifyArgs(args) {
     let reason;
     let fromPlan;
+    let writePlan;
     let json = false;
     let planOnly = false;
+    let changed = false;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === '--json') {
@@ -68,10 +76,14 @@ function parseVerifyArgs(args) {
             planOnly = true;
             continue;
         }
+        if (arg === '--changed') {
+            changed = true;
+            continue;
+        }
         if (arg === '--reason') {
             const value = args[index + 1];
             if (!value || value.startsWith('-')) {
-                return { json, planOnly, reason, error: 'missing_reason_value' };
+                return { json, planOnly, changed, reason, error: 'missing_reason_value' };
             }
             reason = value;
             index += 1;
@@ -80,16 +92,25 @@ function parseVerifyArgs(args) {
         if (arg === '--from-plan') {
             const value = args[index + 1];
             if (!value || value.startsWith('-')) {
-                return { json, planOnly, reason, fromPlan, error: 'missing_from_plan_value' };
+                return { json, planOnly, changed, reason, fromPlan, error: 'missing_from_plan_value' };
             }
             fromPlan = value;
             index += 1;
             continue;
         }
+        if (arg === '--write-plan') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('-')) {
+                return { json, planOnly, changed, reason, fromPlan, writePlan, error: 'missing_write_plan_value' };
+            }
+            writePlan = value;
+            index += 1;
+            continue;
+        }
         if (arg.startsWith('--reason=')) {
             const value = arg.slice('--reason='.length);
             if (value.length === 0) {
-                return { json, planOnly, reason, error: 'missing_reason_value' };
+                return { json, planOnly, changed, reason, error: 'missing_reason_value' };
             }
             reason = value;
             continue;
@@ -97,35 +118,152 @@ function parseVerifyArgs(args) {
         if (arg.startsWith('--from-plan=')) {
             const value = arg.slice('--from-plan='.length);
             if (value.length === 0) {
-                return { json, planOnly, reason, fromPlan, error: 'missing_from_plan_value' };
+                return { json, planOnly, changed, reason, fromPlan, error: 'missing_from_plan_value' };
             }
             fromPlan = value;
             continue;
         }
+        if (arg.startsWith('--write-plan=')) {
+            const value = arg.slice('--write-plan='.length);
+            if (value.length === 0) {
+                return { json, planOnly, changed, reason, fromPlan, writePlan, error: 'missing_write_plan_value' };
+            }
+            writePlan = value;
+            continue;
+        }
         if (arg.startsWith('-')) {
-            return { json, planOnly, reason, error: arg };
+            return { json, planOnly, changed, reason, fromPlan, writePlan, error: arg };
         }
-        return { json, planOnly, reason, error: `unexpected:${arg}` };
+        return { json, planOnly, changed, reason, fromPlan, writePlan, error: `unexpected:${arg}` };
     }
-    return { json, planOnly, reason, fromPlan };
+    return { json, planOnly, changed, reason, fromPlan, writePlan };
 }
 function uniqueStrings(values) {
     return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))];
 }
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function sanitizeIntentFilePart(value) {
+    const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, '_').replace(/^_+|_+$/g, '');
+    return sanitized.length > 0 ? sanitized.slice(0, 80) : 'intent';
+}
 function readStringArray(value) {
     if (!Array.isArray(value)) {
         return [];
     }
     return value.filter((item) => typeof item === 'string');
 }
-function readNumber(value) {
-    return Number.isInteger(value) && Number(value) >= 0 ? Number(value) : null;
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
 }
-function readUpdatePolicies(value) {
-    return readStringArray(value).filter((item) => item === 'update' || item === 'update_or_mark_stale' || item === 'not_applicable');
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
-function readChangeSource(value) {
-    return value === 'changed' || value === 'paths' ? value : 'paths';
+function isUpdatePolicy(value) {
+    return value === 'update' || value === 'update_or_mark_stale' || value === 'not_applicable';
+}
+function isUpdatePolicyArray(value) {
+    return Array.isArray(value) && value.every((item) => isUpdatePolicy(item));
+}
+function readPlanRoot(value) {
+    if (!isPlainRecord(value)) {
+        return null;
+    }
+    const root = value.mustflow_root;
+    return typeof root === 'string' && root.length > 0 ? root : null;
+}
+function readStrictClassificationSummary(value) {
+    if (!isPlainRecord(value)) {
+        return null;
+    }
+    if (!Number.isInteger(value.fileCount) ||
+        Number(value.fileCount) < 0 ||
+        !Number.isInteger(value.publicSurfaceCount) ||
+        Number(value.publicSurfaceCount) < 0 ||
+        !isStringArray(value.changeKinds) ||
+        !isStringArray(value.validationReasons) ||
+        !isUpdatePolicyArray(value.updatePolicies) ||
+        !isStringArray(value.driftChecks) ||
+        !isStringArray(value.affectedContracts)) {
+        return null;
+    }
+    return {
+        fileCount: Number(value.fileCount),
+        publicSurfaceCount: Number(value.publicSurfaceCount),
+        changeKinds: [...value.changeKinds],
+        validationReasons: uniqueStrings(value.validationReasons),
+        updatePolicies: [...value.updatePolicies],
+        driftChecks: [...value.driftChecks],
+        affectedContracts: [...value.affectedContracts],
+    };
+}
+function readStrictClassification(value) {
+    if (!isPlainRecord(value) || typeof value.path !== 'string' || !isStringArray(value.changeKinds)) {
+        return null;
+    }
+    const surface = value.surface;
+    if (!isPlainRecord(surface)) {
+        return null;
+    }
+    if (typeof surface.kind !== 'string' ||
+        typeof surface.category !== 'string' ||
+        typeof surface.isPublicSurface !== 'boolean' ||
+        !isStringArray(surface.validationReasons) ||
+        !isStringArray(surface.affectedContracts) ||
+        !isUpdatePolicy(surface.updatePolicy) ||
+        !isStringArray(surface.driftChecks)) {
+        return null;
+    }
+    return {
+        path: value.path,
+        changeKinds: [...value.changeKinds],
+        surface: {
+            kind: surface.kind,
+            category: surface.category,
+            isPublicSurface: surface.isPublicSurface,
+            validationReasons: [...surface.validationReasons],
+            affectedContracts: [...surface.affectedContracts],
+            updatePolicy: surface.updatePolicy,
+            driftChecks: [...surface.driftChecks],
+        },
+    };
+}
+function readStrictClassifications(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const classifications = value.map(readStrictClassification);
+    return classifications.every((classification) => classification !== null)
+        ? classifications
+        : null;
+}
+function readStrictClassifyPlan(projectRoot, plan) {
+    if (!isPlainRecord(plan)) {
+        throw new Error('unsupported_plan_source');
+    }
+    if (plan.schema_version !== '1' || plan.command !== 'classify') {
+        throw new Error('unsupported_plan_source');
+    }
+    if (readPlanRoot(plan) !== projectRoot) {
+        throw new Error('plan_root_mismatch');
+    }
+    const source = plan.source;
+    const files = plan.files;
+    const classifications = readStrictClassifications(plan.classifications);
+    const summary = readStrictClassificationSummary(plan.summary);
+    if ((source !== 'changed' && source !== 'paths') || !isStringArray(files) || !classifications || !summary) {
+        throw new Error('invalid_plan_file');
+    }
+    if (summary.validationReasons.length === 0) {
+        throw new Error('missing_plan_reasons');
+    }
+    return {
+        source,
+        files: [...files],
+        classifications,
+        summary,
+    };
 }
 function emptyClassificationSummary(validationReasons) {
     return {
@@ -138,51 +276,6 @@ function emptyClassificationSummary(validationReasons) {
         affectedContracts: [],
     };
 }
-function readClassificationSummary(value, fallbackReasons) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return emptyClassificationSummary(fallbackReasons);
-    }
-    const record = value;
-    const validationReasons = uniqueStrings([...fallbackReasons, ...readStringArray(record.validationReasons)]);
-    return {
-        fileCount: readNumber(record.fileCount) ?? 0,
-        publicSurfaceCount: readNumber(record.publicSurfaceCount) ?? 0,
-        changeKinds: readStringArray(record.changeKinds),
-        validationReasons,
-        updatePolicies: readUpdatePolicies(record.updatePolicies),
-        driftChecks: readStringArray(record.driftChecks),
-        affectedContracts: readStringArray(record.affectedContracts),
-    };
-}
-function readClassifications(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter((item) => {
-        if (!item || typeof item !== 'object' || Array.isArray(item)) {
-            return false;
-        }
-        const record = item;
-        const surface = record.surface;
-        const surfaceRecord = surface;
-        return (typeof record.path === 'string' &&
-            Array.isArray(record.changeKinds) &&
-            readStringArray(record.changeKinds).length === record.changeKinds.length &&
-            surface !== null &&
-            typeof surface === 'object' &&
-            !Array.isArray(surface) &&
-            typeof surfaceRecord.kind === 'string' &&
-            typeof surfaceRecord.category === 'string' &&
-            typeof surfaceRecord.isPublicSurface === 'boolean' &&
-            Array.isArray(surfaceRecord.validationReasons) &&
-            readStringArray(surfaceRecord.validationReasons).length === surfaceRecord.validationReasons.length &&
-            Array.isArray(surfaceRecord.affectedContracts) &&
-            readStringArray(surfaceRecord.affectedContracts).length === surfaceRecord.affectedContracts.length &&
-            readUpdatePolicies([surfaceRecord.updatePolicy]).length === 1 &&
-            Array.isArray(surfaceRecord.driftChecks) &&
-            readStringArray(surfaceRecord.driftChecks).length === surfaceRecord.driftChecks.length);
-    });
-}
 function createSyntheticClassificationReport(reasons, source = 'paths', files = []) {
     return {
         source,
@@ -191,45 +284,6 @@ function createSyntheticClassificationReport(reasons, source = 'paths', files =
         summary: emptyClassificationSummary(reasons),
     };
 }
-function readClassificationReport(plan, fallbackReasons) {
-    if (!plan || typeof plan !== 'object' || Array.isArray(plan)) {
-        return createSyntheticClassificationReport(fallbackReasons);
-    }
-    const record = plan;
-    const summary = readClassificationSummary(record.classification_summary ?? record.summary, fallbackReasons);
-    const files = readStringArray(record.files);
-    const classifications = readClassifications(record.classifications);
-    return {
-        source: readChangeSource(record.source),
-        files,
-        classifications,
-        summary,
-    };
-}
-function readPlanReasons(plan) {
-    if (!plan || typeof plan !== 'object' || Array.isArray(plan)) {
-        return [];
-    }
-    const record = plan;
-    const summary = record.summary;
-    const classificationSummary = record.classification_summary;
-    const verification = record.verification;
-    const reasons = [
-        typeof record.reason === 'string' ? record.reason : '',
-        ...readStringArray(record.reasons),
-        ...readStringArray(record.validationReasons),
-        ...(summary && typeof summary === 'object' && !Array.isArray(summary)
-            ? readStringArray(summary.validationReasons)
-            : []),
-        ...(classificationSummary && typeof classificationSummary === 'object' && !Array.isArray(classificationSummary)
-            ? readStringArray(classificationSummary.validationReasons)
-            : []),
-        ...(verification && typeof verification === 'object' && !Array.isArray(verification)
-            ? readStringArray(verification.reasons)
-            : []),
-    ];
-    return uniqueStrings(reasons);
-}
 function resolvePlanPath(projectRoot, inputPath) {
     const resolved = path.resolve(projectRoot, inputPath);
     const relative = path.relative(projectRoot, resolved);
@@ -238,7 +292,7 @@ function resolvePlanPath(projectRoot, inputPath) {
     }
     return resolved;
 }
-function readInputFromPlan(projectRoot, inputPath) {
+export function readInputFromPlan(projectRoot, inputPath) {
     let parsed;
     const planPath = resolvePlanPath(projectRoot, inputPath);
     try {
@@ -247,21 +301,37 @@ function readInputFromPlan(projectRoot, inputPath) {
     catch {
         throw new Error('invalid_plan_file');
     }
-    const reasons = readPlanReasons(parsed);
-    if (reasons.length === 0) {
-        throw new Error('missing_plan_reasons');
-    }
+    const classificationReport = readStrictClassifyPlan(projectRoot, parsed);
     return {
-        reasons,
-        classificationReport: readClassificationReport(parsed, reasons),
+        reasons: classificationReport.summary.validationReasons,
+        classificationReport,
     };
 }
-function planErrorMessageKey(code) {
+function createInputFromChanged(projectRoot) {
+    const plan = createClassifyOutput(projectRoot, 'changed', []);
+    return {
+        plan,
+        input: {
+            reasons: plan.summary.validationReasons,
+            classificationReport: plan,
+        },
+    };
+}
+function writeChangedPlan(projectRoot, inputPath, plan) {
+    const planPath = resolvePlanPath(projectRoot, inputPath);
+    mkdirSync(path.dirname(planPath), { recursive: true });
+    writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}\n`, 'utf8');
+}
+export function planErrorMessageKey(code) {
     switch (code) {
         case 'plan_path_outside_root':
             return 'verify.error.plan_path_outside_root';
         case 'missing_plan_reasons':
             return 'verify.error.missing_plan_reasons';
+        case 'unsupported_plan_source':
+            return 'verify.error.unsupported_plan_source';
+        case 'plan_root_mismatch':
+            return 'verify.error.plan_root_mismatch';
         default:
             return 'verify.error.invalid_plan_file';
     }
@@ -277,9 +347,48 @@ function skippedResult(candidate) {
         receipt: null,
     };
 }
-async function runVerificationIntent(intent, lang) {
+function candidateResultKey(candidate) {
+    return candidate.intent
+        ? `intent:${candidate.intent}`
+        : `missing:${candidate.reason}:${candidate.skipReason ?? ''}:${candidate.detail ?? ''}`;
+}
+function createSkippedResults(candidates, scheduledIntents, gaps) {
+    const seen = new Set();
+    const results = [];
+    const activeGapReasons = new Set(gaps.map((gap) => gap.reason));
+    for (const candidate of candidates) {
+        if (candidate.status === 'runnable' || (candidate.intent && scheduledIntents.has(candidate.intent))) {
+            continue;
+        }
+        if (candidate.candidateState === 'gap' && !activeGapReasons.has(candidate.reason)) {
+            continue;
+        }
+        const key = candidateResultKey(candidate);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        results.push(skippedResult({
+            intent: candidate.intent ?? '',
+            reason: candidate.skipReason,
+            detail: candidate.detail,
+        }));
+    }
+    return results;
+}
+function testTargetsByScheduledIntent(report) {
+    return new Map(report.test_selection.selected
+        .filter((candidate) => candidate.status === 'runnable' &&
+        candidate.testTargetsApplied &&
+        candidate.appliedTestTargets.length > 0)
+        .map((candidate) => [candidate.intent, candidate.appliedTestTargets]));
+}
+async function runVerificationIntent(intent, lang, testTargets = []) {
     const output = createBufferedOutput();
-    const exitCode = await runRun([intent, '--json'], output.reporter, lang);
+    const exitCode = await runRun([intent, '--json'], output.reporter, lang, {
+        writeLatestReceipt: false,
+        testTargets,
+    });
     const rawStdout = output.stdout().trim();
     let receipt = null;
     let status = exitCode === 0 ? 'passed' : 'failed';
@@ -333,39 +442,76 @@ function getVerificationStatus(summary) {
     }
     return 'passed';
 }
-async function createVerifyOutput(reasons, planSource, projectRoot, lang) {
-    const contract = readCommandContract(projectRoot);
-    const candidatesByIntent = new Map();
-    const unmatchedCandidates = [];
-    for (const reason of reasons) {
-        const plan = createVerificationPlan(contract, reason);
-        for (const candidate of plan.candidates) {
-            if (!candidate.intent) {
-                unmatchedCandidates.push(candidate);
-                continue;
-            }
-            if (!candidatesByIntent.has(candidate.intent)) {
-                candidatesByIntent.set(candidate.intent, candidate);
-            }
+function writeVerifyRunReceipts(projectRoot, output) {
+    const runDir = path.join(projectRoot, VERIFY_RUN_DIR);
+    const intentDir = path.join(runDir, 'intents');
+    const receipts = [];
+    rmSync(runDir, { recursive: true, force: true });
+    mkdirSync(intentDir, { recursive: true });
+    for (const [index, result] of output.results.entries()) {
+        let receiptPath = null;
+        if (result.intent && result.receipt) {
+            const fileName = `${String(index + 1).padStart(3, '0')}-${sanitizeIntentFilePart(result.intent)}.json`;
+            const absoluteReceiptPath = path.join(intentDir, fileName);
+            receiptPath = toPosixPath(path.join(VERIFY_RUN_DIR, 'intents', fileName));
+            writeFileSync(absoluteReceiptPath, `${JSON.stringify({ ...result.receipt, receipt_path: receiptPath }, null, 2)}\n`, 'utf8');
         }
+        receipts.push({
+            intent: result.intent,
+            status: result.status,
+            skipped: result.skipped,
+            receipt_path: receiptPath,
+        });
     }
-    const candidates = [...candidatesByIntent.values(), ...unmatchedCandidates].sort((left, right) => left.intent.localeCompare(right.intent));
+    const manifest = {
+        schema_version: '1',
+        command: 'verify',
+        reason: output.reason,
+        reasons: output.reasons,
+        plan_source: output.plan_source,
+        status: output.status,
+        summary: output.summary,
+        receipts,
+    };
+    writeFileSync(path.join(runDir, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    const latest = {
+        schema_version: '1',
+        command: 'verify',
+        kind: 'verify_run_summary',
+        reason: output.reason,
+        reasons: output.reasons,
+        plan_source: output.plan_source,
+        status: output.status,
+        summary: output.summary,
+        run_dir: toPosixPath(VERIFY_RUN_DIR),
+        manifest_path: toPosixPath(path.join(VERIFY_RUN_DIR, 'manifest.json')),
+    };
+    writeFileSync(path.join(projectRoot, LATEST_RUN_RECEIPT_PATH), `${JSON.stringify(latest, null, 2)}\n`, 'utf8');
+}
+async function createVerifyOutput(input, planSource, projectRoot, lang) {
+    const contract = readCommandContract(projectRoot);
+    const report = createChangeVerificationReport(input.classificationReport, contract, projectRoot);
+    const scheduledIntents = new Set(report.schedule.entries.map((entry) => entry.intent));
+    const scheduledTestTargets = testTargetsByScheduledIntent(report);
     const results = [];
-    for (const candidate of candidates) {
-        results.push(candidate.status === 'runnable' ? await runVerificationIntent(candidate.intent, lang) : skippedResult(candidate));
+    for (const entry of report.schedule.entries) {
+        results.push(await runVerificationIntent(entry.intent, lang, scheduledTestTargets.get(entry.intent) ?? []));
     }
+    results.push(...createSkippedResults(report.candidates, scheduledIntents, report.gaps));
     const summary = summarizeResults(results);
-    return {
+    const output = {
         schema_version: VERIFY_SCHEMA_VERSION,
         command: 'verify',
         mustflow_root: projectRoot,
-        reason: reasons.join(', '),
-        reasons,
+        reason: input.reasons.join(', '),
+        reasons: input.reasons,
         plan_source: planSource,
         status: getVerificationStatus(summary),
         summary,
         results,
     };
+    writeVerifyRunReceipts(projectRoot, output);
+    return output;
 }
 async function createPlanOnlyOutput(input, projectRoot) {
     const contract = readCommandContract(projectRoot);
@@ -435,33 +581,52 @@ export async function runVerify(args, reporter, lang = 'en') {
             ? t(lang, 'cli.error.missingValue', { option: '--reason' })
             : parsed.error === 'missing_from_plan_value'
                 ? t(lang, 'cli.error.missingValue', { option: '--from-plan' })
-                : parsed.error.startsWith('unexpected:')
-                    ? t(lang, 'cli.error.unexpectedArgument', { argument: parsed.error.slice('unexpected:'.length) })
-                    : t(lang, 'cli.error.unknownOption', { option: parsed.error });
+                : parsed.error === 'missing_write_plan_value'
+                    ? t(lang, 'cli.error.missingValue', { option: '--write-plan' })
+                    : parsed.error.startsWith('unexpected:')
+                        ? t(lang, 'cli.error.unexpectedArgument', { argument: parsed.error.slice('unexpected:'.length) })
+                        : t(lang, 'cli.error.unknownOption', { option: parsed.error });
         printUsageError(reporter, message, 'mf verify --help', getVerifyHelp(lang), lang);
         return 1;
     }
-    if (parsed.reason && parsed.fromPlan) {
+    const selectedInputCount = [parsed.reason, parsed.fromPlan, parsed.changed ? 'changed' : undefined].filter(Boolean).length;
+    if (selectedInputCount > 1) {
         printUsageError(reporter, t(lang, 'verify.error.conflictingInputs'), 'mf verify --help', getVerifyHelp(lang), lang);
         return 1;
     }
-    if (!parsed.reason && !parsed.fromPlan) {
+    if (selectedInputCount === 0) {
         printUsageError(reporter, t(lang, 'verify.error.missingReason'), 'mf verify --help', getVerifyHelp(lang), lang);
         return 1;
     }
+    if (parsed.writePlan && !parsed.changed) {
+        printUsageError(reporter, t(lang, 'verify.error.writePlanRequiresChanged'), 'mf verify --help', getVerifyHelp(lang), lang);
+        return 1;
+    }
     if (parsed.planOnly && !parsed.json) {
         printUsageError(reporter, t(lang, 'verify.error.planOnlyJson'), 'mf verify --help', getVerifyHelp(lang), lang);
         return 1;
     }
     const projectRoot = resolveMustflowRoot();
     let input;
+    let changedPlan = null;
     try {
-        input = parsed.fromPlan
-            ? readInputFromPlan(projectRoot, parsed.fromPlan)
-            : {
+        if (parsed.changed) {
+            const changedInput = createInputFromChanged(projectRoot);
+            input = changedInput.input;
+            changedPlan = changedInput.plan;
+        }
+        else if (parsed.fromPlan) {
+            input = readInputFromPlan(projectRoot, parsed.fromPlan);
+        }
+        else {
+            input = {
                 reasons: [parsed.reason],
                 classificationReport: createSyntheticClassificationReport([parsed.reason]),
             };
+        }
+        if (parsed.writePlan && changedPlan) {
+            writeChangedPlan(projectRoot, parsed.writePlan, changedPlan);
+        }
     }
     catch (error) {
         const code = error instanceof Error ? error.message : 'invalid_plan_file';
@@ -472,7 +637,7 @@ export async function runVerify(args, reporter, lang = 'en') {
         reporter.stdout(JSON.stringify(await createPlanOnlyOutput(input, projectRoot), null, 2));
         return 0;
     }
-    const output = await createVerifyOutput(input.reasons, parsed.fromPlan ?? null, projectRoot, lang);
+    const output = await createVerifyOutput(input, parsed.fromPlan ?? (parsed.changed ? 'changed' : null), projectRoot, lang);
     if (parsed.json) {
         reporter.stdout(JSON.stringify(output, null, 2));
     }