@bubblebrain-ai/bubble 0.0.5 → 0.0.7

package/dist/agent/execution-governor.d.ts

@@ -3,21 +3,16 @@ import type { TaskType } from "./task-classifier.js";
 export interface GovernorDecision {
     blockedResult?: ToolResult;
 }
-type WorkPhase = "explore" | "modify" | "verify";
 export declare class ExecutionGovernor {
-    private taskType;
     private budget;
     private history;
     private totalSteps;
     private searchSteps;
     private readSteps;
-    private explorationStepsWithoutWrite;
-    private searchFrozen;
-    private explorationFrozen;
-    private phase;
-    private codeChanged;
+    private mutationVersion;
     private reminderQueue;
     private warnedFamilies;
+    private warnedSignatures;
     private softTotalWarned;
     private softSearchWarned;
     private softReadWarned;
@@ -29,16 +24,13 @@ export declare class ExecutionGovernor {
         readSteps: number;
         searchFrozen: boolean;
         explorationFrozen: boolean;
-        phase: WorkPhase;
+        phase: "observe";
     };
     filterToolDefinitions(toolDefinitions: ToolRegistryEntry[]): ToolRegistryEntry[];
     beforeToolCall(toolCall: ParsedToolCall): GovernorDecision;
     afterToolResult(toolCall: ParsedToolCall, result: ToolResult): void;
     private trailingNoProgressCount;
-    private freezeSearch;
-    private enterModifyPhase;
-    private isModificationTask;
-    private historyCount;
+    private hasCurrentMutationObservation;
+    private warnOnce;
     private maybeWarnOnSoftBudgets;
 }
-export {};

package/dist/agent/execution-governor.js

@@ -1,118 +1,84 @@
 import { analyzeToolIntent } from "./tool-intent.js";
-import { buildExplorationFreezeReminder, buildInvestigationReminder, buildLoopWarningReminder, buildSearchFreezeReminder } from "../prompt/reminders.js";
+import { buildInvestigationReminder, buildLoopWarningReminder } from "../prompt/reminders.js";
 const BUDGETS = {
     security_investigation: {
         softTotalSteps: 14,
         softSearchSteps: 6,
         softReadSteps: 8,
-        maxExplorationStepsWithoutWrite: 12,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 2,
-        maxNoProgressFamilyRepeats: 3,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 2,
     },
     code_search: {
         softTotalSteps: 16,
         softSearchSteps: 8,
         softReadSteps: 10,
-        maxExplorationStepsWithoutWrite: 14,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 3,
     },
     debugging: {
         softTotalSteps: 18,
         softSearchSteps: 8,
         softReadSteps: 7,
-        maxExplorationStepsWithoutWrite: 10,
-        maxNoProgressReadExactRepeats: 1,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 1,
         warningFamilyRepeats: 3,
     },
     implementation: {
         softTotalSteps: 18,
         softSearchSteps: 8,
         softReadSteps: 6,
-        maxExplorationStepsWithoutWrite: 8,
-        maxNoProgressReadExactRepeats: 1,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 1,
         warningFamilyRepeats: 3,
     },
     code_review: {
         softTotalSteps: 14,
         softSearchSteps: 6,
         softReadSteps: 8,
-        maxExplorationStepsWithoutWrite: 12,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 3,
     },
     code_explanation: {
         softTotalSteps: 12,
         softSearchSteps: 6,
         softReadSteps: 8,
-        maxExplorationStepsWithoutWrite: 12,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 3,
     },
     repo_orientation: {
         softTotalSteps: 12,
         softSearchSteps: 6,
         softReadSteps: 8,
-        maxExplorationStepsWithoutWrite: 12,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 3,
     },
     product_discussion: {
         softTotalSteps: 10,
         softSearchSteps: 4,
         softReadSteps: 4,
-        maxExplorationStepsWithoutWrite: 8,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 2,
-        maxNoProgressFamilyRepeats: 3,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 2,
     },
     general: {
         softTotalSteps: 18,
         softSearchSteps: 8,
         softReadSteps: 10,
-        maxExplorationStepsWithoutWrite: 14,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 3,
     },
 };
