pi-ui-extend 0.1.1

package/dist/app/subagents-widget-controller.js

@@ -0,0 +1,311 @@
+import { watch } from "node:fs";
+import { join, resolve } from "node:path";
+import { SUBAGENTS_POLL_INTERVAL_MS, SUBAGENTS_RUN_ROOT } from "./constants.js";
+import { stringifyUnknown } from "./message-content.js";
+import { readSubagentRegistry, readSubagentRunStateFromFiles, subagentRunHasParentSession } from "./subagents-files.js";
+import { activeSubagentStates, allSubagentStatesTerminal, isSubagentRunRenderDetails, isSubagentsLiveStateEvent, isSubagentsToolName, resolveSubagentRunDir, } from "./subagents-model.js";
+const SUBAGENTS_FILE_WATCH_DEBOUNCE_MS = 75;
+export class AppSubagentsWidgetController {
+    host;
+    pollTimer;
+    pollInFlight = false;
+    currentRunDir;
+    state;
+    taskPreviewsByRunDir = new Map();
+    snapshotByRunDir = new Map();
+    refreshGeneration = 0;
+    fileWatcher;
+    fileRefreshTimer;
+    constructor(host) {
+        this.host = host;
+    }
+    get widgetState() {
+        return this.state;
+    }
+    startPolling() {
+        this.startFileWatcher();
+        this.schedulePoll(0);
+    }
+    stopPolling() {
+        if (this.pollTimer)
+            clearTimeout(this.pollTimer);
+        this.pollTimer = undefined;
+        if (this.fileRefreshTimer)
+            clearTimeout(this.fileRefreshTimer);
+        this.fileRefreshTimer = undefined;
+        this.stopFileWatcher();
+    }
+    reset() {
+        this.refreshGeneration++;
+        this.currentRunDir = undefined;
+        this.taskPreviewsByRunDir.clear();
+        this.snapshotByRunDir.clear();
+        this.updateState(undefined);
+    }
+    observeToolResult(toolName, details, options = {}) {
+        if (!isSubagentsToolName(toolName))
+            return;
+        if (!isSubagentRunRenderDetails(details))
+            return;
+        const runDir = resolveSubagentRunDir(this.host.cwd, details.runDir);
+        const normalizedDetails = { ...details, runDir };
+        if (normalizedDetails.tasks)
+            this.taskPreviewsByRunDir.set(runDir, normalizedDetails.tasks);
+        if (options.showSnapshot === false) {
+            void this.refreshFromFiles(this.refreshGeneration);
+            this.schedulePoll(0);
+            this.startFileWatcher();
+            return;
+        }
+        this.currentRunDir = runDir;
+        this.snapshotByRunDir.set(runDir, normalizedDetails);
+        if (activeSubagentStates(normalizedDetails.agents).length > 0) {
+            this.state = {
+                runDir,
+                agents: normalizedDetails.agents,
+                ...(normalizedDetails.tasks === undefined ? {} : { tasks: normalizedDetails.tasks }),
+                live: false,
+                snapshotOnly: true,
+                checkedAt: Date.now(),
+            };
+        }
+        void this.refreshFromFiles(this.refreshGeneration);
+        this.schedulePoll(0);
+        if (this.host.isRunning())
+            this.host.render();
+        this.startFileWatcher();
+    }
+    observeLiveState(data) {
+        if (!isSubagentsLiveStateEvent(data))
+            return;
+        if (!this.eventMatchesCurrentSession(data.sessionFile))
+            return;
+        const activeRuns = data.runs
+            .map((run) => ({
+            runDir: resolveSubagentRunDir(this.host.cwd, run.runDir),
+            agents: run.agents,
+            ...(run.tasks === undefined ? {} : { tasks: run.tasks }),
+        }))
+            .filter((run) => activeSubagentStates(run.agents).length > 0);
+        for (const run of activeRuns) {
+            this.snapshotByRunDir.set(run.runDir, {
+                runDir: run.runDir,
+                agents: run.agents,
+                ...(run.tasks === undefined ? {} : { tasks: run.tasks }),
+                mode: "status",
+            });
+            if (run.tasks)
+                this.taskPreviewsByRunDir.set(run.runDir, run.tasks);
+        }
+        const preferred = activeRuns.find((run) => run.runDir === this.currentRunDir) ?? activeRuns[0];
+        if (!preferred) {
+            this.currentRunDir = undefined;
+            this.updateState(undefined);
+            this.stopPolling();
+            return;
+        }
+        this.currentRunDir = preferred.runDir;
+        this.updateState({
+            runDir: preferred.runDir,
+            agents: preferred.agents,
+            ...(preferred.tasks === undefined ? {} : { tasks: preferred.tasks }),
+            live: true,
+            snapshotOnly: false,
+            checkedAt: data.checkedAt,
+        });
+        this.startFileWatcher();
+        this.schedulePoll(SUBAGENTS_POLL_INTERVAL_MS);
+    }
+    startFileWatcher() {
+        if (this.fileWatcher || !this.host.isRunning())
+            return;
+        try {
+            this.fileWatcher = watch(join(this.host.cwd, SUBAGENTS_RUN_ROOT), { recursive: true }, () => {
+                this.handleSubagentsFilesChanged();
+            });
+            this.fileWatcher.on("error", () => this.stopFileWatcher());
+        }
+        catch {
+            // The subagents directory may not exist yet, or recursive watching may be
+            // unavailable on this platform. Polling and live-state events remain as
+            // fallbacks; observeToolResult/liveState will retry once subagents exist.
+            this.fileWatcher = undefined;
+        }
+    }
+    stopFileWatcher() {
+        this.fileWatcher?.close();
+        this.fileWatcher = undefined;
+    }
+    handleSubagentsFilesChanged() {
+        if (!this.host.isRunning())
+            return;
+        if (this.fileRefreshTimer)
+            clearTimeout(this.fileRefreshTimer);
+        this.fileRefreshTimer = setTimeout(() => {
+            this.fileRefreshTimer = undefined;
+            const generation = this.refreshGeneration;
+            void this.refreshFromFiles(generation).then(() => {
+                if (this.isCurrentGeneration(generation) && this.shouldContinuePolling()) {
+                    this.schedulePoll(SUBAGENTS_POLL_INTERVAL_MS);
+                }
+            });
+        }, SUBAGENTS_FILE_WATCH_DEBOUNCE_MS);
+        this.fileRefreshTimer.unref?.();
+    }
+    schedulePoll(delayMs) {
+        if (!this.host.isRunning())
+            return;
+        if (this.pollTimer)
+            clearTimeout(this.pollTimer);
+        this.pollTimer = setTimeout(() => {
+            this.pollTimer = undefined;
+            void this.poll();
+        }, delayMs);
+        this.pollTimer.unref?.();
+    }
+    async poll() {
+        if (!this.host.isRunning())
+            return;
+        if (this.pollInFlight) {
+            this.schedulePoll(SUBAGENTS_POLL_INTERVAL_MS);
+            return;
+        }
+        this.pollInFlight = true;
+        const generation = this.refreshGeneration;
+        try {
+            await this.refreshFromFiles(generation);
+        }
+        finally {
+            this.pollInFlight = false;
+            if (this.shouldContinuePolling())
+                this.schedulePoll(SUBAGENTS_POLL_INTERVAL_MS);
+        }
+    }
+    async refreshFromFiles(generation = this.refreshGeneration) {
+        let runDir = this.currentRunDir;
+        if (!runDir) {
+            const registry = await readSubagentRegistry(this.host.cwd);
+            if (!this.isCurrentGeneration(generation))
+                return;
+            runDir = await this.findActiveRegistryRunDirForCurrentSession(registry, generation);
+            if (!this.isCurrentGeneration(generation))
+                return;
+            if (runDir)
+                this.currentRunDir = runDir;
+        }
+        if (!runDir) {
+            if (!this.isCurrentGeneration(generation))
+                return;
+            this.updateState(undefined);
+            return;
+        }
+        this.currentRunDir = runDir;
+        const fileState = await readSubagentRunStateFromFiles(runDir, { includeLineCounts: false });
+        if (!this.isCurrentGeneration(generation))
+            return;
+        if (!fileState) {
+            await this.clearMissingRunAndMaybeSelectReplacement(runDir, generation);
+            return;
+        }
+        const activeAgents = activeSubagentStates(fileState.agents);
+        if (activeAgents.length === 0) {
+            if (allSubagentStatesTerminal(fileState.agents) || fileState.agents.length === 0) {
+                this.clearCachedRun(runDir);
+                this.currentRunDir = undefined;
+                this.updateState(undefined);
+            }
+            return;
+        }
+        const tasks = this.taskPreviewsByRunDir.get(runDir);
+        this.updateState({
+            runDir,
+            agents: fileState.agents,
+            ...(tasks === undefined ? {} : { tasks }),
+            live: true,
+            snapshotOnly: false,
+            checkedAt: Date.now(),
+        });
+    }
+    async findActiveRegistryRunDirForCurrentSession(registry, generation) {
+        if (!registry)
+            return undefined;
+        const sessionFile = this.host.sessionFile();
+        if (!sessionFile)
+            return undefined;
+        const candidateRunDirs = this.registryRunDirsNewestFirst(registry);
+        for (const runDir of candidateRunDirs) {
+            if (!this.isCurrentGeneration(generation))
+                return undefined;
+            if (!(await subagentRunHasParentSession(runDir, sessionFile)))
+                continue;
+            if (!this.isCurrentGeneration(generation))
+                return undefined;
+            const state = await readSubagentRunStateFromFiles(runDir, { includeLineCounts: false });
+            if (!this.isCurrentGeneration(generation))
+                return undefined;
+            if (activeSubagentStates(state?.agents ?? []).length > 0)
+                return runDir;
+        }
+        return undefined;
+    }
+    registryRunDirsNewestFirst(registry) {
+        const runDirs = [];
+        const seen = new Set();
+        const addRunDir = (runDir) => {
+            if (!runDir)
+                return;
+            const resolved = resolveSubagentRunDir(this.host.cwd, runDir);
+            if (seen.has(resolved))
+                return;
+            seen.add(resolved);
+            runDirs.push(resolved);
+        };
+        addRunDir(registry.latestRunDir);
+        Object.values(registry.runs)
+            .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
+            .forEach((run) => addRunDir(run.runDir));
+        return runDirs;
+    }
+    async clearMissingRunAndMaybeSelectReplacement(runDir, generation) {
+        this.clearCachedRun(runDir);
+        if (this.currentRunDir === runDir)
+            this.currentRunDir = undefined;
+        const registry = await readSubagentRegistry(this.host.cwd);
+        if (!this.isCurrentGeneration(generation))
+            return;
+        const replacementRunDir = await this.findActiveRegistryRunDirForCurrentSession(registry, generation);
+        if (!this.isCurrentGeneration(generation))
+            return;
+        if (replacementRunDir) {
+            this.currentRunDir = replacementRunDir;
+            await this.refreshFromFiles(generation);
+            return;
+        }
+        this.updateState(undefined);
+    }
+    clearCachedRun(runDir) {
+        this.snapshotByRunDir.delete(runDir);
+        this.taskPreviewsByRunDir.delete(runDir);
+    }
+    updateState(next) {
+        const previous = stringifyUnknown(this.state);
+        const serializedNext = stringifyUnknown(next);
+        this.state = next;
+        if (previous !== serializedNext && this.host.isRunning())
+            this.host.render();
+    }
+    isCurrentGeneration(generation) {
+        return generation === this.refreshGeneration;
+    }
+    shouldContinuePolling() {
+        return activeSubagentStates(this.state?.agents ?? []).length > 0;
+    }
+    eventMatchesCurrentSession(eventSessionFile) {
+        if (!eventSessionFile)
+            return true;
+        const sessionFile = this.host.sessionFile();
+        if (!sessionFile)
+            return true;
+        return resolve(eventSessionFile) === resolve(sessionFile);
+    }
+}

