pi-ui-extend 0.1.8 → 0.1.11

package/dist/app/session/resume-session-loader.js

@@ -0,0 +1,204 @@
+import { open, readdir, readFile, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { isRecord } from "../guards.js";
+const DEFAULT_INITIAL_CHUNK_SIZE = 20;
+const DEFAULT_CHUNK_SIZE = 10;
+export async function loadResumeSessionsInChunks(options) {
+    const initialChunkSize = positiveInteger(options.initialChunkSize, DEFAULT_INITIAL_CHUNK_SIZE);
+    const chunkSize = positiveInteger(options.chunkSize, DEFAULT_CHUNK_SIZE);
+    const files = await listSessionFiles(options.cwd, options.sessionDir);
+    const sessions = [];
+    if (files.length === 0) {
+        options.onChunk([], { loaded: 0, total: 0, done: true });
+        return [];
+    }
+    let index = 0;
+    let currentChunkSize = initialChunkSize;
+    while (index < files.length) {
+        if (options.signal?.aborted)
+            break;
+        const chunk = files.slice(index, index + currentChunkSize);
+        const infos = await Promise.all(chunk.map((file) => buildSessionInfo(file)));
+        for (const info of infos) {
+            if (info)
+                sessions.push(info);
+        }
+        sessions.sort(compareSessionsByModifiedDesc);
+        index += currentChunkSize;
+        const done = index >= files.length || options.signal?.aborted === true;
+        options.onChunk([...sessions], { loaded: Math.min(index, files.length), total: files.length, done });
+        currentChunkSize = chunkSize;
+        if (!done)
+            await nextTick();
+    }
+    return [...sessions];
+}
+async function listSessionFiles(cwd, sessionDir) {
+    const dir = sessionDir ? resolve(sessionDir) : getDefaultSessionDir(cwd);
+    const defaultDir = getDefaultSessionDir(cwd);
+    const shouldFilterCwd = sessionDir !== undefined && resolve(dir) !== resolve(defaultDir);
+    const resolvedCwd = resolve(cwd);
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        const files = await Promise.all(entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+            .map(async (entry) => {
+            const path = join(dir, entry.name);
+            try {
+                const stats = await stat(path);
+                if (shouldFilterCwd) {
+                    const header = await readSessionHeader(path);
+                    if (!header || !sessionCwdMatches(header.cwd, resolvedCwd))
+                        return undefined;
+                }
+                return { path, mtime: stats.mtime };
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        return files
+            .filter((file) => file !== undefined)
+            .sort((left, right) => right.mtime.getTime() - left.mtime.getTime());
+    }
+    catch {
+        return [];
+    }
+}
+async function readSessionHeader(filePath) {
+    try {
+        const handle = await open(filePath, "r");
+        try {
+            const buffer = Buffer.alloc(4096);
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+            const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n")[0];
+            if (!firstLine)
+                return undefined;
+            const header = JSON.parse(firstLine);
+            if (!isRecord(header) || header.type !== "session" || typeof header.id !== "string")
+                return undefined;
+            return typeof header.cwd === "string" ? { id: header.id, cwd: header.cwd } : { id: header.id };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+function getDefaultSessionDir(cwd) {
+    const resolvedCwd = resolve(cwd);
+    const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+    return join(resolve(getAgentDir()), "sessions", safePath);
+}
+async function buildSessionInfo(file) {
+    try {
+        const content = await readFile(file.path, "utf8");
+        const entries = parseJsonLines(content);
+        const header = entries[0];
+        if (!isRecord(header) || header.type !== "session" || typeof header.id !== "string")
+            return undefined;
+        let messageCount = 0;
+        let firstMessage = "";
+        let name;
+        const allMessages = [];
+        let lastActivityTime;
+        for (const entry of entries) {
+            if (!isRecord(entry))
+                continue;
+            if (entry.type === "session_info") {
+                name = typeof entry.name === "string" ? entry.name.trim() || undefined : undefined;
+                continue;
+            }
+            if (entry.type !== "message" || !isRecord(entry.message))
+                continue;
+            messageCount++;
+            const message = entry.message;
+            const role = message.role;
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const textContent = extractTextContent(message.content);
+            if (textContent) {
+                allMessages.push(textContent);
+                if (!firstMessage && role === "user")
+                    firstMessage = textContent;
+            }
+            lastActivityTime = latestTimestamp(lastActivityTime, message.timestamp);
+            lastActivityTime = latestTimestamp(lastActivityTime, entry.timestamp);
+        }
+        const headerTimestamp = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
+        const modified = typeof lastActivityTime === "number"
+            ? new Date(lastActivityTime)
+            : (!Number.isNaN(headerTimestamp) ? new Date(headerTimestamp) : file.mtime);
+        return {
+            path: file.path,
+            id: header.id,
+            cwd: typeof header.cwd === "string" ? header.cwd : "",
+            ...(name === undefined ? {} : { name }),
+            ...(typeof header.parentSession === "string" ? { parentSessionPath: header.parentSession } : {}),
+            created: new Date(typeof header.timestamp === "string" ? header.timestamp : file.mtime),
+            modified,
+            messageCount,
+            firstMessage: firstMessage || "(no messages)",
+            allMessagesText: allMessages.join(" "),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseJsonLines(content) {
+    const entries = [];
+    for (const line of content.trim().split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            entries.push(JSON.parse(line));
+        }
+        catch {
+            // Ignore malformed lines, matching SDK session listing behavior.
+        }
+    }
+    return entries;
+}
+function extractTextContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => isRecord(block) && block.type === "text" && typeof block.text === "string" ? block.text : "")
+        .filter(Boolean)
+        .join(" ");
+}
+function latestTimestamp(current, value) {
+    let timestamp;
+    if (typeof value === "number")
+        timestamp = value;
+    else if (typeof value === "string") {
+        const parsed = new Date(value).getTime();
+        if (!Number.isNaN(parsed))
+            timestamp = parsed;
+    }
+    if (timestamp === undefined)
+        return current;
+    return Math.max(current ?? 0, timestamp);
+}
+function sessionCwdMatches(cwd, resolvedCwd) {
+    return cwd !== undefined && cwd !== "" && resolve(cwd) === resolvedCwd;
+}
+function compareSessionsByModifiedDesc(left, right) {
+    return right.modified.getTime() - left.modified.getTime();
+}
+function positiveInteger(value, fallback) {
+    if (value === undefined || !Number.isFinite(value) || value < 1)
+        return fallback;
+    return Math.floor(value);
+}
+function nextTick() {
+    return new Promise((resolveTick) => {
+        setImmediate(resolveTick);
+    });
+}

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

@@ -1,18 +1,18 @@
 import type { AgentSessionEvent, AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
-import type { ConversationViewport } from "./conversation-viewport.js";
-import type { Entry, SessionActivity } from "./types.js";
-import type { WorkspaceMutation, WorkspaceMutationPreparation } from "./workspace-undo.js";
+import type { ConversationViewport } from "../rendering/conversation-viewport.js";
+import type { Entry, SessionActivity } from "../types.js";
+import type { WorkspaceMutation, WorkspaceMutationPreparation } from "../workspace/workspace-undo.js";
 export type AppSessionEventControllerHost = {
     readonly entries: Entry[];
     runtime(): AgentSessionRuntime | undefined;
     conversationViewport(): ConversationViewport;
     isRunning(): boolean;
     render(): void;
+    scheduleRender(): void;
     setStatus(status: string): void;
     restoreSessionStatus(): void;
     setSessionStatus(session: AgentSessionRuntime["session"] | undefined): void;
     setSessionActivity(activity: SessionActivity): void;
-    flushDeferredUserMessages(): void;
     updateQueuedMessageStatus(): void;
     prepareWorkspaceMutation(toolName: string, args: unknown): WorkspaceMutationPreparation | undefined;
     recordWorkspaceMutationForUserEntry(entryId: string, mutation: WorkspaceMutation): void;
@@ -39,6 +39,7 @@ export declare class AppSessionEventController {
     private currentUserEntryId;
     private currentAssistantEntryId;
     private currentThinkingEntryId;
+    private assistantTextBuffer;
     constructor(host: AppSessionEventControllerHost);
     reset(): void;
     loadSessionHistory(): void;
@@ -62,6 +63,9 @@ export declare class AppSessionEventController {
     private recordToolWorkspaceMutation;
     private handleMessageUpdate;
     private appendAssistantText;
+    private flushAssistantTextBuffer;
+    private drainAssistantTextBuffer;
+    private hasVisibleAssistantText;
     private appendThinkingText;
     private finishCurrentThinkingEntry;
     private upsertToolEntry;

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

@@ -1,7 +1,9 @@
-import { createId } from "./id.js";
-import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "./message-content.js";
+import { createId } from "../id.js";
+import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "../rendering/message-content.js";
 import { customMessageEntry, loadSessionHistoryEntries, loadSessionHistoryEntriesAsync } from "./session-history.js";
-import { isRecord } from "./guards.js";
+import { isRecord } from "../guards.js";
+const DCP_MESSAGE_REFERENCE_PREFIX = "[dcp-id]: # (m";
+const DCP_BLOCK_REFERENCE_PREFIX = "[dcp-block-id]: # (b";
 export class AppSessionEventController {
     host;
     entryRenderVersions = new Map();
@@ -10,6 +12,7 @@ export class AppSessionEventController {
     currentUserEntryId;
     currentAssistantEntryId;
     currentThinkingEntryId;
+    assistantTextBuffer = "";
     constructor(host) {
         this.host = host;
     }
@@ -20,6 +23,7 @@ export class AppSessionEventController {
         this.entryRenderVersions.clear();
         this.currentAssistantEntryId = undefined;
         this.currentThinkingEntryId = undefined;
+        this.assistantTextBuffer = "";
     }
     loadSessionHistory() {
         const runtime = this.host.runtime();
@@ -64,7 +68,6 @@ export class AppSessionEventController {
             case "agent_start":
                 this.host.setSessionActivity("running");
                 this.host.setSessionStatus(this.host.runtime()?.session);
-                this.host.flushDeferredUserMessages();
                 break;
             case "thinking_level_changed":
                 this.host.setSessionStatus(this.host.runtime()?.session);
@@ -75,7 +78,6 @@ export class AppSessionEventController {
                 this.currentUserEntryId = undefined;
                 this.host.setSessionActivity("idle");
                 this.host.setSessionStatus(this.host.runtime()?.session);
-                this.host.flushDeferredUserMessages();
                 break;
             case "queue_update":
                 this.host.updateQueuedMessageStatus();
@@ -85,6 +87,7 @@ export class AppSessionEventController {
                 break;
             case "tool_execution_start":
                 this.finishCurrentThinkingEntry();
+                this.flushAssistantTextBuffer(true);
                 this.currentAssistantEntryId = undefined;
                 this.host.setSessionActivity("running");
                 this.prepareToolWorkspaceMutation(event.toolCallId, event.toolName, event.args);
@@ -134,7 +137,6 @@ export class AppSessionEventController {
                         ? "Compaction cancelled"
                         : event.errorMessage ?? "Compaction failed";
                 this.host.showToast(message, event.result ? "success" : event.aborted ? "info" : "error");
-                this.host.flushDeferredUserMessages();
                 break;
             }
             case "auto_retry_start":
@@ -149,7 +151,7 @@ export class AppSessionEventController {
             default:
                 break;
         }
-        this.host.render();
+        this.host.scheduleRender();
     }
     addCustomMessageEntry(message) {
         const entry = customMessageEntry(message);
@@ -214,6 +216,7 @@ export class AppSessionEventController {
         }
         if (isRecord(message) && message.role === "assistant") {
             this.finishCurrentThinkingEntry();
+            this.flushAssistantTextBuffer(true);
             this.clearCurrentAssistantState();
             this.currentUserEntryId = undefined;
         }
@@ -258,11 +261,13 @@ export class AppSessionEventController {
                 break;
             case "done":
                 this.finishCurrentThinkingEntry();
+                this.flushAssistantTextBuffer(true);
                 this.clearCurrentAssistantState();
                 this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
                 break;
             case "error":
                 this.finishCurrentThinkingEntry();
+                this.flushAssistantTextBuffer(true);
                 this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
                 this.addEntry({ id: createId("error"), kind: "error", text: assistantEvent.error.errorMessage ?? assistantEvent.reason });
                 break;
@@ -271,15 +276,51 @@ export class AppSessionEventController {
         }
     }
     appendAssistantText(delta) {
+        this.assistantTextBuffer += delta;
+        this.flushAssistantTextBuffer(false);
+    }
+    flushAssistantTextBuffer(final) {
+        const visibleText = this.drainAssistantTextBuffer(final);
+        if (!visibleText)
+            return;
         let entry = this.currentAssistantEntryId ? this.findEntry(this.currentAssistantEntryId) : undefined;
         if (!entry || entry.kind !== "assistant") {
             entry = { id: createId("assistant"), kind: "assistant", text: "" };
             this.addEntry(entry);
             this.currentAssistantEntryId = entry.id;
         }
-        entry.text += delta;
+        entry.text += visibleText;
         this.touchEntry(entry);
     }
+    drainAssistantTextBuffer(final) {
+        let visibleText = "";
+        for (;;) {
+            const newlineIndex = this.assistantTextBuffer.indexOf("\n");
+            if (newlineIndex === -1)
+                break;
+            const line = this.assistantTextBuffer.slice(0, newlineIndex);
+            this.assistantTextBuffer = this.assistantTextBuffer.slice(newlineIndex + 1);
+            if (shouldDropAssistantStreamLine(line, this.hasVisibleAssistantText(visibleText)))
+                continue;
+            visibleText += `${line}\n`;
+        }
+        if (!this.assistantTextBuffer)
+            return visibleText;
+        if (shouldHoldAssistantStreamTail(this.assistantTextBuffer)) {
+            if (final)
+                this.assistantTextBuffer = "";
+            return visibleText;
+        }
+        visibleText += this.assistantTextBuffer;
+        this.assistantTextBuffer = "";
+        return visibleText;
+    }
+    hasVisibleAssistantText(pendingVisibleText) {
+        if (pendingVisibleText.length > 0)
+            return true;
+        const entry = this.currentAssistantEntryId ? this.findEntry(this.currentAssistantEntryId) : undefined;
+        return entry?.kind === "assistant" && entry.text.length > 0;
+    }
     appendThinkingText(delta) {
         let entry = this.currentThinkingEntryId ? this.findEntry(this.currentThinkingEntryId) : undefined;
         if (!entry || entry.kind !== "thinking") {
@@ -334,5 +375,31 @@ export class AppSessionEventController {
     clearCurrentAssistantState() {
         this.currentAssistantEntryId = undefined;
         this.currentThinkingEntryId = undefined;
+        this.assistantTextBuffer = "";
     }
 }
+function shouldDropAssistantStreamLine(line, hasVisibleText) {
+    if (line.trim().length === 0 && !hasVisibleText)
+        return true;
+    return isHiddenMarkdownMetadataLine(line);
+}
+function shouldHoldAssistantStreamTail(text) {
+    if (text.trim().length === 0)
+        return true;
+    return isPotentialDcpMetadataLine(text);
+}
+function isHiddenMarkdownMetadataLine(line) {
+    return isMarkdownReferenceDefinition(line) || isPotentialDcpMetadataLine(line);
+}
+function isMarkdownReferenceDefinition(line) {
+    return /^ {0,3}\[[^\]\n]+\]:[ \t]*\S.*$/u.test(line);
+}
+function isPotentialDcpMetadataLine(line) {
+    const content = line.replace(/^ {0,3}/u, "");
+    if (content.length === 0)
+        return false;
+    return isPotentialDcpReference(content, DCP_MESSAGE_REFERENCE_PREFIX) || isPotentialDcpReference(content, DCP_BLOCK_REFERENCE_PREFIX);
+}
+function isPotentialDcpReference(content, markerPrefix) {
+    return markerPrefix.startsWith(content) || (content.startsWith(markerPrefix) && /^\d*\)?$/u.test(content.slice(markerPrefix.length)));
+}

package/dist/app/{session-history.d.ts → session/session-history.d.ts}

@@ -1,4 +1,4 @@
-import type { Entry } from "./types.js";
+import type { Entry } from "../types.js";
 type SubagentsToolResultObserveOptions = {
     showSnapshot?: boolean;
 };

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

@@ -1,6 +1,7 @@
-import { isRecord } from "./guards.js";
-import { createId } from "./id.js";
-import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "./message-content.js";
+import { isRecord } from "../guards.js";
+import { createId } from "../id.js";
+import { isOnlyHiddenMetadata } from "../../markdown-format.js";
+import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "../rendering/message-content.js";
 const SYSTEM_CUSTOM_MESSAGE_TYPE = "pix-system";
 const HISTORICAL_SUBAGENTS_OBSERVATION = { showSnapshot: false };
 const DEFAULT_HISTORY_CHUNK_SIZE = 50;
@@ -119,10 +120,10 @@ function renderAssistantHistoryMessage(message, toolResults, options) {
                 options.addEntry({ id: createId("thinking"), kind: "thinking", text: thinkingText, expanded: false, status: "done" });
                 thinkingText = "";
             }
-            if (assistantText) {
+            if (assistantText && !isOnlyHiddenMetadata(assistantText)) {
                 options.addEntry({ id: createId("assistant"), kind: "assistant", text: assistantText });
-                assistantText = "";
             }
+            assistantText = "";
             const toolCallId = String(block.id ?? createId("tool"));
             const result = toolResults.get(toolCallId);
             const toolName = result?.toolName ?? String(block.name ?? "unknown");
@@ -158,7 +159,7 @@ function renderAssistantHistoryMessage(message, toolResults, options) {
     if (thinkingText) {
         options.addEntry({ id: createId("thinking"), kind: "thinking", text: thinkingText, expanded: false, status: "done" });
     }
-    if (assistantText) {
+    if (assistantText && !isOnlyHiddenMetadata(assistantText)) {
         options.addEntry({ id: createId("assistant"), kind: "assistant", text: assistantText });
     }
 }

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

@@ -1,6 +1,6 @@
 import type { AgentSession, AgentSessionEvent, AgentSessionRuntime, ExtensionCommandContextActions, ExtensionError } from "@earendil-works/pi-coding-agent";
-import type { InputEditor } from "../input-editor.js";
-import type { AppOptions, Entry, PixExtensionUIContext, SessionActivity } from "./types.js";
+import type { InputEditor } from "../../input-editor.js";
+import type { AppOptions, Entry, PixExtensionUIContext, SessionActivity } from "../types.js";
 export type AppSessionLifecycleHost = {
     options: AppOptions;
     createRuntime(): Promise<AgentSessionRuntime>;
@@ -37,6 +37,10 @@ export type AppSessionLifecycleHost = {
     clearMouseRenderState(): void;
     scrollReset(): void;
     loadSessionHistoryEntries(): void;
+    loadSessionHistoryEntriesAsync(options: {
+        isCancelled: () => boolean;
+        render: () => void;
+    }): Promise<boolean>;
     syncUserSessionEntryMetadata(): void;
     restoreTabsAfterStartup(): Promise<void>;
     render(): void;
@@ -49,6 +53,7 @@ export declare class AppSessionLifecycleController {
     bindCurrentSession(): Promise<void>;
     unsubscribeSession(): void;
     afterSessionReplacement(message?: string): void;
+    private loadReplacementHistory;
     resetSessionView(): void;
     loadSessionHistory(): void;
     requireRuntime(): AgentSessionRuntime;

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

@@ -1,7 +1,7 @@
-import { createId } from "./id.js";
-import { stringifyUnknown } from "./message-content.js";
-import { collectStartupAvailabilityIssues } from "./startup-checks.js";
-import { createStartupInfoMessage, isEmptyStartupSession } from "./startup-info.js";
+import { createId } from "../id.js";
+import { stringifyUnknown } from "../rendering/message-content.js";
+import { collectStartupAvailabilityIssues } from "../cli/startup-checks.js";
+import { createStartupInfoMessage, isEmptyStartupSession } from "../cli/startup-info.js";
 export class AppSessionLifecycleController {
     host;
     unsubscribe;
@@ -84,7 +84,15 @@ export class AppSessionLifecycleController {
     }
     afterSessionReplacement(message) {
         this.resetSessionView();
-        this.loadSessionHistory();
+        void this.loadReplacementHistory(message);
+        this.host.render();
+    }
+    async loadReplacementHistory(message) {
+        await this.host.loadSessionHistoryEntriesAsync({
+            isCancelled: () => !this.host.isRunning(),
+            render: () => this.host.render(),
+        });
+        this.host.syncUserSessionEntryMetadata();
         if (message)
             this.host.addEntry({ id: createId("system"), kind: "system", text: message });
         const session = this.host.runtime()?.session;

package/dist/app/{session-search.d.ts → session/session-search.d.ts}

@@ -1,5 +1,5 @@
 import { type SessionInfo } from "@earendil-works/pi-coding-agent";
-import type { Entry, PixMenuItem } from "./types.js";
+import type { Entry, PixMenuItem } from "../types.js";
 export type SessionSearchMatch = {
     sessionEntryId?: string;
     role?: string;

package/dist/app/{session-search.js → session/session-search.js}

@@ -1,7 +1,7 @@
 import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { isRecord } from "./guards.js";
-import { renderContent, renderUserMessageContent } from "./message-content.js";
-import { sanitizeText } from "./render-text.js";
+import { isRecord } from "../guards.js";
+import { renderContent, renderUserMessageContent } from "../rendering/message-content.js";
+import { sanitizeText } from "../rendering/render-text.js";
 const DEFAULT_MAX_SEARCH_RESULTS = 50;
 const DEFAULT_SNIPPET_LENGTH = 160;
 const DEFAULT_SCROLL_SAMPLE_LENGTH = 80;

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

@@ -1,6 +1,6 @@
 import { type AgentSession, type AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
-import type { AppBlinkController } from "./blink-controller.js";
-import type { AppOptions, Entry, SessionActivity, SessionTab } from "./types.js";
+import type { AppBlinkController } from "../screen/blink-controller.js";
+import type { AppOptions, Entry, SessionActivity, SessionTab, SubmittedUserMessage } from "../types.js";
 export type TabInputState = {
     text: string;
     cursor: number;
@@ -26,6 +26,8 @@ export type AppTabsControllerHost = {
     syncUserSessionEntryMetadata(): void;
     captureInputState(): TabInputState;
     restoreInputState(state: TabInputState): void;
+    captureDeferredUserMessages?(): readonly SubmittedUserMessage[];
+    restoreDeferredUserMessages?(messages: readonly SubmittedUserMessage[]): void;
     addEntry(entry: Entry): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
@@ -36,6 +38,7 @@ export declare class AppTabsController {
     private readonly runtimesByTabId;
     private readonly runtimeSubscriptionsByTabId;
     private readonly inputStatesByTabId;
+    private readonly deferredUserMessagesByTabId;
     private activeTabId;
     private pendingActiveTabId;
     private historyLoadGeneration;
@@ -50,6 +53,7 @@ export declare class AppTabsController {
     setInputStateForTab(tabId: string | undefined, state: TabInputState): Promise<void>;
     disposeInactiveRuntimes(disposeRuntime?: (runtime: AgentSessionRuntime) => Promise<void>): Promise<void>;
     saveInputStateForQuit(): Promise<void>;
+    persistActiveDeferredUserMessages(): void;
     syncActiveTabFromRuntime(options?: {
         save?: boolean;
         force?: boolean;
@@ -74,13 +78,17 @@ export declare class AppTabsController {
     private shouldSyncTabFromRuntimeEvent;
     private syncTabFromObservedRuntime;
     private storeActiveInputState;
+    private storeActiveDeferredUserMessages;
     private restoreInputState;
+    private restoreDeferredUserMessages;
+    private cloneSubmittedUserMessage;
     private runtimeForTab;
     private findTabForSession;
     private findTabBySessionPath;
     private replaceTabs;
     private removeTab;
     private restorePersistedInputStates;
+    private restorePersistedDeferredUserMessages;
     private ensureCurrentSessionTab;
     private tabFromSession;
     private updateTabFromSession;
@@ -95,6 +103,7 @@ export declare class AppTabsController {
     private restoredTabs;
     private loadTabs;
     private parsePersistedInputState;
+    private parsePersistedSubmittedUserMessages;
     private saveTabs;
     private filePath;
 }