mustflow 1.18.16 → 1.31.0

package/dist/cli/commands/run.js

@@ -1,38 +1,24 @@
-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 { 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 { runVersionSources } from './version-sources.js';
+import { spawn, spawnSync } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
 import { canRunMustflowBuiltinInProcess, isMustflowBinName } from '../../core/command-classification.js';
-import { resolveSafeProjectCwd } from '../../core/command-cwd.js';
-import { evaluateCommandIntentEligibility } from '../../core/command-intent-eligibility.js';
+import { createCommandEnv } from '../../core/command-env.js';
+import { BoundedOutputBuffer } from '../../core/bounded-output.js';
 import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
-import { isRecord, readCommandContract, readMustflowConfigIfExists, readPositiveInteger, readString, readStringArray, } from '../../core/config-loading.js';
+import { readCommandContract, readMustflowConfigIfExists } 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 { createRunPlan, createRunPreview, isMustflowBuiltinIntent, renderRunPreviewText, } from '../lib/run-plan.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);
-}
+import { recordRunPerformanceHistory } from '../../core/run-performance-history.js';
+import { RunProfiler } from '../../core/run-profile.js';
+import { finishRunWriteTracking, startRunWriteTracking } from '../../core/run-write-drift.js';
 function emitOutput(reporter, output, stream) {
     if (!output) {
         return;
     }
-    const text = output.toString().trimEnd();
+    const text = (typeof output === 'object' && 'tail' in output ? output.tail : output.toString()).trimEnd();
     if (text.length === 0) {
         return;
     }
@@ -64,57 +50,6 @@ function terminateProcessTree(pid) {
 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 = [];
@@ -152,37 +87,37 @@ async function runKnownBuiltinCommand(args, reporter, lang) {
         return undefined;
     }
     if (command === 'check') {
-        return runCheck(commandArgs, reporter, lang);
+        return (await import('./check.js')).runCheck(commandArgs, reporter, lang);
     }
     if (command === 'classify') {
-        return runClassify(commandArgs, reporter, lang);
+        return (await import('./classify.js')).runClassify(commandArgs, reporter, lang);
     }
     if (command === 'context') {
-        return runContext(commandArgs, reporter, lang);
+        return (await import('./context.js')).runContext(commandArgs, reporter, lang);
     }
     if (command === 'doctor') {
-        return runDoctor(commandArgs, reporter, lang);
+        return (await import('./doctor.js')).runDoctor(commandArgs, reporter, lang);
     }
     if (command === 'help') {
-        return runHelp(commandArgs, reporter, lang);
+        return (await import('./help.js')).runHelp(commandArgs, reporter, lang);
     }
     if (command === 'impact') {
-        return runImpact(commandArgs, reporter, lang);
+        return (await import('./impact.js')).runImpact(commandArgs, reporter, lang);
     }
     if (command === 'line-endings') {
-        return runLineEndings(commandArgs, reporter, lang);
+        return (await import('./line-endings.js')).runLineEndings(commandArgs, reporter, lang);
     }
     if (command === 'map') {
-        return runMap(commandArgs, reporter, lang);
+        return (await import('./map.js')).runMap(commandArgs, reporter, lang);
     }
     if (command === 'status') {
-        return runStatus(commandArgs, reporter, lang);
+        return (await import('./status.js')).runStatus(commandArgs, reporter, lang);
     }
     if (command === 'update') {
-        return runUpdate(commandArgs, reporter, lang);
+        return (await import('./update.js')).runUpdate(commandArgs, reporter, lang);
     }
     if (command === 'version-sources') {
-        return runVersionSources(commandArgs, reporter, lang);
+        return (await import('./version-sources.js')).runVersionSources(commandArgs, reporter, lang);
     }
     return undefined;
 }
@@ -237,6 +172,76 @@ function runArgvCommand(command, cwd, maxOutputBytes, env, timeoutSeconds) {
         windowsHide: true,
     });
 }
