@herbertgao/pi-extensions 2026.9.14 → 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-multi-account/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [1.23.2] — 2026-09-24
+
+### Fixed
+
+- Sessions hosted by pi-web's session daemon no longer deactivate after the first one. The in-process root-activation lease (designed for terminal Pi's `/reload` and in-process children) misclassified every later pi-web session as a subagent child, leaving it in `subagent-child-passive` mode with failover, preflight and auto-continue silently disabled. When `PI_WEB_SESSION=1` is present, each session now activates as an independent root; any other multi-session SDK host can opt in with the host-neutral `PI_MULTI_ACCOUNT_INDEPENDENT_ROOTS=1`. Genuine pi-subagents children still run in a runner process marked `PI_SUBAGENT_CHILD=1` and remain passive.
+- In-process independent roots and same-session rehydrates now share a process-scoped canonical child proxy and publication lifetime. A sibling can exit in either order without restoring real OAuth into child-facing `auth.json` or orphaning `models.json` loopback routes; only the final root closes the listener and restores auth. A root whose proxy is disabled still retires public numbered aliases before another root publishes placeholders, and keeps that listener alive through handoff. The surviving root handles newly discovered slots, while explicit `PI_SUBAGENT_CHILD` remains passive.
 
 ## [1.23.1] — 2026-09-23