@code-yeongyu/senpi 2026.9.9 → 2026.9.10

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

@@ -5,17 +5,19 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { modelsAreEqual } from "@earendil-works/pi-ai";
+import { contentText, modelsAreEqual } from "@earendil-works/pi-ai";
 import * as TuiLayouts from "@earendil-works/pi-tui";
 import { CombinedAutocompleteProvider, Container, fuzzyFilter, getCapabilities, hyperlink, Markdown, matchesKey, outerKittyGraphicsMode, ProcessTerminal, Spacer, sanitizeTerminalLabel, setCapabilityOverrides, setKeybindings, Text, TruncatedText, TuiAltScreen, TuiMainScreen, visibleWidth, } from "@earendil-works/pi-tui";
 import chalk from "chalk";
 import { spawn, spawnSync } from "child_process";
 import { APP_COMMAND, APP_NAME, APP_TITLE, BRAND, CONFIG_DIR_NAME, DISPLAY_VERSION, expandTildePath, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getShareViewerUrl, VERSION, } from "../../config.js";
-import { parseSkillBlock } from "../../core/agent-session.js";
+import { parseSkillBlock, } from "../../core/agent-session.js";
 import { SessionImportFileNotFoundError } from "../../core/agent-session-runtime.js";
 import { isApiKeyLoginProvider } from "../../core/auth-providers.js";
 import { envValue } from "../../core/brand.js";
 import { CACHE_TTL_MS, collectCacheMisses, computeCacheWaste, detectCacheMiss, } from "../../core/cache-stats.js";
+import { collectEntriesForBranchSummary } from "../../core/compaction/branch-summarization.js";
+import { AssistantEditError, assistantTextEquals } from "../../core/edited-assistant-message.js";
 import { buildNoticeBox } from "../../core/extensions/notice/index.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { appendHiddenTuiStdout, appendUncaughtCrashLog } from "../../core/hidden-stdout-log.js";
@@ -48,6 +50,8 @@ import { checkForNewPiVersion, getReleaseChangelogUrl } from "../../utils/versio
 import { abortedMessageForRendering } from "./aborted-error-label.js";
 import { transferCompactionQueue, waitForPromptDisposition, } from "./compaction-queue-transfer.js";
 import { ArminComponent } from "./components/armin.js";
+import { ASK_USER_ANSWER_KEY, ASK_USER_WIDGET_KEY, AskUserAsyncWidget, buildCommentResponse, buildTimedOutResponse, unansweredIds, } from "./components/ask-user-async-widget.js";
+import { AskUserQuestionComponent } from "./components/ask-user-question.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
 import { BashExecutionComponent } from "./components/bash-execution.js";
 import { BorderedLoader } from "./components/bordered-loader.js";
@@ -89,6 +93,7 @@ import { editFileInExternalEditor, editInExternalEditor } from "./external-edito
 import { GrokChrome } from "./grok/chrome.js";
 import { restoreInteractiveStderr, takeOverInteractiveStderr } from "./interactive-stderr-guard.js";
 import { applyKeybindingsFileEdit, seedKeybindingsFile } from "./keybindings-command.js";
+import { describeLoginFailure } from "./login-outcome.js";
 import { refreshModelCatalogs } from "./model-catalog-refresh.js";
 import { getModelSearchText } from "./model-search.js";
 import { isRiskyMainModel, RISKY_MAIN_MODEL_WARNING } from "./risky-main-model-warning.js";
