pi-ui-extend 0.1.18 → 0.1.20

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

@@ -320,7 +320,7 @@ export class AppMouseController {
             return false;
         const opened = this.host.openFileLink?.(link) ?? openDetectedFileLink(link);
         if (!opened)
-            this.host.showToast("Could not open file link. Install the Zed CLI or set ZED_CLI.", "warning");
+            this.host.showToast("Could not open file link in the detected editor or system viewer.", "warning");
         return true;
     }
     handleInputScrollBar(event) {
@@ -784,14 +784,15 @@ export class AppMouseController {
         const topOffset = editorLayoutTopOffset(tabPanelRows);
         const toScreenRow = (layoutRow) => Math.max(1, Math.min(terminalRows, topOffset + layoutRow));
         const toScreenRowExclusive = (layoutRow) => Math.max(1, Math.min(terminalRows + 1, topOffset + layoutRow));
-        return {
+        const inputFrame = {
             inputStartRow: toScreenRow(layout.inputStartRow),
             inputEndRow: toScreenRowExclusive(layout.inputStartRow + layout.renderedInput.lines.length),
             inputSeparatorRow: toScreenRow(layout.inputSeparatorRow),
-            inputBottomSeparatorRow: toScreenRow(layout.inputBottomSeparatorRow),
-            contentStartColumn: 2,
-            contentEndColumn: columns,
         };
+        if (layout.inputBottomSeparatorRow !== undefined) {
+            inputFrame.inputBottomSeparatorRow = toScreenRow(layout.inputBottomSeparatorRow);
+        }
+        return inputFrame;
     }
     getSelectedConversationText(anchor, current) {
         const range = orderedConversationSelection(anchor, current);
@@ -800,11 +801,13 @@ export class AppMouseController {
         const renderedLines = this.host.conversationViewport().slice(width, range.start.line, count);
         const lines = [];
         for (let index = 0; index < count; index += 1) {
-            const text = renderedLines[index]?.text ?? "";
+            const rendered = renderedLines[index];
+            const text = rendered?.text ?? "";
             const line = range.start.line + index;
             const startColumn = line === range.start.line ? range.start.x : 1;
             const endColumn = line === range.end.line ? range.end.x : text.length + 1;
-            lines.push(sliceByDisplayColumns(text, startColumn, endColumn).trimEnd());
+            const lineText = sliceByDisplayColumns(text, startColumn, endColumn);
+            lines.push(lineText.trimEnd());
         }
         return lines.join("\n").replace(/\s+$/u, "");
     }
@@ -935,16 +938,13 @@ function orderedConversationSelection(anchor, current) {
     return anchor.x <= current.x ? { start: anchor, end: current } : { start: current, end: anchor };
 }
 export function screenSelectionLineText(row, text, startColumn, endColumn, inputFrame) {
-    if (inputFrame && (row === inputFrame.inputSeparatorRow || row === inputFrame.inputBottomSeparatorRow)) {
+    if (inputFrame && row === inputFrame.inputSeparatorRow) {
         return undefined;
     }
-    let copyStartColumn = startColumn;
-    let copyEndColumn = endColumn;
-    if (inputFrame && row >= inputFrame.inputStartRow && row < inputFrame.inputEndRow) {
-        copyStartColumn = Math.max(copyStartColumn, inputFrame.contentStartColumn);
-        copyEndColumn = Math.min(copyEndColumn, inputFrame.contentEndColumn);
+    if (inputFrame?.inputBottomSeparatorRow !== undefined && row === inputFrame.inputBottomSeparatorRow) {
+        return undefined;
     }
-    return sliceByDisplayColumns(text, copyStartColumn, copyEndColumn);
+    return sliceByDisplayColumns(text, startColumn, endColumn);
 }
 function sameConversationPoint(left, right) {
     return !!left && left.line === right.line && left.x === right.x;

package/dist/app/screen/screen-styler.js

@@ -75,7 +75,7 @@ export class ScreenStyler {
     }
     styleInputLine(row, text, tagSpans, suggestionSpans, width, tagColor, suggestionColor, frameColor) {
         const colors = this.host.theme.colors;
-        const baseOptions = { foreground: colors.inputForeground };
+        const baseOptions = { foreground: colors.userForeground };
         if (this.selectionRangeForRow(row, width, text))
             return this.styleLine(row, text, width, baseOptions);
         const plain = padOrTrimPlain(text, width);

package/dist/app/session/lazy-session-manager.d.ts

@@ -8,4 +8,4 @@ export type LazySessionHistoryReader = {
     hasOlder(): boolean;
     readOlder(limit: number): Promise<SessionEntry[]>;
 };
-export declare function openLazySessionManager(sessionPath: string, options?: LazySessionManagerOptions): SessionManager;
+export declare function openLazySessionManager(sessionPath: string, options?: LazySessionManagerOptions): Promise<SessionManager>;

package/dist/app/session/lazy-session-manager.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
-import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readSync, statSync, writeFileSync } from "node:fs";
-import { open as openFile } from "node:fs/promises";
+import { appendFileSync, createReadStream, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { mkdir, open as openFile, stat, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { buildSessionContext, SessionManager, } from "@earendil-works/pi-coding-agent";
@@ -9,8 +9,8 @@ const CURRENT_SESSION_VERSION = 3;
 const DEFAULT_TAIL_ENTRY_COUNT = 180;
 const INITIAL_TAIL_BYTES = 256 * 1024;
 const MAX_TAIL_BYTES = 16 * 1024 * 1024;
-export function openLazySessionManager(sessionPath, options = {}) {
-    return new LazySessionManager(sessionPath, options);
+export async function openLazySessionManager(sessionPath, options = {}) {
+    return await LazySessionManager.open(sessionPath, options);
 }
 class LazySessionManager {
     sessionFilePath;
@@ -29,9 +29,18 @@ class LazySessionManager {
         this.sessionFilePath = resolve(sessionPath);
         this.sessionDirPath = resolve(options.sessionDir ?? dirname(this.sessionFilePath));
         this.tailEntryCount = Math.max(1, Math.floor(options.tailEntryCount ?? DEFAULT_TAIL_ENTRY_COUNT));
-        this.header = this.loadHeader(options.cwdOverride);
-        this.cwdPath = resolve(options.cwdOverride ?? this.header.cwd ?? process.cwd());
-        this.loadTailEntries();
+        this.cwdPath = resolve(options.cwdOverride ?? process.cwd());
+        this.header = createSessionHeader(this.cwdPath);
+    }
+    static async open(sessionPath, options = {}) {
+        const manager = new LazySessionManager(sessionPath, options);
+        await manager.initialize(options.cwdOverride);
+        return manager;
+    }
+    async initialize(cwdOverride) {
+        this.header = await this.loadHeaderAsync(cwdOverride);
+        this.cwdPath = resolve(cwdOverride ?? this.header.cwd ?? process.cwd());
+        await this.loadTailEntriesAsync();
     }
     setSessionFile(sessionFile) {
         if (this.hydrated) {
@@ -40,9 +49,7 @@ class LazySessionManager {
         }
         this.sessionFilePath = resolve(sessionFile);
         this.sessionDirPath = dirname(this.sessionFilePath);
-        this.header = this.loadHeader(this.cwdPath);
-        this.cwdPath = resolve(this.header.cwd || this.cwdPath);
-        this.loadTailEntries();
+        throw new Error("LazySessionManager.setSessionFile() before hydration is unsupported");
     }
     newSession(options) {
         if (this.hydrated)
@@ -106,16 +113,25 @@ class LazySessionManager {
         if (this.hydrated || this.tailStartOffset <= 0)
             return undefined;
         let cursorOffset = this.tailStartOffset;
-        const firstEntryOffset = readFirstSessionEntryOffset(this.sessionFilePath);
+        let firstEntryOffset = 0;
+        let firstEntryOffsetPromise;
+        const loadFirstEntryOffset = async () => {
+            firstEntryOffsetPromise ??= readFirstSessionEntryOffset(this.sessionFilePath).then((offset) => {
+                firstEntryOffset = offset;
+                return offset;
+            });
+            return await firstEntryOffsetPromise;
+        };
         return {
             hasOlder: () => cursorOffset > firstEntryOffset,
             readOlder: async (limit) => {
-                if (cursorOffset <= firstEntryOffset)
+                const resolvedFirstEntryOffset = await loadFirstEntryOffset();
+                if (cursorOffset <= resolvedFirstEntryOffset)
                     return [];
                 const result = await readSessionEntriesBeforeOffset(this.sessionFilePath, cursorOffset, Math.max(1, Math.floor(limit)));
                 cursorOffset = result.startOffset;
                 if (result.entries.length === 0)
-                    cursorOffset = firstEntryOffset;
+                    cursorOffset = resolvedFirstEntryOffset;
                 return result.entries;
             },
         };
@@ -256,18 +272,17 @@ class LazySessionManager {
         }
         return this.hydrated;
     }
-    loadHeader(cwdOverride) {
-        if (!existsSync(this.sessionFilePath)) {
-            mkdirSync(dirname(this.sessionFilePath), { recursive: true });
-            const header = createSessionHeader(resolve(cwdOverride ?? process.cwd()));
-            writeFileSync(this.sessionFilePath, `${JSON.stringify(header)}\n`, "utf8");
-            return header;
-        }
-        const header = readSessionHeaderFast(this.sessionFilePath);
-        return header ?? createSessionHeader(resolve(cwdOverride ?? process.cwd()));
-    }
-    loadTailEntries() {
-        const result = readTailSessionEntries(this.sessionFilePath, this.tailEntryCount);
+    async loadHeaderAsync(cwdOverride) {
+        const existingHeader = await readSessionHeaderFast(this.sessionFilePath);
+        if (existingHeader)
+            return existingHeader;
+        await mkdir(dirname(this.sessionFilePath), { recursive: true });
+        const header = createSessionHeader(resolve(cwdOverride ?? process.cwd()));
+        await writeFile(this.sessionFilePath, `${JSON.stringify(header)}\n`, "utf8");
+        return header;
+    }
+    async loadTailEntriesAsync() {
+        const result = await readTailSessionEntries(this.sessionFilePath, this.tailEntryCount);
         this.entries = result.entries;
         this.tailStartOffset = result.startOffset;
         this.rebuildIndexes();
@@ -338,8 +353,8 @@ function createSessionHeader(cwd) {
 function createSessionId() {
     return randomUUID();
 }
-function readSessionHeaderFast(filePath) {
-    const line = readFirstLine(filePath, 64 * 1024);
+async function readSessionHeaderFast(filePath) {
+    const line = await readFirstLine(filePath, 64 * 1024);
     if (!line)
         return undefined;
     try {
@@ -353,12 +368,12 @@ function readSessionHeaderFast(filePath) {
         return undefined;
     }
 }
-function readFirstLine(filePath, maxBytes) {
-    let fd;
+async function readFirstLine(filePath, maxBytes) {
+    let file;
     try {
-        fd = openSync(filePath, "r");
+        file = await openFile(filePath, "r");
         const buffer = Buffer.alloc(maxBytes);
-        const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
         const text = buffer.toString("utf8", 0, bytesRead);
         return text.split("\n")[0];
     }
@@ -366,16 +381,15 @@ function readFirstLine(filePath, maxBytes) {
         return undefined;
     }
     finally {
-        if (fd !== undefined)
-            closeSync(fd);
+        await file?.close();
     }
 }
-function readFirstSessionEntryOffset(filePath) {
-    let fd;
+async function readFirstSessionEntryOffset(filePath) {
+    let file;
     try {
-        fd = openSync(filePath, "r");
+        file = await openFile(filePath, "r");
         const buffer = Buffer.alloc(64 * 1024);
-        const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
         const entries = parseSessionEntryBufferLines(buffer.subarray(0, bytesRead), 0);
         return entries[0]?.offset ?? 0;
     }
@@ -383,34 +397,30 @@ function readFirstSessionEntryOffset(filePath) {
         return 0;
     }
     finally {
-        if (fd !== undefined)
-            closeSync(fd);
+        await file?.close();
     }
 }
-function readTailSessionEntries(filePath, limit) {
-    if (!existsSync(filePath))
-        return { entries: [], startOffset: 0 };
-    const size = statSync(filePath).size;
+async function readTailSessionEntries(filePath, limit) {
+    const size = await stat(filePath).then((result) => result.size).catch(() => 0);
     if (size <= 0)
         return { entries: [], startOffset: 0 };
     let byteCount = Math.min(size, INITIAL_TAIL_BYTES);
     const maxBytes = Math.min(size, MAX_TAIL_BYTES);
     while (byteCount <= maxBytes) {
-        const result = readTailSessionEntriesWithByteCount(filePath, byteCount, limit);
+        const result = await readTailSessionEntriesWithByteCount(filePath, byteCount, limit, size);
         if (result.entries.length >= limit || byteCount >= maxBytes || byteCount >= size)
             return result;
         byteCount = Math.min(size, Math.max(byteCount + 1, byteCount * 2));
     }
     return { entries: [], startOffset: 0 };
 }
-function readTailSessionEntriesWithByteCount(filePath, byteCount, limit) {
-    let fd;
+async function readTailSessionEntriesWithByteCount(filePath, byteCount, limit, size) {
+    let file;
     try {
-        const size = statSync(filePath).size;
         const start = Math.max(0, size - byteCount);
         const buffer = Buffer.alloc(size - start);
-        fd = openSync(filePath, "r");
-        readSync(fd, buffer, 0, buffer.length, start);
+        file = await openFile(filePath, "r");
+        await file.read(buffer, 0, buffer.length, start);
         let parseStart = 0;
         if (start > 0) {
             const firstNewline = buffer.indexOf(10);
@@ -422,12 +432,14 @@ function readTailSessionEntriesWithByteCount(filePath, byteCount, limit) {
         return { entries: [], startOffset: 0 };
     }
     finally {
-        if (fd !== undefined)
-            closeSync(fd);
+        await file?.close();
     }
 }
 async function readSessionEntriesBeforeOffset(filePath, endOffset, limit) {
-    if (!existsSync(filePath) || endOffset <= 0)
+    if (endOffset <= 0)
+        return { entries: [], startOffset: 0 };
+    const exists = await stat(filePath).then(() => true).catch(() => false);
+    if (!exists)
         return { entries: [], startOffset: 0 };
     let byteCount = Math.min(endOffset, INITIAL_TAIL_BYTES);
     const maxBytes = Math.min(endOffset, MAX_TAIL_BYTES);

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

@@ -51,6 +51,12 @@ export declare class AppQueuedMessageController {
     findQueuedEntry(entryId: string): Extract<Entry, {
         kind: "queued";
     }> | undefined;
+    queuedEntries(): Extract<Entry, {
+        kind: "queued";
+    }>[];
+    deferredQueuedEntries(): Extract<Entry, {
+        kind: "queued";
+    }>[];
     private shouldDeferUserMessage;
     deferUserMessage(message: SubmittedUserMessage): void;
     private rewriteSdkQueuedMessages;

package/dist/app/session/queued-message-controller.js

@@ -1,5 +1,6 @@
 import { createId } from "../id.js";
 import { stringifyUnknown, submittedUserDisplayText } from "../rendering/message-content.js";
+import { deferredQueuedMessageEntries, queuedMessageEntries } from "./queued-message-entries.js";
 export class AppQueuedMessageController {
     host;
     deferredUserMessages = [];
@@ -228,9 +229,16 @@ export class AppQueuedMessageController {
         }
     }
     findQueuedEntry(entryId) {
-        const entry = this.host.visibleEntries().find((candidate) => candidate.id === entryId);
+        const entry = this.queuedEntries().find((candidate) => candidate.id === entryId)
+            ?? this.host.visibleEntries().find((candidate) => candidate.id === entryId);
         return entry?.kind === "queued" ? entry : undefined;
     }
+    queuedEntries() {
+        return queuedMessageEntries(this.host.runtime()?.session, this.deferredUserMessages);
+    }
+    deferredQueuedEntries() {
+        return deferredQueuedMessageEntries(this.deferredUserMessages);
+    }
     shouldDeferUserMessage(session) {
         return session.isCompacting || this.promptSubmissionInFlight;
     }

package/dist/app/session/queued-message-entries.d.ts

@@ -0,0 +1,8 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { Entry, SubmittedUserMessage } from "../types.js";
+export type QueuedEntry = Extract<Entry, {
+    kind: "queued";
+}>;
+export declare function sdkQueuedMessageEntries(session: AgentSession | undefined): QueuedEntry[];
+export declare function deferredQueuedMessageEntries(messages: readonly SubmittedUserMessage[]): QueuedEntry[];
+export declare function queuedMessageEntries(session: AgentSession | undefined, deferredUserMessages: readonly SubmittedUserMessage[]): QueuedEntry[];

package/dist/app/session/queued-message-entries.js

@@ -0,0 +1,41 @@
+import { shortHash } from "../rendering/render-text.js";
+export function sdkQueuedMessageEntries(session) {
+    const entries = [];
+    for (const [index, text] of (session?.getSteeringMessages() ?? []).entries()) {
+        entries.push({
+            id: `queued-sdk-steering-${index}-${shortHash(text)}`,
+            kind: "queued",
+            mode: "steering",
+            text,
+            queueSource: "sdk-steering",
+            queueIndex: index,
+        });
+    }
+    for (const [index, text] of (session?.getFollowUpMessages() ?? []).entries()) {
+        entries.push({
+            id: `queued-sdk-follow-up-${index}-${shortHash(text)}`,
+            kind: "queued",
+            mode: "follow-up",
+            text,
+            queueSource: "sdk-follow-up",
+            queueIndex: index,
+        });
+    }
+    return entries;
+}
+export function deferredQueuedMessageEntries(messages) {
+    return messages.map((message, index) => ({
+        id: `${message.id}-${index}`,
+        kind: "queued",
+        mode: "steering",
+        text: message.displayText,
+        queueSource: "deferred",
+        queueIndex: index,
+    }));
+}
+export function queuedMessageEntries(session, deferredUserMessages) {
+    return [
+        ...sdkQueuedMessageEntries(session),
+        ...deferredQueuedMessageEntries(deferredUserMessages),
+    ];
+}

package/dist/app/session/session-lifecycle-controller.d.ts

@@ -48,17 +48,25 @@ export type AppSessionLifecycleHost = {
     restoreTabsAfterStartup(): Promise<void>;
     render(): void;
 };
+export type BindCurrentSessionOptions = {
+    awaitExtensions?: boolean;
+};
 export declare class AppSessionLifecycleController {
     private readonly host;
     private unsubscribe;
+    private extensionBindPromise;
+    private extensionBindRuntime;
+    private extensionBindSession;
     constructor(host: AppSessionLifecycleHost);
     start(): Promise<void>;
-    bindCurrentSession(): Promise<void>;
+    bindCurrentSession(options?: BindCurrentSessionOptions): Promise<void>;
     unsubscribeSession(): void;
     afterSessionReplacement(message?: string): void;
     private loadReplacementHistory;
     resetSessionView(): void;
     loadSessionHistory(): void;
     requireRuntime(): AgentSessionRuntime;
+    private bindSessionExtensions;
+    private isCurrentRuntimeSession;
     private extensionUiScope;
 }

package/dist/app/session/session-lifecycle-controller.js

@@ -5,6 +5,9 @@ import { createStartupInfoMessage, isEmptyStartupSession } from "../cli/startup-
 export class AppSessionLifecycleController {
     host;
     unsubscribe;
+    extensionBindPromise;
+    extensionBindRuntime;
+    extensionBindSession;
     constructor(host) {
         this.host = host;
     }
@@ -25,9 +28,9 @@ export class AppSessionLifecycleController {
             }
             this.host.setRuntime(runtime);
             runtime.setRebindSession(async () => {
-                await this.bindCurrentSession();
+                await this.bindCurrentSession({ awaitExtensions: false });
             });
-            await this.bindCurrentSession();
+            await this.bindCurrentSession({ awaitExtensions: false });
             if (isEmptyStartupSession(runtime)) {
                 this.host.addEntry({ id: createId("system"), kind: "system", text: createStartupInfoMessage(runtime) });
             }
@@ -64,21 +67,28 @@ export class AppSessionLifecycleController {
             this.host.render();
         }
     }
-    async bindCurrentSession() {
+    async bindCurrentSession(options = {}) {
         const runtime = this.requireRuntime();
+        const session = runtime.session;
         this.unsubscribe?.();
-        this.unsubscribe = runtime.session.subscribe((event) => {
+        this.unsubscribe = session.subscribe((event) => {
             this.host.handleSessionEvent(event);
         });
         this.host.closeSdkMenuForBind();
-        const extensionUiScope = this.extensionUiScope(runtime.session);
+        const extensionUiScope = this.extensionUiScope(session);
         this.host.clearExtensionWidgets(extensionUiScope, { cancelCustomUi: false });
-        await runtime.session.bindExtensions({
-            uiContext: this.host.createExtensionUIContext(extensionUiScope),
-            commandContextActions: this.host.createExtensionCommandContextActions(runtime),
-            shutdownHandler: this.host.extensionShutdownHandler(),
-            onError: (error) => this.host.handleExtensionError(error),
-        });
+        const bindPromise = this.bindSessionExtensions(runtime, session, extensionUiScope);
+        if (options.awaitExtensions === false) {
+            void bindPromise.catch((error) => {
+                if (!this.isCurrentRuntimeSession(runtime, session))
+                    return;
+                this.host.addEntry({ id: createId("error"), kind: "error", text: `Extension bind failed: ${stringifyUnknown(error)}` });
+                this.host.showToast("Extension initialization failed", "error");
+                this.host.render();
+            });
+            return;
+        }
+        await bindPromise;
     }
     unsubscribeSession() {
         this.unsubscribe?.();
@@ -123,6 +133,30 @@ export class AppSessionLifecycleController {
             throw new Error("Runtime is not initialized");
         return runtime;
     }
+    bindSessionExtensions(runtime, session, scopeKey) {
+        if (this.extensionBindPromise && this.extensionBindRuntime === runtime && this.extensionBindSession === session) {
+            return this.extensionBindPromise;
+        }
+        const promise = session.bindExtensions({
+            uiContext: this.host.createExtensionUIContext(scopeKey),
+            commandContextActions: this.host.createExtensionCommandContextActions(runtime),
+            shutdownHandler: this.host.extensionShutdownHandler(),
+            onError: (error) => this.host.handleExtensionError(error),
+        }).finally(() => {
+            if (this.extensionBindPromise !== promise)
+                return;
+            this.extensionBindPromise = undefined;
+            this.extensionBindRuntime = undefined;
+            this.extensionBindSession = undefined;
+        });
+        this.extensionBindPromise = promise;
+        this.extensionBindRuntime = runtime;
+        this.extensionBindSession = session;
+        return promise;
+    }
+    isCurrentRuntimeSession(runtime, session) {
+        return this.host.isRunning() && this.host.runtime() === runtime && runtime.session === session;
+    }
     extensionUiScope(session) {
         return session.sessionFile ?? session.sessionId;
     }

package/dist/app/session/tabs-controller.d.ts

@@ -1,4 +1,5 @@
 import { type AgentSession, type AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { BindCurrentSessionOptions } from "./session-lifecycle-controller.js";
 import type { InputEditorDraftState } from "../../input-editor.js";
 import type { AppBlinkController } from "../screen/blink-controller.js";
 import type { AppOptions, Entry, SessionActivity, SessionTab, SubmittedUserMessage } from "../types.js";
@@ -10,7 +11,7 @@ export type AppTabsControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     createRuntimeForNewSession(): Promise<AgentSessionRuntime>;
     createRuntimeForSession(sessionPath: string): Promise<AgentSessionRuntime>;
-    activateRuntime(runtime: AgentSessionRuntime): Promise<void>;
+    activateRuntime(runtime: AgentSessionRuntime, options?: BindCurrentSessionOptions): Promise<void>;
     disposeRuntime(runtime: AgentSessionRuntime): Promise<void>;
     isRunning(): boolean;
     setStatus(status: string): void;
@@ -37,7 +38,9 @@ export declare class AppTabsController {
     private readonly host;
     private readonly tabItems;
     private readonly runtimesByTabId;
+    private readonly runtimeLoadsByTabId;
     private readonly runtimeSubscriptionsByTabId;
+    private readonly runtimeRefreshTimersByTabId;
     private readonly inputStatesByTabId;
     private readonly deferredUserMessagesByTabId;
     private activeTabId;
@@ -46,6 +49,8 @@ export declare class AppTabsController {
     private restored;
     private retentionCleanupRunning;
     private retentionCleanupScheduled;
+    private prewarmScheduled;
+    private prewarmRunning;
     constructor(host: AppTabsControllerHost);
     tabs(): readonly SessionTab[];
     isSwitching(): boolean;
@@ -81,6 +86,9 @@ export declare class AppTabsController {
     private clearRuntimeSubscriptions;
     private observeRuntimeForTab;
     private shouldSyncTabFromRuntimeEvent;
+    private shouldScheduleDelayedSyncForRuntimeEvent;
+    private scheduleDelayedRuntimeSync;
+    private clearRuntimeRefreshTimers;
     private syncTabFromObservedRuntime;
     private storeActiveInputState;
     private storeActiveDeferredUserMessages;
@@ -115,6 +123,8 @@ export declare class AppTabsController {
     private filePath;
     private sessionDir;
     private scheduleProjectSessionRetention;
+    private scheduleTabPrewarm;
+    private prewarmTabs;
     private cleanupOldProjectSessions;
     private preservedSessionPaths;
     private maxProjectSessions;