pi-ui-extend 1.0.41 → 1.0.45

package/dist/app/rendering/popup-menu-renderer.js

@@ -1,7 +1,7 @@
 import { colorLine } from "../../theme.js";
 import { stringDisplayWidth } from "../../terminal-width.js";
 import { resolveColor, resolveModelColor } from "../../config.js";
-import { SLASH_COMMAND_DESCRIPTION_COLUMN, THINKING_LEVELS, } from "../constants.js";
+import { SLASH_COMMAND_DESCRIPTION_COLUMN, } from "../constants.js";
 import { APP_ICONS } from "../icons.js";
 import { ellipsizeDisplay, padOrTrimPlain, sanitizeText } from "./render-text.js";
 import { modelProviderThemeColor, thinkingLevelThemeColor } from "./status-line-renderer.js";
@@ -96,8 +96,8 @@ export class PopupMenuRenderer {
         }
         return lines;
     }
-    renderModelMenu(width, menu) {
-        const lines = [this.popupMenuHeader("Select model", width)];
+    renderModelMenu(width, menu, state) {
+        const lines = [this.popupMenuHeader(state.visibilityMode ? "Manage visible models" : "Select model & thinking", width)];
         const visibleItems = menu.visibleItems();
         if (!this.hasPopupActionItems(menu.items)) {
             lines.push({
@@ -106,37 +106,55 @@ export class PopupMenuRenderer {
             });
         }
         for (const item of visibleItems) {
-            const marker = item.selected ? "▶ " : "  ";
-            const text = `${marker}${this.labelDescriptionText(item.label, item.description, width - 2)}`;
+            const selectionMarker = item.selected ? "▶ " : "  ";
+            const visibilityMarker = state.visibilityMode ? `${item.value.visible === false ? "○" : APP_ICONS.check} ` : "";
+            const marker = `${selectionMarker}${visibilityMarker}`;
+            const text = `${marker}${this.labelDescriptionText(item.label, item.description, width - marker.length)}`;
             lines.push({
                 text,
                 variant: this.selectableItemVariant(item.value),
-                segments: [...this.modelMenuItemSegments(item.value), ...this.itemHighlightSegments(item, text)],
+                segments: [
+                    ...this.modelMenuItemSegments(item.value, marker.length),
+                    ...this.itemHighlightSegments(item, text, marker.length),
+                ],
                 target: { kind: "popup-menu", index: item.index },
             });
         }
-        return lines;
-    }
-    renderThinkingMenu(width, menu) {
-        const lines = [this.popupMenuHeader("Thinking level", width)];
-        const visibleItems = menu.visibleItems();
-        if (!this.hasPopupActionItems(menu.items)) {
-            lines.push({ text: "  No matching thinking levels", variant: "muted" });
+        if (state.visibilityMode && menu.selectedItem()) {
+            const selected = menu.selectedItem().value;
+            lines.push({
+                text: selected.current
+                    ? "  Current model stays visible until another model is selected"
+                    : "  Enter toggles whether this model appears in model pickers",
+                variant: "muted",
+            });
+            lines.push({
+                text: "  Clear all",
+                variant: "error",
+                target: { kind: "model-visibility-clear" },
+            });
+            lines.push({ text: "  ↑/↓ model · Enter show/hide · Shift+Tab select", variant: "muted" });
         }
-        for (const item of visibleItems) {
-            const marker = item.selected ? "▶ " : "  ";
-            const text = `${marker}${this.labelDescriptionText(item.label, item.description, width - 2)}`;
+        else if (menu.selectedItem()) {
+            const thinkingPrefix = "  Thinking  ← ";
+            const thinkingSuffix = " →";
             lines.push({
-                text,
-                variant: this.selectableItemVariant(item.value),
-                segments: this.thinkingMenuItemSegments(item.value),
-                target: { kind: "popup-menu", index: item.index },
+                text: `${thinkingPrefix}${state.thinkingLevel}${thinkingSuffix}`,
+                variant: "normal",
+                segments: [{
+                        start: thinkingPrefix.length,
+                        end: thinkingPrefix.length + state.thinkingLevel.length,
+                        foreground: thinkingLevelThemeColor(state.thinkingLevel, this.host.theme.colors, state.availableThinkingLevels),
+                        bold: true,
+                    }],
             });
+            lines.push({ text: "  ↑/↓ model · ←/→ thinking · Enter apply · Shift+Tab manage", variant: "muted" });
         }
         return lines;
     }
     renderResumeMenu(width, menu, state) {
-        const title = this.host.resumeLoading ? `Resume session ${APP_ICONS.timerSand}` : "Resume session";
+        const titleBase = state.draft ? "Open a conversation" : "Resume session";
+        const title = this.host.resumeLoading ? `${titleBase} ${APP_ICONS.timerSand}` : titleBase;
         const lines = [this.popupMenuHeader(title, width)];
         const visibleItems = menu.visibleItems();
         if (!this.host.resumeLoading && !this.hasPopupActionItems(menu.items)) {
@@ -261,16 +279,7 @@ export class PopupMenuRenderer {
     selectableItemVariant(value) {
         return value.current ? "muted" : "normal";
     }
-    thinkingMenuItemSegments(value) {
-        const markerOffset = 2; // "▶ " or "  "
-        return [{
-                start: markerOffset,
-                end: markerOffset + value.level.length,
-                foreground: thinkingLevelThemeColor(value.level, this.host.theme.colors, this.availableThinkingLevels()),
-            }];
-    }
-    modelMenuItemSegments(value) {
-        const markerOffset = 2; // "▶ " or "  "
+    modelMenuItemSegments(value, markerOffset = 2) {
         return [{
                 start: markerOffset,
                 end: markerOffset + value.ref.length,
@@ -285,10 +294,6 @@ export class PopupMenuRenderer {
             ? resolveColor(configuredColor, this.host.theme.colors)
             : modelProviderThemeColor(value.model.provider, this.host.theme.colors);
     }
-    availableThinkingLevels() {
-        const levels = this.host.session?.getAvailableThinkingLevels();
-        return Array.isArray(levels) && levels.length > 0 ? levels.map(String) : [...THINKING_LEVELS];
-    }
     queueMessageItemVariant(value) {
         return value === "cancel" ? "error" : "normal";
     }
@@ -301,8 +306,8 @@ export class PopupMenuRenderer {
             ...this.descriptionHighlightSegments(item.description, item.descriptionHighlightRanges ?? item.value.descriptionHighlightRanges ?? [], text),
         ];
     }
-    itemHighlightSegments(item, text) {
-        return this.highlightSegments(item.labelHighlightRanges ?? [], text, 2);
+    itemHighlightSegments(item, text, markerOffset = 2) {
+        return this.highlightSegments(item.labelHighlightRanges ?? [], text, markerOffset);
     }
     highlightSegments(ranges, text, markerOffset) {
         if (ranges.length === 0)

package/dist/app/rendering/render-controller.js

@@ -52,6 +52,7 @@ export class AppRenderController {
         const defaultOverlayLines = menuLines.slice(0, Math.max(0, inputSeparatorRow - 1));
         const underTabsOverlayStartRow = Math.min(rows, topReservedRows + 1);
         const underTabsOverlayLines = menuLines.slice(0, Math.max(0, statusRow - underTabsOverlayStartRow));
+        const draftSurfaceLines = menuLines.slice(0, Math.max(0, bodyHeight));
         const { lines: visible, metrics: scrollMetrics } = this.deps.scrollController.conversationView(columns, bodyHeight);
         const conversationColumns = Math.max(1, Math.min(columns, scrollMetrics.viewportColumns));
         this.deps.mouseController.syncConversationSelectionForRender(scrollMetrics.start, bodyHeight, topReservedRows, conversationColumns);
@@ -104,9 +105,27 @@ export class AppRenderController {
                 .filter((target) => target.kind === "new-tab")
                 .map((target) => ({ ...target, row: tabRow })));
         }
+        const draftSurfaceMenu = popupMenuPlacement === "draft-surface"
+            ? this.deps.popupMenus.getActivePopupMenu(activePopupMenu ?? this.deps.popupMenus.syncActivePopupMenu() ?? "slash")
+            : undefined;
         for (let index = 0; index < bodyHeight; index += 1) {
-            const rendered = visible[index];
             const row = toScreenRow(index + 1);
+            if (draftSurfaceMenu) {
+                const line = draftSurfaceLines[index];
+                if (line) {
+                    const fallbackTarget = { kind: "popup-menu", index: draftSurfaceMenu.selectedIndex };
+                    this.deps.mouseController.renderedTargets.set(row, line.target ?? fallbackTarget);
+                    this.deps.mouseController.renderedRowTexts.set(row, this.deps.popupMenus.overlayPlainText(line, columns));
+                    setRenderedBackground(row, line.backgroundOverride);
+                    appendFrameOutput(row, this.renderFrameRow(row, this.deps.popupMenus.styleOverlayLine(row, line, columns)));
+                }
+                else {
+                    this.deps.mouseController.renderedRowTexts.set(row, "");
+                    appendFrameOutput(row, this.renderFrameRow(row, this.deps.screenStyler.styleBaseLine(row, undefined, columns)));
+                }
+                continue;
+            }
+            const rendered = visible[index];
             if (rendered?.target)
                 this.deps.mouseController.renderedTargets.set(row, rendered.target);
             if (rendered?.imageTargets?.length)
@@ -117,7 +136,9 @@ export class AppRenderController {
             setRenderedBackground(row, rendered?.backgroundOverride);
             appendFrameOutput(row, this.renderFrameRow(row, this.deps.screenStyler.styleBaseLine(row, rendered, conversationColumns)));
         }
-        const loadingConversationOverlay = this.renderConversationLoadingOverlay(this.deps.loadingConversationOverlayText?.(), conversationColumns, topReservedRows, bodyHeight);
+        const loadingConversationOverlay = popupMenuPlacement === "draft-surface"
+            ? undefined
+            : this.renderConversationLoadingOverlay(this.deps.loadingConversationOverlayText?.(), conversationColumns, topReservedRows, bodyHeight);
         if (loadingConversationOverlay) {
             this.deps.mouseController.renderedRowTexts.set(loadingConversationOverlay.row, loadingConversationOverlay.text);
             appendFrameOutput(loadingConversationOverlay.row, this.renderFrameRow(loadingConversationOverlay.row, loadingConversationOverlay.output));

package/dist/app/rendering/status-line-renderer.d.ts

@@ -7,6 +7,10 @@ export type StatusLineRendererHost = {
     readonly theme: Theme;
     readonly screenStyler: ScreenStyler;
     readonly session: AgentSession | undefined;
+    draftModelStatus?(): {
+        modelLabel: string;
+        thinkingLabel: string;
+    } | undefined;
     readonly modelColors?: ModelColorsConfig;
     readonly sessionActivity: SessionActivity;
     readonly statusDotBright: boolean;
@@ -76,6 +80,7 @@ export declare class StatusLineRenderer {
     private pushContextBarSegments;
     private modelUsageProgressColor;
     private modelProviderColor;
+    private modelRefColor;
     private thinkingLevelColor;
     private statusThinkingDisplayLabel;
     private availableThinkingLevels;

package/dist/app/rendering/status-line-renderer.js

@@ -180,8 +180,16 @@ export class StatusLineRenderer {
     }
     modelTarget(statusText, row) {
         const session = this.host.session;
-        if (!session)
-            return undefined;
+        if (!session) {
+            const draft = this.host.draftModelStatus?.();
+            if (!draft)
+                return undefined;
+            const marker = `${draft.modelLabel} ${APP_ICONS.lightbulb} ${draft.thinkingLabel}`;
+            const startIndex = statusText.indexOf(marker);
+            if (startIndex < 0)
+                return undefined;
+            return { row, startColumn: startIndex + 1, endColumn: startIndex + draft.modelLabel.length + 1 };
+        }
         const label = this.host.statusModelLabel(session);
         const marker = `${label} ${this.statusThinkingDisplayLabel(session)} `;
         const startIndex = statusText.indexOf(marker);
@@ -191,8 +199,17 @@ export class StatusLineRenderer {
     }
     thinkingTarget(statusText, row) {
         const session = this.host.session;
-        if (!session)
-            return undefined;
+        if (!session) {
+            const draft = this.host.draftModelStatus?.();
+            if (!draft)
+                return undefined;
+            const marker = `${APP_ICONS.lightbulb} ${draft.thinkingLabel}`;
+            const markerIndex = statusText.indexOf(marker);
+            if (markerIndex < 0)
+                return undefined;
+            const startIndex = markerIndex + APP_ICONS.lightbulb.length + 1;
+            return { row, startColumn: startIndex + 1, endColumn: startIndex + draft.thinkingLabel.length + 1 };
+        }
         const label = this.statusThinkingDisplayLabel(session);
         const marker = ` ${label} ${this.host.formatContextUsagePercent(session)}`;
         const markerIndex = statusText.indexOf(marker);
@@ -327,8 +344,17 @@ export class StatusLineRenderer {
         if (layout.modelUsageLabel)
             this.pushModelUsageSegments(segments, statusText, layout.modelUsageLabel);
         const session = this.host.session;
-        if (!session)
+        if (!session) {
+            const draft = this.host.draftModelStatus?.();
+            if (!draft)
+                return segments;
+            const modelStart = statusText.indexOf(`${draft.modelLabel} ${APP_ICONS.lightbulb} ${draft.thinkingLabel}`);
+            this.pushSegment(segments, modelStart, draft.modelLabel.length, this.modelRefColor(draft.modelLabel));
+            const thinkingMarkerStart = statusText.indexOf(`${APP_ICONS.lightbulb} ${draft.thinkingLabel}`);
+            const thinkingStart = thinkingMarkerStart >= 0 ? thinkingMarkerStart + APP_ICONS.lightbulb.length + 1 : -1;
+            this.pushSegment(segments, thinkingStart, draft.thinkingLabel.length, this.thinkingLevelColor(draft.thinkingLabel));
             return segments;
+        }
         const modelLabel = this.host.statusModelLabel(session);
         const thinkingLabel = this.host.statusThinkingLabel(session);
         const thinkingDisplayLabel = this.statusThinkingDisplayLabel(session);
@@ -511,6 +537,16 @@ export class StatusLineRenderer {
             ? resolveColor(configuredColor, this.host.theme.colors)
             : modelProviderThemeColor(provider, this.host.theme.colors);
     }
+    modelRefColor(ref) {
+        const slash = ref.indexOf("/");
+        const provider = slash > 0 ? ref.slice(0, slash) : undefined;
+        if (!provider)
+            return this.host.theme.colors.selectionForeground;
+        const configuredColor = this.host.modelColors ? resolveModelColor(ref, this.host.modelColors) : undefined;
+        return configuredColor
+            ? resolveColor(configuredColor, this.host.theme.colors)
+            : modelProviderThemeColor(provider, this.host.theme.colors);
+    }
     thinkingLevelColor(label) {
         return thinkingLevelThemeColor(label, this.host.theme.colors, this.availableThinkingLevels());
     }

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

@@ -29,13 +29,15 @@ export class TabLineRenderer {
         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 naturalButtons = tabs.map((tab) => this.buttonLayout(tab, undefined, tabs.length > 1 || tab.draft !== true));
         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 buttons = buttonMaxWidth === undefined
+            ? naturalButtons
+            : tabs.map((tab) => this.buttonLayout(tab, buttonMaxWidth, tabs.length > 1 || tab.draft !== true));
         const segments = [];
         const targets = [];
         const separatorColumns = [];
@@ -61,15 +63,17 @@ export class TabLineRenderer {
             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)),
-            });
+            if (button.closable) {
+                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,
@@ -142,31 +146,33 @@ export class TabLineRenderer {
         }
         return chars.join("");
     }
-    buttonLayout(tab, maxWidth) {
+    buttonLayout(tab, maxWidth, closable = true) {
         const statusText = this.statusIndicatorIcon(tab);
         const prefix = `${statusText} `;
-        const suffix = ` ${APP_ICONS.close}`;
+        const suffix = closable ? ` ${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);
+            return this.buttonLayoutFromText(naturalText, 0, statusText.length, closable);
         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);
+        if (titleWidth <= 0) {
+            return this.buttonLayoutFromText(ellipsizeDisplay(`${statusText}${closable ? APP_ICONS.close : ""}`, maxWidth), 0, statusText.length, closable);
+        }
+        return this.buttonLayoutFromText(`${prefix}${ellipsizeDisplay(title, titleWidth)}${suffix}`, 0, statusText.length, closable);
     }
     displayTitle(tab) {
         return tab.isFork ? `${APP_ICONS.fork}${tab.title}` : tab.title;
     }
-    buttonLayoutFromText(text, statusStart, statusLength) {
-        const closeStart = Math.max(0, text.lastIndexOf(APP_ICONS.close));
+    buttonLayoutFromText(text, statusStart, statusLength, closable) {
+        const closeStart = closable ? Math.max(0, text.lastIndexOf(APP_ICONS.close)) : text.length;
         return {
             text,
             statusStart,
             statusEnd: Math.min(text.length, statusStart + statusLength),
             closeStart,
-            closeEnd: closeStart + APP_ICONS.close.length,
+            closeEnd: closable ? closeStart + APP_ICONS.close.length : closeStart,
+            closable,
         };
     }
     addButtonSegments(tab, button, textOffset, segments) {

package/dist/app/runtime.d.ts

@@ -1,6 +1,6 @@
 import { SessionManager, type EventBus, type AgentSessionRuntime, type AgentSessionServices, type LoadExtensionsResult, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { type PixConfig } from "../config.js";
-import type { AppOptions, ThinkingLevel } from "./types.js";
+import type { AppOptions, SessionModel, ThinkingLevel } from "./types.js";
 export type PiToolsSuiteInstallAction = "installed" | "already-installed" | "existing-kept" | "missing-source";
 export type PiToolsSuiteInstallResult = {
     action: PiToolsSuiteInstallAction;
@@ -28,6 +28,7 @@ export type BundledSkillsInstallOptions = {
 export declare function bundledQuestionExtensionPath(): string;
 export declare function bundledSessionTitleExtensionPath(): string;
 export declare function bundledTerminalBellExtensionPath(): string;
+export declare function bundledTelegramConnectorExtensionPath(): string;
 export declare function piToolsSuiteExtensionSourcePath(): string;
 export declare function piToolsSuiteExtensionInstallPath(agentDir?: string): string;
 export declare function bundledSkillsSourcePath(): string;
@@ -44,8 +45,18 @@ export type CreatePixRuntimeOptions = {
 };
 type RuntimeSessionManagerModelState = Pick<SessionManager, "getEntries" | "getBranch">;
 export declare function resolvePixRuntimeModelRef(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config?: PixConfig): string | undefined;
+export declare function resolvePixRuntimeModelRefs(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config?: PixConfig): string[];
 export declare function resolvePixRuntimeInitialThinkingLevel(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config: PixConfig): ThinkingLevel | undefined;
 export declare function resolveSessionModelRefFromTail(entries: readonly SessionEntry[]): string | undefined;
 export declare function refreshPixModelRuntimeForStartup(modelRuntime: Pick<AgentSessionServices["modelRuntime"], "refresh">): Promise<void>;
+/**
+ * Build the model catalogue used by UI-only draft tabs without allocating an
+ * AgentSession or session file. Drafts can therefore expose model selection
+ * while preserving lazy session materialization until the first prompt.
+ */
+export declare function createPixDraftModelCatalog(options: {
+    cwd: string;
+    agentDir?: string;
+}): Promise<SessionModel[]>;
 export declare function createPixRuntime(options: AppOptions, runtimeOptions?: CreatePixRuntimeOptions): Promise<AgentSessionRuntime>;
 export {};

package/dist/app/runtime.js

@@ -1,9 +1,9 @@
 import { existsSync } from "node:fs";
-import { access, cp, lstat, mkdir, readdir, readlink, realpath, rm, symlink } from "node:fs/promises";
+import { access, cp, lstat, mkdir, readFile, readdir, readlink, realpath, rm, symlink } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, getAgentDir, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { loadPixConfig, resolveDefaultModelRef } from "../config.js";
 import { isThinkingLevel, parseModelRef, parseScopedModelRef } from "./model/model-ref.js";
 import { openLazySessionManager } from "./session/lazy-session-manager.js";
@@ -13,6 +13,7 @@ const BUNDLED_EXTENSIONS_DIR = resolve(dirname(fileURLToPath(import.meta.url)),
 const BUNDLED_QUESTION_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, BUNDLED_QUESTION_EXTENSION_NAME);
 const BUNDLED_SESSION_TITLE_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, "session-title");
 const BUNDLED_TERMINAL_BELL_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, "terminal-bell");
+const BUNDLED_TELEGRAM_CONNECTOR_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, "telegram-connector");
 const PI_TOOLS_SUITE_SOURCE_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../..", "external", PI_TOOLS_SUITE_EXTENSION_NAME);
 const BUNDLED_SKILLS_SOURCE_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../..", "skills");
 export function bundledQuestionExtensionPath() {
@@ -24,6 +25,9 @@ export function bundledSessionTitleExtensionPath() {
 export function bundledTerminalBellExtensionPath() {
     return BUNDLED_TERMINAL_BELL_EXTENSION_DIR;
 }
+export function bundledTelegramConnectorExtensionPath() {
+    return BUNDLED_TELEGRAM_CONNECTOR_EXTENSION_DIR;
+}
 export function piToolsSuiteExtensionSourcePath() {
     return PI_TOOLS_SUITE_SOURCE_DIR;
 }
@@ -60,8 +64,22 @@ export async function ensurePiToolsSuiteExtensionInstalled(options = {}) {
     if (await pathsReferToSameEntry(targetPath, sourcePath)) {
         return { action: "already-installed", sourcePath, targetPath };
     }
+    if (targetStat.isDirectory() && await isLegacyManagedPiToolsSuite(targetPath)) {
+        await rm(targetPath, { recursive: true, force: true });
+        await symlink(sourcePath, targetPath, extensionSymlinkType());
+        return { action: "installed", sourcePath, targetPath };
+    }
     return { action: "existing-kept", sourcePath, targetPath };
 }
+async function isLegacyManagedPiToolsSuite(targetPath) {
+    try {
+        const packageJson = JSON.parse(await readFile(join(targetPath, "package.json"), "utf8"));
+        return packageJson.name === "pi-tools-suite-local";
+    }
+    catch {
+        return false;
+    }
+}
 export async function ensureBundledSkillsInstalled(options = {}) {
     const sourcePath = resolve(options.sourcePath ?? bundledSkillsSourcePath());
     const targetPath = resolve(options.targetPath ?? bundledSkillsInstallPath(options.homeDir));
@@ -98,6 +116,7 @@ export function getBundledExtensionPaths() {
         bundledQuestionExtensionPath(),
         bundledSessionTitleExtensionPath(),
         bundledTerminalBellExtensionPath(),
+        bundledTelegramConnectorExtensionPath(),
     ].filter(extensionEntryExists);
 }
 export async function getBundledExtensionPathsAsync() {
@@ -105,6 +124,7 @@ export async function getBundledExtensionPathsAsync() {
         bundledQuestionExtensionPath(),
         bundledSessionTitleExtensionPath(),
         bundledTerminalBellExtensionPath(),
+        bundledTelegramConnectorExtensionPath(),
     ].map(async (extensionPath) => await extensionEntryExistsAsync(extensionPath) ? extensionPath : undefined));
     return paths.filter((path) => path !== undefined);
 }
@@ -199,12 +219,32 @@ async function ensurePiToolsSuiteExtensionInstalledOnce(options = {}) {
     return await pending;
 }
 export function resolvePixRuntimeModelRef(options, sessionManager, config = loadPixConfig()) {
+    return resolvePixRuntimeModelRefs(options, sessionManager, config)[0];
+}
+export function resolvePixRuntimeModelRefs(options, sessionManager, config = loadPixConfig()) {
     if (options.modelRef)
-        return options.modelRef;
+        return [options.modelRef];
     const existingEntryCount = sessionManager.getEntries().length;
-    if (existingEntryCount > 0)
-        return resolveSessionModelRefFromTail(sessionManager.getBranch());
-    return resolveDefaultModelRef(config);
+    if (existingEntryCount > 0) {
+        const sessionRef = resolveSessionModelRefFromTail(sessionManager.getBranch());
+        return sessionRef ? [sessionRef] : [];
+    }
+    const primary = resolveDefaultModelRef(config);
+    if (!primary)
+        return [];
+    const defaultThinking = config.defaultModel?.thinking;
+    const fallbacks = (config.defaultModel?.fallbackModels ?? []).map((modelRef) => {
+        const trimmed = modelRef.trim();
+        if (!trimmed || !defaultThinking)
+            return trimmed;
+        try {
+            return parseModelRef(trimmed).thinkingLevel === undefined ? `${trimmed}:${defaultThinking}` : trimmed;
+        }
+        catch {
+            return trimmed;
+        }
+    });
+    return [...new Set([primary, ...fallbacks].map((ref) => ref.trim()).filter(Boolean))];
 }
 export function resolvePixRuntimeInitialThinkingLevel(options, sessionManager, config) {
     const effectiveModelRef = resolvePixRuntimeModelRef(options, sessionManager, config);
@@ -239,14 +279,52 @@ export async function refreshPixModelRuntimeForStartup(modelRuntime) {
     // refreshes belong to explicit model-management flows and must not block boot.
     await modelRuntime.refresh({ allowNetwork: false });
 }
+/**
+ * Build the model catalogue used by UI-only draft tabs without allocating an
+ * AgentSession or session file. Drafts can therefore expose model selection
+ * while preserving lazy session materialization until the first prompt.
+ */
+export async function createPixDraftModelCatalog(options) {
+    const agentDir = options.agentDir ?? getAgentDir();
+    await ensurePiToolsSuiteExtensionInstalledOnce({ agentDir });
+    const bundledExtensionPaths = await getBundledExtensionPathsAsync();
+    const modelRuntime = await ModelRuntime.create({
+        authPath: join(agentDir, "auth.json"),
+        modelsPath: join(agentDir, "models.json"),
+        allowModelNetwork: false,
+        refreshOnCreate: false,
+    });
+    const services = await createAgentSessionServices({
+        cwd: options.cwd,
+        agentDir,
+        modelRuntime,
+        resourceLoaderOptions: {
+            noContextFiles: true,
+            noSkills: true,
+            noPromptTemplates: true,
+            noThemes: true,
+            ...(bundledExtensionPaths.length === 0 ? {} : {
+                additionalExtensionPaths: bundledExtensionPaths,
+                extensionsOverride: prioritizeBundledQuestionExtension,
+            }),
+        },
+    });
+    try {
+        return [...services.modelRuntime.getAvailableSnapshot()];
+    }
+    finally {
+        // Draft discovery needs extension provider registrations, but it does not
+        // own a session. Invalidate the temporary extension runtime so event-bus
+        // subscriptions and captured ctx/pi handles cannot outlive discovery.
+        services.resourceLoader.getExtensions().runtime.invalidate("Draft model catalog discovery completed");
+    }
+}
 export async function createPixRuntime(options, runtimeOptions = {}) {
     const agentDir = getAgentDir();
     const reusableServices = reusableRuntimeServices(runtimeOptions.reuseServicesFrom, options.cwd, agentDir);
     const createRuntime = async ({ cwd, sessionManager, sessionStartEvent }) => {
         const config = runtimeOptions.config ?? loadPixConfig(cwd);
-        const effectiveModelRef = resolvePixRuntimeModelRef(options, sessionManager, config);
-        const parsedModel = effectiveModelRef ? parseModelRef(effectiveModelRef) : undefined;
-        const initialThinkingLevel = resolvePixRuntimeInitialThinkingLevel(options, sessionManager, config);
+        const modelRefs = resolvePixRuntimeModelRefs(options, sessionManager, config);
         // Only reuse services for the initial session. Session replacements
         // (switchSession/newSession/fork) must get fresh services so extensions
         // are re-loaded with a fresh pi — otherwise handlers capture the old,
@@ -261,10 +339,36 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
                 ...(runtimeOptions.eventBus === undefined ? {} : { eventBus: runtimeOptions.eventBus }),
             });
         await refreshPixModelRuntimeForStartup(services.modelRuntime);
-        const model = parsedModel ? services.modelRuntime.getModel(parsedModel.provider, parsedModel.modelId) : undefined;
-        if (parsedModel && !model) {
-            throw new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);
+        let model;
+        let selectedRef;
+        let selectedThinkingLevel;
+        let primaryError;
+        for (let index = 0; index < modelRefs.length; index++) {
+            const modelRef = modelRefs[index];
+            let parsedModel;
+            try {
+                parsedModel = parseModelRef(modelRef);
+            }
+            catch (error) {
+                if (index === 0)
+                    throw error;
+                continue;
+            }
+            const candidate = services.modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
+            if (!candidate) {
+                if (index === 0)
+                    primaryError = new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);
+                continue;
+            }
+            model = candidate;
+            selectedRef = modelRef;
+            selectedThinkingLevel = parsedModel.thinkingLevel;
+            break;
+        }
+        if (modelRefs.length > 0 && !model) {
+            throw primaryError ?? new Error(`No configured model is available: ${modelRefs.join(", ")}`);
         }
+        const initialThinkingLevel = selectedThinkingLevel;
         const enabledModelRefs = services.settingsManager.getEnabledModels();
         const scopedModels = (enabledModelRefs ?? []).flatMap((modelRef) => {
             const scoped = parseScopedModelRef(modelRef);
@@ -288,9 +392,13 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
             ...(initialThinkingLevel === undefined ? {} : { thinkingLevel: initialThinkingLevel }),
             ...(scopedModels.length === 0 ? {} : { scopedModels }),
         });
+        const modelFallbackMessage = selectedRef && selectedRef !== modelRefs[0]
+            ? `Default model ${modelRefs[0]} is unavailable; using fallback ${selectedRef}.`
+            : undefined;
         return {
             ...created,
             services,
+            ...(modelFallbackMessage ? { modelFallbackMessage } : {}),
             // Snapshot diagnostics per-runtime. When services are reused across
             // tabs (reuseServicesFrom), services.diagnostics is a shared array —
             // giving each runtime its own copy prevents one tab's creation

package/dist/app/screen/mouse-controller.d.ts

@@ -86,6 +86,8 @@ export declare class AppMouseController {
         index: number;
     } | {
         kind: "popup-menu-close";
+    } | {
+        kind: "model-visibility-clear";
     } | {
         kind: "todo-panel";
     } | {