+function writeStreamChunk(reporter, stream, chunk) {
+    if (stream === 'stdout') {
+        if (reporter.writeStdout) {
+            reporter.writeStdout(chunk);
+            return;
+        }
+        reporter.stdout(chunk.toString().trimEnd());
+        return;
+    }
+    if (reporter.writeStderr) {
+        reporter.writeStderr(chunk);
+        return;
+    }
+    reporter.stderr(chunk.toString().trimEnd());
+}
+function runArgvCommandStreaming(command, cwd, env, timeoutSeconds, stdoutTailBytes, stderrTailBytes, reporter) {
+    return new Promise((resolve) => {
+        const stdout = new BoundedOutputBuffer(stdoutTailBytes);
+        const stderr = new BoundedOutputBuffer(stderrTailBytes);
+        let settled = false;
+        let timedOut = false;
+        let childError;
+        let childPid;
+        let timeout;
+        const child = spawn(command?.executable ?? '', command?.args ?? [], {
+            cwd,
+            env,
+            shell: command?.shell ?? false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            detached: process.platform !== 'win32',
+        });
+        childPid = child.pid;
+        const finish = (status, signal) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            resolve({
+                status,
+                signal,
+                error: timedOut ? Object.assign(new Error('Command timed out'), { code: 'ETIMEDOUT' }) : childError,
+                stdout: stdout.toSnapshot(),
+                stderr: stderr.toSnapshot(),
+                pid: childPid,
+            });
+        };
+        child.stdout?.on('data', (chunk) => {
+            stdout.append(chunk);
+            writeStreamChunk(reporter, 'stdout', chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr.append(chunk);
+            writeStreamChunk(reporter, 'stderr', chunk);
+        });
+        child.once('error', (error) => {
+            childError = error;
+        });
+        child.once('close', (status, signal) => {
+            finish(status, signal);
+        });
+        timeout = setTimeout(() => {
+            timedOut = true;
+            terminateProcessTree(childPid);
+        }, timeoutSeconds * 1000);
+    });
+}
 function runShellCommand(command, cwd, maxOutputBytes, env, timeoutSeconds) {
     return spawnSync(command ?? '', {
         cwd,
@@ -250,6 +255,61 @@ function runShellCommand(command, cwd, maxOutputBytes, env, timeoutSeconds) {
         windowsHide: true,
     });
 }
+function runShellCommandStreaming(command, cwd, env, timeoutSeconds, stdoutTailBytes, stderrTailBytes, reporter) {
+    return new Promise((resolve) => {
+        const stdout = new BoundedOutputBuffer(stdoutTailBytes);
+        const stderr = new BoundedOutputBuffer(stderrTailBytes);
+        let settled = false;
+        let timedOut = false;
+        let childError;
+        let childPid;
+        let timeout;
+        const child = spawn(command ?? '', {
+            cwd,
+            env,
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            detached: process.platform !== 'win32',
+        });
+        childPid = child.pid;
+        const finish = (status, signal) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            resolve({
+                status,
+                signal,
+                error: timedOut ? Object.assign(new Error('Command timed out'), { code: 'ETIMEDOUT' }) : childError,
+                stdout: stdout.toSnapshot(),
+                stderr: stderr.toSnapshot(),
+                pid: childPid,
+            });
+        };
+        child.stdout?.on('data', (chunk) => {
+            stdout.append(chunk);
+            writeStreamChunk(reporter, 'stdout', chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr.append(chunk);
+            writeStreamChunk(reporter, 'stderr', chunk);
+        });
+        child.once('error', (error) => {
+            childError = error;
+        });
+        child.once('close', (status, signal) => {
+            finish(status, signal);
+        });
+        timeout = setTimeout(() => {
+            timedOut = true;
+            terminateProcessTree(childPid);
+        }, timeoutSeconds * 1000);
+    });
+}
 function getRunStatus(error, exitCode, successExitCodes) {
     const errorWithCode = error;
     if (errorWithCode?.code === 'ETIMEDOUT') {
@@ -260,15 +320,66 @@ function getRunStatus(error, exitCode, successExitCodes) {
     }
     return exitCode !== null && successExitCodes.includes(exitCode) ? 'passed' : 'failed';
 }
+function getRunPlanDetail(plan, lang, fallbackKey) {
+    return plan.detail ?? t(lang, fallbackKey);
+}
+function reportRunPlanFailure(plan, reporter, lang) {
+    let message;
+    switch (plan.reasonCode) {
+        case 'status_not_configured':
+            message = t(lang, 'run.error.statusNotConfigured', { intent: plan.intentName, status: plan.intentStatus ?? 'unknown' });
+            break;
+        case 'lifecycle_not_oneshot':
+            message = t(lang, 'run.error.lifecycleNotOneshot', { intent: plan.intentName, lifecycle: plan.lifecycle ?? 'unknown' });
+            break;
+        case 'run_policy_not_agent_allowed':
+            message = t(lang, 'run.error.runPolicy', { intent: plan.intentName });
+            break;
+        case 'stdin_not_closed':
+            message = t(lang, 'run.error.stdin', { intent: plan.intentName });
+            break;
+        case 'missing_timeout':
+            message = t(lang, 'run.error.timeout', { intent: plan.intentName });
+            break;
+        case 'missing_command_source':
+            message = t(lang, 'run.error.commandSource', { intent: plan.intentName });
+            break;
+        case 'unsafe_intent_name':
+            message = t(lang, 'run.error.unsafeIntent', {
+                intent: plan.intentName,
+                detail: getRunPlanDetail(plan, lang, 'run.error.unsafeIntentDetail'),
+            });
+            break;
+        case 'blocked_shell_background_pattern':
+            message = t(lang, 'run.error.blockedShellBackground', {
+                intent: plan.intentName,
+                detail: getRunPlanDetail(plan, lang, 'run.error.blockedShellBackgroundDetail'),
+            });
+            break;
+        case 'cwd_outside_project':
+            message = t(lang, 'run.error.cwdOutsideProject', {
+                intent: plan.intentName,
+                detail: getRunPlanDetail(plan, lang, 'run.error.cwdOutsideProjectDetail'),
+            });
+            break;
+        case 'intent_not_table':
+        default:
+            message = t(lang, 'run.error.unknownIntent', { intent: plan.intentName });
+            break;
+    }
+    reporter.stderr(renderCliError(message, 'mf help commands', lang));
+}
 export function getRunHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf run <intent> [options]',
         summary: t(lang, 'run.help.summary'),
         options: [
+            { label: '--dry-run', description: t(lang, 'run.help.option.dryRun') },
+            { label: '--plan-only', description: t(lang, 'run.help.option.planOnly') },
             { 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'],
+        examples: ['mf run test', 'mf run lint --json', 'mf run mustflow_check --dry-run --json'],
         exitCodes: [
             {
                 label: '0',
@@ -288,18 +399,27 @@ export function getRunHelp(lang = 'en') {
  * invariant: Execution requires configured status, oneshot lifecycle, agent_allowed policy, and closed stdin.
  * risk: config, security, state
  */
-export async function runRun(args, reporter, lang = 'en') {
+export async function runRun(args, reporter, lang = 'en', options = {}) {
+    const executorStartedAtMs = performance.now();
+    const profiler = new RunProfiler();
     if (args.includes('--help') || args.includes('-h')) {
         reporter.stdout(getRunHelp(lang));
         return 0;
     }
-    const supportedOptions = new Set(['--json']);
+    const supportedOptions = new Set(['--json', '--dry-run', '--plan-only']);
     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 dryRun = args.includes('--dry-run');
+    const planOnly = args.includes('--plan-only');
+    const previewMode = dryRun ? 'dry-run' : planOnly ? 'plan-only' : null;
+    if (dryRun && planOnly) {
+        printUsageError(reporter, t(lang, 'run.error.conflictingPreviewModes'), 'mf run --help', getRunHelp(lang), lang);
+        return 1;
+    }
     const positional = args.filter((arg) => !supportedOptions.has(arg));
     const [intentName, ...extra] = positional;
     if (!intentName) {
@@ -310,121 +430,135 @@ export async function runRun(args, reporter, lang = 'en') {
         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));
+    const projectRoot = profiler.measure('root_detection', () => resolveMustflowRoot());
+    const contract = profiler.measure('command_contract', () => readCommandContract(projectRoot));
+    const plan = profiler.measure('plan_creation', () => createRunPlan(projectRoot, contract, intentName, { testTargets: options.testTargets }));
+    if (previewMode) {
+        profiler.measure('preview_render', () => {
+            if (json) {
+                reporter.stdout(JSON.stringify(createRunPreview(plan, previewMode), null, 2));
+            }
+            else {
+                reporter.stdout(renderRunPreviewText(plan, previewMode));
+            }
+        });
+        profiler.writeLatest({
+            projectRoot,
+            intent: intentName,
+            status: plan.ok ? 'previewed' : 'blocked',
+            previewMode,
+        });
+        return plan.ok ? 0 : 1;
+    }
+    if (!plan.ok) {
+        reportRunPlanFailure(plan, reporter, lang);
+        profiler.writeLatest({
+            projectRoot,
+            intent: intentName,
+            status: 'blocked',
+            previewMode: null,
+        });
         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;
+    const runReceiptPolicy = profiler.measure('retention_policy', () => resolveRunReceiptRetentionPolicy(readMustflowConfigIfExists(projectRoot)));
+    const env = profiler.measure('environment', () => createCommandEnv(projectRoot, { policy: plan.envPolicy, allowlist: plan.envAllowlist }));
+    const lifecycleValue = plan.lifecycle ?? 'oneshot';
+    const runPolicyValue = plan.runPolicy ?? 'agent_allowed';
+    const writeTracker = profiler.measure('write_drift_before', () => startRunWriteTracking(projectRoot, contract, intentName));
+    const stdoutTailBytes = Math.min(runReceiptPolicy.stdoutTailBytes, plan.maxOutputBytes);
+    const stderrTailBytes = Math.min(runReceiptPolicy.stderrTailBytes, plan.maxOutputBytes);
+    let streamedOutput = false;
+    const childStartedAtMs = performance.now();
+    const startedAt = new Date();
+    const result = await profiler.measureAsync('child_command', async () => {
+        if (plan.commandArgv && isMustflowBuiltinIntent(plan.intent)) {
+            const builtinResult = await runBuiltinArgvInProcess(plan.commandArgv, plan.cwd, lang);
+            if (builtinResult) {
+                return builtinResult;
+            }
         }
-        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 (plan.commandArgv) {
+            if (!json) {
+                streamedOutput = true;
+                return runArgvCommandStreaming(plan.argvCommand, plan.cwd, env, plan.timeoutSeconds, stdoutTailBytes, stderrTailBytes, reporter);
+            }
+            return runArgvCommand(plan.argvCommand, plan.cwd, plan.maxOutputBytes, env, plan.timeoutSeconds);
         }
-        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;
+        if (!json) {
+            streamedOutput = true;
+            return runShellCommandStreaming(plan.shellCommand, plan.cwd, env, plan.timeoutSeconds, stdoutTailBytes, stderrTailBytes, reporter);
         }
-        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)
-        ? ((await runBuiltinArgvInProcess(commandArgv, cwd, lang)) ??
-            runArgvCommand(argvCommand, cwd, maxOutputBytes, env, timeoutSeconds))
-        : commandArgv
-            ? runArgvCommand(argvCommand, cwd, maxOutputBytes, env, timeoutSeconds)
-            : runShellCommand(shellCommand, cwd, maxOutputBytes, env, timeoutSeconds);
+        return runShellCommand(plan.shellCommand, plan.cwd, plan.maxOutputBytes, env, plan.timeoutSeconds);
+    });
+    const childDurationMs = performance.now() - childStartedAtMs;
     const finishedAt = new Date();
+    const writeDrift = profiler.measure('write_drift_after', () => finishRunWriteTracking(writeTracker));
     const exitCode = typeof result.status === 'number' ? result.status : null;
-    const runStatus = getRunStatus(result.error, exitCode, successExitCodes);
+    const runStatus = getRunStatus(result.error, exitCode, plan.successExitCodes);
     let killMethod = null;
     if (runStatus === 'timed_out') {
         killMethod = getKillMethod();
         terminateProcessTree(result.pid);
     }
-    const receipt = createRunReceipt({
+    const receipt = profiler.measure('receipt_create', () => createRunReceipt({
         intent: intentName,
         status: runStatus,
         timedOut: runStatus === 'timed_out',
         startedAt,
         finishedAt,
         projectRoot,
-        cwd,
+        cwd: plan.cwd,
         lifecycle: lifecycleValue,
         runPolicy: runPolicyValue,
-        mode,
-        argv: commandArgv,
-        cmd: shellCommand,
-        timeoutSeconds,
-        maxOutputBytes,
-        successExitCodes,
+        mode: plan.mode,
+        argv: plan.commandArgv,
+        cmd: plan.shellCommand,
+        envPolicy: plan.envPolicy,
+        envAllowlist: plan.envAllowlist,
+        timeoutSeconds: plan.timeoutSeconds,
+        maxOutputBytes: plan.maxOutputBytes,
+        successExitCodes: plan.successExitCodes,
         exitCode,
         signal: result.signal,
         error: result.error?.message ?? null,
         killMethod,
         stdout: result.stdout,
         stderr: result.stderr,
+        writeDrift,
+        executorOverheadMs: Math.max(0, Math.round((performance.now() - executorStartedAtMs - childDurationMs) * 1000) / 1000),
+        phaseTimings: profiler.getReceiptPhases(),
+        selectionSummary: {
+            strategy: plan.testTargets.length > 0 ? 'project_test_selection' : 'direct_intent',
+            changed_file_count: 0,
+            changed_surface_counts: {},
+            selected_target_count: Math.max(1, plan.testTargets.length),
+            fallback_used: false,
+        },
         stdoutTailBytes: runReceiptPolicy.stdoutTailBytes,
         stderrTailBytes: runReceiptPolicy.stderrTailBytes,
+    }));
+    if (options.writeLatestReceipt !== false) {
+        profiler.measure('receipt_write', () => writeRunReceipt(projectRoot, receipt));
+    }
+    profiler.measure('performance_history_write', () => recordRunPerformanceHistory(projectRoot, receipt));
+    profiler.writeLatest({
+        projectRoot,
+        intent: intentName,
+        status: runStatus,
+        previewMode: null,
     });
-    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 (!streamedOutput) {
+        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 }));
+            reporter.stderr(t(lang, 'run.error.timedOut', { intent: intentName, seconds: plan.timeoutSeconds }));
             return 1;
         }
         reporter.stderr(t(lang, 'run.error.startFailed', { intent: intentName, message: result.error.message }));