pi-ui-extend 0.1.18 → 0.1.19

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;

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

@@ -9,13 +9,16 @@ import { createStartupInfoMessage, isEmptyStartupSession } from "../cli/startup-
 import { tabPanelRows } from "../rendering/tab-line-renderer.js";
 const TAB_STATE_VERSION = 3;
 const MAX_RESTORED_TABS = 8;
+const BACKGROUND_PREWARM_TAB_LIMIT = 2;
 const TAB_ATTENTION_BLINK_KEY = "tab-attention";
 const LOADING_TAB_TITLE_PATTERN = /^loading(?:…|\.\.\.)?$/iu;
 export class AppTabsController {
     host;
     tabItems = [];
     runtimesByTabId = new Map();
+    runtimeLoadsByTabId = new Map();
     runtimeSubscriptionsByTabId = new Map();
+    runtimeRefreshTimersByTabId = new Map();
     inputStatesByTabId = new Map();
     deferredUserMessagesByTabId = new Map();
     activeTabId;
@@ -24,6 +27,8 @@ export class AppTabsController {
     restored = false;
     retentionCleanupRunning = false;
     retentionCleanupScheduled = false;
+    prewarmScheduled = false;
+    prewarmRunning = false;
     constructor(host) {
         this.host = host;
     }
@@ -192,6 +197,7 @@ export class AppTabsController {
             this.settleStartupTabPlaceholders();
             await this.saveTabs();
             this.scheduleProjectSessionRetention();
+            this.scheduleTabPrewarm();
             return;
         }
         let restoredRuntime = runtime;
@@ -200,7 +206,7 @@ export class AppTabsController {
             this.host.render();
             try {
                 restoredRuntime = await this.host.createRuntimeForSession(desiredPath);
-                await this.host.activateRuntime(restoredRuntime);
+                await this.host.activateRuntime(restoredRuntime, { awaitExtensions: false });
             }
             catch {
                 this.host.showToast("Could not restore the previous active tab", "warning");
@@ -224,6 +230,7 @@ export class AppTabsController {
             this.restoreInputState(this.activeTabId);
         await this.saveTabs();
         this.scheduleProjectSessionRetention();
+        this.scheduleTabPrewarm();
     }
     async openNewTab() {
         if (this.pendingActiveTabId) {
@@ -239,31 +246,72 @@ export class AppTabsController {
         this.syncActiveTabFromRuntime();
         this.storeActiveInputState();
         this.storeActiveDeferredUserMessages();
-        this.host.setStatus("starting new tab");
-        this.host.render();
-        const newRuntime = await this.host.createRuntimeForNewSession();
-        const existingTab = this.findTabForSession(newRuntime.session);
-        const tab = existingTab ?? this.tabFromSession(newRuntime.session, { titlePlaceholder: "new" });
-        if (!existingTab)
-            this.tabItems.push(tab);
+        const previousTabId = this.activeTabId;
+        const previousRuntime = runtime;
+        const tab = {
+            id: createId("tab"),
+            title: "new",
+            titlePlaceholder: "new",
+            status: "active",
+            activity: "thinking",
+        };
+        this.tabItems.push(tab);
         this.activeTabId = tab.id;
         this.pendingActiveTabId = tab.id;
         this.clearTabAttention(tab);
-        this.updateTabFromSession(tab, newRuntime.session);
-        this.setRuntimeForTab(tab.id, newRuntime);
         this.restoreInputState(tab.id);
         this.host.closeMenusForTabSwitch?.();
+        this.host.resetSessionView();
+        this.restoreDeferredUserMessages(tab.id);
+        this.host.setSessionActivity("thinking");
+        this.host.setStatus("starting new tab");
+        this.host.render();
+        let newRuntime;
         try {
-            await this.host.activateRuntime(newRuntime);
+            newRuntime = await this.host.createRuntimeForNewSession();
         }
-        finally {
+        catch (error) {
             if (this.pendingActiveTabId === tab.id)
                 this.pendingActiveTabId = undefined;
+            this.removeTab(tab.id);
+            this.activeTabId = previousTabId;
+            if (previousTabId)
+                this.restoreInputState(previousTabId);
+            this.host.closeMenusForTabSwitch?.();
+            this.host.resetSessionView();
+            if (previousTabId)
+                this.restoreDeferredUserMessages(previousTabId);
+            this.host.loadSessionHistory();
+            this.host.setSessionStatus(previousRuntime.session);
+            this.host.setSessionActivity(this.sessionActivity(previousRuntime.session));
+            this.host.render();
+            throw error;
+        }
+        const existingTab = this.findTabForSession(newRuntime.session);
+        const targetTab = existingTab && existingTab.id !== tab.id ? existingTab : tab;
+        if (targetTab !== tab)
+            this.removeTab(tab.id);
+        this.activeTabId = targetTab.id;
+        this.pendingActiveTabId = targetTab.id;
+        this.clearTabAttention(targetTab);
+        this.updateTabFromSession(targetTab, newRuntime.session);
+        this.setRuntimeForTab(targetTab.id, newRuntime);
+        this.restoreInputState(targetTab.id);
+        this.host.resetSessionView();
+        this.restoreDeferredUserMessages(targetTab.id);
+        this.host.setSessionActivity("thinking");
+        this.host.render();
+        try {
+            await this.host.activateRuntime(newRuntime, { awaitExtensions: false });
+        }
+        finally {
+            if (this.pendingActiveTabId === targetTab.id)
+                this.pendingActiveTabId = undefined;
         }
         void this.saveTabs();
         this.scheduleProjectSessionRetention();
         this.host.resetSessionView();
-        this.restoreDeferredUserMessages(tab.id);
+        this.restoreDeferredUserMessages(targetTab.id);
         if (isEmptyStartupSession(newRuntime)) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: createStartupInfoMessage(newRuntime) });
         }
@@ -306,27 +354,50 @@ export class AppTabsController {
         const previousRuntime = runtime;
         this.host.setStatus("opening session tab");
         this.host.render();
+        const tab = {
+            id: createId("tab"),
+            title: basename(resolvedSessionPath, extname(resolvedSessionPath)) || "loading",
+            titlePlaceholder: "loading",
+            status: "active",
+            activity: "thinking",
+            sessionPath: resolvedSessionPath,
+        };
+        this.tabItems.push(tab);
+        this.activeTabId = tab.id;
+        this.pendingActiveTabId = tab.id;
+        this.clearTabAttention(tab);
+        this.restoreInputState(tab.id);
+        this.host.closeMenusForTabSwitch?.();
+        this.host.resetSessionView();
+        this.restoreDeferredUserMessages(tab.id);
+        this.host.setSessionActivity("thinking");
+        this.host.render();
         let newRuntime;
         try {
             newRuntime = await this.host.createRuntimeForSession(resolvedSessionPath);
         }
         catch {
+            this.pendingActiveTabId = undefined;
+            this.removeTab(tab.id);
+            this.activeTabId = previousTabId;
+            if (previousTabId)
+                this.restoreInputState(previousTabId);
+            this.host.closeMenusForTabSwitch?.();
+            this.host.resetSessionView();
+            if (previousTabId)
+                this.restoreDeferredUserMessages(previousTabId);
+            this.host.loadSessionHistory();
             this.host.showToast("Could not open session tab", "warning");
             this.host.setSessionStatus(previousRuntime.session);
+            this.host.setSessionActivity(this.sessionActivity(previousRuntime.session));
             this.host.render();
             return false;
         }
-        const tab = this.tabFromSession(newRuntime.session, { titlePlaceholder: "loading" });
-        this.tabItems.push(tab);
-        this.activeTabId = tab.id;
-        this.pendingActiveTabId = tab.id;
-        this.clearTabAttention(tab);
         this.updateTabFromSession(tab, newRuntime.session);
         this.setRuntimeForTab(tab.id, newRuntime);
-        this.restoreInputState(tab.id);
-        this.host.closeMenusForTabSwitch?.();
+        this.host.render();
         try {
-            await this.host.activateRuntime(newRuntime);
+            await this.host.activateRuntime(newRuntime, { awaitExtensions: false });
         }
         catch {
             this.pendingActiveTabId = undefined;
@@ -337,7 +408,7 @@ export class AppTabsController {
             this.host.closeMenusForTabSwitch?.();
             if (this.host.runtime() !== previousRuntime) {
                 try {
-                    await this.host.activateRuntime(previousRuntime);
+                    await this.host.activateRuntime(previousRuntime, { awaitExtensions: false });
                 }
                 catch {
                     // Keep the best available runtime below and surface the switch failure.
@@ -362,6 +433,7 @@ export class AppTabsController {
         this.setRuntimeForTab(tab.id, newRuntime);
         this.restoreInputState(tab.id);
         void this.saveTabs();
+        this.scheduleTabPrewarm();
         await this.loadActiveSessionHistory(newRuntime);
         return true;
     }
@@ -435,8 +507,12 @@ export class AppTabsController {
             this.inputStatesByTabId.set(tab.id, this.inputStateFromText(result.selectedText));
         this.restoreInputState(tab.id);
         this.host.closeMenusForTabSwitch?.();
+        this.host.resetSessionView();
+        this.restoreDeferredUserMessages(tab.id);
+        this.host.setSessionActivity("thinking");
+        this.host.render();
         try {
-            await this.host.activateRuntime(forkRuntime);
+            await this.host.activateRuntime(forkRuntime, { awaitExtensions: false });
         }
         catch {
             this.pendingActiveTabId = undefined;
@@ -447,7 +523,7 @@ export class AppTabsController {
             this.host.closeMenusForTabSwitch?.();
             if (this.host.runtime() !== previousRuntime) {
                 try {
-                    await this.host.activateRuntime(previousRuntime);
+                    await this.host.activateRuntime(previousRuntime, { awaitExtensions: false });
                 }
                 catch {
                     // Keep the best available runtime below and surface the switch failure.
@@ -472,6 +548,7 @@ export class AppTabsController {
         this.restoreInputState(tab.id);
         void this.saveTabs();
         this.scheduleProjectSessionRetention();
+        this.scheduleTabPrewarm();
         await this.loadActiveSessionHistory(forkRuntime);
         this.host.addEntry({ id: createId("system"), kind: "system", text: `Forked from entry ${entryId} in a new tab.` });
         this.host.setSessionStatus(forkRuntime.session);
@@ -520,7 +597,7 @@ export class AppTabsController {
             targetRuntime = await this.runtimeForTab(target);
             if (!targetRuntime)
                 throw new Error("Could not load tab runtime");
-            await this.host.activateRuntime(targetRuntime);
+            await this.host.activateRuntime(targetRuntime, { awaitExtensions: false });
         }
         catch {
             this.pendingActiveTabId = undefined;
@@ -534,7 +611,7 @@ export class AppTabsController {
             this.host.closeMenusForTabSwitch?.();
             if (this.host.runtime() !== previousRuntime) {
                 try {
-                    await this.host.activateRuntime(previousRuntime);
+                    await this.host.activateRuntime(previousRuntime, { awaitExtensions: false });
                 }
                 catch {
                     // Keep the best available runtime below and surface the switch failure.
@@ -558,6 +635,7 @@ export class AppTabsController {
         this.setRuntimeForTab(target.id, targetRuntime);
         this.restoreInputState(target.id);
         void this.saveTabs();
+        this.scheduleTabPrewarm();
         await this.loadActiveSessionHistory(targetRuntime);
     }
     async closeTab(tabId) {
@@ -605,7 +683,7 @@ export class AppTabsController {
         const nextRuntime = await this.runtimeForTab(nextTab);
         if (!nextRuntime)
             return;
-        await this.host.activateRuntime(nextRuntime);
+        await this.host.activateRuntime(nextRuntime, { awaitExtensions: false });
         this.tabItems.splice(index, 1);
         this.deleteRuntimeForTab(tabId);
         this.inputStatesByTabId.delete(tabId);
@@ -619,6 +697,7 @@ export class AppTabsController {
         this.host.closeMenusForTabSwitch?.();
         void this.host.disposeRuntime(runtime);
         void this.saveTabs();
+        this.scheduleTabPrewarm();
         await this.loadActiveSessionHistory(nextRuntime);
     }
     async replaceLastTabWithNewSession(tabId) {
@@ -739,11 +818,16 @@ export class AppTabsController {
     }
     deleteRuntimeForTab(tabId) {
         this.runtimesByTabId.delete(tabId);
+        this.runtimeLoadsByTabId.delete(tabId);
+        this.clearRuntimeRefreshTimers(tabId);
         const subscription = this.runtimeSubscriptionsByTabId.get(tabId);
         subscription?.unsubscribe();
         this.runtimeSubscriptionsByTabId.delete(tabId);
     }
     clearRuntimeSubscriptions() {
+        for (const tabId of this.runtimeRefreshTimersByTabId.keys()) {
+            this.clearRuntimeRefreshTimers(tabId);
+        }
         for (const subscription of this.runtimeSubscriptionsByTabId.values()) {
             subscription.unsubscribe();
         }
@@ -755,6 +839,9 @@ export class AppTabsController {
             return;
         existing?.unsubscribe();
         const unsubscribe = runtime.session.subscribe((event) => {
+            if (this.shouldScheduleDelayedSyncForRuntimeEvent(event)) {
+                this.scheduleDelayedRuntimeSync(tabId, runtime);
+            }
             if (!this.shouldSyncTabFromRuntimeEvent(event))
                 return;
             this.syncTabFromObservedRuntime(tabId, runtime);
@@ -768,6 +855,35 @@ export class AppTabsController {
             || event.type === "compaction_start"
             || event.type === "compaction_end";
     }
+    shouldScheduleDelayedSyncForRuntimeEvent(event) {
+        return event.type === "agent_end"
+            || event.type === "turn_end"
+            || event.type === "compaction_end";
+    }
+    scheduleDelayedRuntimeSync(tabId, runtime) {
+        this.clearRuntimeRefreshTimers(tabId);
+        for (const delayMs of [0, 100, 500, 1500, 3000]) {
+            const timer = setTimeout(() => {
+                this.runtimeRefreshTimersByTabId.get(tabId)?.delete(timer);
+                this.syncTabFromObservedRuntime(tabId, runtime);
+            }, delayMs);
+            timer.unref?.();
+            let timers = this.runtimeRefreshTimersByTabId.get(tabId);
+            if (!timers) {
+                timers = new Set();
+                this.runtimeRefreshTimersByTabId.set(tabId, timers);
+            }
+            timers.add(timer);
+        }
+    }
+    clearRuntimeRefreshTimers(tabId) {
+        const timers = this.runtimeRefreshTimersByTabId.get(tabId);
+        if (!timers)
+            return;
+        for (const timer of timers)
+            clearTimeout(timer);
+        this.runtimeRefreshTimersByTabId.delete(tabId);
+    }
     syncTabFromObservedRuntime(tabId, runtime) {
         const tab = this.tabItems.find((item) => item.id === tabId);
         if (!tab) {
@@ -827,13 +943,32 @@ export class AppTabsController {
         const existing = this.runtimesByTabId.get(tab.id);
         if (existing)
             return existing;
+        const loading = this.runtimeLoadsByTabId.get(tab.id);
+        if (loading)
+            return await loading;
         if (!tab.sessionPath) {
             this.host.showToast("Tab has no persisted session path", "warning");
             return undefined;
         }
-        const runtime = await this.host.createRuntimeForSession(tab.sessionPath);
-        this.setRuntimeForTab(tab.id, runtime);
-        return runtime;
+        const expectedPath = resolve(tab.sessionPath);
+        const pending = (async () => {
+            const runtime = await this.host.createRuntimeForSession(expectedPath);
+            const liveTab = this.tabItems.find((item) => item.id === tab.id);
+            if (!liveTab || !liveTab.sessionPath || resolve(liveTab.sessionPath) !== expectedPath) {
+                void this.host.disposeRuntime(runtime);
+                return undefined;
+            }
+            this.setRuntimeForTab(tab.id, runtime);
+            return runtime;
+        })();
+        this.runtimeLoadsByTabId.set(tab.id, pending);
+        try {
+            return await pending;
+        }
+        finally {
+            if (this.runtimeLoadsByTabId.get(tab.id) === pending)
+                this.runtimeLoadsByTabId.delete(tab.id);
+        }
     }
     findTabForSession(session, options = {}) {
         const sessionPath = this.sessionPath(session);
@@ -1146,6 +1281,38 @@ export class AppTabsController {
             void this.cleanupOldProjectSessions();
         }, 0);
     }
+    scheduleTabPrewarm() {
+        if (this.host.options.noSession || this.prewarmScheduled || this.prewarmRunning)
+            return;
+        this.prewarmScheduled = true;
+        setTimeout(() => {
+            this.prewarmScheduled = false;
+            void this.prewarmTabs();
+        }, 0);
+    }
+    async prewarmTabs() {
+        if (this.prewarmRunning || this.pendingActiveTabId || !this.host.isRunning())
+            return;
+        this.prewarmRunning = true;
+        try {
+            let warmed = 0;
+            for (const tab of this.tabItems) {
+                if (warmed >= BACKGROUND_PREWARM_TAB_LIMIT)
+                    break;
+                if (tab.id === this.activeTabId || !tab.sessionPath)
+                    continue;
+                if (this.runtimesByTabId.has(tab.id) || this.runtimeLoadsByTabId.has(tab.id))
+                    continue;
+                const runtime = await this.runtimeForTab(tab).catch(() => undefined);
+                if (!runtime)
+                    continue;
+                warmed += 1;
+            }
+        }
+        finally {
+            this.prewarmRunning = false;
+        }
+    }
     async cleanupOldProjectSessions() {
         if (this.retentionCleanupRunning)
             return;

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

@@ -24,6 +24,8 @@ export declare class AppTerminalController {
     private terminalEnabled;
     private interactiveSuspended;
     private stopPromise;
+    private readonly enterInteractiveSequence;
+    private readonly exitInteractiveSequence;
     constructor(host: AppTerminalControllerHost);
     isSuspended(): boolean;
     enableTerminal(): void;

package/dist/app/terminal/terminal-controller.js

@@ -1,10 +1,12 @@
 import { ANSI_RESET } from "../../theme.js";
-import { DISABLE_BRACKETED_PASTE, DISABLE_TERMINAL_KEY_REPORTING, DISABLE_TERMINAL_WRAP, CLEAR_TERMINAL, ENABLE_BRACKETED_PASTE, ENABLE_TERMINAL_KEY_REPORTING, ENABLE_TERMINAL_WRAP, HIDE_CURSOR, RUNTIME_DISPOSE_GRACE_MS, SHOW_CURSOR, } from "../constants.js";
+import { DISABLE_BRACKETED_PASTE, DISABLE_TERMINAL_KEY_REPORTING, DISABLE_TERMINAL_WRAP, CLEAR_TERMINAL, ENABLE_BRACKETED_PASTE, ENABLE_TERMINAL_KEY_REPORTING, ENABLE_TERMINAL_WRAP, HIDE_CURSOR, RESET_TERMINAL_VIEWPORT_STATE, RUNTIME_DISPOSE_GRACE_MS, SHOW_CURSOR, } from "../constants.js";
 export class AppTerminalController {
     host;
     terminalEnabled = false;
     interactiveSuspended = false;
     stopPromise;
+    enterInteractiveSequence = `${ANSI_RESET}${RESET_TERMINAL_VIEWPORT_STATE}${CLEAR_TERMINAL}\x1b[?1049h${RESET_TERMINAL_VIEWPORT_STATE}${CLEAR_TERMINAL}${ENABLE_TERMINAL_KEY_REPORTING}${ENABLE_BRACKETED_PASTE}${DISABLE_TERMINAL_WRAP}\x1b[?1002h\x1b[?1006h${HIDE_CURSOR}`;
+    exitInteractiveSequence = `${ANSI_RESET}${RESET_TERMINAL_VIEWPORT_STATE}${DISABLE_TERMINAL_KEY_REPORTING}${DISABLE_BRACKETED_PASTE}${ENABLE_TERMINAL_WRAP}\x1b[?1006l\x1b[?1002l\x1b[?1049l${SHOW_CURSOR}`;
     constructor(host) {
         this.host = host;
     }
@@ -19,7 +21,7 @@ export class AppTerminalController {
         process.stdin.resume();
         process.stdin.on("data", this.onInputData);
         process.stdout.on("resize", this.onResize);
-        process.stdout.write(`${ANSI_RESET}${CLEAR_TERMINAL}\x1b[?1049h${CLEAR_TERMINAL}${ENABLE_TERMINAL_KEY_REPORTING}${ENABLE_BRACKETED_PASTE}${DISABLE_TERMINAL_WRAP}\x1b[?1002h\x1b[?1006h${HIDE_CURSOR}`);
+        process.stdout.write(this.enterInteractiveSequence);
         process.on("exit", this.restoreTerminal);
     }
     async stop() {
@@ -66,7 +68,7 @@ export class AppTerminalController {
             return;
         this.terminalEnabled = false;
         this.interactiveSuspended = false;
-        process.stdout.write(`${ANSI_RESET}${DISABLE_TERMINAL_KEY_REPORTING}${DISABLE_BRACKETED_PASTE}${ENABLE_TERMINAL_WRAP}\x1b[?1006l\x1b[?1002l\x1b[?1049l${SHOW_CURSOR}`);
+        process.stdout.write(this.exitInteractiveSequence);
         if (process.stdin.isTTY)
             process.stdin.setRawMode(false);
     };
@@ -77,7 +79,7 @@ export class AppTerminalController {
         process.stdin.off("data", this.onInputData);
         process.stdin.pause();
         process.stdout.off("resize", this.onResize);
-        process.stdout.write(`${ANSI_RESET}${DISABLE_TERMINAL_KEY_REPORTING}${DISABLE_BRACKETED_PASTE}${ENABLE_TERMINAL_WRAP}\x1b[?1006l\x1b[?1002l\x1b[?1049l${SHOW_CURSOR}`);
+        process.stdout.write(this.exitInteractiveSequence);
         if (process.stdin.isTTY)
             process.stdin.setRawMode(false);
     }
@@ -91,7 +93,7 @@ export class AppTerminalController {
         process.stdin.on("data", this.onInputData);
         process.stdout.on("resize", this.onResize);
         this.host.resetRenderOutputBuffer();
-        process.stdout.write(`${ANSI_RESET}${CLEAR_TERMINAL}\x1b[?1049h${CLEAR_TERMINAL}${ENABLE_TERMINAL_KEY_REPORTING}${ENABLE_BRACKETED_PASTE}${DISABLE_TERMINAL_WRAP}\x1b[?1002h\x1b[?1006h${HIDE_CURSOR}`);
+        process.stdout.write(this.enterInteractiveSequence);
         this.host.render();
     }
     async stopInternal() {

package/dist/schemas/pi-tools-suite-schema.d.ts

@@ -10,6 +10,7 @@ export declare const PiToolsSuiteConfigSchema: Type.TObject<{
     enabled: Type.TOptional<Type.TBoolean>;
     disabledModules: Type.TOptional<Type.TArray<Type.TString>>;
     todoThinking: Type.TOptional<Type.TBoolean>;
+    lookupModel: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
     terminalBell: Type.TOptional<Type.TObject<{
         sound: Type.TOptional<Type.TBoolean>;
     }>>;
@@ -170,6 +171,8 @@ export declare const PiToolsSuiteConfigSchema: Type.TObject<{
             languageIdByExtension: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
             startupTimeoutMs: Type.TOptional<Type.TNumber>;
             diagnosticsWaitMs: Type.TOptional<Type.TNumber>;
+            pullDiagnostics: Type.TOptional<Type.TBoolean>;
+            waitForPublishDiagnostics: Type.TOptional<Type.TBoolean>;
             initializationOptions: Type.TOptional<Type.TUnknown>;
             settings: Type.TOptional<Type.TUnknown>;
         }>>>;

package/dist/schemas/pi-tools-suite-schema.js

@@ -190,6 +190,8 @@ const LspServerConfig = Type.Object({
     languageIdByExtension: Type.Optional(Type.Record(Type.String(), Type.String(), { description: "File extension → language ID mapping, e.g. {'.ts': 'typescript'}." })),
     startupTimeoutMs: Type.Optional(Type.Number({ description: "Server startup timeout in ms.", minimum: 1000 })),
     diagnosticsWaitMs: Type.Optional(Type.Number({ description: "Wait time for diagnostics after file change.", minimum: 0 })),
+    pullDiagnostics: Type.Optional(Type.Boolean({ description: "When false, skip textDocument/diagnostic pull requests and rely on published diagnostics. Useful for servers where pull diagnostics is slow or incomplete." })),
+    waitForPublishDiagnostics: Type.Optional(Type.Boolean({ description: "When false, do not wait for a fresh textDocument/publishDiagnostics notification after file change. diagnosticsWaitMs still bounds the wait when enabled." })),
     initializationOptions: Type.Optional(Type.Unknown({ description: "LSP initialization options passed to the server." })),
     settings: Type.Optional(Type.Unknown({ description: "LSP workspace/settings passed to the server." })),
 }, { description: "LSP server configuration." });
@@ -204,6 +206,7 @@ export const PiToolsSuiteConfigSchema = Type.Object({
     enabled: Type.Optional(Type.Boolean({ description: "Enable or disable the entire pi-tools-suite extension." })),
     disabledModules: Type.Optional(Type.Array(Type.String(), { description: "List of disabled module names (e.g. ['lsp', 'prompt-commands'])." })),
     todoThinking: Type.Optional(Type.Boolean({ description: "Enable per-todo thinking levels and automatic thinking switch/restore when tasks become in-progress/completed." })),
+    lookupModel: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Vision-capable provider/model used by GLM's lookup tool; unset or null disables lookup." })),
     terminalBell: Type.Optional(TerminalBellConfig),
     dcp: Type.Optional(DcpConfig),
     asyncSubagents: Type.Optional(AsyncSubagentsConfig),

package/dist/theme.d.ts

@@ -13,6 +13,9 @@ export type Theme = {
         inputForeground: string;
         inputBackground: string;
         inputBorder: string;
+        inputBorderWidgetBackground: string;
+        tabBorder: string;
+        assistantMessageBackground: string;
         userMessageBackground: string;
         inputCursorBackground: string;
         popupForeground: string;