pi-spark 0.13.0 → 0.14.0

package/README.md

@@ -4,6 +4,8 @@
 
 [Pi](https://pi.dev/) package that polishes your daily experience and keeps you at the frontier of agentic workflows.
 
+![Overview](./assets/screenshot-overview.png)
+
 ## Features
 
 ### Compact TUI: editor, footer, and fullscreen
@@ -14,6 +16,8 @@ pi-spark ships with custom editor, footer, and fullscreen rendering, replacing t
 - The footer shows session information, extension statuses, cost, and context usage on one line.
 - The fullscreen rendering clears the terminal screen and scrollback on session start and exit, and pins the editor and footer to the bottom.
 
+![Compact TUI](./assets/screenshot-tui.png)
+
 ### Credits
 
 pi-spark shows the active provider's credit balance or rate-limit usage in the status line, so you can keep an eye on what's left without leaving the terminal.
@@ -21,6 +25,8 @@ pi-spark shows the active provider's credit balance or rate-limit usage in the s
 - Supported providers: DeepSeek, Fireworks, Moonshot, OpenAI Codex, OpenRouter, and Vercel AI Gateway.
 - Most provider fetching follows [CodexBar](https://github.com/steipete/codexbar). Fireworks is the exception: its balance sits behind an internal gRPC API, reverse-engineered from the `firectl` binary (see [docs/fireworks.md](./docs/fireworks.md)).
 
+![Credits](./assets/screenshot-credits.png)
+
 ### Presets
 
 pi-spark lets you define named model presets in `spark.json` (see [Configuration](#configuration)), so you can switch between models and thinking levels without retyping provider details. The active preset is shown on the editor's top border.
@@ -29,6 +35,8 @@ pi-spark lets you define named model presets in `spark.json` (see [Configuration
 - Start pi on a given preset with `pi --preset <name>`.
 - Cycle presets with `ctrl+super+p` (forward) and `ctrl+shift+super+p` (backward); `super` is `command` on macOS and needs a terminal that forwards it.
 
+![Presets](./assets/screenshot-presets.png)
+
 ### Recap
 
 pi-spark generates a short recap of the current session after it goes idle, or on demand, inspired by [Claude Code's session recap](https://code.claude.com/docs/en/interactive-mode#session-recap).
@@ -37,12 +45,24 @@ pi-spark generates a short recap of the current session after it goes idle, or o
 - Run `/recap` to generate one manually at any time.
 - The recap can use its own model, configured separately from your working model.
 
-### Agent tools: `name` and `model`
+![Recap](./assets/screenshot-recap.png)
+
+### Agent tools: `pi` and `web`
 
-pi-spark provides the pi coding agent with tools to inspect and manipulate itself. Currently, `name` and `model` tools are included.
+pi-spark adds two agent tools:
 
+The `pi` tool lets the pi coding agent inspect and manipulate itself (~740 tokens).
+
+- `models` lists and searches the model catalog.
 - `name` sets or updates the current session's name.
-- `model` shows the active model or lists pi models.
+- `whoami` shows the current pi state with session name, active model with metadata, and thinking level.
+
+The `web` tool gives the agent live web access, backed by the free [Exa MCP](https://exa.ai/mcp) (~350 tokens). No separate MCP setup or API key is needed.
+
+- `search` finds current information across the web and returns clean, ready-to-use content.
+- `fetch` reads the full content of known URLs as clean markdown, and can batch several URLs in one call.
+
+![Agent tools](./assets/screenshot-tools.png)
 
 ## Configuration
 
@@ -87,10 +107,10 @@ All fields are optional. Each top-level feature runs with the defaults below unl
 | `editor` | `EditorConfig` | Shows a working indicator and the current model on the editor's top border. |
 | `footer` | `{}` | Shows session info, extension statuses, cost, and context usage on one line. |
 | `fullscreen` | `{}` | Clears the screen and scrollback on start and exit, and pins the editor and footer to the bottom. |
-| `model` | `{}` | Exposes the `model` agent tool. |
-| `name` | `{}` | Exposes the `name` agent tool. |
+| `pi` | `{}` | Exposes the `pi` agent tool (`models`, `name`, `whoami` actions). |
 | `presets` | `{ [name]: Preset }` | Defines named model presets, keyed by name. |
 | `recap` | `RecapConfig` | Generates a session recap when idle or on demand. |
+| `web` | `{}` | Exposes the `web` agent tool (`search`, `fetch` actions) via Exa's hosted MCP server. |
 
 #### `EditorConfig`
 
@@ -109,8 +129,8 @@ Each preset must set all three fields.
 
 | Field | Value | Description |
 | --- | --- | --- |
-| `provider` | string | Provider id, e.g. `anthropic`. |
-| `model` | string | Model id, e.g. `claude-opus-4-8`. |
+| `provider` | string | Provider ID, e.g., `anthropic`. |
+| `model` | string | Model ID, e.g., `claude-opus-4-8`. |
 | `thinkingLevel` | `off`, `minimal`, `low`, `medium`, `high`, `xhigh` | Thinking level for the preset. |
 
 #### `RecapConfig`
@@ -119,9 +139,9 @@ All fields are optional, including `thinkingLevel`.
 
 | Field | Value | Description |
 | --- | --- | --- |
-| `idle` | number (ms) or duration string | How long the session must stay idle before a recap is generated. Accepts a millisecond number or a [vercel/ms](https://github.com/vercel/ms) string (e.g. `"3m"`); minimum 5000 ms, defaults to 3 minutes. |
-| `provider` | string | Provider id for the recap model. |
-| `model` | string | Model id for the recap model. |
+| `idle` | number (ms) or duration string | How long the session must stay idle before a recap is generated. Accepts a millisecond number or a [vercel/ms](https://github.com/vercel/ms) string (e.g., `"3m"`); minimum 5000 ms, defaults to 3 minutes. |
+| `provider` | string | Provider ID for the recap model. |
+| `model` | string | Model ID for the recap model. |
 | `thinkingLevel` | `off`, `minimal`, `low`, `medium`, `high`, `xhigh` | Thinking level for the recap model. |
 
 ### Turn off the features you don't like

package/index.ts

@@ -3,10 +3,10 @@ import { registerCredits } from "./src/features/credits";
 import { registerEditor } from "./src/features/editor";
 import { registerFooter } from "./src/features/footer";
 import { registerFullscreen } from "./src/features/fullscreen";
-import { registerModel } from "./src/features/model";
-import { registerName } from "./src/features/name";
+import { registerPi } from "./src/features/pi";
 import { registerPresets } from "./src/features/presets";
 import { registerRecap } from "./src/features/recap";
+import { registerWeb } from "./src/features/web";
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
@@ -24,8 +24,8 @@ export default function (pi: ExtensionAPI) {
   registerEditor(pi, events);
   registerFooter(pi);
   registerFullscreen(pi);
-  registerModel(pi);
-  registerName(pi);
+  registerPi(pi);
   registerPresets(pi);
   registerRecap(pi);
+  registerWeb(pi);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-spark",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Pi package that polishes your daily experience and keeps you at the frontier of agentic workflows.",
   "keywords": [
     "pi-coding-agent",
@@ -31,6 +31,7 @@
   "dependencies": {
     "@grpc/grpc-js": "^1.14.4",
     "@grpc/proto-loader": "^0.8.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "liqe": "^3.8.7",
     "ms": "4.0.0-nightly.202508271359",
     "zod": "^4.4.3"

package/src/config/index.ts

@@ -16,10 +16,10 @@ const DISABLED_CONFIG: SparkConfig = Object.freeze({
   editor: false,
   footer: false,
   fullscreen: false,
-  model: false,
-  name: false,
+  pi: false,
   presets: false,
   recap: false,
+  web: false,
 });
 
 const cache = new Map<string, SparkConfig>();

package/src/config/schema.ts

@@ -4,10 +4,10 @@ import { creditsConfigSchema } from "../features/credits/config";
 import { editorConfigSchema } from "../features/editor/config";
 import { footerConfigSchema } from "../features/footer/config";
 import { fullscreenConfigSchema } from "../features/fullscreen/config";
-import { modelConfigSchema } from "../features/model/config";
-import { nameConfigSchema } from "../features/name/config";
+import { piConfigSchema } from "../features/pi/config";
 import { presetsConfigSchema } from "../features/presets/config";
 import { recapConfigSchema } from "../features/recap/config";
+import { webConfigSchema } from "../features/web/config";
 
 const disabled = z.literal(false);
 
@@ -20,10 +20,10 @@ export const sparkConfigSchema = z.object({
   editor: editorConfigSchema.or(disabled).default({}),
   footer: footerConfigSchema.or(disabled).default({}),
   fullscreen: fullscreenConfigSchema.or(disabled).default({}),
-  model: modelConfigSchema.or(disabled).default({}),
-  name: nameConfigSchema.or(disabled).default({}),
+  pi: piConfigSchema.or(disabled).default({}),
   presets: presetsConfigSchema.or(disabled).default({}),
   recap: recapConfigSchema.or(disabled).default({}),
+  web: webConfigSchema.or(disabled).default({}),
 });
 
 /** Resolved config for every feature; `false` means the feature is disabled. */

package/src/features/pi/actions/models.ts

@@ -0,0 +1,166 @@
+import { keyText, truncateHead } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { filter, parse } from "liqe";
+import { Type } from "typebox";
+
+import { defineAction } from "../registry";
+import { formatListNotice, toMetadata, toModelRow } from "../model";
+
+import type { TruncationResult } from "@earendil-works/pi-coding-agent";
+import type { ModelMetadata, ModelRow } from "../model";
+
+const LIST_MAX_LINES = 200;
+const COLLAPSED_MAX_LINES = 10;
+
+interface ModelsDetails {
+  action: "models";
+  models: ModelMetadata[];
+  total: number;
+  truncation?: TruncationResult;
+}
+
+export const modelsAction = defineAction({
+  name: "models",
+  summary: `lists and searches the model catalog (one JSON object per line, truncated to ${LIST_MAX_LINES} models)`,
+  fields: {
+    query: Type.Optional(Type.String({
+      description:
+        "For \"models\": filter models with a Liqe (Lucene-like) query. Bare terms match any " +
+        "field, and unquoted terms are case-insensitive substrings. The syntax supports " +
+        "AND/OR/NOT, grouping, wildcards, and numeric comparisons; quote values containing " +
+        "special characters (e.g., id:\"deepseek/deepseek-v4\"). Filterable fields are id, name, " +
+        "provider, api, reasoning (boolean), input (modalities), cost.input and cost.output " +
+        "(USD per 1M tokens), contextWindow, maxTokens, thinkingLevels, and available " +
+        "(boolean, true when auth is configured). The catalog is large, so include " +
+        "available:true unless every model is needed (e.g., \"claude available:true\", " +
+        "\"provider:openrouter cost.input:<1\").",
+    })),
+    offset: Type.Optional(Type.Number({ description: "For \"models\": start from this model number (1-indexed)." })),
+    limit: Type.Optional(Type.Number({ description: "For \"models\": Return at most this many models." })),
+  },
+  promptGuidelines: [
+    "Use the pi tool's \"models\" action when you need metadata of pi models; include available:true in the query unless unavailable models are needed.",
+  ],
+  renderCall(args, theme) {
+    let text = `${theme.bold(theme.fg("toolTitle", "pi"))} ${theme.fg("accent", "models")}`;
+
+    const query = args.query?.trim();
+    if (query) text += theme.fg("muted", ` ${query}`);
+
+    if (args.offset !== undefined || args.limit !== undefined) {
+      const start = args.offset ?? 1;
+      const end = args.limit !== undefined ? start + args.limit - 1 : "end";
+      text += theme.fg("warning", ` ${start}-${end}`);
+    }
+
+    return new Text(text, 0, 0);
+  },
+  renderResult(result, { expanded }, theme, context) {
+    const details = result.details as ModelsDetails | undefined;
+
+    const container = new Container();
+    container.addChild(new Spacer(1));
+
+    if (!details) {
+      container.addChild(new Text(theme.fg("muted", "No models found."), 0, 0));
+      return container;
+    }
+
+    const addRows = (rows: ModelRow[]) => {
+      const widths = {
+        label: Math.max(...rows.map((row) => row.label.length)),
+        cost: Math.max(...rows.map((row) => row.cost.length)),
+        context: Math.max(...rows.map((row) => row.context.length)),
+      };
+
+      for (const row of rows) {
+        const cells = [
+          row.label.padEnd(widths.label),
+          row.cost.padStart(widths.cost),
+          row.context.padStart(widths.context),
+        ].join("  ");
+        const noAuthHint = row.available ? "" : theme.fg("dim", "  (no auth)");
+        container.addChild(new Text(theme.fg("muted", cells) + noAuthHint, 0, 0));
+      }
+    };
+
+    const filtered = Boolean(context.args.query?.trim());
+    const models = details.models ?? [];
+    const total = details.total ?? models.length;
+
+    if (models.length > 0) {
+      const maxRows = expanded ? models.length : Math.min(models.length, COLLAPSED_MAX_LINES);
+      addRows(models.slice(0, maxRows).map((model) => toModelRow(model)));
+
+      const hiddenRows = models.length - maxRows;
+      if (hiddenRows > 0) container.addChild(new Text(theme.fg("dim", `... (${hiddenRows} more, ${keyText("app.tools.expand")} to expand)`), 0, 0));
+      container.addChild(new Spacer(1));
+    }
+
+    if (details.truncation?.truncated) {
+      const startIndex = context.args.offset ? Math.max(0, context.args.offset - 1) : 0;
+      const endDisplay = startIndex + models.length;
+      const notice = formatListNotice(true, startIndex, endDisplay, total);
+      if (notice) {
+        container.addChild(new Text(theme.fg("warning", notice), 0, 0));
+        container.addChild(new Spacer(1));
+      }
+    }
+
+    const summary = `${models.length !== total ? `${models.length} of ` : ""}${total} ${filtered ? "matched " : ""}model${total === 1 ? "" : "s"} listed.`;
+    container.addChild(new Text(theme.fg("muted", total > 0 ? summary : `No models ${filtered ? "matched" : "found"}.`), 0, 0));
+
+    return container;
+  },
+  async execute(args, { ctx }) {
+    const queryText = args.query?.trim();
+    const filtered = Boolean(queryText);
+
+    let listQuery = null;
+    if (queryText) {
+      try {
+        listQuery = parse(queryText);
+      } catch (error) {
+        throw new Error(`Invalid Liqe query ${JSON.stringify(queryText)}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+
+    const models = ctx.modelRegistry.getAll().map((model) => toMetadata(model, ctx.modelRegistry.hasConfiguredAuth(model)));
+    const matched = listQuery ? filter(listQuery, models) : models;
+    const total = matched.length;
+
+    if (total === 0) {
+      return {
+        content: [{ type: "text", text: `No models ${filtered ? "matched" : "found"}.` }],
+        details: { action: "models", models: [], total } satisfies ModelsDetails,
+      };
+    }
+
+    // Convert from 1-indexed offset to 0-indexed array access.
+    const startIndex = args.offset ? Math.max(0, args.offset - 1) : 0;
+    if (startIndex >= total) {
+      throw new Error(`Offset ${args.offset} is beyond the end of the list (${total} models total).`);
+    }
+
+    const endIndex = args.limit !== undefined ? Math.min(startIndex + args.limit, total) : total;
+    const selected = matched.slice(startIndex, endIndex);
+
+    // JSONL: one compact object per line, so truncation cuts at record boundaries.
+    const truncation = truncateHead(selected.map((model) => JSON.stringify(model)).join("\n"), {
+      maxLines: LIST_MAX_LINES,
+      maxBytes: Infinity,
+    });
+
+    const delivered = truncation.truncated ? selected.slice(0, truncation.outputLines) : selected;
+    const endDisplay = startIndex + delivered.length;
+
+    let text = truncation.content;
+    const notice = formatListNotice(truncation.truncated, startIndex, endDisplay, total);
+    if (notice) text += `\n\n${notice}`;
+
+    return {
+      content: [{ type: "text", text }],
+      details: { action: "models", models: delivered, total, truncation } satisfies ModelsDetails,
+    };
+  },
+});

package/src/features/pi/actions/name.ts

@@ -0,0 +1,76 @@
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+
+import { sanitizeText } from "../../../utils/format";
+import { defineAction } from "../registry";
+
+interface NameDetails {
+  action: "name";
+  changed: boolean;
+  previous: string | null;
+}
+
+export const nameAction = defineAction({
+  name: "name",
+  summary: "sets or updates the current session's name",
+  fields: {
+    name: Type.String({
+      minLength: 1,
+      maxLength: 120,
+      description:
+        "For \"name\": Use a short, recognizable phrase in sentence case, ideally <= 72 characters " +
+        "(e.g., \"Refactor auth module\", \"Debug flaky CI pipeline\"). Do not use " +
+        "surrounding quotes, trailing punctuation, or generic prefixes like \"Chat about\".",
+    }),
+    reason: Type.Optional(Type.String({
+      maxLength: 240,
+      description:
+        "For \"name\": Explain briefly why the session was named or renamed, such as a long pasted " +
+        "prompt, an ambiguous first message, or a topic shift. Write one user-facing " +
+        "sentence (e.g., \"The focus shifted from debugging to README updates.\").",
+    })),
+  },
+  required: ["name"],
+  promptGuidelines: [
+    "Use the pi tool's \"name\" action to give the current session a concise, recognizable name, especially after a long, vague, or pasted opening prompt, or after a substantial shift in the conversation's focus.",
+  ],
+  renderCall(args, theme) {
+    const name = sanitizeText(args.name ?? "");
+    const reason = sanitizeText(args.reason ?? "");
+
+    const container = new Container();
+    container.addChild(new Text(`${theme.bold(theme.fg("toolTitle", "pi"))} ${theme.fg("accent", "name")} ${theme.fg("muted", name)}`, 0, 0));
+
+    if (reason) {
+      container.addChild(new Spacer(1));
+      container.addChild(new Text(theme.fg("muted", reason), 0, 0));
+    }
+
+    return container;
+  },
+  renderResult() {
+    // "name" has no success UI; errors are rendered by the registry's fallback.
+    return new Text("", 0, 0);
+  },
+  async execute(args, { pi }) {
+    const name = sanitizeText(args.name);
+    if (!name) throw new Error("Session name was empty after normalization; provide a short, non-empty phrase.");
+
+    const previous = pi.getSessionName() ?? null;
+    if (previous === name) {
+      const details: NameDetails = { action: "name", changed: false, previous };
+      return {
+        content: [{ type: "text", text: `Session is already named "${name}". Nothing changed.` }],
+        details,
+      };
+    }
+
+    pi.setSessionName(name);
+
+    const details: NameDetails = { action: "name", changed: true, previous };
+    return {
+      content: [{ type: "text", text: previous ? `Renamed session from "${previous}" to "${name}".` : `Named session "${name}".` }],
+      details,
+    };
+  },
+});

package/src/features/pi/actions/whoami.ts

@@ -0,0 +1,60 @@
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+
+import { defineAction } from "../registry";
+import { toMetadata, toModelRow } from "../model";
+
+import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
+import type { ModelMetadata } from "../model";
+
+interface WhoamiDetails {
+  action: "whoami";
+  sessionName: string | null;
+  model: ModelMetadata | null;
+  thinkingLevel: ModelThinkingLevel;
+}
+
+export const whoamiAction = defineAction({
+  name: "whoami",
+  summary: "shows the current pi state with session name, active model with metadata, and thinking level",
+  fields: {},
+  promptGuidelines: [
+    "Use the pi tool's \"whoami\" action when you need the current session's name or the active model and thinking level.",
+  ],
+  renderResult(result, _options, theme) {
+    const details = result.details as WhoamiDetails | undefined;
+
+    const container = new Container();
+    container.addChild(new Spacer(1));
+
+    if (!details) {
+      container.addChild(new Text(theme.fg("muted", "No pi state available."), 0, 0));
+      return container;
+    }
+
+    const sessionName = details.sessionName ?? theme.fg("dim", "(unnamed)");
+    container.addChild(new Text(`${theme.fg("muted", "session")}  ${theme.fg("accent", sessionName)}`, 0, 0));
+
+    if (details.model) {
+      const row = toModelRow(details.model, details.thinkingLevel);
+      const cells = [row.label, row.cost, row.context].join("  ");
+      container.addChild(new Text(`${theme.fg("muted", "model")}    ${theme.fg("muted", cells)}`, 0, 0));
+    } else {
+      container.addChild(new Text(`${theme.fg("muted", "model")}    ${theme.fg("dim", "(no-model)")}`, 0, 0));
+    }
+
+    return container;
+  },
+  async execute(_args, { pi, ctx }) {
+    const state: WhoamiDetails = {
+      action: "whoami",
+      sessionName: pi.getSessionName() ?? null,
+      model: ctx.model ? toMetadata(ctx.model, true) : null,
+      thinkingLevel: pi.getThinkingLevel(),
+    };
+
+    return {
+      content: [{ type: "text", text: JSON.stringify(state) }],
+      details: state,
+    };
+  },
+});

package/src/features/pi/config.ts

@@ -0,0 +1,3 @@
+import * as z from "zod";
+
+export const piConfigSchema = z.object({});

package/src/features/pi/index.ts

@@ -0,0 +1,23 @@
+import { nameAction } from "./actions/name";
+import { modelsAction } from "./actions/models";
+import { whoamiAction } from "./actions/whoami";
+import { registerPiTool } from "./registry";
+import { loadConfig } from "../../config";
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+/** Self-management actions exposed by the pi tool, ordered alphabetically by action name. */
+const ACTIONS = [
+  modelsAction,
+  nameAction,
+  whoamiAction,
+];
+
+export function registerPi(pi: ExtensionAPI): void {
+  pi.on("session_start", (_event, ctx) => {
+    const config = loadConfig(ctx).pi;
+    if (!config) return;
+
+    registerPiTool(pi, ACTIONS);
+  });
+}

package/src/features/pi/model.ts

@@ -0,0 +1,56 @@
+import { clampThinkingLevel, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+
+import { formatModel, formatTokens } from "../../utils/format";
+
+import type { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
+
+/** Pi's built-in default thinking level, clamped per model. Not exported by pi's public API. */
+const DEFAULT_THINKING_LEVEL: ModelThinkingLevel = "medium";
+
+export type ModelMetadata = Omit<Model<Api>, "headers" | "compat"> & {
+  thinkingLevels: ModelThinkingLevel[];
+  defaultThinkingLevel: ModelThinkingLevel;
+  available: boolean;
+};
+
+export type ModelRow = {
+  label: string;
+  cost: string;
+  context: string;
+  available: boolean;
+};
+
+export function toMetadata(model: Model<Api>, available: boolean): ModelMetadata {
+  const { headers: _headers, compat: _compat, ...metadata } = model;
+
+  return {
+    ...metadata,
+    thinkingLevels: getSupportedThinkingLevels(model),
+    defaultThinkingLevel: clampThinkingLevel(model, DEFAULT_THINKING_LEVEL),
+    available,
+  };
+}
+
+export function toModelRow(model: ModelMetadata, thinkingLevel?: ModelThinkingLevel): ModelRow {
+  return {
+    label: formatModel(model.provider, model.id, thinkingLevel),
+    cost: `$${formatPrice(model.cost.input)}/$${formatPrice(model.cost.output)}`,
+    context: formatTokens(model.contextWindow),
+    available: model.available,
+  };
+}
+
+/** Round to at most 2 decimals and trim float noise: 0.7999... -> 0.8, 0.0983 -> 0.1, 15 -> 15. */
+function formatPrice(value: number): string {
+  return String(parseFloat(value.toFixed(2)));
+}
+
+/** Notice line describing truncation or remaining pages, shared by the text result and the TUI. */
+export function formatListNotice(truncated: boolean, startIndex: number, endDisplay: number, total: number): string | undefined {
+  const nextOffset = endDisplay + 1;
+
+  if (truncated) return `[Truncated: showing models ${startIndex + 1}-${endDisplay} of ${total}. Use offset=${nextOffset} to continue.]`;
+  if (endDisplay < total) return `[${total - endDisplay} more models in list. Use offset=${nextOffset} to continue.]`;
+
+  return undefined;
+}

package/src/features/pi/registry.ts

@@ -0,0 +1,117 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+
+import { joinTextContent } from "../../utils/format";
+
+import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { Static, TObject, TProperties, TSchema } from "typebox";
+
+const DESCRIPTION_INTRO =
+  "Inspect and adjust the current pi session and model state. This tool groups self-management " +
+  "actions over the running pi instance:";
+
+const DESCRIPTION_OUTRO = "Use this tool to read or change pi's own state instead of guessing.";
+
+const GENERAL_GUIDELINE =
+  "The pi tool operates only on pi's own session and model state; it does not read or modify the " +
+  "user's project, files, or task.";
+
+interface ActionDetails {
+  action: string;
+}
+
+interface ActionContext {
+  pi: ExtensionAPI;
+  ctx: ExtensionContext;
+}
+
+/**
+ * One self-management action of the pi tool, owning its fields, execution, and rendering. The
+ * registry merges every action's `fields` into one flat object schema (provider-safe, unlike a
+ * discriminated union; see the StringEnum note in pi's extension docs) and dispatches by `action`.
+ */
+interface Action<F extends TProperties = TProperties, D extends ActionDetails = ActionDetails> {
+  name: D["action"];
+  summary: string;
+  fields: F;
+  /** Fields required at runtime, since the flat schema makes every action's fields optional. */
+  required?: (keyof F & string)[];
+  /** Guideline bullets contributed to the tool's system-prompt guidelines. */
+  promptGuidelines?: string[];
+  renderCall?: NonNullable<ToolDefinition<TObject<F>, D>["renderCall"]>;
+  renderResult?: NonNullable<ToolDefinition<TObject<F>, D>["renderResult"]>;
+  execute(args: Static<TObject<F>>, context: ActionContext, signal: AbortSignal | undefined): Promise<AgentToolResult<D>>;
+}
+
+/** Identity helper that preserves per-action field and details inference at the definition site. */
+export function defineAction<F extends TProperties, D extends ActionDetails>(action: Action<F, D>): Action<F, D> {
+  return action;
+}
+
+/**
+ * Compose the actions into a single flat-schema tool and register it as `pi`. Actions are
+ * heterogeneous, so the collection is typed loosely here; type safety lives at each `defineAction`.
+ */
+export function registerPiTool(pi: ExtensionAPI, actions: Action<any, any>[]): void {
+  const byName = new Map<string, Action<any, any>>();
+  const mergedFields: TProperties = {};
+
+  for (const action of actions) {
+    if (byName.has(action.name)) throw new Error(`Duplicate pi action "${action.name}".`);
+    byName.set(action.name, action);
+
+    for (const [key, schema] of Object.entries(action.fields)) {
+      if (key === "action") throw new Error(`pi action "${action.name}" must not define a field named "action".`);
+      if (key in mergedFields) throw new Error(`pi action "${action.name}" redefines field "${key}"; field names must be unique across actions.`);
+      mergedFields[key] = Type.Optional(schema as TSchema);
+    }
+  }
+
+  const summaries = actions.map((action) => `"${action.name}" ${action.summary}`).join("; ");
+
+  const parameters = Type.Object({
+    action: StringEnum(actions.map((action) => action.name), { description: "The pi action to run." }),
+    ...mergedFields,
+  });
+
+  pi.registerTool({
+    name: "pi",
+    label: "pi",
+    description: `${DESCRIPTION_INTRO} ${summaries}. ${DESCRIPTION_OUTRO}`,
+    promptSnippet: "Inspect and adjust the current pi session and model state",
+    promptGuidelines: [GENERAL_GUIDELINE, ...actions.flatMap((action) => action.promptGuidelines ?? [])],
+    parameters,
+    renderCall(args, theme, context) {
+      const action = byName.get(args.action);
+      if (action?.renderCall) return action.renderCall(args, theme, context);
+
+      return new Text(`${theme.bold(theme.fg("toolTitle", "pi"))} ${theme.fg("accent", args.action)}`, 0, 0);
+    },
+    renderResult(result, options, theme, context) {
+      const details = result.details as ActionDetails | undefined;
+
+      if (context.isError || !details) {
+        const output = joinTextContent(result.content);
+        return new Text(context.isError && output ? theme.fg("error", "\n" + output) : "", 0, 0);
+      }
+
+      const action = byName.get(details.action);
+      if (action?.renderResult) return action.renderResult(result as AgentToolResult<ActionDetails>, options, theme, context);
+
+      return new Text(joinTextContent(result.content), 0, 0);
+    },
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const action = byName.get(params.action);
+      if (!action) throw new Error(`Unknown pi action "${params.action}".`);
+
+      for (const field of action.required ?? []) {
+        if ((params as Record<string, unknown>)[field] === undefined) {
+          throw new Error(`The "${params.action}" action requires "${field}".`);
+        }
+      }
+
+      return action.execute(params as never, { pi, ctx }, signal);
+    },
+  });
+}

package/src/features/web/client.ts

@@ -0,0 +1,72 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+import type { TextContent } from "@earendil-works/pi-ai";
+
+/** Exa's hosted MCP endpoint (Streamable HTTP). No API key required for the free tier. */
+const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
+
+/** Collapse an MCP tool call result's content into plain text content for the model. */
+function sanitizeContent(content: unknown): TextContent[] {
+  const blocks = (Array.isArray(content) ? content : []) as { type: string; text?: string}[];
+  const result: TextContent[] = blocks.map((block) =>
+    block.type === "text" && typeof block.text === "string"
+      ? { type: "text", text: block.text }
+      : { type: "text", text: JSON.stringify(block) },
+  );
+
+  return result;
+}
+
+/**
+ * Thin, session-scoped wrapper over Exa's remote MCP server using the official MCP client.
+ *
+ * The MCP connection (one `initialize` handshake) is established lazily on the first call and
+ * reused for the rest of the session; `close()` tears it down on `session_shutdown`.
+ */
+export class ExaClient {
+  private client: Client | undefined;
+  private connecting: Promise<Client> | undefined;
+
+  async call(toolName: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<TextContent[]> {
+    const client = await this.getClient();
+    const result = await client.callTool({ name: toolName, arguments: args }, undefined, signal ? { signal } : undefined);
+    const content = sanitizeContent(result.content);
+
+    if (result.isError && content.length > 0) {
+      const text = content.map((block) => block.text).join("\n");
+      throw new Error(`Exa request failed: ${text}`);
+    }
+
+    if (result.isError) throw new Error(`Exa request failed: no content returned.`);
+    if (content.length === 0) throw new Error(`No content returned.`);
+
+    return content;
+  }
+
+  async close(): Promise<void> {
+    const current = this.client;
+    this.client = undefined;
+    this.connecting = undefined;
+    await current?.close().catch(() => {});
+  }
+
+  private getClient(): Promise<Client> {
+    if (this.client) return Promise.resolve(this.client);
+
+    if (!this.connecting) {
+      this.connecting = (async () => {
+        const next = new Client({ name: "pi-spark", version: "0" });
+        const transport = new StreamableHTTPClientTransport(new URL(EXA_MCP_URL));
+        await next.connect(transport as Parameters<Client["connect"]>[0]);
+        this.client = next;
+        return next;
+      })().catch((error) => {
+        this.connecting = undefined;
+        throw error;
+      });
+    }
+
+    return this.connecting;
+  }
+}

package/src/features/web/config.ts

@@ -0,0 +1,5 @@
+import * as z from "zod";
+
+export const webConfigSchema = z.object({});
+
+export type WebConfig = z.infer<typeof webConfigSchema>;

package/src/features/web/index.ts

@@ -0,0 +1,125 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { keyText } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+
+import { ExaClient } from "./client";
+import { loadConfig } from "../../config";
+import { joinTextContent } from "../../utils/format";
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const ACTIONS = {
+  search: { tool: "web_search_exa", fields: ["query", "numResults"] as const },
+  fetch: { tool: "web_fetch_exa", fields: ["urls", "maxCharacters"] as const },
+} as const;
+
+const COLLAPSED_MAX_LINES = 10;
+
+export function registerWeb(pi: ExtensionAPI): void {
+  const exa = new ExaClient();
+
+  pi.on("session_start", (_event, ctx) => {
+    const config = loadConfig(ctx).web;
+    if (!config) return;
+
+    pi.registerTool({
+      name: "web",
+      label: "web",
+      description:
+        "Access the live web via Exa: \"search\" finds current information across the web and " +
+        "returns clean, ready-to-use content; \"fetch\" reads the full content of known URLs " +
+        "as clean markdown.",
+      promptSnippet: "Search the web and fetch page content via Exa",
+      promptGuidelines: [
+        "Use the web tool's \"search\" action for current information, news, facts, people, or companies; describe the ideal page rather than keywords (e.g., \"blog post comparing React and Vue performance\").",
+        "Use the web tool's \"fetch\" action to read full content from known URLs, batching multiple URLs in one call, especially when search highlights are insufficient.",
+      ],
+      parameters: Type.Object({
+        action: StringEnum(["search", "fetch"], {
+          description: "The web action to run.",
+        }),
+        query: Type.Optional(Type.String({
+          description:
+            "For \"search\": the search query. Use a semantically rich description of the ideal " +
+            "page, not just keywords. Optionally include category:<type> (company, people) to " +
+            "focus results."
+        })),
+        numResults: Type.Optional(Type.Number({
+          description: "For \"search\": number of search results (default 10).",
+        })),
+        urls: Type.Optional(Type.Array(Type.String(), {
+          description: "For \"fetch\": URLs to read. Batch multiple URLs in one call.",
+        })),
+        maxCharacters: Type.Optional(Type.Number({
+          description: "For \"fetch\": maximum characters to extract per page (default 3000).",
+        })),
+      }),
+      renderCall(args, theme) {
+        let text = `${theme.bold(theme.fg("toolTitle", "web"))} ${theme.fg("success", args.action)}`;
+
+        if (args.action === "search") {
+          const query = args.query?.trim();
+          if (query) text += ` ${theme.fg("muted", query)}`;
+          if (args.numResults !== undefined) text += ` ${theme.fg("warning", `${args.numResults} results`)}`;
+        } else if (args.action === "fetch") {
+          if (args.urls && args.urls.length > 0) text += ` ${theme.fg("muted", `${args.urls.join(", ")}`)}`;
+          if (args.maxCharacters !== undefined) text += ` ${theme.fg("warning", `<= ${args.maxCharacters} chars`)}`;
+        }
+
+        return new Text(text, 0, 0);
+      },
+      renderResult(result, { expanded }, theme, context) {
+        const container = new Container();
+        container.addChild(new Spacer(1));
+
+        const text = joinTextContent(result.content);
+
+        if (context.isError) {
+          container.addChild(new Text(theme.fg("error", text || "Web request failed."), 0, 0));
+          return container;
+        }
+
+        const lines = text.length > 0 ? text.split("\n") : [];
+        if (lines.length === 0) {
+          container.addChild(new Text(theme.fg("muted", "(no content returned)"), 0, 0));
+          return container;
+        }
+
+        const maxLines = expanded ? lines.length : Math.min(lines.length, COLLAPSED_MAX_LINES);
+        container.addChild(new Text(theme.fg("muted", lines.slice(0, maxLines).join("\n")), 0, 0));
+
+        const hidden = lines.length - maxLines;
+        if (hidden > 0) {
+          container.addChild(new Text(theme.fg("dim", `... (${hidden} more lines, ${keyText("app.tools.expand")} to expand)`), 0, 0));
+        }
+
+        return container;
+      },
+      async execute(_toolCallId, params, signal) {
+        const action = ACTIONS[params.action as keyof typeof ACTIONS];
+        if (!action) throw new Error(`Unknown web action "${params.action}".`);
+
+        if (params.action === "search" && !params.query?.trim()) {
+          throw new Error("The \"search\" action requires a non-empty \"query\".");
+        }
+        if (params.action === "fetch" && !(params.urls && params.urls.length > 0)) {
+          throw new Error("The \"fetch\" action requires a non-empty \"urls\" array.");
+        }
+
+        const args: Record<string, unknown> = {};
+        for (const field of action.fields) {
+          const value = (params as Record<string, unknown>)[field];
+          if (value !== undefined) args[field] = value;
+        }
+
+        const content = await exa.call(action.tool, args, signal);
+        return { content, details: { action: params.action } };
+      },
+    });
+  });
+
+  pi.on("session_shutdown", () => {
+    exa.close();
+  });
+}

package/src/utils/format.ts

@@ -1,10 +1,10 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 
-import type { Provider } from "@earendil-works/pi-ai";
+import type { ImageContent, Provider, TextContent } from "@earendil-works/pi-ai";
 import type { ContextUsage } from "@earendil-works/pi-coding-agent";
 
 export function formatModel(provider?: Provider, model?: string, thinkingLevel?: string): string {
-  return provider && model ? `${provider}/${model}${thinkingLevel ? `:${thinkingLevel}` : ""}` : "no-model";
+  return provider && model ? `${provider}/${model}${thinkingLevel ? `:${thinkingLevel}` : ""}` : "(no-model)";
 }
 
 export function formatTokens(count: number): string {
@@ -62,6 +62,14 @@ export function sanitizeText(text: string): string {
     .trim();
 }
 
+/** Join the text blocks of tool result content into a single newline-separated string. */
+export function joinTextContent(content: (TextContent | ImageContent)[]): string {
+  return content
+    .filter((block) => block.type === "text")
+    .map((block) => block.text)
+    .join("\n");
+}
+
 /** Coerce a possibly-stringified numeric value to a finite number, or `undefined`. */
 export function toNumber(value?: string | number | null): number | undefined {
   if (value === undefined || value === null) return undefined;

package/src/features/model/config.ts

@@ -1,3 +0,0 @@
-import * as z from "zod";
-
-export const modelConfigSchema = z.object({});

package/src/features/model/index.ts

@@ -1,268 +0,0 @@
-import { clampThinkingLevel, getSupportedThinkingLevels, StringEnum } from "@earendil-works/pi-ai";
-import { keyText, truncateHead } from "@earendil-works/pi-coding-agent";
-import { Container, Spacer, Text } from "@earendil-works/pi-tui";
-import { filter, parse } from "liqe";
-import { Type } from "typebox";
-
-import { loadConfig } from "../../config";
-import { formatModel, formatTokens } from "../../utils/format";
-
-import type { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, TruncationResult } from "@earendil-works/pi-coding-agent";
-
-/** Pi's built-in default thinking level, clamped per model. Not exported by pi's public API. */
-const DEFAULT_THINKING_LEVEL: ModelThinkingLevel = "medium";
-
-/** Maximum number of models returned per list call; byte size is unrestricted. */
-const LIST_MAX_LINES = 200;
-
-/** Maximum number of model rows shown when the result is collapsed. */
-const COLLAPSED_MAX_ROWS = 10;
-
-type ModelMetadata = Omit<Model<Api>, "headers" | "compat"> & {
-  thinkingLevels: ModelThinkingLevel[];
-  defaultThinkingLevel: ModelThinkingLevel;
-  available: boolean;
-};
-
-type ModelToolDetails =
-  | { action: "active"; active: { model: ModelMetadata; thinkingLevel: ModelThinkingLevel } }
-  | { action: "list"; models: ModelMetadata[]; total: number; truncation?: TruncationResult }
-
-/** One display row of model metadata: label, cost per 1M tokens, and context window. */
-type ModelRow = {
-  label: string;
-  cost: string;
-  context: string;
-  available: boolean;
-};
-
-function toMetadata(model: Model<Api>, available: boolean): ModelMetadata {
-  const { headers: _headers, compat: _compat, ...metadata } = model;
-
-  return {
-    ...metadata,
-    thinkingLevels: getSupportedThinkingLevels(model),
-    defaultThinkingLevel: clampThinkingLevel(model, DEFAULT_THINKING_LEVEL),
-    available,
-  };
-}
-
-function toModelRow(model: ModelMetadata, thinkingLevel?: ModelThinkingLevel): ModelRow {
-  return {
-    label: formatModel(model.provider, model.id, thinkingLevel),
-    cost: `$${formatPrice(model.cost.input)}/$${formatPrice(model.cost.output)}`,
-    context: formatTokens(model.contextWindow),
-    available: model.available,
-  };
-}
-
-/** Round to at most 2 decimals and trim float noise: 0.7999... -> 0.8, 0.0983 -> 0.1, 15 -> 15. */
-function formatPrice(value: number): string {
-  return String(parseFloat(value.toFixed(2)));
-}
-
-/** Notice line describing truncation or remaining pages, shared by the text result and the TUI. */
-function formatListNotice(truncated: boolean, startIndex: number, endDisplay: number, total: number): string | undefined {
-  const nextOffset = endDisplay + 1;
-
-  if (truncated) return `[Truncated: showing models ${startIndex + 1}-${endDisplay} of ${total}. Use offset=${nextOffset} to continue.]`;
-  if (endDisplay < total) return `[${total - endDisplay} more models in list. Use offset=${nextOffset} to continue.]`;
-
-  return undefined;
-}
-
-export function registerModel(pi: ExtensionAPI): void {
-  pi.on("session_start", (_event, ctx) => {
-    const config = loadConfig(ctx).model;
-    if (!config) return;
-
-    pi.registerTool({
-      name: "model",
-      label: "model",
-      description:
-        "Show the active model or list pi models. \"active\" returns the active model with " +
-        "metadata and thinking level. \"list\" returns models with metadata such as provider, id, name, " +
-        "API type, reasoning support, cost, context window, thinking levels, and availability, " +
-        "filterable with a Liqe (Lucene-like) query and paged with offset/limit. List output is " +
-        `one JSON object per line, truncated to ${LIST_MAX_LINES} models.`,
-      promptSnippet: "Show the active model or list pi models",
-      promptGuidelines: [
-        "Use the model tool when you need pi model metadata, the active model, or the thinking level, rather than guessing.",
-        "Use the model tool with `available:true` in the query unless unavailable models are explicitly needed.",
-      ],
-      parameters: Type.Object({
-        action: StringEnum(["active", "list"] as const, {
-          description: "\"active\" shows the active model; \"list\" lists the model catalog.",
-        }),
-        query: Type.Optional(Type.String({
-          description:
-            "For list: filter models with a Liqe (Lucene-like) query. Bare terms match any " +
-            "field, and unquoted terms are case-insensitive substrings. The syntax supports " +
-            "AND/OR/NOT, grouping, wildcards, and numeric comparisons; quote values containing " +
-            "special characters (e.g., id:\"deepseek/deepseek-v4\"). Queryable fields are id, " +
-            "name, provider, api, reasoning (boolean), input (modalities), cost.input and " +
-            "cost.output (USD per 1M tokens), contextWindow, maxTokens, thinkingLevels, and " +
-            "available (boolean, true when auth is configured). The catalog is large, so " +
-            "include available:true unless every model is needed (e.g., \"claude " +
-            "available:true\", \"provider:openrouter cost.input:<1\").",
-        })),
-        offset: Type.Optional(Type.Number({
-          description: "For list: start from this model number (1-indexed)."
-        })),
-        limit: Type.Optional(Type.Number({
-          description: "For list: return at most this many models."
-        })),
-      }),
-      renderCall(args, theme) {
-        let text = `${theme.bold(theme.fg("toolTitle", "model"))} ${theme.fg("accent", args.action)}`;
-
-        if (args.action === "list") {
-          const query = args.query?.trim();
-          if (query) text += theme.fg("muted", ` ${query}`);
-
-          if (args.offset !== undefined || args.limit !== undefined) {
-            const start = args.offset ?? 1;
-            const end = args.limit !== undefined ? start + args.limit - 1 : "end";
-            text += theme.fg("warning", ` ${start}-${end}`);
-          }
-        }
-
-        return new Text(text, 0, 0);
-      },
-      renderResult(result, { expanded }, theme, context) {
-        const details = result.details as ModelToolDetails | undefined;
-
-        const container = new Container();
-        container.addChild(new Spacer(1));
-
-        if (context.isError || !details) {
-          const output = result.content
-            .filter((content) => content.type === "text")
-            .map((content) => content.text)
-            .join("\n");
-          container.addChild(new Text(theme.fg("error", output), 0, 0));
-
-          return container;
-        }
-
-        const addRows = (rows: ModelRow[]) => {
-          const widths = {
-            label: Math.max(...rows.map((row) => row.label.length)),
-            cost: Math.max(...rows.map((row) => row.cost.length)),
-            context: Math.max(...rows.map((row) => row.context.length)),
-          };
-
-          for (const row of rows) {
-            const cells = [
-              row.label.padEnd(widths.label),
-              row.cost.padStart(widths.cost),
-              row.context.padStart(widths.context),
-            ].join("  ");
-            const noAuthHint = row.available ? "" : theme.fg("dim", "  (no auth)");
-            container.addChild(new Text(theme.fg("muted", cells) + noAuthHint, 0, 0));
-          }
-        };
-
-        if (details.action === "active") {
-          const { model, thinkingLevel } = details.active;
-          addRows([toModelRow(model, thinkingLevel)]);
-
-          return container;
-        }
-
-        const filtered = Boolean(context.args.query?.trim());
-        const models = details.models ?? [];
-        const total = details.total ?? models.length;
-
-        if (models.length > 0) {
-          const maxRows = expanded ? models.length : Math.min(models.length, COLLAPSED_MAX_ROWS);
-          addRows(models.slice(0, maxRows).map((model) => toModelRow(model)));
-
-          const hiddenRows = models.length - maxRows;
-          if (hiddenRows > 0) container.addChild(new Text(theme.fg("dim", `... (${hiddenRows} more, ${keyText("app.tools.expand")} to expand)`), 0, 0));
-          container.addChild(new Spacer(1));
-        }
-
-        if (details.truncation?.truncated) {
-          const startIndex = context.args.offset ? Math.max(0, context.args.offset - 1) : 0;
-          const endDisplay = startIndex + models.length;
-          const notice = formatListNotice(true, startIndex, endDisplay, total);
-          if (notice) {
-            container.addChild(new Text(theme.fg("warning", notice), 0, 0));
-            container.addChild(new Spacer(1));
-          }
-        }
-
-        const summary = `${models.length !== total ? `${models.length} of ` : ""}${total} ${filtered ? "matched " : ""}model${total === 1 ? "" : "s"} listed.`;
-        container.addChild(new Text(theme.fg("muted", total > 0 ? summary : `No models ${filtered ? "matched" : "found"}.`), 0, 0));
-
-        return container;
-      },
-      async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-        if (params.action === "active") {
-          const model = ctx.model;
-          if (!model) throw new Error("No model is active.");
-
-          const thinkingLevel = pi.getThinkingLevel();
-          const active = { model: toMetadata(model, true), thinkingLevel };
-
-          return {
-            content: [{ type: "text", text: JSON.stringify(active) }],
-            details: { action: "active", active } satisfies ModelToolDetails,
-          };
-        }
-
-        const queryText = params.query?.trim();
-        const filtered = Boolean(queryText);
-
-        let listQuery = null;
-        if (queryText) {
-          try {
-            listQuery = parse(queryText);
-          } catch (error) {
-            throw new Error(`Invalid Liqe query ${JSON.stringify(queryText)}: ${error instanceof Error ? error.message : String(error)}`);
-          }
-        }
-
-        const models = ctx.modelRegistry.getAll().map((model) => toMetadata(model, ctx.modelRegistry.hasConfiguredAuth(model)));
-        const matched = listQuery ? filter(listQuery, models) : models;
-        const total = matched.length;
-
-        if (total === 0) {
-          return {
-            content: [{ type: "text", text: `No models ${filtered ? "matched" : "found"}.` }],
-            details: { action: "list", models: [], total } satisfies ModelToolDetails,
-          };
-        }
-
-        // Convert from 1-indexed offset to 0-indexed array access.
-        const startIndex = params.offset ? Math.max(0, params.offset - 1) : 0;
-        if (startIndex >= total) {
-          throw new Error(`Offset ${params.offset} is beyond the end of the list (${total} models total).`);
-        }
-
-        const endIndex = params.limit !== undefined ? Math.min(startIndex + params.limit, total) : total;
-        const selected = matched.slice(startIndex, endIndex);
-
-        // JSONL: one compact object per line, so truncation cuts at record boundaries.
-        const truncation = truncateHead(selected.map((model) => JSON.stringify(model)).join("\n"), {
-          maxLines: LIST_MAX_LINES,
-          maxBytes: Infinity,
-        });
-
-        const delivered = truncation.truncated ? selected.slice(0, truncation.outputLines) : selected;
-        const endDisplay = startIndex + delivered.length;
-
-        let text = truncation.content;
-        const notice = formatListNotice(truncation.truncated, startIndex, endDisplay, total);
-        if (notice) text += `\n\n${notice}`;
-
-        return {
-          content: [{ type: "text", text }],
-          details: { action: "list", models: delivered, total, truncation } satisfies ModelToolDetails,
-        };
-      },
-    });
-  });
-}

package/src/features/name/config.ts

@@ -1,3 +0,0 @@
-import * as z from "zod";
-
-export const nameConfigSchema = z.object({});

package/src/features/name/index.ts

@@ -1,86 +0,0 @@
-import { Container, Spacer, Text } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
-
-import { loadConfig } from "../../config";
-import { sanitizeText } from "../../utils/format";
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-export function registerName(pi: ExtensionAPI): void {
-  pi.on("session_start", (_event, ctx) => {
-    const config = loadConfig(ctx).name;
-    if (!config) return;
-
-    pi.registerTool({
-      name: "name",
-      label: "name",
-      description:
-        "Set or update the current session's name. The name is a concise label shown in the session " +
-        "selector instead of the first-message preview.",
-      promptSnippet: "Set or update the current session's name",
-      promptGuidelines: [
-        "Use the name tool when the session needs a concise, recognizable label, especially after a long, vague, or pasted opening prompt.",
-        "Use the name tool to rename the session only after a substantial shift in the conversation's focus, not for minor follow-ups.",
-        "Use the name tool with a reason when it helps explain why the name identifies the session.",
-      ],
-      parameters: Type.Object({
-        name: Type.String({
-          minLength: 1,
-          maxLength: 120,
-          description:
-            "Use a short, recognizable phrase in sentence case, ideally <= 72 characters " +
-            "(e.g., \"Refactor auth module\", \"Debug flaky CI pipeline\"). Do not use " +
-            "surrounding quotes, trailing punctuation, or generic prefixes like \"Chat about\".",
-        }),
-        reason: Type.Optional(Type.String({
-          maxLength: 240,
-          description:
-            "Explain briefly why the session was named or renamed, such as a long pasted " +
-            "prompt, an ambiguous first message, or a topic shift. Write one user-facing " +
-            "sentence (e.g., \"The focus shifted from debugging to README updates.\").",
-        })),
-      }),
-      renderCall(args, theme) {
-        const name = sanitizeText(args.name);
-        const reason = sanitizeText(args.reason ?? "");
-
-        const container = new Container();
-        container.addChild(new Text(`${theme.bold(theme.fg("toolTitle", "name"))} ${theme.fg("accent", name)}`, 0, 0));
-
-        if (reason) {
-          container.addChild(new Spacer(1));
-          container.addChild(new Text(theme.fg("muted", reason), 0, 0));
-        }
-
-        return container;
-      },
-      renderResult(result, _options, theme, context) {
-        const output = result.content
-          .filter((content) => content.type === "text")
-          .map((content) => content.text)
-          .join("\n");
-
-        return new Text(context.isError ? theme.fg("error", "\n" + output) : "", 0, 0);
-      },
-      async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-        const name = sanitizeText(params.name);
-        if (!name) throw new Error("Session name was empty after normalization; provide a short, non-empty phrase.");
-
-        const previous = pi.getSessionName() ?? null;
-        if (previous === name) {
-          return {
-            content: [{ type: "text", text: `Session is already named "${name}". Nothing changed.` }],
-            details: { changed: false, previous },
-          };
-        }
-
-        pi.setSessionName(name);
-
-        return {
-          content: [{ type: "text", text: `${previous ? `Renamed session from "${previous}" to "${name}".` : `Named session "${name}".`}` }],
-          details: { changed: true, previous },
-        };
-      },
-    });
-  });
-}