package/dist/app/tab-line-renderer.d.ts

@@ -0,0 +1,26 @@
+import type { Theme } from "../theme.js";
+import type { ScreenStyler } from "./screen-styler.js";
+import type { SessionTab, TabLineLayout } from "./types.js";
+export type TabLineRendererHost = {
+    readonly theme: Theme;
+    readonly screenStyler: ScreenStyler;
+    readonly tabs: readonly SessionTab[];
+};
+export declare const TAB_PANEL_ROWS = 2;
+export declare function tabPanelRows(tabLineVisible: boolean, terminalRows: number, tabCount?: number): number;
+export declare class TabLineRenderer {
+    private readonly host;
+    constructor(host: TabLineRendererHost);
+    panelRows(terminalRows: number): number;
+    layout(width: number): TabLineLayout;
+    render(row: number, layout: TabLineLayout, width: number): string;
+    renderBottom(row: number, layout: TabLineLayout, width: number): string;
+    bottomText(layout: TabLineLayout, width: number): string;
+    private buttonLayout;
+    private displayTitle;
+    private buttonLayoutFromText;
+    private addButtonSegments;
+    private statusIndicatorStyle;
+    private statusIndicatorIcon;
+    private pushSegment;
+}

package/dist/app/tab-line-renderer.js

@@ -0,0 +1,222 @@
+import { stringDisplayWidth } from "../terminal-width.js";
+import { APP_ICONS } from "./icons.js";
+import { ellipsizeDisplay } from "./render-text.js";
+const TAB_SEPARATOR = " │ ";
+const EMPTY_NEW_TAB_PREFIX = "│ ";
+const DEFAULT_SESSION_TITLE_PATTERN = /^session [0-9a-f]{8}$/iu;
+export const TAB_PANEL_ROWS = 2;
+export function tabPanelRows(tabLineVisible, terminalRows, tabCount = TAB_PANEL_ROWS) {
+    if (!tabLineVisible)
+        return 0;
+    const desiredRows = TAB_PANEL_ROWS;
+    return Math.min(desiredRows, Math.max(0, terminalRows - 1));
+}
+export class TabLineRenderer {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    panelRows(terminalRows) {
+        return tabPanelRows(true, terminalRows, this.host.tabs.length);
+    }
+    layout(width) {
+        if (width <= 0)
+            return { text: "", segments: [], targets: [], separatorColumns: [] };
+        const tabs = this.host.tabs;
+        const separator = TAB_SEPARATOR;
+        const separatorWidth = stringDisplayWidth(separator);
+        const separatorCount = Math.max(0, tabs.length - 1);
+        const newTabWidth = stringDisplayWidth(APP_ICONS.plus);
+        const newTabPrefix = tabs.length > 0 ? separator : EMPTY_NEW_TAB_PREFIX;
+        const newTabPrefixWidth = stringDisplayWidth(newTabPrefix);
+        const tabsWidth = Math.max(0, width - newTabWidth - newTabPrefixWidth);
+        const naturalButtons = tabs.map((tab) => this.buttonLayout(tab));
+        const naturalWidth = naturalButtons.reduce((sum, button) => sum + stringDisplayWidth(button.text), 0)
+            + separatorCount * separatorWidth;
+        const buttonMaxWidth = naturalWidth <= tabsWidth
+            ? undefined
+            : Math.max(7, Math.floor(Math.max(1, tabsWidth - separatorCount * separatorWidth) / tabs.length));
+        const buttons = buttonMaxWidth === undefined ? naturalButtons : tabs.map((tab) => this.buttonLayout(tab, buttonMaxWidth));
+        const segments = [];
+        const targets = [];
+        const separatorColumns = [];
+        let text = "";
+        let displayColumn = 1;
+        for (let index = 0; index < tabs.length; index += 1) {
+            if (index > 0) {
+                const separatorOffset = text.length;
+                separatorColumns.push(displayColumn + 1);
+                text += separator;
+                segments.push({
+                    start: separatorOffset + 1,
+                    end: separatorOffset + 2,
+                    foreground: this.host.theme.colors.inputBorder,
+                });
+                displayColumn += separatorWidth;
+            }
+            const tab = tabs[index];
+            const button = buttons[index];
+            if (!tab || !button)
+                continue;
+            const textOffset = text.length;
+            const buttonWidth = stringDisplayWidth(button.text);
+            text += button.text;
+            this.addButtonSegments(tab, button, textOffset, segments);
+            const closeColumnOffset = stringDisplayWidth(button.text.slice(0, button.closeStart));
+            // Keep the more specific close target before the tab target because the
+            // tab target intentionally spans the whole button, including the close icon.
+            targets.push({
+                kind: "close",
+                tabId: tab.id,
+                startColumn: displayColumn + closeColumnOffset,
+                endColumn: displayColumn + closeColumnOffset + stringDisplayWidth(button.text.slice(button.closeStart, button.closeEnd)),
+            });
+            targets.push({
+                kind: "tab",
+                tabId: tab.id,
+                active: tab.status === "active",
+                startColumn: displayColumn,
+                endColumn: displayColumn + buttonWidth,
+            });
+            displayColumn += buttonWidth;
+        }
+        const tabsText = ellipsizeDisplay(text, tabsWidth);
+        const renderedTabsWidth = stringDisplayWidth(tabsText);
+        const lineText = `${tabsText}${newTabPrefix}${APP_ICONS.plus}`;
+        const newTabDividerColumn = renderedTabsWidth + (tabs.length > 0 ? 2 : 1);
+        const plusStartColumn = renderedTabsWidth + newTabPrefixWidth + 1;
+        const newTabDividerOffset = tabsText.length + (tabs.length > 0 ? 1 : 0);
+        segments.push({
+            start: newTabDividerOffset,
+            end: newTabDividerOffset + 1,
+            foreground: this.host.theme.colors.inputBorder,
+        });
+        segments.push({
+            start: lineText.length - APP_ICONS.plus.length,
+            end: lineText.length,
+            foreground: this.host.theme.colors.info,
+            bold: true,
+        });
+        targets.push({
+            kind: "new-tab",
+            startColumn: plusStartColumn,
+            endColumn: plusStartColumn + newTabWidth,
+        });
+        return {
+            text: ellipsizeDisplay(lineText, width),
+            segments,
+            targets: targets.filter((target) => target.startColumn <= width),
+            separatorColumns: [
+                ...separatorColumns.filter((column) => column <= Math.min(width, renderedTabsWidth)),
+                ...(newTabDividerColumn <= width ? [newTabDividerColumn] : []),
+            ],
+        };
+    }
+    render(row, layout, width) {
+        return this.host.screenStyler.styleLineSegments(row, layout.text, width, {
+            foreground: this.host.theme.colors.statusForeground,
+        }, layout.segments);
+    }
+    renderBottom(row, layout, width) {
+        return this.host.screenStyler.styleLine(row, this.bottomText(layout, width), width, {
+            foreground: this.host.theme.colors.inputBorder,
+        });
+    }
+    bottomText(layout, width) {
+        const chars = Array.from({ length: Math.max(0, width) }, () => "─");
+        const activeTabTarget = layout.targets.find((target) => target.kind === "tab" && target.active);
+        if (activeTabTarget) {
+            const leftSeparator = Math.max(0, ...layout.separatorColumns.filter((column) => column < activeTabTarget.startColumn));
+            const rightSeparator = Math.min(width + 1, ...layout.separatorColumns.filter((column) => column >= activeTabTarget.endColumn));
+            const clearStart = Math.max(1, leftSeparator + 1);
+            const clearEnd = Math.min(width, rightSeparator - 1);
+            for (let column = clearStart; column <= clearEnd; column += 1) {
+                chars[column - 1] = " ";
+            }
+        }
+        for (const column of layout.separatorColumns) {
+            if (column < 1 || column > width)
+                continue;
+            const hasLeftLine = chars[column - 2] === "─";
+            const hasRightLine = chars[column] === "─";
+            chars[column - 1] = hasLeftLine && hasRightLine ? "┴" : hasLeftLine ? "┘" : hasRightLine ? "└" : "╵";
+        }
+        return chars.join("");
+    }
+    buttonLayout(tab, maxWidth) {
+        const statusText = this.statusIndicatorIcon(tab);
+        const prefix = `${statusText} `;
+        const suffix = ` ${APP_ICONS.close}`;
+        const title = this.displayTitle(tab);
+        const naturalText = `${prefix}${title}${suffix}`;
+        const naturalWidth = stringDisplayWidth(naturalText);
+        if (maxWidth === undefined || naturalWidth <= maxWidth)
+            return this.buttonLayoutFromText(naturalText, 0, statusText.length);
+        const titleWidth = maxWidth - stringDisplayWidth(prefix) - stringDisplayWidth(suffix);
+        if (titleWidth <= 0)
+            return this.buttonLayoutFromText(ellipsizeDisplay(`${statusText}${APP_ICONS.close}`, maxWidth), 0, statusText.length);
+        return this.buttonLayoutFromText(`${prefix}${ellipsizeDisplay(title, titleWidth)}${suffix}`, 0, statusText.length);
+    }
+    displayTitle(tab) {
+        const title = tab.title.trim();
+        if (!DEFAULT_SESSION_TITLE_PATTERN.test(title))
+            return tab.title;
+        return tab.titlePlaceholder === "loading" ? "Loading…" : "New";
+    }
+    buttonLayoutFromText(text, statusStart, statusLength) {
+        const closeStart = Math.max(0, text.lastIndexOf(APP_ICONS.close));
+        return {
+            text,
+            statusStart,
+            statusEnd: Math.min(text.length, statusStart + statusLength),
+            closeStart,
+            closeEnd: closeStart + APP_ICONS.close.length,
+        };
+    }
+    addButtonSegments(tab, button, textOffset, segments) {
+        const statusStyle = this.statusIndicatorStyle(tab);
+        if (tab.status !== "active") {
+            this.pushSegment(segments, textOffset + button.statusStart, textOffset + button.statusEnd, {
+                ...statusStyle,
+            });
+            this.pushSegment(segments, textOffset + button.closeStart, textOffset + button.closeEnd, {
+                foreground: this.host.theme.colors.muted,
+            });
+            return;
+        }
+        const statusStart = textOffset + button.statusStart;
+        const statusEnd = textOffset + button.statusEnd;
+        const closeStart = textOffset + button.closeStart;
+        const closeEnd = textOffset + button.closeEnd;
+        const end = textOffset + button.text.length;
+        this.pushSegment(segments, statusStart, statusEnd, {
+            ...statusStyle,
+        });
+        this.pushSegment(segments, statusEnd, closeStart, { foreground: this.host.theme.colors.selectionForeground });
+        this.pushSegment(segments, closeStart, closeEnd, { foreground: this.host.theme.colors.muted });
+        this.pushSegment(segments, closeEnd, end, { foreground: this.host.theme.colors.selectionForeground });
+    }
+    statusIndicatorStyle(tab) {
+        if (tab.status !== "active" && tab.attention === "terminal-bell" && tab.attentionVisible !== false) {
+            return { foreground: this.host.theme.colors.error, bold: true };
+        }
+        if (tab.activity === "running" || tab.activity === "thinking") {
+            return { foreground: this.host.theme.colors.success, bold: true };
+        }
+        return { foreground: this.host.theme.colors.statusDotBase };
+    }
+    statusIndicatorIcon(tab) {
+        if (tab.status !== "active" && tab.attention === "terminal-bell" && tab.attentionVisible !== false) {
+            return APP_ICONS.alert;
+        }
+        if (tab.activity === "running" || tab.activity === "thinking") {
+            return APP_ICONS.timerSand;
+        }
+        return APP_ICONS.checkCircle;
+    }
+    pushSegment(segments, start, end, style) {
+        if (end <= start)
+            return;
+        segments.push({ start, end, ...style });
+    }
+}

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

