mustflow 1.15.97

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

@@ -0,0 +1,102 @@
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { inspectLineEndings } from '../../core/line-endings.js';
+export function getLineEndingsHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf line-endings <check|normalize> [options]',
+        summary: t(lang, 'lineEndings.help.summary'),
+        options: [
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '--all', description: t(lang, 'lineEndings.help.option.all') },
+            { label: '--dry-run', description: t(lang, 'lineEndings.help.option.dryRun') },
+            { label: '--apply', description: t(lang, 'lineEndings.help.option.apply') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf line-endings check',
+            'mf line-endings normalize --dry-run',
+            'mf line-endings normalize --apply',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'lineEndings.help.exit.ok') },
+            { label: '1', description: t(lang, 'lineEndings.help.exit.fail') },
+        ],
+    }, lang);
+}
+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));
+    if (action !== 'check' && action !== 'normalize') {
+        return {
+            action: 'check',
+            json,
+            apply,
+            dryRun,
+            all,
+            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 (action === 'check' && (apply || dryRun)) {
+        return { action, json, apply, dryRun, all, error: t(lang, 'lineEndings.error.checkModeOption') };
+    }
+    if (action === 'normalize' && apply && dryRun) {
+        return { action, json, apply, dryRun, all, error: t(lang, 'lineEndings.error.conflictingModes') };
+    }
+    return { action, json, apply, dryRun, all };
+}
+function renderLineEndingSummary(report, lang) {
+    const lines = [
+        t(lang, 'lineEndings.title'),
+        `${t(lang, 'label.mode')}: ${report.mode}`,
+        `${t(lang, 'label.scope')}: ${report.scope}`,
+        `${t(lang, 'lineEndings.label.policy')}: ${report.policy}`,
+        `${t(lang, 'lineEndings.label.checkedFiles')}: ${report.checked_files}`,
+        `${t(lang, 'lineEndings.label.nonCompliantFiles')}: ${report.non_compliant_files.length}`,
+        `${t(lang, 'label.wroteFiles')}: ${report.wrote_files ? t(lang, 'value.yes') : t(lang, 'value.no')}`,
+    ];
+    if (report.issues.length > 0) {
+        lines.push(t(lang, 'lineEndings.label.issues'), ...report.issues.map((issue) => `- ${issue}`));
+    }
+    if (report.non_compliant_files.length > 0) {
+        lines.push(t(lang, 'lineEndings.label.files'));
+        for (const file of report.non_compliant_files) {
+            const action = file.changed ? t(lang, 'lineEndings.value.changed') : t(lang, 'lineEndings.value.wouldChange');
+            lines.push(`- ${file.path} [${file.lineEnding}] ${action}`);
+        }
+    }
+    if (report.non_compliant_files.length === 0 && report.issues.length === 0) {
+        lines.push(t(lang, 'lineEndings.clean'));
+    }
+    return lines.join('\n');
+}
+export function runLineEndings(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getLineEndingsHelp(lang));
+        return 0;
+    }
+    const options = parseLineEndingOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf line-endings --help', getLineEndingsHelp(lang), lang);
+        return 1;
+    }
+    const mode = options.action === 'check' ? 'check' : 'normalize';
+    const report = inspectLineEndings(resolveMustflowRoot(), mode, {
+        apply: options.action === 'normalize' && options.apply,
+        scope: options.all ? 'tracked' : 'changed',
+    });
+    if (options.json) {
+        reporter.stdout(JSON.stringify(report, null, 2));
+        return report.ok ? 0 : 1;
+    }
+    reporter.stdout(renderLineEndingSummary(report, lang));
+    return report.ok ? 0 : 1;
+}

package/dist/cli/commands/map.js

