@ashx-j/lunr 0.1.7 → 0.2.0

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

@@ -27,6 +27,7 @@ import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScop
 import { refreshModelCandidatesForInit } from "../../core/model-runtime.js";
 import { getModelTiersBridge } from "../../core/model-tiers.js";
 import { registerPermissionModeBridge } from "../../core/permission-mode.js";
+import { nextModeForGoal, registerPermissionModeControlBridge } from "../../core/permission-mode-control.js";
 import { AUTO_MODE_ADDENDUM, getPermissionMode, nextPermissionMode, registerApprovalHandler, resetPermissions, restorePermissionModeAfterPlan, setPermissionMode, } from "../../core/permissions.js";
 import { PLAN_MODE_ADDENDUM } from "../../core/plan-mode.js";
 import * as processRegistry from "../../core/process-registry.js";
@@ -37,9 +38,8 @@ import { SessionManager, sessionEntryToContextMessages } from "../../core/sessio
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 // lunr: moved to core/swarm.ts so the gateway can reuse it.
 import { buildSwarmPrompt } from "../../core/swarm.js";
-import { hasTrustRequiringProjectResources, ProjectTrustStore } from "../../core/trust-manager.js";
-import { collectUsageHistory } from "../../core/usage-history.js";
 import { time } from "../../core/timings.js";
+import { hasTrustRequiringProjectResources, ProjectTrustStore } from "../../core/trust-manager.js";
 import { getPlanUsageResult } from "../../core/usage-service.js";
 import { modelToUserEntry } from "../../core/user-models.js";
 import { copyToClipboard, readClipboardText } from "../../utils/clipboard.js";
@@ -71,6 +71,7 @@ import { formatKeyText, keyDisplayText, keyText } from "./components/keybinding-
 import { LoginDialogComponent } from "./components/login-dialog.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
 import { formatAuthSelectorProviderType, OAuthSelectorComponent, } from "./components/oauth-selector.js";
+import { PlanMessageComponent } from "./components/plan-message.js";
 import { ProcessesSelectorComponent } from "./components/processes-selector.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
@@ -81,11 +82,11 @@ import { updateThinkingRunTimings } from "./components/thinking-summary.js";
 import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
 import { TrustSelectorComponent } from "./components/trust-selector.js";
-import { renderTokenUsageBox, renderUsageBox } from "./components/usage-view.js";
+import { renderUsageBox } from "./components/usage-view.js";
 import { UserMessageComponent } from "./components/user-message.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
 import { getModelSearchText } from "./model-search.js";
