Add unified extensions system (not wired up yet)

New src/core/extensions/ directory with:
- types.ts: merged types from hooks and custom-tools
- loader.ts: single loader for extensions
- runner.ts: ExtensionRunner for event emission
- wrapper.ts: tool wrapping utilities
- index.ts: exports

Key changes from old system:
- Single ExtensionAPI with registerTool() for LLM-callable tools
- Tools use ExtensionContext (has UI access)
- No onSession callback on tools (use pi.on events instead)

refs #454

packages/coding-agent/src/core/extensions/wrapper.ts

@@ -0,0 +1,119 @@
+/**
+ * Tool wrappers for extensions.
+ */
+
+import type { AgentTool, AgentToolUpdateCallback } from "@mariozechner/pi-agent-core";
+import type { ExtensionRunner } from "./runner.js";
+import type { ExtensionContext, RegisteredTool, ToolCallEventResult, ToolResultEventResult } from "./types.js";
+
+/**
+ * Wrap a RegisteredTool into an AgentTool.
+ */
+export function wrapRegisteredTool(registeredTool: RegisteredTool, getContext: () => ExtensionContext): AgentTool {
+	const { definition } = registeredTool;
+	return {
+		name: definition.name,
+		label: definition.label,
+		description: definition.description,
+		parameters: definition.parameters,
+		execute: (toolCallId, params, signal, onUpdate) =>
+			definition.execute(toolCallId, params, onUpdate, getContext(), signal),
+	};
+}
+
+/**
+ * Wrap all registered tools into AgentTools.
+ */
+export function wrapRegisteredTools(
+	registeredTools: RegisteredTool[],
+	getContext: () => ExtensionContext,
+): AgentTool[] {
+	return registeredTools.map((rt) => wrapRegisteredTool(rt, getContext));
+}
+
+/**
+ * Wrap a tool with extension callbacks for interception.
+ * - Emits tool_call event before execution (can block)
+ * - Emits tool_result event after execution (can modify result)
+ */
+export function wrapToolWithExtensions<T>(tool: AgentTool<any, T>, runner: ExtensionRunner): AgentTool<any, T> {
+	return {
+		...tool,
+		execute: async (
+			toolCallId: string,
+			params: Record<string, unknown>,
+			signal?: AbortSignal,
+			onUpdate?: AgentToolUpdateCallback<T>,
+		) => {
+			// Emit tool_call event - extensions can block execution
+			if (runner.hasHandlers("tool_call")) {
+				try {
+					const callResult = (await runner.emitToolCall({
+						type: "tool_call",
+						toolName: tool.name,
+						toolCallId,
+						input: params,
+					})) as ToolCallEventResult | undefined;
+
+					if (callResult?.block) {
+						const reason = callResult.reason || "Tool execution was blocked by an extension";
+						throw new Error(reason);
+					}
+				} catch (err) {
+					if (err instanceof Error) {
+						throw err;
+					}
+					throw new Error(`Extension failed, blocking execution: ${String(err)}`);
+				}
+			}
+
+			// Execute the actual tool
+			try {
+				const result = await tool.execute(toolCallId, params, signal, onUpdate);
+
+				// Emit tool_result event - extensions can modify the result
+				if (runner.hasHandlers("tool_result")) {
+					const resultResult = (await runner.emit({
+						type: "tool_result",
+						toolName: tool.name,
+						toolCallId,
+						input: params,
+						content: result.content,
+						details: result.details,
+						isError: false,
+					})) as ToolResultEventResult | undefined;
+
+					if (resultResult) {
+						return {
+							content: resultResult.content ?? result.content,
+							details: (resultResult.details ?? result.details) as T,
+						};
+					}
+				}
+
+				return result;
+			} catch (err) {
+				// Emit tool_result event for errors
+				if (runner.hasHandlers("tool_result")) {
+					await runner.emit({
+						type: "tool_result",
+						toolName: tool.name,
+						toolCallId,
+						input: params,
+						content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+						details: undefined,
+						isError: true,
+					});
+				}
+				throw err;
+			}
+		},
+	};
+}
+
+/**
+ * Wrap all tools with extension callbacks.
+ */
+export function wrapToolsWithExtensions<T>(tools: AgentTool<any, T>[], runner: ExtensionRunner): AgentTool<any, T>[] {
+	return tools.map((tool) => wrapToolWithExtensions(tool, runner));
+}