mustflow 2.23.0 → 2.24.2

package/dist/cli/commands/init.js

@@ -7,6 +7,7 @@ import { copyFileInsideWithoutSymlinks, ensureFileTargetInsideWithoutSymlinks, e
 import { localeMessage, t } from '../lib/i18n.js';
 import { isLocaleTag } from '../lib/locale-tags.js';
 import { MANIFEST_LOCK_RELATIVE_PATH, sha256File } from '../lib/manifest-lock.js';
+import { formatCliOptionParseError, hasCliOptionToken, parseCliOptions } from '../lib/option-parser.js';
 import { isCommitMessageStyle, isTestAuthoringPolicy } from '../lib/preferences-options.js';
 import { getDefaultTemplate, getTemplateFiles } from '../lib/templates.js';
 const MUSTFLOW_BLOCK_START = '<!-- mustflow:start schema=1 -->';
@@ -24,6 +25,20 @@ const LOCALE_LABELS = {
     fr: 'French',
     hi: 'Hindi',
 };
+const INIT_BOOLEAN_OPTIONS = new Set(['--yes', '--dry-run', '--merge', '--force', '--interactive']);
+const INIT_OPTION_SPECS = [
+    { name: '--yes', kind: 'boolean' },
+    { name: '--dry-run', kind: 'boolean' },
+    { name: '--merge', kind: 'boolean' },
+    { name: '--force', kind: 'boolean' },
+    { name: '--interactive', kind: 'boolean' },
+    { name: '--set', kind: 'string' },
+    { name: '--profile', kind: 'string' },
+    { name: '--locale', kind: 'string' },
+    { name: '--agent-lang', kind: 'string' },
+    { name: '--product-source-locale', kind: 'string' },
+    { name: '--product-locale', kind: 'string' },
+];
 function getMustflowRouterBlock(locale) {
     return localeMessage(locale, 'init.routerBlock');
 }
@@ -91,30 +106,12 @@ export function getInitHelp(lang = 'en') {
         ],
     }, lang);
 }
