pi-spark 0.14.7 → 0.15.0

package/README.md

@@ -2,7 +2,7 @@
 
 # pi-spark
 
-[Pi](https://pi.dev/) package that polishes your daily experience and keeps you at the frontier of agentic workflows.
+[Pi](https://pi.dev/) package that polishes your daily experience.
 
 ![Overview](./assets/screenshot-overview.png)
 
@@ -61,23 +61,6 @@ pi-spark generates a short recap of the current session after it goes idle, or o
 
 ![Recap](./assets/screenshot-recap.png)
 
-### Agent tools: `pi` and `web`
-
-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.
-- `whoami` shows the current pi state, including session name, active model, 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 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
 
 pi-spark reads config from `~/.pi/agent/spark.json` and from the current project's `.pi/spark.json`. Project config overrides matching global fields.
@@ -121,10 +104,8 @@ 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. |
-| `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`
 

package/index.ts

@@ -3,10 +3,8 @@ 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 { 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 +22,6 @@ export default function (pi: ExtensionAPI) {
   registerEditor(pi, events);
   registerFooter(pi);
   registerFullscreen(pi);
-  registerPi(pi);
   registerPresets(pi);
   registerRecap(pi);
-  registerWeb(pi);
 }

package/package.json

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

package/src/config/index.ts

@@ -1,15 +1,13 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { defu } from "defu";
 
 import { featureSchemas } from "./schema";
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { SparkConfig } from "./schema";
 
-type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
-type JsonObject = { [key: string]: JsonValue };
-
 const cache = new Map<string, SparkConfig>();
 
 /** Load and validate spark.json once per session lifecycle; later calls return the cached result. */
@@ -18,8 +16,10 @@ export function loadConfig(ctx: ExtensionContext, fileName: string = "spark.json
   const cached = cache.get(key);
   if (cached) return cached;
 
-  const rawValue = loadMergedJson(getConfigPaths(ctx.cwd, fileName)) ?? {};
-  const raw = isPlainObject(rawValue) ? rawValue : {};
+  // Deep-merge the global file under the project file, so project settings win at scalar
+  // leaves while deep objects (e.g., `recap.model`) combine across both.
+  const [globalPath, projectPath] = getConfigPaths(ctx.cwd, fileName);
+  const raw = defu(readRawConfig(projectPath) ?? {}, readRawConfig(globalPath) ?? {});
 
   // Validate each feature independently so a single invalid field disables only that feature
   // (falling back to its enabled defaults) instead of taking down the whole config.
@@ -46,12 +46,11 @@ export function loadConfig(ctx: ExtensionContext, fileName: string = "spark.json
     }
 
     config[field] = {};
-    const detail = result.error.issues.map((issue) => `${[field, ...issue.path].join(".")}: ${issue.message}`).join("; ");
-    errors.push(detail);
+    errors.push(result.error.issues.map((issue) => `${[field, ...issue.path].join(".")}: ${issue.message}`).join("; "));
   }
 
   if (errors.length > 0) {
-    ctx.ui.notify(`Invalid spark config, using defaults for: ${errors.join("; ")}`, "error");
+    ctx.ui.notify(`Invalid pi-spark config: ${errors.join("; ")}`, "error");
   }
 
   cache.set(key, config as SparkConfig);
@@ -59,46 +58,13 @@ export function loadConfig(ctx: ExtensionContext, fileName: string = "spark.json
 }
 
 function getConfigPaths(cwd: string, fileName: string): [globalPath: string, projectPath: string] {
-  return [join(getAgentDir(), fileName), join(cwd, ".pi", fileName)];
-}
-
-function loadMergedJson(paths: string[]): JsonObject | undefined {
-  let merged: JsonObject | undefined;
-  paths.forEach((path) => {
-    const value = readJsonFile(path);
-    if (value === undefined) return;
-
-    merged = mergeConfig(merged, value);
-  });
-
-  return merged;
+  return [join(getAgentDir(), fileName), join(cwd, CONFIG_DIR_NAME, fileName)];
 }
 
-function readJsonFile(path: string): JsonObject | undefined {
+function readRawConfig(path: string): Record<string, unknown> | undefined {
   try {
-    return JSON.parse(readFileSync(path, "utf8")) as JsonObject;
+    return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
   } catch {
     return undefined;
   }
 }
-
-function mergeConfig(base: JsonObject | undefined, override: JsonObject): JsonObject {
-  if (base === undefined) return override;
-  if (!isPlainObject(base) || !isPlainObject(override)) return override;
-
-  const result: Record<string, JsonValue> = { ...base };
-  Object.entries(override).forEach(([key, overrideValue]) => {
-    const baseValue = base[key];
-    if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
-      result[key] = { ...baseValue, ...overrideValue };
-    } else {
-      result[key] = overrideValue;
-    }
-  });
-
-  return result;
-}
-
-function isPlainObject(value: unknown): value is Record<string, JsonValue> {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}

package/src/config/schema.ts

@@ -4,10 +4,8 @@ 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 { piConfigSchema } from "../features/pi/config";
 import { presetsConfigSchema } from "../features/presets/config";
 import { recapConfigSchema } from "../features/recap/config";
-import { webConfigSchema } from "../features/web/config";
 
 /**
  * Raw option shape for each feature. The enable/disable/default policy lives in `loadConfig`:
@@ -19,10 +17,8 @@ export const featureSchemas = {
   editor: editorConfigSchema,
   footer: footerConfigSchema,
   fullscreen: fullscreenConfigSchema,
-  pi: piConfigSchema,
   presets: presetsConfigSchema,
   recap: recapConfigSchema,
-  web: webConfigSchema,
 } as const;
 
 /** Resolved config for every feature; `false` means the feature is disabled. */

package/src/features/credits/providers/moonshot.ts

@@ -10,7 +10,7 @@ interface MoonshotBalanceResponse {
 
 /**
  * For Moonshot, the international and China-mainland accounts live on separate hosts and bill in
- * different currencies (USD vs CNY), which the endpoint does not report, so each pi provider ID
+ * different currencies (USD vs CNY), which the endpoint does not report, so each Pi provider ID
  * fixes both host and currency.
  */
 function createMoonshotProvider(id: string, host: string, currency: string): CreditsProvider {

package/src/features/credits/status.ts

@@ -14,7 +14,7 @@ export function renderCredits(theme: Theme, label: string, credits: Credits): st
 }
 
 export function renderError(theme: Theme, label: string, message: string): string {
-  return theme.fg("error", `${label} credits unavailable: ${message}`);
+  return theme.fg("error", `${label} ${message}`);
 }
 
 function renderWindows(theme: Theme, credits: Extract<Credits, { type: "windows" }>): string {

package/src/features/credits/types.ts

@@ -16,7 +16,7 @@ export interface CreditsLane {
   percent: number | undefined;
 }
 
-/** A credits source for a pi provider, shown in the status line while that provider is active. */
+/** A credits source for a Pi provider, shown in the status line while that provider is active. */
 export interface CreditsProvider {
   readonly id: Provider;
   readonly label: string;

package/src/features/footer/index.ts

@@ -5,6 +5,7 @@ import { pathToFileURL } from "node:url";
 import { SplitLine } from "../../components/split-line";
 import { loadConfig } from "../../config";
 import { formatContextUsage, formatCost, formatCwd, linkText, sanitizeText } from "../../utils/format";
+import { isFreeModel } from "../../utils/model";
 import { getEntryUsage } from "../../utils/usage";
 
 import type { ExtensionContext, ExtensionAPI, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
@@ -63,6 +64,10 @@ class FooterComponent implements Component {
 
   private getStyledCostText(): string {
     const totalCost = this.ctx.sessionManager.getBranch().reduce((acc, entry) => acc + (getEntryUsage(entry)?.cost.total ?? 0), 0);
+
+    // Hide cost when it's zero and the current model is free.
+    if (totalCost === 0 && this.ctx.model && isFreeModel(this.ctx.model)) return "";
+
     const costText = formatCost(totalCost);
 
     if (totalCost > 20) return this.theme.fg("warning", costText);

package/src/features/fullscreen/filler.ts

@@ -22,7 +22,7 @@ export class BottomFiller implements Component {
     this.measuring = true;
 
     // Re-assert `clearOnShrink` every render pass; the TUI reads it after `render()` returns,
-    // so this wins deterministically over pi's reset to the settings value on startup/reload.
+    // so this wins deterministically over Pi's reset to the settings value on startup/reload.
     this.tui.setClearOnShrink(true);
 
     const rows = this.tui.terminal.rows;

package/src/features/presets/manager.ts

@@ -95,7 +95,7 @@ export class PresetManager {
     if (!preset) return;
 
     return this.keys.find((key) => {
-      const p = this.presets[key]!;
+      const p = this.presets[key];
 
       return p.provider === preset.provider && p.model === preset.model && p.thinkingLevel === preset.thinkingLevel;
     });

package/src/utils/format.ts

@@ -1,6 +1,6 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 
-import type { ImageContent, Provider, TextContent } from "@earendil-works/pi-ai";
+import type { Provider } from "@earendil-works/pi-ai";
 import type { ContextUsage } from "@earendil-works/pi-coding-agent";
 
 export function formatModel(provider?: Provider, model?: string, thinkingLevel?: string): string {
@@ -28,11 +28,6 @@ export function formatCost(cost: number): string {
   return `$${cost.toFixed(2)}`;
 }
 
-/** Format a duration in ms as `1.2s`, like the built-in bash tool. */
-export function formatDuration(ms: number): string {
-  return `${(ms / 1000).toFixed(1)}s`;
-}
-
 export function formatCwd(cwd: string, home: string): string {
   const resolvedCwd = resolve(cwd);
   const resolvedHome = resolve(home);
@@ -67,14 +62,6 @@ 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/utils/model.ts

@@ -0,0 +1,6 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+
+/** Check if a model has zero costs for all categories. */
+export function isFreeModel(model: Model<Api>): boolean {
+  return model.cost.input === 0 && model.cost.output === 0 && model.cost.cacheRead === 0 && model.cost.cacheWrite === 0;
+}

package/src/utils/usage.ts

@@ -1,7 +1,7 @@
 import type { Usage } from "@earendil-works/pi-ai";
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 
-/** Structural type guard for the pi `Usage` shape. */
+/** Structural type guard for the Pi `Usage` shape. */
 export function isUsage(value: unknown): value is Usage {
   if (typeof value !== "object" || value === null) return false;
 

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

@@ -1,165 +0,0 @@
-import { keyHint, 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). Examples: \"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.",
-  ],
-  renderParams(args, theme) {
-    const params: string[] = [];
-
-    const query = args.query?.trim();
-    if (query) params.push(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";
-      params.push(theme.fg("warning", `${start}-${end}`));
-    }
-
-    return params;
-  },
-  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, `) + keyHint("app.tools.expand", "to expand") + theme.fg("dim", ")"), 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

@@ -1,58 +0,0 @@
-import { 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\".",
-    }),
-  },
-  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.",
-  ],
-  renderParams(args, theme) {
-    return [theme.fg("muted", sanitizeText(args.name ?? ""))];
-  },
-  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

@@ -1,61 +0,0 @@
-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, including session name, active model, 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 formatLine = (label: string, value: string) => `${label.padEnd(7)}  ${value}`;
-
-    if (details.sessionName) {
-      container.addChild(new Text(theme.fg("muted", formatLine("session", details.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", formatLine("model", cells)), 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

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

package/src/features/pi/index.ts

@@ -1,23 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,28 +0,0 @@
-import { defineActionFor, registerComposedTool } from "../../utils/tool";
-
-import type { Action } from "../../utils/tool";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-
-interface PiActionContext {
-  pi: ExtensionAPI;
-  ctx: ExtensionContext;
-}
-
-export const defineAction = defineActionFor<PiActionContext>();
-
-export function registerPiTool(pi: ExtensionAPI, actions: Action<PiActionContext, any, any>[]): void {
-  registerComposedTool<PiActionContext>(pi, {
-    name: "pi",
-    label: "pi",
-    descriptionIntro:
-      "Inspect and adjust the current pi session and model state. This tool groups " +
-      "self-management actions over the running pi instance:",
-    descriptionOutro: "Use this tool to read or change pi's own state instead of guessing.",
-    promptSnippet: "Inspect and adjust the current pi session and model state",
-    generalGuidelines: [
-      "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.",
-    ],
-    actions,
-    createContext: (ctx) => ({ pi, ctx }),
-  });
-}

package/src/features/web/actions/fetch.ts

@@ -1,47 +0,0 @@
-import { Type } from "typebox";
-
-import { defineAction } from "../registry";
-import { renderWebResult } from "../render";
-
-interface FetchDetails {
-  action: "fetch";
-}
-
-export const fetchAction = defineAction({
-  name: "fetch",
-  summary: "reads the full content of known URLs as clean markdown",
-  showTiming: true,
-  fields: {
-    urls: Type.Optional(Type.Array(Type.String(), {
-      description: "For \"fetch\": List the URLs to read. Batch multiple URLs in one call.",
-    })),
-    maxCharacters: Type.Optional(Type.Number({
-      description: "For \"fetch\": Extract at most this many characters per page (default 3000).",
-    })),
-  },
-  promptGuidelines: [
-    "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.",
-  ],
-  renderParams(args, theme) {
-    const params: string[] = [];
-
-    if (args.urls && args.urls.length > 0) params.push(theme.fg("muted", args.urls.join(", ")));
-    if (args.maxCharacters !== undefined) params.push(theme.fg("warning", `<= ${args.maxCharacters} chars`));
-
-    return params;
-  },
-  renderResult(result, { expanded }, theme) {
-    return renderWebResult(result, expanded, theme);
-  },
-  async execute(args, { exa }, signal) {
-    if (!(args.urls && args.urls.length > 0)) {
-      throw new Error("The \"fetch\" action requires a non-empty \"urls\" array");
-    }
-
-    const requestArgs: Record<string, unknown> = { urls: args.urls };
-    if (args.maxCharacters !== undefined) requestArgs.maxCharacters = args.maxCharacters;
-
-    const content = await exa.call("web_fetch_exa", requestArgs, signal);
-    return { content, details: { action: "fetch" } satisfies FetchDetails };
-  },
-});

package/src/features/web/actions/search.ts

@@ -1,50 +0,0 @@
-import { Type } from "typebox";
-
-import { defineAction } from "../registry";
-import { renderWebResult } from "../render";
-
-interface SearchDetails {
-  action: "search";
-}
-
-export const searchAction = defineAction({
-  name: "search",
-  summary: "finds current information across the web and returns ready-to-use content",
-  showTiming: true,
-  fields: {
-    query: Type.Optional(Type.String({
-      description:
-        "For \"search\": Provide 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\": Return at most this many search results (default 10).",
-    })),
-  },
-  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\").",
-  ],
-  renderParams(args, theme) {
-    const params: string[] = [];
-
-    const query = args.query?.trim();
-    if (query) params.push(theme.fg("muted", query));
-    if (args.numResults !== undefined) params.push(theme.fg("warning", `${args.numResults} results`));
-
-    return params;
-  },
-  renderResult(result, { expanded }, theme) {
-    return renderWebResult(result, expanded, theme);
-  },
-  async execute(args, { exa }, signal) {
-    const query = args.query?.trim();
-    if (!query) throw new Error("The \"search\" action requires a non-empty \"query\"");
-
-    const requestArgs: Record<string, unknown> = { query };
-    if (args.numResults !== undefined) requestArgs.numResults = args.numResults;
-
-    const content = await exa.call("web_search_exa", requestArgs, signal);
-    return { content, details: { action: "search" } satisfies SearchDetails };
-  },
-});

package/src/features/web/client.ts

@@ -1,77 +0,0 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.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 () => {
-        // The MCP SDK is heavy to import (~40 ms cold); load it lazily so startup never pays for
-        // it unless a web action actually runs.
-        const [{ Client }, { StreamableHTTPClientTransport }] = await Promise.all([
-          import("@modelcontextprotocol/sdk/client/index.js"),
-          import("@modelcontextprotocol/sdk/client/streamableHttp.js"),
-        ]);
-
-        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

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

package/src/features/web/index.ts

@@ -1,28 +0,0 @@
-import { ExaClient } from "./client";
-import { fetchAction } from "./actions/fetch";
-import { searchAction } from "./actions/search";
-import { registerWebTool } from "./registry";
-import { loadConfig } from "../../config";
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-/** Web actions exposed by the web tool, ordered to match the description (search before fetch). */
-const ACTIONS = [
-  searchAction,
-  fetchAction,
-];
-
-export function registerWeb(pi: ExtensionAPI): void {
-  const exa = new ExaClient();
-
-  pi.on("session_start", (_event, ctx) => {
-    const config = loadConfig(ctx).web;
-    if (!config) return;
-
-    registerWebTool(pi, exa, ACTIONS);
-  });
-
-  pi.on("session_shutdown", () => {
-    exa.close();
-  });
-}

package/src/features/web/registry.ts

@@ -1,22 +0,0 @@
-import { defineActionFor, registerComposedTool } from "../../utils/tool";
-
-import type { ExaClient } from "./client";
-import type { Action } from "../../utils/tool";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-interface WebActionContext {
-  exa: ExaClient;
-}
-
-export const defineAction = defineActionFor<WebActionContext>();
-
-export function registerWebTool(pi: ExtensionAPI, exa: ExaClient, actions: Action<WebActionContext, any, any>[]): void {
-  registerComposedTool<WebActionContext>(pi, {
-    name: "web",
-    label: "web",
-    descriptionIntro: "Access the live web via Exa:",
-    promptSnippet: "Search the web and fetch page content via Exa",
-    actions,
-    createContext: () => ({ exa }),
-  });
-}

package/src/features/web/render.ts

@@ -1,34 +0,0 @@
-import { keyHint } from "@earendil-works/pi-coding-agent";
-import { Container, Spacer, Text } from "@earendil-works/pi-tui";
-
-import { joinTextContent } from "../../utils/format";
-
-import type { AgentToolResult, Theme } from "@earendil-works/pi-coding-agent";
-
-const COLLAPSED_MAX_LINES = 10;
-
-/**
- * Render a web result's text content with collapse-to-expand behavior. Shared by the `search` and
- * `fetch` actions, which both return plain text content. Errors are handled by the registry's
- * fallback renderer, so this only covers the success path.
- */
-export function renderWebResult(result: AgentToolResult<unknown>, expanded: boolean, theme: Theme): Container {
-  const container = new Container();
-  container.addChild(new Spacer(1));
-
-  const text = joinTextContent(result.content);
-  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, `) + keyHint("app.tools.expand", "to expand") + theme.fg("dim", ")"), 0, 0));
-
-  return container;
-}

package/src/utils/tool.ts

@@ -1,221 +0,0 @@
-import { StringEnum } from "@earendil-works/pi-ai";
-import { Container, Spacer, Text } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
-
-import { formatDuration, joinTextContent } from "./format";
-
-import type { AgentToolResult, AgentToolUpdateCallback, ExtensionAPI, ExtensionContext, Theme, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { Component } from "@earendil-works/pi-tui";
-import type { Static, TObject, TProperties, TSchema } from "typebox";
-
-interface ActionDetails {
-  action: string;
-}
-
-/**
- * One action of a composed tool. The registry merges all actions' `fields` into one flat schema
- * (provider-safe, unlike a discriminated union) and dispatches by `action`; `C` is the per-call
- * context from `createContext`.
- */
-export interface Action<C, F extends TProperties = TProperties, D extends ActionDetails = ActionDetails> {
-  name: D["action"];
-  summary: string;
-  fields: F;
-  /** Fields required at runtime (the flat schema makes all fields optional). */
-  required?: (keyof F & string)[];
-  promptGuidelines?: string[];
-  /** Show bash-style elapsed/took timing for this action. */
-  showTiming?: boolean;
-  /** Styled segments shown after the `<tool> <action>` prefix. */
-  renderParams?: (args: Static<TObject<F>>, theme: Theme) => string[];
-  /** Only handles successful output; error output is handled centrally. */
-  renderResult?: NonNullable<ToolDefinition<TObject<F>, D>["renderResult"]>;
-  execute(args: Static<TObject<F>>, context: C, signal: AbortSignal | undefined, onUpdate: AgentToolUpdateCallback<D> | undefined): Promise<AgentToolResult<D>>;
-}
-
-/** Identity helper bound to context `C`, so actions infer their field/details types while sharing one context shape. */
-export function defineActionFor<C>() {
-  return <F extends TProperties, D extends ActionDetails>(action: Action<C, F, D>): Action<C, F, D> => action;
-}
-
-interface ComposedToolConfig<C> {
-  name: string;
-  label: string;
-  descriptionIntro: string;
-  descriptionOutro?: string;
-  promptSnippet: string;
-  generalGuidelines?: string[];
-  actions: Action<C, any, any>[];
-  createContext(ctx: ExtensionContext): C;
-}
-
-export function registerComposedTool<C>(pi: ExtensionAPI, config: ComposedToolConfig<C>): void {
-  const byName = new Map<string, Action<C, any, any>>();
-  const mergedFields: TProperties = {};
-
-  for (const action of config.actions) {
-    if (byName.has(action.name)) throw new Error(`Duplicate "${config.name}" action "${action.name}"`);
-    byName.set(action.name, action);
-
-    for (const [key, schema] of Object.entries(action.fields)) {
-      if (key === "action") throw new Error(`"${config.name}" action "${action.name}" must not define a field named "action"`);
-      if (key in mergedFields) throw new Error(`"${config.name}" action "${action.name}" redefines field "${key}"; field names must be unique across actions`);
-      mergedFields[key] = Type.Optional(schema as TSchema);
-    }
-  }
-
-  const summaries = config.actions.map((action) => `"${action.name}" ${action.summary}`).join("; ");
-  const description = config.descriptionOutro
-    ? `${config.descriptionIntro} ${summaries}. ${config.descriptionOutro}`
-    : `${config.descriptionIntro} ${summaries}.`;
-
-  const parameters = Type.Object({
-    action: StringEnum(config.actions.map((action) => action.name), { description: `The ${config.name} action to run.` }),
-    ...mergedFields,
-  });
-
-  const activeTiming = new ActiveTiming();
-  const noTiming = new NoTiming();
-  const timingFor = (action: string | undefined): Timing => (byName.get(action ?? "")?.showTiming ? activeTiming : noTiming);
-
-  const renderActionResult: NonNullable<ToolDefinition["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 as never);
-
-    return new Text(joinTextContent(result.content), 0, 0);
-  };
-
-  pi.registerTool({
-    name: config.name,
-    label: config.label,
-    description,
-    promptSnippet: config.promptSnippet,
-    promptGuidelines: [...(config.generalGuidelines ?? []), ...config.actions.flatMap((action) => action.promptGuidelines ?? [])],
-    parameters,
-    renderCall(args, theme, context) {
-      const segments = [theme.bold(theme.fg("toolTitle", config.name)), theme.fg("accent", args.action)];
-      const params = byName.get(args.action)?.renderParams?.(args, theme);
-      if (params) segments.push(...params);
-
-      return timingFor(context.args.action).renderCall(new Text(segments.join(" "), 0, 0), theme, context);
-    },
-    renderResult(result, options, theme, context) {
-      const inner = renderActionResult(result, options, theme, context);
-
-      return timingFor(context.args.action).renderResult(inner, options, theme, context);
-    },
-    async execute(_toolCallId, params, signal, onUpdate, ctx) {
-      const action = byName.get(params.action);
-      if (!action) throw new Error(`Unknown ${config.name} 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 any, config.createContext(ctx), signal, onUpdate);
-    },
-  });
-}
-
-/** A tuple type without its first element. */
-type DropFirst<T extends readonly unknown[]> = T extends readonly [unknown, ...infer R] ? R : never;
-
-/** A renderer's params after the leading args/result. */
-type RenderCallTail = DropFirst<Parameters<NonNullable<ToolDefinition["renderCall"]>>>;
-type RenderResultTail = DropFirst<Parameters<NonNullable<ToolDefinition["renderResult"]>>>;
-
-/**
- * Bash-style timing for a tool row: a live "Elapsed" ticker while running, a final "Took" once
- * settled. `renderCall`/`renderResult` wrap the built component in place of the args/result.
- */
-interface Timing {
-  renderCall(inner: Component, ...rest: RenderCallTail): Component;
-  renderResult(inner: Component, ...rest: RenderResultTail): Component;
-}
-
-/** Per-row timing state, kept in `ToolRenderContext.state` so the timing classes stay stateless. */
-interface TimingState {
-  startedAt?: number;
-  endedAt?: number;
-  interval?: ReturnType<typeof setInterval>;
-  hasResult?: boolean;
-}
-
-class ActiveTiming implements Timing {
-  // No result yet: `renderCall` owns the live "Elapsed" ticker.
-  renderCall(inner: Component, ...[theme, context]: RenderCallTail): Component {
-    const state = context.state as TimingState;
-
-    if (context.executionStarted && state.startedAt === undefined) {
-      state.startedAt = Date.now();
-      delete state.endedAt;
-      delete state.hasResult;
-    }
-
-    // Not started, or final (`renderResult` owns the "Took" line): render nothing here.
-    if (state.startedAt === undefined || !context.isPartial) return inner;
-
-    state.interval ??= setInterval(() => context.invalidate(), 1000);
-
-    // `renderResult` runs later in the same render pass, so decide visibility at render time:
-    // hide once any result has arrived.
-    return this.withTimingLine(inner, "Elapsed", Date.now() - state.startedAt, theme, () => !state.hasResult);
-  }
-
-  // A result exists: `renderResult` owns the line — "Elapsed" while streaming, "Took" once final.
-  renderResult(inner: Component, ...[options, theme, context]: RenderResultTail): Component {
-    const state = context.state as TimingState;
-    state.hasResult = true;
-
-    const isRunning = options.isPartial && !context.isError;
-    if (!isRunning) this.settle(state);
-    if (state.startedAt === undefined) return inner;
-
-    const endTime = state.endedAt ?? Date.now();
-    return this.withTimingLine(inner, isRunning ? "Elapsed" : "Took", endTime - state.startedAt, theme);
-  }
-
-  private settle(state: TimingState): void {
-    if (state.startedAt !== undefined) {
-      state.endedAt ??= Date.now();
-    }
-
-    if (state.interval) {
-      clearInterval(state.interval);
-      delete state.interval;
-    }
-  }
-
-  private withTimingLine(content: Component, label: string, ms: number, theme: Theme, visible?: () => boolean): Component {
-    const container = new Container();
-    container.addChild(content);
-
-    container.addChild(new Spacer(1));
-    container.addChild(new Text(theme.fg("muted", `${label} ${formatDuration(ms)}`), 0, 0));
-
-    if (!visible) return container;
-
-    return {
-      invalidate: () => container.invalidate(),
-      render: (width) => (visible() ? container.render(width) : content.render(width)),
-    };
-  }
-}
-
-class NoTiming implements Timing {
-  renderCall(inner: Component): Component {
-    return inner;
-  }
-  renderResult(inner: Component): Component {
-    return inner;
-  }
-}