pi-ui-extend 0.1.8 → 0.1.11

package/dist/app/{mouse-controller.js → screen/mouse-controller.js}

@@ -1,13 +1,14 @@
 import { copyTextToClipboard } from "./clipboard.js";
-import { stringifyUnknown } from "./message-content.js";
-import { horizontalPaddingLayout } from "./render-text.js";
+import { stringifyUnknown } from "../rendering/message-content.js";
+import { horizontalPaddingLayout } from "../rendering/render-text.js";
 import { orderedSelection, samePoint } from "./screen-selection.js";
 import { openImageContent as openSystemImageContent } from "./image-opener.js";
-import { stringDisplayWidth } from "../terminal-width.js";
-import { formatDcpStatsToast } from "./dcp-stats.js";
+import { stringDisplayWidth } from "../../terminal-width.js";
+import { formatDcpStatsToast } from "../rendering/dcp-stats.js";
 import { detectFileLinks } from "./file-links.js";
 import { openFileLink as openDetectedFileLink } from "./file-link-opener.js";
 const CLICK_FLASH_MS = 100;
+const LOST_MOUSE_RELEASE_SETTLE_MS = 180;
 export class AppMouseController {
     host;
     popupMenus;
@@ -23,6 +24,7 @@ export class AppMouseController {
     statusContextTarget;
     statusModelUsageTarget;
     statusUserJumpTarget;
+    statusDraftQueueTarget;
     statusThinkingExpandTarget;
     statusCompactToolsTarget;
     statusTerminalBellSoundTarget;
@@ -40,6 +42,7 @@ export class AppMouseController {
     autoScrollAccumulator = 0;
     autoScrollLastTick = 0;
     autoScrollCursorX = 1;
+    leftEdgeReleaseFallbackTimer;
     clickFlash;
     clickFlashTimer;
     clickFlashDirty = false;
@@ -73,6 +76,8 @@ export class AppMouseController {
             return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusModelUsageClick(event)))
             return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusDraftQueueClick(event)))
+            return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusUserJumpClick(event)))
             return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusThinkingExpandClick(event)))