-function splitLongOption(arg) {
+function splitOptionName(arg) {
     const equalsIndex = arg.indexOf('=');
     if (equalsIndex === -1) {
-        return { name: arg };
+        return arg;
     }
-    return {
-        name: arg.slice(0, equalsIndex),
-        value: arg.slice(equalsIndex + 1),
-    };
-}
-function readRequiredOptionValue(args, index, parsed, reporter, lang) {
-    if (parsed.value !== undefined) {
-        if (parsed.value.trim().length === 0) {
-            printUsageError(reporter, t(lang, 'cli.error.missingValue', { option: parsed.name }), 'mf init --help', getInitHelp(lang), lang);
-            return undefined;
-        }
-        return parsed.value;
-    }
-    const next = args[index + 1];
-    if (!next || next.startsWith('-')) {
-        printUsageError(reporter, t(lang, 'cli.error.missingValue', { option: parsed.name }), 'mf init --help', getInitHelp(lang), lang);
-        return undefined;
-    }
-    return next;
+    return arg.slice(0, equalsIndex);
 }
 function parseBoolean(value) {
     if (value === 'true') {
@@ -371,78 +368,67 @@ function parseOptions(args, reporter, lang) {
     let productSourceLocale;
     const productLocales = [];
     const preferenceOverrides = [];
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (!arg) {
-            continue;
-        }
-        const parsed = splitLongOption(arg);
-        if (['--yes', '--dry-run', '--merge', '--force', '--interactive'].includes(parsed.name) && parsed.value !== undefined) {
-            printUsageError(reporter, t(lang, 'cli.error.unexpectedValue', { option: parsed.name }), 'mf init --help', getInitHelp(lang), lang);
+    const parsed = parseCliOptions(args, INIT_OPTION_SPECS);
+    if (parsed.error) {
+        const optionName = splitOptionName(parsed.error.option);
+        if (parsed.error.kind === 'unknown_option' && INIT_BOOLEAN_OPTIONS.has(optionName) && parsed.error.option.includes('=')) {
+            printUsageError(reporter, t(lang, 'cli.error.unexpectedValue', { option: optionName }), 'mf init --help', getInitHelp(lang), lang);
             return undefined;
         }
-        if (parsed.name === '--yes') {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf init --help', getInitHelp(lang), lang);
+        return undefined;
+    }
+    for (const occurrence of parsed.occurrences) {
+        if (occurrence.name === '--yes') {
             yes = true;
             continue;
         }
-        if (parsed.name === '--dry-run') {
+        if (occurrence.name === '--dry-run') {
             dryRun = true;
             continue;
         }
-        if (parsed.name === '--merge') {
+        if (occurrence.name === '--merge') {
             merge = true;
             continue;
         }
-        if (parsed.name === '--force') {
+        if (occurrence.name === '--force') {
             force = true;
             continue;
         }
-        if (parsed.name === '--interactive') {
+        if (occurrence.name === '--interactive') {
             interactive = true;
             continue;
         }
-        if (parsed.name === '--set') {
-            const value = readRequiredOptionValue(args, index, parsed, reporter, lang);
-            if (value === undefined) {
-                return undefined;
-            }
-            if (parsed.value === undefined) {
-                index += 1;
-            }
-            const override = parsePreferenceOverride(value, reporter, lang);
+        if (typeof occurrence.value !== 'string') {
+            continue;
+        }
+        if (occurrence.value.trim().length === 0) {
+            printUsageError(reporter, t(lang, 'cli.error.missingValue', { option: occurrence.name }), 'mf init --help', getInitHelp(lang), lang);
+            return undefined;
+        }
+        if (occurrence.name === '--set') {
+            const override = parsePreferenceOverride(occurrence.value, reporter, lang);
             if (!override) {
                 return undefined;
             }
             preferenceOverrides.push(override);
             continue;
         }
-        if (['--profile', '--locale', '--agent-lang', '--product-source-locale', '--product-locale'].includes(parsed.name)) {
-            const value = readRequiredOptionValue(args, index, parsed, reporter, lang);
-            if (value === undefined) {
-                return undefined;
-            }
-            if (parsed.value === undefined) {
-                index += 1;
-            }
-            if (parsed.name === '--profile') {
-                profile = value;
-            }
-            else if (parsed.name === '--locale') {
-                locale = value;
-            }
-            else if (parsed.name === '--agent-lang') {
-                agentLang = value;
-            }
-            else if (parsed.name === '--product-source-locale') {
-                productSourceLocale = value;
-            }
-            else {
-                productLocales.push(value);
-            }
-            continue;
+        if (occurrence.name === '--profile') {
+            profile = occurrence.value;
+        }
+        else if (occurrence.name === '--locale') {
+            locale = occurrence.value;
+        }
+        else if (occurrence.name === '--agent-lang') {
+            agentLang = occurrence.value;
+        }
+        else if (occurrence.name === '--product-source-locale') {
+            productSourceLocale = occurrence.value;
+        }
+        else if (occurrence.name === '--product-locale') {
+            productLocales.push(occurrence.value);
         }
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: arg }), 'mf init --help', getInitHelp(lang), lang);
-        return undefined;
     }
     if (merge && force) {
         printUsageError(reporter, t(lang, 'init.error.cannotCombineMergeForce'), 'mf init --help', getInitHelp(lang), lang);
@@ -948,7 +934,7 @@ function writeManifestLock(projectRoot, template, plannedFiles, options, customi
     writeUtf8FileInsideWithoutSymlinks(projectRoot, lockPath, renderManifestLock(template, plannedFiles, options, customizedFiles));
 }
 export async function runInit(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getInitHelp(lang));
         return 0;
     }

package/dist/cli/commands/line-endings.js

@@ -1,7 +1,14 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { inspectLineEndings } from '../../core/line-endings.js';
+const LINE_ENDING_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--all', kind: 'boolean' },
+    { name: '--apply', kind: 'boolean' },
+    { name: '--dry-run', kind: 'boolean' },
+];
 export function getLineEndingsHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf line-endings <check|normalize> [options]',
@@ -26,12 +33,11 @@ export function getLineEndingsHelp(lang = 'en') {
 }
 function parseLineEndingOptions(args, lang) {
     const [action, ...rest] = args;
-    const json = rest.includes('--json');
-    const apply = rest.includes('--apply');
-    const dryRun = rest.includes('--dry-run');
-    const all = rest.includes('--all');
-    const supported = new Set(['--json', '--all', '--apply', '--dry-run']);
-    const unsupported = rest.find((arg) => arg.startsWith('-') && !supported.has(arg));
+    const parsed = parseCliOptions(rest, LINE_ENDING_OPTIONS, { allowPositionals: true });
+    const json = hasParsedCliOption(parsed, '--json');
+    const apply = hasParsedCliOption(parsed, '--apply');
+    const dryRun = hasParsedCliOption(parsed, '--dry-run');
+    const all = hasParsedCliOption(parsed, '--all');
     if (action !== 'check' && action !== 'normalize') {
         return {
             action: 'check',
@@ -42,8 +48,8 @@ function parseLineEndingOptions(args, lang) {
             error: action ? t(lang, 'lineEndings.error.unknownAction', { action }) : t(lang, 'lineEndings.error.missingAction'),
         };
     }
-    if (unsupported) {
-        return { action, json, apply, dryRun, all, error: t(lang, 'cli.error.unknownOption', { option: unsupported }) };
+    if (parsed.error) {
+        return { action, json, apply, dryRun, all, error: formatCliOptionParseError(parsed.error, lang) };
     }
     if (action === 'check' && (apply || dryRun)) {
         return { action, json, apply, dryRun, all, error: t(lang, 'lineEndings.error.checkModeOption') };
@@ -79,7 +85,7 @@ function renderLineEndingSummary(report, lang) {
     return lines.join('\n');
 }
 export function runLineEndings(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getLineEndingsHelp(lang));
         return 0;
     }

package/dist/cli/commands/map.js

@@ -1,7 +1,15 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { generateRepoMap, writeRepoMap } from '../lib/repo-map.js';
+const MAP_OPTIONS = [
+    { name: '--stdout', kind: 'boolean' },
+    { name: '--write', kind: 'boolean' },
+    { name: '--depth', kind: 'string' },
+    { name: '--include-nested', kind: 'boolean' },
+    { name: '--root-only', kind: 'boolean' },
+];
 export function getMapHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf map [options]',
@@ -31,54 +39,34 @@ export function getMapHelp(lang = 'en') {
     }, lang);
 }
 export function runMap(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getMapHelp(lang));
         return 0;
     }
-    let shouldPrint = false;
-    let shouldWrite = false;
+    const parsed = parseCliOptions(args, MAP_OPTIONS);
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf map --help', getMapHelp(lang), lang);
+        return 1;
+    }
+    let shouldPrint = hasParsedCliOption(parsed, '--stdout');
+    const shouldWrite = hasParsedCliOption(parsed, '--write');
     let depth = 3;
-    let includeNested;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === '--stdout') {
-            shouldPrint = true;
-            continue;
-        }
-        if (arg === '--write') {
-            shouldWrite = true;
-            continue;
-        }
-        if (arg === '--include-nested') {
-            if (includeNested === false) {
-                printUsageError(reporter, t(lang, 'map.error.nestedConflict'), 'mf map --help', getMapHelp(lang), lang);
-                return 1;
-            }
-            includeNested = true;
-            continue;
-        }
-        if (arg === '--root-only') {
-            if (includeNested === true) {
-                printUsageError(reporter, t(lang, 'map.error.nestedConflict'), 'mf map --help', getMapHelp(lang), lang);
-                return 1;
-            }
-            includeNested = false;
-            continue;
-        }
-        if (arg === '--depth') {
-            const rawDepth = args[index + 1];
-            const parsedDepth = Number.parseInt(rawDepth ?? '', 10);
-            if (!Number.isInteger(parsedDepth) || parsedDepth < 1) {
-                printUsageError(reporter, t(lang, 'map.error.invalidDepth'), 'mf map --help', getMapHelp(lang), lang);
-                return 1;
-            }
-            depth = parsedDepth;
-            index += 1;
-            continue;
-        }
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: arg }), 'mf map --help', getMapHelp(lang), lang);
+    const wantsIncludeNested = hasParsedCliOption(parsed, '--include-nested');
+    const wantsRootOnly = hasParsedCliOption(parsed, '--root-only');
+    let includeNested = wantsIncludeNested ? true : wantsRootOnly ? false : undefined;
+    const rawDepth = getParsedCliStringOption(parsed, '--depth');
+    if (wantsIncludeNested && wantsRootOnly) {
+        printUsageError(reporter, t(lang, 'map.error.nestedConflict'), 'mf map --help', getMapHelp(lang), lang);
         return 1;
     }
+    if (rawDepth !== null) {
+        const parsedDepth = Number.parseInt(rawDepth, 10);
+        if (!Number.isInteger(parsedDepth) || parsedDepth < 1) {
+            printUsageError(reporter, t(lang, 'map.error.invalidDepth'), 'mf map --help', getMapHelp(lang), lang);
+            return 1;
+        }
+        depth = parsedDepth;
+    }
     if (!shouldPrint && !shouldWrite) {
         shouldPrint = true;
     }

package/dist/cli/commands/next.js

@@ -0,0 +1,300 @@
+import { createClassifyOutput } from './classify.js';
+import { createChangeVerificationReport, } from '../../core/change-verification.js';
+import { isRecord, readCommandContract, } from '../../core/config-loading.js';
+import { createVerificationPlanId } from '../../core/verification-plan-id.js';
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { getAgentContext } from '../lib/agent-context.js';
+import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { createRunPlan } from '../lib/run-plan.js';
+import { checkMustflowProjectReport } from '../lib/validation.js';
+const NEXT_SCHEMA_VERSION = '1';
+const COMMAND_AUTHORITY = '.mustflow/config/commands.toml';
+const NEXT_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+];
+export function getNextHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf next [options]',
+        summary: t(lang, 'next.help.summary'),
+        options: [
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: ['mf next', 'mf next --json'],
+        exitCodes: [
+            { label: '0', description: t(lang, 'next.help.exit.ok') },
+            { label: '1', description: t(lang, 'next.help.exit.fail') },
+        ],
+    }, lang);
+}
+function createPolicy() {
+    return {
+        command_authority: COMMAND_AUTHORITY,
+        direct_commands_allowed: false,
+        grants_command_authority: false,
+        writes_files: false,
+    };
+}
+function createState(input) {
+    return {
+        installed: input.installed,
+        check_ok: input.check_ok,
+        command_contract_ok: input.command_contract_ok,
+        git_status: input.git_status ?? 'unavailable',
+        changed_file_count: input.changed_file_count ?? null,
+        validation_reasons: input.validation_reasons ?? [],
+        selected_intents: input.selected_intents ?? [],
+        gap_count: input.gap_count ?? 0,
+    };
+}
+function action(kind, command, title, detail) {
+    return { kind, command, title, detail };
+}
+function toOutput(input) {
+    return {
+        schema_version: NEXT_SCHEMA_VERSION,
+        command: 'next',
+        mustflow_root: input.mustflowRoot,
+        status: input.status,
+        policy: createPolicy(),
+        state: input.state,
+        decision: input.decision,
+        recommended_commands: uniqueCommands(input.recommendedCommands),
+        blockers: input.blockers ?? [],
+        warnings: input.warnings ?? [],
+        gaps: input.gaps ?? [],
+        verification_plan_id: input.verificationPlanId ?? null,
+    };
+}
+function uniqueCommands(commands) {
+    return [...new Set(commands.filter((command) => command.length > 0))];
+}
+function selectedIntents(report) {
+    return report.schedule.entries.map((entry) => entry.intent);
+}
+function toNextGap(gap) {
+    return {
+        reason: gap.reason,
+        files: gap.files,
+        surfaces: gap.surfaces,
+        detail: gap.detail,
+    };
+}
+function runnableIntentCommand(mustflowRoot, contract, intentName) {
+    const rawIntent = contract.intents[intentName];
+    if (!isRecord(rawIntent)) {
+        return null;
+    }
+    return createRunPlan(mustflowRoot, contract, intentName).ok ? `mf run ${intentName}` : null;
+}
+function fallbackCommands(mustflowRoot, contract) {
+    return [
+        'mf api verification-plan --changed --json',
+        'mf onboard commands',
+        runnableIntentCommand(mustflowRoot, contract, 'mustflow_check') ?? '',
+    ];
+}
+function createChangedOutput(mustflowRoot, contract, classification, report) {
+    const intents = selectedIntents(report);
+    const gaps = report.gaps.map(toNextGap);
+    const verificationPlanId = createVerificationPlanId(report, contract);
+    const state = createState({
+        installed: true,
+        check_ok: true,
+        command_contract_ok: true,
+        git_status: 'available',
+        changed_file_count: classification.summary.fileCount,
+        validation_reasons: classification.summary.validationReasons,
+        selected_intents: intents,
+        gap_count: gaps.length,
+    });
+    if (gaps.length > 0) {
+        const detail = gaps[0]?.detail ?? 'At least one changed-file requirement has no runnable configured command.';
+        return toOutput({
+            mustflowRoot,
+            status: 'blocked',
+            state,
+            decision: action('configure_commands', 'mf onboard commands', 'Review command-contract gaps', `${detail} Do not guess package-manager commands directly.`),
+            recommendedCommands: [...fallbackCommands(mustflowRoot, contract), ...(intents.length > 0 ? ['mf verify --changed --json'] : [])],
+            blockers: gaps.map((gap) => gap.detail),
+            gaps,
+            verificationPlanId,
+        });
+    }
+    if (intents.length > 0) {
+        return toOutput({
+            mustflowRoot,
+            status: 'needs_verification',
+            state,
+            decision: action('verify', 'mf verify --changed --json', 'Run configured verification', 'Changed files have runnable configured verification intents. Use mustflow verification instead of direct commands.'),
+            recommendedCommands: ['mf api verification-plan --changed --json', 'mf verify --changed --json'],
+            verificationPlanId,
+        });
+    }
+    return toOutput({
+        mustflowRoot,
+        status: 'idle',
+        state,
+        decision: action('inspect', 'mf api verification-plan --changed --json', 'Inspect verification plan', 'No runnable verification entries were selected.'),
+        recommendedCommands: ['mf api verification-plan --changed --json'],
+        verificationPlanId,
+    });
+}
+function createNextOutput() {
+    const mustflowRoot = resolveMustflowRoot();
+    const context = getAgentContext(mustflowRoot);
+    const check = checkMustflowProjectReport(mustflowRoot, { strict: false });
+    if (!context.installed) {
+        return toOutput({
+            mustflowRoot,
+            status: 'setup_required',
+            state: createState({ installed: false, check_ok: false, command_contract_ok: false }),
+            decision: action('setup', 'mf init --dry-run', 'Install mustflow workflow', 'This root does not have a complete mustflow installation yet.'),
+            recommendedCommands: ['mf init --dry-run', 'mf init --yes'],
+            blockers: ['mustflow is not installed in this root'],
+        });
+    }
+    if (check.issues.length > 0) {
+        return toOutput({
+            mustflowRoot,
+            status: 'blocked',
+            state: createState({
+                installed: true,
+                check_ok: false,
+                command_contract_ok: context.command_contract.exists,
+            }),
+            decision: action('repair', 'mf check --strict', 'Fix mustflow contract issues', 'The installed workflow has validation issues; inspect those before choosing verification.'),
+            recommendedCommands: ['mf check --strict', 'mf status --json', 'mf update --dry-run'],
+            blockers: check.issues,
+            warnings: check.warnings,
+        });
+    }
+    let contract;
+    try {
+        contract = readCommandContract(mustflowRoot);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return toOutput({
+            mustflowRoot,
+            status: 'blocked',
+            state: createState({ installed: true, check_ok: true, command_contract_ok: false }),
+            decision: action('repair', 'mf check --strict', 'Repair command contract', 'The command contract could not be read.'),
+            recommendedCommands: ['mf check --strict', 'mf doctor --json'],
+            blockers: [message],
+        });
+    }
+    let classification;
+    try {
+        classification = createClassifyOutput(mustflowRoot, 'changed', []);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return toOutput({
+            mustflowRoot,
+            status: 'unavailable',
+            state: createState({ installed: true, check_ok: true, command_contract_ok: true }),
+            decision: action('inspect', 'mf doctor --json', 'Inspect repository state', 'Changed-file detection is unavailable.'),
+            recommendedCommands: ['mf doctor --json', 'mf context --json'],
+            warnings: [message],
+        });
+    }
+    if (classification.summary.fileCount === 0) {
+        return toOutput({
+            mustflowRoot,
+            status: 'idle',
+            state: createState({
+                installed: true,
+                check_ok: true,
+                command_contract_ok: true,
+                git_status: 'available',
+                changed_file_count: 0,
+            }),
+            decision: action('none', null, 'No changed files', 'There is no changed-file verification to select.'),
+            recommendedCommands: ['mf doctor --json', 'mf context --json'],
+        });
+    }
+    try {
+        const report = createChangeVerificationReport(classification, contract, mustflowRoot);
+        return createChangedOutput(mustflowRoot, contract, classification, report);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return toOutput({
+            mustflowRoot,
+            status: 'unavailable',
+            state: createState({
+                installed: true,
+                check_ok: true,
+                command_contract_ok: true,
+                git_status: 'available',
+                changed_file_count: classification.summary.fileCount,
+                validation_reasons: classification.summary.validationReasons,
+            }),
+            decision: action('inspect', 'mf api verification-plan --changed --json', 'Inspect verification plan', 'Verification planning could not be summarized.'),
+            recommendedCommands: ['mf api verification-plan --changed --json', 'mf doctor --json'],
+            warnings: [message],
+        });
+    }
+}
+function renderList(values, lang) {
+    return values.length > 0 ? values.join(', ') : t(lang, 'value.none');
+}
+function renderNextOutput(output, lang) {
+    const lines = [
+        t(lang, 'next.title'),
+        `${t(lang, 'label.mustflowRoot')}: ${output.mustflow_root}`,
+        `${t(lang, 'next.label.status')}: ${output.status}`,
+        `${t(lang, 'next.label.nextAction')}: ${output.decision.command ?? t(lang, 'value.none')}`,
+        `${t(lang, 'next.label.reason')}: ${output.decision.detail}`,
+        `${t(lang, 'label.changedFiles')}: ${output.state.changed_file_count ?? t(lang, 'value.none')}`,
+        `${t(lang, 'classify.label.validationReasons')}: ${renderList(output.state.validation_reasons, lang)}`,
+        `${t(lang, 'next.label.selectedIntents')}: ${renderList(output.state.selected_intents, lang)}`,
+        `${t(lang, 'next.label.gaps')}: ${output.gaps.length}`,
+    ];
+    if (output.gaps.length > 0) {
+        lines.push('', t(lang, 'next.section.gaps'));
+        for (const gap of output.gaps) {
+            lines.push(`- ${gap.reason}: ${gap.detail}`);
+        }
+    }
+    if (output.blockers.length > 0) {
+        lines.push('', t(lang, 'next.section.blockers'));
+        for (const blocker of output.blockers) {
+            lines.push(`- ${blocker}`);
+        }
+    }
+    if (output.warnings.length > 0) {
+        lines.push('', t(lang, 'next.section.warnings'));
+        for (const warning of output.warnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    lines.push('', t(lang, 'next.section.commands'));
+    for (const command of output.recommended_commands) {
+        lines.push(`- ${command}`);
+    }
+    lines.push('', t(lang, 'update.plan.noFilesWritten'));
+    return lines.join('\n');
+}
+export function runNext(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getNextHelp(lang));
+        return 0;
+    }
+    const options = parseCliOptions(args, NEXT_OPTIONS);
+    if (options.error) {
+        printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf next --help', getNextHelp(lang), lang);
+        return 1;
+    }
+    const output = createNextOutput();
+    if (hasParsedCliOption(options, '--json')) {
+        reporter.stdout(JSON.stringify(output, null, 2));
+    }
+    else {
+        reporter.stdout(renderNextOutput(output, lang));
+    }
+    return output.status === 'unavailable' ? 1 : 0;
+}