@caupulican/pi-adaptative 0.81.39 → 0.81.41

package/dist/modes/interactive/interactive-mode.js

@@ -4,17 +4,17 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { createCompactionSummaryMessage } from "@caupulican/pi-agent-core";
-import { Container, Loader, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TUI, } from "@caupulican/pi-tui";
-import { APP_NAME, APP_TITLE, VERSION } from "../../config.js";
+import { Container, Loader, ProcessTerminal, Spacer, setKeybindings, Text, TUI, } from "@caupulican/pi-tui";
+import { APP_NAME, APP_TITLE, getAgentDir, VERSION } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { DEFAULT_GOAL_CONTINUE_MAX_STALL_TURNS, DEFAULT_GOAL_CONTINUE_MAX_TURNS, DEFAULT_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES, MAX_GOAL_CONTINUE_MAX_STALL_TURNS, MAX_GOAL_CONTINUE_MAX_TURNS, MAX_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES, } from "../../core/goals/goal-continuation-defaults.js";
 import { configureHttpDispatcher } from "../../core/http-dispatcher.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { formatMissingSessionCwdPrompt } from "../../core/session-cwd.js";
-import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
-import { getCwdRelativePath, resolvePath } from "../../utils/paths.js";
+import { SessionImageStore } from "../../core/session-image-store.js";
+import { isRecordObject } from "../../core/util/value-guards.js";
+import { resolvePath } from "../../utils/paths.js";
 import { ensureTool } from "../../utils/tools-manager.js";
 import { checkForNewPiVersion } from "../../utils/version-check.js";
 import { AuthDialogsController } from "./auth-dialogs-controller.js";
@@ -23,57 +23,46 @@ import * as autocompleteProvider from "./autocomplete-provider.js";
 import * as autonomyCommands from "./autonomy-commands.js";
 import * as clipboardInput from "./clipboard-input.js";
 import * as compactionQueue from "./compaction-queue.js";
+import { ActivityLaneComponent } from "./components/activity-lane.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
 import { BashExecutionComponent } from "./components/bash-execution.js";
 import { BranchSummaryMessageComponent } from "./components/branch-summary-message.js";
 import { CompactionSummaryMessageComponent } from "./components/compaction-summary-message.js";
-import { CountdownTimer } from "./components/countdown-timer.js";
 import { CustomEditor } from "./components/custom-editor.js";
 import { CustomMessageComponent } from "./components/custom-message.js";
 import { DynamicBorder } from "./components/dynamic-border.js";