@@ -615,6 +620,8 @@ export class InteractiveMode {
         this.extensionSelector = undefined;
         this.extensionInput = undefined;
         this.extensionEditor = undefined;
+        this.askUserQuestion = undefined;
+        this.asyncQuestion = undefined;
         this.extensionTerminalInputSubscriptions = new Set();
         // Extension widgets (components rendered above/below the editor)
         this.extensionWidgetsAbove = new Map();
@@ -1955,6 +1962,21 @@ export class InteractiveMode {
                     void this.flushCompactionQueue({ willRetry: false });
                     return { cancelled: false };
                 },
+                editAssistantMessage: async (entryId, text, options) => {
+                    const result = await this.session.editAssistantMessage(entryId, text, {
+                        summarize: options?.summarize,
+                        customInstructions: options?.customInstructions,
+                        expectedLeafId: options?.expectedLeafId,
+                    });
+                    if (result.cancelled || result.unchanged) {
+                        return { cancelled: result.cancelled, unchanged: result.unchanged };
+                    }
+                    this.chatContainer.clear();
+                    this.renderInitialMessages();
+                    this.showStatus("Replaced assistant response");
+                    void this.flushCompactionQueue({ willRetry: false });
+                    return { cancelled: false, entryId: result.entryId };
+                },
                 switchSession: async (sessionPath, options) => {
                     return this.handleResumeSession(sessionPath, options);
                 },
@@ -2075,8 +2097,6 @@ export class InteractiveMode {
      */
     setupExtensionShortcuts(extensionRunner) {
         const shortcuts = extensionRunner.getShortcuts(this.keybindings.getEffectiveConfig());
-        if (shortcuts.size === 0)
-            return;
         // Create a context for shortcut handlers
         const createContext = () => ({
             ui: this.createExtensionUIContext(),
@@ -2136,6 +2156,8 @@ export class InteractiveMode {
         });
         // Set up the extension shortcut handler on the default editor
         this.defaultEditor.onExtensionShortcut = (data) => {
+            if (this.handleAskUserShortcut(data))
+                return true;
             for (const [shortcutStr, shortcut] of shortcuts) {
                 // Cast to KeyId - extension shortcuts use the same format
                 if (matchesKey(data, shortcutStr)) {
@@ -2175,6 +2197,55 @@ export class InteractiveMode {
                     ? { type: "extension_ui_response", id: request.id, cancelled: true }
                     : { type: "extension_ui_response", id: request.id, value };
             }
+            case "question": {
+                const questions = request.questions ?? [];
+                if (questions.length === 0) {
+                    return { type: "extension_ui_response", id: request.id, cancelled: true };
+                }
+                const remainingMs = request.remainingMs !== undefined && request.remainingMs > 0 ? request.remainingMs : request.timeout;
+                const hostRuntime = this.runtimeHost;
+                let progressTimer;
+                let lastDraft;
+                const waitForAnswer = request.waitForAnswer ?? true;
+                // Async questions collapse into the editor widget; the host delivers the answer.
+                const show = waitForAnswer ? this.showQuestionOverlay : this.showAsyncQuestion;
+                const response = await show.call(this, {
+                    requestId: request.requestId ?? "",
+                    questions,
+                    waitForAnswer,
+                    timeoutMs: request.timeout ?? 0,
+                }, {
+                    timeout: remainingMs,
+                    onProgress: (draft) => {
+                        lastDraft = draft;
+                        if (progressTimer !== undefined)
+                            return;
+                        progressTimer = setTimeout(() => {
+                            progressTimer = undefined;
+                            hostRuntime.sendHostUiProgress?.({
+                                type: "extension_ui_progress",
+                                id: request.id,
+                                ...(lastDraft?.answers !== undefined ? { answers: lastDraft.answers } : {}),
+                                ...(lastDraft?.comment !== undefined ? { comment: lastDraft.comment } : {}),
+                            });
+                        }, 1_000);
+                    },
+                });
+                if (progressTimer !== undefined)
+                    clearTimeout(progressTimer);
+                if (response.status === "cancelled") {
+                    return { type: "extension_ui_response", id: request.id, cancelled: true };
+                }
+                // The host owns the idle timer; a locally expired countdown sends nothing.
+                if (response.status === "timed_out")
+                    return undefined;
+                return {
+                    type: "extension_ui_response",
+                    id: request.id,
+                    answers: response.answers,
+                    ...(response.comment !== undefined ? { comment: response.comment } : {}),
+                };
+            }
             case "notify":
                 this.showExtensionNotify(request.message ?? "");
                 return undefined;
@@ -2537,6 +2608,14 @@ export class InteractiveMode {
         if (this.extensionEditor) {
             this.hideExtensionEditor();
         }
+        if (this.askUserQuestion) {
+            this.hideQuestionOverlay();
+        }
+        this.asyncQuestion?.finish({
+            status: "cancelled",
+            answers: {},
+            unanswered: this.asyncQuestion.request.questions.map((question) => question.id),
+        });
         this.ui.hideOverlay();
         this.clearExtensionTerminalInputListeners();
         this.setExtensionFooter(undefined);
@@ -2693,6 +2772,10 @@ export class InteractiveMode {
             select: (title, options, opts) => this.showExtensionSelector(title, options, opts),
             confirm: (title, message, opts) => this.showExtensionConfirm(title, message, opts),
             input: (title, placeholder, opts) => this.showExtensionInput(title, placeholder, opts),
+            // Async answers are delivered by the ask-user extension, not here: the
+            // widget only resolves the question, so the model sees exactly one
+            // framed user message no matter which surface answered.
+            question: (request, opts) => request.waitForAnswer ? this.showQuestionOverlay(request, opts) : this.showAsyncQuestion(request, opts),
             notify: (message, type) => this.showExtensionNotify(message, type),
             onTerminalInput: (handler) => this.addExtensionTerminalInputListener(handler),
             setStatus: (key, text) => this.setExtensionStatus(key, text),
@@ -2868,6 +2951,162 @@ export class InteractiveMode {
         this.ui.setFocus(this.editor);
         this.ui.requestRender();
     }
+    /**
+     * Show the ask-user multi-question overlay in place of the editor.
+     */
+    showQuestionOverlay(request, opts) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const previousWorkingMessage = this.workingMessage;
+            const finish = (response) => {
+                if (settled)
+                    return;
+                settled = true;
+                opts?.signal?.removeEventListener("abort", onAbort);
+                this.workingMessage = previousWorkingMessage;
+                this.updateWorkingIndicatorMessage();
+                this.hideQuestionOverlay();
+                resolve(response);
+            };
+            const onAbort = () => {
+                finish({
+                    status: "cancelled",
+                    answers: {},
+                    unanswered: request.questions.map((question) => question.id),
+                });
+            };
+            if (opts?.signal?.aborted) {
+                resolve({
+                    status: "cancelled",
+                    answers: {},
+                    unanswered: request.questions.map((question) => question.id),
+                });
+                return;
+            }
+            opts?.signal?.addEventListener("abort", onAbort, { once: true });
+            this.workingMessage = "Waiting for your answer";
+            this.updateWorkingIndicatorMessage();
+            this.askUserQuestion = new AskUserQuestionComponent(request, (response) => finish(response), {
+                tui: this.ui,
+                timeoutMs: opts?.timeout ?? request.timeoutMs,
+                onProgress: opts?.onProgress,
+            });
+            this.disposeActiveSelector();
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.askUserQuestion);
+            this.ui.setFocus(this.askUserQuestion);
+            this.ui.requestRender();
+        });
+    }
+    /**
+     * Hide the ask-user question overlay and restore the editor.
+     */
+    hideQuestionOverlay() {
+        this.askUserQuestion?.dispose();
+        this.askUserQuestion = undefined;
+        this.editorContainer.clear();
+        this.editorContainer.addChild(this.editor);
+        this.ui.setFocus(this.editor);
+        this.ui.requestRender();
+    }
+    /**
+     * Park a waitForAnswer=false question behind a one-line widget above the
+     * editor. The turn keeps running; the promise settles when the user submits
+     * from the expanded component, types an ordinary reply (comment), the idle
+     * countdown expires, or the caller aborts. A newer async question supersedes
+     * a pending one, which resolves as cancelled.
+     */
+    showAsyncQuestion(request, opts) {
+        return new Promise((resolve) => {
+            const cancelled = () => ({
+                status: "cancelled",
+                answers: {},
+                unanswered: request.questions.map((question) => question.id),
+            });
+            if (opts?.signal?.aborted) {
+                resolve(cancelled());
+                return;
+            }
+            this.asyncQuestion?.finish(cancelled());
+            const onAbort = () => state.finish(cancelled());
+            const state = {
+                request,
+                timeoutMs: opts?.timeout ?? request.timeoutMs,
+                onProgress: opts?.onProgress,
+                draft: { answers: {} },
+                finish: (response) => {
+                    if (this.asyncQuestion !== state)
+                        return;
+                    this.asyncQuestion = undefined;
+                    opts?.signal?.removeEventListener("abort", onAbort);
+                    if (this.askUserQuestion)
+                        this.hideQuestionOverlay();
+                    this.setExtensionWidget(ASK_USER_WIDGET_KEY, undefined);
+                    resolve(response);
+                },
+            };
+            this.asyncQuestion = state;
+            opts?.signal?.addEventListener("abort", onAbort, { once: true });
+            this.refreshAsyncWidget(state);
+        });
+    }
+    /** (Re)render the collapsed widget with a fresh idle countdown. */
+    refreshAsyncWidget(state) {
+        this.setExtensionWidget(ASK_USER_WIDGET_KEY, (tui) => {
+            const startedAt = Date.now();
+            return new AskUserAsyncWidget({
+                unanswered: unansweredIds(state.request, state.draft).length,
+                timeoutMs: state.timeoutMs,
+                tui,
+                onExpire: () => state.finish(buildTimedOutResponse(state.request, state.draft, Date.now() - startedAt)),
+            });
+        });
+    }
+    /** Editor shortcut: expand the pending async question into the full component. */
+    handleAskUserShortcut(data) {
+        const state = this.asyncQuestion;
+        if (!state || this.askUserQuestion || !matchesKey(data, ASK_USER_ANSWER_KEY))
+            return false;
+        const component = new AskUserQuestionComponent(state.request, (response) => {
+            if (this.asyncQuestion !== state)
+                return;
+            if (response.status !== "cancelled") {
+                state.finish(response);
+                return;
+            }
+            // Esc collapses back to the widget; the question stays pending.
+            this.hideQuestionOverlay();
+            this.refreshAsyncWidget(state);
+        }, {
+            tui: this.ui,
+            timeoutMs: state.timeoutMs,
+            onProgress: (draft) => {
+                state.draft = draft;
+                state.onProgress?.(draft);
+            },
+        });
+        this.askUserQuestion = component;
+        this.disposeActiveSelector();
+        this.editorContainer.clear();
+        this.editorContainer.addChild(component);
+        this.ui.setFocus(component);
+        this.ui.requestRender();
+        return true;
+    }
+    /**
+     * Ordinary composer text while an async question is pending is the comment
+     * answer: resolve the question with it and let the framed message replace
+     * the raw text. Returns false when nothing is pending.
+     */
+    submitAsyncQuestionComment(text) {
+        const state = this.asyncQuestion;
+        if (!state)
+            return false;
+        this.editor.addToHistory?.(text);
+        this.editor.setText("");
+        state.finish(buildCommentResponse(state.request, state.draft, text));
+        return true;
+    }
     /**
      * Full editor text with paste markers expanded. Prefers the editor's own
      * getExpandedText(); falls back to expanding from the paste snapshot when
@@ -3309,6 +3548,13 @@ export class InteractiveMode {
                 text = text.trim();
                 if (!text)
                     return;
+                // A pending async question claims ordinary text as its comment answer;
+                // slash and bash commands keep their normal routing.
+                if (!text.startsWith("/") &&
+                    !text.startsWith("!") &&
+                    this.asyncQuestion &&
+                    this.submitAsyncQuestionComment(text))
+                    return;
                 // Handle commands
                 if (text === "/settings") {
                     await this.showSettingsSelector();
@@ -3547,7 +3793,12 @@ export class InteractiveMode {
                 this.editor.addToHistory?.(text);
             }
             catch (error) {
-                this.showError(error instanceof Error ? error.message : String(error));
+                if (typeof this.showError === "function") {
+                    this.showError(error instanceof Error ? error.message : String(error));
+                }
+                else {
+                    throw error;
+                }
             }
         };
     }
@@ -3623,6 +3874,12 @@ export class InteractiveMode {
             case "high_reasoning_warning":
                 this.showHighReasoningWarning(event);
                 break;
+            case "resume_compaction_required":
+                this.showWarning(event.notice);
+                break;
+            case "resume_context_reduced":
+                this.showWarning(event.notice);
+                break;
             case "settings_source_selected":
                 this.showSettingsSourceSelected(event);
                 break;
@@ -5125,8 +5382,8 @@ export class InteractiveMode {
         this.showNoticeBox({
             title: "Update Available",
             tone: "warning",
-            why: `New version ${newVersion} is available. Run ${action}`,
-            extra: [{ text: `Changelog: ${changelogLink}`, tone: "accent" }],
+            why: `New version ${newVersion} is available.`,
+            extra: [{ text: action }, { text: `Changelog: ${changelogLink}`, tone: "accent" }],
         });
     }
     showRiskyMainModelWarning(model) {
@@ -6163,86 +6420,12 @@ export class InteractiveMode {
                     this.showStatus("Already at this point");
                     return;
                 }
-                // Ask about summarization
                 done(); // Close selector first
-                // Loop until user makes a complete choice or cancels to tree
-                let wantsSummary = false;
-                let customInstructions;
-                // Check if we should skip the prompt (user preference to always default to no summary)
-                if (!this.settingsManager.getBranchSummarySkipPrompt()) {
-                    while (true) {
-                        const summaryChoice = await this.showExtensionSelector("Summarize branch?", [
-                            "No summary",
-                            "Summarize",
-                            "Summarize with custom prompt",
-                        ]);
-                        if (summaryChoice === undefined) {
-                            // User pressed escape - re-show tree selector with same selection
-                            this.showTreeSelector(entryId);
-                            return;
-                        }
-                        wantsSummary = summaryChoice !== "No summary";
-                        if (summaryChoice === "Summarize with custom prompt") {
-                            customInstructions = await this.showExtensionEditor("Custom summarization instructions");
-                            if (customInstructions === undefined) {
-                                // User cancelled - loop back to summary selector
-                                continue;
-                            }
-                        }
-                        // User made a complete choice
-                        break;
-                    }
-                }
-                // The user committed to navigating: stop the active response first.
-                if (this.session.isStreaming) {
-                    this.restoreQueuedMessagesToEditor();
-                    await this.session.abort();
-                }
-                // Set up escape handler and status indicator if summarizing
-                let showingSummaryIndicator = false;
-                const originalOnEscape = this.defaultEditor.onEscape;
-                if (wantsSummary) {
-                    this.defaultEditor.onEscape = () => {
-                        this.session.abortBranchSummary();
-                    };
-                    this.chatContainer.addChild(new Spacer(1));
-                    this.showStatusIndicator(new BranchSummaryStatusIndicator(this.ui));
-                    showingSummaryIndicator = true;
-                    this.ui.requestRender();
-                }
-                try {
-                    const result = await this.session.navigateTree(entryId, {
-                        summarize: wantsSummary,
-                        customInstructions,
-                    });
-                    if (result.aborted) {
-                        // Summarization aborted - re-show tree selector with same selection
-                        this.showStatus("Branch summarization cancelled");
-                        this.showTreeSelector(entryId);
-                        return;
-                    }
-                    if (result.cancelled) {
-                        this.showStatus("Navigation cancelled");
-                        return;
-                    }
-                    // Update UI
-                    this.chatContainer.clear();
-                    this.renderInitialMessages();
-                    if (result.editorText && !this.editor.getText().trim()) {
-                        this.editor.setText(result.editorText);
-                    }
-                    this.showStatus("Navigated to selected point");
-                    void this.flushCompactionQueue({ willRetry: false });
-                }
-                catch (error) {
-                    this.showError(error instanceof Error ? error.message : String(error));
-                }
-                finally {
-                    if (showingSummaryIndicator) {
-                        this.clearStatusIndicator("branchSummary");
-                    }
-                    this.defaultEditor.onEscape = originalOnEscape;
-                }
+                await this.runTreeNavigation(entryId, {
+                    promptForSummary: true,
+                    navigate: (options) => this.session.navigateTree(entryId, options),
+                    successStatus: "Navigated to selected point",
+                });
             }, () => {
                 done();
                 this.ui.requestRender();
@@ -6263,9 +6446,144 @@ export class InteractiveMode {
                     this.showError(error instanceof Error ? error.message : String(error));
                 }
             };
+            selector.onEditMessage = (entryId) => {
+                done();
+                void this.editAssistantMessageFromTree(entryId);
+            };
             return { component: selector, focus: selector };
         });
     }
+    async editAssistantMessageFromTree(entryId) {
+        const entry = this.sessionManager.getEntry(entryId);
+        if (entry?.type !== "message" || entry.message.role !== "assistant") {
+            this.showError("Only assistant responses can be edited here");
+            return;
+        }
+        const message = entry.message;
+        // The leaf seen when the editor opens is the token the edit is checked against.
+        const expectedLeafId = this.sessionManager.getLeafId() ?? undefined;
+        const dropsToolCalls = message.content.some((block) => block.type === "toolCall");
+        const title = dropsToolCalls
+            ? "Edit assistant response (its tool calls will be dropped)"
+            : "Edit assistant response";
+        const edited = await this.showExtensionEditor(title, contentText(message.content, ""));
+        if (edited === undefined) {
+            this.showTreeSelector(entryId);
+            return;
+        }
+        if (!edited.trim()) {
+            this.showError("Assistant response cannot be empty");
+            this.showTreeSelector(entryId);
+            return;
+        }
+        if (assistantTextEquals(message, edited)) {
+            this.showStatus("Assistant response unchanged");
+            return;
+        }
+        await this.runTreeNavigation(entryId, {
+            promptForSummary: this.treeNavigationAbandonsConversation(entryId),
+            navigate: async (options) => {
+                try {
+                    return await this.session.editAssistantMessage(entryId, edited, { ...options, expectedLeafId });
+                }
+                catch (error) {
+                    if (error instanceof AssistantEditError && error.reason === "stale-leaf") {
+                        throw new Error("The session changed while you were editing; reopen /tree and try again");
+                    }
+                    throw error;
+                }
+            },
+            successStatus: "Replaced assistant response with your edit",
+        });
+    }
+    /** Bookkeeping entries after the target (thinking level, labels, custom state) leave nothing to summarize. */
+    treeNavigationAbandonsConversation(targetId) {
+        const { entries } = collectEntriesForBranchSummary(this.sessionManager, this.sessionManager.getLeafId(), targetId);
+        return entries.some((entry) => entry.type === "message" ||
+            entry.type === "custom_message" ||
+            entry.type === "compaction" ||
+            entry.type === "branch_summary");
+    }
+    async promptBranchSummaryChoice() {
+        while (true) {
+            const summaryChoice = await this.showExtensionSelector("Summarize branch?", [
+                "No summary",
+                "Summarize",
+                "Summarize with custom prompt",
+            ]);
+            if (summaryChoice === undefined) {
+                return undefined;
+            }
+            if (summaryChoice !== "Summarize with custom prompt") {
+                return { summarize: summaryChoice !== "No summary" };
+            }
+            const customInstructions = await this.showExtensionEditor("Custom summarization instructions");
+            if (customInstructions !== undefined) {
+                return { summarize: true, customInstructions };
+            }
+        }
+    }
+    async runTreeNavigation(entryId, flow) {
+        let wantsSummary = false;
+        let customInstructions;
+        if (flow.promptForSummary && !this.settingsManager.getBranchSummarySkipPrompt()) {
+            const choice = await this.promptBranchSummaryChoice();
+            if (choice === undefined) {
+                // User pressed escape - re-show tree selector with same selection
+                this.showTreeSelector(entryId);
+                return;
+            }
+            wantsSummary = choice.summarize;
+            customInstructions = choice.customInstructions;
+        }
+        // The user committed to navigating: stop the active response first.
+        if (this.session.isStreaming) {
+            this.restoreQueuedMessagesToEditor();
+            await this.session.abort();
+        }
+        // Set up escape handler and status indicator if summarizing
+        let showingSummaryIndicator = false;
+        const originalOnEscape = this.defaultEditor.onEscape;
+        if (wantsSummary) {
+            this.defaultEditor.onEscape = () => {
+                this.session.abortBranchSummary();
+            };
+            this.chatContainer.addChild(new Spacer(1));
+            this.showStatusIndicator(new BranchSummaryStatusIndicator(this.ui));
+            showingSummaryIndicator = true;
+            this.ui.requestRender();
+        }
+        try {
+            const result = await flow.navigate({ summarize: wantsSummary, customInstructions });
+            if (result.aborted) {
+                // Summarization aborted - re-show tree selector with same selection
+                this.showStatus("Branch summarization cancelled");
+                this.showTreeSelector(entryId);
+                return;
+            }
+            if (result.cancelled) {
+                this.showStatus("Navigation cancelled");
+                return;
+            }
+            // Update UI
+            this.chatContainer.clear();
+            this.renderInitialMessages();
+            if (result.editorText && !this.editor.getText().trim()) {
+                this.editor.setText(result.editorText);
+            }
+            this.showStatus(flow.successStatus);
+            void this.flushCompactionQueue({ willRetry: false });
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            if (showingSummaryIndicator) {
+                this.clearStatusIndicator("branchSummary");
+            }
+            this.defaultEditor.onEscape = originalOnEscape;
+        }
+    }
     showSessionSelector() {
         this.showSelector((done) => {
             const selector = new SessionSelectorComponent((onProgress) => SessionManager.list(this.sessionManager.getCwd(), this.sessionManager.getSessionDir(), onProgress), (onProgress) => this.sessionManager.usesDefaultSessionDir()
@@ -6656,13 +6974,7 @@ export class InteractiveMode {
         }
         catch (error) {
             restoreEditor();
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            if (error instanceof CredentialSynchronizationError) {
-                this.showError(`Saved API key for ${providerName}, but local model state could not be synchronized: ${errorMsg}`);
-            }
-            else if (errorMsg !== "Login cancelled") {
-                this.showError(`Failed to save API key for ${providerName}: ${errorMsg}`);
-            }
+            this.showLoginFailure(describeLoginFailure(error, providerName, "api_key"));
         }
     }
     showAuthSelect(dialog, prompt) {
@@ -6762,15 +7074,16 @@ export class InteractiveMode {
         }
         catch (error) {
             restoreEditor();
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            if (error instanceof CredentialSynchronizationError) {
-                this.showError(`Logged in to ${providerName}, but local model state could not be synchronized: ${errorMsg}`);
-            }
-            else if (errorMsg !== "Login cancelled") {
-                this.showError(`Failed to login to ${providerName}: ${errorMsg}`);
-            }
+            this.showLoginFailure(describeLoginFailure(error, providerName, "oauth"));
         }
     }
+    /** #1542: a cancelled login is a neutral status line; only a genuine failure is an error. */
+    showLoginFailure(notice) {
+        if (notice.level === "status")
+            this.showStatus(notice.message);
+        else
+            this.showError(notice.message);
+    }
     // =========================================================================
     // Command handlers
     // =========================================================================