@evalops/maestro 0.10.50 → 0.10.53

package/dist/main.js

@@ -86,38 +86,63 @@
  * @module main
  */
 import chalk from "chalk";
-import { applySessionStartHooks } from "./agent/session-start-hooks.js";
-import { ToolRetryService } from "./agent/tool-retry.js";
-import { PlatformBackedActionApprovalService } from "./approvals/platform-action-approval.js";
 import { createAuthSetup, validateCodexFlags } from "./bootstrap/auth-setup.js";
 import { disposeCheckpointService, initCheckpointService, } from "./checkpoints/index.js";
 import { parseArgs } from "./cli/args.js";
-import { EXEC_SESSION_SUMMARY_PREFIX } from "./cli/commands/exec-constants.js";
+import { isNativeUtilityCommand } from "./cli/direct-runtime-command.js";
 import { isHeadlessModeRequested, recordHeadlessRuntimeSelection, selectHeadlessRuntime, willDispatchHeadlessRuntime, } from "./cli/headless-runtime-selection.js";
 import { printHelp } from "./cli/help.js";
-import { detectRuntimeConstraintContext } from "./cli/system-prompt.js";
+import { buildNativeHostedRunnerArgs, launchNativeCli, launchNativeTui, shouldLaunchNativeHeadless, shouldLaunchNativeInteractiveTui, shouldLaunchNativePrint, } from "./cli/native-tui-launcher.js";
 import { validateFrameworkPreference } from "./config/framework.js";
-import { buildCliConfigOverrides, loadRuntimeConfig, } from "./config/runtime-config.js";
+import { loadRuntimeConfig, } from "./config/runtime-config.js";
 import { loadAndFinalizeEnv } from "./load-env.js";
 import { bootstrapLsp } from "./lsp/bootstrap.js";
-import { createLazyAutoMemoryCoordinators } from "./memory/lazy-auto-memory.js";
 import { ensureModelsLoaded } from "./models/builtin.js";
 import { reloadModelConfig } from "./models/registry.js";
 import { getPackageVersion } from "./package-metadata.js";
 import { setConfiguredPackageRuntimeContext } from "./packages/runtime.js";
-import { resolveMaestroSystemPrompt } from "./prompts/system-prompt.js";
 import { parseOptionalBoolean } from "./runtime/env.js";
 import { defaultSettings } from "./runtime/settings.js";
 import { configureSafeMode } from "./safety/safe-mode.js";
 import { beaconTimeoutMs } from "./telemetry/beacon.js";
 import { recordStagedRolloutSurfaceUsageLazy } from "./telemetry/staged-rollout-lazy.js";
 import { createStartupProfilerFromEnv } from "./utils/checkpoint-profiler.js";
-import { isInsideGitRepository } from "./utils/git.js";
 const VERSION = getPackageVersion();
 const STARTUP_TELEMETRY_EXIT_WAIT_GRACE_MS = 25;
 let enterpriseCleanupRegistered = false;
 let checkpointCleanupRegistered = false;