@@ -284,6 +289,7 @@ export class AppMouseController {
             this.statusThinkingTarget,
             this.statusContextTarget,
             this.statusModelUsageTarget,
+            this.statusDraftQueueTarget,
             this.statusUserJumpTarget,
             this.statusThinkingExpandTarget,
             this.statusCompactToolsTarget,
@@ -350,7 +356,7 @@ export class AppMouseController {
         const baseButton = event.button & 3;
         const draggingLeftButton = (event.button & 32) !== 0 && baseButton === 0;
         if (event.released) {
-            if (!this.scrollBarDragActive && !onScrollBar)
+            if (!this.scrollBarDragActive)
                 return false;
             this.scrollBarDragActive = false;
             return true;
@@ -380,7 +386,7 @@ export class AppMouseController {
         const baseButton = event.button & 3;
         const draggingLeftButton = (event.button & 32) !== 0 && baseButton === 0;
         if (event.released)
-            return this.finishInputScrollBarDrag(event, onScrollBar);
+            return this.finishInputScrollBarDrag(event);
         if (event.button === 0 && onScrollBar) {
             this.inputScrollBarDragActive = true;
             this.scrollInputToTrackRow(editorRow, scrollBar.trackHeight, renderedInput.totalLineCount, renderedInput.visibleRowCount);
@@ -392,10 +398,10 @@ export class AppMouseController {
         this.scrollInputToTrackRow(trackRow, scrollBar.trackHeight, renderedInput.totalLineCount, renderedInput.visibleRowCount);
         return true;
     }
-    finishInputScrollBarDrag(event, onScrollBar = false) {
+    finishInputScrollBarDrag(event) {
         if (!event.released)
             return false;
-        if (!this.inputScrollBarDragActive && !onScrollBar)
+        if (!this.inputScrollBarDragActive)
             return false;
         this.inputScrollBarDragActive = false;
         return true;
@@ -507,6 +513,15 @@ export class AppMouseController {
         this.host.render();
         return true;
     }
+    handleStatusDraftQueueClick(event) {
+        const target = this.statusDraftQueueTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        void this.host.queueInputFromStatus?.();
+        return true;
+    }
     handleStatusThinkingExpandClick(event) {
         const target = this.statusThinkingExpandTarget;
         if (!target)
@@ -634,42 +649,27 @@ export class AppMouseController {
         return true;
     }
     handleMouseSelection(event) {
-        const point = { x: event.x, y: event.y };
         const baseButton = event.button & 3;
         const draggingLeftButton = (event.button & 32) !== 0 && baseButton === 0;
         if (event.released) {
             if (!this.mouseSelection)
                 return false;
-            this.stopAutoScroll();
+            this.cancelLeftEdgeReleaseFallback();
             this.updateSelectionCurrentFromMouse(event, { autoScroll: false });
-            const selection = this.mouseSelection;
-            this.mouseSelection = undefined;
-            if (!selection.moved && samePoint(selection.anchor, point)) {
-                this.host.render();
-                return false;
-            }
-            const selectedText = this.getSelectedText(selection);
-            this.host.render();
-            if (selectedText.trim().length === 0)
-                return true;
-            try {
-                this.copyTextToClipboard(selectedText);
-                this.host.showToast("Copied to clipboard", "success");
-            }
-            catch (error) {
-                this.host.showToast(`Copy failed: ${stringifyUnknown(error)}`, "error");
-            }
-            return true;
+            return this.finishMouseSelection();
         }
         if (draggingLeftButton) {
             if (!this.mouseSelection)
                 return false;
             this.updateSelectionCurrentFromMouse(event);
+            this.updateLeftEdgeReleaseFallback(event);
             this.host.render();
             return true;
         }
         if (event.button === 0) {
+            this.cancelLeftEdgeReleaseFallback();
             this.stopAutoScroll();
+            const point = { x: event.x, y: event.y };
             const conversationPoint = this.conversationPointFromMouse(event, false);
             this.mouseSelection = conversationPoint
                 ? {
@@ -685,6 +685,47 @@ export class AppMouseController {
         }
         return false;
     }
+    finishMouseSelection() {
+        const selection = this.mouseSelection;
+        if (!selection)
+            return false;
+        this.cancelLeftEdgeReleaseFallback();
+        this.stopAutoScroll();
+        this.mouseSelection = undefined;
+        if (!selection.moved && samePoint(selection.anchor, selection.current)) {
+            this.host.render();
+            return false;
+        }
+        const selectedText = this.getSelectedText(selection);
+        this.host.render();
+        if (selectedText.trim().length === 0)
+            return true;
+        try {
+            this.copyTextToClipboard(selectedText);
+            this.host.showToast("Copied to clipboard", "success");
+        }
+        catch (error) {
+            this.host.showToast(`Copy failed: ${stringifyUnknown(error)}`, "error");
+        }
+        return true;
+    }
+    updateLeftEdgeReleaseFallback(event) {
+        if (!this.mouseSelection?.moved || event.x > 1) {
+            this.cancelLeftEdgeReleaseFallback();
+            return;
+        }
+        this.cancelLeftEdgeReleaseFallback();
+        this.leftEdgeReleaseFallbackTimer = setTimeout(() => {
+            this.leftEdgeReleaseFallbackTimer = undefined;
+            this.finishMouseSelection();
+        }, LOST_MOUSE_RELEASE_SETTLE_MS);
+    }
+    cancelLeftEdgeReleaseFallback() {
+        if (!this.leftEdgeReleaseFallbackTimer)
+            return;
+        clearTimeout(this.leftEdgeReleaseFallbackTimer);
+        this.leftEdgeReleaseFallbackTimer = undefined;
+    }
     syncConversationSelectionForRender(startLine, bodyHeight, topReservedRows, width) {
         this.renderedConversationFrame = {
             bodyHeight,
@@ -741,7 +782,9 @@ export class AppMouseController {
         return this.getSelectedScreenText(selection.anchor, selection.current);
     }
     copyTextToClipboard(text) {
-        (this.host.copyTextToClipboard ?? copyTextToClipboard)(text);
+        void Promise.resolve((this.host.copyTextToClipboard ?? copyTextToClipboard)(text)).catch((error) => {
+            this.host.showToast(error instanceof Error ? error.message : String(error), "error");
+        });
     }
     getSelectedScreenText(anchor, current) {
         const range = orderedSelection(anchor, current);

package/dist/app/{screen-selection.d.ts → screen/screen-selection.d.ts}

@@ -1,4 +1,4 @@
-import type { ScreenPoint } from "./types.js";
+import type { ScreenPoint } from "../types.js";
 export declare function samePoint(left: ScreenPoint, right: ScreenPoint): boolean;
 export declare function orderedSelection(anchor: ScreenPoint, current: ScreenPoint): {
     start: ScreenPoint;

package/dist/app/{screen-styler.d.ts → screen/screen-styler.d.ts}

@@ -1,5 +1,5 @@
-import { type Theme } from "../theme.js";
-import type { MouseSelection, RenderedLine, StyledSegment } from "./types.js";
+import { type Theme } from "../../theme.js";
+import type { MouseSelection, RenderedLine, StyledSegment } from "../types.js";
 export type ScreenStylerHost = {
     readonly theme: Theme;
     readonly cwd?: string;
@@ -24,7 +24,10 @@ export declare class ScreenStyler {
     styleInputLine(row: number, text: string, tagSpans: readonly {
         start: number;
         end: number;
-    }[] | undefined, width: number, tagColor: string, frameColor?: string): string;
+    }[] | undefined, suggestionSpans: readonly {
+        start: number;
+        end: number;
+    }[] | undefined, width: number, tagColor: string, suggestionColor: string, frameColor?: string): string;
     private styleAnsiLine;
     selectionRangeForRow(row: number, width: number): {
         startIndex: number;

package/dist/app/{screen-styler.js → screen/screen-styler.js}

@@ -1,7 +1,7 @@
-import { ANSI_RESET, colorize } from "../theme.js";
-import { renderMarkdownLine } from "../markdown-format.js";
-import { syntaxHighlightSegmentsForLine } from "../syntax-highlight.js";
-import { padOrTrimPlain } from "./render-text.js";
+import { ANSI_RESET, colorize } from "../../theme.js";
+import { renderMarkdownLine } from "../../markdown-format.js";
+import { syntaxHighlightSegmentsForLine } from "../../syntax-highlight.js";
+import { padOrTrimPlain } from "../rendering/render-text.js";
 import { orderedSelection } from "./screen-selection.js";
 export class ScreenStyler {
     host;
@@ -72,14 +72,14 @@ export class ScreenStyler {
             colorize(after, options),
         ].join("");
     }
-    styleInputLine(row, text, tagSpans, width, tagColor, frameColor) {
+    styleInputLine(row, text, tagSpans, suggestionSpans, width, tagColor, suggestionColor, frameColor) {
         const colors = this.host.theme.colors;
         const baseOptions = { foreground: colors.inputForeground };
         if (this.selectionRangeForRow(row, width))
             return this.styleLine(row, text, width, baseOptions);
         const plain = padOrTrimPlain(text, width);
         const frameSpans = inputFrameSpans(plain, width, frameColor);
-        if ((!tagSpans || tagSpans.length === 0) && frameSpans.length === 0) {
+        if ((!tagSpans || tagSpans.length === 0) && (!suggestionSpans || suggestionSpans.length === 0) && frameSpans.length === 0) {
             return hasAnsi(plain) ? this.styleAnsiLine(plain, baseOptions) : colorize(plain, baseOptions);
         }
         const chunks = [];
@@ -88,6 +88,7 @@ export class ScreenStyler {
         const spans = [
             ...frameSpans,
             ...(tagSpans ?? []).map((span) => ({ ...span, foreground: tagColor, bold: true })),
+            ...(suggestionSpans ?? []).map((span) => ({ ...span, foreground: suggestionColor })),
         ].sort((a, b) => a.start - b.start || a.end - b.end);
         for (const span of spans) {
             const start = Math.max(offset, Math.min(endOffset, span.start));

package/dist/app/{scroll-controller.d.ts → screen/scroll-controller.d.ts}

@@ -1,6 +1,6 @@
-import type { ConversationViewport } from "./conversation-viewport.js";
-import type { EditorLayoutRenderer } from "./editor-layout-renderer.js";
-import type { RenderedLine } from "./types.js";
+import type { ConversationViewport } from "../rendering/conversation-viewport.js";
+import type { EditorLayoutRenderer } from "../rendering/editor-layout-renderer.js";
+import type { RenderedLine } from "../types.js";
 export type AppScrollMetrics = {
     bodyHeight: number;
     viewportColumns: number;

package/dist/app/{scroll-controller.js → screen/scroll-controller.js}

@@ -1,4 +1,4 @@
-import { sanitizeText } from "./render-text.js";
+import { sanitizeText } from "../rendering/render-text.js";
 export class AppScrollController {
     host;
     scrollFromBottom = 0;

package/dist/app/{status-controller.d.ts → screen/status-controller.d.ts}

@@ -1,18 +1,20 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
-import type { Theme } from "../theme.js";
+import type { Theme } from "../../theme.js";
 import type { AppBlinkController } from "./blink-controller.js";
-import type { SessionActivity } from "./types.js";
+import type { SessionActivity } from "../types.js";
 export type AppStatusControllerHost = {
     readonly cwd: string;
     readonly theme: Theme;
     readonly blinkController: AppBlinkController;
     runtimeSession(): AgentSession | undefined;
+    render(): void;
 };
 export declare class AppStatusController {
     private readonly host;
     private status;
     private statusFollowsSession;
     private gitBranchCache;
+    private gitBranchLookupInFlight;
     sessionActivity: SessionActivity;
     get statusDotBright(): boolean;
     constructor(host: AppStatusControllerHost);
@@ -31,5 +33,6 @@ export declare class AppStatusController {
     roundedContextUsagePercent(session: AgentSession): number | undefined;
     contextUsagePercentColor(percent: number): string;
     private currentGitBranchName;
+    private refreshGitBranchName;
     private startStatusBlink;
 }

package/dist/app/{status-controller.js → screen/status-controller.js}

@@ -1,12 +1,13 @@
-import { spawnSync } from "node:child_process";
 import { basename } from "node:path";
-import { GIT_BRANCH_CACHE_MS } from "./constants.js";
+import { GIT_BRANCH_CACHE_MS } from "../constants.js";
+import { runProcess } from "../process.js";
 const STATUS_DOT_BLINK_KEY = "status-dot";
 export class AppStatusController {
     host;
     status = "starting";
     statusFollowsSession = false;
     gitBranchCache;
+    gitBranchLookupInFlight = false;
     sessionActivity = "idle";
     get statusDotBright() {
         return this.host.blinkController.visible(STATUS_DOT_BLINK_KEY, false);
@@ -87,13 +88,27 @@ export class AppStatusController {
         if (this.gitBranchCache && now - this.gitBranchCache.checkedAt < GIT_BRANCH_CACHE_MS) {
             return this.gitBranchCache.branch;
         }
-        const result = spawnSync("git", ["-C", this.host.cwd, "branch", "--show-current"], {
-            encoding: "utf8",
-            timeout: 150,
-        });
-        const branch = result.status === 0 ? result.stdout.trim() || undefined : undefined;
-        this.gitBranchCache = { checkedAt: now, branch };
-        return branch;
+        if (!this.gitBranchLookupInFlight) {
+            this.gitBranchLookupInFlight = true;
+            void this.refreshGitBranchName();
+        }
+        return this.gitBranchCache?.branch;
+    }
+    async refreshGitBranchName() {
+        const previous = this.gitBranchCache?.branch;
+        try {
+            const result = await runProcess("git", ["-C", this.host.cwd, "branch", "--show-current"], {
+                timeoutMs: 150,
+                maxBufferBytes: 1024,
+            });
+            const branch = result.status === 0 ? result.stdout.trim() || undefined : undefined;
+            this.gitBranchCache = { checkedAt: Date.now(), branch };
+            if (branch !== previous)
+                this.host.render();
+        }
+        finally {
+            this.gitBranchLookupInFlight = false;
+        }
     }
     startStatusBlink() {
         this.host.blinkController.setActive(STATUS_DOT_BLINK_KEY, true, {

package/dist/app/{queued-message-controller.d.ts → session/queued-message-controller.d.ts}

@@ -1,6 +1,6 @@
 import type { AgentSession, AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
-import type { ImageContent } from "../input-editor.js";
-import type { Entry, SessionActivity, SubmittedUserMessage } from "./types.js";
+import type { ImageContent } from "../../input-editor.js";
+import type { Entry, SessionActivity, SubmittedUserMessage } from "../types.js";
 export type AppQueuedMessageControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     requireRuntime(): AgentSessionRuntime;
@@ -19,6 +19,7 @@ export type AppQueuedMessageControllerHost = {
     setInput(value: string): void;
     insertInput(value: string): void;
     attachImage(data: string, mimeType: string): void;
+    onDeferredUserMessagesChanged?(): void;
 };
 export declare class AppQueuedMessageController {
     private readonly host;
@@ -28,6 +29,8 @@ export declare class AppQueuedMessageController {
     private immediateSendInProgress;
     constructor(host: AppQueuedMessageControllerHost);
     reset(): void;
+    captureDeferredUserMessages(): SubmittedUserMessage[];
+    restoreDeferredUserMessages(messages: readonly SubmittedUserMessage[]): void;
     createSubmittedUserMessage(promptText: string, displayText: string, images: ImageContent[]): SubmittedUserMessage;
     submitUserMessage(message: SubmittedUserMessage): Promise<void>;
     sendUserMessageToSession(message: SubmittedUserMessage, options?: {
@@ -44,11 +47,12 @@ export declare class AppQueuedMessageController {
     cancelQueuedMessage(entryId: string): Promise<void>;
     editQueuedMessage(entryId: string): Promise<void>;
     sendQueuedMessageImmediately(entryId: string): Promise<void>;
+    private sendQueuedEntryImmediately;
     findQueuedEntry(entryId: string): Extract<Entry, {
         kind: "queued";
     }> | undefined;
     private shouldDeferUserMessage;
-    private deferUserMessage;
+    deferUserMessage(message: SubmittedUserMessage): void;
     private rewriteSdkQueuedMessages;
     private takeQueuedEntryForInterruptedSend;
     private restoreSdkQueuedMessages;
@@ -59,4 +63,6 @@ export declare class AppQueuedMessageController {
     private requeueRemovedEntry;
     private restoreSubmittedMessageToEditor;
     private restorableSubmittedMessageText;
+    private cloneSubmittedUserMessage;
+    private notifyDeferredUserMessagesChanged;
 }

package/dist/app/{queued-message-controller.js → session/queued-message-controller.js}

@@ -1,5 +1,5 @@
-import { createId } from "./id.js";
-import { stringifyUnknown, submittedUserDisplayText } from "./message-content.js";
+import { createId } from "../id.js";
+import { stringifyUnknown, submittedUserDisplayText } from "../rendering/message-content.js";
 export class AppQueuedMessageController {
     host;
     deferredUserMessages = [];
@@ -14,6 +14,14 @@ export class AppQueuedMessageController {
         this.promptSubmissionInFlight = false;
         this.flushingDeferredUserMessages = false;
     }
+    captureDeferredUserMessages() {
+        return this.deferredUserMessages.map((message) => this.cloneSubmittedUserMessage(message));
+    }
+    restoreDeferredUserMessages(messages) {
+        this.deferredUserMessages.length = 0;
+        this.deferredUserMessages.push(...messages.map((message) => this.cloneSubmittedUserMessage(message)));
+        this.updateQueuedMessageStatus();
+    }
     createSubmittedUserMessage(promptText, displayText, images) {
         return {
             id: createId("queued-user"),
@@ -55,8 +63,6 @@ export class AppQueuedMessageController {
             }
             if (this.totalQueuedMessageCount() > 0)
                 this.updateQueuedMessageStatus();
-            if (!this.flushingDeferredUserMessages)
-                void this.flushDeferredUserMessages();
         }
     }
     async flushDeferredUserMessages() {
@@ -80,22 +86,14 @@ export class AppQueuedMessageController {
                 const message = this.deferredUserMessages.shift();
                 if (!message)
                     break;
+                this.notifyDeferredUserMessagesChanged();
                 this.updateQueuedMessageStatus();
-                if (!activeSession.isStreaming && this.deferredUserMessages.length > 0) {
-                    void this.sendUserMessageToSession(message).catch((error) => {
-                        this.deferredUserMessages.unshift(message);
-                        this.updateQueuedMessageStatus();
-                        this.host.addEntry({ id: createId("error"), kind: "error", text: `Queued message failed: ${stringifyUnknown(error)}` });
-                        if (this.host.isRunning())
-                            this.host.render();
-                    });
-                    break;
-                }
                 try {
                     await this.sendUserMessageToSession(message);
                 }
                 catch (error) {
                     this.deferredUserMessages.unshift(message);
+                    this.notifyDeferredUserMessagesChanged();
                     this.updateQueuedMessageStatus();
                     this.host.addEntry({ id: createId("error"), kind: "error", text: `Queued message failed: ${stringifyUnknown(error)}` });
                     break;
@@ -103,17 +101,11 @@ export class AppQueuedMessageController {
             }
         }
         finally {
-            const shouldRetryFlush = this.deferredUserMessages.length > 0 && Boolean(this.host.runtime()?.session) && !this.host.runtime()?.session.isCompacting;
             this.flushingDeferredUserMessages = false;
             if (this.totalQueuedMessageCount() > 0)
                 this.updateQueuedMessageStatus();
             if (this.host.isRunning())
                 this.host.render();
-            if (shouldRetryFlush) {
-                queueMicrotask(() => {
-                    void this.flushDeferredUserMessages();
-                });
-            }
         }
     }
     queuedMessageCounts() {
@@ -135,6 +127,8 @@ export class AppQueuedMessageController {
         const session = this.host.runtime()?.session;
         const sdkQueued = session?.clearQueue() ?? { steering: [], followUp: [] };
         const deferred = this.deferredUserMessages.splice(0);
+        if (deferred.length > 0)
+            this.notifyDeferredUserMessagesChanged();
         const restoredTexts = [
             ...sdkQueued.steering,
             ...deferred.map((message) => this.restorableSubmittedMessageText(message)),
@@ -186,6 +180,9 @@ export class AppQueuedMessageController {
         const entry = this.findQueuedEntry(entryId);
         if (!entry)
             throw new Error("Queued message is no longer available");
+        await this.sendQueuedEntryImmediately(entry);
+    }
+    async sendQueuedEntryImmediately(entry) {
         const session = this.host.requireRuntime().session;
         const shouldInterrupt = session.isStreaming || session.isCompacting;
         const taken = shouldInterrupt
@@ -224,8 +221,6 @@ export class AppQueuedMessageController {
             this.immediateSendInProgress = false;
             if (this.totalQueuedMessageCount() > 0)
                 this.updateQueuedMessageStatus();
-            if (!this.flushingDeferredUserMessages)
-                void this.flushDeferredUserMessages();
         }
     }
     findQueuedEntry(entryId) {
@@ -233,11 +228,13 @@ export class AppQueuedMessageController {
         return entry?.kind === "queued" ? entry : undefined;
     }
     shouldDeferUserMessage(session) {
-        return session.isCompacting || (!session.isStreaming && this.promptSubmissionInFlight);
+        return session.isStreaming || session.isCompacting || this.promptSubmissionInFlight;
     }
     deferUserMessage(message) {
         this.deferredUserMessages.push(message);
+        this.notifyDeferredUserMessagesChanged();
         this.updateQueuedMessageStatus();
+        this.host.showToast("Message queued; send it from the queue menu or status button", "info");
         this.host.render();
     }
     async rewriteSdkQueuedMessages(update) {
@@ -282,6 +279,7 @@ export class AppQueuedMessageController {
             if (!message)
                 throw new Error("Queued message is no longer available");
             session.clearQueue();
+            this.notifyDeferredUserMessagesChanged();
             return { removed: message, sdkMessagesToRestore: sdkMessages };
         }
         const messages = entry.queueSource === "sdk-steering" ? sdkMessages.steering : sdkMessages.followUp;
@@ -334,6 +332,7 @@ export class AppQueuedMessageController {
             const [message] = this.deferredUserMessages.splice(entry.queueIndex, 1);
             if (!message)
                 throw new Error("Queued message is no longer available");
+            this.notifyDeferredUserMessagesChanged();
             return message;
         }
         const removed = await this.rewriteSdkQueuedMessages((steering, followUp) => {
@@ -350,6 +349,7 @@ export class AppQueuedMessageController {
             if (typeof removed === "string")
                 return;
             this.deferredUserMessages.splice(Math.min(entry.queueIndex, this.deferredUserMessages.length), 0, removed);
+            this.notifyDeferredUserMessagesChanged();
             return;
         }
         if (typeof removed !== "string")
@@ -374,4 +374,15 @@ export class AppQueuedMessageController {
             ? message.promptText.replace(/\[Image \d+(?:: [^\]]+)?\]\s*/g, "").trimEnd()
             : message.promptText.trimEnd();
     }
+    cloneSubmittedUserMessage(message) {
+        return {
+            id: message.id,
+            promptText: message.promptText,
+            displayText: message.displayText,
+            images: message.images.map((image) => ({ ...image })),
+        };
+    }
+    notifyDeferredUserMessagesChanged() {
+        this.host.onDeferredUserMessagesChanged?.();
+    }
 }

package/dist/app/{request-history.js → session/request-history.js}

@@ -1,8 +1,8 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { REQUEST_HISTORY_MAX_BYTES, REQUEST_HISTORY_MAX_ENTRIES, REQUEST_HISTORY_MAX_ENTRY_BYTES, REQUEST_HISTORY_VERSION, } from "./constants.js";
-import { isRecord } from "./guards.js";
+import { REQUEST_HISTORY_MAX_BYTES, REQUEST_HISTORY_MAX_ENTRIES, REQUEST_HISTORY_MAX_ENTRY_BYTES, REQUEST_HISTORY_VERSION, } from "../constants.js";
+import { isRecord } from "../guards.js";
 export class AppRequestHistory {
     host;
     entries = [];

package/dist/app/session/resume-session-loader.d.ts

@@ -0,0 +1,15 @@
+import { type SessionInfo } from "@earendil-works/pi-coding-agent";
+export type ResumeSessionLoadProgress = {
+    loaded: number;
+    total: number;
+    done: boolean;
+};
+export type ResumeSessionLoaderOptions = {
+    cwd: string;
+    sessionDir?: string;
+    initialChunkSize?: number;
+    chunkSize?: number;
+    signal?: AbortSignal;
+    onChunk(sessions: readonly SessionInfo[], progress: ResumeSessionLoadProgress): void;
+};
+export declare function loadResumeSessionsInChunks(options: ResumeSessionLoaderOptions): Promise<SessionInfo[]>;