@herbertgao/pi-extensions 2026.9.15 → 2026.9.16

package/node_modules/pi-mcp-adapter/index.ts

@@ -342,7 +342,7 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
   const reportedDirectToolNamesByServer = new Map<string, Set<string>>();
   const registeredNamespaceProxyTools = new Set<string>();
   const fallbackDeactivatedTools = new Set<string>();
-  // directTools: "search" — registered inactive, activated by mcp({ search }).
+  // directTools: "search" — registered inactive, activated by mcp({ search }) or a successful mcp({ tool }) call.
   const lazyDirectTools = new Set<string>();
   const searchActivatedTools = new Set<string>();
   const toolRenderOptions = resolveMcpToolRenderOptions(earlyConfig.settings);
@@ -450,10 +450,10 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
   }
 
   /**
-   * Activate the lazy direct tools a search matched, additively. This is the
-   * one place a search-mode tool becomes active; nothing is ever deactivated
-   * here. Returns the names that actually changed state so the result can
-   * report only real additions.
+   * Activate lazy direct tools additively — the ones a search matched, or the
+   * one a successful proxy call named. This is the one place a search-mode tool
+   * becomes active; nothing is ever deactivated here. Returns the names that
+   * actually changed state so the result can report only real additions.
    */
   function activateSearchMatches(matches: ReadonlyArray<{ server: string; tool: string }>): string[] {
     const activeTools = getActiveToolsIfReady();
@@ -502,17 +502,14 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
     const unregisterTool = (pi as ExtensionAPI & { unregisterTool?: (name: string) => boolean }).unregisterTool;
     const unregistered = toolNames.filter((toolName) => callReentrant(() => unregisterTool?.(toolName)) === true);
     const fallbackNames = toolNames.filter((toolName) => !unregistered.includes(toolName));
-    const remove = new Set(toolNames);
     const activeTools = getActiveToolsIfReady();
-    if (!activeTools || activeTools.length === 0) {
-      for (const toolName of fallbackNames) fallbackDeactivatedTools.add(toolName);
-      return unregistered;
-    }
+    if (!activeTools) return unregistered;
+    const removedFallbackNames = fallbackNames.filter((name) => activeTools.includes(name));
+    if (removedFallbackNames.length === 0) return unregistered;
+    const remove = new Set(removedFallbackNames);
     const nextActiveTools = activeTools.filter((name) => !remove.has(name));
-    if (nextActiveTools.length !== activeTools.length) {
-      for (const toolName of fallbackNames) fallbackDeactivatedTools.add(toolName);
-      callReentrant(() => pi.setActiveTools(nextActiveTools));
-    }
+    callReentrant(() => pi.setActiveTools(nextActiveTools));
+    for (const toolName of removedFallbackNames) fallbackDeactivatedTools.add(toolName);
     return unregistered;
   }
 