+import { ExpandableText, isExpandable } from "./components/expandable-text.js";
 import { FooterComponent } from "./components/footer.js";
 import { formatKeyText, keyDisplayText, keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
 import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { ToolGroupComponent } from "./components/tool-group.js";
-import { getToolPanelActionKey, getToolPanelResultActionKeys, shouldReuseToolPanelInPlace, ToolPanelRegistry, } from "./components/tool-panel-registry.js";
+import { getToolPanelActionKey, shouldReuseToolPanelInPlace, ToolPanelRegistry, } from "./components/tool-panel-registry.js";
 import { UserMessageComponent } from "./components/user-message.js";
 import * as configBackup from "./config-backup.js";
 import { EditorOverlayHost } from "./editor-overlay-host.js";
 import { ExtensionUiHost } from "./extension-ui-host.js";
 import { openEditorForPath, openExternalEditor } from "./external-editor.js";
 import * as historyReloadMath from "./history-reload-math.js";
+import { handleInteractiveEvent } from "./interactive-event-controller.js";
 import * as keyHandlers from "./key-handlers.js";
+import { renderLoadedResources } from "./loaded-resources-view.js";
 import * as localModelCommands from "./local-model-commands.js";
 import { ProfileMenuController } from "./profile-menu-controller.js";
 import * as reportCommands from "./report-commands.js";
-import * as resourceDisplay from "./resource-display.js";
 import * as resourceShellCommands from "./resource-shell-commands.js";
 import * as sessionFlows from "./session-flow-commands.js";
 import * as sessionIoCommands from "./session-io-commands.js";
+import { handleNonFatalSessionReplacementError } from "./session-replacement-errors.js";
 import * as settingsSelectorFlow from "./settings-selector-flow.js";
 import * as signalLifecycle from "./signal-lifecycle.js";
 import * as startupChecks from "./startup-checks.js";
 import { getEditorTheme, getMarkdownTheme, initTheme, onThemeChange, setRegisteredThemes, setTheme, stopThemeWatcher, theme, } from "./theme/theme.js";
+import * as usageCommands from "./usage-commands.js";
 const TUI_HISTORY_RELOAD_CHUNK_SIZE = 20;
 const TUI_LIVE_HISTORY_MAX_COMPONENTS = 260;
 const TUI_LIVE_HISTORY_TRIM_TO_COMPONENTS = 220;
 const STREAMING_UI_UPDATE_INTERVAL_MS = 80;
-function isExpandable(obj) {
-    return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
-}
-class ExpandableText extends Text {
-    getCollapsedText;
-    getExpandedText;
-    constructor(getCollapsedText, getExpandedText, expanded = false, paddingX = 0, paddingY = 0) {
-        super(expanded ? getExpandedText() : getCollapsedText(), paddingX, paddingY);
-        this.getCollapsedText = getCollapsedText;
-        this.getExpandedText = getExpandedText;
-    }
-    setExpanded(expanded) {
-        this.setText(expanded ? this.getExpandedText() : this.getCollapsedText());
-    }
-}
 const ANTHROPIC_SUBSCRIPTION_AUTH_WARNING = "Anthropic subscription auth is active. Third-party harness usage draws from extra usage and is billed per token, not your Claude plan limits. Manage extra usage at https://claude.ai/settings/usage.";
 function isAnthropicSubscriptionAuthKey(apiKey) {
     return typeof apiKey === "string" && apiKey.startsWith("sk-ant-oat");
@@ -126,6 +115,7 @@ export class InteractiveMode {
     pendingUserInputs = [];
     pendingClipboardImages = [];
     clipboardImageCounter = 0;
+    clipboardImageStore;
     loadingAnimation = undefined;
     workingMessage = undefined;
     workingVisible = true;
@@ -170,10 +160,8 @@ export class InteractiveMode {
     // Track pending bash components (shown in pending area, moved to chat on submit)
     pendingBashComponents = [];
     // Auto-compaction state
-    autoCompactionLoader = undefined;
     autoCompactionEscapeHandler;
     // Auto-retry state
-    retryLoader = undefined;
     retryCountdown = undefined;
     retryEscapeHandler;
     // Messages queued while compaction is running
@@ -183,6 +171,8 @@ export class InteractiveMode {
     // Extension widget containers (hold components rendered above/below the editor)
     widgetContainerAbove;
     widgetContainerBelow;
+    activityLane;
+    hasHumanAudience;
     // Header container that holds the built-in or custom header
     headerContainer;
     // Built-in header (logo + keybinding hints + changelog)
@@ -204,6 +194,8 @@ export class InteractiveMode {
     constructor(runtimeHost, options = {}) {
         this.runtimeHost = runtimeHost;
         this.options = options;
+        this.hasHumanAudience = options.hasHumanAudience ?? true;
+        this.workingVisible = this.hasHumanAudience;
         this.runtimeHost.setBeforeSessionInvalidate(() => {
             this.extensionUiHost.resetExtensionUI();
         });
@@ -219,6 +211,9 @@ export class InteractiveMode {
         this.statusContainer = new Container();
         this.widgetContainerAbove = new Container();
         this.widgetContainerBelow = new Container();
+        this.activityLane = this.hasHumanAudience
+            ? new ActivityLaneComponent(theme, () => this.ui.requestRender())
+            : undefined;
         this.keybindings = KeybindingsManager.create();
         setKeybindings(this.keybindings);
         const editorPaddingX = this.settingsManager.getEditorPaddingX();
@@ -304,6 +299,7 @@ export class InteractiveMode {
                 },
                 getBuiltInHeader: () => this.builtInHeader,
                 getAutocompleteProvider: () => this.autocompleteProvider,
+                getClipboardImageStore: () => this.clipboardImageStore,
                 getToolsExpanded: () => this.toolOutputExpanded,
                 pushAutocompleteProviderWrapper: (factory) => {
                     this.autocompleteProviderWrappers.push(factory);
@@ -339,19 +335,6 @@ export class InteractiveMode {
         setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
         initTheme(this.settingsManager.getTheme(), true);
     }
-    getBuiltInCommandConflictDiagnostics(extensionRunner) {
-        const builtinNames = new Set(BUILTIN_SLASH_COMMANDS.map((command) => command.name));
-        return extensionRunner
-            .getRegisteredCommands()
-            .filter((command) => builtinNames.has(command.name))
-            .map((command) => ({
-            type: "warning",
-            message: command.invocationName === command.name
-                ? `Extension command '/${command.name}' conflicts with built-in interactive command. Skipping in autocomplete.`
-                : `Extension command '/${command.name}' conflicts with built-in interactive command. Available as '/${command.invocationName}'.`,
-            path: command.sourceInfo.path,
-        }));
-    }
     // Thin delegate retained so setupAutocompleteProvider's base-provider seam
     // (stubbed via prototype in interactive-mode-status.test.ts) keeps working.
     createBaseAutocompleteProvider() {
@@ -472,13 +455,19 @@ export class InteractiveMode {
             this.headerContainer.addChild(this.builtInHeader);
         }
         this.ui.addChild(this.chatContainer);
-        this.ui.addChild(this.pendingMessagesContainer);
-        this.ui.addChild(this.statusContainer);
-        this.extensionUiHost.renderWidgets(); // Initialize with default spacer
-        this.ui.addChild(this.widgetContainerAbove);
+        if (this.hasHumanAudience) {
+            this.ui.addChild(this.pendingMessagesContainer);
+            this.ui.addChild(this.statusContainer);
+            this.extensionUiHost.renderWidgets(); // Initialize with default spacer
+            this.ui.addChild(this.widgetContainerAbove);
+            if (this.activityLane)
+                this.ui.addChild(this.activityLane);
+        }
         this.ui.addChild(this.editorContainer);
-        this.ui.addChild(this.widgetContainerBelow);
-        this.ui.addChild(this.footer);
+        if (this.hasHumanAudience) {
+            this.ui.addChild(this.widgetContainerBelow);
+            this.ui.addChild(this.footer);
+        }
         this.ui.setFocus(this.editor);
         this.setupKeyHandlers();
         this.setupEditorSubmitHandler();
@@ -496,6 +485,7 @@ export class InteractiveMode {
         onThemeChange(() => {
             this.ui.invalidate();
             this.updateEditorBorderColor();
+            this.refreshActivityLane();
             this.ui.requestRender();
         });
         // Set up git branch watcher (uses provider instead of footer)
@@ -535,10 +525,17 @@ export class InteractiveMode {
             }
         });
         // Start package update check asynchronously
-        this.checkForPackageUpdates().then((updates) => {
+        this.checkForPackageUpdates()
+            .then((updates) => {
             if (updates.length > 0) {
                 this.showPackageUpdateNotification(updates);
             }
+        })
+            .finally(() => {
+            // npm can overwrite the shared Windows console title while checking extension versions.
+            if (process.platform === "win32" && this.isInitialized) {
+                this.updateTerminalTitle();
+            }
         });
         // Check tmux keyboard setup asynchronously
         this.checkTmuxKeyboardSetup().then((warning) => {
@@ -617,6 +614,50 @@ export class InteractiveMode {
         this.footerDataProvider.setAutonomyStatusSnapshot(this.session.getAutonomyStatusSnapshot());
         this.footer.invalidate();
     }
+    activityLaneSnapshot() {
+        return {
+            goalState: this.session.getGoalStateSnapshot(),
+            taskState: this.session.getTaskStepsStateSnapshot(),
+            laneRecords: this.session.getLaneRecords(),
+        };
+    }
+    refreshActivityLane(options = {}) {
+        if (!this.activityLane)
+            return;
+        const sessionKey = this.sessionManager.getSessionId();
+        if (options.replace) {
+            this.activityLane.replaceCanonical(sessionKey, this.activityLaneSnapshot());
+        }
+        else {
+            this.activityLane.updateCanonical(sessionKey, this.activityLaneSnapshot());
+        }
+    }
+    toolActivityKind(toolName) {
+        if (toolName === "task_steps")
+            return "task";
+        if (toolName === "goal")
+            return "goal";
+        if (toolName === "delegate" || toolName === "delegate_status")
+            return "worker";
+        return "tool";
+    }
+    toolActivityLabel(toolName) {
+        const label = this.getRegisteredToolDefinition(toolName)?.label?.trim() || toolName;
+        return label.replace(/[_-]+/g, " ").replace(/(^|\s)\S/g, (character) => character.toUpperCase());
+    }
+    toolActivityTerminalStatus(isError, details) {
+        if (isError)
+            return "failure";
+        if (!isRecordObject(details))
+            return "success";
+        if (details.applied === false || details.kind === "error")
+            return "failure";
+        if (details.kind === "review" && details.reviewed === false)
+            return "failure";
+        if (details.started === false)
+            return "neutral";
+        return "success";
+    }
     checkForPackageUpdates() {
         return startupChecks.checkForPackageUpdates(this.startupChecksHost());
     }
@@ -639,220 +680,25 @@ export class InteractiveMode {
     // =========================================================================
     // Extension System
     // =========================================================================
-    // The resource-display formatters below are pure and live in ./resource-display.ts.
-    // These thin `this.`-delegates are retained so showLoadedResources' formatter
-    // injection seam (exercised via prototype stubs in interactive-mode-status.test.ts)
-    // keeps working unchanged.
-    formatDisplayPath(p) {
-        return resourceDisplay.formatDisplayPath(p);
-    }
-    formatExtensionDisplayPath(path) {
-        return resourceDisplay.formatExtensionDisplayPath(path);
-    }
-    formatContextPath(p) {
-        const cwd = path.resolve(this.sessionManager.getCwd());
-        const absolutePath = path.isAbsolute(p) ? path.resolve(p) : path.resolve(cwd, p);
-        const relativePath = getCwdRelativePath(absolutePath, cwd);
-        if (relativePath !== undefined) {
-            return relativePath;
-        }
-        return this.formatDisplayPath(absolutePath);
-    }
     getStartupExpansionState() {
         return this.options.verbose || this.toolOutputExpanded;
     }
-    getShortPath(fullPath, sourceInfo) {
-        return resourceDisplay.getShortPath(fullPath, sourceInfo);
-    }
-    getCompactPathLabel(resourcePath, sourceInfo) {
-        return resourceDisplay.getCompactPathLabel(resourcePath, sourceInfo);
-    }
-    getCompactPackageSourceLabel(sourceInfo) {
-        return resourceDisplay.getCompactPackageSourceLabel(sourceInfo);
-    }
-    getCompactExtensionLabel(resourcePath, sourceInfo) {
-        return resourceDisplay.getCompactExtensionLabel(resourcePath, sourceInfo);
-    }
-    getCompactDisplayPathSegments(resourcePath) {
-        return resourceDisplay.getCompactDisplayPathSegments(resourcePath);
-    }
-    getCompactNonPackageExtensionLabel(resourcePath, index, allPaths) {
-        return resourceDisplay.getCompactNonPackageExtensionLabel(resourcePath, index, allPaths);
-    }
-    getCompactExtensionLabels(extensions) {
-        return resourceDisplay.getCompactExtensionLabels(extensions);
-    }
-    getScopeGroup(sourceInfo) {
-        return resourceDisplay.getScopeGroup(sourceInfo);
-    }
-    isPackageSource(sourceInfo) {
-        return resourceDisplay.isPackageSource(sourceInfo);
-    }
-    buildScopeGroups(items) {
-        return resourceDisplay.buildScopeGroups(items);
-    }
-    formatScopeGroups(groups, options) {
-        return resourceDisplay.formatScopeGroups(groups, options);
-    }
-    formatDiagnostics(diagnostics, sourceInfos) {
-        return resourceDisplay.formatDiagnostics(diagnostics, sourceInfos);
-    }
     showLoadedResources(options) {
-        const showListing = options?.force || this.options.verbose || !this.settingsManager.getQuietStartup();
-        const showDiagnostics = showListing || options?.showDiagnosticsWhenQuiet === true;
-        if (!showListing && !showDiagnostics) {
-            return;
-        }
-        const sectionHeader = (name, color = "mdHeading") => theme.fg(color, `[${name}]`);
-        const formatCompactList = (items, options) => {
-            const labels = items.map((item) => item.trim()).filter((item) => item.length > 0);
-            if (options?.sort !== false) {
-                labels.sort((a, b) => a.localeCompare(b));
-            }
-            return theme.fg("dim", `  ${labels.join(", ")}`);
-        };
-        const addLoadedSection = (name, collapsedBody, expandedBody = collapsedBody, color = "mdHeading") => {
-            const section = new ExpandableText(() => `${sectionHeader(name, color)}\n${collapsedBody}`, () => `${sectionHeader(name, color)}\n${expandedBody}`, this.getStartupExpansionState(), 0, 0);
-            this.chatContainer.addChild(section);
-            this.chatContainer.addChild(new Spacer(1));
-        };
-        const skillsResult = this.session.resourceLoader.getSkills();
-        const promptsResult = this.session.resourceLoader.getPrompts();
-        const themesResult = this.session.resourceLoader.getThemes();
-        const extensions = options?.extensions ??
-            this.session.resourceLoader.getExtensions().extensions.map((extension) => ({
-                path: extension.path,
-                sourceInfo: extension.sourceInfo,
-            }));
-        const sourceInfos = new Map();
-        for (const extension of extensions) {
-            if (extension.sourceInfo) {
-                sourceInfos.set(extension.path, extension.sourceInfo);
-            }
-        }
-        for (const skill of skillsResult.skills) {
-            if (skill.sourceInfo) {
-                sourceInfos.set(skill.filePath, skill.sourceInfo);
-            }
-        }
-        for (const prompt of promptsResult.prompts) {
-            if (prompt.sourceInfo) {
-                sourceInfos.set(prompt.filePath, prompt.sourceInfo);
-            }
-        }
-        for (const loadedTheme of themesResult.themes) {
-            if (loadedTheme.sourcePath && loadedTheme.sourceInfo) {
-                sourceInfos.set(loadedTheme.sourcePath, loadedTheme.sourceInfo);
-            }
-        }
-        if (showListing) {
-            const contextFiles = this.session.resourceLoader.getAgentsFiles().agentsFiles;
-            if (contextFiles.length > 0) {
-                this.chatContainer.addChild(new Spacer(1));
-                const contextList = contextFiles
-                    .map((f) => theme.fg("dim", `  ${this.formatDisplayPath(f.path)}`))
-                    .join("\n");
-                const contextCompactList = formatCompactList(contextFiles.map((contextFile) => this.formatContextPath(contextFile.path)), { sort: false });
-                addLoadedSection("Context", contextCompactList, contextList);
-            }
-            const skills = this.session.resourceLoader.getActiveSkills();
-            if (skills.length > 0) {
-                const groups = this.buildScopeGroups(skills.map((skill) => ({ path: skill.filePath, sourceInfo: skill.sourceInfo })));
-                const skillList = this.formatScopeGroups(groups, {
-                    formatPath: (item) => this.formatDisplayPath(item.path),
-                    formatPackagePath: (item) => this.getShortPath(item.path, item.sourceInfo),
-                });
-                const skillCompactList = formatCompactList(skills.map((skill) => skill.name));
-                addLoadedSection("Skills", skillCompactList, skillList);
-            }
-            const templates = this.session.promptTemplates;
-            if (templates.length > 0) {
-                const groups = this.buildScopeGroups(templates.map((template) => ({ path: template.filePath, sourceInfo: template.sourceInfo })));
-                const templateByPath = new Map(templates.map((t) => [t.filePath, t]));
-                const templateList = this.formatScopeGroups(groups, {
-                    formatPath: (item) => {
-                        const template = templateByPath.get(item.path);
-                        return template ? `/${template.name}` : this.formatDisplayPath(item.path);
-                    },
-                    formatPackagePath: (item) => {
-                        const template = templateByPath.get(item.path);
-                        return template ? `/${template.name}` : this.formatDisplayPath(item.path);
-                    },
-                });
-                const promptCompactList = formatCompactList(templates.map((template) => `/${template.name}`));
-                addLoadedSection("Prompts", promptCompactList, templateList);
-            }
-            if (extensions.length > 0) {
-                const groups = this.buildScopeGroups(extensions);
-                const extList = this.formatScopeGroups(groups, {
-                    formatPath: (item) => this.formatExtensionDisplayPath(item.path),
-                    formatPackagePath: (item) => this.formatExtensionDisplayPath(this.getShortPath(item.path, item.sourceInfo)),
-                });
-                const extensionCompactList = formatCompactList(this.getCompactExtensionLabels(extensions));
-                addLoadedSection("Extensions", extensionCompactList, extList, "mdHeading");
-            }
-            // Show loaded themes (excluding built-in)
-            const loadedThemes = themesResult.themes;
-            const customThemes = loadedThemes.filter((t) => t.sourcePath);
-            if (customThemes.length > 0) {
-                const groups = this.buildScopeGroups(customThemes.map((loadedTheme) => ({
-                    path: loadedTheme.sourcePath,
-                    sourceInfo: loadedTheme.sourceInfo,
-                })));
-                const themeList = this.formatScopeGroups(groups, {
-                    formatPath: (item) => this.formatDisplayPath(item.path),
-                    formatPackagePath: (item) => this.getShortPath(item.path, item.sourceInfo),
-                });
-                const themeCompactList = formatCompactList(customThemes.map((loadedTheme) => loadedTheme.name ?? this.getCompactPathLabel(loadedTheme.sourcePath, loadedTheme.sourceInfo)));
-                addLoadedSection("Themes", themeCompactList, themeList);
-            }
-        }
-        if (showDiagnostics) {
-            const skillDiagnostics = skillsResult.diagnostics;
-            if (skillDiagnostics.length > 0) {
-                const warningLines = this.formatDiagnostics(skillDiagnostics, sourceInfos);
-                this.chatContainer.addChild(new Text(`${theme.fg("warning", "[Skill conflicts]")}\n${warningLines}`, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
-            }
-            const promptDiagnostics = promptsResult.diagnostics;
-            if (promptDiagnostics.length > 0) {
-                const warningLines = this.formatDiagnostics(promptDiagnostics, sourceInfos);
-                this.chatContainer.addChild(new Text(`${theme.fg("warning", "[Prompt conflicts]")}\n${warningLines}`, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
-            }
-            const extensionDiagnostics = [];
-            const extensionErrors = this.session.resourceLoader.getExtensions().errors;
-            if (extensionErrors.length > 0) {
-                for (const error of extensionErrors) {
-                    extensionDiagnostics.push({ type: "error", message: error.error, path: error.path });
-                }
-            }
-            const commandDiagnostics = this.session.extensionRunner.getCommandDiagnostics();
-            extensionDiagnostics.push(...commandDiagnostics);
-            extensionDiagnostics.push(...this.getBuiltInCommandConflictDiagnostics(this.session.extensionRunner));
-            const shortcutDiagnostics = this.session.extensionRunner.getShortcutDiagnostics();
-            extensionDiagnostics.push(...shortcutDiagnostics);
-            if (extensionDiagnostics.length > 0) {
-                const warningLines = this.formatDiagnostics(extensionDiagnostics, sourceInfos);
-                this.chatContainer.addChild(new Text(`${theme.fg("warning", "[Extension issues]")}\n${warningLines}`, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
-            }
-            const themeDiagnostics = themesResult.diagnostics;
-            if (themeDiagnostics.length > 0) {
-                const warningLines = this.formatDiagnostics(themeDiagnostics, sourceInfos);
-                this.chatContainer.addChild(new Text(`${theme.fg("warning", "[Theme conflicts]")}\n${warningLines}`, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
-            }
-        }
+        renderLoadedResources({
+            session: this.session,
+            chatContainer: this.chatContainer,
+            verbose: this.options.verbose ?? false,
+            expanded: this.getStartupExpansionState(),
+        }, options);
     }
     /**
      * Initialize the extension system with TUI-based UI context.
      */
     async bindCurrentSessionExtensions() {
-        const uiContext = this.extensionUiHost.createExtensionUIContext();
+        const uiContext = this.hasHumanAudience ? this.extensionUiHost.createExtensionUIContext() : undefined;
         await this.session.bindExtensions({
             uiContext,
-            mode: "tui",
+            mode: this.hasHumanAudience ? "tui" : "print",
             abortHandler: () => {
                 this.restoreQueuedMessagesToEditor({ abort: true });
             },
@@ -873,6 +719,9 @@ export class InteractiveMode {
                         return result;
                     }
                     catch (error) {
+                        const disposition = this.handleNonFatalSessionReplacementError(error);
+                        if (disposition)
+                            return { cancelled: disposition === "previous_restored" };
                         return this.handleFatalRuntimeError("Failed to create session", error);
                     }
                 },
@@ -887,6 +736,9 @@ export class InteractiveMode {
                         return { cancelled: result.cancelled };
                     }
                     catch (error) {
+                        const disposition = this.handleNonFatalSessionReplacementError(error);
+                        if (disposition)
+                            return { cancelled: disposition === "previous_restored" };
                         return this.handleFatalRuntimeError("Failed to fork session", error);
                     }
                 },
@@ -952,6 +804,18 @@ export class InteractiveMode {
     async rebindCurrentSession() {
         this.unsubscribe?.();
         this.unsubscribe = undefined;
+        this.pendingClipboardImages = [];
+        this.clipboardImageCounter = 0;
+        const clipboardImageDirectory = this.settingsManager.getClipboardImageDirectory();
+        this.clipboardImageStore =
+            this.sessionManager.isPersisted() || clipboardImageDirectory
+                ? new SessionImageStore({
+                    agentDir: getAgentDir(),
+                    cwd: this.sessionManager.getCwd(),
+                    sessionId: this.sessionManager.getSessionId(),
+                    directory: clipboardImageDirectory,
+                })
+                : undefined;
         this.applyRuntimeSettings();
         await this.bindCurrentSessionExtensions();
         this.subscribeToAgent();
@@ -959,6 +823,13 @@ export class InteractiveMode {
         await this.updateAvailableProviderCount();
         this.updateEditorBorderColor();
         this.updateTerminalTitle();
+        this.refreshActivityLane({ replace: true });
+        try {
+            await this.session.resumePendingHumanInput();
+        }
+        catch (error) {
+            this.showError(`Failed to resume pending user input: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
     subscribeToExtensionsChanged() {
         this.unsubscribeExtensionsChanged?.();
@@ -973,6 +844,12 @@ export class InteractiveMode {
         this.stop();
         process.exit(1);
     }
+    handleNonFatalSessionReplacementError(error) {
+        return handleNonFatalSessionReplacementError({
+            renderCurrentSessionState: () => this.renderCurrentSessionState(),
+            showError: (message) => this.showError(message),
+        }, error);
+    }
     renderCurrentSessionState() {
         this.pendingMessagesContainer.clear();
         this.compactionQueuedMessages = [];
@@ -1041,21 +918,21 @@ export class InteractiveMode {
             return;
         }
     }
-    attachToolExecutionComponent(toolName, toolCallId, args, repair) {
+    attachToolExecutionComponent(toolName, toolCallId, args, repair, deferResultUntilExpanded = false) {
         const actionKey = getToolPanelActionKey(this.getToolPanelScope(), toolName, args);
         const toolDefinition = this.getRegisteredToolDefinition(toolName);
         const reuseInPlace = shouldReuseToolPanelInPlace(toolName, args);
         const existing = this.toolPanels.getReusable(actionKey, { allowActive: reuseInPlace });
         if (existing) {
             if (reuseInPlace && actionKey) {
-                existing.resetInvocation(toolName, toolCallId, args, toolDefinition, repair);
+                existing.resetInvocation(toolName, toolCallId, args, toolDefinition, repair, deferResultUntilExpanded);
                 existing.setExpanded(this.toolOutputExpanded);
                 this.toolPanels.replaceActiveForAction(toolCallId, existing, actionKey);
                 this.ui.requestRender();
                 return existing;
             }
             this.detachToolExecutionComponent(existing);
-            existing.resetInvocation(toolName, toolCallId, args, toolDefinition, repair);
+            existing.resetInvocation(toolName, toolCallId, args, toolDefinition, repair, deferResultUntilExpanded);
             existing.setExpanded(this.toolOutputExpanded);
             this.appendToolExecutionComponent(existing, true);
             this.toolPanels.register(toolCallId, existing, actionKey);
@@ -1065,6 +942,7 @@ export class InteractiveMode {
             showImages: this.settingsManager.getShowImages(),
             imageWidthCells: this.settingsManager.getImageWidthCells(),
             repair,
+            deferResultUntilExpanded,
         }, toolDefinition, this.ui, this.sessionManager.getCwd());
         component.setExpanded(this.toolOutputExpanded);
         this.appendToolExecutionComponent(component, true);
@@ -1089,8 +967,15 @@ export class InteractiveMode {
             this.loadingAnimation = undefined;
         }
         this.statusContainer.clear();
+        this.activityLane?.remove("runtime:routing");
+        this.activityLane?.remove("runtime:turn");
     }
     setWorkingVisible(visible) {
+        if (!this.hasHumanAudience) {
+            this.workingVisible = false;
+            this.stopWorkingLoader();
+            return;
+        }
         this.workingVisible = visible;
         if (!visible) {
             this.stopWorkingLoader();
@@ -1098,15 +983,39 @@ export class InteractiveMode {
             return;
         }
         if (this.session.isStreaming && !this.loadingAnimation) {
-            this.statusContainer.clear();
-            this.loadingAnimation = this.createWorkingLoader();
-            this.statusContainer.addChild(this.loadingAnimation);
+            if (this.workingIndicatorOptions) {
+                this.statusContainer.clear();
+                this.loadingAnimation = this.createWorkingLoader();
+                this.statusContainer.addChild(this.loadingAnimation);
+            }
+            else {
+                this.activityLane?.start({ id: "runtime:turn", kind: "runtime", label: this.getWorkingLoaderMessage() });
+            }
         }
         this.ui.requestRender();
     }
     setWorkingIndicator(options) {
         this.workingIndicatorOptions = options;
-        this.loadingAnimation?.setIndicator(options);
+        if (!this.hasHumanAudience) {
+            this.stopWorkingLoader();
+            return;
+        }
+        if (options) {
+            this.activityLane?.remove("runtime:turn");
+            if (this.session.isStreaming && this.workingVisible) {
+                this.stopWorkingLoader();
+                this.loadingAnimation = this.createWorkingLoader();
+                this.statusContainer.addChild(this.loadingAnimation);
+            }
+        }
+        else {
+            this.loadingAnimation?.stop();
+            this.loadingAnimation = undefined;
+            this.statusContainer.clear();
+            if (this.session.isStreaming && this.workingVisible) {
+                this.activityLane?.start({ id: "runtime:turn", kind: "runtime", label: this.getWorkingLoaderMessage() });
+            }
+        }
         this.ui.requestRender();
     }
     setHiddenThinkingLabel(label) {
@@ -1129,13 +1038,14 @@ export class InteractiveMode {
         if (this.loadingAnimation) {
             this.loadingAnimation.setMessage(message ?? this.defaultWorkingMessage);
         }
+        this.activityLane?.update("runtime:turn", message ?? this.defaultWorkingMessage);
     }
     /**
      * Reset the working indicator and hidden-thinking label to their built-in defaults.
      */
     resetWorkingIndicators() {
         this.workingMessage = undefined;
-        this.workingVisible = true;
+        this.workingVisible = this.hasHumanAudience;
         this.setWorkingIndicator();
         if (this.loadingAnimation) {
             this.loadingAnimation.setMessage(`${this.defaultWorkingMessage} (${keyText("app.interrupt")} to interrupt)`);
@@ -1201,6 +1111,8 @@ export class InteractiveMode {
     }
     handleClipboardImagePaste() {
         const self = this;
+        const selectedModel = this.session?.model;
+        const modelCannotSeeImages = selectedModel ? !selectedModel.input.includes("image") : false;
         return clipboardInput.handleClipboardImagePaste({
             get pendingClipboardImages() {
                 return self.pendingClipboardImages;
@@ -1216,6 +1128,12 @@ export class InteractiveMode {
             },
             editor: this.editor,
             ui: this.ui,
+            autoResizeImages: this.settingsManager.getImageAutoResize(),
+            blockImages: this.settingsManager.getBlockImages() || modelCannotSeeImages,
+            blockImagesReason: modelCannotSeeImages
+                ? "The selected model does not accept image input. Switch to an image-capable model or route this inspection to a vision worker."
+                : undefined,
+            imageStore: this.clipboardImageStore,
             showStatus: (message) => this.showStatus(message),
             showWarning: (message) => this.showWarning(message),
         });
@@ -1235,6 +1153,7 @@ export class InteractiveMode {
             set clipboardImageCounter(value) {
                 self.clipboardImageCounter = value;
             },
+            clipboardImageStore: this.clipboardImageStore,
         }, text);
     }
     buildUserInputSubmission(text) {
@@ -1412,7 +1331,12 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
-            if (text === "/usage" || text === "/cost") {
+            if (text === "/usage") {
+                this.handleUsageMenuCommand();
+                this.editor.setText("");
+                return;
+            }
+            if (text === "/cost") {
                 this.handleUsageCommand();
                 this.editor.setText("");
                 return;
@@ -1567,317 +1491,8 @@ export class InteractiveMode {
             await this.handleEvent(event);
         });
     }
-    async handleEvent(event) {
-        if (!this.isInitialized) {
-            await this.init();
-        }
-        this.footer.invalidate();
-        switch (event.type) {
-            // Part B: general "the system is processing" feedback for the routing/prep gap before a
-            // turn starts streaming (the judge is a real bounded LLM call, not instant) — independent
-            // of thinking level, since this isn't model-thinking. Reuses the same working loader
-            // agent_start below uses, so the hand-off into real streaming is the same
-            // stop-then-recreate it already does — no distinct spinner, no double-render.
-            case "routing_start":
-                if (!this.session.isStreaming && !this.loadingAnimation && this.workingVisible) {
-                    this.loadingAnimation = this.createWorkingLoader();
-                    this.statusContainer.addChild(this.loadingAnimation);
-                    this.ui.requestRender();
-                }
-                break;
-            case "routing_end":
-                // Unconditional: covers both a clean hand-off into agent_start (which immediately
-                // stops-and-recreates its own loader anyway) and a turn that failed before ever
-                // starting, which must not leave the indicator spinning forever.
-                this.stopWorkingLoader();
-                this.ui.requestRender();
-                break;
-            case "agent_start":
-                this.clearActiveToolCalls();
-                if (this.settingsManager.getShowTerminalProgress()) {
-                    this.ui.terminal.setProgress(true);
-                }
-                // Restore main escape handler if retry handler is still active
-                // (retry success event fires later, but we need main handler now)
-                if (this.retryEscapeHandler) {
-                    this.defaultEditor.onEscape = this.retryEscapeHandler;
-                    this.retryEscapeHandler = undefined;
-                }
-                if (this.retryCountdown) {
-                    this.retryCountdown.dispose();
-                    this.retryCountdown = undefined;
-                }
-                if (this.retryLoader) {
-                    this.retryLoader.stop();
-                    this.retryLoader = undefined;
-                }
-                this.stopWorkingLoader();
-                if (this.workingVisible) {
-                    this.loadingAnimation = this.createWorkingLoader();
-                    this.statusContainer.addChild(this.loadingAnimation);
-                }
-                this.ui.requestRender();
-                break;
-            case "queue_update":
-                this.updatePendingMessagesDisplay();
-                this.ui.requestRender();
-                break;
-            case "session_info_changed":
-                this.updateTerminalTitle();
-                this.footer.invalidate();
-                this.ui.requestRender();
-                break;
-            case "thinking_level_changed":
-                this.footer.invalidate();
-                this.updateEditorBorderColor();
-                break;
-            case "warning":
-                this.showWarning(event.message);
-                break;
-            case "delegate_workers": {
-                const activeParts = [
-                    event.running > 0 ? `${event.running} running` : undefined,
-                    event.queued > 0 ? `${event.queued} queued` : undefined,
-                ].filter((part) => part !== undefined);
-                const latestTerminal = event.terminalSinceFlush.at(-1);
-                const terminalStatus = event.terminalSinceFlush.length === 1 && latestTerminal
-                    ? `${latestTerminal.laneId} ${latestTerminal.status}`
-                    : event.failedSinceFlush > 0
-                        ? `${event.failedSinceFlush} failed`
-                        : event.completedSinceFlush > 0
-                            ? `${event.completedSinceFlush} completed`
-                            : undefined;
-                const status = activeParts.length > 0 ? activeParts.join(", ") : terminalStatus;
-                this.footerDataProvider.setExtensionStatus("delegate", status ? `delegate: ${status}` : undefined);
-                this.footer.invalidate();
-                break;
-            }
-            case "message_start":
-                if (event.message.role === "custom") {
-                    this.addMessageToChat(event.message);
-                    this.ui.requestRender();
-                }
-                else if (event.message.role === "user") {
-                    this.addMessageToChat(event.message);
-                    this.updatePendingMessagesDisplay();
-                    this.ui.requestRender();
-                }
-                else if (event.message.role === "assistant") {
-                    this.clearPendingStreamingUiUpdate();
-                    this.lastStreamingUiUpdateAt = 0;
-                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
-                    this.streamingMessage = event.message;
-                    this.chatContainer.addChild(this.streamingComponent);
-                    this.applyStreamingMessageUpdate(this.streamingMessage, { force: true });
-                    this.trimLiveTuiHistory();
-                }
-                break;
-            case "message_update":
-                if (this.streamingComponent && event.message.role === "assistant") {
-                    this.applyStreamingMessageUpdate(event.message);
-                }
-                break;
-            case "message_end":
-                if (event.message.role === "user")
-                    break;
-                if (this.streamingComponent && event.message.role === "assistant") {
-                    this.streamingMessage = event.message;
-                    let errorMessage;
-                    if (this.streamingMessage.stopReason === "aborted") {
-                        const retryAttempt = this.session.retryAttempt;
-                        errorMessage =
-                            retryAttempt > 0
-                                ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
-                                : "Operation aborted";
-                        this.streamingMessage.errorMessage = errorMessage;
-                    }
-                    this.applyStreamingMessageUpdate(this.streamingMessage, { force: true });
-                    if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
-                        if (!errorMessage) {
-                            errorMessage = this.streamingMessage.errorMessage || "Error";
-                        }
-                        for (const [, component] of this.toolPanels.activeEntries()) {
-                            component.updateResult({
-                                content: [{ type: "text", text: errorMessage }],
-                                isError: true,
-                            });
-                        }
-                        this.clearActiveToolCalls();
-                    }
-                    else {
-                        // Args are now complete - trigger diff computation for edit tools
-                        for (const [, component] of this.toolPanels.activeEntries()) {
-                            component.setArgsComplete();
-                        }
-                    }
-                    this.streamingComponent = undefined;
-                    this.streamingMessage = undefined;
-                    this.footer.invalidate();
-                }
-                this.ui.requestRender();
-                break;
-            case "tool_execution_start": {
-                let component = this.toolPanels.getActive(event.toolCallId);
-                if (!component)
-                    component = this.attachToolExecutionComponent(event.toolName, event.toolCallId, event.args, event.repair);
-                else
-                    component.updateArgs(event.args, event.repair);
-                component.markExecutionStarted(event.repair);
-                this.ui.requestRender();
-                break;
-            }
-            case "tool_execution_update": {
-                const component = this.toolPanels.getActive(event.toolCallId);
-                if (component) {
-                    component.updateArgs(event.args, event.repair);
-                    component.updateResult({ ...event.partialResult, isError: false }, true);
-                    this.ui.requestRender();
-                }
-                break;
-            }
-            case "tool_execution_end": {
-                const component = this.toolPanels.getActive(event.toolCallId);
-                if (component) {
-                    component.updateResult({ ...event.result, isError: event.isError });
-                    this.toolPanels.registerAliases(component, getToolPanelResultActionKeys(this.getToolPanelScope(), event.toolName, event.result));
-                    this.toolPanels.finish(event.toolCallId);
-                    this.ui.requestRender();
-                }
-                break;
-            }
-            case "agent_end":
-                // Native in-process reflection fully replaces the subprocess learning paths
-                // (continuous-learning AND autonomy-review) when enabled; otherwise fall back to legacy.
-                if (this.isNativeReflectionEnabled()) {
-                    this.maybeRunNativeReflection(event.messages);
-                }
-                else if (!this.maybeStartAutoLearn()) {
-                    this.maybeStartAutonomyReview(event.messages);
-                }
-                if (this.settingsManager.getShowTerminalProgress()) {
-                    this.ui.terminal.setProgress(false);
-                }
-                if (this.loadingAnimation) {
-                    this.loadingAnimation.stop();
-                    this.loadingAnimation = undefined;
-                    this.statusContainer.clear();
-                }
-                if (this.streamingComponent) {
-                    this.chatContainer.removeChild(this.streamingComponent);
-                    this.streamingComponent = undefined;
-                    this.streamingMessage = undefined;
-                }
-                this.clearActiveToolCalls();
-                await this.checkShutdownRequested();
-                this.ui.requestRender();
-                break;
-            case "compaction_start": {
-                if (this.settingsManager.getShowTerminalProgress()) {
-                    this.ui.terminal.setProgress(true);
-                }
-                // Keep editor active; submissions are queued during compaction.
-                this.autoCompactionEscapeHandler = this.defaultEditor.onEscape;
-                this.defaultEditor.onEscape = () => {
-                    this.session.abortCompaction();
-                };
-                this.statusContainer.clear();
-                const cancelHint = `(${keyText("app.interrupt")} to cancel)`;
-                const label = event.reason === "manual"
-                    ? `Compacting context... ${cancelHint}`
-                    : `${event.reason === "overflow" ? "Context overflow detected, " : ""}Auto-compacting... ${cancelHint}`;
-                this.autoCompactionLoader = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), label);
-                this.statusContainer.addChild(this.autoCompactionLoader);
-                this.ui.requestRender();
-                break;
-            }
-            case "compaction_end": {
-                if (this.settingsManager.getShowTerminalProgress()) {
-                    this.ui.terminal.setProgress(false);
-                }
-                if (this.autoCompactionEscapeHandler) {
-                    this.defaultEditor.onEscape = this.autoCompactionEscapeHandler;
-                    this.autoCompactionEscapeHandler = undefined;
-                }
-                if (this.autoCompactionLoader) {
-                    this.autoCompactionLoader.stop();
-                    this.autoCompactionLoader = undefined;
-                    this.statusContainer.clear();
-                }
-                if (event.aborted) {
-                    if (event.reason === "manual") {
-                        this.showError("Compaction cancelled");
-                    }
-                    else {
-                        this.showStatus("Auto-compaction cancelled");
-                    }
-                }
-                else if (event.result) {
-                    await this.rebuildChatFromMessages();
-                    this.addMessageToChat(createCompactionSummaryMessage(event.result.summary, event.result.tokensBefore, new Date().toISOString()));
-                    this.footer.invalidate();
-                }
-                else if (event.errorMessage) {
-                    if (event.reason === "manual") {
-                        this.showError(event.errorMessage);
-                    }
-                    else {
-                        this.chatContainer.addChild(new Spacer(1));
-                        this.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
-                    }
-                }
-                else if (event.skipReason) {
-                    // Benign auto-compaction no-op: still tell the user WHY nothing changed —
-                    // an invisible skip is indistinguishable from broken compaction.
-                    this.showStatus(`Auto-compaction skipped: ${event.skipReason}`);
-                }
-                void this.flushCompactionQueue({ willRetry: event.willRetry });
-                this.ui.requestRender();
-                break;
-            }
-            case "auto_retry_start": {
-                // Set up escape to abort retry
-                this.retryEscapeHandler = this.defaultEditor.onEscape;
-                this.defaultEditor.onEscape = () => {
-                    this.session.abortRetry();
-                };
-                // Show retry indicator
-                this.statusContainer.clear();
-                this.retryCountdown?.dispose();
-                const retryMessage = (seconds) => `Retrying (${event.attempt}/${event.maxAttempts}) in ${seconds}s... (${keyText("app.interrupt")} to cancel)`;
-                this.retryLoader = new Loader(this.ui, (spinner) => theme.fg("warning", spinner), (text) => theme.fg("muted", text), retryMessage(Math.ceil(event.delayMs / 1000)));
-                this.retryCountdown = new CountdownTimer(event.delayMs, this.ui, (seconds) => {
-                    this.retryLoader?.setMessage(retryMessage(seconds));
-                }, () => {
-                    this.retryCountdown = undefined;
-                });
-                this.statusContainer.addChild(this.retryLoader);
-                this.ui.requestRender();
-                break;
-            }
-            case "auto_retry_end": {
-                // Restore escape handler
-                if (this.retryEscapeHandler) {
-                    this.defaultEditor.onEscape = this.retryEscapeHandler;
-                    this.retryEscapeHandler = undefined;
-                }
-                if (this.retryCountdown) {
-                    this.retryCountdown.dispose();
-                    this.retryCountdown = undefined;
-                }
-                // Stop loader
-                if (this.retryLoader) {
-                    this.retryLoader.stop();
-                    this.retryLoader = undefined;
-                    this.statusContainer.clear();
-                }
-                // Show error only on final failure (success shows normal response)
-                if (!event.success) {
-                    this.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`);
-                }
-                this.ui.requestRender();
-                break;
-            }
-        }
+    handleEvent(event) {
+        return handleInteractiveEvent(this, event);
     }
     /** Extract text content from a user message */
     // Thin `this.`-delegate to the pure formatter in ./history-reload-math.ts; kept so
@@ -2070,6 +1685,8 @@ export class InteractiveMode {
      * we update the previous status line instead of appending new ones to avoid log spam.
      */
     showStatus(message) {
+        if (!this.hasHumanAudience)
+            return;
         this.appendStatusToChat(message);
     }
     addMessageToChat(message, options) {
@@ -2152,7 +1769,9 @@ export class InteractiveMode {
     // Thin `this.`-delegate to the pure reload-window math in ./history-reload-math.ts;
     // kept so renderSessionContext and the prototype-based history tests resolve it via `this`.
     messagesForTuiHistoryReload(messages) {
-        return historyReloadMath.messagesForTuiHistoryReload(messages);
+        return historyReloadMath.messagesForTuiHistoryReload(messages, {
+            includeToolResultContent: this.toolOutputExpanded,
+        });
     }
     /**
      * Render session context to chat. Used for initial load and rebuild after compaction.
@@ -2203,7 +1822,7 @@ export class InteractiveMode {
                         // Render tool call components
                         for (const content of message.content) {
                             if (content.type === "toolCall") {
-                                const component = this.attachToolExecutionComponent(content.name, content.id, content.arguments);
+                                const component = this.attachToolExecutionComponent(content.name, content.id, content.arguments, undefined, true);
                                 if (message.stopReason === "aborted" || message.stopReason === "error") {
                                     let errorMessage;
                                     if (message.stopReason === "aborted") {
@@ -2580,20 +2199,28 @@ export class InteractiveMode {
     }
     updatePendingMessagesDisplay() {
         this.pendingMessagesContainer.clear();
+        for (const component of this.pendingBashComponents)
+            this.pendingMessagesContainer.addChild(component);
         const { steering: steeringMessages, followUp: followUpMessages } = this.getAllQueuedMessages();
-        if (steeringMessages.length > 0 || followUpMessages.length > 0) {
-            this.pendingMessagesContainer.addChild(new Spacer(1));
-            for (const message of steeringMessages) {
-                const text = theme.fg("dim", `Steering: ${message}`);
-                this.pendingMessagesContainer.addChild(new TruncatedText(text, 1, 0));
-            }
-            for (const message of followUpMessages) {
-                const text = theme.fg("dim", `Follow-up: ${message}`);
-                this.pendingMessagesContainer.addChild(new TruncatedText(text, 1, 0));
-            }
+        const steeringCount = steeringMessages.length;
+        const followUpCount = followUpMessages.length;
+        const total = steeringCount + followUpCount;
+        if (total > 0) {
             const dequeueHint = this.getAppKeyDisplay("app.message.dequeue");
-            const hintText = theme.fg("dim", `↳ ${dequeueHint} to edit all queued messages`);
-            this.pendingMessagesContainer.addChild(new TruncatedText(hintText, 1, 0));
+            const details = [
+                steeringCount > 0 ? `${steeringCount} steering` : undefined,
+                followUpCount > 0 ? `${followUpCount} follow-up` : undefined,
+            ]
+                .filter((value) => value !== undefined)
+                .join(" · ");
+            this.activityLane?.wait({
+                id: "queue:messages",
+                kind: "queue",
+                label: `Queued ${total} · ${details} · ${dequeueHint} edit`,
+            });
+        }
+        else {
+            this.activityLane?.remove("queue:messages");
         }
     }
     restoreQueuedMessagesToEditor(options) {
@@ -2690,6 +2317,7 @@ export class InteractiveMode {
             showSelector: (create) => this.showSelector(create),
             showStatus: (message) => this.showStatus(message),
             showError: (message) => this.showError(message),
+            refreshAutonomyFooterStatus: () => this.refreshAutonomyFooterStatus(),
             renderCurrentSessionState: () => this.renderCurrentSessionState(),
             renderInitialMessages: (options) => this.renderInitialMessages(options),
             flushCompactionQueue: (options) => this.flushCompactionQueue(options),
@@ -3210,7 +2838,7 @@ export class InteractiveMode {
         }, text);
     }
     parseGoalContinueCommand(text) {
-        const usage = "Usage: /goal-continue [maxTurns 1-20] [maxStallTurns 0-100] [maxMinutes 0-1440]";
+        const usage = "Usage: /goal-continue [maxTurns 0=unbounded] [maxStallTurns 0-100] [maxMinutes 0-1440]";
         const parts = text.trim().split(/\s+/).slice(1);
         if (parts.length > 3) {
             return { ok: false, error: usage };
@@ -3225,7 +2853,7 @@ export class InteractiveMode {
                 return undefined;
             return parsed;
         };
-        const maxTurns = parseBoundedInteger(parts[0], DEFAULT_GOAL_CONTINUE_MAX_TURNS, 1, MAX_GOAL_CONTINUE_MAX_TURNS);
+        const maxTurns = parseBoundedInteger(parts[0], DEFAULT_GOAL_CONTINUE_MAX_TURNS, 0, MAX_GOAL_CONTINUE_MAX_TURNS);
         const maxStallTurns = parseBoundedInteger(parts[1], DEFAULT_GOAL_CONTINUE_MAX_STALL_TURNS, 0, MAX_GOAL_CONTINUE_MAX_STALL_TURNS);
         const maxWallClockMinutes = parseBoundedInteger(parts[2], DEFAULT_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES, 0, MAX_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES);
         if (maxTurns === undefined || maxStallTurns === undefined || maxWallClockMinutes === undefined) {
@@ -3234,28 +2862,45 @@ export class InteractiveMode {
         return { ok: true, maxTurns, maxStallTurns, maxWallClockMinutes };
     }
     async handleGoalCommand(text) {
+        let statusMessage;
         await sessionFlows.handleGoalCommand({
             session: this.session,
-            showStatus: (message) => this.showStatus(message),
+            promptForGoalEdit: (currentObjective) => this.extensionUiHost.showExtensionEditor("Edit goal objective", currentObjective),
+            getMaxStallTurns: () => this.settingsManager?.getAutonomySettings().maxStallTurns ?? 20,
+            showStatus: (message) => {
+                statusMessage = message;
+            },
             showError: (message) => this.showError(message),
             refreshAutonomyFooterStatus: () => this.refreshAutonomyFooterStatus(),
         }, text);
+        this.refreshActivityLane?.();
+        if (statusMessage)
+            this.activityLane?.announce(statusMessage, "neutral");
     }
     handleTaskCommand(text) {
+        let statusMessage;
         sessionFlows.handleTaskCommand({
             session: this.session,
-            showStatus: (message) => this.showStatus(message),
+            showStatus: (message) => {
+                statusMessage = message;
+            },
             showError: (message) => this.showError(message),
         }, text);
+        this.refreshActivityLane?.();
+        const state = this.session.getTaskStepsStateSnapshot();
+        if ((!state || state.steps.length === 0 || statusMessage?.startsWith("/task ")) && statusMessage) {
+            this.activityLane?.announce(statusMessage, "neutral");
+        }
     }
     async handleGoalContinueCommand(text) {
         await sessionFlows.handleGoalContinueCommand({
             session: this.session,
             parseGoalContinueCommand: (t) => this.parseGoalContinueCommand(t),
-            showStatus: (message) => this.showStatus(message),
+            showStatus: (message) => this.activityLane?.announce(message),
             showError: (message) => this.showError(message),
             refreshAutonomyFooterStatus: () => this.refreshAutonomyFooterStatus(),
         }, text);
+        this.refreshActivityLane?.();
     }
     handleSessionCommand() {
         sessionFlows.handleSessionCommand({
@@ -3273,6 +2918,15 @@ export class InteractiveMode {
             getCurrentAutoLearnSettings: () => this.getCurrentAutoLearnSettings(),
         });
     }
+    handleUsageMenuCommand() {
+        usageCommands.handleUsageMenuCommand({
+            session: this.session,
+            showSelector: (create) => this.showSelector(create),
+            showStatus: (message) => this.showStatus(message),
+            showError: (message) => this.showError(message),
+            showUsageReport: () => this.handleUsageCommand(),
+        });
+    }
     handleChangelogCommand() {
         reportCommands.handleChangelogCommand({
             chatContainer: this.chatContainer,
@@ -3324,6 +2978,8 @@ export class InteractiveMode {
             this.ui.requestRender();
         }
         catch (error) {
+            if (this.handleNonFatalSessionReplacementError(error))
+                return;
             await this.handleFatalRuntimeError("Failed to create session", error);
         }
     }
@@ -3422,17 +3078,9 @@ export class InteractiveMode {
         }, command, excludeFromContext);
     }
     handleCompactCommand(customInstructions) {
-        const self = this;
         return resourceShellCommands.handleCompactCommand({
             sessionManager: this.sessionManager,
             showWarning: (message) => this.showWarning(message),
-            get loadingAnimation() {
-                return self.loadingAnimation;
-            },
-            set loadingAnimation(value) {
-                self.loadingAnimation = value;
-            },
-            statusContainer: this.statusContainer,
             session: this.session,
         }, customInstructions);
     }
@@ -3446,8 +3094,10 @@ export class InteractiveMode {
             this.loadingAnimation = undefined;
         }
         this.authDialogs.cancelActiveDialog();
+        this.extensionUiHost.clearHostWidgets();
         this.extensionUiHost.resetExtensionUI();
         this.overlayHost.unmount();
+        this.activityLane?.dispose();
         this.footer.dispose();
         this.footerDataProvider.dispose();
         if (this.unsubscribe) {