pi-ui-extend 0.1.28 → 0.1.31

package/dist/app/app.d.ts

@@ -81,6 +81,8 @@ export declare class PiUiExtendApp {
     private setVoicePartialTranscript;
     private addVoiceSystemMessage;
     private resetSessionView;
+    private captureSessionView;
+    private restoreSessionView;
     private loadSessionHistory;
     private openSearchResultInNewTab;
     private scrollToUserMessageJumpTarget;

package/dist/app/app.js

@@ -41,7 +41,7 @@ import { TabLineRenderer } from "./rendering/tab-line-renderer.js";
 import { AppTerminalController } from "./terminal/terminal-controller.js";
 import { TerminalBellSoundController } from "./terminal/terminal-bell-sound-controller.js";
 import { AppToastController } from "./rendering/toast-controller.js";
-import { checkPixUpdate, formatPixStartupUpdateDialog } from "./cli/update.js";
+import { checkPiUpdate, checkPixUpdate, formatPixStartupUpdateDialog, formatPiStartupUpdateToast } from "./cli/update.js";
 import { AppVoiceController } from "./input/voice-controller.js";
 import { createIsolatedExtensionEventBus } from "./extensions/extension-event-bus.js";
 import { setAppIconTheme } from "./icons.js";
@@ -181,6 +181,8 @@ export class PiUiExtendApp {
             resetSessionView: () => this.resetSessionView(),
             loadSessionHistory: () => this.loadSessionHistory(),
             loadSessionHistoryAsync: (options) => this.loadSessionHistoryAsync(options),
+            captureSessionView: () => this.captureSessionView(),
+            restoreSessionView: (view) => this.restoreSessionView(view),
             syncUserSessionEntryMetadata: () => this.workspaceActions.syncUserSessionEntryMetadata(),
             captureInputState: () => this.inputEditor.draftState,
             restoreInputState: (state) => this.restoreTabInputState(state),
@@ -785,18 +787,27 @@ export class PiUiExtendApp {
         await this.sessionLifecycle.start();
         this.modelUsageController.startPolling();
         this.nerdFontController.ensureInstalledOnStartup();
-        void this.checkPixUpdateOnStartup();
+        this.checkPixUpdateOnStartup();
     }
-    async checkPixUpdateOnStartup() {
-        try {
-            const result = await checkPixUpdate();
+    checkPixUpdateOnStartup() {
+        void checkPiUpdate()
+            .then((result) => {
+            if (result.status !== "newer")
+                return;
+            this.showToast(formatPiStartupUpdateToast(result), "warning");
+        })
+            .catch(() => {
+            // Startup update checks should never interrupt the TUI.
+        });
+        void checkPixUpdate()
+            .then((result) => {
             if (result.status !== "newer")
                 return;
             this.showToast(formatPixStartupUpdateDialog(result), "warning", { variant: "dialog" });
-        }
-        catch {
+        })
+            .catch(() => {
             // Startup update checks should never interrupt the TUI.
-        }
+        });
     }
     async bindCurrentSession(options) {
         await this.sessionLifecycle.bindCurrentSession(options);
@@ -889,6 +900,18 @@ export class PiUiExtendApp {
     resetSessionView() {
         this.sessionLifecycle.resetSessionView();
     }
+    captureSessionView() {
+        return {
+            entries: [...this.entries],
+            eventState: this.sessionEvents.snapshotState(),
+        };
+    }
+    restoreSessionView(view) {
+        this.entries.splice(0, this.entries.length, ...view.entries);
+        this.sessionEvents.restoreState(view.eventState);
+        this.conversationViewport.clear();
+        this.workspaceActions.syncUserSessionEntryMetadata();
+    }
     loadSessionHistory() {
         void this.sessionEvents.loadSessionHistoryAsync({
             isCancelled: () => !this.running,

package/dist/app/cli/update.d.ts

@@ -33,12 +33,17 @@ export type PixUpdateCheckOptions = {
     packageRoot?: string;
     fetchLatestVersion?: (packageName: string, currentVersion: string, timeoutMs: number) => Promise<string | undefined>;
 };
+export type PiUpdateCheckOptions = PixUpdateCheckOptions & {
+    pixPackageRoot?: string;
+};
 export declare function pixUpdateUsage(): string;
 export declare function parsePixUpdateArgs(argv: readonly string[]): PixUpdateCliOptions;
 export declare function getPixPackageVersion(packageRoot?: string): string;
 export declare function checkPixUpdate(options?: PixUpdateCheckOptions): Promise<PixUpdateCheckResult>;
+export declare function checkPiUpdate(options?: PiUpdateCheckOptions): Promise<PixUpdateCheckResult>;
 export declare function formatPixUpdateCheck(result: PixUpdateCheckResult): string;
 export declare function formatPixStartupUpdateDialog(result: PixUpdateCheckResult): string;
+export declare function formatPiStartupUpdateToast(result: PixUpdateCheckResult): string;
 export declare function getPixSelfUpdateCommand(packageName: string, latestVersion?: string, packageRoot?: string): PixSelfUpdateCommand | undefined;
 export declare function runPixUpdateCli(argv?: readonly string[]): Promise<number>;
 declare function runCommand(command: PixSelfUpdateCommand): Promise<void>;

package/dist/app/cli/update.js

@@ -1,10 +1,13 @@
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
 const DEFAULT_UPDATE_TIMEOUT_MS = 10_000;
 const NPM_REGISTRY_URL = "https://registry.npmjs.org";
+const PI_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+const requireFromUpdateModule = createRequire(import.meta.url);
 const defaultPixUpdateDeps = {
     checkPixUpdate,
     runCommand,
@@ -53,6 +56,14 @@ export function getPixPackageVersion(packageRoot) {
 }
 export async function checkPixUpdate(options = {}) {
     const packageInfo = readPixPackageInfo(options.packageRoot);
+    return await checkPackageUpdate(packageInfo, options);
+}
+export async function checkPiUpdate(options = {}) {
+    const packageRoot = options.packageRoot ?? findPiPackageRoot(options.pixPackageRoot);
+    const packageInfo = readPackageInfo(packageRoot, PI_PACKAGE_NAME);
+    return await checkPackageUpdate(packageInfo, options);
+}
+async function checkPackageUpdate(packageInfo, options) {
     const base = {
         packageName: packageInfo.name,
         currentVersion: packageInfo.version,
@@ -124,6 +135,9 @@ export function formatPixStartupUpdateDialog(result) {
         `current: ${result.packageName} v${result.currentVersion}`,
         ...(result.latestVersion ? [`latest: ${result.latestVersion}`] : []),
         "",
+        "Pix includes the pinned Pi SDK/dependencies used by this renderer.",
+        "Updating only the global `pi` CLI is not enough for Pix.",
+        "",
         "To update:",
         "1. Exit Pix.",
         "2. Run `pix update` in your shell.",
@@ -131,6 +145,11 @@ export function formatPixStartupUpdateDialog(result) {
     ];
     return lines.join("\n");
 }
+export function formatPiStartupUpdateToast(result) {
+    return result.latestVersion
+        ? `Pi ${result.latestVersion} is available; Pix bundles Pi ${result.currentVersion}. Waiting for a matching Pix update.`
+        : `Pi update detected; Pix bundles Pi ${result.currentVersion}. Waiting for a matching Pix update.`;
+}
 export function getPixSelfUpdateCommand(packageName, latestVersion, packageRoot = readPixPackageInfo().packageRoot) {
     if (!packageRootLooksPackageManaged(packageRoot))
         return undefined;
@@ -191,9 +210,12 @@ export async function runPixUpdateCli(argv = process.argv.slice(2)) {
     }
 }
 function readPixPackageInfo(packageRoot = findPixPackageRoot()) {
+    return readPackageInfo(packageRoot, "pi-ui-extend");
+}
+function readPackageInfo(packageRoot, fallbackName) {
     const packageJsonPath = join(packageRoot, "package.json");
     const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-    const name = typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : "pi-ui-extend";
+    const name = typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : fallbackName;
     const version = typeof raw.version === "string" && raw.version.trim() ? raw.version.trim() : "0.0.0";
     return {
         name,
@@ -214,6 +236,12 @@ function findPixPackageRoot() {
         currentDir = nextDir;
     }
 }
+function findPiPackageRoot(pixPackageRoot = readPixPackageInfo().packageRoot) {
+    const packageJsonPath = requireFromUpdateModule.resolve(`${PI_PACKAGE_NAME}/package.json`, {
+        paths: [pixPackageRoot],
+    });
+    return dirname(packageJsonPath);
+}
 async function fetchLatestNpmVersion(packageName, currentVersion, timeoutMs) {
     const response = await fetch(`${NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}/latest`, {
         headers: {

package/dist/app/model/model-usage-status.d.ts

@@ -89,6 +89,8 @@ type AntigravityQuotaAccount = {
     readonly email?: string;
     readonly refreshToken: string;
     readonly accessToken?: string;
+    readonly clientId?: string;
+    readonly clientSecret?: string;
     readonly cachedQuota?: AntigravityCachedQuota;
     readonly cachedQuotaUpdatedAt?: number;
     readonly projectId: string;

package/dist/app/model/model-usage-status.js

@@ -8,6 +8,8 @@ const OPENAI_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
 const ZHIPU_QUOTA_URL = "https://bigmodel.cn/api/monitor/usage/quota/limit";
 const GOOGLE_QUOTA_API_URL = "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels";
+const GOOGLE_TOKEN_REFRESH_URL = "https://oauth2.googleapis.com/token";
+const GOOGLE_ANTIGRAVITY_USER_AGENT = "antigravity/1.11.9 windows/amd64";
 const REQUEST_TIMEOUT_MS = 10_000;
 const DAY_SECONDS = 86_400;
 const HOUR_SECONDS = 3_600;
@@ -383,11 +385,11 @@ export function resolveAntigravityQuotaModelKey(model) {
 }
 export function googleAntigravityUsageStatusFromResponse(data, descriptor, now = Date.now()) {
     const quotaInfo = data.models[descriptor.quotaModelKey]?.quotaInfo;
-    if (!quotaInfo || !Number.isFinite(quotaInfo.remainingFraction))
+    if (!quotaInfo)
         return undefined;
     const resetAt = parseResetTime(quotaInfo.resetTime, now);
     const window = {
-        remainingPercent: clampPercent(Math.round((quotaInfo.remainingFraction ?? 0) * 100)),
+        remainingPercent: quotaRemainingPercent(quotaInfo),
         resetAt,
         windowSeconds: Math.max(0, Math.round((resetAt - now) / 1000)),
     };
@@ -404,13 +406,8 @@ export function googleAntigravityUsageStatusFromResponse(data, descriptor, now =
 }
 async function queryGoogleAntigravityModelUsage(descriptor) {
     const now = Date.now();
-    const cachedResponse = googleQuotaResponseFromCachedQuota(descriptor.account.cachedQuota, descriptor.account.cachedQuotaUpdatedAt, now);
-    if (cachedResponse)
-        return googleAntigravityUsageStatusFromResponse(cachedResponse, descriptor, now);
-    if (!descriptor.account.accessToken)
-        return undefined;
-    const response = await fetchGoogleAntigravityQuota(descriptor.account.accessToken, descriptor.account.projectId);
-    return googleAntigravityUsageStatusFromResponse(response, descriptor);
+    const response = await fetchGoogleAntigravityQuotaForAccount(descriptor.account, now);
+    return googleAntigravityUsageStatusFromResponse(response, descriptor, now);
 }
 const GOOGLE_ACCOUNT_QUOTA_WINDOWS = [
     { label: "Claude Opus", quotaModelKey: "claude-opus-4-6-thinking" },
@@ -424,12 +421,8 @@ async function queryGoogleAntigravityAccountUsage(now) {
     const results = await Promise.all(accounts.map(async (account) => {
         const accountLabel = account.email ?? maskCredential(account.refreshToken);
         try {
-            const response = account.cachedQuota ? googleQuotaResponseFromCachedQuota(account.cachedQuota, account.cachedQuotaUpdatedAt, now) : undefined;
-            const windows = response ? googleAccountWindowsFromResponse(response, now) : [];
-            if (windows.length === 0 && account.accessToken) {
-                const liveResponse = await fetchGoogleAntigravityQuota(account.accessToken, account.projectId);
-                windows.push(...googleAccountWindowsFromResponse(liveResponse, now));
-            }
+            const response = await fetchGoogleAntigravityQuotaForAccount(account, now);
+            const windows = googleAccountWindowsFromResponse(response, now);
             return {
                 account: accountLabel,
                 windows,
@@ -456,12 +449,14 @@ function readAllAntigravityQuotaAccounts() {
     const credential = readPiAuthSync().antigravity;
     if (!credential)
         return [];
+    const credentialClient = getGoogleOAuthClientCredentials(credential);
     const accounts = storedAntigravityAccounts(credential);
     if (accounts.length > 0) {
         const activeIndex = clampAccountIndex(credential.activeIndex, accounts.length);
         const activeAccess = antigravityAccessFromCredential(credential);
         return accounts.map((account, accountIndex) => antigravityQuotaAccount(account, {
             ...(credential.email ? { fallbackEmail: credential.email } : {}),
+            ...(credentialClient ? { clientCredentials: credentialClient } : {}),
             ...(accountIndex === activeIndex && activeAccess ? { accessToken: activeAccess.accessToken } : {}),
             accountIndex,
             accountCount: accounts.length,
@@ -471,6 +466,7 @@ function readAllAntigravityQuotaAccounts() {
     const fallbackAccess = antigravityAccessFromCredential(credential);
     const account = fallbackAccount ? antigravityQuotaAccount(fallbackAccount, {
         ...(credential.email ? { fallbackEmail: credential.email } : {}),
+        ...(credentialClient ? { clientCredentials: credentialClient } : {}),
         ...(fallbackAccess ? { accessToken: fallbackAccess.accessToken } : {}),
     }) : undefined;
     return account ? [account] : [];
@@ -483,9 +479,41 @@ function readPiAuthSync() {
         return {};
     }
 }
+function getAccountRefreshToken(account) {
+    if (account.refreshToken)
+        return account.refreshToken;
+    if (!account.refresh)
+        return undefined;
+    return splitAntigravityRefresh(account.refresh).refreshToken;
+}
+function stringProperty(source, keys) {
+    if (!source || typeof source !== "object")
+        return undefined;
+    const record = source;
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value)
+            return value;
+    }
+    return undefined;
+}
+function getGoogleOAuthClientCredentials(...sources) {
+    for (const source of sources) {
+        const nested = source && typeof source === "object"
+            ? source.oauthClient
+            : undefined;
+        const nestedClientId = stringProperty(nested, ["clientId", "client_id", "id"]);
+        const nestedClientSecret = stringProperty(nested, ["clientSecret", "client_secret", "secret"]);
+        const clientId = nestedClientId ?? stringProperty(source, ["clientId", "client_id", "googleClientId", "google_client_id", "oauthClientId", "oauth_client_id"]);
+        const clientSecret = nestedClientSecret ?? stringProperty(source, ["clientSecret", "client_secret", "googleClientSecret", "google_client_secret", "oauthClientSecret", "oauth_client_secret"]);
+        if (clientId)
+            return { clientId, ...(clientSecret ? { clientSecret } : {}) };
+    }
+    return undefined;
+}
 function storedAntigravityAccounts(credential) {
     return Array.isArray(credential.accounts)
-        ? credential.accounts.filter((account) => account.enabled !== false && !!account.refreshToken)
+        ? credential.accounts.filter((account) => account.enabled !== false && !!getAccountRefreshToken(account))
         : [];
 }
 function antigravityAccountFromCredential(credential) {
@@ -506,16 +534,19 @@ function antigravityAccountFromCredential(credential) {
     };
 }
 function antigravityQuotaAccount(account, options = {}) {
-    const refreshToken = account.refreshToken;
+    const refreshToken = getAccountRefreshToken(account);
     if (!refreshToken)
         return undefined;
     const email = account.email || options.fallbackEmail;
     const projectId = account.projectId || account.managedProjectId || DEFAULT_ANTIGRAVITY_PROJECT_ID;
+    const clientCredentials = getGoogleOAuthClientCredentials(account, options.clientCredentials);
     return {
         refreshToken,
         projectId,
         cacheKey: email ? email.toLowerCase() : shortHash(refreshToken),
         ...(options.accessToken ? { accessToken: options.accessToken } : {}),
+        ...(clientCredentials ? { clientId: clientCredentials.clientId } : {}),
+        ...(clientCredentials?.clientSecret ? { clientSecret: clientCredentials.clientSecret } : {}),
         ...(account.cachedQuota ? { cachedQuota: account.cachedQuota } : {}),
         ...(typeof account.cachedQuotaUpdatedAt === "number" ? { cachedQuotaUpdatedAt: account.cachedQuotaUpdatedAt } : {}),
         ...(email ? { email } : {}),
@@ -590,13 +621,49 @@ function clampAccountIndex(index, accountCount) {
 function shortHash(value) {
     return createHash("sha256").update(value).digest("hex").slice(0, 12);
 }
+async function fetchGoogleAntigravityQuotaForAccount(account, now = Date.now()) {
+    if (account.accessToken)
+        return await fetchGoogleAntigravityQuota(account.accessToken, account.projectId);
+    if (account.clientId) {
+        const { accessToken } = await refreshGoogleAntigravityAccessToken(account);
+        return await fetchGoogleAntigravityQuota(accessToken, account.projectId);
+    }
+    const cachedResponse = googleQuotaResponseFromCachedQuota(account.cachedQuota, account.cachedQuotaUpdatedAt, now);
+    if (cachedResponse)
+        return cachedResponse;
+    throw new Error("Missing Google OAuth client credentials, cannot query live Antigravity quota.");
+}
+async function refreshGoogleAntigravityAccessToken(account) {
+    if (!account.clientId)
+        throw new Error("Missing Google OAuth client id, cannot refresh Antigravity access token.");
+    const params = new URLSearchParams({
+        client_id: account.clientId,
+        refresh_token: account.refreshToken,
+        grant_type: "refresh_token",
+    });
+    if (account.clientSecret)
+        params.set("client_secret", account.clientSecret);
+    const response = await fetchWithTimeout(GOOGLE_TOKEN_REFRESH_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: params,
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Google token refresh failed (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data.access_token)
+        throw new Error("Google token refresh did not return an access token.");
+    return { accessToken: data.access_token };
+}
 async function fetchGoogleAntigravityQuota(accessToken, projectId) {
     const response = await fetchWithTimeout(GOOGLE_QUOTA_API_URL, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${accessToken}`,
-            "User-Agent": "antigravity/1.18.3 darwin/arm64",
+            "User-Agent": GOOGLE_ANTIGRAVITY_USER_AGENT,
         },
         body: JSON.stringify({ project: projectId }),
     });
@@ -757,16 +824,19 @@ function accountWindowFromRateLimit(window, now) {
 }
 function googleAccountWindowFromResponse(data, label, quotaModelKey, now) {
     const quotaInfo = data.models[quotaModelKey]?.quotaInfo;
-    if (!quotaInfo || !Number.isFinite(quotaInfo.remainingFraction))
+    if (!quotaInfo)
         return undefined;
     const resetAt = parseResetTime(quotaInfo.resetTime, now);
     return {
         label,
-        remainingPercent: clampPercent(Math.round((quotaInfo.remainingFraction ?? 0) * 100)),
+        remainingPercent: quotaRemainingPercent(quotaInfo),
         resetAt,
         windowSeconds: Math.max(0, Math.round((resetAt - now) / 1000)),
     };
 }
+function quotaRemainingPercent(quotaInfo) {
+    return clampPercent(Math.round((Number.isFinite(quotaInfo.remainingFraction) ? quotaInfo.remainingFraction : 0) * 100));
+}
 function googleAccountWindowsFromResponse(data, now) {
     return GOOGLE_ACCOUNT_QUOTA_WINDOWS
         .map((window) => googleAccountWindowFromResponse(data, window.label, window.quotaModelKey, now))

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

@@ -1,8 +1,22 @@
 import type { AgentSessionEvent, AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
 import type { ConversationViewport } from "../rendering/conversation-viewport.js";
-import { type LoadOlderSessionHistoryOptions } from "./session-history.js";
+import { type LoadOlderSessionHistoryOptions, type SessionHistoryOlderLoader } from "./session-history.js";
 import type { Entry, SessionActivity } from "../types.js";
 import type { WorkspaceMutation, WorkspaceMutationPreparation } from "../workspace/workspace-undo.js";
+export type AppSessionEventControllerState = {
+    toolEntryIdsByCallId: Map<string, string>;
+    toolMutationPreparationsByCallId: Map<string, {
+        userEntryId: string;
+        args: unknown;
+        preparation?: WorkspaceMutationPreparation;
+    }>;
+    olderHistoryLoader: SessionHistoryOlderLoader | undefined;
+    currentUserEntryId: string | undefined;
+    currentAssistantEntryId: string | undefined;
+    currentThinkingEntryId: string | undefined;
+    assistantTextBuffer: string;
+    entryRenderVersions: Map<string, number>;
+};
 export type AppSessionEventControllerHost = {
     readonly entries: Entry[];
     runtime(): AgentSessionRuntime | undefined;
@@ -45,6 +59,8 @@ export declare class AppSessionEventController {
     private currentThinkingEntryId;
     private assistantTextBuffer;
     constructor(host: AppSessionEventControllerHost);
+    snapshotState(): AppSessionEventControllerState;
+    restoreState(state: AppSessionEventControllerState): void;
     reset(): void;
     loadSessionHistory(): void;
     loadSessionHistoryAsync(options: {

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

@@ -20,6 +20,34 @@ export class AppSessionEventController {
     constructor(host) {
         this.host = host;
     }
+    snapshotState() {
+        return {
+            toolEntryIdsByCallId: new Map(this.toolEntryIdsByCallId),
+            toolMutationPreparationsByCallId: new Map(this.toolMutationPreparationsByCallId),
+            olderHistoryLoader: this.olderHistoryLoader,
+            currentUserEntryId: this.currentUserEntryId,
+            currentAssistantEntryId: this.currentAssistantEntryId,
+            currentThinkingEntryId: this.currentThinkingEntryId,
+            assistantTextBuffer: this.assistantTextBuffer,
+            entryRenderVersions: new Map(this.entryRenderVersions),
+        };
+    }
+    restoreState(state) {
+        this.toolEntryIdsByCallId.clear();
+        for (const [key, value] of state.toolEntryIdsByCallId)
+            this.toolEntryIdsByCallId.set(key, value);
+        this.toolMutationPreparationsByCallId.clear();
+        for (const [key, value] of state.toolMutationPreparationsByCallId)
+            this.toolMutationPreparationsByCallId.set(key, value);
+        this.olderHistoryLoader = state.olderHistoryLoader;
+        this.currentUserEntryId = state.currentUserEntryId;
+        this.currentAssistantEntryId = state.currentAssistantEntryId;
+        this.currentThinkingEntryId = state.currentThinkingEntryId;
+        this.assistantTextBuffer = state.assistantTextBuffer;
+        this.entryRenderVersions.clear();
+        for (const [key, value] of state.entryRenderVersions)
+            this.entryRenderVersions.set(key, value);
+    }
     reset() {
         this.toolEntryIdsByCallId.clear();
         this.toolMutationPreparationsByCallId.clear();

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

@@ -1,8 +1,13 @@
 import { type AgentSession, type AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
 import type { BindCurrentSessionOptions } from "./session-lifecycle-controller.js";
+import type { AppSessionEventControllerState } from "./session-event-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";
+type TabSessionView = {
+    entries: Entry[];
+    eventState: AppSessionEventControllerState;
+};
 export type TabInputState = InputEditorDraftState;
 export type AppTabsControllerHost = {
     readonly options: AppOptions;
@@ -24,6 +29,8 @@ export type AppTabsControllerHost = {
         render: () => void;
         lazyOlderHistory?: boolean;
     }): Promise<boolean>;
+    captureSessionView?(): TabSessionView;
+    restoreSessionView?(view: TabSessionView): void;
     syncUserSessionEntryMetadata(): void;
     captureInputState(): TabInputState;
     restoreInputState(state: TabInputState): void;
@@ -44,6 +51,7 @@ export declare class AppTabsController {
     private readonly historyReloadTimersByTabId;
     private readonly inputStatesByTabId;
     private readonly deferredUserMessagesByTabId;
+    private readonly sessionViewsByTabId;
     private readonly tabIdsNeedingHistoryReload;
     private activeTabId;
     private pendingActiveTabId;
@@ -83,6 +91,7 @@ export declare class AppTabsController {
     private activeTab;
     private clearStartupTabPlaceholders;
     private storeActiveRuntime;
+    private storeActiveSessionView;
     private setRuntimeForTab;
     private deleteRuntimeForTab;
     private clearRuntimeSubscriptions;
@@ -138,3 +147,4 @@ export declare class AppTabsController {
     private preservedSessionPaths;
     private maxProjectSessions;
 }
+export {};