@@ -0,0 +1,95 @@
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { generateRepoMap, writeRepoMap } from '../lib/repo-map.js';
+export function getMapHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf map [options]',
+        summary: t(lang, 'map.help.summary'),
+        options: [
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+            { label: '--stdout', description: t(lang, 'map.help.option.stdout') },
+            { label: '--write', description: t(lang, 'map.help.option.write') },
+            {
+                label: '--depth <level>',
+                description: t(lang, 'map.help.option.depth'),
+            },
+            {
+                label: '--include-nested',
+                description: t(lang, 'map.help.option.includeNested'),
+            },
+            {
+                label: '--root-only',
+                description: t(lang, 'map.help.option.rootOnly'),
+            },
+        ],
+        examples: ['mf map --stdout', 'mf map --write', 'mf map --write --include-nested'],
+        exitCodes: [
+            { label: '0', description: t(lang, 'map.help.exit.ok') },
+            { label: '1', description: t(lang, 'cli.common.invalidInput') },
+        ],
+    }, lang);
+}
+export function runMap(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getMapHelp(lang));
+        return 0;
+    }
+    let shouldPrint = false;
+    let shouldWrite = false;
+    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);
+        return 1;
+    }
+    if (!shouldPrint && !shouldWrite) {
+        shouldPrint = true;
+    }
+    const projectRoot = resolveMustflowRoot();
+    const content = generateRepoMap(projectRoot, { depth, includeNested });
+    if (shouldWrite) {
+        writeRepoMap(projectRoot, content);
+        reporter.stdout(t(lang, 'map.wrote'));
+    }
+    if (shouldPrint) {
+        reporter.stdout(content);
+    }
+    return 0;
+}

package/dist/cli/commands/run.js

