lsd-pi 1.3.7 → 1.3.9

package/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts

@@ -56,19 +56,9 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
         "bash", "bg_shell",
         "web_search", "search-the-web", "google_search", "search_and_read",
         "fetch_page", "resolve_library", "get_library_docs",
+        "subagent", "await_subagent",
     ]);
 
-    const shouldStartToolHidden = (toolName: string): boolean => {
-        const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
-        if (!collapseToolCalls || host.collapsedToolCallsExpanded) {
-            return false;
-        }
-        if (ALWAYS_DIRECT_TOOLS.has(toolName)) {
-            return false;
-        }
-        return shouldCollapse(toolName, false);
-    };
-
     const hasVisibleRender = (child: { render?: (width: number) => string[] } | undefined): boolean => {
         if (!child?.render) return true;
         try {
@@ -190,7 +180,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                 (text) => theme.fg("accent", text),
                 host.defaultWorkingMessage,
             );
-            host.loadingAnimation.setCycleMessages(host.workingMessages, 3000);
+            host.loadingAnimation.setCycleMessages(host.workingMessages, 10_000);
             host.statusContainer.addChild(host.loadingAnimation);
             host.startLoadingTips();
             // Show steer/queue + expand hint in editor bottom border while agent is running
@@ -253,9 +243,19 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                                 host.ui,
                             );
                             component.setExpanded(host.toolOutputExpanded);
-                            component.setHidden(shouldStartToolHidden(content.name));
+                            const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
+                            const shouldHide = collapseToolCalls && !host.collapsedToolCallsExpanded && shouldCollapse(content.name, false) && !ALWAYS_DIRECT_TOOLS.has(content.name);
                             host.chatContainer.addChild(component);
+                            if (shouldHide) {
+                                // Check for adjacent summary AFTER adding to container so indexOf works
+                                const adjacentSummary = findAdjacentCollapsedToolSummary(content.name, component);
+                                if (adjacentSummary) {
+                                    component.setIndented(true);
+                                }
+                            }
+                            component.setHidden(shouldHide);
                             host.pendingTools.set(content.id, component);
+                            host.updateEditorExpandHint();
                         } else {
                             host.pendingTools.get(content.id)?.updateArgs(content.arguments);
                         }
@@ -273,9 +273,19 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                                 host.ui,
                             );
                             component.setExpanded(host.toolOutputExpanded);
-                            component.setHidden(shouldStartToolHidden(content.name));
+                            const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
+                            const shouldHide = collapseToolCalls && !host.collapsedToolCallsExpanded && shouldCollapse(content.name, false) && !ALWAYS_DIRECT_TOOLS.has(content.name);
                             host.chatContainer.addChild(component);
+                            if (shouldHide) {
+                                // Check for adjacent summary AFTER adding to container so indexOf works
+                                const adjacentSummary = findAdjacentCollapsedToolSummary(content.name, component);
+                                if (adjacentSummary) {
+                                    component.setIndented(true);
+                                }
+                            }
+                            component.setHidden(shouldHide);
                             host.pendingTools.set(content.id, component);
+                            host.updateEditorExpandHint();
                         }
                     } else if (content.type === "webSearchResult") {
                         const component = host.pendingTools.get(content.toolUseId);
@@ -356,9 +366,19 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                     host.ui,
                 );
                 component.setExpanded(host.toolOutputExpanded);
-                component.setHidden(shouldStartToolHidden(event.toolName));
+                const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
+                const shouldHide = collapseToolCalls && !host.collapsedToolCallsExpanded && shouldCollapse(event.toolName, false) && !ALWAYS_DIRECT_TOOLS.has(event.toolName);
                 host.chatContainer.addChild(component);
+                if (shouldHide) {
+                    // Check for adjacent summary AFTER adding to container so indexOf works
+                    const adjacentSummary = findAdjacentCollapsedToolSummary(event.toolName, component);
+                    if (adjacentSummary) {
+                        component.setIndented(true);
+                    }
+                }
+                component.setHidden(shouldHide);
                 host.pendingTools.set(event.toolCallId, component);