@@ -1508,7 +1505,7 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
     (pi.registerTool as (tool: unknown) => unknown)({
       name: "mcpScript",
       label: "MCP Script",
-      description: "Run trusted JavaScript that makes multiple MCP tool calls in one request — loop, filter, chain, or fan out between calls. For a single MCP call, search, describe, status check, or auth action, use the mcp tool instead. Discover with await tools.search({ query }) — resolves to { items: [{ path, name, server, description? }], total, hasMore, nextOffset }, not an { ok, data } envelope. Inspect with await tools.describe({ path }) — resolves to the tool descriptor with inputTypeScript, or { path, error: { code, message, suggestions } }. Then call tools.call(path, args) — resolves to { ok: true, data } or { ok: false, error: { code, message } } — or use direct flat calls when the name is already known; use emit(value) for user-visible output. Load the mcp-scripting skill for the full workflow guide.",
+      description: "Run trusted JavaScript that makes multiple MCP tool calls in one request — loop, filter, chain, or fan out between calls. For a single MCP call, search, describe, status check, or auth action, use the mcp tool instead. Discover with await tools.search({ query }) — resolves to { items: [{ path, name, server, description? }], total, hasMore, nextOffset }, not an { ok, data } envelope. Inspect with await tools.describe({ path }) — resolves to the tool descriptor with inputTypeScript, or { path, error: { code, message, suggestions } }. Then call tools.call(path, args) — resolves to { ok: true, data } or { ok: false, error: { code, message } } — or use direct flat calls when the name is already known; use emit(value) for user-visible output.",
       promptSnippet: "Batch multiple MCP tool calls in one JavaScript request (loop, filter, chain)",
       parameters: Type.Object({
         code: Type.String({ description: "Trusted JavaScript MCP script. Use tools.<prefixedToolName>(args) and emit(value)." }),
@@ -1939,7 +1936,23 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
             : proxyModes.executeAuthComplete(proxyState, params.server, input);
         }
         if (params.tool) {
-          return proxyModes.executeCall(proxyState, params.tool, parsedArgs, params.server, getPiTools, signal);
+          const result = await proxyModes.executeCall(proxyState, params.tool, parsedArgs, params.server, getPiTools, signal);
+          assertRuntimeGuard(proxyGuard);
+          if (lazyDirectTools.size === 0) return result;
+          // A successful proxy call is as clear a signal as a search hit: the
+          // model wants this tool. Activate it the same additive way, keyed on
+          // the registered (prefixed) name the call reports as canonicalTool.
+          // Failed calls (lookup, approval, tool errors) carry details.error
+          // and activate nothing.
+          const identity = result.details as { error?: unknown; server?: unknown; canonicalTool?: unknown } | undefined;
+          if (!identity || identity.error !== undefined || typeof identity.server !== "string" || typeof identity.canonicalTool !== "string") return result;
+          holdLazyToolsInactive();
+          const added = activateSearchMatches([{ server: identity.server, tool: identity.canonicalTool }]);
+          if (added.length === 0) return result;
+          // Content is returned untouched: the call's output is already sized to
+          // the output limits and is what a compact view previews. The tool
+          // description tells the model a called tool is direct from then on.
+          return { ...result, details: { ...(result.details ?? {}), activated: added }, addedToolNames: added };
         }
         if (params.connect) {
           return connectAndReport(proxyState, params.connect, signal, _ctx as ExtensionContext);
@@ -1982,8 +1995,8 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
       cache,
       envRaw === undefined || envRaw === "__none__" ? undefined : envDirectToolOverride,
     );
-    // Search-mode tools are registered INACTIVE and `mcp({ search })` is their only
-    // activation entry point, so dropping the gateway strands them: every tool held, nothing
+    // Search-mode tools are registered INACTIVE and the `mcp` gateway (search, or a
+    // proxy call) is their only activation entry point, so dropping it strands them: every tool held, nothing
     // able to activate one. Keep it whenever any spec depends on it.
     const hasSearchModeSpecs = directSpecs.some((spec) => spec.lazy === true);
     const shouldRegisterProxyTool =
@@ -1999,10 +2012,14 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
         finalizationRegistrations?.add("mcp");
         registerProxyTool(description);
         finalizationGuard?.();
-        return;
       }
       const activeTools = getActiveToolsIfReady();
-      if (activeTools && !activeTools.includes("mcp")) {
+      if (activeTools?.includes("mcp")) {
+        // Observed host reactivation ends our fallback ownership. A later
+        // host removal must not be mistaken for our own deactivation.
+        fallbackDeactivatedTools.delete("mcp");
+      } else if (activeTools && fallbackDeactivatedTools.delete("mcp")) {
+        // Only undo a fallback deactivation that the adapter still owns.
         callReentrant(() => pi.setActiveTools([...activeTools, "mcp"]));
       }
       return;

package/node_modules/pi-mcp-adapter/init.ts

@@ -267,28 +267,27 @@ export async function initializeMcp(
 
   const allServerEntries = Object.entries(config.mcpServers);
   const serverEntries = allServerEntries.filter(([, definition]) => !isServerDisabled(definition));
-  if (serverEntries.length === 0) {
-    if (allServerEntries.length > 0 && hasUI) {
-      ui?.notify(`MCP: All ${allServerEntries.length} server(s) are disabled`, "info");
-    }
-    publishMcpStatusSnapshot(state);
-    return state;
+  if (serverEntries.length === 0 && allServerEntries.length > 0 && hasUI) {
+    ui?.notify(`MCP: All ${allServerEntries.length} server(s) are disabled`, "info");
   }
 
   const idleSetting = typeof config.settings?.idleTimeout === "number" ? config.settings.idleTimeout : 10;
   lifecycle.setGlobalIdleTimeout(idleSetting);
 
-  const cachePath = getMetadataCachePath();
-  const cacheFileExists = existsSync(cachePath);
-  let cache = loadMetadataCache();
+  let cache: ReturnType<typeof loadMetadataCache> = null;
   let bootstrapAll = false;
 
-  if (!cacheFileExists) {
-    bootstrapAll = true;
-    saveMetadataCache({ version: 1, servers: {} });
-  } else if (!cache) {
-    cache = { version: 1, servers: {} };
-    saveMetadataCache(cache);
+  if (serverEntries.length > 0) {
+    const cachePath = getMetadataCachePath();
+    const cacheFileExists = existsSync(cachePath);
+    cache = loadMetadataCache();
+    if (!cacheFileExists) {
+      bootstrapAll = true;
+      saveMetadataCache({ version: 1, servers: {} });
+    } else if (!cache) {
+      cache = { version: 1, servers: {} };
+      saveMetadataCache(cache);
+    }
   }
 
   const prefix = config.settings?.toolPrefix ?? "server";

package/node_modules/pi-mcp-adapter/json-schema-validator.ts

@@ -11,6 +11,20 @@ import type {
 // ajv-formats types target its bundled ajv; the runtime accepts both instances.
 const addFormats = addFormatsImport as unknown as (instance: Ajv) => void;
 
+// Rust servers built with schemars annotate numbers with these formats. The
+// `type`, `minimum`, and `maximum` keywords already carry the constraint, so
+// registering them as always-valid only stops Ajv's "unknown format" warnings.
+// int32, int64, float, and double are omitted: ajv-formats validates them.
+const SCHEMARS_NUMERIC_FORMATS = [
+  "int", "int8", "int16", "int128",
+  "uint", "uint8", "uint16", "uint32", "uint64", "uint128",
+];
+
+function addKnownFormats(ajv: Ajv): void {
+  addFormats(ajv);
+  for (const format of SCHEMARS_NUMERIC_FORMATS) ajv.addFormat(format, true);
+}
+
 type SchemaDialect =
   | { status: "unstamped" }
   | { status: "stamped"; uri: string };
@@ -44,7 +58,7 @@ export function createJsonSchemaValidator(): JsonSchemaValidatorProvider {
         draft2020Validator ??= (() => {
           const Ajv2020 = Ajv2020Import as unknown as typeof Ajv;
           const ajv = new Ajv2020({ strict: false, allErrors: true });
-          addFormats(ajv);
+          addKnownFormats(ajv);
           return new AjvJsonSchemaValidator(ajv);
         })();
         return draft2020Validator.getValidator<T>(schema);
@@ -60,7 +74,7 @@ export function createJsonSchemaValidator(): JsonSchemaValidatorProvider {
           validateSchema: false,
           allErrors: true,
         });
-        addFormats(ajv);
+        addKnownFormats(ajv);
         return new AjvJsonSchemaValidator(ajv);
       })();
       return draft07Validator.getValidator<T>(schema);

package/node_modules/pi-mcp-adapter/mcp-auth.ts

@@ -210,6 +210,7 @@ interface AuthEntryChunkManifest {
 }
 
 let KeyringEntryClass: KeyringEntryConstructor | undefined;
+const keyringEntries = new Map<string, KeyringEntry>();
 const memoryAuthEntries = new Map<string, string>();
 
 let testAuthSecretStoreReadCount = 0;
@@ -238,12 +239,29 @@ const memoryAuthSecretStore: AuthSecretStore = {
 
 const keyringAuthSecretStore: AuthSecretStore = {
   read(account) {
-    return getKeyringEntry(account).getPassword() ?? undefined;
+    const cached = keyringEntries.get(account);
+    if (cached) {
+      try {
+        // keyring v2 throws for provider/session failures; null means the credential is absent.
+        return cached.getPassword() ?? undefined;
+      } catch {
+        // A stale native Entry may survive a keyring daemon restart. Retry once.
+      }
+      keyringEntries.delete(account);
+    }
+    const fresh = getKeyringEntry(account);
+    const value = fresh.getPassword();
+    keyringEntries.set(account, fresh);
+    return value ?? undefined;
   },
   write(account, payload) {
-    getKeyringEntry(account).setPassword(payload);
+    keyringEntries.delete(account);
+    const fresh = getKeyringEntry(account);
+    fresh.setPassword(payload);
+    keyringEntries.set(account, fresh);
   },
   remove(account) {
+    keyringEntries.delete(account);
     getKeyringEntry(account).deleteCredential();
   },
 };
@@ -305,9 +323,16 @@ const keyRevokedAuthSecretStore: AuthSecretStore = {
 export function resetTestAuthSecretStore(): void {
   memoryAuthEntries.clear();
   authEntryCache.clear();
+  keyringEntries.clear();
   testAuthSecretStoreReadCount = 0;
 }
 
+/** Install a fake native Entry for OAuth storage tests without opening a real keyring. */
+export function setTestKeyringEntryClass(entryClass: KeyringEntryConstructor | undefined): void {
+  keyringEntries.clear();
+  KeyringEntryClass = entryClass;
+}
+
 export function resetAuthEntryCache(): void {
   authEntryCache.clear();
 }

package/node_modules/pi-mcp-adapter/metadata-cache.ts

@@ -86,7 +86,7 @@ export function computeServerHash(definition: ServerEntry, environment: NodeJS.P
   // Exclude lifecycle, idleTimeout, requestTimeoutMs, debug — those are runtime behavior settings
   // that don't change which tools a server exposes.
   const identity: Record<string, unknown> = {
-    command: definition.command,
+    command: resolveConfigPath(definition.command, environment),
     args: definition.args,
     socket: resolveConfigPath(definition.socket, environment),
     env: isBuiltInAgentPlugin(definition, "env") ? definition.env : interpolateEnvRecord(definition.env, environment),

package/node_modules/pi-mcp-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-adapter",
-  "version": "2.37.0",
+  "version": "2.38.0",
   "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
   "type": "module",
   "types": "./index.ts",
@@ -163,6 +163,7 @@
     "banner.png",
     "skills",
     "README.md",
+    "OAUTH.md",
     "CHANGELOG.md",
     "LICENSE",
     "dist"
@@ -172,7 +173,7 @@
     "@modelcontextprotocol/core": "2.0.0",
     "@modelcontextprotocol/ext-apps": "^1.2.2",
     "@modelcontextprotocol/ext-tasks": "^0.1.0",
-    "@napi-rs/keyring": "^1.3.0",
+    "@napi-rs/keyring": "^2.1.0",
     "@typesafe-ai/sdk": "0.6.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",

package/node_modules/pi-mcp-adapter/proxy-modes.ts

@@ -1374,7 +1374,7 @@ export async function executeCall(
   }
 
   const callIdentity = toolMeta.resourceUri
-    ? { server: serverName, resourceUri: toolMeta.resourceUri }
+    ? { server: serverName, resourceUri: toolMeta.resourceUri, canonicalTool: toolMeta.name }
     : { server: serverName, tool: toolMeta.originalName, canonicalTool: toolMeta.name };
 
   let connection = state.manager.getConnection(serverName);

package/node_modules/pi-mcp-adapter/server-manager.ts

@@ -63,6 +63,7 @@ import { attachTaskSession, type RawRequestChannel } from "./mcp-tasks.ts";
 import type { TaskEnabledSession } from "@modelcontextprotocol/ext-tasks/client";
 import {
   interpolateEnvVars,
+  expandHomePath,
   resolveBearerToken,
   resolveCommandSecret,
   resolveCommandSecretsRecord,
@@ -1044,11 +1045,13 @@ export class McpServerManager {
 
     if (definition.command) {
       client = this.createClient(name, definition);
-      let command = definition.command;
+      let command = resolveConfigPath(definition.command) ?? definition.command;
       const literalArgs = isBuiltInAgentPlugin(definition, "args");
       const literalCwd = isBuiltInAgentPlugin(definition, "cwd");
-      let args = literalArgs ? [...(definition.args ?? [])] : (definition.args ?? []).map((argument) => interpolateEnvVars(argument));
-      const cwd = (literalCwd ? definition.cwd : resolveConfigPath(definition.cwd)) ?? this.defaultCwd;
+      let args = literalArgs
+        ? [...(definition.args ?? [])]
+        : (definition.args ?? []).map((argument) => expandHomePath(interpolateEnvVars(argument)) ?? argument);
+      const cwd = (literalCwd ? expandHomePath(definition.cwd) : resolveConfigPath(definition.cwd)) ?? this.defaultCwd;
       if (definition.pluginDataDir) mkdirSync(definition.pluginDataDir, { recursive: true });
       if (cwd !== undefined) {
         const cwdStats = statSync(cwd, { throwIfNoEntry: false });

package/node_modules/pi-mcp-adapter/tool-result-renderer.ts

@@ -75,6 +75,8 @@ class CompactMcpToolResult implements Component {
     private readonly inputPreview: string,
     private readonly display: McpToolResultDisplay,
     private readonly theme: RenderTheme,
+    /** Shown after the title and never truncated; the title shrinks instead (e.g. `✗3`). */
+    private readonly status = "",
   ) {}
 
   render(width: number): string[] {
@@ -113,17 +115,23 @@ class CompactMcpToolResult implements Component {
   private renderPrefix(width: number): string {
     if (!this.title) return "";
     const arrow = " → ";
-    if (!this.inputPreview) return `${this.theme.fg("toolTitle", this.title)}${arrow}`;
+    const statusWidth = this.status ? visibleWidth(this.status) + 1 : 0;
+    const head = (maxWidth?: number) => {
+      const title = maxWidth === undefined
+        ? this.title
+        : truncateToWidth(this.title, Math.max(1, maxWidth - statusWidth), "…");
+      const status = this.status ? ` ${this.theme.fg("error", this.status)}` : "";
+      return `${this.theme.fg("toolTitle", title)}${status}`;
+    };
+    if (!this.inputPreview) return `${head()}${arrow}`;
 
     const maxPrefixWidth = Math.max(12, Math.floor(width * 0.55));
-    const titleWidth = visibleWidth(this.title);
+    const titleWidth = visibleWidth(this.title) + statusWidth;
     const inputWidth = Math.max(0, maxPrefixWidth - titleWidth - 1);
-    if (inputWidth <= 3) {
-      return `${this.theme.fg("toolTitle", truncateToWidth(this.title, maxPrefixWidth, "…"))}${arrow}`;
-    }
+    if (inputWidth <= 3) return `${head(maxPrefixWidth)}${arrow}`;
 
     const input = truncateToWidth(this.inputPreview, inputWidth, "…");
-    return `${this.theme.fg("toolTitle", this.title)} ${this.theme.fg("muted", input)}${arrow}`;
+    return `${head()} ${this.theme.fg("muted", input)}${arrow}`;
   }
 }
 
@@ -326,11 +334,91 @@ export function createMcpDirectToolCallRenderer(displayName: string, options = r
 
 export function createMcpScriptToolCallRenderer(options = resolveMcpToolRenderOptions()) {
   return (args: { code: string }, theme?: RenderTheme, context?: McpToolRenderContext) => {
+    // Compact mode hides this call row once the result lands, so leave a title for the result row.
+    // The tool list comes from the result's `details.calls` trace (see formatMcpScriptCallSummary);
+    // the script code itself is never copied into the compact row.
+    if (context?.state) context.state.compactTitle = MCP_SCRIPT_TITLE;
     if (shouldUseCompactFinalRender(options, context)) return new EmptyComponent();
     return renderToolCallLines(formatMcpScriptToolCallLines(args), theme);
   };
 }
 
+const MCP_SCRIPT_TITLE = "mcpScript";
+const MCP_SCRIPT_SUMMARY_MAX_TOOLS = 4;
+
+export interface McpScriptCallSummary {
+  /** Traced operations that failed; the compact row shows it as `mcpScript ✗N`. */
+  failed: number;
+  /** What the script touched; "" when it made no MCP operations. */
+  preview: string;
+}
+
+const PLAIN_TOOL_PATH = /^[A-Za-z0-9_.\/:@-]+$/;
+
+/**
+ * Traced paths are script-supplied. Only identifier-like paths (what MCP tool names look like)
+ * are shown bare. Anything else is shown as a quoted, ASCII-escaped JSON string, so it cannot
+ * break the row, cannot pass for summary syntax (`foo×2`, `a, b`, ` · `, `+1 more`), and stays
+ * distinct from the clean path it may resemble (`demo_red` vs `"\u001b[31mdemo_red"`).
+ */
+function formatTracedPath(path: string): string {
+  if (PLAIN_TOOL_PATH.test(path)) return path;
+  // JSON.stringify quotes and escapes C0 controls, quotes and backslashes; escaping all other
+  // non-ASCII too rules out DEL, C1 controls, bidi overrides and invisible characters.
+  return JSON.stringify(path).replace(/[^\x20-\x7e]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+
+/**
+ * Failure count and compact-row preview for an mcpScript run, from the `details.calls` trace.
+ * The preview lists distinct tool paths in first-call order with repeat counts, then other
+ * operation counts, e.g. `github_search_issues×6, slack_post_message · search`.
+ * Scripts that only describe tools list the described paths instead (`describe a, b`).
+ * The failure count is rendered as a title status, not in the preview: narrow rows drop the
+ * preview first, and the status is never truncated (the title shrinks instead).
+ * Returns null for non-script results.
+ */
+export function formatMcpScriptCallSummary(
+  details: McpToolResultDetails | undefined,
+  maxTools = MCP_SCRIPT_SUMMARY_MAX_TOOLS,
+): McpScriptCallSummary | null {
+  if (details?.mode !== "script") return null;
+  const operations = Array.isArray(details.calls) ? details.calls : [];
+  const callCounts = new Map<string, number>();
+  const describeCounts = new Map<string, number>();
+  const metaCounts = new Map<string, number>();
+  let failed = 0;
+  for (const operation of operations) {
+    if (typeof operation !== "object" || operation === null) continue;
+    const { operation: kind, path, ok } = operation as { operation?: unknown; path?: unknown; ok?: unknown };
+    if (typeof kind !== "string") continue;
+    if (ok === false) failed += 1;
+    const target = kind === "call" ? callCounts : kind === "describe" ? describeCounts : null;
+    if (target && typeof path === "string") {
+      target.set(path, (target.get(path) ?? 0) + 1);
+    } else {
+      metaCounts.set(kind, (metaCounts.get(kind) ?? 0) + 1);
+    }
+  }
+
+  const withCount = (name: string, count: number) => (count > 1 ? `${name}×${count}` : name);
+  const listPaths = (counts: Map<string, number>) => {
+    const names = [...counts].map(([path, count]) => withCount(formatTracedPath(path), count));
+    return names.length > maxTools
+      ? [...names.slice(0, maxTools), `+${names.length - maxTools} more`].join(", ")
+      : names.join(", ");
+  };
+
+  let tools = listPaths(callCounts);
+  if (!tools && describeCounts.size > 0) {
+    tools = `describe ${listPaths(describeCounts)}`;
+  } else {
+    const describes = [...describeCounts.values()].reduce((sum, count) => sum + count, 0);
+    if (describes > 0) metaCounts.set("describe", describes);
+  }
+  const meta = [...metaCounts].map(([kind, count]) => withCount(kind, count)).join(", ");
+  return { failed, preview: [tools, meta].filter(Boolean).join(" · ") };
+}
+
 function blockToLines(block: McpToolContentBlock): string[] {
   if (block.type === "text") {
     return block.text.split("\n");
@@ -448,6 +536,11 @@ export function renderMcpToolResult(
   const expanded = options.expanded || context?.isError === true || hasErrorDetails;
   if (!expanded && renderOptions.resultRendering === "compact") {
     const display = formatMcpToolResultLines(result, false, renderOptions.collapsedResultLines);
+    const scriptSummary = formatMcpScriptCallSummary(result.details);
+    if (scriptSummary) {
+      const status = scriptSummary.failed > 0 ? `✗${scriptSummary.failed}` : "";
+      return new CompactMcpToolResult(MCP_SCRIPT_TITLE, scriptSummary.preview, display, activeTheme, status);
+    }
     const title = context?.state?.compactTitle ?? formatMcpToolResultIdentity(result.details) ?? "";
     const inputPreview = context?.state?.compactInputPreview ?? "";
     return new CompactMcpToolResult(title, inputPreview, display, activeTheme);

package/node_modules/pi-mcp-adapter/types.ts

@@ -192,7 +192,7 @@ export interface UiServerHandle {
   sessionToken: string;
   serverName: string;
   toolName: string;
-  viewer?: "browser" | "glimpse" | "suppressed";
+  viewer?: "browser" | "glimpse" | "orca" | "suppressed";
   windowOpen?: boolean;
   close: (reason?: string) => void;
   sendToolInput: (args: Record<string, unknown>) => void;
@@ -740,7 +740,7 @@ export interface PromptMetadata {
 }
 
 export interface DirectToolSpec {
-  /** Registered inactive; `mcp({ search })` activates it (directTools: "search"). */
+  /** Registered inactive; `mcp({ search })` or a successful `mcp({ tool })` call activates it (directTools: "search"). */
   lazy?: boolean;
   serverName: string;
   originalName: string;

package/node_modules/pi-mcp-adapter/ui-session.ts

@@ -35,7 +35,7 @@ export interface UiSessionRequest {
   onNeedsAuth?: SessionRecoveryDeps["onNeedsAuth"];
 }
 
-export type UiSessionViewer = "browser" | "glimpse" | "suppressed";
+export type UiSessionViewer = "browser" | "glimpse" | "orca" | "suppressed";
 
 export interface UiSessionRuntime {
   serverName: string;
@@ -143,6 +143,19 @@ async function openInBrowser(state: McpExtensionState, url: string, signal: Abor
   }
 }
 
+async function openInOrcaBrowser(url: string, signal: AbortSignal): Promise<void> {
+  throwIfAborted(signal);
+  await new Promise<void>((resolve, reject) => {
+    execFile("orca", ["goto", "--url", url], { timeout: 10000, signal }, (error) => {
+      if (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
 function isRemoteSession(): boolean {
   return Boolean(process.env.SSH_CONNECTION || process.env.SSH_TTY);
 }
@@ -486,7 +499,6 @@ export async function maybeStartUiSession(
         `If this session is remote, run ssh -L ${handle.port}:127.0.0.1:${handle.port} -L ${handle.proxyPort}:127.0.0.1:${handle.proxyPort} <this-host> first.`,
         "info",
       );
-      log.info("Suppressing MCP UI window (MCP_UI_VIEWER=" + viewerPref + ")", { url: handle.url });
     } else {
       const remoteLikely = remoteByEnv || await hasActiveRemoteLogin();
       const emitRemoteHint = async (openError: string | null, openedOnHost = false) => {
@@ -499,33 +511,17 @@ export async function maybeStartUiSession(
           openedOnHost,
         }), openError === null ? "info" : "warning");
       };
-      const glimpseDetected = !remoteByEnv && isGlimpseAvailable();
-      const useGlimpse = !remoteByEnv && (viewerPref === "glimpse" ||
-        (viewerPref !== "browser" && glimpseDetected));
-
-      if (useGlimpse) {
+      // Handle Orca browser viewer
+      if (viewerPref === "orca") {
         try {
-          const glimpseHtml = `<!DOCTYPE html><html><head><meta charset="utf-8"><style>body{margin:0;padding:0;width:100vw;height:100vh;overflow:hidden}iframe{width:100%;height:100%;border:none}</style></head><body><iframe src="${handle.url}"></iframe></body></html>`;
-          const glimpseWindow = await openGlimpseWindow(glimpseHtml, {
-            title: `MCP · ${request.serverName} · ${request.toolName}`,
-            width: 1000,
-            height: 800,
-            onClosed: () => {
-              if (active) handle.close("glimpse-closed");
-            },
-          });
-          if (state.owner?.isActive() === false || runtimeSignal.aborted) {
-            glimpseWindow.close();
-            throwIfAborted(runtimeSignal);
-            throw new Error("MCP Glimpse window became stale before registration");
-          }
-          activeGlimpseWindow = glimpseWindow;
-          viewer = "glimpse";
+          await openInOrcaBrowser(handle.url, runtimeSignal);
           if (remoteLikely) {
             await emitRemoteHint(null, true);
           }
+          viewer = "orca";
         } catch (error) {
-          log.debug("Glimpse unavailable, using browser", {
+          if (isAbortError(error, runtimeSignal)) throw error;
+          log.debug("Orca browser failed, using fallback", {
             error: error instanceof Error ? error.message : String(error),
           });
           const openError = await openInBrowser(state, handle.url, runtimeSignal);
@@ -535,9 +531,46 @@ export async function maybeStartUiSession(
           viewer = "browser";
         }
       } else {
-        const openError = await openInBrowser(state, handle.url, runtimeSignal);
-        if (openError !== null || remoteLikely) {
-          await emitRemoteHint(openError);
+        const glimpseDetected = !remoteByEnv && isGlimpseAvailable();
+        const useGlimpse = !remoteByEnv && (viewerPref === "glimpse" ||
+          (viewerPref !== "browser" && glimpseDetected));
+
+        if (useGlimpse) {
+          try {
+            const glimpseHtml = `<!DOCTYPE html><html><head><meta charset="utf-8"><style>body{margin:0;padding:0;width:100vw;height:100vh;overflow:hidden}iframe{width:100%;height:100%;border:none}</style></head><body><iframe src="${handle.url}"></iframe></body></html>`;
+            const glimpseWindow = await openGlimpseWindow(glimpseHtml, {
+              title: `MCP · ${request.serverName} · ${request.toolName}`,
+              width: 1000,
+              height: 800,
+              onClosed: () => {
+                if (active) handle.close("glimpse-closed");
+              },
+            });
+            if (state.owner?.isActive() === false || runtimeSignal.aborted) {
+              glimpseWindow.close();
+              throwIfAborted(runtimeSignal);
+              throw new Error("MCP Glimpse window became stale before registration");
+            }
+            activeGlimpseWindow = glimpseWindow;
+            viewer = "glimpse";
+            if (remoteLikely) {
+              await emitRemoteHint(null, true);
+            }
+          } catch (error) {
+            log.debug("Glimpse unavailable, using browser", {
+              error: error instanceof Error ? error.message : String(error),
+            });
+            const openError = await openInBrowser(state, handle.url, runtimeSignal);
+            if (openError !== null || remoteLikely) {
+              await emitRemoteHint(openError);
+            }
+            viewer = "browser";
+          }
+        } else {
+          const openError = await openInBrowser(state, handle.url, runtimeSignal);
+          if (openError !== null || remoteLikely) {
+            await emitRemoteHint(openError);
+          }
         }
       }
     }

package/node_modules/pi-mcp-adapter/utils.ts

@@ -247,10 +247,18 @@ export function resolveServerUrl(definition: Pick<ServerEntry, "url">, environme
 export function resolveConfigPath(value: string | undefined, environment: NodeJS.ProcessEnv = process.env): string | undefined {
   if (value === undefined) return undefined;
 
-  const resolved = interpolateEnvVars(value, environment);
+  return expandHomePath(interpolateEnvVars(value, environment));
+}
+
+/** Expand a leading home-directory marker without interpolating environment variables. */
+export function expandHomePath(value: string | undefined): string | undefined {
+  if (value === undefined) return undefined;
+
+  const resolved = value;
   if (resolved === "~") return homedir();
-  if (resolved.startsWith("~/") || resolved.startsWith("~\\")) {
-    return join(homedir(), resolved.slice(2));
+  if (resolved.startsWith("~/") || (platform() === "win32" && resolved.startsWith("~\\"))) {
+    const suffix = platform() === "win32" ? resolved.slice(2).replace(/[\\/]/g, sep) : resolved.slice(2);
+    return join(homedir(), suffix);
   }
   return resolved;
 }

package/node_modules/pi-next-cue/.github/workflows/publish.yml

@@ -0,0 +1,20 @@
+name: Publish to npm
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org
+          package-manager-cache: false
+      - run: npm publish --access public