@@ -0,0 +1,442 @@
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { runCheck } from './check.js';
+import { runClassify } from './classify.js';
+import { runContext } from './context.js';
+import { runDoctor } from './doctor.js';
+import { runExplain } from './explain.js';
+import { runHelp } from './help.js';
+import { runImpact } from './impact.js';
+import { runLineEndings } from './line-endings.js';
+import { runMap } from './map.js';
+import { runStatus } from './status.js';
+import { runUpdate } from './update.js';
+import { runVerify } from './verify.js';
+import { runVersionSources } from './version-sources.js';
+import { canRunMustflowBuiltinInProcess, isMustflowBinName } from '../../core/command-classification.js';
+import { resolveSafeProjectCwd } from '../../core/command-cwd.js';
+import { evaluateCommandIntentEligibility } from '../../core/command-intent-eligibility.js';
+import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
+import { isRecord, readCommandContract, readMustflowConfigIfExists, readPositiveInteger, readString, readStringArray, } from '../../core/config-loading.js';
+import { resolveRunReceiptRetentionPolicy } from '../../core/retention-policy.js';
+import { t } from '../lib/i18n.js';
+import { getPackageVersion } from '../lib/package-info.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { createRunReceipt, writeRunReceipt } from '../../core/run-receipt.js';
+function getSuccessExitCodes(intent) {
+    const value = intent.success_exit_codes;
+    if (!Array.isArray(value) || value.length === 0 || value.some((entry) => !Number.isInteger(entry))) {
+        return [0];
+    }
+    return value.map(Number);
+}
+function emitOutput(reporter, output, stream) {
+    if (!output) {
+        return;
+    }
+    const text = output.toString().trimEnd();
+    if (text.length === 0) {
+        return;
+    }
+    reporter[stream](text);
+}
+function terminateProcessTree(pid) {
+    if (!pid || pid <= 0) {
+        return;
+    }
+    if (process.platform === 'win32') {
+        spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], {
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        return;
+    }
+    try {
+        process.kill(-pid, 'SIGTERM');
+    }
+    catch {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            // The child may already be gone after Node's spawn timeout handling.
+        }
+    }
+}
+function getKillMethod() {
+    return process.platform === 'win32' ? 'taskkill_process_tree' : 'process_group_sigterm';
+}
+function getPathEnvKey(env) {
+    return Object.keys(env).find((key) => key.toLowerCase() === 'path') ?? 'PATH';
+}
+function sameResolvedPath(left, right) {
+    const resolvedLeft = path.resolve(left);
+    const resolvedRight = path.resolve(right);
+    return process.platform === 'win32'
+        ? resolvedLeft.toLowerCase() === resolvedRight.toLowerCase()
+        : resolvedLeft === resolvedRight;
+}
+function createCommandEnv(projectRoot) {
+    const env = { ...process.env };
+    const pathKey = getPathEnvKey(env);
+    const localBinPath = path.join(projectRoot, 'node_modules', '.bin');
+    const currentPath = env[pathKey];
+    if (currentPath) {
+        env[pathKey] = currentPath
+            .split(path.delimiter)
+            .filter((entry) => entry.length > 0 && !sameResolvedPath(entry, localBinPath))
+            .join(path.delimiter);
+    }
+    return env;
+}
+function shouldUseShellForArgvExecutable(executablePath) {
+    return process.platform === 'win32' && executablePath.toLowerCase().endsWith('.cmd');
+}
+function isMustflowBuiltinIntent(intent) {
+    return readString(intent, 'kind') === 'mustflow_builtin';
+}
+function resolveCurrentCliEntrypoint() {
+    const entrypoint = process.argv[1];
+    return entrypoint ? path.resolve(entrypoint) : undefined;
+}
+function resolveArgvCommand(intent, commandArgv) {
+    const [command = '', ...args] = commandArgv;
+    if (isMustflowBuiltinIntent(intent) && isMustflowBinName(command)) {
+        const entrypoint = resolveCurrentCliEntrypoint();
+        if (entrypoint) {
+            return {
+                executable: process.execPath,
+                args: [entrypoint, ...args],
+                shell: false,
+            };
+        }
+    }
+    return {
+        executable: command,
+        args,
+        shell: shouldUseShellForArgvExecutable(command),
+    };
+}
+function createBufferedReporter() {
+    const stdout = [];
+    const stderr = [];
+    return {
+        reporter: {
+            stdout(message) {
+                stdout.push(`${message}\n`);
+            },
+            stderr(message) {
+                stderr.push(`${message}\n`);
+            },
+        },
+        stdout() {
+            return stdout.join('');
+        },
+        stderr() {
+            return stderr.join('');
+        },
+    };
+}
+/**
+ * mf:anchor cli.run.builtin-inprocess
+ * purpose: Dispatch selected mustflow built-in commands without spawning a nested CLI process.
+ * search: builtin intent, in-process command, nested mf run, run receipt
+ * invariant: Only commands classified by command-classification can use this path.
+ * risk: config, state
+ */
+function runKnownBuiltinCommand(args, reporter, lang) {
+    const [command, ...commandArgs] = args;
+    if ((command === '--version' || command === '-v' || command === 'version') && commandArgs.length === 0) {
+        reporter.stdout(getPackageVersion());
+        return 0;
+    }
+    if (!canRunMustflowBuiltinInProcess(command)) {
+        return undefined;
+    }
+    if (command === 'check') {
+        return runCheck(commandArgs, reporter, lang);
+    }
+    if (command === 'classify') {
+        return runClassify(commandArgs, reporter, lang);
+    }
+    if (command === 'context') {
+        return runContext(commandArgs, reporter, lang);
+    }
+    if (command === 'doctor') {
+        return runDoctor(commandArgs, reporter, lang);
+    }
+    if (command === 'explain') {
+        return runExplain(commandArgs, reporter, lang);
+    }
+    if (command === 'help') {
+        return runHelp(commandArgs, reporter, lang);
+    }
+    if (command === 'impact') {
+        return runImpact(commandArgs, reporter, lang);
+    }
+    if (command === 'line-endings') {
+        return runLineEndings(commandArgs, reporter, lang);
+    }
+    if (command === 'map') {
+        return runMap(commandArgs, reporter, lang);
+    }
+    if (command === 'status') {
+        return runStatus(commandArgs, reporter, lang);
+    }
+    if (command === 'update') {
+        return runUpdate(commandArgs, reporter, lang);
+    }
+    if (command === 'version-sources') {
+        return runVersionSources(commandArgs, reporter, lang);
+    }
+    if (command === 'verify') {
+        return runVerify(commandArgs, reporter, lang);
+    }
+    return undefined;
+}
+function withWorkingDirectory(cwd, callback) {
+    const previousCwd = process.cwd();
+    process.chdir(cwd);
+    try {
+        return callback();
+    }
+    finally {
+        process.chdir(previousCwd);
+    }
+}
+function runBuiltinArgvInProcess(commandArgv, cwd, lang) {
+    const [command = '', ...builtinArgs] = commandArgv;
+    if (!isMustflowBinName(command)) {
+        return undefined;
+    }
+    const output = createBufferedReporter();
+    try {
+        const status = withWorkingDirectory(cwd, () => runKnownBuiltinCommand(builtinArgs, output.reporter, lang));
+        if (status === undefined) {
+            return undefined;
+        }
+        return {
+            status,
+            signal: null,
+            stdout: output.stdout(),
+            stderr: output.stderr(),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            status: 1,
+            signal: null,
+            stdout: output.stdout(),
+            stderr: `${output.stderr()}${message}\n`,
+        };
+    }
+}
+function runArgvCommand(command, cwd, maxOutputBytes, env, timeoutSeconds) {
+    return spawnSync(command?.executable ?? '', command?.args ?? [], {
+        cwd,
+        encoding: 'utf8',
+        input: '',
+        maxBuffer: maxOutputBytes,
+        env,
+        shell: command?.shell ?? false,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: timeoutSeconds * 1000,
+        windowsHide: true,
+    });
+}
+function runShellCommand(command, cwd, maxOutputBytes, env, timeoutSeconds) {
+    return spawnSync(command ?? '', {
+        cwd,
+        encoding: 'utf8',
+        input: '',
+        maxBuffer: maxOutputBytes,
+        env,
+        shell: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: timeoutSeconds * 1000,
+        windowsHide: true,
+    });
+}
+function getRunStatus(error, exitCode, successExitCodes) {
+    const errorWithCode = error;
+    if (errorWithCode?.code === 'ETIMEDOUT') {
+        return 'timed_out';
+    }
+    if (error) {
+        return 'start_failed';
+    }
+    return exitCode !== null && successExitCodes.includes(exitCode) ? 'passed' : 'failed';
+}
+export function getRunHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf run <intent> [options]',
+        summary: t(lang, 'run.help.summary'),
+        options: [
+            { label: '--json', description: t(lang, 'run.help.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: ['mf run test', 'mf run lint --json', 'mf run mustflow_check'],
+        exitCodes: [
+            {
+                label: '0',
+                description: t(lang, 'run.help.exit.ok'),
+            },
+            {
+                label: '1',
+                description: t(lang, 'run.help.exit.fail'),
+            },
+        ],
+    }, lang);
+}
+/**
+ * mf:anchor cli.run.intent-contract
+ * purpose: Enforce command intent eligibility before executing a configured oneshot command.
+ * search: command contract, agent_allowed, oneshot, stdin closed, timeout
+ * invariant: Execution requires configured status, oneshot lifecycle, agent_allowed policy, and closed stdin.
+ * risk: config, security, state
+ */
+export function runRun(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getRunHelp(lang));
+        return 0;
+    }
+    const supportedOptions = new Set(['--json']);
+    const unsupported = args.filter((arg) => arg.startsWith('-') && !supportedOptions.has(arg));
+    if (unsupported.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf run --help', getRunHelp(lang), lang);
+        return 1;
+    }
+    const json = args.includes('--json');
+    const positional = args.filter((arg) => !supportedOptions.has(arg));
+    const [intentName, ...extra] = positional;
+    if (!intentName) {
+        printUsageError(reporter, t(lang, 'run.error.missingIntent'), 'mf run --help', getRunHelp(lang), lang);
+        return 1;
+    }
+    if (extra.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: extra[0] }), 'mf run --help', getRunHelp(lang), lang);
+        return 1;
+    }
+    const projectRoot = resolveMustflowRoot();
+    const contract = readCommandContract(projectRoot);
+    const runReceiptPolicy = resolveRunReceiptRetentionPolicy(readMustflowConfigIfExists(projectRoot));
+    const intent = contract.intents[intentName];
+    if (!isRecord(intent)) {
+        reporter.stderr(renderCliError(t(lang, 'run.error.unknownIntent', { intent: intentName }), 'mf help commands', lang));
+        return 1;
+    }
+    const eligibility = evaluateCommandIntentEligibility(intentName, intent);
+    const intentStatus = readString(intent, 'status') ?? 'unknown';
+    const lifecycle = readString(intent, 'lifecycle');
+    const runPolicy = readString(intent, 'run_policy');
+    const timeoutSeconds = readPositiveInteger(intent, 'timeout_seconds');
+    if (!eligibility.ok) {
+        if (eligibility.code === 'status_not_configured') {
+            reporter.stderr(renderCliError(t(lang, 'run.error.statusNotConfigured', { intent: intentName, status: intentStatus }), 'mf help commands', lang));
+            return 1;
+        }
+        if (eligibility.code === 'lifecycle_not_oneshot') {
+            reporter.stderr(renderCliError(t(lang, 'run.error.lifecycleNotOneshot', { intent: intentName, lifecycle: lifecycle ?? 'unknown' }), 'mf help commands', lang));
+            return 1;
+        }
+        if (eligibility.code === 'run_policy_not_agent_allowed') {
+            reporter.stderr(renderCliError(t(lang, 'run.error.runPolicy', { intent: intentName }), 'mf help commands', lang));
+            return 1;
+        }
+        if (eligibility.code === 'stdin_not_closed') {
+            reporter.stderr(renderCliError(t(lang, 'run.error.stdin', { intent: intentName }), 'mf help commands', lang));
+            return 1;
+        }
+        if (eligibility.code === 'missing_timeout') {
+            reporter.stderr(renderCliError(t(lang, 'run.error.timeout', { intent: intentName }), 'mf help commands', lang));
+            return 1;
+        }
+        if (eligibility.code === 'missing_command_source') {
+            reporter.stderr(renderCliError(t(lang, 'run.error.commandSource', { intent: intentName }), 'mf help commands', lang));
+            return 1;
+        }
+        if (eligibility.code === 'unsafe_intent_name') {
+            reporter.stderr(renderCliError(`Intent ${intentName} has an unsafe name. ${eligibility.detail ?? 'Use a shell-safe intent name.'}`, 'mf help commands', lang));
+            return 1;
+        }
+        if (eligibility.code === 'blocked_shell_background_pattern') {
+            reporter.stderr(renderCliError(`Intent ${intentName} is blocked. ${eligibility.detail ?? 'Shell commands must not spawn background work.'}`, 'mf help commands', lang));
+            return 1;
+        }
+        reporter.stderr(renderCliError(t(lang, 'run.error.unknownIntent', { intent: intentName }), 'mf help commands', lang));
+        return 1;
+    }
+    const maxOutputBytes = readPositiveInteger(intent, 'max_output_bytes') ?? readPositiveInteger(contract.defaults, 'max_output_bytes') ?? 1_048_576;
+    if (!timeoutSeconds) {
+        reporter.stderr(renderCliError(t(lang, 'run.error.timeout', { intent: intentName }), 'mf help commands', lang));
+        return 1;
+    }
+    const cwd = resolveSafeProjectCwd(projectRoot, readString(intent, 'cwd') ?? readString(contract.defaults, 'default_cwd'));
+    const successExitCodes = getSuccessExitCodes(intent);
+    const argv = readStringArray(intent, 'argv');
+    const commandArgv = argv && argv.length > 0 ? argv : undefined;
+    const shellCommand = intent.mode === 'shell' ? readString(intent, 'cmd') : undefined;
+    const env = createCommandEnv(projectRoot);
+    const lifecycleValue = lifecycle ?? 'oneshot';
+    const runPolicyValue = runPolicy ?? 'agent_allowed';
+    const mode = commandArgv ? 'argv' : 'shell';
+    const startedAt = new Date();
+    const argvCommand = commandArgv ? resolveArgvCommand(intent, commandArgv) : undefined;
+    const result = commandArgv && isMustflowBuiltinIntent(intent)
+        ? (runBuiltinArgvInProcess(commandArgv, cwd, lang) ??
+            runArgvCommand(argvCommand, cwd, maxOutputBytes, env, timeoutSeconds))
+        : commandArgv
+            ? runArgvCommand(argvCommand, cwd, maxOutputBytes, env, timeoutSeconds)
+            : runShellCommand(shellCommand, cwd, maxOutputBytes, env, timeoutSeconds);
+    const finishedAt = new Date();
+    const exitCode = typeof result.status === 'number' ? result.status : null;
+    const runStatus = getRunStatus(result.error, exitCode, successExitCodes);
+    let killMethod = null;
+    if (runStatus === 'timed_out') {
+        killMethod = getKillMethod();
+        terminateProcessTree(result.pid);
+    }
+    const receipt = createRunReceipt({
+        intent: intentName,
+        status: runStatus,
+        timedOut: runStatus === 'timed_out',
+        startedAt,
+        finishedAt,
+        projectRoot,
+        cwd,
+        lifecycle: lifecycleValue,
+        runPolicy: runPolicyValue,
+        mode,
+        argv: commandArgv,
+        cmd: shellCommand,
+        timeoutSeconds,
+        maxOutputBytes,
+        successExitCodes,
+        exitCode,
+        signal: result.signal,
+        error: result.error?.message ?? null,
+        killMethod,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        stdoutTailBytes: runReceiptPolicy.stdoutTailBytes,
+        stderrTailBytes: runReceiptPolicy.stderrTailBytes,
+    });
+    writeRunReceipt(projectRoot, receipt);
+    if (json) {
+        reporter.stdout(JSON.stringify(receipt, null, 2));
+        return runStatus === 'passed' ? 0 : 1;
+    }
+    emitOutput(reporter, result.stdout, 'stdout');
+    emitOutput(reporter, result.stderr, 'stderr');
+    if (result.error) {
+        const errorWithCode = result.error;
+        if (errorWithCode.code === 'ETIMEDOUT') {
+            reporter.stderr(t(lang, 'run.error.timedOut', { intent: intentName, seconds: timeoutSeconds }));
+            return 1;
+        }
+        reporter.stderr(t(lang, 'run.error.startFailed', { intent: intentName, message: result.error.message }));
+        return 1;
+    }
+    return runStatus === 'passed' ? 0 : 1;
+}