+                host.updateEditorExpandHint();
                 host.ui.requestRender();
             }
             break;
@@ -410,6 +430,8 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                 if (collapseToolCalls && shouldCollapse(event.toolName, event.isError) && !ALWAYS_DIRECT_TOOLS.has(event.toolName)) {
                     appendCollapsedToolSummary(event.toolName, component.getElapsed(), component);
                     component.setHidden(!host.collapsedToolCallsExpanded);
+                    component.setIndented(false);
+                    host.updateEditorExpandHint();
                 } else {
                     component.setHidden(false);
                     resetCollapsedToolSummary();

package/packages/pi-coding-agent/src/modes/interactive/controllers/extension-ui-controller.ts

@@ -55,6 +55,7 @@ export function createExtensionUIContext(host: any): ExtensionUIContext {
 		},
 		getToolsExpanded: () => host.collapsedToolCallsExpanded || host.toolOutputExpanded,
 		setToolsExpanded: (expanded) => host.setToolsExpanded(expanded),
+		isEditorFocused: () => !!host.editor.focused,
 	};
 }
 

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -1538,7 +1538,7 @@ export class InteractiveMode {
 		this.defaultEditor.onExtensionShortcut = undefined;
 		this.updateTerminalTitle();
 		if (this.loadingAnimation) {
-			this.loadingAnimation.setCycleMessages(this.workingMessages);
+			this.loadingAnimation.setCycleMessages(this.workingMessages, 10_000);
 		}
 	}
 
@@ -1881,7 +1881,7 @@ export class InteractiveMode {
 	/** Reset the loading animation back to cycling working messages. */
 	private resetLoadingMessage(): void {
 		if (this.loadingAnimation) {
-			this.loadingAnimation.setCycleMessages(this.workingMessages);
+			this.loadingAnimation.setCycleMessages(this.workingMessages, 10_000);
 		}
 	}
 
@@ -3110,6 +3110,7 @@ export class InteractiveMode {
 			}
 			if (child instanceof ToolExecutionComponent) {
 				child.setHidden(!showCollapsedToolCalls && child.shouldHideWhenCollapsed(collapseToolCalls));
+				child.setIndented(false);
 			}
 			if (child instanceof ToolSummaryLine) {
 				child.setHidden(!collapseToolCalls || showCollapsedToolCalls);

package/packages/pi-coding-agent/src/modes/rpc/rpc-mode.ts

@@ -422,6 +422,10 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		setToolsExpanded(_expanded: boolean) {
 			// Tool expansion not supported in RPC mode - no TUI
 		},
+
+		isEditorFocused() {
+			return false;
+		},
 	});
 
 	// Set up extensions with RPC-based UI context.

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lsd-pi",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "piConfig": {
     "name": "lsd",
     "configDir": ".lsd"

package/src/resources/extensions/mcp-client/index.ts

@@ -62,6 +62,14 @@ interface McpState {
 const connections = new Map<string, ManagedConnection>();
 let configCache: McpServerConfig[] | null = null;
 const toolCache = new Map<string, McpToolSchema[]>();
+let warmupPromise: Promise<McpWarmupResult[]> | null = null;
+
+interface McpWarmupResult {
+    name: string;
+    status: "connected" | "error";
+    toolCount?: number;
+    error?: string;
+}
 
 const MCP_STATE_PATH = join(process.cwd(), ".lsd", "mcp-state.json");
 
@@ -263,6 +271,49 @@ async function getOrConnect(name: string, signal?: AbortSignal): Promise<Client>
     return client;
 }
 