@@ -0,0 +1,100 @@
+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";
+export type TabInputState = {
+    text: string;
+    cursor: number;
+};
+export type AppTabsControllerHost = {
+    readonly options: AppOptions;
+    readonly blinkController: AppBlinkController;
+    runtime(): AgentSessionRuntime | undefined;
+    createRuntimeForNewSession(): Promise<AgentSessionRuntime>;
+    createRuntimeForSession(sessionPath: string): Promise<AgentSessionRuntime>;
+    activateRuntime(runtime: AgentSessionRuntime): Promise<void>;
+    disposeRuntime(runtime: AgentSessionRuntime): Promise<void>;
+    isRunning(): boolean;
+    setStatus(status: string): void;
+    setSessionStatus(session: AgentSession | undefined): void;
+    setSessionActivity(activity: SessionActivity): void;
+    resetSessionView(): void;
+    loadSessionHistory(): void;
+    loadSessionHistoryAsync(options: {
+        isCancelled: () => boolean;
+        render: () => void;
+    }): Promise<boolean>;
+    syncUserSessionEntryMetadata(): void;
+    captureInputState(): TabInputState;
+    restoreInputState(state: TabInputState): void;
+    addEntry(entry: Entry): void;
+    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    render(): void;
+};
+export declare class AppTabsController {
+    private readonly host;
+    private readonly tabItems;
+    private readonly runtimesByTabId;
+    private readonly runtimeSubscriptionsByTabId;
+    private readonly inputStatesByTabId;
+    private activeTabId;
+    private pendingActiveTabId;
+    private historyLoadGeneration;
+    private restored;
+    constructor(host: AppTabsControllerHost);
+    tabs(): readonly SessionTab[];
+    isSwitching(): boolean;
+    markTerminalBellAttention(sessionPath: string | undefined): void;
+    tabPanelRows(terminalRows: number): number;
+    activeInputTabId(): string | undefined;
+    inputStateForTab(tabId: string | undefined): TabInputState | undefined;
+    setInputStateForTab(tabId: string | undefined, state: TabInputState): Promise<void>;
+    disposeInactiveRuntimes(disposeRuntime?: (runtime: AgentSessionRuntime) => Promise<void>): Promise<void>;
+    saveInputStateForQuit(): Promise<void>;
+    syncActiveTabFromRuntime(options?: {
+        save?: boolean;
+        force?: boolean;
+    }): void;
+    restoreAfterStartup(): Promise<void>;
+    openNewTab(): Promise<void>;
+    openSessionInNewTab(sessionPath: string): Promise<boolean>;
+    switchToTab(tabId: string): Promise<void>;
+    closeTab(tabId: string): Promise<void>;
+    private replaceLastTabWithNewSession;
+    private loadActiveSessionHistory;
+    private cancelHistoryLoad;
+    private tabsAvailable;
+    private runtimeForCommand;
+    private idleRuntime;
+    private activeTab;
+    private storeActiveRuntime;
+    private setRuntimeForTab;
+    private deleteRuntimeForTab;
+    private clearRuntimeSubscriptions;
+    private observeRuntimeForTab;
+    private shouldSyncTabFromRuntimeEvent;
+    private syncTabFromObservedRuntime;
+    private storeActiveInputState;
+    private restoreInputState;
+    private runtimeForTab;
+    private findTabForSession;
+    private findTabBySessionPath;
+    private replaceTabs;
+    private removeTab;
+    private restorePersistedInputStates;
+    private ensureCurrentSessionTab;
+    private tabFromSession;
+    private updateTabFromSession;
+    private sessionPath;
+    private sessionTitle;
+    private sessionActivity;
+    private tabActivity;
+    private clearTabAttention;
+    private startAttentionBlink;
+    private stopAttentionBlinkIfIdle;
+    private loadSessionTitles;
+    private restoredTabs;
+    private loadTabs;
+    private parsePersistedInputState;
+    private saveTabs;
+    private filePath;
+}