-import { countMessageGraphemes, sliceMessageContent } from "./smooth-streaming.js";
+import { computeSmoothRevealStep, countGraphemesBeforeToolCall, countMessageGraphemes, sliceMessageContent, } from "./smooth-streaming.js";
 import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, getThemeName, onThemeChange, setRegisteredThemes, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
 import { InteractiveThemeController } from "./theme/theme-controller.js";
 function isExpandable(obj) {
@@ -253,7 +254,6 @@ export class InteractiveMode {
     // flashing whole chunks.
     streamingTargetMessage = undefined;
     streamingDisplayedLength = 0;
-    lastSmoothRenderAt = 0;
     smoothStreamingTimer = undefined;
     // Tool execution tracking: toolCallId -> component
     pendingTools = new Map();
@@ -282,6 +282,9 @@ export class InteractiveMode {
     // lunr: mode in effect before the current plan stretch. Used by approve / `/plan off`
     // / `/plan <text>` to leave plan. Shift+Tab and `/mode` pick the destination themselves.
     previousPermissionMode;
+    // lunr: mode in effect before `/goal` forced session auto. Dedicated so it cannot
+    // collide with plan restore.
+    preGoalPermissionMode;
     // lunr: in-memory redo stack for /undo and /redo (leaf entry ids; cleared on any
     // new user message, never persisted — undone turns reappear after restart)
     redoStack = [];
@@ -343,6 +346,7 @@ export class InteractiveMode {
             this.resetExtensionUI();
             // lunr: reset permission mode to configured default + clear session approvals
             this.previousPermissionMode = undefined;
+            this.preGoalPermissionMode = undefined;
             resetPermissions(this.settingsManager.getDefaultPermissionMode());
             // lunr: clear process registry and rollback state
             processRegistry.clearRegistry();
@@ -362,8 +366,17 @@ export class InteractiveMode {
         this.version = VERSION;
         this.ui = new TUI(new ProcessTerminal(), this.settingsManager.getShowHardwareCursor());
         this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
+        this.ui.onTextSelected = (text) => {
+            void copyToClipboard(text)
+                .then(() => this.showStatus("Copied."))
+                .catch((error) => this.showError(error instanceof Error ? error.message : String(error)));
+        };
         // lunr: register the permission-mode footer bridge (provider-side: InteractiveMode owns the state).
         registerPermissionModeBridge(() => getPermissionMode());
+        registerPermissionModeControlBridge({
+            enterGoalAuto: () => this.enterGoalAuto(),
+            leaveGoalAuto: () => this.leaveGoalAuto(),
+        });
         // lunr: reset permission mode to configured default on startup.
         resetPermissions(this.settingsManager.getDefaultPermissionMode());
         this.headerContainer = new Container();
@@ -2252,11 +2265,6 @@ export class InteractiveMode {
                 await this.handleUsageCommand();
                 return;
             }
-            if (text === "/token-usage") {
-                this.editor.setText("");
-                this.handleTokenUsageCommand();
-                return;
-            }
             if (text === "/context") {
                 this.editor.setText("");
                 this.handleContextCommand();
@@ -2440,9 +2448,17 @@ export class InteractiveMode {
             this.editor.addToHistory?.(text);
         };
     }
-    /** Smooth streaming tick rate (ms) and base reveal speed (graphemes per tick). */
-    static SMOOTH_STREAMING_TICK_MS = 20;
-    static SMOOTH_STREAMING_BASE_GRAPHEMES_PER_TICK = 4;
+    /** Smooth streaming tick rate (~30 FPS). TUI already caps paints at 16ms. */
+    static SMOOTH_STREAMING_TICK_MS = 33;
+    getSmoothStreamingOptions() {
+        return { hideThinking: this.hideThinkingBlock };
+    }
+    clearSmoothStreamingTimer() {
+        if (this.smoothStreamingTimer) {
+            clearInterval(this.smoothStreamingTimer);
+            this.smoothStreamingTimer = undefined;
+        }
+    }
     startSmoothStreaming() {
         if (this.smoothStreamingTimer)
             return;
@@ -2452,38 +2468,96 @@ export class InteractiveMode {
         // Never keep the process alive just to finish a reveal animation.
         this.smoothStreamingTimer.unref?.();
     }
+    /** Apply the current reveal slice and sync tool cards that have crossed the frontier. */
+    paintSmoothStreamingFrame() {
+        const target = this.streamingTargetMessage;
+        if (!this.streamingComponent || !target)
+            return;
+        const opts = this.getSmoothStreamingOptions();
+        const revealed = sliceMessageContent(target, this.streamingDisplayedLength, opts);
+        this.streamingComponent.updateContent(revealed);
+        this.syncRevealedStreamingTools(revealed, target);
+        this.ui.requestRender();
+    }
+    /**
+     * Create/update tool cards only once smooth streaming has revealed past their
+     * leading text. Args always come from the full target so later arg deltas apply.
+     */
+    syncRevealedStreamingTools(revealed, target) {
+        const revealedIds = new Set();
+        for (const block of revealed.content) {
+            if (block.type === "toolCall")
+                revealedIds.add(block.id);
+        }
+        for (const content of target.content) {
+            if (content.type !== "toolCall" || !revealedIds.has(content.id))
+                continue;
+            if (!this.pendingTools.has(content.id)) {
+                const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
+                    showImages: this.settingsManager.getShowImages(),
+                    imageWidthCells: this.settingsManager.getImageWidthCells(),
+                }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
+                component.setExpanded(this.toolOutputExpanded);
+                this.addToolComponentToChat(component);
+                this.pendingTools.set(content.id, component);
+            }
+            else {
+                const component = this.pendingTools.get(content.id);
+                if (component) {
+                    component.updateArgs(content.arguments);
+                }
+            }
+        }
+    }
     advanceSmoothStreaming() {
         const target = this.streamingTargetMessage;
         if (!this.streamingComponent || !target) {
             this.stopSmoothStreaming();
             return;
         }
-        const total = countMessageGraphemes(target);
-        if (this.streamingDisplayedLength >= total)
+        const opts = this.getSmoothStreamingOptions();
+        const total = countMessageGraphemes(target, opts);
+        if (this.streamingDisplayedLength >= total) {
+            // Caught up: stop the interval until new backlog arrives.
+            this.clearSmoothStreamingTimer();
             return;
-        // Catch-up acceleration: the further the display lags behind the model,
-        // the more graphemes each tick reveals.
+        }
         const backlog = total - this.streamingDisplayedLength;
-        this.streamingDisplayedLength += Math.max(InteractiveMode.SMOOTH_STREAMING_BASE_GRAPHEMES_PER_TICK, Math.ceil(backlog / 8));
+        this.streamingDisplayedLength += computeSmoothRevealStep(backlog);
         if (this.streamingDisplayedLength > total) {
             this.streamingDisplayedLength = total;
         }
-        this.streamingComponent.updateContent(sliceMessageContent(target, this.streamingDisplayedLength));
-        // Throttle renders to ~30 FPS so the TUI isn't redrawn every 20 ms tick.
-        const now = Date.now();
-        if (now - this.lastSmoothRenderAt >= 33) {
-            this.lastSmoothRenderAt = now;
-            this.ui.requestRender();
+        this.paintSmoothStreamingFrame();
+        if (this.streamingDisplayedLength >= total) {
+            this.clearSmoothStreamingTimer();
         }
     }
     stopSmoothStreaming() {
-        if (this.smoothStreamingTimer) {
-            clearInterval(this.smoothStreamingTimer);
-            this.smoothStreamingTimer = undefined;
-        }
+        this.clearSmoothStreamingTimer();
         this.streamingTargetMessage = undefined;
         this.streamingDisplayedLength = 0;
-        this.lastSmoothRenderAt = 0;
+    }
+    /** Apply a mid-stream smoothStreaming setting change without rewinding. */
+    applySmoothStreamingSettingChange(enabled) {
+        this.settingsManager.setSmoothStreaming(enabled);
+        if (!this.streamingComponent || !this.streamingMessage)
+            return;
+        if (enabled) {
+            // Already showing the full live message; start the reveal cursor at the
+            // current visible length so the next deltas only animate new text.
+            this.streamingTargetMessage = this.streamingMessage;
+            const opts = this.getSmoothStreamingOptions();
+            this.streamingDisplayedLength = countMessageGraphemes(this.streamingMessage, opts);
+            this.paintSmoothStreamingFrame();
+            this.startSmoothStreaming();
+            return;
+        }
+        // Off: stop the timer and snap to the full target immediately.
+        this.clearSmoothStreamingTimer();
+        this.streamingTargetMessage = this.streamingMessage;
+        this.streamingComponent.updateContent(this.streamingMessage);
+        this.syncRevealedStreamingTools(this.streamingMessage, this.streamingMessage);
+        this.ui.requestRender();
     }
     subscribeToAgent() {
         this.unsubscribe = this.session.subscribe(async (event) => {
@@ -2561,7 +2635,7 @@ export class InteractiveMode {
                     this.streamingDisplayedLength = 0;
                     this.chatContainer.addChild(this.streamingComponent);
                     if (this.settingsManager.getSmoothStreaming()) {
-                        this.streamingComponent.updateContent(sliceMessageContent(this.streamingMessage, 0));
+                        this.streamingComponent.updateContent(sliceMessageContent(this.streamingMessage, 0, this.getSmoothStreamingOptions()));
                     }
                     else {
                         this.streamingComponent.updateContent(this.streamingMessage);
@@ -2577,40 +2651,32 @@ export class InteractiveMode {
                     // so smooth-streaming reveal lag doesn't inflate durations.
                     updateThinkingRunTimings(this.thinkingRunTimings, this.streamingMessage.content, Date.now(), false);
                     if (this.settingsManager.getSmoothStreaming()) {
-                        // Smooth streaming: only track the target here; the timer
-                        // reveals it grapheme by grapheme.
-                        this.startSmoothStreaming();
+                        // Smooth streaming: timer reveals graphemes. Tool cards sync from
+                        // the reveal frontier so they don't jump ahead of leading text.
+                        const opts = this.getSmoothStreamingOptions();
+                        const total = countMessageGraphemes(this.streamingMessage, opts);
+                        if (this.streamingDisplayedLength >= total) {
+                            // Already caught up (or tool-only): paint so new tool cards appear.
+                            this.paintSmoothStreamingFrame();
+                            this.clearSmoothStreamingTimer();
+                        }
+                        else {
+                            this.startSmoothStreaming();
+                        }
                     }
                     else {
                         this.streamingComponent.updateContent(this.streamingMessage);
+                        this.syncRevealedStreamingTools(this.streamingMessage, this.streamingMessage);
+                        this.ui.requestRender();
                     }
-                    for (const content of this.streamingMessage.content) {
-                        if (content.type === "toolCall") {
-                            if (!this.pendingTools.has(content.id)) {
-                                const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
-                                    showImages: this.settingsManager.getShowImages(),
-                                    imageWidthCells: this.settingsManager.getImageWidthCells(),
-                                }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
-                                component.setExpanded(this.toolOutputExpanded);
-                                this.addToolComponentToChat(component);
-                                this.pendingTools.set(content.id, component);
-                            }
-                            else {
-                                const component = this.pendingTools.get(content.id);
-                                if (component) {
-                                    component.updateArgs(content.arguments);
-                                }
-                            }
-                        }
-                    }
-                    this.ui.requestRender();
                 }
                 break;
             case "message_end":
                 if (event.message.role === "user")
                     break;
                 if (this.streamingComponent && event.message.role === "assistant") {
-                    // Stop the reveal timer and render the full message immediately.
+                    // Snap remaining graphemes on end (abort/error and normal stop).
+                    // Avoids multi-second leftover animation; paint always follows below.
                     this.stopSmoothStreaming();
                     this.streamingMessage = event.message;
                     let errorMessage;
@@ -2653,6 +2719,18 @@ export class InteractiveMode {
                 this.ui.requestRender();
                 break;
             case "tool_execution_start": {
+                // If smooth streaming still has leading text unrevealed, flush through
+                // this tool so the running card is not hidden behind the typewriter.
+                if (this.settingsManager.getSmoothStreaming() &&
+                    this.streamingTargetMessage &&
+                    this.streamingComponent) {
+                    const opts = this.getSmoothStreamingOptions();
+                    const needed = countGraphemesBeforeToolCall(this.streamingTargetMessage, event.toolCallId, opts);
+                    if (this.streamingDisplayedLength < needed) {
+                        this.streamingDisplayedLength = needed;
+                    }
+                    this.paintSmoothStreamingFrame();
+                }
                 let component = this.pendingTools.get(event.toolCallId);
                 if (!component) {
                     component = new ToolExecutionComponent(event.toolName, event.toolCallId, event.args, {
@@ -3117,7 +3195,7 @@ export class InteractiveMode {
         if (this.isShuttingDown)
             return;
         this.isShuttingDown = true;
-        this.stopSmoothStreaming?.();
+        this.stopSmoothStreaming();
         // Keep signal handlers registered until terminal cleanup has completed.
         // `signal-exit` checks the listener list during the same SIGTERM/SIGHUP
         // dispatch and re-sends the signal if only its own listeners remain.
@@ -3418,10 +3496,25 @@ export class InteractiveMode {
         // Rebuild chat from session messages
         this.chatContainer.clear();
         this.rebuildChatFromMessages();
-        // If streaming, re-add the streaming component with updated visibility and re-render
+        // If streaming, re-add the streaming component with updated visibility and re-render.
+        // Re-slice to the current revealed length so hide-thinking does not dump the tail.
         if (this.streamingComponent && this.streamingMessage) {
             this.streamingComponent.setHideThinkingBlock(this.hideThinkingBlock);
-            this.streamingComponent.updateContent(this.streamingMessage);
+            if (this.settingsManager.getSmoothStreaming() && this.streamingTargetMessage) {
+                const opts = this.getSmoothStreamingOptions();
+                const total = countMessageGraphemes(this.streamingTargetMessage, opts);
+                if (this.streamingDisplayedLength > total) {
+                    this.streamingDisplayedLength = total;
+                }
+                this.paintSmoothStreamingFrame();
+                // Restart the timer if new (or still-pending) backlog exists.
+                if (this.streamingDisplayedLength < total) {
+                    this.startSmoothStreaming();
+                }
+            }
+            else {
+                this.streamingComponent.updateContent(this.streamingMessage);
+            }
             this.chatContainer.addChild(this.streamingComponent);
         }
         this.showStatus(`Thinking blocks: ${this.hideThinkingBlock ? "hidden" : "visible"}`);
@@ -3818,7 +3911,7 @@ export class InteractiveMode {
                     this.settingsManager.setQuietStartup(enabled);
                 },
                 onSmoothStreamingChange: (enabled) => {
-                    this.settingsManager.setSmoothStreaming(enabled);
+                    this.applySmoothStreamingSettingChange(enabled);
                 },
                 onSessionRetentionDaysChange: (days) => {
                     this.settingsManager.setSessionRetentionDays(days);
@@ -5904,41 +5997,24 @@ export class InteractiveMode {
         this.chatContainer.addChild(new Text(info, 1, 0));
         this.ui.requestRender();
     }
-    // lunr: shared per-model session aggregation for /usage and /token-usage.
-    collectSessionModelRows() {
-        const perModelMap = new Map();
-        for (const entry of this.sessionManager.getEntries()) {
-            if (entry.type !== "message" || entry.message.role !== "assistant")
-                continue;
-            const message = entry.message;
-            const usage = message.usage;
-            const key = `${message.provider}/${message.responseModel ?? message.model}`;
-            let row = perModelMap.get(key);
-            if (!row) {
-                row = { model: key, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
-                perModelMap.set(key, row);
-            }
-            row.input += usage.input;
-            row.output += usage.output;
-            row.cacheRead += usage.cacheRead;
-            row.cacheWrite += usage.cacheWrite;
-            row.total += usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
-        }
-        return Array.from(perModelMap.values()).sort((a, b) => b.total - a.total);
-    }
-    // lunr: 30-day history from session files on disk; best-effort — on any
-    // error the section is simply omitted.
-    collectUsageHistorySafe() {
-        try {
-            return collectUsageHistory({ sinceMs: Date.now() - 30 * 24 * 60 * 60 * 1000 });
-        }
-        catch {
+    collectUsageBreakdown() {
+        const model = this.session.model;
+        const contextWindow = model?.contextWindow ?? 0;
+        if (!model || contextWindow <= 0)
             return undefined;
-        }
+        const tools = this.session
+            .getActiveToolNames()
+            .map((name) => this.session.getToolDefinition(name))
+            .filter((definition) => definition !== undefined);
+        return computeContextBreakdown({
+            systemPrompt: this.session.systemPrompt,
+            tools,
+            messages: this.session.messages,
+            contextWindow,
+        });
     }
-    // lunr: /usage — simple token totals (session + last 30 days), context window
-    // bar, and subscription plan usage (when the current provider has a usage
-    // adapter). Per-model rows live in /token-usage.
+    // lunr: /usage — current session only: token totals, live context split,
+    // context-window bar, and subscription plan usage.
     async handleUsageCommand() {
         const stats = this.session.getSessionStats();
         const sessionTotals = stats.tokens.total > 0
@@ -5953,24 +6029,14 @@ export class InteractiveMode {
         const context = this.session.getContextUsage();
         const provider = this.session.model?.provider;
         const planResult = provider ? await getPlanUsageResult(provider, this.session.modelRuntime) : {};
-        const history = this.collectUsageHistorySafe();
-        const lines = renderUsageBox({ sessionTotals, context, plan: planResult.usage, history }, this.ui.terminal.columns);
+        const breakdown = this.collectUsageBreakdown();
+        const lines = renderUsageBox({ sessionTotals, context, plan: planResult.usage, breakdown }, this.ui.terminal.columns);
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(lines.join("\n"), 1, 0));
         if (planResult.error)
             this.showStatus(planResult.error);
         this.ui.requestRender();
     }
-    // lunr: /token-usage — per-model token breakdown for the current session and
-    // the last 30 days (from session files on disk).
-    handleTokenUsageCommand() {
-        const sessionRows = this.collectSessionModelRows();
-        const history = this.collectUsageHistorySafe();
-        const lines = renderTokenUsageBox({ sessionRows, history }, this.ui.terminal.columns);
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(lines.join("\n"), 1, 0));
-        this.ui.requestRender();
-    }
     // lunr: /context — estimated breakdown of what consumes the context window
     // (system prompt incl. project context files, tool definitions, and the live
     // session messages). Uses session.messages, so post-compaction renders match
@@ -5982,16 +6048,11 @@ export class InteractiveMode {
             this.showStatus("No model selected or context window unknown.");
             return;
         }
-        const tools = this.session
-            .getActiveToolNames()
-            .map((name) => this.session.getToolDefinition(name))
-            .filter((definition) => definition !== undefined);
-        const breakdown = computeContextBreakdown({
-            systemPrompt: this.session.systemPrompt,
-            tools,
-            messages: this.session.messages,
-            contextWindow,
-        });
+        const breakdown = this.collectUsageBreakdown();
+        if (!breakdown) {
+            this.showStatus("No model selected or context window unknown.");
+            return;
+        }
         const lines = renderContextBox({ breakdown, model: `${model.provider}/${model.id}` }, this.ui.terminal.columns);
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(lines.join("\n"), 1, 0));
@@ -6083,6 +6144,21 @@ export class InteractiveMode {
             this.session.setSystemPromptAppend(undefined);
         }
     }
+    // lunr: `/goal` forces session auto without writing settings.
+    enterGoalAuto() {
+        const next = nextModeForGoal(getPermissionMode(), "enter", this.preGoalPermissionMode);
+        this.preGoalPermissionMode = next.saved;
+        if (next.mode !== getPermissionMode()) {
+            this.applyPermissionMode(next.mode, { silent: true });
+        }
+    }
+    leaveGoalAuto() {
+        const next = nextModeForGoal(getPermissionMode(), "leave", this.preGoalPermissionMode);
+        this.preGoalPermissionMode = next.saved;
+        if (next.mode !== getPermissionMode()) {
+            this.applyPermissionMode(next.mode, { silent: true });
+        }
+    }
     applyPermissionMode(mode, opts) {
         const prev = getPermissionMode();
         if (mode === "plan" && prev !== "plan") {
@@ -6178,7 +6254,13 @@ export class InteractiveMode {
     // lunr: approval dialog for present_plan (plan mode). The "with feedback"
     // options collect a one-line note via showExtensionInput that becomes part of
     // the result text the model sees. Esc/close counts as Decline.
+    showPlanInChat(summary) {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new PlanMessageComponent(summary, this.getMarkdownThemeWithSettings(), this.outputPad, this.settingsManager.getGutterRail()));
+        this.ui.requestRender();
+    }
     async showPlanApprovalDialog(summary) {
+        this.showPlanInChat(summary);
         return new Promise((resolve) => {
             this.showSelector((done) => {
                 const selector = new ExtensionSelectorComponent("▶ Approve plan?", ["Approve", "Approve with feedback", "Decline", "Decline with feedback"], (option) => {
@@ -6202,7 +6284,7 @@ export class InteractiveMode {
                 }, () => {
                     done();
                     resolve("reject");
-                }, { message: summary.slice(0, 500) });
+                });
                 return { component: selector, focus: selector };
             });
         });