+async function warmupEnabledServers(): Promise<McpWarmupResult[]> {
+    if (warmupPromise) return warmupPromise;
+
+    warmupPromise = (async () => {
+        const enabledServers = readConfigs().filter((server) => server.enabled);
+        if (enabledServers.length === 0) return [];
+
+        const results = await Promise.allSettled(enabledServers.map(async (server) => {
+            const client = await getOrConnect(server.name);
+            const result = await client.listTools(undefined, { timeout: 30000 });
+            const tools: McpToolSchema[] = (result.tools ?? []).map((tool) => ({
+                name: tool.name,
+                description: tool.description ?? "",
+                inputSchema: tool.inputSchema as Record<string, unknown> | undefined,
+            }));
+            toolCache.set(server.name, tools);
+            return {
+                name: server.name,
+                status: "connected" as const,
+                toolCount: tools.length,
+            };
+        }));
+
+        return results.map((result, index) => {
+            if (result.status === "fulfilled") {
+                return result.value;
+            }
+
+            return {
+                name: enabledServers[index]?.name ?? `server-${index + 1}`,
+                status: "error" as const,
+                error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+            };
+        });
+    })();
+
+    try {
+        return await warmupPromise;
+    } finally {
+        warmupPromise = null;
+    }
+}
+
 async function closeAll(): Promise<void> {
     const closing = Array.from(connections.entries()).map(async ([name, conn]) => {
         try {
@@ -277,6 +328,7 @@ async function closeAll(): Promise<void> {
 }
 
 async function reloadMcpState(): Promise<void> {
+    warmupPromise = null;
     await closeAll();
     configCache = null;
 }
@@ -402,6 +454,14 @@ async function handleMcpCommand(args: string, ctx: ExtensionCommandContext): Pro
             const action = enabled ? "enabled" : "disabled";
             const changeText = result.changed ? action : `already ${action}`;
             ctx.ui.notify(`MCP server ${result.canonicalName} ${changeText}.`, "info");
+
+            if (enabled) {
+                const warmupResults = await warmupEnabledServers();
+                const warmupResult = warmupResults.find((entry) => entry.name === result.canonicalName);
+                if (warmupResult?.status === "error") {
+                    ctx.ui.notify(`Failed to connect ${result.canonicalName}: ${warmupResult.error}`, "error");
+                }
+            }
         } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             ctx.ui.notify(message, "error");
@@ -412,7 +472,12 @@ async function handleMcpCommand(args: string, ctx: ExtensionCommandContext): Pro
     if (subcommand === "reload") {
         await reloadMcpState();
         const servers = readConfigs();
-        ctx.ui.notify(`Reloaded MCP config — ${servers.length} server(s) available.`, "info");
+        const warmupResults = await warmupEnabledServers();
+        const failed = warmupResults.filter((entry) => entry.status === "error");
+        const summary = failed.length > 0
+            ? `Reloaded MCP config — ${servers.length} server(s) available, ${failed.length} failed to connect.`
+            : `Reloaded MCP config — ${servers.length} server(s) available.`;
+        ctx.ui.notify(summary, failed.length > 0 ? "warning" : "info");
         return;
     }
 
@@ -733,17 +798,31 @@ export default function(pi: ExtensionAPI) {
 
     pi.on("session_start", async (_event, ctx) => {
         const servers = readConfigs();
+        const enabledServers = servers.filter((server) => server.enabled);
         if (servers.length > 0) {
-            ctx.ui.notify(`MCP client ready — ${servers.filter((server) => server.enabled).length}/${servers.length} server(s) enabled`, "info");
+            ctx.ui.notify(`MCP client ready — ${enabledServers.length}/${servers.length} server(s) enabled`, "info");
         }
+        if (enabledServers.length === 0) return;
+
+        void warmupEnabledServers().then((results) => {
+            const failed = results.filter((entry) => entry.status === "error");
+            if (failed.length > 0) {
+                const failureSummary = failed.map((entry) => `${entry.name}: ${entry.error}`).join("; ");
+                ctx.ui.notify(`MCP autoconnect partial failure — ${failureSummary}`, "warning");
+            }
+        }).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            ctx.ui.notify(`MCP autoconnect failed: ${message}`, "warning");
+        });
     });
 
     pi.on("session_shutdown", async () => {
+        warmupPromise = null;
         await closeAll();
     });
 
     pi.on("session_switch", async () => {
-        await closeAll();
-        configCache = null;
+        await reloadMcpState();
+        void warmupEnabledServers();
     });
 }

package/src/resources/extensions/mcp-client/tests/server-name-spaces.test.ts

@@ -53,3 +53,19 @@ test("#3029: getOrConnect normalizes name for connection cache lookup", () => {
 		"getOrConnect should use config.name (canonical) as the connections cache key",
 	);
 });