-let sandboxCleanupRegistered = false;
+const sandboxCleanupRegistered = false;
+async function cleanupNonInteractiveRuntimeResources() {
+    let timeout;
+    const timeoutPromise = new Promise((resolve) => {
+        timeout = setTimeout(() => resolve("timeout"), 5_000);
+    });
+    const cleanupPromise = (async () => {
+        try {
+            const [{ mcpManager }, { lspManager }] = await Promise.all([
+                import("./mcp/manager.js"),
+                import("./lsp/manager.js"),
+            ]);
+            await Promise.allSettled([
+                mcpManager.disconnectAll(),
+                lspManager.shutdownAll(),
+            ]);
+        }
+        catch {
+            // Best-effort shutdown must not mask the command's original result.
+        }
+        return "done";
+    })();
+    try {
+        await Promise.race([cleanupPromise, timeoutPromise]);
+    }
+    finally {
+        void cleanupPromise.catch(() => undefined);
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
 function isTruthyEnvFlag(value) {
     switch (value?.trim().toLowerCase()) {
         case "1":
@@ -184,17 +209,6 @@ async function captureStartupError(error) {
         // Startup error reporting is best-effort and must not mask the root error.
     }
 }
-async function printAllAgentModes() {
-    const { getAllModes, getModelForMode } = await import("./agent/modes.js");
-    const lines = ["Agent modes:", ""];
-    for (const { mode, config } of getAllModes({ includeHidden: true })) {
-        const hiddenSuffix = config.visible === false ? " [hidden]" : "";
-        lines.push(`${mode}${hiddenSuffix}`);
-        lines.push(`  ${config.description}`);
-        lines.push(`  model: ${getModelForMode(mode)}`);
-    }
-    console.log(lines.join("\n"));
-}
 function shouldRegisterBackgroundTaskShutdownHooks(command, parsedTools) {
     if (command !== "exec") {
         return true;
@@ -205,72 +219,81 @@ function shouldRegisterBackgroundTaskShutdownHooks(command, parsedTools) {
     return (parsedTools.includes("bash") || parsedTools.includes("background_tasks"));
 }
 /**
- * Runs the full interactive Terminal UI (TUI) mode.
- *
- * This is the primary user-facing mode when composer is invoked without
- * command-line messages. It provides:
- * - Real-time streaming of model responses
- * - Interactive input with readline and autocomplete
- * - Tool execution with approval prompts
- * - Session persistence and recovery
- * - View switching (chat, tools, sessions, etc.)
- *
- * The function sets up the TUI renderer, subscribes to agent events,
- * and runs the main input loop until the user exits.
- *
- * @param agent - Configured Agent instance for LLM communication
- * @param sessionManager - Handles session persistence and recovery
- * @param version - Current CLI version for display
- * @param approvalService - Controls tool execution approval behavior
- * @param explicitApiKey - API key from --api-key flag (for display purposes)
- * @param options - Additional startup configuration (model scope, changelog, etc.)
+ * Hand off interactive mode to the native maestro-tui binary (Rust agent).
+ * Forwards only flags maestro-tui accepts and propagates the child exit code.
  */
-async function runInteractiveMode(agent, sessionManager, version, approvalService, toolRetryService, explicitApiKey, options = {}, profileName, cliOverrides) {
-    // Redirect logs to file to avoid polluting the TUI
-    const { redirectLoggerToFile } = await import("./utils/logger.js");
-    redirectLoggerToFile();
-    let sessionEndReason = "user_exit";
+async function runNativeInteractiveMode(parsed, writeError) {
     try {
-        const { AgentRuntimeController } = await import("./runtime/agent-runtime.js");
-        const { TuiRenderer } = await import("./cli-tui/tui-renderer.js");
-        // Initialize the TUI renderer which manages all terminal output
-        const renderer = new TuiRenderer(agent, sessionManager, version, approvalService, toolRetryService, explicitApiKey, { ...options, profileName, cliOverrides });
-        const runtime = new AgentRuntimeController({
-            agent,
-            sessionManager,
-            renderer,
-            profileName,
-            cliOverrides,
-            onError: (error) => {
-                const message = error instanceof Error ? error.message : "Unknown error occurred";
-                renderer.showError(message);
+        const exitCode = await launchNativeTui({
+            parsed: {
+                provider: parsed.provider,
+                model: parsed.model,
+                apiKey: parsed.apiKey,
+                continue: parsed.continue,
+                resume: parsed.resume,
+                worktree: parsed.worktree,
+                messages: parsed.messages,
             },
+            cwd: process.cwd(),
+            env: process.env,
         });
-        // Initialize TUI - sets up terminal raw mode, cursor handling, and rendering
-        await renderer.init();
-        // Render any existing messages from a continued session (--continue mode)
-        // This allows users to see their previous conversation context
-        renderer.renderInitialMessages(agent.state);
-        // Subscribe to agent events for real-time UI updates
-        // The renderer handles streaming text, tool execution, errors, and completion
-        agent.subscribe(async (event) => {
-            await renderer.handleEvent(event, agent.state);
+        process.exit(exitCode);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        writeError(message);
+        process.exit(1);
+    }
+}
+async function runNativePrintMode(parsed, writeError) {
+    try {
+        const json = parsed.mode === "json" || Boolean(parsed.execJson);
+        const exitCode = await launchNativeTui({
+            parsed: {
+                provider: parsed.provider,
+                model: parsed.model,
+                apiKey: parsed.apiKey,
+                print: true,
+                json,
+                outputLastMessage: parsed.execOutputLast,
+                outputSchema: parsed.execOutputSchema,
+                messages: parsed.messages,
+            },
+            cwd: process.cwd(),
+            env: process.env,
         });
-        // Run the main interactive loop - blocks until user exits
-        await runtime.runInteractiveLoop(renderer);
+        process.exit(exitCode);
     }
     catch (error) {
-        sessionEndReason = "error";
-        throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        writeError(message);
+        process.exit(1);
     }
-    finally {
-        const { applySessionEndHooks } = await import("./agent/session-lifecycle-hooks.js");
-        await applySessionEndHooks({
-            agent,
-            sessionManager,
+}
+/**
+ * Hand off headless/RPC protocol mode to native maestro-tui --headless.
+ * Stdio is the headless protocol surface; do not bootstrap the TS agent.
+ */
+async function runNativeHeadlessMode(writeError) {
+    try {
+        const exitCode = await launchNativeTui({
+            parsed: { headless: true, messages: [] },
             cwd: process.cwd(),
-            reason: sessionEndReason,
+            env: process.env,
         });
+        process.exit(exitCode);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // Protocol clients expect JSON errors on stdout when possible.
+        process.stdout.write(`${JSON.stringify({
+            type: "error",
+            message: `Headless startup failed: ${message}`,
+            fatal: true,
+            error_type: "fatal",
+        })}\n`);
+        writeError(message);
+        process.exit(1);
     }
 }
 async function waitForStartupTelemetryForImmediateExit(startupTelemetry) {
@@ -313,83 +336,6 @@ async function waitForStartupTelemetryForImmediateExit(startupTelemetry) {
  * @param messages - Array of user messages to process sequentially
  * @param mode - Output format: "text" for human-readable, "json" for JSONL
  */
-async function runSingleShotMode(agent, sessionManager, messages, mode, profileName, cliOverrides) {
-    const { JsonlEventWriter, createAgentJsonlAdapter, emitThreadEnd, emitThreadStart, emitUserTurn: emitUserTurnEvent, } = await import("./cli/jsonl-writer.js");
-    // Use session ID as thread ID for JSONL output correlation
-    const threadId = sessionManager.getSessionId();
-    // Set up JSONL writer for structured output in json mode
-    // This enables machine-readable event streaming for integrations
-    const jsonlWriter = mode === "json" ? new JsonlEventWriter(true, process.stdout) : null;
-    // Turn ID generator for correlating user messages with responses
-    const nextTurnId = (() => {
-        let counter = 0;
-        return () => `turn-${++counter}`;
-    })();
-    // Adapter translates agent events to JSONL format
-    const adapter = jsonlWriter && createAgentJsonlAdapter(jsonlWriter, nextTurnId);
-    const { runUserPromptWithRecovery } = await import("./agent/user-prompt-runtime.js");
-    // In JSON mode, emit thread start and subscribe to all events
-    if (jsonlWriter) {
-        emitThreadStart(jsonlWriter, threadId, { sessionId: threadId });
-        agent.subscribe((event) => {
-            adapter?.handle(event);
-        });
-    }
-    let sessionEndReason = "complete";
-    try {
-        const { withMcpPostKeepMessages } = await import("./mcp/prompt-recovery.js");
-        // Process each message sequentially
-        // This allows multi-message conversations in single-shot mode
-        for (const message of messages) {
-            if (jsonlWriter) {
-                emitUserTurnEvent(jsonlWriter, nextTurnId, message);
-            }
-            await runUserPromptWithRecovery({
-                agent,
-                sessionManager,
-                cwd: process.cwd(),
-                prompt: message,
-                execute: () => agent.prompt(message),
-                getPostKeepMessages: withMcpPostKeepMessages(),
-                profileName,
-                cliOverrides,
-            });
-        }
-        // In text mode, extract and output only the final text response
-        // This provides clean output for shell pipelines and scripts
-        if (mode === "text") {
-            const { isAssistantMessage } = await import("./agent/index.js");
-            const lastMessage = agent.state.messages[agent.state.messages.length - 1];
-            if (isAssistantMessage(lastMessage)) {
-                for (const content of lastMessage.content) {
-                    if (content.type === "text") {
-                        console.log(content.text);
-                    }
-                }
-            }
-        }
-        if (jsonlWriter) {
-            emitThreadEnd(jsonlWriter, threadId, "ok", threadId);
-        }
-    }
-    catch (error) {
-        sessionEndReason = "error";
-        // Ensure error is recorded in JSONL output for machine processing
-        if (jsonlWriter) {
-            emitThreadEnd(jsonlWriter, threadId, "error", threadId);
-        }
-        throw error;
-    }
-    finally {
-        const { applySessionEndHooks } = await import("./agent/session-lifecycle-hooks.js");
-        await applySessionEndHooks({
-            agent,
-            sessionManager,
-            cwd: process.cwd(),
-            reason: sessionEndReason,
-        });
-    }
-}
 function resolveSessionStartHookSource(params) {
     if (params.shouldRestoreSession) {
         return "resume";
@@ -496,29 +442,20 @@ export async function main(args) {
         process.exit(0);
     }
     if (parsed.listModesAll) {
-        const hiddenFlagTelemetry = recordStagedRolloutSurfaceUsageLazy("hidden_flag_used", {
-            surfaceId: "cli:--list-modes-all",
-            surfaceType: "cli_flag",
-            owner: "agent-runtime",
-        });
-        await printAllAgentModes();
-        await waitForStartupTelemetryForImmediateExit(Promise.all([startupTelemetry, hiddenFlagTelemetry]).then(() => undefined));
-        process.exit(0);
+        const { launchNativeCli } = await import("./cli/native-tui-launcher.js");
+        const exitCode = await launchNativeCli([
+            "modes",
+            "list",
+            "--list-modes-all",
+        ]);
+        await waitForStartupTelemetryForImmediateExit(startupTelemetry);
+        process.exit(exitCode);
     }
     if (parsed.error) {
         console.error(chalk.red(parsed.error));
         await waitForStartupTelemetryForImmediateExit(startupTelemetry);
         process.exit(1);
     }
-    if (parsed.command === "modes") {
-        const { handleModesCommand } = await import("./cli/commands/modes.js");
-        await handleModesCommand(parsed.subcommand, parsed.messages, {
-            provider: parsed.provider,
-            json: parsed.execJson,
-        });
-        await waitForStartupTelemetryForImmediateExit(startupTelemetry);
-        return;
-    }
     const isHeadlessMode = isHeadlessModeRequested(parsed);
     const willDispatchHeadlessMode = willDispatchHeadlessRuntime(parsed);
     const exitWithEarlyStartupError = (error) => {
@@ -552,6 +489,15 @@ export async function main(args) {
         await waitForStartupTelemetryForImmediateExit(startupTelemetry);
         return;
     }
+    if (isNativeUtilityCommand(parsed.command)) {
+        // Utility commands own their complete lifecycle in Rust. Keep this handoff
+        // ahead of replay setup so inherited scenario state cannot bootstrap the
+        // TypeScript runtime or change a utility command's behavior. Direct dispatch
+        // intentionally falls back here when startup telemetry is configured.
+        startObservability(process.env);
+        await waitForStartupTelemetryForImmediateExit(startupTelemetry);
+        process.exit(await launchNativeCli(args));
+    }
     const replayScenarioPath = parsed.replayScenarioPath ?? process.env.MAESTRO_SCENARIO_PATH;
     let scenarioReplay;
     if (replayScenarioPath) {
@@ -567,14 +513,10 @@ export async function main(args) {
             scenarioId: replayScenario.scenarioId,
         };
     }
-    // Handle `maestro hosted-runner` before importing web-server so hosted
-    // defaults are visible to its module-level runtime profile.
+    // Hosted execution is owned by the native Rust runtime. Keep this before the
+    // web-server import so the legacy TypeScript hosted server cannot bootstrap.
     if (parsed.command === "hosted-runner") {
-        const { handleHostedRunnerCommand } = await import("./cli/commands/hosted-runner.js");
-        await handleHostedRunnerCommand(parsed.commandArgs ?? [], {
-            defaultPort: parsed.port,
-        });
-        return;
+        process.exit(await launchNativeCli(buildNativeHostedRunnerArgs(parsed.commandArgs ?? [], parsed.port), { forwardSignals: true }));
     }
     // Handle `maestro web` early exit (start the bundled web server + UI).
     if (parsed.command === "web") {
@@ -606,14 +548,11 @@ export async function main(args) {
         await handleInitCommand(parsed.commandArgs ?? []);
         return;
     }
-    if (parsed.command === "status") {
-        const { handleStatusCommand } = await import("./cli/commands/status.js");
-        await handleStatusCommand();
-        return;
-    }
-    if (parsed.command === "update") {
-        const { handleUpdateCommand } = await import("./cli/commands/update.js");
-        await handleUpdateCommand(parsed.commandArgs ?? []);
+    if (parsed.command === "mission") {
+        const { handleMissionCommand } = await import("./cli/commands/mission.js");
+        await handleMissionCommand(parsed.subcommand, parsed.messages, {
+            json: parsed.execJson,
+        });
         return;
     }
     if (parsed.command === "context") {
@@ -632,32 +571,28 @@ export async function main(args) {
         });
         return;
     }
-    if (parsed.command === "skill") {
-        const { handleSkillCommand } = await import("./cli/commands/skill.js");
-        const cliOverrides = buildCliConfigOverrides(parsed);
-        const overrideProfile = typeof cliOverrides.profile === "string"
-            ? cliOverrides.profile
-            : undefined;
-        const profileName = parsed.profile ?? overrideProfile;
-        await handleSkillCommand(parsed.subcommand, parsed.commandArgs ?? [], {
-            profileName,
-            cliOverrides,
-        });
-        return;
+    // Agent paths hand off to native maestro-tui before the TypeScript bootstrap.
+    // Residual TS: web, config, mission, and other utility subcommands.
+    if (shouldLaunchNativeHeadless(parsed)) {
+        await waitForStartupTelemetryForImmediateExit(startupTelemetry);
+        await runNativeHeadlessMode(writeStartupErrorToStderr);
     }
-    // If we're about to enter interactive TUI mode (no prompt messages and not RPC/exec),
-    // or headless mode (stdout is JSON-only), redirect all logging/console output to a file.
-    // This must run before config/model loading to catch any early warnings.
-    const isLikelyInteractiveTui = !parsed.messages.length &&
-        (parsed.mode === "text" || parsed.mode === undefined) &&
-        parsed.command === undefined;
-    if (isLikelyInteractiveTui || willDispatchHeadlessMode) {
-        const { redirectLoggerToFile, redirectConsoleToLogger, redirectStderrToLogger, pipeProcessEventsToLogger, } = await import("./utils/logger.js");
+    if (shouldLaunchNativeInteractiveTui(parsed)) {
+        await waitForStartupTelemetryForImmediateExit(startupTelemetry);
+        await runNativeInteractiveMode(parsed, writeStartupErrorToStderr);
+    }
+    if (shouldLaunchNativePrint(parsed)) {
+        await waitForStartupTelemetryForImmediateExit(startupTelemetry);
+        await runNativePrintMode(parsed, writeStartupErrorToStderr);
+    }
+    // If we're about to enter headless mode (stdout is JSON-only), redirect all
+    // logging/console output to a file. This must run before config/model loading
+    // to catch any early warnings. Keep error-level console on stderr so fatal
+    // headless startup failures remain protocol-visible on stdout/stderr as designed.
+    if (willDispatchHeadlessMode) {
+        const { redirectLoggerToFile, redirectConsoleToLogger, pipeProcessEventsToLogger, } = await import("./utils/logger.js");
         redirectLoggerToFile();
-        redirectConsoleToLogger({ preserveErrorStderr: willDispatchHeadlessMode });
-        if (!willDispatchHeadlessMode) {
-            redirectStderrToLogger();
-        }
+        redirectConsoleToLogger({ preserveErrorStderr: true });
         pipeProcessEventsToLogger();
     }
     const headlessRuntimeSelection = selectHeadlessRuntime(process.env, {
@@ -892,21 +827,11 @@ export async function main(args) {
                 process.exit(1);
         }
     }
-    if (parsed.command === "openai") {
-        const { handleOpenAICommand } = await import("./cli/commands/openai.js");
-        await handleOpenAICommand(parsed.subcommand, parsed.messages);
-        return;
-    }
     if (parsed.command === "evalops") {
         const { handleEvalOpsCommand } = await import("./cli/commands/evalops.js");
         await handleEvalOpsCommand(parsed.subcommand, parsed.commandArgs ?? []);
         return;
     }
-    if (parsed.command === "hooks") {
-        const { handleHooksCommand } = await import("./cli/commands/hooks.js");
-        await handleHooksCommand(parsed.subcommand);
-        return;
-    }
     if (parsed.command === "run") {
         const { handleRunCommand } = await import("./cli/commands/run.js");
         await handleRunCommand(parsed.subcommand, parsed.messages, {
@@ -914,30 +839,6 @@ export async function main(args) {
         });
         return;
     }
-    if (parsed.command === "sessions") {
-        const { handleSessionsCommand } = await import("./cli/commands/sessions.js");
-        await handleSessionsCommand(parsed.subcommand, parsed.messages, {
-            json: parsed.execJson,
-            format: parsed.exportFormat,
-            redactSecrets: parsed.redactSecrets,
-        });
-        return;
-    }
-    if (parsed.command === "export") {
-        const { handleExportCommand } = await import("./cli/commands/session-transfer.js");
-        await handleExportCommand(parsed.messages[0], parsed.messages[1], parsed.exportFormat, { redactSecrets: parsed.redactSecrets });
-        return;
-    }
-    if (parsed.command === "import") {
-        const { handleImportCommand } = await import("./cli/commands/session-transfer.js");
-        await handleImportCommand(parsed.messages[0]);
-        return;
-    }
-    if (parsed.command === "memory") {
-        const { handleMemoryCommand } = await import("./cli/commands/memory.js");
-        await handleMemoryCommand(parsed.subcommand, parsed.messages);
-        return;
-    }
     if (parsed.command === "remote") {
         const { handleRemoteCommand } = await import("./cli/commands/remote.js");
         await handleRemoteCommand(parsed.subcommand, parsed.commandArgs ?? []);
@@ -953,48 +854,20 @@ export async function main(args) {
         await handleOperatingPlaneCommand(parsed.commandArgs ?? []);
         return;
     }
-    if (parsed.command === "anthropic") {
-        const { handleAnthropicCommand } = await import("./cli/commands/anthropic.js");
-        await handleAnthropicCommand();
-        return;
-    }
-    const execCommandModulePromise = parsed.command === "exec" ? import("./cli/commands/exec.js") : undefined;
-    // Handle cost commands
     if (parsed.command === "cost") {
-        const { handleCostSummary, handleCostClear, handleCostBreakdown } = await import("./cli/commands/cost.js");
-        switch (parsed.subcommand) {
-            case "clear":
-                await handleCostClear();
-                return;
-            case "breakdown":
-                await handleCostBreakdown();
-                return;
-            case "today":
-            case "yesterday":
-            case "week":
-            case "month":
-            case "all":
-                await handleCostSummary(parsed.subcommand);
-                return;
-            case undefined:
-                // Default to today
-                await handleCostSummary("today");
-                return;
-            default:
-                console.error(chalk.red(`Unknown cost subcommand: ${parsed.subcommand}`));
-                console.log(chalk.dim("\nAvailable commands:"));
-                console.log(chalk.dim("  maestro cost [today]     - Show today's costs (default)"));
-                console.log(chalk.dim("  maestro cost yesterday   - Show yesterday's costs"));
-                console.log(chalk.dim("  maestro cost week        - Show last 7 days"));
-                console.log(chalk.dim("  maestro cost month       - Show last 30 days"));
-                console.log(chalk.dim("  maestro cost all         - Show all time costs"));
-                console.log(chalk.dim("  maestro cost breakdown   - Detailed breakdown"));
-                console.log(chalk.dim("  maestro cost clear       - Clear usage data"));
-                process.exit(1);
-        }
+        console.error(chalk.red(`Unknown cost subcommand: ${parsed.subcommand}`));
+        console.log(chalk.dim("\nAvailable commands:"));
+        console.log(chalk.dim("  maestro cost [today]     - Show today's costs (default)"));
+        console.log(chalk.dim("  maestro cost yesterday   - Show yesterday's costs"));
+        console.log(chalk.dim("  maestro cost week        - Show last 7 days"));
+        console.log(chalk.dim("  maestro cost month       - Show last 30 days"));
+        console.log(chalk.dim("  maestro cost all         - Show all time costs"));
+        console.log(chalk.dim("  maestro cost breakdown   - Detailed breakdown"));
+        console.log(chalk.dim("  maestro cost clear       - Clear usage data"));
+        process.exit(1);
     }
-    if (parsed.command === "stats") {
-        const { handleStatsCommand } = await import("./cli/commands/stats.js");
+    if (parsed.command === "value") {
+        const { handleValueCommand } = await import("./cli/commands/value.js");
         switch (parsed.subcommand) {
             case undefined:
             case "today":
@@ -1004,570 +877,58 @@ export async function main(args) {
             case "month":
             case "30d":
             case "all":
-                await handleStatsCommand(parsed.subcommand, {
-                    sessionId: parsed.session,
+                await handleValueCommand(parsed.subcommand, {
                     format: parsed.exportFormat,
+                    outputDir: parsed.outputDir,
+                    writeArtifacts: parsed.valueWrite,
                 });
                 return;
             default:
-                console.error(chalk.red(`Unknown stats subcommand: ${parsed.subcommand}`));
+                console.error(chalk.red(`Unknown value subcommand: ${parsed.subcommand}`));
                 console.log(chalk.dim("\nAvailable commands:"));
-                console.log(chalk.dim("  maestro stats              - Show last 7 days"));
-                console.log(chalk.dim("  maestro stats --session <id> - Show one session"));
-                console.log(chalk.dim("  maestro stats today        - Show today"));
-                console.log(chalk.dim("  maestro stats month        - Show last 30 days"));
-                console.log(chalk.dim("  maestro stats all          - Show all time"));
-                console.log(chalk.dim("  maestro stats --format json|csv - Export usage data"));
+                console.log(chalk.dim("  maestro value              - Show last 30 days"));
+                console.log(chalk.dim("  maestro value week         - Show last 7 days"));
+                console.log(chalk.dim("  maestro value all          - Show all local evidence"));
+                console.log(chalk.dim("  maestro value --format json|md - Export value report"));
+                console.log(chalk.dim("  maestro value --write --output-dir .maestro/value-reports - Persist report artifacts"));
                 process.exit(1);
         }
     }
-    // Handle models commands
-    if (parsed.command === "models") {
-        const { handleModelsList, handleModelsProviders } = await import("./cli/commands/models.js");
-        const providerFilter = parsed.provider;
-        switch (parsed.subcommand) {
-            case "providers":
-                await handleModelsProviders(providerFilter);
-                return;
-            case undefined:
-            case "list":
-                await handleModelsList(providerFilter);
-                return;
-            default:
-                console.error(chalk.red(`Unknown models subcommand: ${parsed.subcommand || "(none)"}`));
-                console.log(chalk.dim("\nAvailable commands:"));
-                console.log(chalk.dim("  maestro models list             - List registered models"));
-                console.log(chalk.dim("  maestro models providers        - Summarize providers"));
-                process.exit(1);
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 6: Special Command Handling (agents init)
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Track agents init state for deferred execution
-    let agentsInitPrompt = null;
-    let agentsInitPath = null;
-    const quoteShellArg = (value) => {
-        if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {
-            return value;
-        }
-        if (process.platform === "win32") {
-            const escaped = value
-                .replace(/(\\*)"/g, (_match, slashes) => `${slashes}${slashes}\\"`)
-                .replace(/\\+$/g, (slashes) => `${slashes}${slashes}`);
-            return `"${escaped}"`;
-        }
-        return `'${value.replaceAll("'", "'\\''")}'`;
-    };
-    const buildAgentsInitRerunCommand = (targetArg) => targetArg
-        ? `maestro agents init ${quoteShellArg(targetArg)} --force`
-        : "maestro agents init --force";
-    // Handle "maestro agents init" command to generate AGENTS.md
-    if (parsed.command === "agents") {
-        const { buildAgentsInitPrompt, handleAgentsInit } = await import("./cli/commands/agents.js");
-        if (parsed.subcommand && parsed.subcommand !== "init") {
-            console.error(chalk.red(`Unknown agents subcommand: ${parsed.subcommand}. Try "maestro agents init"`));
-            process.exit(1);
-        }
-        try {
-            const targetArg = parsed.messages[0];
-            const result = handleAgentsInit(targetArg, { force: parsed.force });
-            if (result.action === "preview") {
-                const { sanitizeTerminalPreview } = await import("./cli-tui/utils/text-formatting.js");
-                const rerunCommand = buildAgentsInitRerunCommand(targetArg);
-                console.log([
-                    `AGENTS instructions already exist at ${result.path}.`,
-                    `Preview the proposed update below, then re-run with \`${rerunCommand}\` to apply it.`,
-                    "",
-                    sanitizeTerminalPreview(result.diff ?? ""),
-                ].join("\n"));
-                return;
-            }
-            if (result.action === "updated") {
-                console.log(`Updated AGENTS instructions at ${result.path}.`);
-                return;
-            }
-            agentsInitPath = result.path;
-            agentsInitPrompt = buildAgentsInitPrompt(result.path, result.sources);
-            if (parsed.messages.length === 0) {
-                parsed.messages = [agentsInitPrompt];
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error
-                ? error.message
-                : "Failed to initialize AGENTS.md";
-            console.error(chalk.red(message));
-            process.exit(1);
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 7: Session Management
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Create session manager for conversation persistence
-    // The session manager handles:
-    // - Session file creation and storage (~/.maestro/agent/sessions/)
-    // - Message persistence in JSONL format
-    // - Session resume and continuation
-    // - Model/thinking level tracking across restarts
-    const useFreshExecSessionManager = parsed.command === "exec" &&
-        parsed.execJson &&
-        !willDispatchHeadlessMode &&
-        !parsed.continue &&
-        !parsed.resume &&
-        !parsed.session &&
-        !parsed.execResumeId &&
-        !parsed.execUseLast;
-    let earlyFreshExecJsonThreadId = null;
-    if (useFreshExecSessionManager &&
-        parsed.messages.some((message) => message.trim().length > 0)) {
-        const [{ randomUUID }, { JsonlEventWriter, emitThreadStart }] = await Promise.all([
-            import("node:crypto"),
-            import("./cli/jsonl-writer.js"),
-        ]);
-        earlyFreshExecJsonThreadId = randomUUID();
-        emitThreadStart(new JsonlEventWriter(true, process.stdout), earlyFreshExecJsonThreadId, {
-            sandboxMode: parsed.sandbox ?? process.env.MAESTRO_SANDBOX_MODE,
-            cwd: process.cwd(),
-            sessionId: earlyFreshExecJsonThreadId,
-        });
-        earlyExecJsonThreadId = earlyFreshExecJsonThreadId;
-    }
-    const sessionManager = await withExecJsonStartupCleanup(async () => (useFreshExecSessionManager
-        ? new (await import("./session/fresh-exec-session-manager.js")).FreshExecSessionManager({
-            sessionId: earlyFreshExecJsonThreadId ?? undefined,
-        })
-        : new (await import("./session/manager.js")).SessionManager(parsed.continue && !parsed.resume, // continueSession: auto-load most recent
-        parsed.session)));
-    let scenarioRecorder;
-    if (parsed.recordScenarioPath) {
-        const { ScriptedScenarioRecorder } = await import("./server/scenario-recorder.js");
-        scenarioRecorder = new ScriptedScenarioRecorder({
-            outPath: parsed.recordScenarioPath,
-            recordedFrom: () => sessionManager.getSessionId(),
-        });
-    }
-    startupProfiler.checkpoint("session:created");
-    const shouldEmitExecJsonThreadStartAfterSession = Boolean(parsed.command === "exec" &&
-        parsed.execJson &&
-        !willDispatchHeadlessMode &&
-        !earlyFreshExecJsonThreadId &&
-        parsed.messages.some((message) => message.trim().length > 0));
-    const execJsonThreadStartEmitted = Boolean(earlyFreshExecJsonThreadId || shouldEmitExecJsonThreadStartAfterSession);
-    let execResumeApplied = false;
-    if (parsed.command === "exec") {
-        let targetPath = null;
-        if (parsed.execResumeId) {
-            targetPath = sessionManager.getSessionFileById(parsed.execResumeId);
-            if (!targetPath) {
-                console.error(chalk.red(`No session found with id ${parsed.execResumeId}.`));
-                process.exit(1);
-            }
-        }
-        else if (parsed.execUseLast) {
-            const sessions = sessionManager.loadAllSessions();
-            const lastExec = sessions.find((session) => session.summary?.startsWith(EXEC_SESSION_SUMMARY_PREFIX));
-            if (!lastExec) {
-                console.error(chalk.red("No previous maestro exec sessions were found."));
-                process.exit(1);
-            }
-            targetPath = lastExec.path;
-        }
-        if (targetPath) {
-            sessionManager.setSessionFile(targetPath);
-            execResumeApplied = true;
-        }
-    }
-    if (parsed.command === "exec" &&
-        !willDispatchHeadlessMode &&
-        parsed.messages.length === 0) {
-        throw new Error("maestro exec requires at least one prompt");
-    }
-    if (shouldEmitExecJsonThreadStartAfterSession) {
-        const { JsonlEventWriter, emitThreadStart } = await import("./cli/jsonl-writer.js");
-        const threadId = sessionManager.getSessionId();
-        emitThreadStart(new JsonlEventWriter(true, process.stdout), threadId, {
-            sandboxMode: parsed.sandbox ?? process.env.MAESTRO_SANDBOX_MODE,
-            cwd: process.cwd(),
-            sessionId: threadId,
-        });
-        earlyExecJsonThreadId = threadId;
-    }
-    // Disable session saving if --no-session flag is set
-    if (parsed.noSession) {
-        sessionManager.disable();
-    }
-    // Handle --resume flag: show session selector
-    if (parsed.resume) {
-        const { selectSession } = await import("./cli/session.js");
-        const selectedSession = await selectSession(sessionManager);
-        if (!selectedSession) {
-            console.log(chalk.dim("No session selected"));
-            return;
-        }
-        // Set the selected session as the active session
-        sessionManager.setSessionFile(selectedSession);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 8: Model Resolution
-    // ─────────────────────────────────────────────────────────────────────────────
-    let model;
-    try {
-        const { resolveModelFromArgs } = await import("./bootstrap/model-resolution-setup.js");
-        const resolved = await resolveModelFromArgs({
-            parsedProvider: parsed.provider,
-            parsedModel: parsed.model,
-            requireCredential,
-        });
-        model = resolved.model;
-    }
-    catch (error) {
-        await exitWithStartupError(error);
-    }
-    // Determine approval mode for tool execution:
-    // - "prompt": Ask user before each tool execution (default for interactive)
-    // - "auto": Automatically approve all tools (default for non-interactive)
-    // - "fail": Reject all tool executions (for read-only mode)
-    const isInteractiveTui = parsed.messages.length === 0 && (parsed.mode ?? "text") !== "rpc";
-    const defaultApprovalMode = isInteractiveTui
-        ? "prompt"
-        : "auto";
-    // Override approval mode based on exec flags
-    const approvalModeOverride = (() => {
-        if (parsed.command === "exec") {
-            if (parsed.execReadOnly)
-                return "fail"; // Read-only: reject all writes
-            if (parsed.execFullAuto)
-                return "auto"; // Full-auto: approve everything
-        }
-        return parsed.approvalMode ?? defaultApprovalMode;
-    })();
-    const toolRetryMode = isInteractiveTui && !isHeadlessMode ? "prompt" : "skip";
-    // Create approval service that controls tool execution authorization
-    let approvalService;
-    let headlessClientToolService;
-    let toolRetryService;
-    if (isHeadlessMode) {
-        const [{ ServerRequestActionApprovalService }, { clientToolService }, { ServerRequestToolRetryService },] = await Promise.all([
-            import("./server/approval-service.js"),
-            import("./server/client-tools-service.js"),
-            import("./server/tool-retry-service.js"),
-        ]);
-        approvalService = new ServerRequestActionApprovalService(approvalModeOverride, () => sessionManager.getSessionId() ?? undefined);
-        headlessClientToolService = clientToolService.forSession(() => sessionManager.getSessionId() ?? undefined);
-        toolRetryService = new ServerRequestToolRetryService(toolRetryMode, () => sessionManager.getSessionId() ?? undefined);
-    }
-    else {
-        approvalService = new PlatformBackedActionApprovalService(approvalModeOverride, {
-            sessionIdProvider: () => sessionManager.getSessionId() ?? undefined,
-        });
-        toolRetryService = new ToolRetryService(toolRetryMode);
-    }
-    let interactiveClientToolService;
-    if (isInteractiveTui && !isHeadlessMode) {
-        const { TuiClientToolService } = await import("./cli-tui/client-tools/local-client-tool-service.js");
-        interactiveClientToolService = new TuiClientToolService();
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 10: Tool Registry and Sandbox Setup
-    // ─────────────────────────────────────────────────────────────────────────────
-    let toolsResult;
-    try {
-        const { createToolsAndSandbox } = await import("./bootstrap/tools-setup.js");
-        toolsResult = await createToolsAndSandbox({
-            parsedTools: parsed.tools,
-            parsedSandbox: parsed.sandbox,
-            modelApi: model.api,
-            cwd: process.cwd(),
-            shouldPrintMessages: !parsed.execJson && parsed.mode !== "json",
-        });
-    }
-    catch (error) {
-        await exitWithStartupError(error);
-    }
-    const { allTools, sandbox, sandboxMode } = toolsResult;
-    startupProfiler.checkpoint("tools:prepared", { tools: allTools.length });
-    let configuredAllTools = allTools;
-    if (interactiveClientToolService) {
-        const { askUserClientTool } = await import("./tools/ask-user-client.js");
-        configuredAllTools = allTools.map((tool) => tool.name === "ask_user" ? askUserClientTool : tool);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 11: System Prompt Assembly
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Build the system prompt with project context after sandbox setup so runtime
-    // constraint fragments reflect the resolved sandbox state, not just the
-    // requested CLI mode.
-    const resolvedConstraintSandboxMode = await withExecJsonStartupCleanup(() => resolveConstraintSandboxMode({
-        sandbox,
-        sandboxMode,
-    }));
-    const systemPromptToolNames = parsed.tools ??
-        (model.api === "openai-codex-app-server"
-            ? toolsResult.baseTools.map((tool) => tool.name)
-            : undefined);
-    const runtimeConstraints = detectRuntimeConstraintContext({
-        cwd: process.cwd(),
-        sandboxMode: resolvedConstraintSandboxMode,
-        sandboxEnabled: Boolean(sandbox) && resolvedConstraintSandboxMode !== "local",
-        readOnly: parsed.execReadOnly || parsed.readonly ? true : undefined,
-    });
-    const { systemPrompt, promptMetadata, promptContextManifest, systemPromptSourcePaths: freshSystemPromptSourcePaths, } = await withExecJsonStartupCleanup(() => resolveMaestroSystemPrompt({
-        customPrompt: parsed.systemPrompt,
-        toolNames: systemPromptToolNames,
-        appendPrompt: parsed.appendSystemPrompt,
-        runtimeConstraints,
-        cwd: process.cwd(),
-        profileName: runtimeConfig.explicitProfileName,
-        cliOverrides: runtimeConfig.explicitCliOverrides,
-    }));
-    // Preserve any prompt source paths recorded by a previously saved session
-    // header. When `maestro -c` / `-r` resumes a session whose append prompt
-    // or context-doc was deleted in between runs, the fresh resolve above can
-    // no longer return that path, but a read-restore at compaction time would
-    // otherwise re-surface stale content from it. See #2602.
-    const persistedSystemPromptSourcePaths = sessionManager.getHeader?.()?.systemPromptSourcePaths ?? [];
-    const systemPromptSourcePaths = Array.from(new Set([
-        ...freshSystemPromptSourcePaths,
-        ...persistedSystemPromptSourcePaths,
-    ]));
-    const deferExecJsonContextManifest = parsed.command === "exec" && parsed.execJson && !willDispatchHeadlessMode;
-    const backfillExecJsonContextManifest = deferExecJsonContextManifest && !sessionManager.isInitialized();
-    const unifiedContextManifest = deferExecJsonContextManifest
-        ? undefined
-        : await withExecJsonStartupCleanup(() => import("./context/manifest.js").then(({ loadUnifiedContextManifest }) => loadUnifiedContextManifest(process.cwd(), {
-            projectDocs: promptContextManifest,
-        })));
-    startupProfiler.checkpoint("prompt:assembled", {
-        system_bytes: systemPrompt.length,
-    });
-    // Register sandbox cleanup on exit (only if sandbox is active)
-    if (sandbox && toolsResult.disposeSandbox) {
-        const cleanupSandbox = toolsResult.disposeSandbox;
-        if (!sandboxCleanupRegistered) {
-            process.once("beforeExit", () => void cleanupSandbox());
-            process.once("SIGINT", () => {
-                void cleanupSandbox();
-                process.exit(0);
-            });
-            process.once("SIGTERM", () => {
-                void cleanupSandbox();
-                process.exit(0);
-            });
-            sandboxCleanupRegistered = true;
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 12: Agent Creation
-    // ─────────────────────────────────────────────────────────────────────────────
-    const { createAgentInstance } = await withExecJsonStartupCleanup(() => import("./bootstrap/agent-creation-setup.js"));
-    const { setTaskBudgetTotal } = await withExecJsonStartupCleanup(() => import("./agent/task-budget-access.js"));
-    const enterpriseUser = (() => {
-        const u = enterpriseContext.getUser();
-        return u ? { id: u.userId, orgId: u.orgId } : undefined;
-    })();
-    const { agent } = await withExecJsonStartupCleanup(() => createAgentInstance({
-        systemPrompt,
-        promptMetadata,
-        systemPromptSourcePaths,
-        promptContextManifest,
-        unifiedContextManifest,
-        model,
-        reasoningSummary,
-        allTools: configuredAllTools,
-        sandbox,
-        sandboxMode: sandboxMode ?? null,
-        approvalService,
-        toolRetryService,
-        clientToolService: headlessClientToolService ?? interactiveClientToolService,
-        requireCredential,
-        enterpriseUser,
-        readonly: parsed.readonly,
-        composer: parsed.composer,
-        cwd: process.cwd(),
-    }));
-    await withExecJsonStartupCleanup(() => setTaskBudgetTotal(agent, parsed.taskBudget));
-    startupProfiler.checkpoint("agent:ready");
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 11.5: TypeScript Hooks Initialization
-    // ─────────────────────────────────────────────────────────────────────────────
-    const { initializeTypeScriptHooks } = await withExecJsonStartupCleanup(() => import("./bootstrap/hooks-setup.js"));
-    const { tsHooks } = await withExecJsonStartupCleanup(() => initializeTypeScriptHooks({
-        agent,
-        sessionManager,
-        cwd: process.cwd(),
-        baseTools: configuredAllTools,
-    }));
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 12: MCP (Model Context Protocol) Integration
-    // ─────────────────────────────────────────────────────────────────────────────
-    const { initializeMcpServers } = await withExecJsonStartupCleanup(() => import("./bootstrap/mcp-setup.js"));
-    const execJsonMcpConfigSnapshot = await withExecJsonStartupCleanup(() => initializeMcpServers({
-        agent,
-        baseTools: configuredAllTools,
-        cwd: process.cwd(),
-    }));
-    startupProfiler.checkpoint("mcp:bootstrap_queued");
-    // Determine mode early to know if we should print messages
-    const isInteractive = parsed.messages.length === 0;
-    const mode = parsed.mode || "text";
-    // Don't print messages in headless mode - stdout is for JSON only
-    const shouldPrintMessages = (isInteractive || mode === "text") &&
-        mode !== "json" &&
-        mode !== "headless" &&
-        !parsed.headless &&
-        !parsed.execJson;
-    const isGitRepository = isInsideGitRepository();
-    // Log sandbox status
-    if (sandbox && shouldPrintMessages) {
-        console.log(chalk.dim(`Sandbox enabled (mode: ${sandboxMode})`));
-    }
-    if (approvalModeOverride === "auto" &&
-        !isGitRepository &&
-        shouldPrintMessages) {
-        console.log(chalk.yellow("Auto approval is enabled outside a git repository. Changes will not be version controlled."));
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 13: Session Restoration
-    // ─────────────────────────────────────────────────────────────────────────────
-    const shouldRestoreSession = parsed.continue || parsed.resume || execResumeApplied;
-    const isFreshInteractiveSession = isInteractive && !shouldRestoreSession && mode !== "rpc";
-    let startupChangelogSummary = null;
-    let updateNotice = null;
-    let scopedModels = [];
-    const needsSessionRestorationSetup = shouldRestoreSession ||
-        (shouldPrintMessages && !(parsed.continue || parsed.resume)) ||
-        Boolean(parsed.models?.length) ||
-        isFreshInteractiveSession;
-    if (needsSessionRestorationSetup) {
-        const { restoreSessionState } = await withExecJsonStartupCleanup(() => import("./bootstrap/session-restoration-setup.js"));
-        ({ startupChangelogSummary, updateNotice, scopedModels } =
-            await withExecJsonStartupCleanup(() => restoreSessionState({
-                agent,
-                sessionManager,
-                shouldRestoreSession,
-                isContinueOrResume: Boolean(parsed.continue || parsed.resume),
-                shouldPrintMessages,
-                isFreshInteractiveSession,
-                version: VERSION,
-                models: parsed.models,
-            })));
-    }
-    await withExecJsonStartupCleanup(() => applySessionStartHooks({
-        agent,
-        sessionManager,
-        cwd: process.cwd(),
-        source: resolveSessionStartHookSource({
-            mode,
-            command: parsed.command,
-            isInteractive,
-            headless: parsed.headless,
-            shouldRestoreSession,
-        }),
-    }));
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 14.5: Event Subscriptions
-    // ─────────────────────────────────────────────────────────────────────────────
-    const { setupEventSubscriptions } = await withExecJsonStartupCleanup(() => import("./bootstrap/event-subscriptions-setup.js"));
-    const automaticMemory = await withExecJsonStartupCleanup(() => createLazyAutoMemoryCoordinators({
-        cwd: process.cwd(),
-        getAuthContext: (provider) => requireCredential(provider, false),
-        getModel: () => agent.state.model,
-        sessionManager,
-    }));
-    await withExecJsonStartupCleanup(() => setupEventSubscriptions({
-        agent,
-        sessionManager,
-        approvalMode: (approvalModeOverride ?? "prompt"),
-        sandboxMode,
-        tsHookCount: tsHooks.length,
-        cwd: process.cwd(),
-        enterpriseContext,
-        automaticMemoryExtraction: automaticMemory.extraction,
-        scenarioReplay,
-        scenarioRecorder,
-    }));
-    // ─────────────────────────────────────────────────────────────────────────────
-    // PHASE 14: Runtime Mode Dispatch
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Route to the appropriate runtime mode based on command and arguments:
-    // 1. agents init: Generate AGENTS.md file
-    // 2. RPC mode: JSON-over-stdio protocol for programmatic control
-    // 3. Interactive TUI: Full terminal interface
-    // 4. Exec mode: Non-interactive batch execution
-    // 5. Single-shot: Process CLI messages and exit
-    try {
-        if (agentsInitPrompt) {
-            startupProfiler.terminal("exec:ready", { mode: "agents" });
-            const cwd = process.cwd();
-            const targetPath = agentsInitPath ?? "AGENTS.md";
-            const displayPath = targetPath.startsWith(cwd) && targetPath !== cwd
-                ? `.${targetPath.slice(cwd.length)}`
-                : targetPath;
-            const runMode = mode === "rpc" || mode === "headless" ? "text" : mode;
-            console.log(chalk.green(`Drafting AGENTS.md at ${displayPath}...`));
-            await runSingleShotMode(agent, sessionManager, [agentsInitPrompt], runMode, runtimeConfig.explicitProfileName, runtimeConfig.explicitCliOverrides);
-            console.log(chalk.dim(`AGENTS.md generated at ${displayPath}`));
-        }
-        else if (mode === "headless" || parsed.headless) {
-            // Headless mode - for native TUI communication
-            const { runHeadlessMode } = await import("./cli/headless.js");
-            startupProfiler.terminal("headless:ready");
-            await runHeadlessMode(agent, sessionManager, approvalService, toolRetryService, {
-                runtimeSelection: headlessRuntimeSelection,
-                profileName: runtimeConfig.explicitProfileName,
-                cliOverrides: runtimeConfig.explicitCliOverrides,
-            });
-        }
-        else if (mode === "rpc") {
-            // RPC mode - headless operation
-            startupProfiler.terminal("rpc:ready");
-            const { runRpcMode } = await import("./cli/rpc-mode.js");
-            await runRpcMode(agent, sessionManager, runtimeConfig.explicitProfileName, runtimeConfig.explicitCliOverrides);
-        }
-        else if (isInteractive) {
-            // No messages and not RPC - use TUI
-            startupProfiler.terminal("ui:ready");
-            await runInteractiveMode(agent, sessionManager, VERSION, approvalService, toolRetryService, parsed.apiKey, {
-                clientToolService: interactiveClientToolService,
-                modelScope: scopedModels,
-                startupChangelogSummary,
-                updateNotice,
-            }, runtimeConfig.explicitProfileName, runtimeConfig.explicitCliOverrides);
-        }
-        else if (parsed.command === "exec") {
-            startupProfiler.terminal("exec:ready");
-            const { runExecCommand } = await withExecJsonStartupCleanup(() => execCommandModulePromise ?? import("./cli/commands/exec.js"));
-            await runExecCommand({
-                agent,
-                sessionManager,
-                prompts: parsed.messages,
-                jsonl: Boolean(parsed.execJson),
-                threadStartEmitted: execJsonThreadStartEmitted,
-                sandboxMode: sandboxMode,
-                outputSchema: parsed.execOutputSchema,
-                outputLastMessage: parsed.execOutputLast,
-                profileName: runtimeConfig.explicitProfileName,
-                cliOverrides: runtimeConfig.explicitCliOverrides,
-                beforeFinalJsonlEvents: backfillExecJsonContextManifest
-                    ? async () => {
-                        const { loadUnifiedContextManifest } = await withExecJsonStartupCleanup(() => import("./context/manifest.js"));
-                        await withExecJsonStartupCleanup(() => sessionManager.updateUnifiedContextManifest(loadUnifiedContextManifest(process.cwd(), {
-                            projectDocs: promptContextManifest,
-                            mcpConfig: execJsonMcpConfigSnapshot,
-                        })));
-                    }
-                    : undefined,
-            });
-        }
-        else {
-            // CLI mode with messages
-            startupProfiler.terminal("cli:ready");
-            await runSingleShotMode(agent, sessionManager, parsed.messages, mode, runtimeConfig.explicitProfileName, runtimeConfig.explicitCliOverrides);
-        }
-    }
-    finally {
-        await automaticMemory.flush();
+    // Native-only agent modes. TypeScript Agent bootstrap has been removed.
+    // Utility commands already returned above. Hand off everything remaining
+    // to maestro-tui (interactive / print / headless).
+    await waitForStartupTelemetryForImmediateExit(startupTelemetry);
+    // Scenario replay: exec/print stay on the native print path (smoke +
+    // scripting). Interactive/headless/rpc still use headless protocol when
+    // a scenario is attached without an exec/print surface.
+    const replayForcesHeadless = Boolean(scenarioReplay) &&
+        !shouldLaunchNativePrint(parsed) &&
+        parsed.command !== "exec";
+    if (shouldLaunchNativeHeadless(parsed) || replayForcesHeadless) {
+        await runNativeHeadlessMode(writeStartupErrorToStderr);
+    }
+    if (shouldLaunchNativeInteractiveTui(parsed) && !scenarioReplay) {
+        await runNativeInteractiveMode(parsed, writeStartupErrorToStderr);
+    }
+    if (shouldLaunchNativePrint(parsed) ||
+        (parsed.messages.length > 0 &&
+            (parsed.command === undefined || parsed.command === "exec")) ||
+        (Boolean(scenarioReplay) && parsed.command === "exec")) {
+        await runNativePrintMode(parsed, writeStartupErrorToStderr);
+    }
+    if (process.env.MAESTRO_ALLOW_TS_AGENT === "1" ||
+        process.env.MAESTRO_ALLOW_TS_AGENT === "true") {
+        writeStartupErrorToStderr([
+            "MAESTRO_ALLOW_TS_AGENT is set, but the TypeScript Agent runtime has been removed.",
+            "Use native maestro-tui for interactive, print/exec, and headless/rpc.",
+        ].join("\n"));
+        process.exit(1);
     }
+    writeStartupErrorToStderr([
+        "No agent work requested, or this path is not implemented in the Node shim.",
+        'Use `maestro` (native TUI), `maestro exec "…"`, or `maestro --headless`.',
+        "Utility commands: config, web, skill, init, hosted-runner, …",
+    ].join("\n"));
+    process.exit(1);
 }
 //# sourceMappingURL=main.js.map