-const SEARCH_TOOLS_DISABLED = new Set(["grep", "web_search", "web_fetch"]);
-const EXPLORATION_TOOLS_DISABLED = new Set(["read", "glob", "grep", "web_search", "web_fetch", "spawn_agent", "wait_agent", "send_input", "tool_search"]);
 export class ExecutionGovernor {
-    taskType;
     budget;
     history = [];
     totalSteps = 0;
     searchSteps = 0;
     readSteps = 0;
-    explorationStepsWithoutWrite = 0;
-    searchFrozen = false;
-    explorationFrozen = false;
-    phase = "explore";
-    codeChanged = false;
+    mutationVersion = 0;
     reminderQueue = [];
     warnedFamilies = new Set();
+    warnedSignatures = new Set();
     softTotalWarned = false;
     softSearchWarned = false;
     softReadWarned = false;
     constructor(taskType) {
-        this.taskType = taskType;
         this.budget = BUDGETS[taskType];
         if (taskType === "security_investigation") {
             this.reminderQueue.push(buildInvestigationReminder());
@@ -128,62 +94,33 @@ export class ExecutionGovernor {
             totalSteps: this.totalSteps,
             searchSteps: this.searchSteps,
             readSteps: this.readSteps,
-            searchFrozen: this.searchFrozen,
-            explorationFrozen: this.explorationFrozen,
-            phase: this.phase,
+            searchFrozen: false,
+            explorationFrozen: false,
+            phase: "observe",
         };
     }
     filterToolDefinitions(toolDefinitions) {
-        let filtered = toolDefinitions;
-        if (this.explorationFrozen) {
-            filtered = filtered.filter((tool) => !EXPLORATION_TOOLS_DISABLED.has(tool.name));
-        }
-        else if (this.searchFrozen) {
-            filtered = filtered.filter((tool) => !SEARCH_TOOLS_DISABLED.has(tool.name));
-        }
-        return filtered;
+        return toolDefinitions;
     }
     beforeToolCall(toolCall) {
         const intent = analyzeToolIntent(toolCall);
-        if (this.explorationFrozen && isExplorationIntent(intent)) {
-            return {
-                blockedResult: blockedResult("Exploration blocked: this implementation task already has enough context. Use edit/write, verify an existing change, or explain the blocker.", "blocked", "Exploration frozen because tool calls stopped producing task progress.", metadataKindForFamily(intent.family)),
-            };
-        }
-        if (this.isModificationTask() && !this.codeChanged && intent.family === "read") {
+        if (intent.family === "read") {
             const signature = intent.read?.signature;
-            if (signature && this.historyCount((entry) => entry.signature === signature) >= this.budget.maxNoProgressReadExactRepeats) {
-                this.enterModifyPhase(`Repeated the same file range without making progress: ${signature}`);
-                return {
-                    blockedResult: blockedResult("Read blocked: this file range was already read. You have enough context to make the requested change; use edit/write now or explain the blocker.", "blocked", "Repeated identical read before modification.", "read"),
-                };
+            if (signature && this.hasCurrentMutationObservation((entry) => entry.signature === signature)) {
+                this.warnOnce(`read:${signature}`, "This exact file range was already read since the last successful edit/write. If the content is still available and nothing changed, use the prior result; otherwise it is okay to re-read to recover context or verify a change.");
             }
         }
         if (intent.family === "search") {
-            if (this.searchFrozen) {
-                return {
-                    blockedResult: blockedResult("Search blocked: repeated low-yield searching is now frozen for this task.", "blocked", "Search frozen due to repeated low-yield searching.", "search"),
-                };
-            }
             const signature = intent.search?.signature;
             const familyKey = intent.search?.familyKey;
-            if (signature && this.trailingNoProgressCount((entry) => entry.signature === signature) >= this.budget.maxNoProgressExactRepeats) {
-                this.freezeSearch(`Repeated the same search signature without new evidence: ${signature}`);
-                return {
-                    blockedResult: blockedResult("Search blocked: repeated the same search multiple times without new evidence.", "blocked", "Repeated identical search without progress.", "search"),
-                };
+            if (signature && this.trailingNoProgressCount((entry) => entry.signature === signature) >= this.budget.warningExactRepeats) {
+                this.warnOnce(`search:${signature}`, "This search is very similar to one you already ran and it did not produce new evidence. Change the query/path, follow a concrete lead, or summarize the strongest findings.");
             }
             if (familyKey) {
                 const familyNoProgress = this.trailingNoProgressCount((entry) => entry.familyKey === familyKey);
-                if (familyNoProgress >= this.budget.maxNoProgressFamilyRepeats) {
-                    this.freezeSearch(`Repeated the same search family without new evidence: ${familyKey}`);
-                    return {
-                        blockedResult: blockedResult("Search blocked: repeated the same search family without new evidence.", "blocked", "Repeated similar searches without progress.", "search"),
-                    };
-                }
                 if (familyNoProgress >= this.budget.warningFamilyRepeats && !this.warnedFamilies.has(familyKey)) {
                     this.warnedFamilies.add(familyKey);
-                    this.reminderQueue.push(buildLoopWarningReminder("Repeated searches are yielding little new evidence. Change your hypothesis, narrow the path, or summarize current findings instead of repeating variants."));
+                    this.reminderQueue.push(buildLoopWarningReminder("Repeated searches in the same family are yielding little new evidence. Change your hypothesis, narrow the path, follow a specific file lead, or summarize current findings instead of repeating variants."));
                 }
             }
         }
@@ -194,9 +131,6 @@ export class ExecutionGovernor {
         if (intent.family === "read") {
             this.readSteps += 1;
         }
-        if (isExplorationIntent(intent) && !this.codeChanged) {
-            this.explorationStepsWithoutWrite += 1;
-        }
         this.maybeWarnOnSoftBudgets(intent.family === "search", intent.family === "read");
         return {};
     }
@@ -211,23 +145,19 @@ export class ExecutionGovernor {
             signature: intent.search?.signature ?? intent.read?.signature,
             familyKey: intent.search?.familyKey ?? intent.read?.familyKey,
             progress,
+            mutationVersion: this.mutationVersion,
         });
         if (isSuccessfulWriteIntent(intent, result)) {
-            this.codeChanged = true;
-            this.phase = "verify";
-            return;
-        }
-        if (this.isModificationTask()
-            && !this.codeChanged
-            && isExplorationIntent(intent)
-            && this.explorationStepsWithoutWrite >= this.budget.maxExplorationStepsWithoutWrite) {
-            this.enterModifyPhase(`Used ${this.explorationStepsWithoutWrite} exploration tools without editing files.`);
+            this.mutationVersion += 1;
         }
     }
     trailingNoProgressCount(predicate) {
         let count = 0;
         for (let index = this.history.length - 1; index >= 0; index--) {
             const entry = this.history[index];
+            if (entry.mutationVersion !== this.mutationVersion) {
+                break;
+            }
             if (!predicate(entry)) {
                 break;
             }
@@ -238,27 +168,15 @@ export class ExecutionGovernor {
         }
         return count;
     }
-    freezeSearch(reason) {
-        if (this.searchFrozen) {
-            return;
-        }
-        this.searchFrozen = true;
-        this.reminderQueue.push(buildSearchFreezeReminder(reason));
+    hasCurrentMutationObservation(predicate) {
+        return this.history.some((entry) => entry.mutationVersion === this.mutationVersion && predicate(entry));
     }
-    enterModifyPhase(reason) {
-        if (this.explorationFrozen) {
+    warnOnce(key, reason) {
+        if (this.warnedSignatures.has(key)) {
             return;
         }
-        this.phase = "modify";
-        this.explorationFrozen = true;
-        this.searchFrozen = true;
-        this.reminderQueue.push(buildExplorationFreezeReminder(reason));
-    }
-    isModificationTask() {
-        return this.taskType === "implementation" || this.taskType === "debugging";
-    }
-    historyCount(predicate) {
-        return this.history.reduce((count, entry) => count + (predicate(entry) ? 1 : 0), 0);
+        this.warnedSignatures.add(key);
+        this.reminderQueue.push(buildLoopWarningReminder(reason));
     }
     maybeWarnOnSoftBudgets(isSearchStep, isReadStep) {
         if (!this.softTotalWarned && this.totalSteps >= this.budget.softTotalSteps) {
@@ -275,28 +193,12 @@ export class ExecutionGovernor {
         }
     }
 }
-function isExplorationIntent(intent) {
-    return intent.family === "search" || intent.family === "read" || intent.family === "web";
-}
 function isSuccessfulWriteIntent(intent, result) {
     if (result.isError || result.status === "blocked" || result.status === "command_error") {
         return false;
     }
     return intent.family === "write" || intent.family === "edit" || result.metadata?.kind === "write" || result.metadata?.kind === "edit";
 }
-function metadataKindForFamily(family) {
-    switch (family) {
-        case "search":
-        case "read":
-        case "write":
-        case "edit":
-        case "shell":
-        case "web":
-            return family;
-        default:
-            return "security";
-    }
-}
 function inferProgress(intent, result) {
     if (result.status === "blocked" || result.status === "timeout" || result.status === "command_error") {
         return false;
@@ -314,14 +216,3 @@ function inferProgress(intent, result) {
     }
     return !result.isError;
 }
-function blockedResult(content, status, reason, kind = "security") {
-    return {
-        content,
-        isError: true,
-        status,
-        metadata: {
-            kind,
-            reason,
-        },
-    };
-}

package/dist/agent/task-size.d.ts

@@ -0,0 +1,9 @@
+import type { ContentPart } from "../types.js";
+/**
+ * Coarse "is this a small / focused task" classifier. Used to inject a hint
+ * that suppresses the default exploration-first protocol when the user's
+ * request is clearly a one-shot create or single-file tweak. Counterpart to
+ * `task-classifier.ts` which categorizes by *kind*, not *size*.
+ */
+export type TaskSize = "small" | "normal";
+export declare function classifyTaskSize(input: string | ContentPart[]): TaskSize;

package/dist/agent/task-size.js

@@ -0,0 +1,33 @@
+// Two-part match: a "create" verb AND a "deliverable" noun in the same
+// sentence is a strong signal of a focused, one-shot task.
+const SMALL_TASK_VERBS = [
+    /\b(write|create|generate|make|draft|build|add)\b/i,
+    /帮我写|帮我创建|帮我生成|写(个|一个|一份)|新建一个|做(个|一个|一份)|生成(个|一个|一份)|搞(个|一个|一份)/i,
+];
+const SMALL_TASK_NOUNS = [
+    /\b(file|page|component|script|snippet|function|class|test|html|css|js|ts|tsx|jsx|md|markdown|hello world)\b/i,
+    /(文件|页面|组件|脚本|片段|函数|类|测试|html|css|介绍|文章|页|说明|示例|demo)/i,
+];
+function matchesSmallTaskPattern(text) {
+    return SMALL_TASK_VERBS.some((re) => re.test(text))
+        && SMALL_TASK_NOUNS.some((re) => re.test(text));
+}
+const LARGE_TASK_NEGATIONS = [
+    /\b(refactor|rewrite|migrate|overhaul|integrate|architect|review the codebase|whole project|across the codebase)\b/i,
+    /多个|批量|全部|所有|整个项目|整个仓库|架构|重构|端到端|跨模块/i,
+];
+export function classifyTaskSize(input) {
+    const text = (typeof input === "string"
+        ? input
+        : input
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("\n")).trim();
+    if (!text)
+        return "normal";
+    // Up to ~120 chars with a small-task verb+noun match and no negation: small.
+    if (text.length <= 120 && matchesSmallTaskPattern(text)) {
+        return LARGE_TASK_NEGATIONS.some((re) => re.test(text)) ? "normal" : "small";
+    }
+    return "normal";
+}

package/dist/agent/tool-intent.d.ts

@@ -32,3 +32,4 @@ export interface ParsedReadCommand {
 }
 export declare function parseSearchBashCommand(command: string): ParsedSearchCommand | undefined;
 export declare function parseReadBashCommand(command: string): ParsedReadCommand | undefined;
+export declare function shellSplit(command: string): string[];

package/dist/agent/tool-intent.js

@@ -256,7 +256,7 @@ function parseLineCount(value) {
     const parsed = Number(value.replace(/^\+/, ""));
     return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
 }
-function shellSplit(command) {
+export function shellSplit(command) {
     const tokens = [];
     let current = "";
     let quote = null;

package/dist/agent.js

@@ -338,6 +338,9 @@ export class Agent {
                                 if (chunk.argumentsFull !== undefined) {
                                     currentToolCall.args = chunk.argumentsFull;
                                 }
+                                if (chunk.argumentsCorrupt) {
+                                    currentToolCall.argsCorrupt = true;
+                                }
                                 if (chunk.arguments) {
                                     yield {
                                         type: "tool_call_delta",
@@ -353,6 +356,7 @@ export class Agent {
                                     id: currentToolCall.id,
                                     name: currentToolCall.name,
                                     arguments: currentToolCall.args,
+                                    ...(currentToolCall.argsCorrupt ? { argsCorrupt: true } : {}),
                                 });
                                 yield {
                                     type: "tool_call_end",
@@ -405,10 +409,14 @@ export class Agent {
                 for (let index = 0; index < assistantMsg.toolCalls.length; index++) {
                     const tc = assistantMsg.toolCalls[index];
                     try {
-                        parsedCalls.push({ ...tc, parsedArgs: JSON.parse(tc.arguments) });
+                        parsedCalls.push({
+                            ...tc,
+                            parsedArgs: JSON.parse(tc.arguments),
+                            ...(tc.argsCorrupt ? { argsCorrupt: true } : {}),
+                        });
                     }
                     catch {
-                        parsedCalls.push({ ...tc, parsedArgs: {} });
+                        parsedCalls.push({ ...tc, parsedArgs: {}, argsCorrupt: true });
                     }
                 }
                 const executedResults = [];
@@ -1084,6 +1092,25 @@ export class Agent {
                 isError: true,
             };
         }
+        if (toolCall.argsCorrupt) {
+            return {
+                content: `Error: The arguments for "${toolCall.name}" failed to parse as JSON, indicating the tool call was truncated or malformed mid-stream. ` +
+                    `Re-issue the call with valid JSON arguments; do not assume the previous attempt ran.`,
+                isError: true,
+                status: "blocked",
+                metadata: { kind: "security", reason: "args_corrupt" },
+            };
+        }
+        const missingRequired = findMissingRequiredArgs(tool.parameters, toolCall.parsedArgs);
+        if (missingRequired.length > 0) {
+            return {
+                content: `Error: Tool "${toolCall.name}" was called without required argument${missingRequired.length === 1 ? "" : "s"}: ${missingRequired.map((name) => `"${name}"`).join(", ")}. ` +
+                    `Re-issue the call with all required fields filled. Do not assume the previous attempt ran with default values.`,
+                isError: true,
+                status: "blocked",
+                metadata: { kind: "security", reason: "missing_required_args", missing: missingRequired },
+            };
+        }
         try {
             return await tool.execute(toolCall.parsedArgs, {
                 cwd,
@@ -1102,6 +1129,23 @@ export class Agent {
         }
     }
 }
+function findMissingRequiredArgs(schema, args) {
+    const required = schema?.required;
+    if (!required || required.length === 0)
+        return [];
+    const missing = [];
+    for (const name of required) {
+        const value = args ? args[name] : undefined;
+        // Empty strings/arrays are intentionally allowed — writing an empty file
+        // or passing an empty list can be legitimate. Only undefined/null counts
+        // as "missing", because the observed failure mode is `finalArgs: "{}"`
+        // where the field is entirely absent.
+        if (value === undefined || value === null) {
+            missing.push(name);
+        }
+    }
+    return missing;
+}
 function estimateResidentChars(messages) {
     let total = 0;
     for (const message of messages) {

package/dist/main.js

@@ -125,9 +125,8 @@ async function main() {
         const { registry: slashRegistry } = await import("./slash-commands/index.js");
         slashRegistry.addDynamicSource(() => mcpManager.getPromptCommands());
     }
-    // Signal-based shutdown for Ctrl-C / kill. For /quit the command handler
-    // shuts MCP down directly — process.once("exit", ...)
-    // runs synchronously and can't await async work, so relying on it is a trap.
+    // Signal-based shutdown for Ctrl-C / kill. Normal /quit cleanup happens after
+    // the TUI renderer has been destroyed, avoiding native teardown races.
     const shutdownMcp = async () => {
         try {
             await mcpManager.shutdown();
@@ -261,6 +260,18 @@ async function main() {
         // Codex-style memory runs at startup over historical rollouts. Exit should
         // not perform an ad-hoc extraction of the just-finished session.
     };
+    const shutdownRuntime = async () => {
+        const results = await Promise.allSettled([
+            flushMemory(),
+            shutdownMcp(),
+            lspService.shutdown(),
+        ]);
+        for (const result of results) {
+            if (result.status === "rejected") {
+                // Shutdown is best-effort; never turn exit into a fatal error.
+            }
+        }
+    };
     const runMemoryCompaction = async () => formatMemoryStartupResult(await runMemoryStartupPipeline({
         cwd: args.cwd,
         complete: (messages, completeOptions) => agent.complete(messages, completeOptions),
@@ -296,49 +307,53 @@ async function main() {
             console.log(chalk.dim(`Resumed session: ${sessionManager.getSessionFile()}`));
         }
     }
-    // Print mode: single prompt, then exit
-    if (args.print || args.prompt) {
-        const prompt = args.prompt || (await readPipedStdin()) || "";
-        if (!prompt) {
-            console.error(chalk.red("Error: No prompt provided."));
-            process.exit(1);
-        }
-        for await (const event of agent.run(prompt, args.cwd)) {
-            if (event.type === "text_delta") {
-                process.stdout.write(event.content);
-            }
-            else if (event.type === "tool_start") {
-                console.log(chalk.cyan(`\n[Tool: ${event.name}]`));
+    try {
+        // Print mode: single prompt, then exit
+        if (args.print || args.prompt) {
+            const prompt = args.prompt || (await readPipedStdin()) || "";
+            if (!prompt) {
+                console.error(chalk.red("Error: No prompt provided."));
+                process.exit(1);
             }
-            else if (event.type === "tool_end") {
-                const color = event.result.isError ? chalk.red : chalk.dim;
-                console.log(color(`[Result: ${event.result.content.slice(0, 200)}${event.result.content.length > 200 ? "..." : ""}]`));
+            for await (const event of agent.run(prompt, args.cwd)) {
+                if (event.type === "text_delta") {
+                    process.stdout.write(event.content);
+                }
+                else if (event.type === "tool_start") {
+                    console.log(chalk.cyan(`\n[Tool: ${event.name}]`));
+                }
+                else if (event.type === "tool_end") {
+                    const color = event.result.isError ? chalk.red : chalk.dim;
+                    console.log(color(`[Result: ${event.result.content.slice(0, 200)}${event.result.content.length > 200 ? "..." : ""}]`));
+                }
             }
+            console.log();
+            return;
         }
-        console.log();
-        return;
+        // Interactive mode: OpenTUI uses Bun native FFI, matching opencode's TUI stack.
+        const { runTui } = await import("./tui/run.js");
+        await runTui(agent, args, {
+            sessionManager,
+            createProvider,
+            registry,
+            skillRegistry,
+            planHandlerRef,
+            approvalHandlerRef,
+            questionController,
+            bashAllowlist,
+            settingsManager,
+            lspService,
+            mcpManager,
+            theme: userConfig.getTheme(),
+            flushMemory,
+            runMemoryCompaction,
+            runMemorySummary,
+            runMemoryRefresh,
+        });
+    }
+    finally {
+        await shutdownRuntime();
     }
-    // Interactive mode: OpenTUI uses Bun native FFI, matching opencode's TUI stack.
-    const { runTui } = await import("./tui/run.js");
-    await runTui(agent, args, {
-        sessionManager,
-        createProvider,
-        registry,
-        skillRegistry,
-        planHandlerRef,
-        approvalHandlerRef,
-        questionController,
-        bashAllowlist,
-        settingsManager,
-        lspService,
-        mcpManager,
-        theme: userConfig.getTheme(),
-        flushMemory,
-        runMemoryCompaction,
-        runMemorySummary,
-        runMemoryRefresh,
-    });
-    await flushMemory();
 }
 async function readPipedStdin() {
     if (process.stdin.isTTY)