+
+test("enabled MCP servers are warmed up on session start", () => {
+	assert.match(
+		source,
+		/pi\.on\("session_start", async \(_event, ctx\) => {[\s\S]*?warmupEnabledServers\(/,
+		"session_start should trigger MCP autoconnect warmup for enabled servers",
+	);
+});
+
+test("warmupEnabledServers preloads tool schemas during autoconnect", () => {
+	assert.match(
+		source,
+		/async function warmupEnabledServers\([\s\S]*?client\.listTools\(undefined, \{ timeout: 30000 \}\)[\s\S]*?toolCache\.set\(/,
+		"warmupEnabledServers should list tools and populate tool cache during startup",
+	);
+});

package/src/resources/extensions/slash-commands/plan.ts

@@ -191,8 +191,8 @@ function readAutoSwitchPlanModelSetting(): boolean {
     const settingsPath = join(getAgentDir(), "settings.json");
     if (!existsSync(settingsPath)) return false;
     const raw = readFileSync(settingsPath, "utf-8");
-    const parsed = JSON.parse(raw) as { autoSwitchPlanModel?: unknown };
-    return parsed.autoSwitchPlanModel === true;
+    const parsed = JSON.parse(raw) as { planModeAutoSwitchModel?: unknown };
+    return parsed.planModeAutoSwitchModel === true;
   } catch {
     return false;
   }
@@ -418,10 +418,10 @@ async function approvePlan(
   permissionMode: RestorablePermissionMode,
   executeWithSubagent = false,
 ): Promise<void> {
-  const reasoningModel = parseQualifiedModelRef(readPlanModeReasoningModel());
-  if (reasoningModel) {
-    await setModelIfNeeded(pi, ctx, reasoningModel);
-  }
+  // Do NOT switch to reasoning model during execution.
+  // The reasoning model is only for plan-mode investigation, not execution.
+  // If a coding model is configured and we're using a subagent, the explicit
+  // model="<planModeCodingModel>" in the kickoff message will handle it.
 
   state = {
     ...state,

package/src/resources/extensions/usage/index.ts

@@ -75,6 +75,8 @@ type UsageRow = {
 	cacheWrite: number;
 	total: number;
 	cost: number;
+	totalDurationMs: number;
+	totalOutputForSpeed: number;
 };
 
 type UsageReport = {
@@ -313,6 +315,7 @@ function collectUsage(sessionFiles: string[], startMs: number, endMs: number, sc
 		let projectLabel = basename(file);
 		let headerResolved = false;
 		let currentModel = "";
+		let lastUserTimestamp = 0;
 
 		const raw = readFileSync(file, "utf-8");
 		for (const line of raw.split("\n")) {
@@ -367,6 +370,8 @@ function collectUsage(sessionFiles: string[], startMs: number, endMs: number, sc
 					cacheWrite: 0,
 					total: 0,
 					cost: 0,
+					totalDurationMs: 0,
+					totalOutputForSpeed: 0,
 				};
 
 				existing.messages += 1;
@@ -376,10 +381,27 @@ function collectUsage(sessionFiles: string[], startMs: number, endMs: number, sc
 				existing.cacheWrite += cacheWrite;
 				existing.total += total;
 				existing.cost += cost;
+
+				// Track tok/sec: use preceding user message timestamp
+				if (output > 0 && lastUserTimestamp > 0) {
+					const durationMs = timestamp - lastUserTimestamp;
+					if (durationMs > 0) {
+						existing.totalDurationMs += durationMs;
+						existing.totalOutputForSpeed += output;
+					}
+				}
+
 				rows.set(key, existing);
 			} else if (message.role === "user") {
 				const timestamp = Number(message.timestamp ?? 0);
-				if (!timestamp || timestamp < startMs || timestamp >= endMs) continue;
+				if (!timestamp) continue;
+
+				// Always track last user timestamp for tok/sec calculation,
+				// even if this user message is outside the time range
+				// (the assistant response may still be within range).
+				lastUserTimestamp = timestamp;
+
+				if (timestamp < startMs || timestamp >= endMs) continue;
 
 				matchedUserPrompts++;
 				const model = currentModel;
@@ -397,6 +419,8 @@ function collectUsage(sessionFiles: string[], startMs: number, endMs: number, sc
 					cacheWrite: 0,
 					total: 0,
 					cost: 0,
+					totalDurationMs: 0,
+					totalOutputForSpeed: 0,
 				};
 
 				existing.userPrompts += 1;
@@ -431,9 +455,11 @@ function collectUsage(sessionFiles: string[], startMs: number, endMs: number, sc
 			acc.cacheWrite += row.cacheWrite;
 			acc.total += row.total;
 			acc.cost += row.cost;
+			acc.totalDurationMs += row.totalDurationMs;
+			acc.totalOutputForSpeed += row.totalOutputForSpeed;
 			return acc;
 		},
-		{ messages: 0, userPrompts: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, cost: 0 },
+		{ messages: 0, userPrompts: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, cost: 0, totalDurationMs: 0, totalOutputForSpeed: 0 },
 	);
 
 	return {
@@ -448,6 +474,11 @@ function collectUsage(sessionFiles: string[], startMs: number, endMs: number, sc
 	};
 }
 
+function formatSpeed(totalDurationMs: number, totalOutputForSpeed: number): string {
+	if (totalDurationMs <= 0) return "—";
+	return Math.round(totalOutputForSpeed / (totalDurationMs / 1000)).toLocaleString();
+}
+
 function renderTable(report: UsageReport): string {
 	const firstColumnHeader = report.groupBy === "project"
 		? "project"
@@ -465,8 +496,11 @@ function renderTable(report: UsageReport): string {
 		write: formatInt(row.cacheWrite),
 		total: formatInt(row.total),
 		cost: formatCost(row.cost),
+		speed: formatSpeed(row.totalDurationMs, row.totalOutputForSpeed),
 	}));
 
+	const totalsSpeed = formatSpeed(report.totals.totalDurationMs, report.totals.totalOutputForSpeed);
+
 	const widths = {
 		label: Math.max(firstColumnHeader.length, ...displayRows.map((row) => row.label.length), 5),
 		userPrompts: Math.max(11, ...displayRows.map((row) => row.userPrompts.length), String(report.totals.userPrompts).length),
@@ -477,6 +511,7 @@ function renderTable(report: UsageReport): string {
 		write: Math.max(5, ...displayRows.map((row) => row.write.length), formatInt(report.totals.cacheWrite).length),
 		total: Math.max(5, ...displayRows.map((row) => row.total.length), formatInt(report.totals.total).length),
 		cost: Math.max(7, ...displayRows.map((row) => row.cost.length), formatCost(report.totals.cost).length),
+		speed: Math.max(5, ...displayRows.map((row) => row.speed.length), totalsSpeed.length),
 	};
 
 	const header = [
@@ -489,6 +524,7 @@ function renderTable(report: UsageReport): string {
 		"write".padStart(widths.write),
 		"total".padStart(widths.total),
 		"cost".padStart(widths.cost),
+		"tok/s".padStart(widths.speed),
 	].join("  ");
 
 	const divider = "-".repeat(header.length);
@@ -502,6 +538,7 @@ function renderTable(report: UsageReport): string {
 		row.write.padStart(widths.write),
 		row.total.padStart(widths.total),
 		row.cost.padStart(widths.cost),
+		row.speed.padStart(widths.speed),
 	].join("  "));
 
 	const totalsLine = [
@@ -514,6 +551,7 @@ function renderTable(report: UsageReport): string {
 		formatInt(report.totals.cacheWrite).padStart(widths.write),
 		formatInt(report.totals.total).padStart(widths.total),
 		formatCost(report.totals.cost).padStart(widths.cost),
+		totalsSpeed.padStart(widths.speed),
 	].join("  ");
 
 	return [header, divider, ...body, divider, totalsLine].join("\n");

package/src/resources/extensions/voice/index.ts

@@ -303,6 +303,7 @@ export default function(pi: ExtensionAPI) {
             activationMode,
             editorText: ctx.ui.getEditorText(),
             holdToTalkSupported: isKittyProtocolActive(),
+            isEditorFocused: ctx.ui.isEditorFocused(),
             onUnsupported: () => {
                 if (holdToTalkUnsupportedNotified) return;
                 holdToTalkUnsupportedNotified = true;

package/src/resources/extensions/voice/push-to-talk.ts

@@ -8,6 +8,7 @@ export interface PushToTalkState {
     activationMode: VoiceActivationMode | null;
     editorText: string;
     holdToTalkSupported: boolean;
+    isEditorFocused: boolean;
     onUnsupported?(): void;
     startPushToTalk(): void | Promise<void>;
     stopVoice(): void | Promise<void>;
@@ -16,6 +17,8 @@ export interface PushToTalkState {
 export function handlePushToTalkInput(data: string, state: PushToTalkState): ReturnType<TerminalInputHandler> {
     if (!matchesKey(data, Key.space)) return undefined;
 
+    if (!state.isEditorFocused) return undefined;
+
     if (isKeyRelease(data)) {
         if (state.activationMode === "push-to-talk") {
             void Promise.resolve(state.stopVoice());

package/src/resources/extensions/voice/tests/push-to-talk.test.ts

@@ -15,6 +15,7 @@ describe("voice push-to-talk handler", () => {
             activationMode: null,
             editorText: "",
             holdToTalkSupported: true,
+            isEditorFocused: true,
             startPushToTalk: () => { startCalls += 1; },
             stopVoice: () => { stopCalls += 1; },
         });
@@ -32,6 +33,7 @@ describe("voice push-to-talk handler", () => {
             activationMode: null,
             editorText: "hello",
             holdToTalkSupported: true,
+            isEditorFocused: true,
             startPushToTalk: () => { startCalls += 1; },
             stopVoice: () => { },
         });
@@ -48,6 +50,7 @@ describe("voice push-to-talk handler", () => {
             activationMode: "push-to-talk",
             editorText: "",
             holdToTalkSupported: true,
+            isEditorFocused: true,
             startPushToTalk: () => { startCalls += 1; },
             stopVoice: () => { },
         });
@@ -64,6 +67,7 @@ describe("voice push-to-talk handler", () => {
             activationMode: "push-to-talk",
             editorText: "",
             holdToTalkSupported: true,
+            isEditorFocused: true,
             startPushToTalk: () => { },
             stopVoice: () => { stopCalls += 1; },
         });
@@ -80,6 +84,7 @@ describe("voice push-to-talk handler", () => {
             activationMode: "toggle",
             editorText: "",
             holdToTalkSupported: true,
+            isEditorFocused: true,
             startPushToTalk: () => { },
             stopVoice: () => { stopCalls += 1; },
         });
@@ -97,6 +102,7 @@ describe("voice push-to-talk handler", () => {
             activationMode: null,
             editorText: "",
             holdToTalkSupported: false,
+            isEditorFocused: true,
             onUnsupported: () => { notifyCalls += 1; },
             startPushToTalk: () => { startCalls += 1; },
             stopVoice: () => { },