@bubblebrain-ai/bubble 0.0.51 → 0.0.53

package/dist/{tui-ink → tui/model}/trace-groups.js

@@ -1,6 +1,6 @@
 import os from "node:os";
-import { getEditDiffDetails } from "./edit-diff.js";
-import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+import { getEditDiffDetails } from "../formatting/edit-diff.js";
+import { analyzeToolIntent } from "../../agent/tool-intent.js";
 const DEFAULT_MAX_ITEMS = 6;
 const DEFAULT_MAX_PREVIEW_LINES = 8;
 export function buildTraceGroups(toolCalls, options = {}) {
@@ -22,6 +22,14 @@ export function buildTraceGroups(toolCalls, options = {}) {
         bucketClassifier = null;
     };
     for (const toolCall of toolCalls) {
+        // Grok keeps background-agent lifecycle in Tasks Pane. The transcript
+        // records only the launch event; wait/list/input/close echoes would repeat
+        // the same roster on every provider turn without adding chat history.
+        if (toolCall.metadata?.kind === "subagent"
+            && toolCall.name !== "spawn_agent"
+            && toolCall.name !== "run_workflow") {
+            continue;
+        }
         const classifier = classifyTool(toolCall);
         if (!classifier.groupable) {
             flush();
@@ -97,7 +105,20 @@ export function executeCommandBlock(group, maxLines) {
 }
 function classifyTool(toolCall) {
     if (toolCall.metadata?.kind === "subagent") {
-        return { kind: "subagent", title: "Subagents", bucketKey: `subagent:${toolCall.id}`, groupable: false };
+        const workflow = toolCall.name === "run_workflow" || toolCall.metadata.mode === "workflow";
+        return { kind: "subagent", title: workflow ? "Workflow" : "Subagent", bucketKey: `subagent:${toolCall.id}`, groupable: false };
+    }
+    if (toolCall.name === "bash") {
+        const semanticKind = toolCall.metadata?.kind;
+        const family = semanticKind === "read" || semanticKind === "search"
+            ? semanticKind
+            : analyzeToolIntent({ name: toolCall.name, parsedArgs: toolCall.args }).family;
+        if (family === "read") {
+            return { kind: "read", title: "Read", bucketKey: "read", groupable: true };
+        }
+        if (family === "search") {
+            return { kind: "search", title: "Search", bucketKey: "search", groupable: true };
+        }
     }
     switch (toolCall.name) {
         case "glob": {
@@ -188,7 +209,7 @@ function listResultItems(tool, homeDir) {
     const metadataPaths = Array.isArray(tool.metadata?.paths)
         ? tool.metadata.paths.filter((item) => typeof item === "string" && item.trim().length > 0)
         : [];
-    if (metadataPaths.length > 0 || typeof tool.metadata?.matches === "number") {
+    if (metadataPaths.length > 0) {
         return metadataPaths.map((line) => formatTracePath(line, homeDir));
     }
     return resultLines(tool.result)
@@ -220,7 +241,11 @@ function isListResultLine(line) {
 }
 function buildPathGroup(classifier, raw, options, pending, startedAt, hasError, errorCount, nounBase) {
     const items = unique(raw
-        .map((tool) => formatTracePath(tool.args.path ?? tool.args.file ?? "", options.homeDir))
+        .map((tool) => formatTracePath(tool.args.path
+        ?? tool.args.file
+        ?? tool.metadata?.path
+        ?? analyzeToolIntent({ name: tool.name, parsedArgs: tool.args }).read?.path
+        ?? "", options.homeDir))
         .filter(Boolean));
     const { shown, omitted } = take(items, options.maxItems);
     const count = items.length || raw.length;
@@ -242,12 +267,16 @@ function buildPathGroup(classifier, raw, options, pending, startedAt, hasError,
 }
 function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
     const items = raw.map((tool) => {
-        const pattern = String(tool.args.pattern ?? tool.args.query ?? "").trim();
-        const scope = String(tool.args.path ?? tool.args.glob ?? tool.args.include ?? "").trim();
+        const intent = analyzeToolIntent({ name: tool.name, parsedArgs: tool.args }).search;
+        const pattern = String(tool.args.pattern ?? tool.args.query ?? tool.metadata?.pattern ?? intent?.pattern ?? "").trim();
+        const scope = String(tool.args.path ?? tool.args.glob ?? tool.args.include ?? tool.metadata?.path ?? intent?.path ?? "").trim();
         const patternText = pattern ? `"${pattern}"` : "(pattern)";
         return scope ? `${patternText} in ${formatTracePath(scope, options.homeDir)}` : patternText;
     });
+    const resultPreview = raw.flatMap((tool) => resultLines(tool.result))
+        .map((line) => formatTracePath(line, options.homeDir));
     const { shown, omitted } = take(items, options.maxItems);
+    const preview = take(resultPreview, options.maxPreviewLines);
     const count = raw.length;
     return {
         kind: "search",
@@ -256,9 +285,9 @@ function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError
         count,
         noun: plural(count, "search", "searches"),
         items: shown,
-        previewLines: [],
+        previewLines: preview.shown,
         errorLines: collectErrorLines(raw, options),
-        omitted,
+        omitted: omitted + preview.omitted,
         pending,
         hasError,
         errorCount,
@@ -270,9 +299,33 @@ function buildExecuteGroup(classifier, tool, options, pending, startedAt, hasErr
     const { shown, omitted } = take(lines, options.maxPreviewLines);
     const rawCommand = String(tool.args.command ?? tool.args.cmd ?? commandFromRawArguments(tool.rawArguments) ?? "");
     const description = String(tool.args.description ?? "").trim() || undefined;
+    const taskId = typeof tool.metadata?.taskId === "string" ? tool.metadata.taskId : undefined;
+    const lifecycle = typeof tool.metadata?.taskLifecycle === "string"
+        ? tool.metadata.taskLifecycle
+        : undefined;
+    const backgroundLaunch = tool.metadata?.background === true && taskId && !lifecycle;
+    const title = lifecycle === "completed"
+        ? "Task completed"
+        : lifecycle === "failed"
+            ? "Task failed"
+            : lifecycle === "killed"
+                ? "Task killed"
+                : backgroundLaunch
+                    ? "Task started"
+                    : classifier.title;
+    const endedAt = typeof tool.metadata?.endedAt === "number" ? tool.metadata.endedAt : undefined;
+    const elapsed = endedAt ? formatElapsedDuration(tool.startedAt, endedAt) : undefined;
+    const exitCode = typeof tool.metadata?.exitCode === "number" ? tool.metadata.exitCode : undefined;
+    const outputLines = typeof tool.metadata?.outputLines === "number" ? tool.metadata.outputLines : undefined;
+    const statusLabel = taskId
+        ? [taskId, elapsed ? `in ${elapsed}` : undefined, exitCode !== undefined ? `exit ${exitCode}` : undefined,
+            outputLines !== undefined ? `${outputLines} line${outputLines === 1 ? "" : "s"}` : undefined]
+            .filter(Boolean)
+            .join(" · ")
+        : undefined;
     return {
         kind: "execute",
-        title: classifier.title,
+        title,
         raw: [tool],
         command: normalizeCommand(rawCommand),
         description,
@@ -285,8 +338,18 @@ function buildExecuteGroup(classifier, tool, options, pending, startedAt, hasErr
         hasError,
         errorCount,
         startedAt,
+        statusLabel,
     };
 }
+function formatElapsedDuration(startedAt, endedAt) {
+    if (startedAt === undefined)
+        return undefined;
+    const seconds = Math.max(0, Math.round((endedAt - startedAt) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
+}
 function buildMutationGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
     const items = raw
         .map((tool) => {
@@ -320,27 +383,35 @@ function buildMutationGroup(classifier, raw, options, pending, startedAt, hasErr
         startedAt,
     };
 }
-function buildSubagentGroup(classifier, tool, options, pending, startedAt) {
+function buildSubagentGroup(classifier, tool, _options, pending, startedAt) {
     const subagents = subagentsFromMetadata(tool);
-    const rows = subagents.length > 0
-        ? subagents.map(formatSubagentRow)
-        : resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
-    const { shown, omitted } = take(rows, options.maxPreviewLines);
     const errorCount = subagents.filter(isFailedSubagent).length + (tool.isError ? 1 : 0);
+    const statusLabel = subagents.length > 0
+        && subagents.every((subagent) => subagent.status === "completed" || subagent.status === "closed")
+        ? "completed"
+        : undefined;
+    const launchLabel = tool.name === "run_workflow"
+        ? String(tool.args.title ?? tool.args.description ?? "").trim()
+        : subagents[0]?.nickname || subagents[0]?.agentName || String(tool.args.description ?? "").trim();
     return {
         kind: "subagent",
         title: classifier.title,
+        description: launchLabel || undefined,
         raw: [tool],
         count: subagents.length || 1,
         noun: plural(subagents.length || 1, "agent", "agents"),
         items: [],
-        previewLines: shown,
+        // The full roster and live activity belong to Tasks Pane. Keeping member
+        // rows here creates two competing sources of truth and makes every
+        // wait/list call visually replay the launch.
+        previewLines: [],
         errorLines: [],
-        omitted,
+        omitted: 0,
         pending: pending || subagents.some((subagent) => ["queued", "running"].includes(subagent.status ?? "running")),
         hasError: !!tool.isError || errorCount > 0,
         errorCount,
         startedAt,
+        statusLabel,
     };
 }
 function buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
@@ -370,23 +441,13 @@ function subagentsFromMetadata(tool) {
         return [];
     return raw.filter((item) => typeof item === "object" && item !== null);
 }
-function formatSubagentRow(subagent) {
-    const label = subagent.nickname || subagent.agentName || subagent.subAgentId || "subagent";
-    const role = [subagent.agentName, subagent.category ? `/${subagent.category}` : ""].join("") || "default";
-    const route = formatSubagentRoute(subagent.route);
-    const descriptor = route ? `${role} @ ${route}` : role;
-    const status = subagent.status || "running";
-    const note = subagent.error
-        || subagent.toolNotes?.filter(Boolean).at(-1)
-        || subagent.summary
-        || subagent.task
-        || "";
-    return [label, `(${descriptor})`, status, note].filter(Boolean).join(" ");
-}
 function isFailedSubagent(subagent) {
     return subagent.status === "failed" || subagent.status === "blocked" || subagent.status === "cancelled";
 }
 function isToolPending(tool) {
+    if (tool.status) {
+        return tool.status === "queued" || tool.status === "pending" || tool.status === "running";
+    }
     return tool.result === undefined;
 }
 function isDirectoryLikeGlob(pattern) {

package/dist/tui/model/trace-interaction.d.ts

@@ -0,0 +1,63 @@
+import type { TraceGroup } from "./trace-groups.js";
+export type TraceRowTarget = {
+    kind: "group";
+    key: string;
+    groupKey: string;
+    foldable: boolean;
+    action?: TraceAction;
+} | {
+    kind: "item";
+    key: string;
+    groupKey: string;
+    toolId: string;
+    foldable: boolean;
+    action?: TraceAction;
+} | {
+    kind: "image";
+    key: string;
+    groupKey: string;
+    imageLabel: string;
+    foldable: false;
+    action: TraceAction;
+};
+export type TraceAction = {
+    kind: "open-subagent";
+    subAgentId: string;
+} | {
+    kind: "open-task";
+    taskId: string;
+} | {
+    kind: "open-image";
+    messageKey: string;
+    imageLabel: string;
+};
+/**
+ * UI-only fold/selection state. Tool lifecycle data remains immutable in the
+ * controller; live and settled renderers share this object so committing a
+ * turn cannot reset an expanded tool entry.
+ */
+export declare class TraceInteractionState {
+    private revision;
+    private selectedKey?;
+    private selectedGroupKey?;
+    private hoveredGroupKey?;
+    private readonly expandedGroups;
+    private readonly expandedItems;
+    groupKey(group: TraceGroup): string;
+    itemKey(group: TraceGroup, toolId: string): string;
+    isSelected(key: string): boolean;
+    isGroupSelected(groupKey: string): boolean;
+    isGroupHovered(groupKey: string): boolean;
+    isGroupExpanded(groupKey: string): boolean;
+    isItemExpanded(itemKey: string): boolean;
+    /**
+     * Monotonic render revision for transcript projection caches. The tool
+     * lifecycle remains immutable in the controller; only these UI affordances
+     * can change the settled projection without replacing the transcript array.
+     */
+    getRevision(): number;
+    activate(target: TraceRowTarget, clickCount: 1 | 2): TraceAction | undefined;
+    hover(target: TraceRowTarget | undefined): boolean;
+    clearHover(): boolean;
+    private toggle;
+}

package/dist/tui/model/trace-interaction.js

@@ -0,0 +1,87 @@
+/**
+ * UI-only fold/selection state. Tool lifecycle data remains immutable in the
+ * controller; live and settled renderers share this object so committing a
+ * turn cannot reset an expanded tool entry.
+ */
+export class TraceInteractionState {
+    revision = 0;
+    selectedKey;
+    selectedGroupKey;
+    hoveredGroupKey;
+    expandedGroups = new Set();
+    expandedItems = new Set();
+    groupKey(group) {
+        return `${group.kind}:${group.raw[0]?.id ?? group.title}`;
+    }
+    itemKey(group, toolId) {
+        return `${this.groupKey(group)}:item:${toolId}`;
+    }
+    isSelected(key) {
+        return this.selectedKey === key;
+    }
+    isGroupSelected(groupKey) {
+        return this.selectedGroupKey === groupKey;
+    }
+    isGroupHovered(groupKey) {
+        return this.hoveredGroupKey === groupKey;
+    }
+    isGroupExpanded(groupKey) {
+        return this.expandedGroups.has(groupKey);
+    }
+    isItemExpanded(itemKey) {
+        return this.expandedItems.has(itemKey);
+    }
+    /**
+     * Monotonic render revision for transcript projection caches. The tool
+     * lifecycle remains immutable in the controller; only these UI affordances
+     * can change the settled projection without replacing the transcript array.
+     */
+    getRevision() {
+        return this.revision;
+    }
+    activate(target, clickCount) {
+        const selectionChanged = this.selectedKey !== target.key || this.selectedGroupKey !== target.groupKey;
+        this.selectedKey = target.key;
+        this.selectedGroupKey = target.groupKey;
+        let foldChanged = false;
+        const actionClickCount = target.kind === "image" ? 1 : 2;
+        if (clickCount === actionClickCount && target.action) {
+            if (selectionChanged)
+                this.revision += 1;
+            return target.action;
+        }
+        if (clickCount !== 2 || !target.foldable) {
+            if (selectionChanged)
+                this.revision += 1;
+            return undefined;
+        }
+        if (target.kind === "group") {
+            this.toggle(this.expandedGroups, target.groupKey);
+            foldChanged = true;
+        }
+        else if (target.kind === "item") {
+            this.toggle(this.expandedItems, target.key);
+            foldChanged = true;
+        }
+        if (selectionChanged || foldChanged)
+            this.revision += 1;
+        return undefined;
+    }
+    hover(target) {
+        const next = target?.groupKey;
+        if (next === this.hoveredGroupKey)
+            return false;
+        this.hoveredGroupKey = next;
+        this.revision += 1;
+        return true;
+    }
+    clearHover() {
+        return this.hover(undefined);
+    }
+    toggle(values, key) {
+        if (values.has(key))
+            values.delete(key);
+        else
+            values.add(key);
+    }
+}

package/dist/tui/model-picker-data.d.ts

@@ -1,5 +1,5 @@
 import { type ModelInfo, type ProviderProfile, type ProviderRegistry } from "../provider-registry.js";
-type ModelPickerRegistry = Pick<ProviderRegistry, "getEnabled" | "getModelConfig" | "listModels">;
+export type ModelPickerRegistry = Pick<ProviderRegistry, "getEnabled" | "getModelConfig" | "listModels">;
 export type ModelProviderGroup = {
     provider: ProviderProfile;
     models: ModelInfo[];
@@ -7,4 +7,3 @@ export type ModelProviderGroup = {
 export declare function localModelsForProvider(registry: Pick<ProviderRegistry, "getModelConfig">, provider: ProviderProfile): ModelInfo[];
 export declare function getVisibleModelProviders(registry: Pick<ProviderRegistry, "getEnabled">, providerId?: string): ProviderProfile[];
 export declare function discoverModelProviderGroups(registry: ModelPickerRegistry, providerId?: string): Promise<ModelProviderGroup[]>;
-export {};

package/dist/tui/model-picker-data.js

@@ -1,7 +1,8 @@
 import { listBuiltinModels } from "../model-catalog.js";
+import { filterProviderModels } from "../provider-model-policy.js";
 import { isUserVisibleProvider, } from "../provider-registry.js";
 export function localModelsForProvider(registry, provider) {
-    const customModels = registry.getModelConfig().getCustomModels(provider.id);
+    const customModels = filterProviderModels(provider.id, registry.getModelConfig().getCustomModels(provider.id));
     if (customModels.length > 0)
         return customModels;
     const builtinProviderId = provider.id === "openai" && provider.authType === "oauth"
@@ -11,6 +12,12 @@ export function localModelsForProvider(registry, provider) {
         id: model.id,
         name: model.name,
         providerId: provider.id,
+        reasoningLevels: model.reasoningLevels,
+        defaultReasoningLevel: model.defaultReasoningLevel,
+        contextWindow: model.contextWindow,
+        useResponsesLite: model.useResponsesLite,
+        toolOutputTokenLimit: model.toolOutputTokenLimit,
+        tier: model.tier,
     }));
 }
 export function getVisibleModelProviders(registry, providerId) {

package/dist/tui/model-switch.js

@@ -2,6 +2,7 @@ import { decodeModel, displayModel } from "../provider-registry.js";
 import { buildSystemPrompt } from "../system-prompt.js";
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "../provider-transform.js";
 import { normalizeInheritedThinkingLevel } from "../variant/variant-resolver.js";
+import { assertProviderModelAllowed } from "../provider-model-policy.js";
 export function modelSwitchTarget(model, fallbackProviderId) {
     const decoded = decodeModel(model);
     return {
@@ -23,6 +24,7 @@ export function formatModelSwitchError(model, error) {
 }
 export async function switchAgentModel(options) {
     const { providerId, modelId } = modelSwitchTarget(options.model, options.agent.providerId || options.registry.getDefault()?.id);
+    assertProviderModelAllowed(providerId, modelId);
     if (!options.preparedProvider) {
         await options.registry.prepareProvider(providerId);
     }

package/dist/{tui-ink → tui}/run-session-picker.d.ts

@@ -1,10 +1,9 @@
-import type { ResolvedTheme } from "./detect-theme.js";
-import type { SessionSummary } from "../session.js";
+import { SessionSummary } from "../session.js";
 export interface RunSessionPickerOptions {
     currentCwd: string;
     currentSessions: SessionSummary[];
     allSessions: SessionSummary[];
-    resolvedTheme: ResolvedTheme;
+    resolvedTheme?: "light" | "dark";
     themeOverrides?: Record<string, string>;
 }
 export declare function runSessionPicker(options: RunSessionPickerOptions): Promise<string | undefined>;

package/dist/tui/run-session-picker.js

@@ -0,0 +1,64 @@
+/**
+ * Startup `--resume` session picker on the vendored Pi TUI renderer. Contract:
+ * resolve the chosen session file, or undefined on cancel.
+ */
+import { Box, ProcessTerminal, TuiMainScreen, Text, VStack, SelectList } from "@bubblebrain-ai/pi-tui";
+import { paletteFor } from "./model/theme.js";
+import { themeBackground, themeDim, themeForeground } from "./model/theme-style.js";
+export async function runSessionPicker(options) {
+    const terminal = new ProcessTerminal();
+    const tui = new TuiMainScreen(terminal);
+    const theme = paletteFor(options.resolvedTheme ?? "dark", options.themeOverrides);
+    const items = [];
+    for (const summary of options.currentSessions.slice(0, 10)) {
+        items.push({
+            value: summary.file,
+            label: summary.title ?? summary.file.split("/").pop() ?? summary.file,
+            description: "this project",
+        });
+    }
+    const otherCount = options.allSessions.length - options.currentSessions.length;
+    if (otherCount > 0) {
+        for (const summary of options.allSessions.filter((s) => !options.currentSessions.includes(s)).slice(0, 10)) {
+            items.push({
+                value: summary.file,
+                label: summary.title ?? summary.file.split("/").pop() ?? summary.file,
+                description: "other project",
+            });
+        }
+    }
+    if (items.length === 0)
+        return undefined;
+    return new Promise((resolve) => {
+        const finish = (value) => {
+            try {
+                tui.stop();
+            }
+            catch {
+                /* already stopped */
+            }
+            resolve(value);
+        };
+        const header = new VStack([
+            new Text(themeForeground(theme.accent, "Resume session"), 1, 0),
+            new Text(themeDim(theme.dim, "Enter to select · Esc to start fresh"), 1, 0),
+        ]);
+        const list = new SelectList(items, 10, {
+            selectedPrefix: () => themeForeground(theme.accent, "› "),
+            selectedText: (str) => themeForeground(theme.inputText, str),
+            description: (str) => themeDim(theme.dim, str),
+            scrollInfo: (str) => themeDim(theme.dim, str),
+            noMatch: (str) => themeDim(theme.dim, str),
+        }, {});
+        const content = new VStack([header, list]);
+        const box = theme.background
+            ? new Box(0, 0, (text) => themeBackground(theme.background, text))
+            : new Box(0, 0);
+        box.addChild(content);
+        list.onSelect = (item) => finish(item.value);
+        list.onCancel = () => finish(undefined);
+        tui.addChild(box);
+        tui.start();
+        tui.setFocus(list);
+    });
+}

package/dist/tui/run.d.ts

@@ -0,0 +1,72 @@
+import type { Agent } from "../agent.js";
+import type { SessionManager } from "../session.js";
+import type { ProviderRegistry } from "../provider-registry.js";
+import type { SkillRegistry } from "../skills/registry.js";
+import type { PlanDecision } from "../types.js";
+import type { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+import type { QuestionController } from "../question/controller.js";
+import type { BashAllowlist } from "../approval/session-cache.js";
+import type { SettingsManager } from "../permissions/settings.js";
+import type { LspService } from "../lsp/service.js";
+import type { McpManager } from "../mcp/manager.js";
+import type { GoalStore } from "../goal/store.js";
+import type { ProcessManager } from "../tasks/manager.js";
+import type { PromotionChannel } from "../tasks/promotion.js";
+import type { ThemeMode } from "../config.js";
+import type { ExternalHookController } from "../hooks/controller.js";
+import type { ExternalRuntimeManager } from "../external-runtime/types.js";
+import type { FlushScheduler } from "./controller/ports.js";
+export interface RunTuiOptions {
+    sessionManager?: SessionManager;
+    createProvider?: (providerId: string, apiKey: string, baseURL: string) => unknown;
+    registry?: ProviderRegistry;
+    skillRegistry?: SkillRegistry;
+    planHandlerRef?: {
+        current?: (plan: string) => Promise<PlanDecision>;
+    };
+    approvalHandlerRef?: {
+        current?: (request: ApprovalRequest) => Promise<ApprovalDecision>;
+    };
+    questionController?: QuestionController;
+    bashAllowlist?: BashAllowlist;
+    settingsManager?: SettingsManager;
+    switchSession?: (sessionFile: string) => {
+        manager: SessionManager;
+    } | {
+        error: string;
+    };
+    createFreshSession?: (cwd: string) => {
+        manager: SessionManager;
+    } | {
+        error: string;
+    };
+    lspService?: LspService;
+    mcpManager?: McpManager;
+    goalStore?: GoalStore;
+    processManager?: ProcessManager;
+    tasksAutoResume?: boolean;
+    promotionChannel?: PromotionChannel;
+    themeMode?: ThemeMode;
+    themeOverrides?: Record<string, string>;
+    detectedTheme?: "light" | "dark";
+    onThemeModeChange?: (mode: ThemeMode) => void;
+    flushMemory?: () => Promise<void>;
+    runMemoryCompaction?: () => Promise<string>;
+    runMemorySummary?: (scope?: string) => Promise<string>;
+    runMemoryRefresh?: (scope?: string) => Promise<string>;
+    bypassEnabled?: boolean;
+    updateNotice?: string;
+    updateNoticeRefresh?: Promise<string | null>;
+    hookController?: ExternalHookController;
+    externalRuntime?: ExternalRuntimeManager;
+}
+export interface TuiExitSummary {
+    exitCode: number;
+    reason: string;
+    wallMs: number;
+}
+export declare function runTui(agent: Agent, _args: unknown, options: RunTuiOptions): Promise<TuiExitSummary>;
+/** Resolve after first paint so git discovery never delays TUI startup. */
+export declare function currentGitBranch(cwd: string): Promise<string | undefined>;
+/** Production streaming repaint scheduler: one cancellable timer per burst. */
+export declare function createFlushScheduler(): FlushScheduler;