@herbertgao/pi-extensions 2026.9.11 → 2026.9.13

package/node_modules/pi-mcp-adapter/elicitation-handler.ts

@@ -11,6 +11,7 @@ import {
 import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
 import type { JsonSchemaType } from "@modelcontextprotocol/client";
 import open from "open";
+import { abortable, throwIfAborted } from "./abort.ts";
 
 export type ElicitationValue = string | number | boolean | string[] | undefined;
 type FormProperty = ElicitRequestFormParams["requestedSchema"]["properties"][string];
@@ -35,49 +36,52 @@ export function registerElicitationHandler(client: Client, options: ElicitationH
 export async function handleElicitationRequest(
   options: ElicitationHandlerOptions,
   request: ElicitRequest,
+  signal?: AbortSignal,
 ): Promise<ElicitResult> {
+  throwIfAborted(signal);
   return request.params.mode === "url"
-    ? handleUrlElicitation(options, request.params)
-    : handleFormElicitation(options, request.params);
+    ? handleUrlElicitation(options, request.params, signal)
+    : handleFormElicitation(options, request.params, signal);
 }
 
 export async function handleFormElicitation(
   options: ElicitationHandlerOptions,
   params: ElicitRequestFormParams,
+  signal?: AbortSignal,
 ): Promise<ElicitResult> {
   const properties = Object.entries(params.requestedSchema.properties);
-  const decision = await options.ui.select(
+  const decision = await abortable(options.ui.select(
     `MCP Input Request\nServer: ${options.serverName}\n\n${params.message}`,
     ["Continue", "Decline"],
-  );
+  ), signal);
   if (decision === undefined) return { action: "cancel" };
   if (decision === "Decline") return { action: "decline" };
   if (properties.length === 0) return { action: "accept", content: {} };
 
   const values: Record<string, ElicitationValue> = {};
   for (const [name, schema] of properties) {
-    const value = await collectValidField(options.ui, params, name, schema);
+    const value = await collectValidField(options.ui, params, name, schema, undefined, signal);
     if (value.status === "cancelled") return { action: "cancel" };
     values[name] = value.value;
   }
 
   while (true) {
     const content = coerceAndValidateFormValues(params, values);
-    const action = await options.ui.select(
+    const action = await abortable(options.ui.select(
       formatReview(options.serverName, properties, content),
       ["Submit", "Edit", "Decline"],
-    );
+    ), signal);
     if (action === undefined) return { action: "cancel" };
     if (action === "Decline") return { action: "decline" };
     if (action === "Submit") return { action: "accept", content };
 
     const labels = properties.map(([name, schema]) => `${schema.title ?? humanizeName(name)} (${name})`);
-    const selected = await options.ui.select("Choose a field to edit", labels);
+    const selected = await abortable(options.ui.select("Choose a field to edit", labels), signal);
     if (selected === undefined) return { action: "cancel" };
     const property = properties[labels.indexOf(selected)];
     if (!property) continue;
     const [name, schema] = property;
-    const value = await collectValidField(options.ui, params, name, schema, values[name]);
+    const value = await collectValidField(options.ui, params, name, schema, values[name], signal);
     if (value.status === "cancelled") return { action: "cancel" };
     values[name] = value.value;
   }
@@ -89,10 +93,11 @@ async function collectValidField(
   name: string,
   schema: FormProperty,
   current?: ElicitationValue,
+  signal?: AbortSignal,
 ): Promise<FieldCollectionResult> {
   const required = params.requestedSchema.required?.includes(name) === true;
   while (true) {
-    const result = await collectField(ui, params, name, schema, current);
+    const result = await collectField(ui, params, name, schema, current, signal);
     if (result.status === "cancelled") return result;
     try {
       coerceAndValidateFormValues({
@@ -117,6 +122,7 @@ async function collectField(
   name: string,
   schema: FormProperty,
   current?: ElicitationValue,
+  signal?: AbortSignal,
 ): Promise<FieldCollectionResult> {
   const required = params.requestedSchema.required?.includes(name) === true;
   const title = [schema.title ?? humanizeName(name), required ? "(required)" : "", schema.description]
@@ -136,7 +142,7 @@ async function collectField(
     if (useDefault) actions.push(useDefault);
     const omit = required ? undefined : uniqueAction("Omit", actions);
     if (omit) actions.push(omit);
-    const action = await ui.select(title, actions);
+    const action = await abortable(ui.select(title, actions), signal);
     if (action === undefined) return { status: "cancelled" };
     if (action === useDefault) return { status: "collected", value: schema.default };
     if (action === omit) return { status: "collected", value: undefined };
@@ -147,7 +153,7 @@ async function collectField(
     const actions = ["Yes", "No"];
     if (schema.default !== undefined) actions.push("Use default");
     if (!required) actions.push("Omit");
-    const action = await ui.select(title, actions);
+    const action = await abortable(ui.select(title, actions), signal);
     if (action === undefined) return { status: "cancelled" };
     if (action === "Use default") return { status: "collected", value: schema.default };
     if (action === "Omit") return { status: "collected", value: undefined };
@@ -158,7 +164,7 @@ async function collectField(
     const actions = ["Choose values"];
     if (schema.default !== undefined) actions.push("Use default");
     if (!required) actions.push("Omit");
-    const action = await ui.select(title, actions);
+    const action = await abortable(ui.select(title, actions), signal);
     if (action === undefined) return { status: "cancelled" };
     if (action === "Use default") return { status: "collected", value: schema.default };
     if (action === "Omit") return { status: "collected", value: undefined };
@@ -168,7 +174,7 @@ async function collectField(
     while (true) {
       const displays = uniqueLabels(choices.map(choice => selected.has(choice.value) ? `✓ ${choice.display}` : choice.display));
       const done = uniqueAction("Done", displays);
-      const picked = await ui.select(title, [...displays, done]);
+      const picked = await abortable(ui.select(title, [...displays, done]), signal);
       if (picked === undefined) return { status: "cancelled" };
       if (picked === done) return { status: "collected", value: [...selected] };
       const choice = choices[displays.indexOf(picked)];
@@ -181,11 +187,11 @@ async function collectField(
   const actions = ["Enter value"];
   if (schema.default !== undefined) actions.push("Use default");
   if (!required) actions.push("Omit");
-  const action = await ui.select(title, actions);
+  const action = await abortable(ui.select(title, actions), signal);
   if (action === undefined) return { status: "cancelled" };
   if (action === "Use default") return { status: "collected", value: schema.default };
   if (action === "Omit") return { status: "collected", value: undefined };
-  const entered = await ui.input(title, current === undefined ? undefined : String(current));
+  const entered = await abortable(ui.input(title, current === undefined ? undefined : String(current)), signal);
   return entered === undefined ? { status: "cancelled" } : { status: "collected", value: entered };
 }
 
@@ -305,7 +311,9 @@ function formatReview(
 export async function handleUrlElicitation(
   options: ElicitationHandlerOptions,
   params: ElicitRequestURLParams,
+  signal?: AbortSignal,
 ): Promise<ElicitResult> {
+  throwIfAborted(signal);
   if (!options.allowUrl) throw new ProtocolError(ProtocolErrorCode.InvalidParams, "URL elicitation is not supported");
 
   let parsed: URL;
@@ -318,7 +326,7 @@ export async function handleUrlElicitation(
     throw new ProtocolError(ProtocolErrorCode.InvalidParams, "URL elicitation only supports HTTP and HTTPS URLs");
   }
 
-  const decision = await options.ui.select([
+  const decision = await abortable(options.ui.select([
     "MCP Browser Request",
     `Server: ${options.serverName}`,
     "",
@@ -328,16 +336,18 @@ export async function handleUrlElicitation(
     `Full URL: ${params.url}`,
     "",
     "Open this URL in your browser?",
-  ].join("\n"), ["Open", "Decline"]);
+  ].join("\n"), ["Open", "Decline"]), signal);
   if (decision === undefined) return { action: "cancel" };
   if (decision === "Decline") return { action: "decline" };
 
   try {
-    await open(params.url);
+    await abortable(open(params.url), signal);
   } catch (error) {
+    throwIfAborted(signal);
     options.ui.notify(`Could not open MCP elicitation URL: ${error instanceof Error ? error.message : String(error)}`, "error");
     return { action: "cancel" };
   }
+  throwIfAborted(signal);
   options.onUrlAccepted?.(params.elicitationId);
   options.ui.notify("Opened browser for MCP elicitation.", "info");
   return { action: "accept" };

package/node_modules/pi-mcp-adapter/examples/jev-accessibility-loop.mjs

@@ -0,0 +1,85 @@
+const SAFE_OPERATIONS = new Set(["focus", "scroll"]);
+
+export async function runAccessibilityLoop(tools, jev, options) {
+  const { observePath, actionPath, goal, allowedOperations, sources, maxSteps, maxMs, maxEvaluations } = options;
+  if (typeof observePath !== "string" || !observePath || typeof actionPath !== "string" || !actionPath || typeof goal !== "string" || !goal
+    || !Array.isArray(allowedOperations) || allowedOperations.length === 0 || allowedOperations.some(operation => !SAFE_OPERATIONS.has(operation))) {
+    throw new Error("Exact tool paths, a goal, and non-destructive focus/scroll operations are required");
+  }
+  if (![maxSteps, maxMs, maxEvaluations].every(value => Number.isInteger(value) && value > 0)) {
+    throw new Error("Positive step, time, and evaluation budgets are required");
+  }
+  if (!Array.isArray(sources) || sources.length === 0 || sources.some(source => typeof source !== "string" || !source)) {
+    throw new Error("Explicit MCP sources are required for accessibility data");
+  }
+  const startedAt = Date.now();
+  let evaluations = 0;
+  let previousFingerprint;
+
+  const observe = async () => {
+    const result = await tools.call(observePath, {});
+    if (!result.ok) return { error: "observation-failed" };
+    const tree = result.data?.structuredContent;
+    if (!tree || typeof tree.observationId !== "string" || !tree.observationId || !Array.isArray(tree.nodes)) {
+      return { error: "needs-information" };
+    }
+    return { tree };
+  };
+
+  for (let step = 0; step < maxSteps; step += 1) {
+    if (Date.now() - startedAt >= maxMs) return { status: "stop", reason: "time-budget" };
+    const snapshot = await observe();
+    if (snapshot.error) return { status: snapshot.error === "needs-information" ? "needs-information" : "stop", reason: snapshot.error };
+    const fingerprint = JSON.stringify(snapshot.tree.nodes);
+    if (fingerprint === previousFingerprint) return { status: "stop", reason: "no-progress" };
+    previousFingerprint = fingerprint;
+
+    const actions = snapshot.tree.nodes.flatMap(node =>
+      (node && typeof node.id === "string" && node.id && Array.isArray(node.actions) ? node.actions : [])
+        .filter(operation => typeof operation === "string" && allowedOperations.includes(operation))
+        .map(operation => ({ target: node.id, operation })),
+    ).slice(0, 120).map((action, index) => ({ ...action, label: `a${index}` }));
+    if (actions.length === 0) return { status: "no-match" };
+    if (evaluations >= maxEvaluations) return { status: "stop", reason: "evaluation-budget" };
+    evaluations += 1;
+    const evaluation = await jev.evaluate({
+      state: { goal, observationId: snapshot.tree.observationId, nodes: snapshot.tree.nodes },
+      sources,
+      questions: {
+        next: {
+          type: "choice",
+          instructions: "Choose complete only when the observation proves the goal. Otherwise choose one safe action, none, or needsInformation.",
+          criteria: Object.fromEntries([
+            ...actions.map(action => [action.label, { target: action.target, operation: action.operation }]),
+            ["complete", "Goal is observably complete"],
+            ["none", "No matching safe action"],
+            ["needsInformation", "User information is required"],
+          ]),
+        },
+      },
+    });
+    if (!evaluation.ok) return { status: "stop", reason: evaluation.error.code };
+    const answer = evaluation.data.answers.next;
+    if (answer.type !== "choice" || answer.confidence < 0.85) return { status: "stop", reason: "uncertain" };
+    if (answer.choice === "complete") return { status: "complete", observationId: snapshot.tree.observationId };
+    if (answer.choice === "none") return { status: "no-match" };
+    if (answer.choice === "needsInformation") return { status: "needs-information" };
+    const selected = actions.find(action => action.label === answer.choice);
+    if (!selected) return { status: "stop", reason: "invalid-action" };
+
+    if (Date.now() - startedAt >= maxMs) return { status: "stop", reason: "time-budget" };
+    const fresh = await observe();
+    if (fresh.error || fresh.tree.observationId === snapshot.tree.observationId) return { status: "stop", reason: "stale-candidate" };
+    const target = fresh.tree.nodes.find(node => node.id === selected.target);
+    if (!target || !Array.isArray(target.actions) || !target.actions.includes(selected.operation)) {
+      return { status: "stop", reason: "stale-candidate" };
+    }
+    const acted = await tools.call(actionPath, {
+      operation: selected.operation,
+      target: selected.target,
+      observationId: fresh.tree.observationId,
+    });
+    if (!acted.ok) return { status: "stop", reason: "action-failed-or-uncertain" };
+  }
+  return { status: "stop", reason: "step-budget" };
+}

package/node_modules/pi-mcp-adapter/examples/jev-semantic-filter.mjs

@@ -0,0 +1,34 @@
+export async function filterIssuesForTriage(tools, jev) {
+  const found = await tools.search({
+    query: "list open customer issue reports",
+    server: "github",
+    searchMode: "semantic",
+    limit: 5,
+  });
+  const tool = found.items?.[0];
+  if (!tool) return { status: "no-match" };
+
+  const listed = await tools.call(tool.path, { state: "open", limit: 20 });
+  if (!listed.ok) return { status: "stop", error: listed.error };
+  const issues = listed.data?.structuredContent?.issues;
+  if (!Array.isArray(issues) || issues.length === 0) return { status: "no-match" };
+
+  const candidates = issues.slice(0, 20).map((issue, index) => ({
+    id: `issue${index}`,
+    title: String(issue.title ?? ""),
+    body: String(issue.body ?? "").slice(0, 2000),
+  }));
+  const questions = Object.fromEntries(candidates.flatMap(issue => [
+    [`relevant_${issue.id}`, { type: "noul", instructions: "Is this issue actionable and relevant?", criteria: { true: "Relevant", false: "Not relevant" } }],
+    [`regression_${issue.id}`, { type: "noul", instructions: "Does this issue contain evidence of a regression?", criteria: { true: "Regression", false: "No regression evidence" } }],
+  ]));
+  const evaluation = await jev.evaluate({ state: { candidates }, questions, sources: ["github"] });
+  if (!evaluation.ok) return { status: "stop", error: evaluation.error };
+
+  const useful = candidates.filter(issue => {
+    const relevant = evaluation.data.answers[`relevant_${issue.id}`];
+    const regression = evaluation.data.answers[`regression_${issue.id}`];
+    return relevant?.type === "noul" && regression?.type === "noul" && relevant.noul >= 0.8 && regression.noul >= 0.7;
+  });
+  return useful.length > 0 ? { status: "matched", issues: useful } : { status: "no-match" };
+}

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

@@ -1,17 +1,19 @@
 import { withFileMutationQueue, type AgentToolUpdateCallback, type ExtensionAPI, type ExtensionContext, type ToolInfo } from "@earendil-works/pi-coding-agent";
 import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import type { McpExtensionState } from "./state.ts";
 import { isServerDisabled, type DirectToolSpec, type McpAdapterOptions, type McpConfig, type PromptMetadata, type ServerEntry } from "./types.ts";
 import type { McpOAuthRuntime } from "./mcp-auth-flow.ts";
 import { Type } from "typebox";
 import type { TSchema } from "typebox";
 import { cloneMcpConfig, discoverConfiguredClaudePluginSkills, getPiGlobalConfigPath, getProjectConfigPath, loadMcpConfig, resolveConfiguredClaudePluginMcp, writeProjectServerDisabledOverride, writeSharedServerEntry } from "./config.ts";
-import { buildProxyDescription, getMissingConfiguredDirectToolServers, prepareDirectToolArguments, resolveDirectTools } from "./direct-tool-surface.ts";
+import { buildProxyDescription, getLargeDirectToolsAdvisory, getMissingConfiguredDirectToolServers, prepareDirectToolArguments, resolveDirectTools } from "./direct-tool-surface.ts";
 import { isServerInActiveFailureBackoff } from "./failure-backoff.ts";
 import { computeServerHash, isServerCacheValid, loadMetadataCache, parseDirectToolSelectors, type MetadataCache } from "./metadata-cache.ts";
 import { createPromptCommand, resolveCachedPrompts } from "./prompts.ts";
 import { logger } from "./logger.ts";
-import { formatTerminalError, getConfigPathFromArgv, normalizeDirectToolInputSchema, truncateAtWord } from "./utils.ts";
+import { formatMcpFooterStatus, formatTerminalError, getConfigPathFromArgv, normalizeDirectToolInputSchema, truncateAtWord } from "./utils.ts";
 import { createMcpDirectToolCallRenderer, createMcpProxyToolCallRenderer, createMcpScriptToolCallRenderer, createMcpToolResultRenderer, resolveMcpToolRenderOptions } from "./tool-result-renderer.ts";
 import { toolErrorOverride } from "./error-signal.ts";
 import { createMcpRuntimeOwner, createOwnedUi, isAbortError, type McpRuntimeOwner } from "./runtime-owner.ts";
@@ -348,6 +350,7 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
   let proxyToolRegistered = false;
   let proxyToolDescription: string | null = null;
   let directToolsFrozen = false;
+  let largeDirectToolsAdvisoryDelivered = false;
   // Session/runtime scoped server registrations from other extensions. They
   // survive session restarts within this install and die with the process.
   const runtimeServers = new Map<string, { definition: ServerEntry; entry: ServerEntry }>();
@@ -605,6 +608,8 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
   }
 
   function syncToolSurface(ctx?: ExtensionContext): void {
+    const notificationGeneration = lifecycleGeneration;
+    const notificationOwner = currentOwner;
     const config = state?.config ?? earlyConfig;
     const cache = loadToolSurfaceCache(config);
     const result = syncDirectTools(config, cache);
@@ -618,6 +623,13 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
     }
     syncProxyTool(config, cache, result.specs);
     syncNamespaceTools(config, cache, result.reservedDirectNames, result.activeDirectNames);
+    deliverLargeDirectToolsAdvisory(ctx, config, result.specs);
+    if (ctx && (notificationGeneration !== lifecycleGeneration
+      || notificationOwner !== currentOwner
+      || (notificationOwner && !notificationOwner.isActive()))) {
+      throw notificationOwner?.signal.reason ?? new Error("Stale MCP session after direct-tools advisory");
+    }
+    finalizationGuard?.();
     const changed = result.added.length + result.updated.length + result.deactivated.length;
     if (changed > 0 && ctx?.hasUI) {
       callReentrant(() => ctx.ui.notify(
@@ -627,6 +639,49 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
     }
   }
 
+  function deliverLargeDirectToolsAdvisory(
+    ctx: ExtensionContext | undefined,
+    config: McpConfig,
+    specs: readonly DirectToolSpec[],
+  ): void {
+    if (!ctx || largeDirectToolsAdvisoryDelivered) return;
+    const message = getLargeDirectToolsAdvisory(config, specs);
+    if (!message) return;
+    largeDirectToolsAdvisoryDelivered = true;
+    if (ctx.hasUI) {
+      callReentrant(() => ctx.ui.notify(message, "warning"));
+    } else {
+      console.warn(message);
+    }
+  }
+
+  function getDeferredSessionSnapshot(cwd: string | undefined): {
+    config: McpConfig;
+    specs: DirectToolSpec[];
+    enabledServerCount: number;
+  } | undefined {
+    const config = programmaticConfig
+      ? resolveConfiguredClaudePluginMcp(cloneMcpConfig(sessionConfig), cwd ?? process.cwd())
+      : loadMcpConfig(earlyConfigPath, cwd);
+    const cache = loadMetadataCache();
+    const enabledServers = Object.entries(config.mcpServers)
+      .filter(([, definition]) => !isServerDisabled(definition));
+    if (enabledServers.some(([, definition]) => definition.lifecycle === "eager" || definition.lifecycle === "keep-alive")) {
+      return undefined;
+    }
+    if (!cache || !enabledServers.every(([serverName, definition]) => {
+      const entry = cache.servers[serverName];
+      return entry !== undefined && isServerCacheValid(entry, definition);
+    })) return undefined;
+    if (envRaw !== undefined && envRaw !== "__none__"
+      && getMissingConfiguredDirectToolServers(config, cache, envDirectToolOverride).length > 0) return undefined;
+    return {
+      config,
+      specs: resolveCurrentDirectTools(config, cache),
+      enabledServerCount: enabledServers.length,
+    };
+  }
+
   function syncNamespaceTools(
     config: McpConfig,
     cache: MetadataCache | null,
@@ -1016,11 +1071,18 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
       ? cloneMcpConfig(sessionConfig)
       : loadMcpConfig(earlyConfigPath, event.cwd);
     const skillPaths = discoverConfiguredClaudePluginSkills(resourceConfig, event.cwd);
+    if (earlyConfig.settings?.scriptMode !== false) {
+      const scriptingSkillPath = fileURLToPath(new URL("./skills/mcp-scripting/SKILL.md", import.meta.url));
+      if (existsSync(scriptingSkillPath) && !skillPaths.includes(scriptingSkillPath)) {
+        skillPaths.push(scriptingSkillPath);
+      }
+    }
     return skillPaths.length > 0 ? { skillPaths } : undefined;
   });
 
   pi.on("session_start", async (_event, ctx) => {
     const generation = ++lifecycleGeneration;
+    largeDirectToolsAdvisoryDelivered = false;
     const previousState = state;
     const previousOwner = currentOwner;
     const previousOAuthRuntime = currentOAuthRuntime;
@@ -1049,7 +1111,24 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
     if (state) return;
 
     if (!initPromise) {
-      if (deferSessionRuntime) return;
+      const deferredSnapshot = deferSessionRuntime ? getDeferredSessionSnapshot(ctx.cwd) : undefined;
+      if (deferredSnapshot) {
+        deliverLargeDirectToolsAdvisory(ctx, deferredSnapshot.config, deferredSnapshot.specs);
+        if (generation !== lifecycleGeneration || !owner.isActive() || currentOwner !== owner) return;
+        const serverCount = Object.keys(deferredSnapshot.config.mcpServers).length;
+        const formattedStatus = formatMcpFooterStatus(
+          deferredSnapshot.config,
+          deferredSnapshot.enabledServerCount,
+          serverCount - deferredSnapshot.enabledServerCount,
+          0,
+        );
+        const theme = ctx.ui?.theme;
+        const styledStatus = formattedStatus !== undefined && typeof theme?.fg === "function"
+          ? theme.fg("accent", formattedStatus)
+          : formattedStatus;
+        ctx.ui?.setStatus("mcp", styledStatus);
+        return;
+      }
       startInitialization(ctx, owner, generation, "stale_session_start");
     }
 
@@ -1148,6 +1227,8 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
           { value: "tools", label: "tools — List all tools" },
           { value: "prompts", label: "prompts — List all MCP prompts" },
           { value: "setup", label: "setup — Configure MCP servers" },
+          { value: "jev", label: "jev setup — Configure Jev semantic search" },
+          { value: "edit", label: "edit — Edit .mcp.json or the global config" },
           { value: "logout", label: "logout — Clear server credentials" },
           { value: "token", label: "token — Manage stored bearer tokens" },
           { value: "disable", label: "disable — Disable a server" },
@@ -1158,6 +1239,11 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
       }
 
       const [, subcommand, argumentPrefix] = argumentMatch;
+      if (subcommand === "jev") {
+        return "setup".startsWith((argumentPrefix ?? "").trimStart())
+          ? [{ value: "jev setup", label: "setup — Configure Jev semantic search" }]
+          : null;
+      }
       if (
         (subcommand !== "reconnect" && subcommand !== "logout" && subcommand !== "disable" && subcommand !== "enable" && subcommand !== "token")
         || argumentPrefix === undefined
@@ -1246,6 +1332,41 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
           }
           break;
         }
+        case "jev": {
+          if (parts[1] !== "setup" || parts.length !== 2) {
+            commandCtx.ui?.notify("Usage: /mcp jev setup", "error");
+            break;
+          }
+          if (programmaticConfig) {
+            commandCtx.ui?.notify("Jev setup is unavailable when config is supplied by createMcpAdapter().", "info");
+            break;
+          }
+          commandOwner?.throwIfInactive();
+          if (await commands.setupJevSemanticSearch(state, commandCtx, earlyConfigPath)) {
+            commandOwner?.throwIfInactive();
+            await commandReload();
+            return;
+          }
+          break;
+        }
+        case "edit": {
+          if (programmaticConfig) {
+            commandCtx.ui?.notify("MCP edit is unavailable when config is supplied by createMcpAdapter().", "info");
+            break;
+          }
+          const target = parts[1] ?? "project";
+          if (target !== "project" && target !== "global") {
+            commandCtx.ui?.notify("Usage: /mcp edit [project|global]", "error");
+            return;
+          }
+          commandOwner?.throwIfInactive();
+          if (await commands.editSharedConfig(commandCtx, target)) {
+            commandOwner?.throwIfInactive();
+            await commandReload();
+            return;
+          }
+          break;
+        }
         case "logout": {
           const serverName = rest;
           if (!serverName) {
@@ -1666,11 +1787,12 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
         describe: Type.Optional(Type.String({ description: "Tool name to describe (shows parameters)" })),
         instructions: Type.Optional(Type.String({ description: "Server name to show that server's usage instructions" })),
         search: Type.Optional(Type.String({ description: "Search tools by name/description" })),
+        searchMode: Type.Optional(Type.String({ enum: ["lexical", "semantic"], description: "Search backend (default: lexical; semantic is available when a TypeSafe key is configured)" })),
         regex: Type.Optional(Type.Boolean({ description: "Treat search as regex (default: substring match)" })),
         includeSchemas: Type.Optional(Type.Boolean({ description: "Include parameter schemas in search results (default: true)" })),
         limit: optionalNumber({ minimum: 1, description: "Maximum search results to return (default: 12)" }),
         offset: optionalNumber({ minimum: 0, description: "Search result offset (default: 0)" }),
-        server: Type.Optional(Type.String({ description: "Server name (filters/disambiguates calls and optionally names an install)" })),
+        server: Type.Optional(Type.String({ description: "Server name: filters searches, disambiguates calls and describe operations, and optionally names an install" })),
         action: Type.Optional(Type.String({ description: "Action: 'install', 'ui-messages', 'auth-start', or 'auth-complete'" })),
         url: Type.Optional(Type.String({ description: "MCP endpoint URL for action: 'install'" })),
         target: Type.Optional(Type.String({ description: "Install target: 'global' (default) or 'project'" })),
@@ -1683,6 +1805,7 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
         describe?: string;
         instructions?: string;
         search?: string;
+        searchMode?: "lexical" | "semantic";
         regex?: boolean;
         includeSchemas?: boolean;
         limit?: number;
@@ -1811,13 +1934,13 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
           return connectAndReport(proxyState, params.connect, signal, _ctx as ExtensionContext);
         }
         if (params.describe) {
-          return proxyModes.executeDescribe(proxyState, params.describe);
+          return proxyModes.executeDescribe(proxyState, params.describe, params.server);
         }
         if (params.instructions) {
           return proxyModes.executeInstructions(proxyState, params.instructions);
         }
         if (params.search !== undefined) {
-          const result = proxyModes.executeSearch(proxyState, params.search, params.regex, params.server, params.includeSchemas, params.limit, params.offset);
+          const result = await proxyModes.executeSearch(proxyState, params.search, params.regex, params.server, params.includeSchemas, params.limit, params.offset, params.searchMode, signal);
           if (lazyDirectTools.size === 0) return result;
           holdLazyToolsInactive();
           const matches = (result.details as { matches?: Array<{ server: string; tool: string }> } | undefined)?.matches ?? [];

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

@@ -24,7 +24,7 @@ import { McpServerManager, isTransientHttpConnectError } from "./server-manager.
 import { buildToolMetadata, totalToolCount } from "./tool-metadata.ts";
 import { resourceNameToToolName } from "./resource-tools.ts";
 import { UiResourceHandler } from "./ui-resource-handler.ts";
-import { formatMcpStatus, openUrl, parallelLimit, sanitizeTerminalText } from "./utils.ts";
+import { formatMcpFooterStatus, formatMcpStatus, openUrl, parallelLimit, sanitizeTerminalText } from "./utils.ts";
 import { logger } from "./logger.ts";
 import { throwIfAborted } from "./abort.ts";
 import { getAuthStorageOptions } from "./mcp-auth.ts";
@@ -209,6 +209,7 @@ export async function initializeMcp(
     failureTracker,
     failureMessages,
     approvedToolCalls,
+    approvedServers: new Map(),
     ...(persistSessionApproval !== undefined ? { persistSessionApproval } : {}),
     ...(sessionManager !== undefined ? { sessionManager } : {}),
     approvalEvents: pi.events,
@@ -253,6 +254,9 @@ export async function initializeMcp(
     if (!owner.isActive()) return;
     updateStatusBar(state);
   });
+  owner.addCleanup(() => {
+    state.approvedServers = new Map();
+  });
   owner.addCleanup(() => lifecycle.gracefulShutdown());
   owner.addCleanup(() => {
     if (state.uiServer) {
@@ -642,28 +646,11 @@ export function updateStatusBar(state: McpExtensionState): void {
   const entries = Object.entries(state.config.mcpServers);
   const disabledCount = entries.filter(([, definition]) => isServerDisabled(definition)).length;
   const enabledCount = entries.length - disabledCount;
-  if (entries.length === 0) {
-    ui.setStatus("mcp", undefined);
-    return;
-  }
   const connectedCount = [...state.manager.getAllConnections()].filter(([name, connection]) => {
     const definition = state.config.mcpServers[name];
     return connection.status === "connected" && definition !== undefined && !isServerDisabled(definition);
   }).length;
-  const footerStatus = state.config.settings?.mcpFooterStatus ?? "full";
-  if (footerStatus === "off") {
-    ui.setStatus("mcp", undefined);
-    return;
-  }
-
-  let status = footerStatus === "compact"
-    ? `MCP ${connectedCount}/${enabledCount}`
-    : `${enabledCount} ${enabledCount === 1 ? "server" : "servers"} enabled`;
-  if (footerStatus === "full") {
-    if (connectedCount > 0) status += ` (${connectedCount} connected)`;
-    if (disabledCount > 0) status += ` (${disabledCount} disabled)`;
-  }
-  const formattedStatus = footerStatus === "compact" ? status : formatMcpStatus(state.config, status);
+  const formattedStatus = formatMcpFooterStatus(state.config, enabledCount, disabledCount, connectedCount);
   if (formattedStatus === undefined) {
     ui.setStatus("mcp", undefined);
     return;