@bastani/atomic 0.9.5-alpha.7 → 0.9.5-alpha.9

package/dist/builtin/intercom/index.ts

@@ -1,57 +1,54 @@
-import type { ExtensionAPI, ExtensionContext, HandlerFn, MessageRenderer, RegisteredCommand, ToolDefinition } from "@bastani/atomic";
-import { Text } from "@mariozechner/pi-tui";
+import type { AgentEndEvent, AgentStartEvent, ExtensionAPI, ExtensionCommandContext, ExtensionContext, ExtensionHandler, MessageRenderer, ModelSelectEvent, RegisteredCommand, SessionShutdownEvent, SessionStartEvent, ToolDefinition, ToolExecutionEndEvent, ToolExecutionStartEvent, TurnEndEvent, TurnStartEvent } from "@bastani/atomic";
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { renderIntercomToolResult } from "./result-renderers.js";
 
 type CapturedCommand = Omit<RegisteredCommand, "name" | "sourceInfo">;
 type CapturedShortcut = Parameters<ExtensionAPI["registerShortcut"]>[1];
 type EventHandler = Parameters<ExtensionAPI["events"]["on"]>[1];
+type EventPayload = Parameters<EventHandler>[0];
 type ToolRenderResultArgs = Parameters<NonNullable<ToolDefinition["renderResult"]>>;
+
+type ForwardedEventMap = {
+	session_start: SessionStartEvent;
+	session_shutdown: SessionShutdownEvent;
+	turn_start: TurnStartEvent;
+	turn_end: TurnEndEvent;
+	agent_start: AgentStartEvent;
+	agent_end: AgentEndEvent;
+	tool_execution_start: ToolExecutionStartEvent;
+	tool_execution_end: ToolExecutionEndEvent;
+	model_select: ModelSelectEvent;
+};
+
+type LazyLifecycleEvent = keyof ForwardedEventMap;
+type ForwardedHandler<K extends LazyLifecycleEvent> = ExtensionHandler<ForwardedEventMap[K]>;
+type ForwardedHandlerMap = { [K in LazyLifecycleEvent]: ForwardedHandler<K>[] };
+type AnyForwardedHandler = { [K in LazyLifecycleEvent]: ForwardedHandler<K> }[LazyLifecycleEvent];
+
 type CapturedHeavy = {
 	tools: Map<string, ToolDefinition>;
 	commands: Map<string, CapturedCommand>;
-	handlers: Map<string, HandlerFn[]>;
+	handlers: ForwardedHandlerMap;
 	shortcuts: Map<string, CapturedShortcut>;
 	eventHandlers: Map<string, EventHandler[]>;
 };
