pi-ui-extend 0.1.9 → 0.1.13

package/dist/app/screen/clipboard.d.ts

@@ -1,4 +1,13 @@
-export declare function copyTextToClipboard(text: string): void;
-export declare function clipboardSupportAvailable(env?: NodeJS.ProcessEnv): boolean;
+import { commandExists, runProcess } from "../process.js";
+type ClipboardDeps = {
+    commandExists: typeof commandExists;
+    requireResolve(specifier: string): string;
+    runProcess: typeof runProcess;
+    stdout: Pick<NodeJS.WriteStream, "destroyed" | "isTTY" | "write">;
+};
+export declare function setClipboardTestDeps(overrides: Partial<ClipboardDeps>): () => void;
+export declare function copyTextToClipboard(text: string): Promise<void>;
+export declare function clipboardSupportAvailable(env?: NodeJS.ProcessEnv): Promise<boolean>;
 export declare function clipboardInstallHint(): string;
 export declare function osc52ClipboardSequence(text: string, env?: NodeJS.ProcessEnv): string;
+export {};

package/dist/app/screen/clipboard.js

@@ -1,22 +1,37 @@
-import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
+import { commandExists, runProcess } from "../process.js";
 const require = createRequire(import.meta.url);
-export function copyTextToClipboard(text) {
+let deps = {
+    commandExists,
+    requireResolve: (specifier) => require.resolve(specifier),
+    runProcess,
+    stdout: process.stdout,
+};
+export function setClipboardTestDeps(overrides) {
+    const previous = deps;
+    deps = { ...deps, ...overrides };
+    return () => {
+        deps = previous;
+    };
+}
+export async function copyTextToClipboard(text) {
     const commands = clipboardCommands();
     for (const [command, args] of commands) {
-        const result = spawnSync(command, args, { input: text, stdio: ["pipe", "ignore", "ignore"] });
+        const result = await deps.runProcess(command, args, { input: text, maxBufferBytes: 1024 });
         if (!result.error && result.status === 0)
             return;
     }
-    if (copyWithNativeClipboard(text))
+    if (await copyWithNativeClipboard(text))
         return;
     if (copyWithOsc52(text))
         return;
     throw new Error(`No clipboard command found. ${clipboardInstallHint()}`);
 }
-export function clipboardSupportAvailable(env = process.env) {
-    if (clipboardCommands().some(([command]) => commandExists(command, env)))
-        return true;
+export async function clipboardSupportAvailable(env = process.env) {
+    for (const [command] of clipboardCommands()) {
+        if (await deps.commandExists(command, env))
+            return true;
+    }
     return resolveNativeClipboardEntrypoint() !== undefined;
 }
 export function clipboardInstallHint() {
@@ -44,7 +59,7 @@ function clipboardCommands() {
             ];
     }
 }
-function copyWithNativeClipboard(text) {
+async function copyWithNativeClipboard(text) {
     const entrypoint = resolveNativeClipboardEntrypoint();
     if (!entrypoint)
         return false;
@@ -55,17 +70,17 @@ function copyWithNativeClipboard(text) {
 		const clipboard = require(${JSON.stringify(entrypoint)});
 		await clipboard.setText(readFileSync(0, "utf8"));
 	`;
-    const result = spawnSync(process.execPath, ["--input-type=module", "-e", script], {
+    const result = await deps.runProcess(process.execPath, ["--input-type=module", "-e", script], {
         input: text,
-        stdio: ["pipe", "ignore", "ignore"],
-        timeout: 3_000,
+        timeoutMs: 3_000,
+        maxBufferBytes: 1024,
     });
     return !result.error && result.status === 0;
 }
 function copyWithOsc52(text) {
-    if (process.stdout.destroyed || (!process.stdout.isTTY && !process.env.TMUX && !process.env.STY))
+    if (deps.stdout.destroyed || (!deps.stdout.isTTY && !process.env.TMUX && !process.env.STY))
         return false;
-    process.stdout.write(osc52ClipboardSequence(text));
+    deps.stdout.write(osc52ClipboardSequence(text));
     return true;
 }
 export function osc52ClipboardSequence(text, env = process.env) {
@@ -78,16 +93,9 @@ export function osc52ClipboardSequence(text, env = process.env) {
 }
 function resolveNativeClipboardEntrypoint() {
     try {
-        return require.resolve("@mariozechner/clipboard");
+        return deps.requireResolve("@mariozechner/clipboard");
     }
     catch {
         return undefined;
     }
 }
-function commandExists(command, env) {
-    const names = process.platform === "win32" ? [command, command.replace(/\.exe$/iu, ".cmd"), command.replace(/\.exe$/iu, ".bat")] : [command];
-    return names.some((name) => spawnSync(process.platform === "win32" ? "where" : "sh", process.platform === "win32" ? [name] : ["-lc", `command -v ${shellQuote(name)}`], { env, stdio: "ignore" }).status === 0);
-}
-function shellQuote(value) {
-    return `'${value.replaceAll("'", `'\\''`)}'`;
-}

package/dist/app/screen/file-link-opener.d.ts

@@ -1,2 +1,10 @@
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
 import type { RenderedLink } from "./file-links.js";
+type FileLinkOpenerDeps = {
+    existsSync: typeof existsSync;
+    spawn: typeof spawn;
+};
+export declare function setFileLinkOpenerTestDeps(overrides: Partial<FileLinkOpenerDeps>): () => void;
 export declare function openFileLink(link: RenderedLink): boolean;
+export {};

package/dist/app/screen/file-link-opener.js

@@ -2,6 +2,14 @@ import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { delimiter, join } from "node:path";
 import { fileURLToPath } from "node:url";
+let deps = { existsSync, spawn };
+export function setFileLinkOpenerTestDeps(overrides) {
+    const previous = deps;
+    deps = { ...deps, ...overrides };
+    return () => {
+        deps = previous;
+    };
+}
 export function openFileLink(link) {
     const filePath = link.filePath ?? filePathFromUrl(link.url);
     if (!filePath)
@@ -37,7 +45,7 @@ function zedCommandCandidates() {
 }
 function trySpawnCandidates(candidates, args) {
     for (const command of candidates) {
-        if (command.includes("/") && !existsSync(command))
+        if (command.includes("/") && !deps.existsSync(command))
             continue;
         if (!command.includes("/") && !commandOnPath(command))
             continue;
@@ -51,11 +59,11 @@ function commandOnPath(command) {
     const extensions = process.platform === "win32"
         ? (process.env.PATHEXT?.split(";") ?? [".EXE", ".CMD", ".BAT", ".COM"])
         : [""];
-    return pathEntries.some((entry) => extensions.some((extension) => existsSync(join(entry, `${command}${extension}`))));
+    return pathEntries.some((entry) => extensions.some((extension) => deps.existsSync(join(entry, `${command}${extension}`))));
 }
 function spawnDetached(command, args) {
     try {
-        const child = spawn(command, args, { detached: true, stdio: "ignore" });
+        const child = deps.spawn(command, args, { detached: true, stdio: "ignore" });
         child.on("error", () => { });
         child.unref();
         return true;

package/dist/app/screen/file-links.js

@@ -2,11 +2,11 @@ import { existsSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-const FILE_PATH_CANDIDATE = /(?<![\p{L}\p{N}_:])((?:file:\/\/\/|~\/|\.{1,2}\/|\/|[A-Za-z0-9_.@-]+\/)[^\s"'`<>]*)/gu;
+const FILE_PATH_CANDIDATE = /(?<![\p{L}\p{N}_:])((?:file:\/\/\/|~[\\/]|\.{1,2}[\\/]|[A-Za-z]:[\\/]|[\\/]|[A-Za-z0-9_.@-]+[\\/])[^\s"'`<>]*)/gu;
 const TRAILING_PUNCTUATION = new Set([".", ",", ";", ")", "]", "}"]);
 export function detectFileLinks(text, cwd) {
     const links = [];
-    if (!text.includes("/"))
+    if (!text.includes("/") && !text.includes("\\"))
         return links;
     for (const match of text.matchAll(FILE_PATH_CANDIDATE)) {
         const raw = match[1];
@@ -89,7 +89,7 @@ function resolveLocalPath(pathText, cwd) {
             return undefined;
         }
     }
-    if (pathText.startsWith("~/"))
+    if (pathText.startsWith("~/") || pathText.startsWith("~\\"))
         return resolve(homedir(), pathText.slice(2));
     if (isAbsolute(pathText))
         return pathText;

package/dist/app/screen/image-opener.d.ts

@@ -1,2 +1,14 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import type { ImageContent } from "../../input-editor.js";
+type ImageOpenerDeps = {
+    existsSync: typeof existsSync;
+    mkdirSync: typeof mkdirSync;
+    spawn: typeof spawn;
+    tmpdir: typeof tmpdir;
+    writeFileSync: typeof writeFileSync;
+};
+export declare function setImageOpenerTestDeps(overrides: Partial<ImageOpenerDeps>): () => void;
 export declare function openImageContent(image: ImageContent): boolean;
+export {};

package/dist/app/screen/image-opener.js

@@ -3,6 +3,14 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+let deps = { existsSync, mkdirSync, spawn, tmpdir, writeFileSync };
+export function setImageOpenerTestDeps(overrides) {
+    const previous = deps;
+    deps = { ...deps, ...overrides };
+    return () => {
+        deps = previous;
+    };
+}
 export function openImageContent(image) {
     const filePath = writeImageTempFile(image);
     if (!filePath)
@@ -14,12 +22,12 @@ function writeImageTempFile(image) {
         const data = Buffer.from(image.data, "base64");
         if (data.length === 0)
             return undefined;
-        const dir = join(tmpdir(), "pix-image-open");
-        mkdirSync(dir, { recursive: true });
+        const dir = join(deps.tmpdir(), "pix-image-open");
+        deps.mkdirSync(dir, { recursive: true });
         const hash = createHash("sha256").update(image.mimeType).update("\0").update(data).digest("hex").slice(0, 24);
         const filePath = join(dir, `${hash}${imageExtension(image.mimeType)}`);
-        if (!existsSync(filePath))
-            writeFileSync(filePath, data, { flag: "wx" });
+        if (!deps.existsSync(filePath))
+            deps.writeFileSync(filePath, data, { flag: "wx" });
         return filePath;
     }
     catch {
@@ -53,7 +61,7 @@ function openPathWithSystemViewer(filePath) {
 }
 function spawnDetached(command, args) {
     try {
-        const child = spawn(command, args, { detached: true, stdio: "ignore" });
+        const child = deps.spawn(command, args, { detached: true, stdio: "ignore" });
         child.on("error", () => { });
         child.unref();
         return true;

package/dist/app/screen/mouse-controller.d.ts

@@ -6,7 +6,7 @@ import type { ToastEntry, ToastVariant } from "../../ui.js";
 import type { AppPopupActionController } from "../popup/popup-action-controller.js";
 import type { AppPopupMenuController } from "../popup/popup-menu-controller.js";
 import type { AppScrollController } from "./scroll-controller.js";
-import type { Entry, ImageClickTarget, MouseEvent, MouseSelection, StatusContextTarget, StatusCompactToolsTarget, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, TabLineMouseTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
+import type { Entry, ImageClickTarget, MouseEvent, MouseSelection, StatusContextTarget, StatusCompactToolsTarget, StatusDraftQueueTarget, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, TabLineMouseTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
 import { type RenderedLink } from "./file-links.js";
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
 type ClickFlash = {
@@ -56,10 +56,11 @@ export type AppMouseControllerHost = {
     }): void;
     dismissToast(toastId: number): void;
     refreshModelUsageStatus(): void | Promise<void>;
+    queueInputFromStatus?(): void | Promise<void>;
     toggleAllThinkingExpanded?(): void;
     toggleSuperCompactTools?(): void;
     toggleTerminalBellSound?(): void;
-    copyTextToClipboard?(text: string): void;
+    copyTextToClipboard?(text: string): void | Promise<void>;
     handleExtensionInputMouse(event: MouseEvent & {
         localRow: number;
         localColumn: number;
@@ -100,6 +101,7 @@ export declare class AppMouseController {
     statusContextTarget: StatusContextTarget | undefined;
     statusModelUsageTarget: StatusModelUsageTarget | undefined;
     statusUserJumpTarget: StatusUserJumpTarget | undefined;
+    statusDraftQueueTarget: StatusDraftQueueTarget | undefined;
     statusThinkingExpandTarget: StatusThinkingExpandTarget | undefined;
     statusCompactToolsTarget: StatusCompactToolsTarget | undefined;
     statusTerminalBellSoundTarget: StatusTerminalBellSoundTarget | undefined;
@@ -153,6 +155,7 @@ export declare class AppMouseController {
     private handleStatusContextClick;
     private handleStatusModelUsageClick;
     private handleStatusUserJumpClick;
+    private handleStatusDraftQueueClick;
     private handleStatusThinkingExpandClick;
     private handleStatusCompactToolsClick;
     private handleStatusTerminalBellSoundClick;

package/dist/app/screen/mouse-controller.js

@@ -24,6 +24,7 @@ export class AppMouseController {
     statusContextTarget;
     statusModelUsageTarget;
     statusUserJumpTarget;
+    statusDraftQueueTarget;
     statusThinkingExpandTarget;
     statusCompactToolsTarget;
     statusTerminalBellSoundTarget;
@@ -75,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)))
@@ -286,6 +289,7 @@ export class AppMouseController {
             this.statusThinkingTarget,
             this.statusContextTarget,
             this.statusModelUsageTarget,
+            this.statusDraftQueueTarget,
             this.statusUserJumpTarget,
             this.statusThinkingExpandTarget,
             this.statusCompactToolsTarget,
@@ -509,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)
@@ -769,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/screen-styler.d.ts

@@ -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/screen-styler.js

@@ -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/screen/status-controller.d.ts

@@ -7,12 +7,14 @@ export type AppStatusControllerHost = {
     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/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 { 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/session/queued-message-controller.d.ts

@@ -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/session/queued-message-controller.js

@@ -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"),
@@ -24,6 +32,10 @@ export class AppQueuedMessageController {
     }
     async submitUserMessage(message) {
         const session = this.host.requireRuntime().session;
+        if (session.isStreaming) {
+            await this.sendUserMessageToSession(message, { streamingBehavior: "steer" });
+            return;
+        }
         if (this.shouldDeferUserMessage(session)) {
             this.deferUserMessage(message);
             return;
@@ -55,8 +67,6 @@ export class AppQueuedMessageController {
             }
             if (this.totalQueuedMessageCount() > 0)
                 this.updateQueuedMessageStatus();
-            if (!this.flushingDeferredUserMessages)
-                void this.flushDeferredUserMessages();
         }
     }
     async flushDeferredUserMessages() {
@@ -80,22 +90,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 +105,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 +131,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 +184,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 +225,6 @@ export class AppQueuedMessageController {
             this.immediateSendInProgress = false;
             if (this.totalQueuedMessageCount() > 0)
                 this.updateQueuedMessageStatus();
-            if (!this.flushingDeferredUserMessages)
-                void this.flushDeferredUserMessages();
         }
     }
     findQueuedEntry(entryId) {
@@ -233,11 +232,13 @@ export class AppQueuedMessageController {
         return entry?.kind === "queued" ? entry : undefined;
     }
     shouldDeferUserMessage(session) {
-        return session.isCompacting || (!session.isStreaming && this.promptSubmissionInFlight);
+        return 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 +283,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 +336,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 +353,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 +378,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/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[]>;