pi-gortex 0.2.0 → 0.4.0

package/src/index.ts

@@ -3,7 +3,7 @@
 // hook bridge. See docs/architecture.md for the design.
 
 import type {
-  ContextEvent,
+  BeforeAgentStartEventResult,
   ExtensionAPI,
   ExtensionContext,
   ToolCallEvent,
@@ -12,6 +12,7 @@ import type {
 
 import { resolveConfig } from "./config.ts";
 import type { GortexConfig } from "./config.ts";
+import { watchNativeEdits } from "./diff.ts";
 import { callHook, normalizeToolCall } from "./hook.ts";
 import {
   MCPStdioClient,
@@ -20,6 +21,19 @@ import {
   ensureDaemon,
   isBelowVersion,
 } from "./mcp-client.ts";
+import {
+  NATIVE_READY_WAIT_MS,
+  bareToolName,
+  binaryResolves,
+  daemonVersionFromBriefing,
+  isNativeGortexTool,
+  mcpConnectorLoaded,
+  registerNativeServer,
+  unregisterNativeServer,
+  supportsNativeMcp,
+  waitForNativeTools,
+} from "./native.ts";
+import { nativeRenderers } from "./render.ts";
 import { nodeProcessDeps } from "./runtime.ts";
 import type { ProcessDeps } from "./runtime.ts";
 import {
@@ -35,6 +49,7 @@ import {
   setBridgeError,
   setClient,
   setVersionWarning,
+  withdrawnToolNames,
 } from "./state.ts";
 
 export type { GortexConfig, SidecarConfig } from "./config.ts";
@@ -82,12 +97,49 @@ function reportVersionSkew(
         `run \`gortex upgrade\`.`,
   );
 
-  // A Pi build without a UI (print/JSON mode) or without notify must not take
-  // the session down over an advisory message.
+  notifyUser(ctx, user);
+}
+
+/**
+ * A warning for the user only. A Pi build without a UI (print/JSON mode) or
+ * without notify must not take the session down over an advisory message.
+ */
+function notifyUser(ctx: ExtensionContext | undefined, message: string): void {
   try {
-    if (ctx?.hasUI) ctx.ui.notify(user, "warning");
+    if (ctx?.hasUI) ctx.ui.notify(message, "warning");
   } catch {
-    // the model still gets the orientation line above
+    // advisory only
+  }
+}
+
+/** Marks the messages this extension stores in the session. */
+const GORTEX_MESSAGE_TYPE = "gortex";
+
+interface GortexMessageDetails {
+  /** Whether the content includes the session briefing, not only warnings. */
+  briefing: boolean;
+}
+
+/** Kept out of the transcript; Pi still sends it to the model. */
+function gortexMessage(content: string, briefing: boolean): BeforeAgentStartEventResult {
+  const details: GortexMessageDetails = { briefing };
+  return { message: { customType: GORTEX_MESSAGE_TYPE, content, display: false, details } };
+}
+
+/**
+ * Whether a briefing already sits in what the model sees: after a resume or
+ * /reload, or when compaction kept it. Answers false when Pi can't tell.
+ */
+function briefingInContext(ctx: ExtensionContext | undefined): boolean {
+  try {
+    return (ctx?.sessionManager.buildContextEntries() ?? []).some(
+      (entry) =>
+        entry.type === "custom_message" &&
+        entry.customType === GORTEX_MESSAGE_TYPE &&
+        (entry.details as GortexMessageDetails | undefined)?.briefing === true,
+    );
+  } catch {
+    return false;
   }
 }
 
@@ -99,6 +151,8 @@ export interface GortexExtensionOptions {
   deps?: ProcessDeps;
   /** Readiness cap override. */
   readyWaitMs?: number;
+  /** Override for the wait on Pi's built-in MCP connecting the gortex server. */
+  nativeReadyWaitMs?: number;
 }
 
 export default function gortexExtension(pi: ExtensionAPI, options: GortexExtensionOptions = {}): void {
@@ -109,14 +163,26 @@ export default function gortexExtension(pi: ExtensionAPI, options: GortexExtensi
   const piCwd = (): string => (pi as { cwd?: string })?.cwd ?? process.cwd();
   const deps = options.deps ?? nodeProcessDeps;
   const readyWaitMs = options.readyWaitMs ?? READY_WAIT_MS;
+  const nativeReadyWaitMs = options.nativeReadyWaitMs ?? NATIVE_READY_WAIT_MS;
+
+  // On a Pi with built-in MCP, Pi owns the tool channel: it spawns `gortex mcp`
+  // (which starts the daemon itself), registers the tools and renders them.
+  // A binary that does not resolve, or a registration Pi refuses, falls back to
+  // the extension's own client, which reports its failure to the model.
+  let nativeRefusal = "";
+  let native = ((): boolean => {
+    if (!config.nativeMcp || !supportsNativeMcp(pi) || !binaryResolves(config.bin)) return false;
+    nativeRefusal = registerNativeServer(pi, config);
+    return nativeRefusal === "";
+  })();
 
   // Latched for the whole session once the first turn has run the
   // session_start hook, whether or not it produced anything to inject.
   let startupHookRan = false;
-  // Orientation awaiting injection into the next LLM call, computed once per
-  // session. The `context` hook appends it as a tail user message, because a
-  // systemPrompt change sits at messages[0] and invalidates prefix caching.
-  let pendingOrientation = "";
+  // This session's briefing, kept so a compaction that summarises it away can
+  // send it again on the next turn.
+  let briefing = "";
+  let briefingCompacted = false;
 
   // Settles when the current session_start handler is done: bridge up and
   // tools registered, or the handshake failed. Never rejects.
@@ -166,7 +232,8 @@ export default function gortexExtension(pi: ExtensionAPI, options: GortexExtensi
   // session's bridge child (if any) is stopped before a fresh handshake.
   pi.on("session_start", async (_event, ctx) => {
     startupHookRan = false;
-    pendingOrientation = "";
+    briefing = "";
+    briefingCompacted = false;
     setBridgeError("");
     setVersionWarning("");
     armSessionReady(); // no-op when a turn is already parked on this session
@@ -178,17 +245,30 @@ export default function gortexExtension(pi: ExtensionAPI, options: GortexExtensi
     }
   });
 
-  // startSession holds the body of session_start so the readiness promise
-  // above settles on every exit path, early returns included.
-  async function startSession(ctx?: ExtensionContext): Promise<void> {
-    ensureDaemon(config.bin, deps);
-    gortexToolNames.clear();
+  // Stops the live bridge, if any, and clears the slot. Shared by
+  // session_start and session_shutdown so both paths stay in sync.
+  function stopBridge(): void {
     clearSyncTimer();
     const previous = getClient();
     if (previous) {
       previous.stop();
       setClient(null);
     }
+  }
+
+  // startSession holds the body of session_start so the readiness promise
+  // above settles on every exit path, early returns included.
+  async function startSession(ctx?: ExtensionContext): Promise<void> {
+    if (native && !mcpConnectorLoaded(pi)) {
+      unregisterNativeServer(pi);
+      native = false;
+    }
+    if (native) return;
+    if (nativeRefusal) notifyUser(ctx, `Pi refused the gortex MCP server (${nativeRefusal}), so the extension runs its own client.`);
+    ensureDaemon(config.bin, deps);
+    gortexToolNames.clear();
+    withdrawnToolNames.clear();
+    stopBridge();
     const c = new MCPStdioClient({ bin: config.bin, toolsPreset: config.toolsPreset, deps });
     // Claim the slot before the first await: an overlapping
     // session_start (rapid /new or /reload) then sees and stops THIS
@@ -214,18 +294,34 @@ export default function gortexExtension(pi: ExtensionAPI, options: GortexExtensi
     }
   }
 
-  // Fires before the agent loop's first LLM call. It can't mutate messages
-  // itself, so it just parks the orientation for the `context` hook.
-  pi.on("before_agent_start", async () => {
-    if (startupHookRan) return;
+  pi.on("session_compact", () => {
+    briefingCompacted = true;
+  });
+
+  // Fires before the agent loop's first LLM call. The returned message is
+  // stored in the session after the prompt, so every later LLM call carries it
+  // and the system prompt, which prefix caching keys on, stays untouched.
+  pi.on("before_agent_start", async (_event, ctx): Promise<BeforeAgentStartEventResult | void> => {
+    if (startupHookRan) {
+      if (!briefingCompacted) return;
+      briefingCompacted = false;
+      if (!briefing || briefingInContext(ctx)) return;
+      return gortexMessage(briefing, true);
+    }
     startupHookRan = true; // before the first await, so a second turn can't race in
     // Pi awaits each listener, so this holds the turn until the tools are
     // registered and bridgeError reflects the handshake (or the cap expires).
-    const ready = await waitForSession(readyWaitMs);
+    // session_start settles `native` first: it falls back when nothing connects MCP.
+    const sessionDone = await waitForSession(readyWaitMs);
+    const ready = native ? await waitForNativeTools(pi, nativeReadyWaitMs) : sessionDone;
     const decision = callHook(config.hookArgv, deps, {
       event: "session_start",
-      cwd: piCwd(),
+      cwd: ctx?.cwd ?? piCwd(),
     });
+    // Pi's MCP keeps the handshake to itself, so the version comes from the briefing.
+    if (native && decision.orientation) {
+      reportVersionSkew(ctx, daemonVersionFromBriefing(decision.orientation), "");
+    }
     const parts: string[] = [];
     const bridgeError = getBridgeError();
     if (bridgeError) {
@@ -250,41 +346,32 @@ export default function gortexExtension(pi: ExtensionAPI, options: GortexExtensi
       parts.push(versionWarning);
       setVersionWarning("");
     }
-    if (decision.orientation) parts.push(decision.orientation);
-    if (parts.length > 0) pendingOrientation = parts.join("\n\n");
-    return;
-  });
-
-  // Fires before each LLM call with a mutable message array. Appends the
-  // parked orientation once, clearing it only after the push lands so the
-  // orientation survives a context shape this hook can't append to.
-  // Pi exports ContextEvent but not its result type, so it is spelled out here.
-  pi.on("context", (event: ContextEvent): { messages?: ContextEvent["messages"] } | void => {
-    if (!pendingOrientation) return;
-    try {
-      const messages = (event as { messages?: unknown })?.messages;
-      if (Array.isArray(messages)) {
-        // Pi's AgentMessage also carries a `timestamp`; only the two fields
-        // Pi reads for a tail user turn are pushed.
-        messages.push({ role: "user", content: pendingOrientation } as ContextEvent["messages"][number]);
-        pendingOrientation = "";
-        return { messages: messages as ContextEvent["messages"] };
-      }
-    } catch {
-      // best effort; never break context assembly.
+    let briefed = false;
+    if (decision.orientation) {
+      briefing = decision.orientation;
+      // A resumed or reloaded session already holds it.
+      briefed = !briefingInContext(ctx);
+      if (briefed) parts.push(decision.orientation);
     }
-    return;
+    if (parts.length === 0) return;
+    return gortexMessage(parts.join("\n\n"), briefed);
   });
 
-  if (!config.enforce) return;
+  // Never let the bridge child outlive the session.
+  pi.on("session_shutdown", async () => {
+    stopBridge();
+  });
 
   // Enforcement: every non-Gortex tool call is checked against the Go hook.
-  pi.on("tool_call", async (event: ToolCallEvent, ctx: ExtensionContext): Promise<ToolCallEventResult | void> => {
+  const enforceReadDiscipline = async (event: ToolCallEvent, ctx: ExtensionContext): Promise<ToolCallEventResult | void> => {
     const piName: string = (event as { toolName?: string })?.toolName ?? "";
     const piInput: Record<string, unknown> = (event?.input as Record<string, unknown>) ?? {};
-    const isGortexTool = gortexToolNames.has(piName);
+    const isGortexTool = native ? isNativeGortexTool(piName) : gortexToolNames.has(piName);
 
-    const norm = normalizeToolCall(piName, piInput);
+    // A graph tool keeps its own name: Gortex's `read` is no Pi `read`.
+    const norm = isGortexTool
+      ? { tool_name: bareToolName(piName), tool_input: piInput }
+      : normalizeToolCall(piName, piInput);
     const decision = callHook(config.hookArgv, deps, {
       event: "tool_call",
       tool_name: norm.tool_name,
@@ -309,5 +396,18 @@ export default function gortexExtension(pi: ExtensionAPI, options: GortexExtensi
       }
     }
     return;
-  });
+  };
+  if (config.enforce) pi.on("tool_call", enforceReadDiscipline);
+
+  // After enforcement, so a blocked call is never snapshotted. Shell calls are
+  // tracked on both channels; edits are snapshotted on Pi's built-in MCP only.
+  watchNativeEdits(pi, () => native);
+  if (native) {
+    // Pi < 1.0.1 has no tool renderers; the diffs are still stored.
+    try {
+      (pi as Partial<Pick<ExtensionAPI, "registerToolRenderer">>).registerToolRenderer?.(nativeRenderers);
+    } catch {
+      // drawing diffs is optional
+    }
+  }
 }

package/src/mcp-client.ts

@@ -53,6 +53,24 @@ export function isBelowVersion(actual: string, floor: string): boolean {
 // session. Fail open to the daemon's default surface instead.
 const FORWARDED_PRESETS = new Set(["edit", "nav", "readonly"]);
 
+/**
+ * The variables `gortex mcp` needs on top of `env` to serve `toolsPreset`.
+ * The daemon's own default surface already IS core/defer; only a recognised
+ * non-default preset needs the proxy-side narrowing.
+ */
+export function presetEnv(
+  toolsPreset: string,
+  env: Record<string, string | undefined>,
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  const preset = toolsPreset.trim().toLowerCase();
+  const tools = env.GORTEX_TOOLS || (FORWARDED_PRESETS.has(preset) ? preset : "");
+  if (tools && !env.GORTEX_TOOLS) out.GORTEX_TOOLS = tools;
+  // Never let a preset hide-block tools promoted later by tools_search.
+  if (tools && !env.GORTEX_TOOLS_MODE) out.GORTEX_TOOLS_MODE = "defer";
+  return out;
+}
+
 export interface MCPStdioClientOptions {
   bin: string;
   toolsPreset: string;
@@ -137,16 +155,7 @@ export class MCPStdioClient {
   }
 
   private childEnv(): Record<string, string | undefined> {
-    const env: Record<string, string | undefined> = { ...this.env };
-    const preset = this.toolsPreset.trim().toLowerCase();
-    // The daemon's own default surface already IS core/defer; only a
-    // recognised non-default preset needs the proxy-side narrowing.
-    if (!env.GORTEX_TOOLS && FORWARDED_PRESETS.has(preset)) {
-      env.GORTEX_TOOLS = preset;
-    }
-    // Never let a preset hide-block tools promoted later by tools_search.
-    if (env.GORTEX_TOOLS && !env.GORTEX_TOOLS_MODE) env.GORTEX_TOOLS_MODE = "defer";
-    return env;
+    return { ...this.env, ...presetEnv(this.toolsPreset, this.env) };
   }
 
   private spawnChild(): void {
@@ -165,6 +174,11 @@ export class MCPStdioClient {
     child.stdin?.on("error", () => {}); // EPIPE race: child may exit before stdin.write() finishes
     child.on("error", () => this.markExited(new Error("gortex mcp spawn failed")));
     child.on("exit", () => this.markExited(new Error("gortex mcp exited")));
+    // The child and its pipes must never keep the event loop alive.
+    child.unref?.();
+    child.stdin?.unref?.();
+    child.stdout?.unref?.();
+    child.stderr?.unref?.();
   }
 
   private markExited(err: Error): void {

package/src/native.ts

@@ -0,0 +1,141 @@
+// The tool channel on Pi's built-in MCP (Pi >= 0.99): the extension registers
+// `gortex mcp` with pi.registerMcpServer() and Pi owns the connection, the tool
+// registry and the rendering. See docs/architecture.md.
+
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import type { GortexConfig } from "./config.ts";
+import { CALL_TIMEOUT_MS, presetEnv } from "./mcp-client.ts";
+
+export const MCP_SERVER_NAME = "gortex";
+/** Pi names a server's tools `mcp__<server>__<tool>`. */
+export const MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
+
+const SERVER_DESCRIPTION =
+  "Gortex code graph of the indexed repositories: symbol search, source reads, usages, " +
+  "call chains, change impact and graph-aware edits.";
+
+// Pi 0.87 declares none of the MCP members, so they are read structurally.
+type NativeMcpApi = Pick<ExtensionAPI, "registerMcpServer" | "unregisterMcpServer" | "getAllTools" | "getCommands">;
+
+export function supportsNativeMcp(pi: ExtensionAPI): boolean {
+  return typeof (pi as Partial<NativeMcpApi>).registerMcpServer === "function";
+}
+
+export function nativeServerConfig(
+  config: GortexConfig,
+  env: Record<string, string | undefined> = process.env,
+): Parameters<ExtensionAPI["registerMcpServer"]>[1] {
+  return {
+    command: config.bin,
+    args: ["mcp"],
+    env: presetEnv(config.toolsPreset, env),
+    // Declared to the model like built-in tools, and the first prompt waits
+    // for the connection. Codemode would hand scripts gcx text to parse.
+    exposure: "direct",
+    timeout: CALL_TIMEOUT_MS / 1000,
+    description: SERVER_DESCRIPTION,
+  };
+}
+
+/** Registers the server; returns why it failed, or "" on success. */
+export function registerNativeServer(pi: ExtensionAPI, config: GortexConfig): string {
+  try {
+    (pi as NativeMcpApi).registerMcpServer(MCP_SERVER_NAME, nativeServerConfig(config));
+    return "";
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+}
+
+/**
+ * Whether `bin` names an executable file, directly or through PATH. Pi reports
+ * no connection failure to extensions, so a server that cannot spawn would
+ * read as one still connecting.
+ */
+export function binaryResolves(bin: string, env: Record<string, string | undefined> = process.env): boolean {
+  const exts = process.platform === "win32" ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")] : [""];
+  const candidates = /[\\/]/.test(bin)
+    ? [bin]
+    : (env.PATH ?? "").split(delimiter).filter(Boolean).map((dir) => join(dir, bin));
+  return candidates.some((path) =>
+    exts.some((ext) => {
+      try {
+        accessSync(path + ext, constants.X_OK);
+        return statSync(path + ext).isFile();
+      } catch {
+        return false;
+      }
+    }),
+  );
+}
+
+/**
+ * The daemon version the session_start briefing reports, or "" when it names
+ * none. The briefing is the only place it reaches the extension on Pi's MCP.
+ */
+export function daemonVersionFromBriefing(briefing: string): string {
+  return /Gortex daemon [^(\n]*\(v(\d[^,\s)]*)/.exec(briefing)?.[1] ?? "";
+}
+
+/**
+ * Whether an extension that connects MCP servers is loaded. Pi's own MCP
+ * extension and the ones that replace it register `/mcp`; `--no-mcp` and
+ * `-ne` without `builtin:mcp` leave a registration with nothing to connect it.
+ * Read on session_start, once every extension has loaded. A Pi that cannot
+ * list commands is trusted to connect the server.
+ */
+export function mcpConnectorLoaded(pi: ExtensionAPI): boolean {
+  try {
+    return (pi as NativeMcpApi).getCommands().some((command) => command.name === "mcp");
+  } catch {
+    return true;
+  }
+}
+
+/** Withdraws the registration, which also keeps Pi from reporting it as unconnected. */
+export function unregisterNativeServer(pi: ExtensionAPI): void {
+  try {
+    (pi as NativeMcpApi).unregisterMcpServer(MCP_SERVER_NAME);
+  } catch {
+    // already gone, or this instance has been invalidated
+  }
+}
+
+export function isNativeGortexTool(name: string): boolean {
+  return name.startsWith(MCP_TOOL_PREFIX);
+}
+
+/** The daemon's own name for a native tool, as Gortex guidance spells it. */
+export function bareToolName(name: string): string {
+  return isNativeGortexTool(name) ? name.slice(MCP_TOOL_PREFIX.length) : name;
+}
+
+/** True once Pi has registered at least one tool from the gortex server. */
+export function nativeToolsReady(pi: ExtensionAPI): boolean {
+  try {
+    return (pi as NativeMcpApi).getAllTools().some((tool) => isNativeGortexTool(tool.name));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * How long the first turn waits for the gortex tools on top of Pi's own wait.
+ * Pi's MCP extension already holds the first prompt for up to 10s on a direct
+ * server, so this only covers a daemon still warming up after that.
+ */
+export const NATIVE_READY_WAIT_MS = 5_000;
+
+/** Resolves true once the gortex tools are registered, false when `ms` passes first. */
+export async function waitForNativeTools(pi: ExtensionAPI, ms: number, pollMs = 100): Promise<boolean> {
+  const deadline = Date.now() + ms;
+  while (!nativeToolsReady(pi)) {
+    if (Date.now() >= deadline) return false;
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+  return true;
+}

package/src/render.ts

@@ -1,18 +1,25 @@
 // TUI rendering for bridged tools: a call line read off Gortex's argument
 // shape (operation, target, options), Pi's own read renderer for a file read,
-// and a result collapsed until the user expands it.
+// an edit's diff, and a result collapsed until the user expands it.
 
-import { createReadToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { Theme, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { createReadToolDefinition, renderDiff } from "@earendil-works/pi-coding-agent";
+import type { Theme, ToolDefinition, ToolRenderers } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import type { Component } from "@earendil-works/pi-tui";
 
+import type { EditDetails } from "./diff.ts";
 import { textFromResult } from "./mcp-client.ts";
+import { isNativeGortexTool } from "./native.ts";
 
 type ToolRenderContext = Parameters<NonNullable<ToolDefinition["renderCall"]>>[2];
 
 export type RenderCall = (args: Record<string, unknown>, theme: Theme, context: ToolRenderContext) => Component;
-export type RenderResult = (result: unknown, options: { expanded?: boolean }) => Component;
+export type RenderResult = (
+  result: unknown,
+  options: { expanded?: boolean },
+  theme?: Theme,
+  context?: ToolRenderContext,
+) => Component;
 
 const OPERATION_ARGS = ["operation", "kind"];
 const SUBJECT_ARGS = ["target", "query", "question", "task", "path"];
@@ -144,6 +151,56 @@ export function resultText(result: unknown): string {
   return textFromResult(result) || JSON.stringify(structured ?? result ?? {});
 }
 
-/** renderResult collapses the result to nothing until the user expands it with ctrl+o. */
-export const renderResult: RenderResult = (result, options) =>
-  new Text(options?.expanded ? resultText(result) : "", 0, 0);
+/** diffView draws each file an edit changed with Pi's diff renderer, or nothing when the result has none. */
+function diffView(result: unknown, theme: Theme | undefined, context: ToolRenderContext | undefined): Container | undefined {
+  const diffs = (result as { details?: EditDetails })?.details?.diffs;
+  if (!diffs?.length || !theme || context?.isError) return undefined;
+  const view = new Container();
+  for (const { path, diff, note } of diffs) {
+    view.addChild(new Spacer(1));
+    if (note) {
+      view.addChild(new Text(`${theme.fg("accent", path)} ${theme.fg("muted", note)}`, 1, 0));
+      continue;
+    }
+    if (diffs.length > 1) view.addChild(new Text(theme.fg("accent", path), 1, 0));
+    view.addChild(new Text(renderDiff(diff, { filePath: path }), 1, 0));
+  }
+  return view;
+}
+
+/**
+ * renderResult shows the diff of every file an edit changed, the way Pi's own
+ * edit does. Gortex's text reply stays collapsed until the user expands it
+ * with ctrl+o.
+ */
+export const renderResult: RenderResult = (result, options, theme, context) => {
+  const text = new Text(options?.expanded ? resultText(result) : "", 0, 0);
+  const view = diffView(result, theme, context);
+  if (!view) return text;
+  if (options?.expanded) view.addChild(text);
+  return view;
+};
+
+/**
+ * nativeRenderers draws the diffs watchNativeEdits stores above Pi's own MCP
+ * result, which shows once expanded or on an error. Every other tool keeps its
+ * renderers.
+ */
+export function nativeRenderers(toolName: string, next: () => ToolRenderers | undefined): ToolRenderers | undefined {
+  const base = next();
+  // Without a base, Pi's MCP extension fills in its own renderers.
+  if (!base || !isNativeGortexTool(toolName)) return base;
+  const baseResult = base.renderResult;
+  return {
+    ...base,
+    renderResult(result, options, theme, context) {
+      // Pi's renderer reuses lastComponent as its own and clears it.
+      const own = () => baseResult?.(result, options, theme, { ...context, lastComponent: undefined });
+      const rest = options.expanded || context.isError ? own() : undefined;
+      const view = diffView(result, theme, context);
+      if (!view) return rest ?? new Text("", 0, 0);
+      if (rest) view.addChild(rest);
+      return view;
+    },
+  };
+}

package/src/runtime.ts

@@ -8,11 +8,15 @@ import type { SpawnOptions } from "node:child_process";
 
 export interface ChildStream {
   on(event: string, listener: (chunk: unknown) => void): unknown;
+  /** Drops the event-loop reference; I/O keeps working. */
+  unref?(): unknown;
 }
 
 export interface ChildStdin {
   on(event: string, listener: (err: unknown) => void): unknown;
   write(chunk: string): unknown;
+  /** Drops the event-loop reference; I/O keeps working. */
+  unref?(): unknown;
 }
 
 /** The subset of ChildProcess the MCP bridge and the daemon launcher touch. */

package/src/state.ts

@@ -3,7 +3,9 @@
 // Shared at module level on purpose: a new invocation's session_start stops the
 // previous invocation's bridge child, which works only while both invocations
 // see the same `client`. Move this into the factory closure and every `/new`
-// leaks a `gortex mcp` process.
+// leaks a `gortex mcp` process. Reload is the exception: Pi re-imports the
+// extension with a fresh module graph, so there the old instance's
+// session_shutdown handler is what stops its bridge.
 
 import type { MCPStdioClient } from "./mcp-client.ts";
 
@@ -31,6 +33,13 @@ let versionWarning = "";
  */
 export const gortexToolNames = new Set<string>();
 
+/**
+ * Registered names the daemon has since dropped from its list. Pi cannot
+ * unregister a tool, so these are switched off in the active set instead, and
+ * back on if the daemon lists them again.
+ */
+export const withdrawnToolNames = new Set<string>();
+
 export function getClient(): MCPStdioClient | null {
   return client;
 }