one-code-extension 0.1.0

package/extensions/tasks/store.ts

@@ -0,0 +1,174 @@
+/**
+ * Stateful task list (pure) — Claude Code's TaskCreate/TaskGet/TaskList/TaskUpdate.
+ *
+ * Unlike todo_write's whole-list replacement, tasks are individually addressable
+ * by id and carry owners, arbitrary metadata, and dependency links. `blocks` and
+ * `blockedBy` are kept reciprocal: adding one side always records the other.
+ */
+
+export type TaskStatus = "pending" | "in_progress" | "completed";
+
+export interface TaskItem {
+	id: string;
+	subject: string;
+	description: string;
+	activeForm?: string;
+	status: TaskStatus;
+	owner?: string;
+	metadata: Record<string, unknown>;
+	/** Ids of tasks that cannot start until this one completes. */
+	blocks: string[];
+	/** Ids of tasks that must complete before this one can start. */
+	blockedBy: string[];
+}
+
+export interface TaskSnapshot {
+	nextId: number;
+	tasks: TaskItem[];
+}
+
+export interface TaskUpdateInput {
+	subject?: string;
+	description?: string;
+	activeForm?: string;
+	status?: TaskStatus | "deleted";
+	owner?: string;
+	metadata?: Record<string, unknown>;
+	addBlocks?: string[];
+	addBlockedBy?: string[];
+}
+
+export class TaskStore {
+	private tasks = new Map<string, TaskItem>();
+	private nextId = 1;
+
+	create(input: { subject: string; description: string; activeForm?: string; metadata?: Record<string, unknown> }): TaskItem {
+		const task: TaskItem = {
+			id: String(this.nextId++),
+			subject: input.subject,
+			description: input.description,
+			activeForm: input.activeForm,
+			status: "pending",
+			metadata: { ...(input.metadata ?? {}) },
+			blocks: [],
+			blockedBy: [],
+		};
+		this.tasks.set(task.id, task);
+		return task;
+	}
+
+	get(id: string): TaskItem | undefined {
+		return this.tasks.get(id);
+	}
+
+	list(): TaskItem[] {
+		return [...this.tasks.values()];
+	}
+
+	/** Ids in `blockedBy` that refer to existing, not-yet-completed tasks. */
+	openBlockers(task: TaskItem): string[] {
+		return task.blockedBy.filter((id) => {
+			const blocker = this.tasks.get(id);
+			return blocker !== undefined && blocker.status !== "completed";
+		});
+	}
+
+	update(id: string, input: TaskUpdateInput): { task?: TaskItem; deleted?: boolean; error?: string } {
+		const task = this.tasks.get(id);
+		if (!task) return { error: `No task with id "${id}". Use task_list to see ids.` };
+
+		if (input.status === "deleted") {
+			this.tasks.delete(id);
+			for (const other of this.tasks.values()) {
+				other.blocks = other.blocks.filter((b) => b !== id);
+				other.blockedBy = other.blockedBy.filter((b) => b !== id);
+			}
+			return { deleted: true };
+		}
+
+		if (input.subject !== undefined) task.subject = input.subject;
+		if (input.description !== undefined) task.description = input.description;
+		if (input.activeForm !== undefined) task.activeForm = input.activeForm;
+		if (input.status !== undefined) task.status = input.status;
+		if (input.owner !== undefined) task.owner = input.owner || undefined;
+
+		if (input.metadata) {
+			for (const [key, value] of Object.entries(input.metadata)) {
+				if (value === null) delete task.metadata[key];
+				else task.metadata[key] = value;
+			}
+		}
+
+		// Separate a self-reference from a genuinely unknown id: link() rejects
+		// both, so folding them together reported a valid, existing id as "Unknown
+		// task id" — sending the model to hunt a typo that isn't there.
+		const unknown: string[] = [];
+		let selfRef = false;
+		for (const other of input.addBlocks ?? []) {
+			if (other === id) selfRef = true;
+			else if (!this.link(id, other)) unknown.push(other);
+		}
+		for (const other of input.addBlockedBy ?? []) {
+			if (other === id) selfRef = true;
+			else if (!this.link(other, id)) unknown.push(other);
+		}
+		const errors: string[] = [];
+		if (selfRef) errors.push(`Task #${id} cannot block or be blocked by itself`);
+		if (unknown.length > 0) errors.push(`Unknown task id(s) in dependency list: ${unknown.join(", ")}`);
+		if (errors.length > 0) return { task, error: errors.join(". ") };
+		return { task };
+	}
+
+	/** Record "blocker blocks blocked" on both sides. False if either id is unknown. */
+	private link(blockerId: string, blockedId: string): boolean {
+		const blocker = this.tasks.get(blockerId);
+		const blocked = this.tasks.get(blockedId);
+		if (!blocker || !blocked || blockerId === blockedId) return false;
+		if (!blocker.blocks.includes(blockedId)) blocker.blocks.push(blockedId);
+		if (!blocked.blockedBy.includes(blockerId)) blocked.blockedBy.push(blockerId);
+		return true;
+	}
+
+	snapshot(): TaskSnapshot {
+		return { nextId: this.nextId, tasks: this.list().map((t) => ({ ...t, metadata: { ...t.metadata }, blocks: [...t.blocks], blockedBy: [...t.blockedBy] })) };
+	}
+
+	restore(snapshot: TaskSnapshot | undefined): void {
+		this.tasks.clear();
+		this.nextId = snapshot?.nextId ?? 1;
+		for (const task of snapshot?.tasks ?? []) {
+			this.tasks.set(task.id, { ...task, metadata: { ...task.metadata }, blocks: [...task.blocks], blockedBy: [...task.blockedBy] });
+		}
+	}
+}
+
+const STATUS_MARK: Record<TaskStatus, string> = { pending: " ", in_progress: "▸", completed: "x" };
+
+export function formatTaskLine(store: TaskStore, task: TaskItem): string {
+	const parts = [`#${task.id} [${STATUS_MARK[task.status]}] ${task.subject}`];
+	if (task.owner) parts.push(`owner: ${task.owner}`);
+	const open = store.openBlockers(task);
+	if (open.length > 0) parts.push(`blocked by: ${open.map((b) => `#${b}`).join(", ")}`);
+	return parts.join(" · ");
+}
+
+export function formatTaskList(store: TaskStore): string {
+	const tasks = store.list();
+	if (tasks.length === 0) return "No tasks.";
+	return tasks.map((t) => formatTaskLine(store, t)).join("\n");
+}
+
+export function formatTaskDetails(store: TaskStore, task: TaskItem): string {
+	const lines = [
+		`Task #${task.id}: ${task.subject}`,
+		`Status: ${task.status}${task.owner ? ` · owner: ${task.owner}` : ""}`,
+		`Description: ${task.description}`,
+	];
+	if (task.blocks.length > 0) lines.push(`Blocks: ${task.blocks.map((b) => `#${b}`).join(", ")}`);
+	const open = store.openBlockers(task);
+	if (task.blockedBy.length > 0) {
+		lines.push(`Blocked by: ${task.blockedBy.map((b) => `#${b}`).join(", ")}${open.length === 0 ? " (all resolved)" : ""}`);
+	}
+	if (Object.keys(task.metadata).length > 0) lines.push(`Metadata: ${JSON.stringify(task.metadata)}`);
+	return lines.join("\n");
+}

package/extensions/todo/index.ts

@@ -0,0 +1,133 @@
+/**
+ * todo extension — Claude Code's TodoWrite: stateless whole-list replacement.
+ *
+ * Schema matches Claude Code (content / status / activeForm per item). State
+ * lives in tool-result details, so branching and resuming a session restores
+ * the list that was current at that point in history (pattern from pi's
+ * official todo example). A widget under the editor shows live progress.
+ */
+
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { restoreLatestDetails } from "../lib/branch-restore.ts";
+import { REMINDER_CHANNEL } from "../lib/reminders.ts";
+import { ccToolRenderers } from "../lib/tui-render.ts";
+
+interface TodoItem {
+	content: string;
+	status: "pending" | "in_progress" | "completed";
+	activeForm: string;
+}
+
+interface TodoDetails {
+	todos: TodoItem[];
+}
+
+const TodoWriteParams = Type.Object({
+	todos: Type.Array(
+		Type.Object({
+			content: Type.String({ description: "The task, in imperative form (e.g. 'Fix the login bug')" }),
+			status: StringEnum(["pending", "in_progress", "completed"] as const),
+			activeForm: Type.String({ description: "Present-continuous form shown while in progress (e.g. 'Fixing the login bug')" }),
+		}),
+		{ description: "The complete todo list; this REPLACES the previous list entirely" },
+	),
+});
+
+function formatTodos(todos: TodoItem[]): string {
+	if (todos.length === 0) return "Todo list cleared.";
+	const mark = (t: TodoItem) => (t.status === "completed" ? "x" : t.status === "in_progress" ? "▸" : " ");
+	return todos.map((t) => `[${mark(t)}] ${t.content}`).join("\n");
+}
+
+/**
+ * Claude Code nudges the model when the task tools have gone unused for a while.
+ * A todo tool nobody remembers to call is decoration, so we do the same — quietly
+ * and rarely, based on session state.
+ */
+const NUDGE_AFTER_TURNS = 8;
+const TODO_TOOLS = new Set(["todo_write"]);
+
+export default function todoExtension(pi: ExtensionAPI) {
+	let todos: TodoItem[] = [];
+	let turnsSinceTodoUse = 0;
+
+	const updateWidget = (ctx: ExtensionContext) => {
+		if (!ctx.hasUI) return;
+		if (todos.length === 0) {
+			ctx.ui.setWidget("cc-todos", undefined);
+			return;
+		}
+		const done = todos.filter((t) => t.status === "completed").length;
+		const active = todos.find((t) => t.status === "in_progress");
+		const line = ` todos ${done}/${todos.length}${active ? ` · ${active.activeForm}` : ""}`;
+		ctx.ui.setWidget("cc-todos", [line]);
+	};
+
+	const reconstructState = (ctx: ExtensionContext) => {
+		const details = restoreLatestDetails<TodoDetails>(ctx.sessionManager.getBranch(), TODO_TOOLS, (d) => Boolean(d?.todos));
+		todos = details?.todos ?? [];
+		updateWidget(ctx);
+	};
+
+	pi.on("session_start", (_event, ctx) => reconstructState(ctx));
+	pi.on("session_tree", (_event, ctx) => reconstructState(ctx));
+
+	pi.on("turn_end", () => {
+		turnsSinceTodoUse++;
+		if (turnsSinceTodoUse < NUDGE_AFTER_TURNS) return;
+		turnsSinceTodoUse = 0;
+
+		if (todos.length === 0) {
+			pi.events.emit(REMINDER_CHANNEL, {
+				text: "The todo tool has not been used recently. If the current work has several steps, track it with todo_write so progress is visible; skip this if the task is simple.",
+			});
+			return;
+		}
+
+		const active = todos.filter((t) => t.status === "in_progress");
+		const done = todos.filter((t) => t.status === "completed").length;
+		if (active.length === 0 && done < todos.length) {
+			pi.events.emit(REMINDER_CHANNEL, {
+				text: `The todo list has ${todos.length - done} unfinished item(s) and none marked in_progress. Update it with todo_write to reflect what you are actually doing, or clear it if it is stale.`,
+			});
+		} else if (active.length > 1) {
+			pi.events.emit(REMINDER_CHANNEL, {
+				text: `${active.length} todo items are marked in_progress. Exactly one should be in progress at a time — update the list with todo_write.`,
+			});
+		}
+	});
+
+	pi.registerTool({
+		name: "todo_write",
+		label: "Todos",
+		...ccToolRenderers<{ todos?: unknown[] }>("Todos", {
+			title: (a) => (a?.todos ? `${a.todos.length} items` : undefined),
+			maxCollapsedLines: 12,
+		}),
+		description:
+			"Create and manage a structured task list for the current session. Each call REPLACES the entire list. Use for multi-step tasks (3+ steps): mark exactly one item in_progress before starting it, mark it completed immediately when done, and keep the list current rather than batching updates.",
+		promptSnippet: "Track multi-step task progress with a todo list",
+		promptGuidelines: [
+			"For tasks with 3+ steps, track progress with todo_write; keep exactly one item in_progress",
+		],
+		parameters: TodoWriteParams,
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			todos = params.todos as TodoItem[];
+			turnsSinceTodoUse = 0;
+			updateWidget(ctx);
+			return {
+				content: [{ type: "text", text: formatTodos(todos) }],
+				details: { todos: [...todos] } satisfies TodoDetails,
+			};
+		},
+	});
+
+	pi.registerCommand("todos", {
+		description: "Show the agent's current todo list",
+		handler: async (_args, ctx) => {
+			ctx.ui.notify(todos.length ? formatTodos(todos) : "No todos.", "info");
+		},
+	});
+}

package/extensions/tool-search/index.ts

@@ -0,0 +1,168 @@
+/**
+ * tool-search extension — Claude Code's ToolSearch.
+ *
+ * Deactivates every tool registered in the deferred registry at session start,
+ * tells the model which names exist (a system reminder, as Claude Code does),
+ * and activates matches additively when the model calls `tool_search`.
+ *
+ * Deferral runs on ALL model tiers, matching Claude Code: capture-confirmed that
+ * current CC (v2.1.224/226) defers the niche/long-tail tools behind ToolSearch
+ * even on Haiku, keeping only the core set eager (findings §14). Which tools are
+ * deferrable is decided per tool (extensions opt in via DEFER_CHANNEL) — core
+ * tools like read/edit/write/bash never register, so they stay eager.
+ *
+ * The mechanism is provider-independent: `pi.setActiveTools` edits the agent's
+ * active tool set (`agent.state.tools`), which IS what pi sends, so a deactivated
+ * tool is omitted from the request on any provider (OpenRouter, deepseek, etc.).
+ * Provider-native deferral (Anthropic `defer_loading`, OpenAI `tool_search_call`)
+ * is only a cache optimization on top; without it, loading a tool mid-session
+ * grows the tools array and invalidates the prompt cache from the tools block
+ * down — an accepted tradeoff (findings §7).
+ *
+ * Load order matters: this extension must come BEFORE any extension that defers
+ * a tool, because those emit their defer request while extensions are loading
+ * and pi's event bus only delivers to listeners already registered.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import {
+	DEFER_CHANNEL,
+	deferredRegistry,
+	deferredReminderText,
+	type DeferRequest,
+	searchTools,
+	selectedNames,
+} from "../lib/deferred.ts";
+import { CONTEXT_ORDER, REMINDER_CHANNEL } from "../lib/reminders.ts";
+import { ccToolRenderers } from "../lib/tui-render.ts";
+
+export default function toolSearchExtension(pi: ExtensionAPI) {
+	let sessionStarted = false;
+
+	const searchableTools = () =>
+		pi
+			.getAllTools()
+			.filter((tool) => deferredRegistry.has(tool.name))
+			.map((tool) => ({
+				name: tool.name,
+				description: tool.description ?? "",
+				keywords: deferredRegistry.keywordsFor(tool.name),
+			}));
+
+	const announceDeferred = () => {
+		const available = searchableTools();
+		if (available.length === 0) return;
+		pi.events.emit(REMINDER_CHANNEL, {
+			scope: "every-turn",
+			key: "deferred-tools",
+			text: deferredReminderText(available),
+			placement: "first-prepend",
+			order: CONTEXT_ORDER.deferredTools,
+		});
+	};
+
+	/** Deactivate every deferred-registry tool and announce the loadable set. */
+	const deferAll = () => {
+		const deferred = new Set(deferredRegistry.names);
+		if (deferred.size === 0) return;
+		const active = pi.getActiveTools();
+		const next = active.filter((name) => !deferred.has(name));
+		if (next.length !== active.length) pi.setActiveTools(next);
+		announceDeferred();
+	};
+
+	pi.events.on(DEFER_CHANNEL, (data) => {
+		const request = data as DeferRequest;
+		deferredRegistry.add(request);
+		// A defer arriving after the session_start pass (MCP servers connect
+		// asynchronously and register their tools then) would otherwise leave the
+		// tool eager AND unlisted in the reminder. Deactivate it and refresh the
+		// keyed reminder.
+		if (sessionStarted && request?.name) {
+			const active = pi.getActiveTools();
+			if (active.includes(request.name)) {
+				pi.setActiveTools(active.filter((name) => name !== request.name));
+			}
+			announceDeferred();
+		}
+	});
+
+	pi.on("session_start", () => {
+		sessionStarted = true;
+		deferAll();
+	});
+
+	pi.registerTool({
+		name: "tool_search",
+		label: "Tool Search",
+		...ccToolRenderers("Tool Search"),
+		description:
+			"Load the schemas of tools that are available but not yet callable. Query forms: `select:<name>[,<name>]` to load exact tools by name, `+<term> <words>` to require a term in the tool name, or plain keywords to search. Returns the tools that are now callable.",
+		promptSnippet: "Load additional tool schemas on demand",
+		parameters: Type.Object({
+			query: Type.String({ description: "Tool names (`select:a,b`) or keywords describing the capability needed" }),
+			max_results: Type.Optional(
+				Type.Integer({ minimum: 1, maximum: 20, description: "Maximum tools to load (default 5)" }),
+			),
+		}),
+		async execute(_toolCallId, params) {
+			const available = searchableTools();
+			const matches = searchTools(params.query, available, params.max_results ?? 5);
+
+			// For an exact `select:` query, a requested name that matched nothing was
+			// silently dropped before — the model was told the rest "Loaded" and only
+			// discovered the miss later as an opaque InputValidationError. Always
+			// surface the unmatched names.
+			const requested = selectedNames(params.query);
+			const notFound = requested
+				? requested.filter((n) => !matches.some((m) => m.name.toLowerCase() === n))
+				: [];
+			const notFoundNote =
+				notFound.length > 0
+					? ` Not found (not deferred tool names — check spelling, or search by keyword instead of \`select:\`): ${notFound.join(", ")}.`
+					: "";
+
+			if (matches.length === 0) {
+				const names = available.map((t) => t.name).join(", ") || "(none)";
+				return {
+					content: [
+						{ type: "text", text: `No tools matched "${params.query}".${notFoundNote} Tools that can be loaded: ${names}` },
+					],
+					details: { matches: [] as string[], added: [] as string[], notFound },
+					isError: true,
+				};
+			}
+
+			const active = pi.getActiveTools();
+			const added = matches.map((m) => m.name).filter((name) => !active.includes(name));
+			if (added.length > 0) {
+				pi.setActiveTools([...new Set([...active, ...added])]);
+			}
+
+			const loaded = matches.map((m) => m.name);
+			return {
+				content: [
+					{
+						type: "text",
+						text:
+							(added.length > 0
+								? `Loaded ${added.join(", ")}. These tools are now callable.`
+								: `Already loaded: ${loaded.join(", ")}.`) + notFoundNote,
+					},
+				],
+				details: { matches: loaded, added, notFound },
+			};
+		},
+	});
+
+	pi.registerCommand("tools-deferred", {
+		description: "Show which tools are deferred (loadable via tool_search)",
+		handler: async (_args, ctx) => {
+			const available = searchableTools();
+			const activeSet = new Set(pi.getActiveTools());
+			const lines = available.map((t) => `${activeSet.has(t.name) ? "loaded " : "deferred"} ${t.name}`);
+			ctx.ui.notify(lines.length ? lines.join("\n") : "No deferred tools registered.", "info");
+		},
+	});
+}

package/extensions/tool-style/index.ts

@@ -0,0 +1,84 @@
+/**
+ * tool-style extension — Claude Code's `● Tool(args)` / `⎿ result` transcript
+ * language for pi's built-in file tools.
+ *
+ * Registering a tool under a built-in's name overrides it (findings §2, the
+ * same mechanism the bash extension uses). Every model-facing field —
+ * description, promptSnippet, promptGuidelines, parameters — is passed through
+ * from pi's own definition byte-identical, so the system prompt and tool
+ * schemas are unchanged; execution delegates to a per-cwd instance of pi's
+ * real definition (they close over cwd, and enter_worktree moves the session
+ * mid-run). Only the TUI renderers differ: a `●` call line, and the base
+ * result component indented under a `⎿` elbow so upstream streaming,
+ * truncation, and ctrl+o expansion behavior is preserved. Edit keeps its own
+ * call component (the diff preview a permission prompt relies on) with just
+ * the header line restyled.
+ *
+ * grep/find/ls stay tier-gated: registering them does not bypass the
+ * search-tools extension, which reconciles the active-tool list on
+ * session_start/model_select and removes them for frontier models.
+ */
+
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import {
+	createEditToolDefinition,
+	createFindToolDefinition,
+	createGrepToolDefinition,
+	createLsToolDefinition,
+	createReadToolDefinition,
+	createWriteToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+import { perCwd } from "../lib/per-cwd.ts";
+import { ccWrapBuiltinRenderers } from "../lib/tui-render.ts";
+
+// The concrete definitions are each strongly typed to their own schema; this
+// extension treats them uniformly, so the spec is deliberately loose. Every
+// field is still passed through verbatim.
+type BuiltinDefinition = ToolDefinition<any, any, any> & { name: string };
+
+interface BuiltinSpec {
+	label: string;
+	create: (cwd: string) => BuiltinDefinition;
+	title: (args: Record<string, unknown> | undefined) => string | undefined;
+	keepBaseCall?: boolean;
+}
+
+const asSpecCreate = (create: (cwd: string) => unknown): BuiltinSpec["create"] =>
+	create as BuiltinSpec["create"];
+
+const BUILTINS: BuiltinSpec[] = [
+	{ label: "Read", create: asSpecCreate(createReadToolDefinition), title: (a) => a?.path as string | undefined },
+	{ label: "Write", create: asSpecCreate(createWriteToolDefinition), title: (a) => a?.path as string | undefined },
+	{
+		label: "Update",
+		create: asSpecCreate(createEditToolDefinition),
+		title: (a) => a?.path as string | undefined,
+		keepBaseCall: true,
+	},
+	{ label: "Grep", create: asSpecCreate(createGrepToolDefinition), title: (a) => a?.pattern as string | undefined },
+	{ label: "Find", create: asSpecCreate(createFindToolDefinition), title: (a) => a?.pattern as string | undefined },
+	{ label: "LS", create: asSpecCreate(createLsToolDefinition), title: (a) => (a?.path as string | undefined) ?? "." },
+];
+
+export default function toolStyleExtension(pi: ExtensionAPI) {
+	for (const spec of BUILTINS) {
+		const base = spec.create(process.cwd());
+		const forCwd = perCwd(spec.create);
+
+		pi.registerTool({
+			name: base.name,
+			label: base.label,
+			description: base.description,
+			promptSnippet: base.promptSnippet,
+			promptGuidelines: base.promptGuidelines,
+			parameters: base.parameters,
+			executionMode: base.executionMode,
+			prepareArguments: base.prepareArguments,
+			constrainedSampling: base.constrainedSampling,
+			...ccWrapBuiltinRenderers(spec.label, base, { title: spec.title, keepBaseCall: spec.keepBaseCall }),
+			async execute(toolCallId, params, signal, onUpdate, ctx: ExtensionContext) {
+				return forCwd(ctx.cwd).execute(toolCallId, params as never, signal, onUpdate, ctx);
+			},
+		} as ToolDefinition);
+	}
+}

package/extensions/web/index.ts

@@ -0,0 +1,43 @@
+/**
+ * web extension — Claude Code's WebSearch role.
+ *
+ * `web_search` comes from the community `pi-web-search` package, which calls the
+ * *current model provider's own* search API (OpenAI/Codex, Anthropic, Gemini) —
+ * no third-party key, and as close to Claude Code's server-side search as an
+ * extension can get. It also registers Gemini-only `url_context`.
+ *
+ * WebFetch lives in `extensions/web-fetch` (our own); this file only owns search.
+ *
+ * Note: pi-web-search drives `setActiveTools` to hide `url_context` on non-Gemini
+ * models. That composes with our deferral only because `tool-search` loads first
+ * and therefore deactivates deferred tools before this package snapshots the
+ * active set. Keep that ordering.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import webSearch from "pi-web-search/src/index.ts";
+import { DEFER_CHANNEL } from "../lib/deferred.ts";
+
+export default function webExtension(pi: ExtensionAPI) {
+	webSearch(pi);
+
+	// pi-web-search reports failures ("Failed: …" text, details.error set)
+	// without isError, so a weak model can read a failure as a successful
+	// search with odd content. Stamp isError here rather than patching the
+	// vendor package.
+	pi.on("tool_result", (event) => {
+		if (event.toolName !== "web_search" && event.toolName !== "url_context") return;
+		if (event.isError) return;
+		const details = event.details as { error?: unknown } | undefined;
+		if (details?.error) return { isError: true };
+	});
+
+	pi.events.emit(DEFER_CHANNEL, {
+		name: "web_search",
+		keywords: ["web", "search", "internet", "google", "news", "lookup", "online", "current"],
+	});
+	pi.events.emit(DEFER_CHANNEL, {
+		name: "url_context",
+		keywords: ["url", "analyze page", "gemini"],
+	});
+}