-type LifecycleSnapshot = {
-	event: unknown;
+
+type LifecycleSnapshot<K extends LazyLifecycleEvent> = {
+	event: ForwardedEventMap[K];
 	ctx: ExtensionContext;
 };
 
-type SessionSnapshot = LifecycleSnapshot & {
+type SessionSnapshot = LifecycleSnapshot<"session_start"> & {
 	generation: number;
 };
 
 type ActiveLifecycleState = {
-	turnStart: LifecycleSnapshot | null;
-	agentStart: LifecycleSnapshot | null;
-	activeTools: Map<string, LifecycleSnapshot>;
-	modelSelect: LifecycleSnapshot | null;
+	turnStart: LifecycleSnapshot<"turn_start"> | null;
+	agentStart: LifecycleSnapshot<"agent_start"> | null;
+	activeTools: Map<string, LifecycleSnapshot<"tool_execution_start">>;
+	modelSelect: LifecycleSnapshot<"model_select"> | null;
 };
-
-type LazyLifecycleEvent =
-	| "session_start"
-	| "session_shutdown"
-	| "turn_start"
-	| "turn_end"
-	| "agent_start"
-	| "agent_end"
-	| "tool_execution_start"
-	| "tool_execution_end"
-	| "model_select";
-
-const FORWARDED_EVENTS: readonly LazyLifecycleEvent[] = [
-	"session_start",
-	"session_shutdown",
-	"turn_start",
-	"turn_end",
-	"agent_start",
-	"agent_end",
-	"tool_execution_start",
-	"tool_execution_end",
-	"model_select",
-];
 const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
 const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 
@@ -59,16 +56,67 @@ function hasSubagentIntercomEnv(): boolean {
 	return Object.keys(process.env).some((key) => key.endsWith("_SUBAGENT_ORCHESTRATOR_TARGET"));
 }
 
-function getToolCallId(event: unknown): string | null {
-	if (typeof event !== "object" || event === null || !("toolCallId" in event)) return null;
-	const toolCallId = event.toolCallId;
-	return typeof toolCallId === "string" ? toolCallId : null;
+function createSyntheticSessionStartEvent(): SessionStartEvent {
+	return { type: "session_start", reason: "startup" };
 }
 
-function addHandler(captured: CapturedHeavy, event: string, handler: HandlerFn): void {
-	const handlers = captured.handlers.get(event) ?? [];
-	handlers.push(handler);
-	captured.handlers.set(event, handlers);
+function createForwardedHandlerMap(): ForwardedHandlerMap {
+	return {
+		session_start: [],
+		session_shutdown: [],
+		turn_start: [],
+		turn_end: [],
+		agent_start: [],
+		agent_end: [],
+		tool_execution_start: [],
+		tool_execution_end: [],
+		model_select: [],
+	};
+}
+
+function addHandler<K extends LazyLifecycleEvent>(captured: CapturedHeavy, event: K, handler: ForwardedHandler<K>): void {
+	captured.handlers[event].push(handler);
+}
+
+function captureForwardedHandler(captured: CapturedHeavy, event: "session_start", handler: ForwardedHandler<"session_start">): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: "session_shutdown", handler: ForwardedHandler<"session_shutdown">): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: "turn_start", handler: ForwardedHandler<"turn_start">): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: "turn_end", handler: ForwardedHandler<"turn_end">): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: "agent_start", handler: ForwardedHandler<"agent_start">): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: "agent_end", handler: ForwardedHandler<"agent_end">): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: "tool_execution_start", handler: ForwardedHandler<"tool_execution_start">): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: "tool_execution_end", handler: ForwardedHandler<"tool_execution_end">): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: "model_select", handler: ForwardedHandler<"model_select">): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: LazyLifecycleEvent, handler: AnyForwardedHandler): void;
+function captureForwardedHandler(captured: CapturedHeavy, event: LazyLifecycleEvent, handler: AnyForwardedHandler): void {
+	switch (event) {
+		case "session_start":
+			addHandler(captured, event, handler as ForwardedHandler<"session_start">);
+			return;
+		case "session_shutdown":
+			addHandler(captured, event, handler as ForwardedHandler<"session_shutdown">);
+			return;
+		case "turn_start":
+			addHandler(captured, event, handler as ForwardedHandler<"turn_start">);
+			return;
+		case "turn_end":
+			addHandler(captured, event, handler as ForwardedHandler<"turn_end">);
+			return;
+		case "agent_start":
+			addHandler(captured, event, handler as ForwardedHandler<"agent_start">);
+			return;
+		case "agent_end":
+			addHandler(captured, event, handler as ForwardedHandler<"agent_end">);
+			return;
+		case "tool_execution_start":
+			addHandler(captured, event, handler as ForwardedHandler<"tool_execution_start">);
+			return;
+		case "tool_execution_end":
+			addHandler(captured, event, handler as ForwardedHandler<"tool_execution_end">);
+			return;
+		case "model_select":
+			addHandler(captured, event, handler as ForwardedHandler<"model_select">);
+	}
 }
 
 function addEventHandler(captured: CapturedHeavy, event: string, handler: EventHandler): void {
@@ -77,13 +125,13 @@ function addEventHandler(captured: CapturedHeavy, event: string, handler: EventH
 	captured.eventHandlers.set(event, handlers);
 }
 
-async function dispatchHandlers(captured: CapturedHeavy, eventName: string, event: unknown, ctx: ExtensionContext): Promise<void> {
-	for (const handler of captured.handlers.get(eventName) ?? []) {
+async function dispatchHandlers<K extends LazyLifecycleEvent>(captured: CapturedHeavy, eventName: K, event: ForwardedEventMap[K], ctx: ExtensionContext): Promise<void> {
+	for (const handler of captured.handlers[eventName]) {
 		await handler(event, ctx);
 	}
 }
 
-async function dispatchEventHandlers(captured: CapturedHeavy, eventName: string, payload: unknown): Promise<void> {
+async function dispatchEventHandlers(captured: CapturedHeavy, eventName: string, payload: EventPayload): Promise<void> {
 	for (const handler of captured.eventHandlers.get(eventName) ?? []) {
 		await handler(payload);
 	}
@@ -99,8 +147,8 @@ function createHeavyProxy(pi: ExtensionAPI, captured: CapturedHeavy): ExtensionA
 				return (name: string, options: CapturedCommand) => captured.commands.set(name, options);
 			}
 			if (prop === "on") {
-				return (event: string, handler: HandlerFn) => {
-					addHandler(captured, event, handler);
+				return (event: LazyLifecycleEvent, handler: AnyForwardedHandler) => {
+					captureForwardedHandler(captured, event, handler);
 				};
 			}
 			if (prop === "registerShortcut") {
@@ -136,19 +184,19 @@ async function executeHeavyTool(
 	loadHeavy: (ctx?: ExtensionContext) => Promise<CapturedHeavy>,
 	name: string,
 	args: Parameters<NonNullable<ToolDefinition["execute"]>>,
-): Promise<ReturnType<NonNullable<ToolDefinition["execute"]>>> {
+): Promise<Awaited<ReturnType<NonNullable<ToolDefinition["execute"]>>>> {
 	const ctx = args[4];
 	const heavy = await loadHeavy(ctx);
 	const tool = heavy.tools.get(name);
 	if (!tool?.execute) throw new Error(`Intercom tool implementation not found: ${name}`);
-	return tool.execute(...args) as ReturnType<NonNullable<ToolDefinition["execute"]>>;
+	return await tool.execute(...args) as Awaited<ReturnType<NonNullable<ToolDefinition["execute"]>>>;
 }
 
-async function runHeavyCommand(loadHeavy: (ctx?: ExtensionContext) => Promise<CapturedHeavy>, args: string | undefined, ctx: ExtensionContext): Promise<void> {
+async function runHeavyCommand(loadHeavy: (ctx?: ExtensionContext) => Promise<CapturedHeavy>, args: string | undefined, ctx: ExtensionCommandContext): Promise<void> {
 	const heavy = await loadHeavy(ctx);
 	const command = heavy.commands.get("intercom");
 	if (!command) throw new Error("Intercom command implementation not found");
-	await command.handler(args, ctx);
+	await command.handler(args ?? "", ctx);
 }
 
 function renderHeavyToolResult(loadedHeavy: CapturedHeavy | null, name: string, args: ToolRenderResultArgs): ReturnType<NonNullable<ToolDefinition["renderResult"]>> {
@@ -194,7 +242,7 @@ export default function intercom(pi: ExtensionAPI) {
 				const captured: CapturedHeavy = {
 					tools: new Map(),
 					commands: new Map(),
-					handlers: new Map(),
+					handlers: createForwardedHandlerMap(),
 					shortcuts: new Map(),
 					eventHandlers: new Map(),
 				};
@@ -202,7 +250,7 @@ export default function intercom(pi: ExtensionAPI) {
 				await mod.default(createHeavyProxy(pi, captured));
 				loadedHeavy = captured;
 				if (!sessionSnapshot && ctx) {
-					sessionSnapshot = { event: {}, ctx, generation: ++lifecycleGeneration };
+					sessionSnapshot = { event: createSyntheticSessionStartEvent(), ctx, generation: ++lifecycleGeneration };
 				}
 				await replaySessionStart(captured);
 				return captured;
@@ -210,88 +258,72 @@ export default function intercom(pi: ExtensionAPI) {
 		}
 		const heavy = await heavyPromise;
 		if (!sessionSnapshot && ctx) {
-			sessionSnapshot = { event: {}, ctx, generation: ++lifecycleGeneration };
+			sessionSnapshot = { event: createSyntheticSessionStartEvent(), ctx, generation: ++lifecycleGeneration };
 			await replaySessionStart(heavy);
 		}
 		return heavy;
 	}
 
-	for (const eventName of FORWARDED_EVENTS) {
-		switch (eventName) {
-			case "session_start":
-				pi.on("session_start", async (event, ctx) => {
-					const generation = ++lifecycleGeneration;
-					sessionSnapshot = { event, ctx, generation };
-					if (loadedHeavy) {
-						replayedGeneration = generation;
-						await dispatchHandlers(loadedHeavy, "session_start", event, ctx);
-					}
-				});
-				break;
-			case "session_shutdown":
-				pi.on("session_shutdown", async (event, ctx) => {
-					++lifecycleGeneration;
-					activeLifecycle.turnStart = null;
-					activeLifecycle.agentStart = null;
-					activeLifecycle.activeTools.clear();
-					activeLifecycle.modelSelect = null;
-					if (loadedHeavy) {
-						await dispatchHandlers(loadedHeavy, "session_shutdown", event, ctx);
-					}
-					sessionSnapshot = null;
-					replayedGeneration = lifecycleGeneration;
-				});
-				break;
-			case "turn_start":
-				pi.on("turn_start", async (event, ctx) => {
-					activeLifecycle.turnStart = { event, ctx };
-					if (loadedHeavy) await dispatchHandlers(loadedHeavy, "turn_start", event, ctx);
-				});
-				break;
-			case "turn_end":
-				pi.on("turn_end", async (event, ctx) => {
-					activeLifecycle.turnStart = null;
-					activeLifecycle.agentStart = null;
-					activeLifecycle.activeTools.clear();
-					if (loadedHeavy) await dispatchHandlers(loadedHeavy, "turn_end", event, ctx);
-				});
-				break;
-			case "agent_start":
-				pi.on("agent_start", async (event, ctx) => {
-					activeLifecycle.agentStart = { event, ctx };
-					activeLifecycle.activeTools.clear();
-					if (loadedHeavy) await dispatchHandlers(loadedHeavy, "agent_start", event, ctx);
-				});
-				break;
-			case "agent_end":
-				pi.on("agent_end", async (event, ctx) => {
-					activeLifecycle.agentStart = null;
-					activeLifecycle.activeTools.clear();
-					if (loadedHeavy) await dispatchHandlers(loadedHeavy, "agent_end", event, ctx);
-				});
-				break;
-			case "tool_execution_start":
-				pi.on("tool_execution_start", async (event, ctx) => {
-					const toolCallId = getToolCallId(event);
-					if (toolCallId) activeLifecycle.activeTools.set(toolCallId, { event, ctx });
-					if (loadedHeavy) await dispatchHandlers(loadedHeavy, "tool_execution_start", event, ctx);
-				});
-				break;
-			case "tool_execution_end":
-				pi.on("tool_execution_end", async (event, ctx) => {
-					const toolCallId = getToolCallId(event);
-					if (toolCallId) activeLifecycle.activeTools.delete(toolCallId);
-					if (loadedHeavy) await dispatchHandlers(loadedHeavy, "tool_execution_end", event, ctx);
-				});
-				break;
-			case "model_select":
-				pi.on("model_select", async (event, ctx) => {
-					activeLifecycle.modelSelect = { event, ctx };
-					if (loadedHeavy) await dispatchHandlers(loadedHeavy, "model_select", event, ctx);
-				});
-				break;
+	pi.on("session_start", async (event, ctx) => {
+		const generation = ++lifecycleGeneration;
+		sessionSnapshot = { event, ctx, generation };
+		if (loadedHeavy) {
+			replayedGeneration = generation;
+			await dispatchHandlers(loadedHeavy, "session_start", event, ctx);
 		}
-	}
+	});
+
+	pi.on("session_shutdown", async (event, ctx) => {
+		++lifecycleGeneration;
+		activeLifecycle.turnStart = null;
+		activeLifecycle.agentStart = null;
+		activeLifecycle.activeTools.clear();
+		activeLifecycle.modelSelect = null;
+		if (loadedHeavy) {
+			await dispatchHandlers(loadedHeavy, "session_shutdown", event, ctx);
+		}
+		sessionSnapshot = null;
+		replayedGeneration = lifecycleGeneration;
+	});
+
+	pi.on("turn_start", async (event, ctx) => {
+		activeLifecycle.turnStart = { event, ctx };
+		if (loadedHeavy) await dispatchHandlers(loadedHeavy, "turn_start", event, ctx);
+	});
+
+	pi.on("turn_end", async (event, ctx) => {
+		activeLifecycle.turnStart = null;
+		activeLifecycle.agentStart = null;
+		activeLifecycle.activeTools.clear();
+		if (loadedHeavy) await dispatchHandlers(loadedHeavy, "turn_end", event, ctx);
+	});
+
+	pi.on("agent_start", async (event, ctx) => {
+		activeLifecycle.agentStart = { event, ctx };
+		activeLifecycle.activeTools.clear();
+		if (loadedHeavy) await dispatchHandlers(loadedHeavy, "agent_start", event, ctx);
+	});
+
+	pi.on("agent_end", async (event, ctx) => {
+		activeLifecycle.agentStart = null;
+		activeLifecycle.activeTools.clear();
+		if (loadedHeavy) await dispatchHandlers(loadedHeavy, "agent_end", event, ctx);
+	});
+
+	pi.on("tool_execution_start", async (event, ctx) => {
+		activeLifecycle.activeTools.set(event.toolCallId, { event, ctx });
+		if (loadedHeavy) await dispatchHandlers(loadedHeavy, "tool_execution_start", event, ctx);
+	});
+
+	pi.on("tool_execution_end", async (event, ctx) => {
+		activeLifecycle.activeTools.delete(event.toolCallId);
+		if (loadedHeavy) await dispatchHandlers(loadedHeavy, "tool_execution_end", event, ctx);
+	});
+
+	pi.on("model_select", async (event, ctx) => {
+		activeLifecycle.modelSelect = { event, ctx };
+		if (loadedHeavy) await dispatchHandlers(loadedHeavy, "model_select", event, ctx);
+	});
 
 	pi.registerShortcut("alt+m", {
 		description: "Open session intercom overlay",
@@ -322,7 +354,7 @@ export default function intercom(pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "intercom",
 		label: "Intercom",
-		description: `Send a message to another pi session running on this machine.
+		description: `Send a message to another local agent session running on this machine.
 Use this to communicate findings, request help, or coordinate work with other sessions.
 
 Usage:
@@ -332,7 +364,7 @@ Usage:
   intercom({ action: "reply", message: "..." })                      → Reply to the active/single pending ask
   intercom({ action: "pending" })                                      → List unresolved inbound asks
   intercom({ action: "status" })                  → Show connection status`,
-		promptSnippet: "Use to coordinate with other local pi sessions: list peers, send updates, ask for help, or check intercom connectivity.",
+		promptSnippet: "Use to coordinate with other local agent sessions: list peers, send updates, ask for help, or check intercom connectivity.",
 		parameters: Type.Object({
 			action: Type.String({ description: "Action: 'list', 'send', 'ask', 'reply', 'pending', or 'status'" }),
 			to: Type.Optional(Type.String({ description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')" })),

package/dist/builtin/intercom/intercom-tool.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@bastani/atomic";
 import { randomUUID } from "crypto";
 import { Type } from "typebox";
-import { Text } from "@mariozechner/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
 import type { IntercomClient } from "./broker/client.ts";
 import type { Message } from "./types.ts";
 import { renderIntercomResult } from "./result-renderers.js";
@@ -30,7 +30,7 @@ export function registerIntercomTool(pi: ExtensionAPI, deps: IntercomToolDeps):
   pi.registerTool({
     name: "intercom",
     label: "Intercom",
-    description: `Send a message to another pi session running on this machine.
+    description: `Send a message to another local agent session running on this machine.
 Use this to communicate findings, request help, or coordinate work with other sessions.
 
 Usage:
@@ -41,7 +41,7 @@ Usage:
   intercom({ action: "pending" })                                      → List unresolved inbound asks
   intercom({ action: "status" })                  → Show connection status`,
     promptSnippet:
-      "Use to coordinate with other local pi sessions: list peers, send updates, ask for help, or check intercom connectivity.",
+      "Use to coordinate with other local agent sessions: list peers, send updates, ask for help, or check intercom connectivity.",
 
     parameters: Type.Object({
       action: Type.String({
@@ -104,6 +104,7 @@ Usage:
             return {
               content: [{ type: "text", text: `${currentSection}\n\n${otherSection}` }],
               isError: false,
+              details: {},
             };
           } catch (error) {
             return {
@@ -141,6 +142,7 @@ Usage:
                 return {
                   content: [{ type: "text", text: "Message cancelled by user" }],
                   isError: false,
+                  details: {},
                 };
               }
             }
@@ -268,6 +270,7 @@ Usage:
             return {
               content: [{ type: "text", text: `**Reply from ${to}:**\n${replyText}${replyAttachments}` }],
               isError: false,
+              details: {},
             };
           } catch (error) {
             rejectReplyWaiter(toError(error));
@@ -343,6 +346,7 @@ Usage:
             return {
               content: [{ type: "text", text: "No unresolved inbound asks." }],
               isError: false,
+              details: {},
             };
           }
 
@@ -355,6 +359,7 @@ Usage:
           return {
             content: [{ type: "text", text: `**Pending asks:**\n${lines.join("\n")}` }],
             isError: false,
+            details: {},
           };
         }
 
@@ -368,6 +373,7 @@ Usage:
                 text: `**Intercom Status:**\nConnected: Yes\nSession ID: ${mySessionId}\nActive sessions: ${sessions.length}`,
               }],
               isError: false,
+              details: {},
             };
           } catch (error) {
             return {

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.5-alpha.7",
+  "version": "0.9.5-alpha.9",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [
@@ -29,6 +29,14 @@
     "CHANGELOG.md",
     "LICENSE"
   ],
+  "atomic": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
   "pi": {
     "extensions": [
       "./index.ts"
@@ -50,6 +58,7 @@
     }
   },
   "dependencies": {
+    "tsx": "^4.20.6",
     "typebox": "^1.1.24"
   }
 }

package/dist/builtin/intercom/result-renderers.ts

@@ -1,5 +1,5 @@
 import type { ToolDefinition } from "@bastani/atomic";
-import { Text } from "@mariozechner/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
 
 type ToolResultRenderer = NonNullable<ToolDefinition["renderResult"]>;
 type ToolRenderResultArgs = Parameters<ToolResultRenderer>;

package/dist/builtin/intercom/ui/compose.ts

@@ -1,5 +1,5 @@
-import type { Component, TUI } from "@mariozechner/pi-tui";
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { KeybindingsManager, Theme } from "@bastani/atomic";
 import type { IntercomClient } from "../broker/client.js";
 import type { SessionInfo } from "../types.js";

package/dist/builtin/intercom/ui/inline-message.ts

@@ -1,5 +1,5 @@
-import type { Component } from "@mariozechner/pi-tui";
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import type { Component } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { Theme } from "@bastani/atomic";
 import type { SessionInfo, Message } from "../types.js";
 

package/dist/builtin/intercom/ui/session-list.ts

@@ -1,5 +1,5 @@
-import type { Component } from "@mariozechner/pi-tui";
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { Component } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { KeybindingsManager, Theme } from "@bastani/atomic";
 import type { SessionInfo } from "../types.js";
 

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.5-alpha.9] - 2026-07-09
+
+### Changed
+
+- Improved startup responsiveness by keeping first-run/default lazy MCP metadata bootstrap out of `initializeMcp()`'s synchronous path. Cached direct tools and the MCP proxy still register immediately, explicit `eager`/`keep-alive` servers still connect during initialization, missing configured or `MCP_DIRECT_TOOLS`-selected direct-tool metadata is warmed in the background, and explicit proxy `search`, `describe`, and server-list requests hydrate cold-cache lazy server metadata on demand instead of broadening startup warmup. Warmed direct tools are registered live in the current session after metadata refresh rather than requiring restart. Cold-cache `describe` first narrows hydration to prefix-matched or explicitly requested servers, treats hyphen/underscore prefixes as aliases, and does not fan out to unrelated lazy servers after a prefix-directed miss; cold-cache proxy `search` intentionally hydrates all matching lazy servers so unscoped searches can see every configured tool.
+
+### Fixed
+
+- Aligned MCP tool result expansion hints with the CLI-wide `Ctrl+o` keybinding copy.
+- Fixed MCP background direct-tool warmup cancellation so stale in-flight connects are discarded before metadata/cache mutation, direct-tool refresh callbacks are guarded to the active session, completed warmups clear their active handle safely, and env-selected direct tool servers hydrate without forcing every lazy server eager.
+
 ## [0.9.4] - 2026-07-03
 
 ### Changed

package/dist/builtin/mcp/README.md

@@ -65,7 +65,7 @@ Precedence is:
 3. `.mcp.json`
 4. `.pi/mcp.json`
 
-Servers are **lazy by default** — they won't connect until you actually call one of their tools. The adapter caches tool metadata so search and describe work without live connections.
+Servers are **lazy by default** — they won't connect until you actually call one of their tools. The adapter caches tool metadata so search and describe work without live connections when a valid cache exists; on a cold cache, explicit proxy search/describe/server-list requests may connect lazy server(s) once to hydrate metadata on demand. `describe` narrows cold-cache hydration to an explicitly requested server or the server identified by the configured tool-name prefix before falling back to broader discovery. Unscoped `search` intentionally hydrates every configured lazy server that lacks cached metadata so the search can see all available tools.
 
 ```
 mcp({ search: "screenshot" })
@@ -136,7 +136,7 @@ Pi-specific files are the write targets for imported or shared global servers wh
 
 ### Lifecycle Modes
 
-- **`lazy`** (default) — Don't connect at startup. Connect on first tool call. Disconnect after idle timeout. Cached metadata keeps search/list working without connections.
+- **`lazy`** (default) — Don't connect at startup. Connect on first tool call or explicit cold-cache proxy metadata request (`search`, `describe`, or `server` list). Disconnect after idle timeout. Cached metadata keeps search/list working without connections.
 - **`eager`** — Connect at startup but don't auto-reconnect if the connection drops. No idle timeout by default (set `idleTimeout` explicitly to enable).
 - **`keep-alive`** — Connect at startup. Auto-reconnect via health checks. No idle timeout. Use for servers you always need available.
 
@@ -232,7 +232,7 @@ To exclude specific tools while still using `directTools: true`, add `excludeToo
 
 Each direct tool costs ~150-300 tokens in the system prompt (name + description + schema). Good for targeted sets of 5-20 tools. For servers with 75+ tools, stick with the proxy or pick specific tools with a `string[]`.
 
-Direct tools register from the metadata cache in the Pi agent dir (`~/.pi/agent/mcp-cache.json` by default, or `$PI_CODING_AGENT_DIR/mcp-cache.json` when set), so no server connections are needed at startup. On the first session after adding `directTools` to a new server, the cache won't exist yet — tools fall back to proxy-only and the cache populates in the background. To force it: `/mcp reconnect <server>`.
+Direct tools register from the metadata cache in the Pi agent dir (`~/.pi/agent/mcp-cache.json` by default, or `$PI_CODING_AGENT_DIR/mcp-cache.json` when set), so no server connections are needed at startup when the cache is warm. On the first session after adding `directTools` to a new server, or when a child/subagent selects tools through `MCP_DIRECT_TOOLS`, the cache may not exist yet — tools fall back to proxy-only while the selected/configured direct-tool servers populate in the background, then the extension refreshes tool registration so the warmed direct tools become available in the current session. To force it immediately: `/mcp reconnect <server>`.
 
 When you change direct-tool toggles in `/mcp` or write new config through `/mcp setup`, the extension triggers Pi's normal reload flow automatically. That refreshes extensions, prompts, skills, and MCP tool registration in one shot, so newly configured direct tools can appear without a manual restart.
 
@@ -332,7 +332,7 @@ Prefer `.mcp.json` for project-local shared MCP config. Use `.pi/mcp.json` only
 | Connect | `mcp({ connect: "server-name" })` |
 | UI messages | `mcp({ action: "ui-messages" })` |
 
-MCP proxy and direct-tool results render compactly by default: long text shows the first three lines plus a `CTRL+O Expand` hint, while the full result remains available when expanded and is still returned unchanged to the model.
+MCP proxy and direct-tool results render compactly by default: long text shows the first three lines plus a `Ctrl+o Expand` hint, while the full result remains available when expanded and is still returned unchanged to the model.
 
 Search includes both MCP tools and Pi tools (from extensions). Pi tools appear first with `[pi tool]` prefix. Space-separated words are OR'd.
 
@@ -358,8 +358,8 @@ In interactive sessions, you can also authenticate from `/mcp` with `CTRL+A` or
 ## How It Works
 
 - One `mcp` tool in context (~200 tokens) instead of hundreds
-- Servers are lazy by default — they connect on first tool call, not at startup
-- Tool metadata is cached to disk so search/list/describe work without live connections
+- Servers are lazy by default — they connect on first tool call or explicit cold-cache proxy metadata request, not at startup
+- Tool metadata is cached to disk so search/list/describe work without live connections when the cache is valid; cold-cache explicit search/describe/server-list requests hydrate metadata on demand
 - Idle servers disconnect after 10 minutes (configurable), reconnect automatically on next use
 - npx-based servers resolve to direct binary paths, skipping the ~143 MB npm parent process
 - MCP server validates arguments, not the adapter