pi-ui-extend 0.1.34 → 0.1.36

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

@@ -26,6 +26,8 @@ export class AppSessionEventController {
     historyEntries = [];
     historyWindowStart = 0;
     currentThinkingEntryId;
+    currentThinkingEntryStartedAt;
+    thinkingElapsedRenderTimer;
     assistantMessageClosed = false;
     assistantTextBuffer = "";
     constructor(host) {
@@ -44,6 +46,7 @@ export class AppSessionEventController {
             currentAssistantTextBlockContentIndex: this.currentAssistantTextBlockContentIndex,
             assistantTextBlocksByContentIndex: new Map(this.assistantTextBlocksByContentIndex),
             currentThinkingEntryId: this.currentThinkingEntryId,
+            currentThinkingEntryStartedAt: this.currentThinkingEntryStartedAt,
             assistantMessageClosed: this.assistantMessageClosed,
             assistantTextBuffer: this.assistantTextBuffer,
             entryRenderVersions: new Map(this.entryRenderVersions),
@@ -71,6 +74,8 @@ export class AppSessionEventController {
         for (const [key, value] of state.assistantTextBlocksByContentIndex)
             this.assistantTextBlocksByContentIndex.set(key, value);
         this.currentThinkingEntryId = state.currentThinkingEntryId;
+        this.currentThinkingEntryStartedAt = state.currentThinkingEntryStartedAt;
+        this.syncThinkingElapsedRenderTimer();
         this.assistantMessageClosed = state.assistantMessageClosed;
         this.assistantTextBuffer = state.assistantTextBuffer;
         this.entryRenderVersions.clear();
@@ -94,6 +99,8 @@ export class AppSessionEventController {
         this.assistantTextBlocksByContentIndex.clear();
         this.finalizedToolCallContentIndexes.clear();
         this.currentThinkingEntryId = undefined;
+        this.currentThinkingEntryStartedAt = undefined;
+        this.stopThinkingElapsedRenderTimer();
         this.assistantMessageClosed = false;
         this.assistantTextBuffer = "";
         this.olderHistoryLoader = undefined;
@@ -563,6 +570,7 @@ export class AppSessionEventController {
                 this.handleToolCallStreamUpdate(assistantEvent.contentIndex, assistantEvent.partial, assistantEvent.toolCall);
                 break;
             case "done":
+                this.reconcileAssistantTextFromFinalMessage(assistantEvent.message);
                 this.renderAssistantToolCallsFromMessage(assistantEvent.message);
                 this.finishCurrentThinkingEntry();
                 this.flushAssistantTextBuffer(true);
@@ -754,12 +762,15 @@ export class AppSessionEventController {
             : undefined;
         if (!entry || entry.kind !== "thinking") {
             const level = this.currentThinkingLevel();
+            const startedAt = this.currentThinkingEntryStartedAt ?? Date.now();
+            this.currentThinkingEntryStartedAt = startedAt;
             entry = {
                 id: createId("thinking"),
                 kind: "thinking",
                 text: "",
                 expanded: this.host.toolDefaultExpanded(THINKING_TOOL_NAME),
                 ...(level === undefined ? {} : { level }),
+                startedAt,
                 status: "running",
             };
             this.addEntry(entry);
@@ -770,17 +781,24 @@ export class AppSessionEventController {
             delete entry.level;
         else
             entry.level = level;
+        entry.startedAt ??= this.currentThinkingEntryStartedAt ?? Date.now();
+        this.currentThinkingEntryStartedAt = entry.startedAt;
+        delete entry.finishedAt;
         entry.status = "running";
         entry.text += delta;
+        this.startThinkingElapsedRenderTimer();
         this.touchEntry(entry);
     }
     finishCurrentThinkingEntry() {
         const entry = this.currentThinkingEntryId ? this.findEntry(this.currentThinkingEntryId) : undefined;
         if (entry?.kind === "thinking" && entry.status !== "done") {
             entry.status = "done";
+            entry.finishedAt ??= Date.now();
             this.touchEntry(entry);
         }
         this.currentThinkingEntryId = undefined;
+        this.currentThinkingEntryStartedAt = undefined;
+        this.stopThinkingElapsedRenderTimer();
     }
     reconcileThinkingText(content) {
         let entry = this.currentThinkingEntryId
@@ -788,12 +806,15 @@ export class AppSessionEventController {
             : undefined;
         if (!entry || entry.kind !== "thinking") {
             const level = this.currentThinkingLevel();
+            const startedAt = this.currentThinkingEntryStartedAt ?? Date.now();
+            this.currentThinkingEntryStartedAt = startedAt;
             entry = {
                 id: createId("thinking"),
                 kind: "thinking",
                 text: "",
                 expanded: this.host.toolDefaultExpanded(THINKING_TOOL_NAME),
                 ...(level === undefined ? {} : { level }),
+                startedAt,
                 status: "running",
             };
             this.addEntry(entry);
@@ -806,13 +827,63 @@ export class AppSessionEventController {
                 delete entry.level;
             else
                 entry.level = level;
+            entry.startedAt ??= this.currentThinkingEntryStartedAt ?? Date.now();
+            this.currentThinkingEntryStartedAt = entry.startedAt;
+            delete entry.finishedAt;
             entry.status = "running";
+            this.startThinkingElapsedRenderTimer();
             this.touchEntry(entry);
         }
     }
+    syncThinkingElapsedRenderTimer() {
+        const entry = this.currentThinkingEntryId ? this.findEntry(this.currentThinkingEntryId) : undefined;
+        if (entry?.kind === "thinking" && entry.status === "running" && entry.startedAt !== undefined) {
+            this.startThinkingElapsedRenderTimer();
+            return;
+        }
+        this.stopThinkingElapsedRenderTimer();
+    }
+    startThinkingElapsedRenderTimer() {
+        if (this.thinkingElapsedRenderTimer)
+            return;
+        this.thinkingElapsedRenderTimer = setInterval(() => {
+            if (!this.host.isRunning()) {
+                this.stopThinkingElapsedRenderTimer();
+                return;
+            }
+            this.host.scheduleRender();
+        }, 1000);
+        this.thinkingElapsedRenderTimer.unref?.();
+    }
+    stopThinkingElapsedRenderTimer() {
+        if (!this.thinkingElapsedRenderTimer)
+            return;
+        clearInterval(this.thinkingElapsedRenderTimer);
+        this.thinkingElapsedRenderTimer = undefined;
+    }
     currentThinkingLevel() {
         return this.host.runtime()?.session.thinkingLevel;
     }
+    reconcileAssistantTextFromFinalMessage(message) {
+        const openContentIndex = this.currentAssistantTextBlockContentIndex;
+        if (openContentIndex !== undefined) {
+            const content = assistantTextContentAt(message, openContentIndex);
+            if (content !== undefined)
+                this.reconcileAssistantTextBlock(content, openContentIndex);
+            return;
+        }
+        const textBlocks = assistantTextContents(message);
+        if (textBlocks.length !== 1)
+            return;
+        const entry = this.currentAssistantEntryId ? this.findEntry(this.currentAssistantEntryId) : undefined;
+        if (entry?.kind !== "assistant")
+            return;
+        const visibleText = assistantStreamVisibleTextForCompleteBlock(textBlocks[0] ?? "", false);
+        if (!visibleText || entry.text === visibleText)
+            return;
+        entry.text = visibleText;
+        this.touchEntry(entry);
+    }
     renderAssistantToolCallsFromMessage(message) {
         if (!isRecord(message) || !Array.isArray(message.content))
             return;
@@ -893,6 +964,8 @@ export class AppSessionEventController {
         this.currentAssistantTextBlockStartLength = undefined;
         this.currentAssistantTextBlockContentIndex = undefined;
         this.currentThinkingEntryId = undefined;
+        this.currentThinkingEntryStartedAt = undefined;
+        this.stopThinkingElapsedRenderTimer();
         this.assistantTextBuffer = "";
         this.assistantTextBlocksByContentIndex.clear();
         this.finalizedToolCallContentIndexes.clear();
@@ -916,6 +989,11 @@ function assistantTextContentAt(value, contentIndex) {
     const block = value.content[contentIndex];
     return isRecord(block) && block.type === "text" && typeof block.text === "string" ? block.text : undefined;
 }
+function assistantTextContents(value) {
+    if (!isRecord(value) || !Array.isArray(value.content))
+        return [];
+    return value.content.flatMap((block) => (isRecord(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []));
+}
 function assistantStreamVisibleTextForCompleteBlock(text, hasVisibleTextBeforeBlock) {
     let buffer = text;
     let visibleText = "";

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

@@ -61,6 +61,7 @@ export declare class AppSessionLifecycleController {
     constructor(host: AppSessionLifecycleHost);
     start(): Promise<void>;
     bindCurrentSession(options?: BindCurrentSessionOptions): Promise<void>;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime | undefined): Promise<void>;
     unsubscribeSession(): void;
     afterSessionReplacement(message?: string): void;
     private loadReplacementHistory;

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

@@ -85,6 +85,13 @@ export class AppSessionLifecycleController {
         }
         await bindPromise;
     }
+    async awaitCurrentSessionExtensions(runtime = this.host.runtime()) {
+        if (!runtime)
+            return;
+        if (this.extensionBindRuntime !== runtime || this.extensionBindSession !== runtime.session)
+            return;
+        await this.extensionBindPromise;
+    }
     unsubscribeSession() {
         this.unsubscribe?.();
     }

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

@@ -18,6 +18,7 @@ export type AppTabsControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     createRuntimeForNewSession(): Promise<AgentSessionRuntime>;
     createRuntimeForSession(sessionPath: string): Promise<AgentSessionRuntime>;
+    awaitCurrentSessionExtensions?(runtime?: AgentSessionRuntime): Promise<void>;
     activateRuntime(runtime: AgentSessionRuntime, options?: BindCurrentSessionOptions): Promise<void>;
     disposeRuntime(runtime: AgentSessionRuntime): Promise<void>;
     isRunning(): boolean;

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

@@ -641,7 +641,9 @@ export class AppTabsController {
         void this.saveTabs();
         this.scheduleTabPrewarm();
         const cachedView = this.sessionViewsByTabId.get(target.id);
-        if (cachedView && this.host.restoreSessionView) {
+        const cachedViewNeedsHistoryReload = this.tabIdsNeedingHistoryReload.has(target.id)
+            && this.sessionActivity(targetRuntime.session) !== "running";
+        if (cachedView && this.host.restoreSessionView && !cachedViewNeedsHistoryReload) {
             this.host.restoreSessionView(cachedView);
             this.restoreDeferredUserMessages(target.id);
             this.host.setSessionStatus(targetRuntime.session);
@@ -728,6 +730,7 @@ export class AppTabsController {
         this.activeTabId = tab.id;
         this.host.setStatus("starting new session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions?.(runtime);
         const result = await runtime.newSession();
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "New session cancelled." });

package/dist/app/subagents/subagents-widget-controller.d.ts

@@ -13,7 +13,9 @@ export declare class AppSubagentsWidgetController {
     private pollTimer;
     private pollInFlight;
     private currentRunDir;
+    private currentRunDirs;
     private state;
+    private readonly runFreshnessByRunDir;
     private readonly taskPreviewsByRunDir;
     private readonly snapshotByRunDir;
     private refreshGeneration;
@@ -32,10 +34,16 @@ export declare class AppSubagentsWidgetController {
     private schedulePoll;
     private poll;
     private refreshFromFiles;
-    private findActiveRegistryRunDirForCurrentSession;
+    private findActiveRegistryRunDirsForCurrentSession;
     private registryRunDirsNewestFirst;
-    private clearMissingRunAndMaybeSelectReplacement;
     private clearCachedRun;
+    private buildStateFromRuns;
+    private orderRuns;
+    private orderRunDirs;
+    private rememberRunFreshness;
+    private runFreshness;
+    private runFreshnessFromAgents;
+    private parseRunTimestamp;
     private updateState;
     private isCurrentGeneration;
     private shouldContinuePolling;

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

@@ -10,7 +10,9 @@ export class AppSubagentsWidgetController {
     pollTimer;
     pollInFlight = false;
     currentRunDir;
+    currentRunDirs = [];
     state;
+    runFreshnessByRunDir = new Map();
     taskPreviewsByRunDir = new Map();
     snapshotByRunDir = new Map();
     refreshGeneration = 0;
@@ -38,6 +40,8 @@ export class AppSubagentsWidgetController {
     reset() {
         this.refreshGeneration++;
         this.currentRunDir = undefined;
+        this.currentRunDirs = [];
+        this.runFreshnessByRunDir.clear();
         this.taskPreviewsByRunDir.clear();
         this.snapshotByRunDir.clear();
         this.updateState(undefined);
@@ -59,15 +63,14 @@ export class AppSubagentsWidgetController {
         }
         this.currentRunDir = runDir;
         this.snapshotByRunDir.set(runDir, normalizedDetails);
+        this.rememberRunFreshness(runDir, this.runFreshnessFromAgents(normalizedDetails.agents) ?? Date.now());
         if (activeSubagentStates(normalizedDetails.agents).length > 0) {
-            this.state = {
-                runDir,
-                agents: normalizedDetails.agents,
-                ...(normalizedDetails.tasks === undefined ? {} : { tasks: normalizedDetails.tasks }),
+            this.currentRunDirs = this.orderRunDirs([runDir, ...this.currentRunDirs]);
+            this.updateState(this.buildStateFromRuns([normalizedDetails], {
                 live: false,
                 snapshotOnly: true,
                 checkedAt: Date.now(),
-            };
+            }));
         }
         void this.refreshFromFiles(this.refreshGeneration);
         this.schedulePoll(0);
@@ -88,6 +91,7 @@ export class AppSubagentsWidgetController {
         }))
             .filter((run) => activeSubagentStates(run.agents).length > 0);
         for (const run of activeRuns) {
+            this.rememberRunFreshness(run.runDir, this.runFreshnessFromAgents(run.agents) ?? data.checkedAt);
             this.snapshotByRunDir.set(run.runDir, {
                 runDir: run.runDir,
                 agents: run.agents,
@@ -97,22 +101,21 @@ export class AppSubagentsWidgetController {
             if (run.tasks)
                 this.taskPreviewsByRunDir.set(run.runDir, run.tasks);
         }
-        const preferred = activeRuns.find((run) => run.runDir === this.currentRunDir) ?? activeRuns[0];
-        if (!preferred) {
+        if (activeRuns.length === 0) {
             this.currentRunDir = undefined;
+            this.currentRunDirs = [];
             this.updateState(undefined);
             this.stopPolling();
             return;
         }
-        this.currentRunDir = preferred.runDir;
-        this.updateState({
-            runDir: preferred.runDir,
-            agents: preferred.agents,
-            ...(preferred.tasks === undefined ? {} : { tasks: preferred.tasks }),
+        const orderedRuns = this.orderRuns(activeRuns);
+        this.currentRunDir = orderedRuns[0]?.runDir;
+        this.currentRunDirs = orderedRuns.map((run) => run.runDir);
+        this.updateState(this.buildStateFromRuns(orderedRuns, {
             live: true,
             snapshotOnly: false,
             checkedAt: data.checkedAt,
-        });
+        }));
         this.startFileWatcher();
         this.schedulePoll(SUBAGENTS_POLL_INTERVAL_MS);
     }
@@ -182,71 +185,77 @@ export class AppSubagentsWidgetController {
         }
     }
     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);
+        const registry = await readSubagentRegistry(this.host.cwd);
+        if (!this.isCurrentGeneration(generation))
             return;
-        }
-        this.currentRunDir = runDir;
-        const fileState = await readSubagentRunStateFromFiles(runDir, { includeLineCounts: false });
+        const runDirs = await this.findActiveRegistryRunDirsForCurrentSession(registry, generation);
         if (!this.isCurrentGeneration(generation))
             return;
-        if (!fileState) {
-            await this.clearMissingRunAndMaybeSelectReplacement(runDir, generation);
+        if (runDirs.length === 0) {
+            this.currentRunDir = undefined;
+            this.currentRunDirs = [];
+            this.updateState(undefined);
             return;
         }
-        const activeAgents = activeSubagentStates(fileState.agents);
-        if (activeAgents.length === 0) {
-            if (allSubagentStatesTerminal(fileState.agents) || fileState.agents.length === 0) {
+        const runs = [];
+        for (const runDir of runDirs) {
+            const fileState = await readSubagentRunStateFromFiles(runDir, { includeLineCounts: false });
+            if (!this.isCurrentGeneration(generation))
+                return;
+            if (!fileState) {
                 this.clearCachedRun(runDir);
-                this.currentRunDir = undefined;
-                this.updateState(undefined);
+                continue;
+            }
+            const activeAgents = activeSubagentStates(fileState.agents);
+            if (activeAgents.length === 0) {
+                if (allSubagentStatesTerminal(fileState.agents) || fileState.agents.length === 0)
+                    this.clearCachedRun(runDir);
+                continue;
             }
+            const tasks = this.taskPreviewsByRunDir.get(runDir);
+            runs.push({
+                runDir,
+                agents: fileState.agents,
+                ...(tasks === undefined ? {} : { tasks }),
+            });
+        }
+        if (runs.length === 0) {
+            this.currentRunDir = undefined;
+            this.currentRunDirs = [];
+            this.updateState(undefined);
             return;
         }
-        const tasks = this.taskPreviewsByRunDir.get(runDir);
-        this.updateState({
-            runDir,
-            agents: fileState.agents,
-            ...(tasks === undefined ? {} : { tasks }),
+        const orderedRuns = this.orderRuns(runs);
+        this.currentRunDir = orderedRuns[0]?.runDir;
+        this.currentRunDirs = orderedRuns.map((run) => run.runDir);
+        this.updateState(this.buildStateFromRuns(orderedRuns, {
             live: true,
             snapshotOnly: false,
             checkedAt: Date.now(),
-        });
+        }));
     }
-    async findActiveRegistryRunDirForCurrentSession(registry, generation) {
+    async findActiveRegistryRunDirsForCurrentSession(registry, generation) {
         if (!registry)
-            return undefined;
+            return [];
         const sessionFile = this.host.sessionFile();
         if (!sessionFile)
-            return undefined;
+            return [];
         const candidateRunDirs = this.registryRunDirsNewestFirst(registry);
+        const matchingRunDirs = [];
         for (const runDir of candidateRunDirs) {
             if (!this.isCurrentGeneration(generation))
-                return undefined;
+                return [];
             if (!(await subagentRunHasParentSession(runDir, sessionFile)))
                 continue;
             if (!this.isCurrentGeneration(generation))
-                return undefined;
+                return [];
             const state = await readSubagentRunStateFromFiles(runDir, { includeLineCounts: false });
             if (!this.isCurrentGeneration(generation))
-                return undefined;
+                return [];
             if (activeSubagentStates(state?.agents ?? []).length > 0)
-                return runDir;
+                matchingRunDirs.push(runDir);
         }
-        return undefined;
+        return matchingRunDirs;
     }
     registryRunDirsNewestFirst(registry) {
         const runDirs = [];
@@ -263,30 +272,89 @@ export class AppSubagentsWidgetController {
         addRunDir(registry.latestRunDir);
         Object.values(registry.runs)
             .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
-            .forEach((run) => addRunDir(run.runDir));
+            .forEach((run) => {
+            this.rememberRunFreshness(run.runDir, this.parseRunTimestamp(run.updatedAt) ?? this.parseRunTimestamp(run.createdAt));
+            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.runFreshnessByRunDir.delete(runDir);
         this.snapshotByRunDir.delete(runDir);
         this.taskPreviewsByRunDir.delete(runDir);
     }
+    buildStateFromRuns(runs, meta) {
+        const activeRuns = runs
+            .map((run) => ({ ...run, agents: activeSubagentStates(run.agents) }))
+            .filter((run) => run.agents.length > 0);
+        if (activeRuns.length === 0)
+            return undefined;
+        const primary = activeRuns[0];
+        if (!primary)
+            return undefined;
+        return {
+            runs: activeRuns.map((run) => ({
+                runDir: run.runDir,
+                agents: run.agents,
+                ...(run.tasks === undefined ? {} : { tasks: run.tasks }),
+            })),
+            runDir: primary.runDir,
+            agents: activeRuns.flatMap((run) => run.agents),
+            ...(primary.tasks === undefined ? {} : { tasks: primary.tasks }),
+            ...meta,
+        };
+    }
+    orderRuns(runs) {
+        const order = this.orderRunDirs(runs.map((run) => run.runDir));
+        const priority = new Map(order.map((runDir, index) => [runDir, index]));
+        return [...runs].sort((a, b) => {
+            const freshness = this.runFreshness(b) - this.runFreshness(a);
+            if (freshness !== 0)
+                return freshness;
+            return (priority.get(a.runDir) ?? Number.MAX_SAFE_INTEGER) - (priority.get(b.runDir) ?? Number.MAX_SAFE_INTEGER);
+        });
+    }
+    orderRunDirs(runDirs) {
+        const seen = new Set();
+        const preferred = [this.currentRunDir, ...this.currentRunDirs, ...runDirs].filter((runDir) => Boolean(runDir));
+        const ordered = [];
+        for (const runDir of preferred) {
+            if (seen.has(runDir))
+                continue;
+            seen.add(runDir);
+            ordered.push(runDir);
+        }
+        return ordered;
+    }
+    rememberRunFreshness(runDir, freshness) {
+        if (!Number.isFinite(freshness))
+            return;
+        const next = freshness ?? 0;
+        const previous = this.runFreshnessByRunDir.get(runDir) ?? Number.NEGATIVE_INFINITY;
+        if (next >= previous)
+            this.runFreshnessByRunDir.set(runDir, next);
+    }
+    runFreshness(run) {
+        return this.runFreshnessFromAgents(run.agents)
+            ?? this.runFreshnessByRunDir.get(run.runDir)
+            ?? 0;
+    }
+    runFreshnessFromAgents(agents) {
+        let freshest;
+        for (const agent of agents) {
+            const parsed = this.parseRunTimestamp(agent.startedAt);
+            if (parsed === undefined)
+                continue;
+            freshest = freshest === undefined ? parsed : Math.max(freshest, parsed);
+        }
+        return freshest;
+    }
+    parseRunTimestamp(value) {
+        if (!value)
+            return undefined;
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
     updateState(next) {
         const previous = stringifyUnknown(this.state);
         const serializedNext = stringifyUnknown(next);
@@ -298,6 +366,9 @@ export class AppSubagentsWidgetController {
         return generation === this.refreshGeneration;
     }
     shouldContinuePolling() {
+        const runs = this.state?.runs;
+        if (runs?.length)
+            return runs.some((run) => activeSubagentStates(run.agents).length > 0);
         return activeSubagentStates(this.state?.agents ?? []).length > 0;
     }
     eventMatchesCurrentSession(eventSessionFile) {

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

@@ -24,6 +24,10 @@ export declare class AppTerminalController {
     private terminalEnabled;
     private interactiveSuspended;
     private stopPromise;
+    private keyboardProtocolNegotiationBuffer;
+    private keyboardProtocolBufferFlushTimer;
+    private kittyProtocolActive;
+    private modifyOtherKeysActive;
     private readonly enterInteractiveSequence;
     private readonly exitInteractiveSequence;
     constructor(host: AppTerminalControllerHost);
@@ -40,4 +44,10 @@ export declare class AppTerminalController {
     private scheduleForcedProcessExit;
     private readonly onResize;
     private readonly onInputData;
+    private beginKeyboardProtocolNegotiation;
+    private filterKeyboardProtocolNegotiationInput;
+    private handleKeyboardProtocolNegotiationResponse;
+    private enableModifyOtherKeysFallback;
+    private setKeyboardProtocolNegotiationBuffer;
+    private clearKeyboardProtocolNegotiationBuffer;
 }