@bike4mind/cli 0.16.0 → 0.17.1

package/dist/index.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { $ as SessionStore, A as substituteArguments, B as DEFAULT_RETRY_CONFIG, C as WebSocketToolExecutor, D as ServerLlmBackend, E as WebSocketLlmBackend, F as generateCliTools, G as getPlanModeFilePath, H as clearFeatureModuleTools, I as getProcessHooks, J as isReadOnlyTool, K as buildSystemPrompt, L as ALWAYS_DENIED_FOR_AGENTS, M as extractCompactInstructions, N as loadContextFiles, O as isTransientNetworkError, P as PermissionManager, Q as CommandHistoryStore, R as DEFAULT_AGENT_MODEL, S as ApiClient, T as FallbackLlmBackend, U as registerFeatureModuleTools, V as DEFAULT_THOROUGHNESS, W as setWebSocketToolExecutor, X as CustomCommandStore, Y as ReActAgent, Z as CheckpointStore, _ as createAgentDelegateTool, a as createBlockerTools, at as formatFileSize, b as createSkillTool, c as createDecisionStore, d as createFindDefinitionTool, et as OAuthClient, f as createTodoStore, g as BackgroundAgentManager, h as createBackgroundAgentTools, i as createBlockerStore, it as mergeCommands, j as formatStep, k as McpManager, l as formatDecisionsOutput, m as createCoordinateTaskTool, n as createReviewGateTool, nt as processFileReferences, o as formatBlockersOutput, ot as searchFiles, p as createWriteTodosTool, q as buildSkillsPromptSection, r as formatReviewGatesOutput, rt as searchCommands, s as createDecisionLogTool, st as warmFileCache, t as createReviewGateStore, tt as hasFileReferences, u as createGetFileStructureTool, v as AgentStore, w as WebSocketConnectionManager, x as parseAgentConfig, y as SubagentOrchestrator, z as DEFAULT_MAX_ITERATIONS } from "./tools-D9eSRR7Q.mjs";
+import { $ as CommandHistoryStore, A as substituteArguments, B as DEFAULT_RETRY_CONFIG, C as createCoordinateTaskTool, D as FallbackLlmBackend, E as ApiClient, F as generateCliTools, G as ReActAgent, H as clearFeatureModuleTools, I as getProcessHooks, J as buildSkillsPromptSection, K as getPlanModeFilePath, L as ALWAYS_DENIED_FOR_AGENTS, M as extractCompactInstructions, N as loadContextFiles, O as ServerLlmBackend, P as PermissionManager, Q as CheckpointStore, R as DEFAULT_AGENT_MODEL, S as parseAgentConfig, T as createAgentDelegateTool, U as registerFeatureModuleTools, V as DEFAULT_THOROUGHNESS, W as setWebSocketToolExecutor, X as RemoteSkillSource, Y as isReadOnlyTool, Z as CustomCommandStore, _ as createGetFileStructureTool, a as WebSocketToolExecutor, at as mergeCommands, b as createWriteTodosTool, c as createReviewGateStore, ct as warmFileCache, d as createBlockerStore, et as SessionStore, f as createBlockerTools, g as formatDecisionsOutput, h as createDecisionStore, i as McpManager, it as searchCommands, j as formatStep, k as isTransientNetworkError, l as createReviewGateTool, m as createDecisionLogTool, n as SubagentOrchestrator, nt as hasFileReferences, o as WebSocketConnectionManager, ot as formatFileSize, p as formatBlockersOutput, q as buildSystemPrompt, r as AgentStore, rt as processFileReferences, s as WebSocketLlmBackend, st as searchFiles, t as BackgroundAgentManager, tt as OAuthClient, u as formatReviewGatesOutput, v as createFindDefinitionTool, w as createBackgroundAgentTools, x as createSkillTool, y as createTodoStore, z as DEFAULT_MAX_ITERATIONS } from "./BackgroundAgentManager-C5HEirFN.mjs";
 import { n as useCliStore, t as selectActiveBackgroundAgents } from "./store-DV5s-qni.mjs";
-import { Gt as validateNotebookPath$1, Wt as validateJupyterKernelName, g as CREDIT_DEDUCT_TRANSACTION_TYPES, i as getEnvironmentName, n as logger, r as getApiUrl, t as ConfigStore, v as ChatModels } from "./ConfigStore-CtGc4fF2.mjs";
-import { t as version } from "./package-3pouvthv.mjs";
+import { Jt as validateJupyterKernelName, Yt as validateNotebookPath$1, g as CREDIT_DEDUCT_TRANSACTION_TYPES, i as getEnvironmentName, n as logger, r as getApiUrl, t as ConfigStore, v as ChatModels } from "./ConfigStore-gV8aHo9b.mjs";
+import { t as version } from "./package-Dzetdo6D.mjs";
 import { r as checkForUpdate } from "./updateChecker-C8xsNY2L.mjs";
 import React, { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
 import { Box, Static, Text, render, useApp, useInput, usePaste, useStdout } from "ink";
@@ -3287,1104 +3287,625 @@ var MessageBuilder = class {
 	}
 };
 //#endregion
-//#region src/utils/jupyterClient.ts
+//#region src/llm/NotifyingLlmBackend.ts
 /**
-* Jupyter Server REST API Client
-*
-* Provides methods for interacting with a local Jupyter Server instance.
-* Used by Keep commands to execute notebooks on the user's local machine.
+* LLM backend wrapper that injects background agent notifications
+* into the message array before each completion call.
 *
-* @see https://jupyter-server.readthedocs.io/en/latest/developers/rest-api.html
-* @see https://jupyter-client.readthedocs.io/en/latest/messaging.html
+* When a background agent completes (or fails), the notification
+* appears as a system message so the main agent naturally sees it
+* in context — no polling required.
 */
-var JupyterClientError = class extends Error {
-	constructor(message, statusCode, response) {
-		super(message);
-		this.statusCode = statusCode;
-		this.response = response;
-		this.name = "JupyterClientError";
+var NotifyingLlmBackend = class {
+	constructor(inner, backgroundManager) {
+		this.inner = inner;
+		this.backgroundManager = backgroundManager;
+	}
+	get currentModel() {
+		return this.inner.currentModel;
+	}
+	set currentModel(model) {
+		this.inner.currentModel = model;
+	}
+	async complete(model, messages, options, callback) {
+		const notifications = this.backgroundManager.drainNotifications();
+		let effectiveMessages = messages;
+		if (notifications.length > 0) {
+			const notificationMessage = {
+				role: "user",
+				content: `[System Notification]\n\n${notifications.join("\n\n---\n\n")}\n\nPlease acknowledge these background agent results and incorporate them into your current work.`
+			};
+			effectiveMessages = [...messages, notificationMessage];
+		}
+		return this.inner.complete(model, effectiveMessages, options, callback);
+	}
+	pushToolMessages(messages, tool, result) {
+		return this.inner.pushToolMessages(messages, tool, result);
+	}
+	async getModelInfo() {
+		return this.inner.getModelInfo();
 	}
 };
+//#endregion
+//#region src/utils/peonNotifier.ts
 /**
-* Validate Jupyter server URL
+* peon-ping notifier — native b4m adapter for peon-ping (https://peonping.com).
+*
+* peon-ping plays game-character voice lines + on-screen banners when an AI
+* coding agent finishes a turn or needs attention. It consumes a small JSON
+* event on stdin (the "CESP" hook contract shared by Claude Code and every
+* peon-ping adapter):
+*
+*   { hook_event_name, notification_type, cwd, session_id, permission_mode }
+*
+* This module is the b4m CLI's equivalent of the shell adapters peon-ping
+* ships for other IDEs (see `adapters/openclaw.sh`), except it runs in-process
+* and is wired directly to the CLI's lifecycle via a store subscription.
+*
+* Behaviour is auto-detect: if a `peon.sh` is found on disk it is enabled,
+* otherwise every call is a silent no-op. Set `B4M_PEON_PING=0` to force it
+* off even when installed.
 */
-function validateServerUrl(url) {
-	if (!url || typeof url !== "string") throw new JupyterClientError("Server URL is required");
-	let parsed;
+/**
+* Resolve the path to `peon.sh`, checking the same locations peon-ping's own
+* adapters use. Returns null when peon-ping is not installed. Resolved once and
+* cached: `null` means "looked and found nothing".
+*/
+let resolvedScript;
+function findPeonScript() {
+	if (resolvedScript !== void 0) return resolvedScript;
+	const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(homedir(), ".claude");
+	resolvedScript = [
+		process.env.CLAUDE_PEON_DIR ? path.join(process.env.CLAUDE_PEON_DIR, "peon.sh") : null,
+		path.join(claudeDir, "hooks", "peon-ping", "peon.sh"),
+		path.join(homedir(), ".openpeon", "peon.sh")
+	].filter((p) => p !== null).find((p) => existsSync(p)) ?? null;
+	return resolvedScript;
+}
+/** Explicit off-switch via env, even when peon-ping is installed. */
+function isDisabledByEnv() {
+	const v = process.env.B4M_PEON_PING?.toLowerCase();
+	return v === "0" || v === "false" || v === "off";
+}
+/** True when peon-ping is installed and not disabled. */
+function isPeonAvailable() {
+	return !isDisabledByEnv() && findPeonScript() !== null;
+}
+/**
+* Fire a single peon-ping event. Fire-and-forget and fail-safe: the child is
+* detached and unref'd, all output is discarded, and any spawn error is logged
+* to the debug log but never surfaced — the CLI must never break because of a
+* missing or misbehaving peon install.
+*/
+function notifyPeon(event, options = {}) {
+	if (isDisabledByEnv()) return;
+	const script = findPeonScript();
+	if (!script) return;
+	const payload = JSON.stringify({
+		hook_event_name: event,
+		notification_type: options.notificationType ?? "",
+		cwd: process.cwd(),
+		session_id: useCliStore.getState().session?.id ?? `b4m-${process.pid}`,
+		permission_mode: ""
+	});
 	try {
-		parsed = new URL(url);
-	} catch {
-		throw new JupyterClientError(`Invalid server URL: ${url}`);
+		const child = spawn("bash", [script], {
+			stdio: [
+				"pipe",
+				"ignore",
+				"ignore"
+			],
+			detached: true
+		});
+		child.on("error", (err) => logger.debug(`peon-ping spawn failed: ${err.message}`));
+		child.stdin?.on("error", () => {});
+		child.stdin?.end(payload);
+		child.unref();
+	} catch (err) {
+		logger.debug(`peon-ping notify error: ${err.message}`);
 	}
-	if (!["http:", "https:"].includes(parsed.protocol)) throw new JupyterClientError(`Invalid protocol: ${parsed.protocol}. Only http and https are allowed`);
 }
 /**
-* Validate notebook path to prevent path traversal (throws on invalid)
+* Subscribe to CLI lifecycle and emit peon-ping events:
+* - `Stop` when the agent finishes a turn (isThinking true → false)
+* - `Notification` (permission_prompt) when a permission / user-question /
+*   review-gate prompt first appears and the user needs to act
+*
+* Fires `SessionStart` immediately. Returns an unsubscribe function; call it
+* (and pass `emitSessionEnd`) on exit to emit `SessionEnd`.
 */
-function validateNotebookPath(path) {
-	const result = validateNotebookPath$1(path);
-	if (!result.valid) throw new JupyterClientError(result.error || "Invalid notebook path");
+function startPeonNotifier() {
+	if (!isPeonAvailable()) return () => {};
+	notifyPeon("SessionStart");
+	return useCliStore.subscribe((state, prev) => {
+		if (prev.isThinking && !state.isThinking) notifyPeon("Stop");
+		if (!prev.permissionPrompt && !!state.permissionPrompt || !prev.userQuestionPrompt && !!state.userQuestionPrompt || !prev.reviewGatePrompt && !!state.reviewGatePrompt) notifyPeon("Notification", { notificationType: "permission_prompt" });
+	});
+}
+/** Emit `SessionEnd`. Call on CLI exit. */
+function emitPeonSessionEnd() {
+	notifyPeon("SessionEnd");
 }
+//#endregion
+//#region src/agents/dynamicAgentTool.ts
 /**
-* Validate kernel name against whitelist (throws on invalid)
+* Create the create_dynamic_agent tool
+*
+* This tool allows the main agent to create and spawn a one-off agent at runtime
+* with a custom system prompt, model, and tool restrictions. Unlike agent_delegate,
+* this does not require a pre-defined agent markdown file.
+*
+* @param orchestrator - The SubagentOrchestrator instance
+* @param parentSessionId - Current session ID
+* @param backgroundManager - Optional background manager for async execution
+* @returns Tool definition compatible with agent tools
 */
-function validateKernelName(name) {
-	const result = validateJupyterKernelName(name);
-	if (!result.valid) throw new JupyterClientError(result.error || "Invalid kernel name");
-}
-var JupyterClient = class {
-	constructor(config) {
-		validateServerUrl(config.serverUrl);
-		this.serverUrl = config.serverUrl.replace(/\/$/, "");
-		this.token = config.token;
-	}
-	getHeaders() {
-		const headers = { "Content-Type": "application/json" };
-		if (this.token) headers["Authorization"] = `token ${this.token}`;
-		return headers;
-	}
-	async request(method, path, body) {
-		const url = `${this.serverUrl}${path}`;
-		const options = {
-			method,
-			headers: this.getHeaders()
-		};
-		if (body) options.body = JSON.stringify(body);
-		const response = await fetch(url, options);
-		if (!response.ok) {
-			let errorBody;
-			try {
-				errorBody = await response.json();
-			} catch {
-				errorBody = await response.text();
+function createDynamicAgentTool(orchestrator, parentSessionId, backgroundManager) {
+	return {
+		toolFn: async (args) => {
+			const params = args;
+			if (!params.task) throw new Error("create_dynamic_agent: task parameter is required");
+			if (!params.name) throw new Error("create_dynamic_agent: name parameter is required");
+			if (!/^[a-zA-Z0-9_-]+$/.test(params.name)) throw new Error("create_dynamic_agent: name must contain only alphanumeric characters, hyphens, and underscores");
+			if (!params.systemPrompt) throw new Error("create_dynamic_agent: systemPrompt parameter is required");
+			const deniedTools = [...params.deniedTools || [], ...ALWAYS_DENIED_FOR_AGENTS];
+			const agentDefinition = {
+				description: params.description || `Dynamic agent: ${params.name}`,
+				model: params.model || DEFAULT_AGENT_MODEL,
+				modelResolved: true,
+				systemPrompt: params.systemPrompt,
+				allowedTools: params.allowedTools,
+				deniedTools,
+				maxIterations: { ...DEFAULT_MAX_ITERATIONS },
+				defaultThoroughness: DEFAULT_THOROUGHNESS,
+				defaultVariables: params.variables,
+				retry: { ...DEFAULT_RETRY_CONFIG }
+			};
+			const spawnOptions = {
+				task: params.task,
+				agentName: params.name,
+				thoroughness: params.thoroughness,
+				variables: params.variables,
+				parentSessionId,
+				model: params.model,
+				allowedTools: params.allowedTools,
+				agentDefinition
+			};
+			if (params.run_in_background && backgroundManager) {
+				const jobId = backgroundManager.spawn({
+					...spawnOptions,
+					groupDescription: params.group_description
+				});
+				return `Dynamic background agent "${params.name}" started. Job ID: ${jobId}. Use check_agent_status tool with this job ID to retrieve results when ready.`;
 			}
-			throw new JupyterClientError(`Jupyter API error: ${response.status} ${response.statusText}`, response.status, errorBody);
-		}
-		if (response.status === 204) return {};
-		return response.json();
-	}
-	/**
-	* Check if the Jupyter server is running and accessible
-	*/
-	async checkStatus() {
-		return this.request("GET", "/api/status");
-	}
-	/**
-	* Get available kernel specifications
-	*/
-	async getKernelSpecs() {
-		return this.request("GET", "/api/kernelspecs");
-	}
-	/**
-	* List all active sessions
-	*/
-	async listSessions() {
-		return this.request("GET", "/api/sessions");
-	}
-	/**
-	* Start a new kernel session for a notebook
-	*/
-	async startSession(notebookPath, kernelName) {
-		validateNotebookPath(notebookPath);
-		const kernel = kernelName || "python3";
-		validateKernelName(kernel);
-		return this.request("POST", "/api/sessions", {
-			path: notebookPath,
-			type: "notebook",
-			name: notebookPath.split("/").pop() || "Untitled",
-			kernel: { name: kernel }
-		});
+			return (await orchestrator.delegateToAgent(spawnOptions)).summary;
+		},
+		toolSchema: {
+			name: "create_dynamic_agent",
+			description: `Create and spawn a one-off agent at runtime with a custom system prompt.
+
+Unlike agent_delegate (which uses pre-defined agents), this tool lets you compose a new agent on the fly with custom instructions, model, and tool restrictions.
+
+**When to use this tool:**
+- When no existing agent fits the task at hand
+- When you need a specialized agent with custom instructions for a one-off task
+- When you need fine-grained control over what tools the agent can access
+
+**Constraints:**
+- Dynamic agents CANNOT call agent_delegate or create_dynamic_agent (no recursive spawning)
+- Dynamic agents are ephemeral — they are not saved or reusable across sessions
+
+**Example uses:**
+- Create a security auditor agent with specific review criteria
+- Create a migration agent that follows a custom checklist
+- Create a specialized code generator with domain-specific instructions`,
+			parameters: {
+				type: "object",
+				properties: {
+					task: {
+						type: "string",
+						description: "Clear description of what you want the dynamic agent to accomplish."
+					},
+					name: {
+						type: "string",
+						description: "Unique name for this dynamic agent (e.g., \"security-auditor\", \"migration-helper\"). Used for logging and identification."
+					},
+					systemPrompt: {
+						type: "string",
+						description: "Custom system prompt for the agent. This defines the agent's role, capabilities, and constraints. Use $TASK to reference the task parameter."
+					},
+					description: {
+						type: "string",
+						description: "Short description of the agent's purpose (for logging)."
+					},
+					model: {
+						type: "string",
+						description: "Model to use for this agent (e.g., \"claude-sonnet-4-5-20250929\"). Defaults to the agent system default."
+					},
+					allowedTools: {
+						type: "array",
+						items: { type: "string" },
+						description: "Whitelist of tool name patterns the agent can use. Supports wildcards (e.g., \"file_*\", \"mcp__github__*\"). If omitted, all non-denied tools are available."
+					},
+					deniedTools: {
+						type: "array",
+						items: { type: "string" },
+						description: "Blacklist of tool name patterns the agent cannot use. agent_delegate and create_dynamic_agent are always denied."
+					},
+					thoroughness: {
+						type: "string",
+						enum: [
+							"quick",
+							"medium",
+							"very_thorough"
+						],
+						description: `How thoroughly to execute:
+- quick: Fast, 1-2 iterations
+- medium: Balanced, 3-5 iterations (default)
+- very_thorough: Comprehensive, 8-10+ iterations`
+					},
+					variables: {
+						type: "object",
+						additionalProperties: { type: "string" },
+						description: "Variables to substitute in the system prompt. For example: { \"DOMAIN\": \"auth\" } replaces $DOMAIN in the prompt."
+					},
+					run_in_background: {
+						type: "boolean",
+						description: "Run the agent in the background (non-blocking). Returns a job ID immediately. Use check_agent_status to poll for results."
+					},
+					group_description: {
+						type: "string",
+						description: "Short description of what this group of background agents is working on. Only needed for the first background agent in a group."
+					}
+				},
+				required: [
+					"task",
+					"name",
+					"systemPrompt"
+				]
+			}
+		}
+	};
+}
+//#endregion
+//#region src/tools/deferredToolRegistry.ts
+/**
+* Registry of tool schemas that are NOT loaded into the model's initial tool
+* list. The model sees only the names (via the system prompt directory) and
+* must call the `tool_search` meta-tool to load schemas on demand.
+*
+* This mirrors Claude Code's deferred-tool pattern. The win is large for
+* heavy MCP integrations (e.g. 41 GitHub MCP tools at ~250-350 tokens of
+* JSONSchema each = ~10-15k tokens per turn that's now ~1-1.5k of names).
+*/
+var DeferredToolRegistry = class {
+	constructor() {
+		this.byName = /* @__PURE__ */ new Map();
 	}
-	/**
-	* Get a session by ID
-	*/
-	async getSession(sessionId) {
-		return this.request("GET", `/api/sessions/${sessionId}`);
+	/** Replace registry contents with the supplied tools. Idempotent. */
+	register(tools) {
+		this.byName.clear();
+		for (const tool of tools) this.byName.set(tool.toolSchema.name, tool);
+		logger.debug(`[DeferredToolRegistry] Registered ${tools.length} deferred tool(s)`);
 	}
-	/**
-	* Stop a kernel session
-	*/
-	async stopSession(sessionId) {
-		await this.request("DELETE", `/api/sessions/${sessionId}`);
+	clear() {
+		this.byName.clear();
 	}
-	/**
-	* Get WebSocket URL for kernel channels
-	*/
-	getKernelWebSocketUrl(kernelId) {
-		const httpUrl = new URL(this.serverUrl);
-		const wsUrl = `${httpUrl.protocol === "https:" ? "wss:" : "ws:"}//${httpUrl.host}/api/kernels/${kernelId}/channels`;
-		if (this.token) return `${wsUrl}?token=${this.token}`;
-		return wsUrl;
+	size() {
+		return this.byName.size;
 	}
-	/**
-	* Generate a unique message ID for Jupyter protocol
-	*/
-	generateMsgId() {
-		return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+	has(name) {
+		return this.byName.has(name);
+	}
+	get(name) {
+		return this.byName.get(name);
+	}
+	getAll() {
+		return Array.from(this.byName.values());
+	}
+	/** Return tools whose names appear in the supplied list, in input order. */
+	getByNames(names) {
+		const found = [];
+		for (const name of names) {
+			const tool = this.byName.get(name);
+			if (tool) found.push(tool);
+		}
+		return found;
 	}
 	/**
-	* Execute code in a kernel using the Jupyter WebSocket protocol.
-	*
-	* Connects to the kernel's channels WebSocket, sends an execute_request,
-	* and collects outputs until the kernel returns to idle state.
-	*
-	* @param kernelId - The kernel ID to execute code in
-	* @param code - The code to execute
-	* @param timeoutMs - Execution timeout in milliseconds (default: 30000)
+	* Rank-search deferred tools by query terms. Name matches outrank
+	* description matches; exact substring on name wins ties.
 	*/
-	async executeCell(kernelId, code, timeoutMs = 3e4) {
-		const wsUrl = this.getKernelWebSocketUrl(kernelId);
-		const msgId = this.generateMsgId();
-		return new Promise((resolve, reject) => {
-			const outputs = [];
-			let executionCount = null;
-			let hasError = false;
-			let errorInfo;
-			const ws = new WsWebSocket(wsUrl);
-			const timeoutHandle = setTimeout(() => {
-				cleanup();
-				reject(new JupyterClientError(`Cell execution timed out after ${timeoutMs}ms`));
-			}, timeoutMs);
-			const cleanup = () => {
-				clearTimeout(timeoutHandle);
-				if (ws.readyState === WsWebSocket.OPEN || ws.readyState === WsWebSocket.CONNECTING) ws.close();
-			};
-			ws.on("error", (err) => {
-				cleanup();
-				reject(new JupyterClientError(`WebSocket error: ${err.message}`));
-			});
-			ws.on("open", () => {
-				const executeRequest = {
-					header: {
-						msg_id: msgId,
-						msg_type: "execute_request",
-						username: "b4m-cli",
-						session: this.generateMsgId(),
-						date: (/* @__PURE__ */ new Date()).toISOString(),
-						version: "5.3"
-					},
-					parent_header: {},
-					metadata: {},
-					content: {
-						code,
-						silent: false,
-						store_history: true,
-						user_expressions: {},
-						allow_stdin: false,
-						stop_on_error: true
-					},
-					buffers: [],
-					channel: "shell"
-				};
-				ws.send(JSON.stringify(executeRequest));
+	searchByKeywords(query, maxResults) {
+		const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+		if (terms.length === 0) return [];
+		const scored = [];
+		for (const tool of this.byName.values()) {
+			const name = tool.toolSchema.name.toLowerCase();
+			const desc = (tool.toolSchema.description || "").toLowerCase();
+			let score = 0;
+			for (const term of terms) {
+				if (name.includes(term)) score += 10;
+				if (desc.includes(term)) score += 1;
+			}
+			if (score > 0) scored.push({
+				tool,
+				score
 			});
-			ws.on("message", (data) => {
-				try {
-					const msg = JSON.parse(data.toString());
-					if (msg.parent_header?.msg_id !== msgId) return;
-					switch (msg.header?.msg_type || msg.msg_type) {
-						case "stream":
-							outputs.push({
-								output_type: "stream",
-								name: msg.content.name,
-								text: msg.content.text
-							});
-							break;
-						case "execute_result":
-							executionCount = msg.content.execution_count;
-							outputs.push({
-								output_type: "execute_result",
-								data: msg.content.data,
-								execution_count: msg.content.execution_count,
-								metadata: msg.content.metadata
-							});
-							break;
-						case "display_data":
-							outputs.push({
-								output_type: "display_data",
-								data: msg.content.data,
-								metadata: msg.content.metadata
-							});
-							break;
-						case "error":
-							hasError = true;
-							errorInfo = {
-								ename: msg.content.ename,
-								evalue: msg.content.evalue,
-								traceback: msg.content.traceback
-							};
-							outputs.push({
-								output_type: "error",
-								ename: msg.content.ename,
-								evalue: msg.content.evalue,
-								traceback: msg.content.traceback
-							});
-							break;
-						case "execute_reply":
-							if (msg.content.status === "ok" || msg.content.status === "error") {
-								if (msg.content.execution_count !== void 0) executionCount = msg.content.execution_count;
-								cleanup();
-								resolve({
-									success: !hasError,
-									outputs,
-									executionCount,
-									error: errorInfo
-								});
-							}
-							break;
-						case "status": break;
-					}
-				} catch {}
-			});
-			ws.on("close", () => {
-				clearTimeout(timeoutHandle);
-			});
-		});
-	}
-	/**
-	* @deprecated Use executeCell instead. This method exists for backwards compatibility.
-	*/
-	async executeCode(kernelId, code) {
-		return this.executeCell(kernelId, code);
-	}
-	/**
-	* Interrupt a running kernel
-	*/
-	async interruptKernel(kernelId) {
-		await this.request("POST", `/api/kernels/${kernelId}/interrupt`);
+		}
+		scored.sort((a, b) => b.score - a.score);
+		return scored.slice(0, maxResults).map((s) => s.tool);
 	}
-	/**
-	* Restart a kernel
-	*/
-	async restartKernel(kernelId) {
-		return this.request("POST", `/api/kernels/${kernelId}/restart`);
+	/** Return the directory entries used to render the system-prompt reminder. */
+	getDirectoryNames() {
+		return Array.from(this.byName.keys()).sort();
 	}
 };
-/**
-* Create a JupyterClient from environment variables or config
-*/
-function createJupyterClientFromEnv() {
-	const serverUrl = process.env.JUPYTER_SERVER_URL;
-	const token = process.env.JUPYTER_TOKEN;
-	if (!serverUrl) return null;
-	return new JupyterClient({
-		serverUrl,
-		token
-	});
-}
+const deferredToolRegistry = new DeferredToolRegistry();
 //#endregion
-//#region src/commands/executeNotebookHandler.ts
+//#region src/tools/toolSearchTool.ts
 /**
-* Jupyter Notebook Execution Handler
-*
-* Handles the jupyter_execute_notebook Keep command.
-* Orchestrates cell-by-cell execution of a notebook via local Jupyter server.
+* Default number of tools returned for a keyword search. Matches Claude
+* Code's ToolSearch convention. 5 keeps the response payload small while
+* surfacing enough alternatives for the model to refine its query.
 */
+const DEFAULT_MAX_RESULTS = 5;
 /**
-* Zod schema for validating execute notebook parameters.
-* Replaces unsafe `as` casts with proper runtime validation.
+* Runtime validation for tool_search params. The LLM produces these
+* values, so we validate at this boundary rather than trusting the
+* shape. Coerces `max_results` from string→number for models that emit
+* numeric-looking strings.
 */
-const ExecuteNotebookParams = z.object({
-	notebookJson: z.string().min(1, "notebookJson is required"),
-	sessionId: z.string().min(1, "sessionId is required"),
-	kernelName: z.string().default("python3"),
-	timeoutPerCell: z.number().default(3e4)
+const ToolSearchParamsSchema = z.object({
+	query: z.string().min(1, "query must be a non-empty string"),
+	max_results: z.coerce.number().int().min(1).max(20).optional()
 });
 /**
-* Get cell source as string (handles both string and string[] formats).
+* Parse the query string. Two forms:
+*   - `select:name1,name2,...` — exact-name selection
+*   - free text — keyword search across name + description
 */
-function getCellSource(cell) {
-	return Array.isArray(cell.source) ? cell.source.join("") : cell.source;
+function parseQuery(query) {
+	const trimmed = query.trim();
+	const selectMatch = trimmed.match(/^select:(.+)$/i);
+	if (selectMatch) return {
+		mode: "select",
+		names: selectMatch[1].split(",").map((n) => n.trim()).filter((n) => n.length > 0)
+	};
+	return {
+		mode: "search",
+		text: trimmed
+	};
 }
 /**
-* Execute a Jupyter notebook cell by cell.
+* Format the loaded-tools response. Mirrors Claude Code's convention:
+* one <function>{...}</function> line per matched tool. The model has
+* already seen this format in its tool-registration system messages, so
+* it parses without additional explanation.
 *
-* @param params - Validated notebook execution parameters
-* @param deps - Dependencies (jupyter client, websocket manager, logger)
-* @returns Execution result with success status and executed notebook
+* Note: the schemas are *also* injected into context.tools by the caller,
+* so on the next iteration the model gets them as native tool definitions.
+* The text response here is for in-turn awareness and audit trail.
 */
-async function executeNotebook(params, deps) {
-	const { jupyterClient, wsManager, logger, requestId } = deps;
-	const { notebookJson, sessionId, kernelName, timeoutPerCell } = ExecuteNotebookParams.parse(params);
-	let notebook;
-	try {
-		notebook = JSON.parse(notebookJson);
-		if (!notebook.cells || !Array.isArray(notebook.cells)) throw new Error("Invalid notebook: missing cells array");
-	} catch (parseErr) {
-		throw new Error(`Failed to parse notebook JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
-	}
-	const totalCodeCells = notebook.cells.filter((c) => c.cell_type === "code").length;
-	logger.info(`[Keep] Starting notebook execution: ${totalCodeCells} code cells, kernel: ${kernelName}`);
-	const tempNotebookPath = `/tmp/b4m-notebook-${randomUUID()}.ipynb`;
-	await promises.writeFile(tempNotebookPath, notebookJson, "utf-8");
-	let jupyterSession = null;
-	let cellsExecuted = 0;
-	let cellsFailed = 0;
-	try {
-		logger.info(`[Keep] Starting Jupyter kernel: ${kernelName}`);
-		jupyterSession = await jupyterClient.startSession(tempNotebookPath, kernelName);
-		const kernelId = jupyterSession.kernel.id;
-		const jupyterSessionId = jupyterSession.id;
-		logger.info(`[Keep] Kernel started: session=${jupyterSessionId}, kernel=${kernelId}`);
-		let codeCellIndex = 0;
-		for (let i = 0; i < notebook.cells.length; i++) {
-			const cell = notebook.cells[i];
-			if (cell.cell_type !== "code") continue;
-			const cellCode = getCellSource(cell);
-			if (!cellCode.trim()) {
-				codeCellIndex++;
-				continue;
-			}
-			logger.info(`[Keep] Executing cell ${codeCellIndex + 1}/${totalCodeCells}`);
-			wsManager?.send({
-				action: "jupyter_cell_output",
-				requestId,
-				sessionId,
-				jupyterSessionId,
-				cellIndex: codeCellIndex,
-				outputType: "stream",
-				content: {
-					text: `Executing cell ${codeCellIndex + 1}/${totalCodeCells}...`,
-					name: "stdout"
-				},
-				executionCount: null,
-				isComplete: false
-			});
-			try {
-				const cellResult = await jupyterClient.executeCell(kernelId, cellCode, timeoutPerCell);
-				cell.outputs = cellResult.outputs;
-				cell.execution_count = cellResult.executionCount;
-				if (cellResult.success) {
-					cellsExecuted++;
-					wsManager?.send({
-						action: "jupyter_cell_output",
-						requestId,
-						sessionId,
-						jupyterSessionId,
-						cellIndex: codeCellIndex,
-						outputType: "execute_result",
-						content: {
-							text: cellResult.outputs.map((o) => {
-								if (o.text) return Array.isArray(o.text) ? o.text.join("") : o.text;
-								if (o.data && typeof o.data === "object" && "text/plain" in o.data) {
-									const textPlain = o.data["text/plain"];
-									return Array.isArray(textPlain) ? textPlain.join("") : String(textPlain);
-								}
-								return "";
-							}).join(""),
-							data: cellResult.outputs.find((o) => o.data)?.data
-						},
-						executionCount: cellResult.executionCount,
-						isComplete: true
-					});
-				} else {
-					cellsFailed++;
-					wsManager?.send({
-						action: "jupyter_cell_output",
-						requestId,
-						sessionId,
-						jupyterSessionId,
-						cellIndex: codeCellIndex,
-						outputType: "error",
-						content: {
-							ename: cellResult.error?.ename || "ExecutionError",
-							evalue: cellResult.error?.evalue || "Cell execution failed",
-							traceback: cellResult.error?.traceback || []
-						},
-						executionCount: cellResult.executionCount,
-						isComplete: true
-					});
-					logger.warn(`[Keep] Cell ${codeCellIndex + 1} failed: ${cellResult.error?.ename}: ${cellResult.error?.evalue}`);
-				}
-			} catch (cellErr) {
-				cellsFailed++;
-				const errMsg = cellErr instanceof Error ? cellErr.message : String(cellErr);
-				wsManager?.send({
-					action: "jupyter_cell_output",
-					requestId,
-					sessionId,
-					jupyterSessionId,
-					cellIndex: codeCellIndex,
-					outputType: "error",
-					content: {
-						ename: "ExecutionError",
-						evalue: errMsg,
-						traceback: []
-					},
-					executionCount: null,
-					isComplete: true
-				});
-				logger.error(`[Keep] Cell ${codeCellIndex + 1} threw error: ${errMsg}`);
-			}
-			codeCellIndex++;
-		}
-		return {
-			success: cellsFailed === 0,
-			cellsExecuted,
-			cellsFailed,
-			totalCodeCells,
-			executedNotebook: JSON.stringify(notebook)
+function renderToolsBlock(tools) {
+	if (tools.length === 0) return "";
+	return `<functions>\n${tools.map((tool) => {
+		const schema = {
+			description: tool.toolSchema.description,
+			name: tool.toolSchema.name,
+			parameters: tool.toolSchema.parameters
 		};
-	} finally {
-		if (jupyterSession) try {
-			logger.info(`[Keep] Stopping Jupyter session: ${jupyterSession.id}`);
-			await jupyterClient.stopSession(jupyterSession.id);
-		} catch (stopErr) {
-			logger.warn(`[Keep] Failed to stop session: ${stopErr instanceof Error ? stopErr.message : String(stopErr)}`);
+		return `<function>${JSON.stringify(schema)}</function>`;
+	}).join("\n")}\n</functions>`;
+}
+/**
+* Build the tool_search meta-tool. The returned tool has a closure over
+* the supplied `toolListAccessor`, which it uses to push newly-resolved
+* tool schemas into the live agent context.
+*
+* Idempotent: re-loading a tool that's already in the context is a no-op.
+*/
+function createToolSearchTool(toolListAccessor) {
+	return {
+		toolSchema: {
+			name: "tool_search",
+			description: "Fetches full schema definitions for deferred tools so they can be called. Deferred tools appear by name only in a system reminder; their parameter schemas are NOT loaded by default. Use this tool to load schemas on demand. Query forms: 'select:name1,name2' for exact selection, or free-text keywords to search by name and description. Once a tool's schema is returned, it becomes callable in subsequent turns.",
+			parameters: {
+				type: "object",
+				properties: {
+					query: {
+						type: "string",
+						description: "Either 'select:<comma-separated names>' to fetch specific tools, or free-text keywords (e.g. 'github pull request') to rank-search deferred tools."
+					},
+					max_results: {
+						type: "number",
+						description: `Maximum number of tools to return for keyword search. Defaults to ${DEFAULT_MAX_RESULTS}. Ignored for 'select:' queries.`
+					}
+				},
+				required: ["query"]
+			}
+		},
+		toolFn: async (params) => {
+			const parsedParams = ToolSearchParamsSchema.safeParse(params ?? {});
+			if (!parsedParams.success) {
+				const issue = parsedParams.error.issues[0];
+				return `tool_search: invalid parameters — ${issue.path.join(".") || "params"}: ${issue.message}`;
+			}
+			const { query, max_results } = parsedParams.data;
+			const parsed = parseQuery(query);
+			let matched;
+			let unmatched = [];
+			if (parsed.mode === "select") {
+				matched = deferredToolRegistry.getByNames(parsed.names);
+				const foundNames = new Set(matched.map((t) => t.toolSchema.name));
+				unmatched = parsed.names.filter((n) => !foundNames.has(n));
+			} else {
+				const max = max_results ?? DEFAULT_MAX_RESULTS;
+				matched = deferredToolRegistry.searchByKeywords(parsed.text, max);
+			}
+			if (matched.length === 0) return parsed.mode === "select" ? `tool_search: no deferred tools matched ${parsed.names.join(", ")}. Use a free-text query to search.` : `tool_search: no deferred tools matched query "${parsed.text}".`;
+			const liveTools = toolListAccessor();
+			const liveNames = new Set(liveTools.map((t) => t.toolSchema.name));
+			let added = 0;
+			for (const tool of matched) if (!liveNames.has(tool.toolSchema.name)) {
+				liveTools.push(tool);
+				added++;
+			}
+			logger.debug(`[tool_search] query="${query}" matched=${matched.length} added=${added} alreadyLoaded=${matched.length - added}`);
+			const block = renderToolsBlock(matched);
+			return `${`Loaded ${added} new tool schema(s)${added < matched.length ? ` (${matched.length - added} already loaded)` : ""}. These are now callable in your next message.${unmatched.length > 0 ? `\n\nNot found: ${unmatched.join(", ")}` : ""}`}\n\n${block}`;
 		}
-		try {
-			await promises.unlink(tempNotebookPath);
-		} catch {}
-	}
+	};
 }
 //#endregion
-//#region src/llm/NotifyingLlmBackend.ts
+//#region src/features/FeatureModuleRegistry.ts
 /**
-* LLM backend wrapper that injects background agent notifications
-* into the message array before each completion call.
+* Manages the lifecycle of opt-in CLI feature modules.
 *
-* When a background agent completes (or fails), the notification
-* appears as a system message so the main agent naturally sees it
-* in context — no polling required.
+* Created during bootstrap, modules are conditionally registered based on config,
+* then the registry's outputs are fed into tool generation and prompt building.
 */
-var NotifyingLlmBackend = class {
-	constructor(inner, backgroundManager) {
-		this.inner = inner;
-		this.backgroundManager = backgroundManager;
+var FeatureModuleRegistry = class {
+	constructor() {
+		this.modules = [];
 	}
-	get currentModel() {
-		return this.inner.currentModel;
+	/** Register a feature module */
+	register(module) {
+		if (this.modules.some((m) => m.name === module.name)) throw new Error(`Feature module '${module.name}' is already registered`);
+		this.modules.push(module);
 	}
-	set currentModel(model) {
-		this.inner.currentModel = model;
+	/** Collect all tools from all registered modules */
+	getAllTools() {
+		return this.modules.flatMap((m) => m.getTools());
 	}
-	async complete(model, messages, options, callback) {
-		const notifications = this.backgroundManager.drainNotifications();
-		let effectiveMessages = messages;
-		if (notifications.length > 0) {
-			const notificationMessage = {
-				role: "user",
-				content: `[System Notification]\n\n${notifications.join("\n\n---\n\n")}\n\nPlease acknowledge these background agent results and incorporate them into your current work.`
-			};
-			effectiveMessages = [...messages, notificationMessage];
+	/** Get all tool names from all registered modules */
+	getAllToolNames() {
+		return this.getAllTools().map((t) => t.toolSchema.name);
+	}
+	/** Build combined system prompt section from all modules */
+	getSystemPromptSections() {
+		const sections = this.modules.map((m) => m.getSystemPromptSection()).filter((s) => s.length > 0);
+		return sections.length > 0 ? "\n\n" + sections.join("\n\n") : "";
+	}
+	/** Register all WS handlers from all modules */
+	registerAllWsHandlers(wsManager) {
+		for (const module of this.modules) module.registerWsHandlers?.(wsManager);
+	}
+	/** Collect all slash commands from all registered modules */
+	getAllCommands() {
+		return this.modules.flatMap((m) => m.getCommands?.() ?? []);
+	}
+	/** Try to execute a slash command. Returns true if handled. */
+	executeCommand(name, args) {
+		for (const module of this.modules) {
+			const command = (module.getCommands?.() ?? []).find((c) => c.name === name);
+			if (command) {
+				command.execute(args);
+				return true;
+			}
 		}
-		return this.inner.complete(model, effectiveMessages, options, callback);
+		return false;
 	}
-	pushToolMessages(messages, tool, result) {
-		return this.inner.pushToolMessages(messages, tool, result);
+	/** Cleanup all modules */
+	disposeAll() {
+		for (const module of this.modules) module.dispose?.();
 	}
-	async getModelInfo() {
-		return this.inner.getModelInfo();
+	/** Get names of all registered modules */
+	getModuleNames() {
+		return this.modules.map((m) => m.name);
+	}
+	/** Check if any modules are registered */
+	get hasModules() {
+		return this.modules.length > 0;
 	}
 };
 //#endregion
-//#region src/llm/MultiLlmBackend.ts
+//#region src/features/tavern/TavernService.ts
 /**
-* Routes completions between B4M server and a local Ollama instance
-* based on the selected model's backend type.
+* HTTP implementation of ITavernService using the shared ApiClient.
+*
+* Each method maps to one /api/tavern/* endpoint.
+* Pure transport — no business logic.
 */
-var MultiLlmBackend = class {
-	constructor(serverBackend, ollamaBackend, serverModels, ollamaModels, initialModel) {
-		this.serverBackend = serverBackend;
-		this.ollamaBackend = ollamaBackend;
-		this.serverModels = serverModels;
-		this.ollamaModels = ollamaModels;
-		this.currentModel = initialModel;
-		this.ollamaModelIds = new Set(ollamaModels.map((m) => m.id));
+var TavernService = class {
+	constructor(apiClient) {
+		this.apiClient = apiClient;
 	}
-	get activeBackend() {
-		return this.ollamaModelIds.has(this.currentModel) ? this.ollamaBackend : this.serverBackend;
+	async listAgents() {
+		return this.apiClient.get("/api/agents?limit=100");
 	}
-	async complete(model, messages, options, callback) {
-		return (this.ollamaModelIds.has(model) ? this.ollamaBackend : this.serverBackend).complete(model, messages, options, callback);
+	async createAgent(request) {
+		return this.apiClient.post("/api/agents", request);
 	}
-	pushToolMessages(messages, tool, result, thinkingBlocks) {
-		this.activeBackend.pushToolMessages(messages, tool, result, thinkingBlocks);
+	async updateAgent(agentId, request) {
+		return this.apiClient.put(`/api/agents/${encodeURIComponent(agentId)}`, request);
 	}
-	async getModelInfo() {
-		return [...this.serverModels, ...this.ollamaModels];
+	async deleteAgent(agentId) {
+		await this.apiClient.delete(`/api/agents/${encodeURIComponent(agentId)}`);
+	}
+	async mentionAgent(agentName, message, config) {
+		return this.apiClient.post("/api/tavern/mention", {
+			agentName,
+			message,
+			config
+		});
+	}
+	async listQuests() {
+		return this.apiClient.get("/api/tavern/quests");
+	}
+	async postQuest(request) {
+		return this.apiClient.post("/api/tavern/quests", request);
+	}
+	async deleteQuest(questId) {
+		await this.apiClient.delete(`/api/tavern/quests`, { data: { questId } });
+	}
+	async getAgentNotebook(agentId, limit = 50) {
+		return this.apiClient.get(`/api/tavern/agent-notebook?agentId=${encodeURIComponent(agentId)}&limit=${limit}`);
+	}
+	async listGates() {
+		return this.apiClient.get("/api/tavern/gates");
+	}
+	async resolveGate(gateId, resolution) {
+		return this.apiClient.post("/api/tavern/gate-resolve", {
+			gateId,
+			resolution
+		});
+	}
+	async toggleHeartbeats(enabled) {
+		return this.apiClient.post("/api/tavern/toggle-heartbeats", { enabled });
+	}
+	async triggerHeartbeat(config) {
+		return this.apiClient.post("/api/tavern/trigger-heartbeat", { config });
+	}
+	async abortHeartbeats() {
+		await this.apiClient.post("/api/tavern/abort-heartbeats", { abort: true });
+	}
+	async getQuestPlan(planId) {
+		return this.apiClient.get(`/api/quest-master-plans/${encodeURIComponent(planId)}`);
+	}
+	async updateReviewGate(planId, questId, subQuestId, reviewStatus, reviewNote) {
+		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/review-gate`, {
+			questId,
+			subQuestId,
+			reviewStatus,
+			reviewNote
+		});
+	}
+	async updateSubQuestProgress(planId, questId, subQuestId, updates) {
+		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/subquest-progress`, {
+			questId,
+			subQuestId,
+			...updates
+		});
+	}
+	async updateHandoff(planId, handoff) {
+		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/handoff`, handoff);
 	}
 };
 //#endregion
-//#region src/utils/peonNotifier.ts
+//#region src/features/tavern/types.ts
 /**
-* peon-ping notifier — native b4m adapter for peon-ping (https://peonping.com).
-*
-* peon-ping plays game-character voice lines + on-screen banners when an AI
-* coding agent finishes a turn or needs attention. It consumes a small JSON
-* event on stdin (the "CESP" hook contract shared by Claude Code and every
-* peon-ping adapter):
-*
-*   { hook_event_name, notification_type, cwd, session_id, permission_mode }
-*
-* This module is the b4m CLI's equivalent of the shell adapters peon-ping
-* ships for other IDEs (see `adapters/openclaw.sh`), except it runs in-process
-* and is wired directly to the CLI's lifecycle via a store subscription.
-*
-* Behaviour is auto-detect: if a `peon.sh` is found on disk it is enabled,
-* otherwise every call is a silent no-op. Set `B4M_PEON_PING=0` to force it
-* off even when installed.
-*/
-/**
-* Resolve the path to `peon.sh`, checking the same locations peon-ping's own
-* adapters use. Returns null when peon-ping is not installed. Resolved once and
-* cached: `null` means "looked and found nothing".
-*/
-let resolvedScript;
-function findPeonScript() {
-	if (resolvedScript !== void 0) return resolvedScript;
-	const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(homedir(), ".claude");
-	resolvedScript = [
-		process.env.CLAUDE_PEON_DIR ? path.join(process.env.CLAUDE_PEON_DIR, "peon.sh") : null,
-		path.join(claudeDir, "hooks", "peon-ping", "peon.sh"),
-		path.join(homedir(), ".openpeon", "peon.sh")
-	].filter((p) => p !== null).find((p) => existsSync(p)) ?? null;
-	return resolvedScript;
-}
-/** Explicit off-switch via env, even when peon-ping is installed. */
-function isDisabledByEnv() {
-	const v = process.env.B4M_PEON_PING?.toLowerCase();
-	return v === "0" || v === "false" || v === "off";
-}
-/** True when peon-ping is installed and not disabled. */
-function isPeonAvailable() {
-	return !isDisabledByEnv() && findPeonScript() !== null;
-}
-/**
-* Fire a single peon-ping event. Fire-and-forget and fail-safe: the child is
-* detached and unref'd, all output is discarded, and any spawn error is logged
-* to the debug log but never surfaced — the CLI must never break because of a
-* missing or misbehaving peon install.
-*/
-function notifyPeon(event, options = {}) {
-	if (isDisabledByEnv()) return;
-	const script = findPeonScript();
-	if (!script) return;
-	const payload = JSON.stringify({
-		hook_event_name: event,
-		notification_type: options.notificationType ?? "",
-		cwd: process.cwd(),
-		session_id: useCliStore.getState().session?.id ?? `b4m-${process.pid}`,
-		permission_mode: ""
-	});
-	try {
-		const child = spawn("bash", [script], {
-			stdio: [
-				"pipe",
-				"ignore",
-				"ignore"
-			],
-			detached: true
-		});
-		child.on("error", (err) => logger.debug(`peon-ping spawn failed: ${err.message}`));
-		child.stdin?.on("error", () => {});
-		child.stdin?.end(payload);
-		child.unref();
-	} catch (err) {
-		logger.debug(`peon-ping notify error: ${err.message}`);
-	}
-}
-/**
-* Subscribe to CLI lifecycle and emit peon-ping events:
-* - `Stop` when the agent finishes a turn (isThinking true → false)
-* - `Notification` (permission_prompt) when a permission / user-question /
-*   review-gate prompt first appears and the user needs to act
-*
-* Fires `SessionStart` immediately. Returns an unsubscribe function; call it
-* (and pass `emitSessionEnd`) on exit to emit `SessionEnd`.
-*/
-function startPeonNotifier() {
-	if (!isPeonAvailable()) return () => {};
-	notifyPeon("SessionStart");
-	return useCliStore.subscribe((state, prev) => {
-		if (prev.isThinking && !state.isThinking) notifyPeon("Stop");
-		if (!prev.permissionPrompt && !!state.permissionPrompt || !prev.userQuestionPrompt && !!state.userQuestionPrompt || !prev.reviewGatePrompt && !!state.reviewGatePrompt) notifyPeon("Notification", { notificationType: "permission_prompt" });
-	});
-}
-/** Emit `SessionEnd`. Call on CLI exit. */
-function emitPeonSessionEnd() {
-	notifyPeon("SessionEnd");
-}
-//#endregion
-//#region src/agents/dynamicAgentTool.ts
-/**
-* Create the create_dynamic_agent tool
-*
-* This tool allows the main agent to create and spawn a one-off agent at runtime
-* with a custom system prompt, model, and tool restrictions. Unlike agent_delegate,
-* this does not require a pre-defined agent markdown file.
-*
-* @param orchestrator - The SubagentOrchestrator instance
-* @param parentSessionId - Current session ID
-* @param backgroundManager - Optional background manager for async execution
-* @returns Tool definition compatible with agent tools
-*/
-function createDynamicAgentTool(orchestrator, parentSessionId, backgroundManager) {
-	return {
-		toolFn: async (args) => {
-			const params = args;
-			if (!params.task) throw new Error("create_dynamic_agent: task parameter is required");
-			if (!params.name) throw new Error("create_dynamic_agent: name parameter is required");
-			if (!/^[a-zA-Z0-9_-]+$/.test(params.name)) throw new Error("create_dynamic_agent: name must contain only alphanumeric characters, hyphens, and underscores");
-			if (!params.systemPrompt) throw new Error("create_dynamic_agent: systemPrompt parameter is required");
-			const deniedTools = [...params.deniedTools || [], ...ALWAYS_DENIED_FOR_AGENTS];
-			const agentDefinition = {
-				description: params.description || `Dynamic agent: ${params.name}`,
-				model: params.model || DEFAULT_AGENT_MODEL,
-				modelResolved: true,
-				systemPrompt: params.systemPrompt,
-				allowedTools: params.allowedTools,
-				deniedTools,
-				maxIterations: { ...DEFAULT_MAX_ITERATIONS },
-				defaultThoroughness: DEFAULT_THOROUGHNESS,
-				defaultVariables: params.variables,
-				retry: { ...DEFAULT_RETRY_CONFIG }
-			};
-			const spawnOptions = {
-				task: params.task,
-				agentName: params.name,
-				thoroughness: params.thoroughness,
-				variables: params.variables,
-				parentSessionId,
-				model: params.model,
-				allowedTools: params.allowedTools,
-				agentDefinition
-			};
-			if (params.run_in_background && backgroundManager) {
-				const jobId = backgroundManager.spawn({
-					...spawnOptions,
-					groupDescription: params.group_description
-				});
-				return `Dynamic background agent "${params.name}" started. Job ID: ${jobId}. Use check_agent_status tool with this job ID to retrieve results when ready.`;
-			}
-			return (await orchestrator.delegateToAgent(spawnOptions)).summary;
-		},
-		toolSchema: {
-			name: "create_dynamic_agent",
-			description: `Create and spawn a one-off agent at runtime with a custom system prompt.
-
-Unlike agent_delegate (which uses pre-defined agents), this tool lets you compose a new agent on the fly with custom instructions, model, and tool restrictions.
-
-**When to use this tool:**
-- When no existing agent fits the task at hand
-- When you need a specialized agent with custom instructions for a one-off task
-- When you need fine-grained control over what tools the agent can access
-
-**Constraints:**
-- Dynamic agents CANNOT call agent_delegate or create_dynamic_agent (no recursive spawning)
-- Dynamic agents are ephemeral — they are not saved or reusable across sessions
-
-**Example uses:**
-- Create a security auditor agent with specific review criteria
-- Create a migration agent that follows a custom checklist
-- Create a specialized code generator with domain-specific instructions`,
-			parameters: {
-				type: "object",
-				properties: {
-					task: {
-						type: "string",
-						description: "Clear description of what you want the dynamic agent to accomplish."
-					},
-					name: {
-						type: "string",
-						description: "Unique name for this dynamic agent (e.g., \"security-auditor\", \"migration-helper\"). Used for logging and identification."
-					},
-					systemPrompt: {
-						type: "string",
-						description: "Custom system prompt for the agent. This defines the agent's role, capabilities, and constraints. Use $TASK to reference the task parameter."
-					},
-					description: {
-						type: "string",
-						description: "Short description of the agent's purpose (for logging)."
-					},
-					model: {
-						type: "string",
-						description: "Model to use for this agent (e.g., \"claude-sonnet-4-5-20250929\"). Defaults to the agent system default."
-					},
-					allowedTools: {
-						type: "array",
-						items: { type: "string" },
-						description: "Whitelist of tool name patterns the agent can use. Supports wildcards (e.g., \"file_*\", \"mcp__github__*\"). If omitted, all non-denied tools are available."
-					},
-					deniedTools: {
-						type: "array",
-						items: { type: "string" },
-						description: "Blacklist of tool name patterns the agent cannot use. agent_delegate and create_dynamic_agent are always denied."
-					},
-					thoroughness: {
-						type: "string",
-						enum: [
-							"quick",
-							"medium",
-							"very_thorough"
-						],
-						description: `How thoroughly to execute:
-- quick: Fast, 1-2 iterations
-- medium: Balanced, 3-5 iterations (default)
-- very_thorough: Comprehensive, 8-10+ iterations`
-					},
-					variables: {
-						type: "object",
-						additionalProperties: { type: "string" },
-						description: "Variables to substitute in the system prompt. For example: { \"DOMAIN\": \"auth\" } replaces $DOMAIN in the prompt."
-					},
-					run_in_background: {
-						type: "boolean",
-						description: "Run the agent in the background (non-blocking). Returns a job ID immediately. Use check_agent_status to poll for results."
-					},
-					group_description: {
-						type: "string",
-						description: "Short description of what this group of background agents is working on. Only needed for the first background agent in a group."
-					}
-				},
-				required: [
-					"task",
-					"name",
-					"systemPrompt"
-				]
-			}
-		}
-	};
-}
-//#endregion
-//#region src/tools/deferredToolRegistry.ts
-/**
-* Registry of tool schemas that are NOT loaded into the model's initial tool
-* list. The model sees only the names (via the system prompt directory) and
-* must call the `tool_search` meta-tool to load schemas on demand.
-*
-* This mirrors Claude Code's deferred-tool pattern. The win is large for
-* heavy MCP integrations (e.g. 41 GitHub MCP tools at ~250-350 tokens of
-* JSONSchema each = ~10-15k tokens per turn that's now ~1-1.5k of names).
-*/
-var DeferredToolRegistry = class {
-	constructor() {
-		this.byName = /* @__PURE__ */ new Map();
-	}
-	/** Replace registry contents with the supplied tools. Idempotent. */
-	register(tools) {
-		this.byName.clear();
-		for (const tool of tools) this.byName.set(tool.toolSchema.name, tool);
-		logger.debug(`[DeferredToolRegistry] Registered ${tools.length} deferred tool(s)`);
-	}
-	clear() {
-		this.byName.clear();
-	}
-	size() {
-		return this.byName.size;
-	}
-	has(name) {
-		return this.byName.has(name);
-	}
-	get(name) {
-		return this.byName.get(name);
-	}
-	getAll() {
-		return Array.from(this.byName.values());
-	}
-	/** Return tools whose names appear in the supplied list, in input order. */
-	getByNames(names) {
-		const found = [];
-		for (const name of names) {
-			const tool = this.byName.get(name);
-			if (tool) found.push(tool);
-		}
-		return found;
-	}
-	/**
-	* Rank-search deferred tools by query terms. Name matches outrank
-	* description matches; exact substring on name wins ties.
-	*/
-	searchByKeywords(query, maxResults) {
-		const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
-		if (terms.length === 0) return [];
-		const scored = [];
-		for (const tool of this.byName.values()) {
-			const name = tool.toolSchema.name.toLowerCase();
-			const desc = (tool.toolSchema.description || "").toLowerCase();
-			let score = 0;
-			for (const term of terms) {
-				if (name.includes(term)) score += 10;
-				if (desc.includes(term)) score += 1;
-			}
-			if (score > 0) scored.push({
-				tool,
-				score
-			});
-		}
-		scored.sort((a, b) => b.score - a.score);
-		return scored.slice(0, maxResults).map((s) => s.tool);
-	}
-	/** Return the directory entries used to render the system-prompt reminder. */
-	getDirectoryNames() {
-		return Array.from(this.byName.keys()).sort();
-	}
-};
-const deferredToolRegistry = new DeferredToolRegistry();
-//#endregion
-//#region src/tools/toolSearchTool.ts
-/**
-* Default number of tools returned for a keyword search. Matches Claude
-* Code's ToolSearch convention. 5 keeps the response payload small while
-* surfacing enough alternatives for the model to refine its query.
-*/
-const DEFAULT_MAX_RESULTS = 5;
-/**
-* Runtime validation for tool_search params. The LLM produces these
-* values, so we validate at this boundary rather than trusting the
-* shape. Coerces `max_results` from string→number for models that emit
-* numeric-looking strings.
-*/
-const ToolSearchParamsSchema = z.object({
-	query: z.string().min(1, "query must be a non-empty string"),
-	max_results: z.coerce.number().int().min(1).max(20).optional()
-});
-/**
-* Parse the query string. Two forms:
-*   - `select:name1,name2,...` — exact-name selection
-*   - free text — keyword search across name + description
-*/
-function parseQuery(query) {
-	const trimmed = query.trim();
-	const selectMatch = trimmed.match(/^select:(.+)$/i);
-	if (selectMatch) return {
-		mode: "select",
-		names: selectMatch[1].split(",").map((n) => n.trim()).filter((n) => n.length > 0)
-	};
-	return {
-		mode: "search",
-		text: trimmed
-	};
-}
-/**
-* Format the loaded-tools response. Mirrors Claude Code's convention:
-* one <function>{...}</function> line per matched tool. The model has
-* already seen this format in its tool-registration system messages, so
-* it parses without additional explanation.
-*
-* Note: the schemas are *also* injected into context.tools by the caller,
-* so on the next iteration the model gets them as native tool definitions.
-* The text response here is for in-turn awareness and audit trail.
-*/
-function renderToolsBlock(tools) {
-	if (tools.length === 0) return "";
-	return `<functions>\n${tools.map((tool) => {
-		const schema = {
-			description: tool.toolSchema.description,
-			name: tool.toolSchema.name,
-			parameters: tool.toolSchema.parameters
-		};
-		return `<function>${JSON.stringify(schema)}</function>`;
-	}).join("\n")}\n</functions>`;
-}
-/**
-* Build the tool_search meta-tool. The returned tool has a closure over
-* the supplied `toolListAccessor`, which it uses to push newly-resolved
-* tool schemas into the live agent context.
-*
-* Idempotent: re-loading a tool that's already in the context is a no-op.
-*/
-function createToolSearchTool(toolListAccessor) {
-	return {
-		toolSchema: {
-			name: "tool_search",
-			description: "Fetches full schema definitions for deferred tools so they can be called. Deferred tools appear by name only in a system reminder; their parameter schemas are NOT loaded by default. Use this tool to load schemas on demand. Query forms: 'select:name1,name2' for exact selection, or free-text keywords to search by name and description. Once a tool's schema is returned, it becomes callable in subsequent turns.",
-			parameters: {
-				type: "object",
-				properties: {
-					query: {
-						type: "string",
-						description: "Either 'select:<comma-separated names>' to fetch specific tools, or free-text keywords (e.g. 'github pull request') to rank-search deferred tools."
-					},
-					max_results: {
-						type: "number",
-						description: `Maximum number of tools to return for keyword search. Defaults to ${DEFAULT_MAX_RESULTS}. Ignored for 'select:' queries.`
-					}
-				},
-				required: ["query"]
-			}
-		},
-		toolFn: async (params) => {
-			const parsedParams = ToolSearchParamsSchema.safeParse(params ?? {});
-			if (!parsedParams.success) {
-				const issue = parsedParams.error.issues[0];
-				return `tool_search: invalid parameters — ${issue.path.join(".") || "params"}: ${issue.message}`;
-			}
-			const { query, max_results } = parsedParams.data;
-			const parsed = parseQuery(query);
-			let matched;
-			let unmatched = [];
-			if (parsed.mode === "select") {
-				matched = deferredToolRegistry.getByNames(parsed.names);
-				const foundNames = new Set(matched.map((t) => t.toolSchema.name));
-				unmatched = parsed.names.filter((n) => !foundNames.has(n));
-			} else {
-				const max = max_results ?? DEFAULT_MAX_RESULTS;
-				matched = deferredToolRegistry.searchByKeywords(parsed.text, max);
-			}
-			if (matched.length === 0) return parsed.mode === "select" ? `tool_search: no deferred tools matched ${parsed.names.join(", ")}. Use a free-text query to search.` : `tool_search: no deferred tools matched query "${parsed.text}".`;
-			const liveTools = toolListAccessor();
-			const liveNames = new Set(liveTools.map((t) => t.toolSchema.name));
-			let added = 0;
-			for (const tool of matched) if (!liveNames.has(tool.toolSchema.name)) {
-				liveTools.push(tool);
-				added++;
-			}
-			logger.debug(`[tool_search] query="${query}" matched=${matched.length} added=${added} alreadyLoaded=${matched.length - added}`);
-			const block = renderToolsBlock(matched);
-			return `${`Loaded ${added} new tool schema(s)${added < matched.length ? ` (${matched.length - added} already loaded)` : ""}. These are now callable in your next message.${unmatched.length > 0 ? `\n\nNot found: ${unmatched.join(", ")}` : ""}`}\n\n${block}`;
-		}
-	};
-}
-//#endregion
-//#region src/features/FeatureModuleRegistry.ts
-/**
-* Manages the lifecycle of opt-in CLI feature modules.
-*
-* Created during bootstrap, modules are conditionally registered based on config,
-* then the registry's outputs are fed into tool generation and prompt building.
-*/
-var FeatureModuleRegistry = class {
-	constructor() {
-		this.modules = [];
-	}
-	/** Register a feature module */
-	register(module) {
-		if (this.modules.some((m) => m.name === module.name)) throw new Error(`Feature module '${module.name}' is already registered`);
-		this.modules.push(module);
-	}
-	/** Collect all tools from all registered modules */
-	getAllTools() {
-		return this.modules.flatMap((m) => m.getTools());
-	}
-	/** Get all tool names from all registered modules */
-	getAllToolNames() {
-		return this.getAllTools().map((t) => t.toolSchema.name);
-	}
-	/** Build combined system prompt section from all modules */
-	getSystemPromptSections() {
-		const sections = this.modules.map((m) => m.getSystemPromptSection()).filter((s) => s.length > 0);
-		return sections.length > 0 ? "\n\n" + sections.join("\n\n") : "";
-	}
-	/** Register all WS handlers from all modules */
-	registerAllWsHandlers(wsManager) {
-		for (const module of this.modules) module.registerWsHandlers?.(wsManager);
-	}
-	/** Collect all slash commands from all registered modules */
-	getAllCommands() {
-		return this.modules.flatMap((m) => m.getCommands?.() ?? []);
-	}
-	/** Try to execute a slash command. Returns true if handled. */
-	executeCommand(name, args) {
-		for (const module of this.modules) {
-			const command = (module.getCommands?.() ?? []).find((c) => c.name === name);
-			if (command) {
-				command.execute(args);
-				return true;
-			}
-		}
-		return false;
-	}
-	/** Cleanup all modules */
-	disposeAll() {
-		for (const module of this.modules) module.dispose?.();
-	}
-	/** Get names of all registered modules */
-	getModuleNames() {
-		return this.modules.map((m) => m.name);
-	}
-	/** Check if any modules are registered */
-	get hasModules() {
-		return this.modules.length > 0;
-	}
-};
-//#endregion
-//#region src/features/tavern/TavernService.ts
-/**
-* HTTP implementation of ITavernService using the shared ApiClient.
-*
-* Each method maps to one /api/tavern/* endpoint.
-* Pure transport — no business logic.
-*/
-var TavernService = class {
-	constructor(apiClient) {
-		this.apiClient = apiClient;
-	}
-	async listAgents() {
-		return this.apiClient.get("/api/agents?limit=100");
-	}
-	async createAgent(request) {
-		return this.apiClient.post("/api/agents", request);
-	}
-	async updateAgent(agentId, request) {
-		return this.apiClient.put(`/api/agents/${encodeURIComponent(agentId)}`, request);
-	}
-	async deleteAgent(agentId) {
-		await this.apiClient.delete(`/api/agents/${encodeURIComponent(agentId)}`);
-	}
-	async mentionAgent(agentName, message, config) {
-		return this.apiClient.post("/api/tavern/mention", {
-			agentName,
-			message,
-			config
-		});
-	}
-	async listQuests() {
-		return this.apiClient.get("/api/tavern/quests");
-	}
-	async postQuest(request) {
-		return this.apiClient.post("/api/tavern/quests", request);
-	}
-	async deleteQuest(questId) {
-		await this.apiClient.delete(`/api/tavern/quests`, { data: { questId } });
-	}
-	async getAgentNotebook(agentId, limit = 50) {
-		return this.apiClient.get(`/api/tavern/agent-notebook?agentId=${encodeURIComponent(agentId)}&limit=${limit}`);
-	}
-	async listGates() {
-		return this.apiClient.get("/api/tavern/gates");
-	}
-	async resolveGate(gateId, resolution) {
-		return this.apiClient.post("/api/tavern/gate-resolve", {
-			gateId,
-			resolution
-		});
-	}
-	async toggleHeartbeats(enabled) {
-		return this.apiClient.post("/api/tavern/toggle-heartbeats", { enabled });
-	}
-	async triggerHeartbeat(config) {
-		return this.apiClient.post("/api/tavern/trigger-heartbeat", { config });
-	}
-	async abortHeartbeats() {
-		await this.apiClient.post("/api/tavern/abort-heartbeats", { abort: true });
-	}
-	async getQuestPlan(planId) {
-		return this.apiClient.get(`/api/quest-master-plans/${encodeURIComponent(planId)}`);
-	}
-	async updateReviewGate(planId, questId, subQuestId, reviewStatus, reviewNote) {
-		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/review-gate`, {
-			questId,
-			subQuestId,
-			reviewStatus,
-			reviewNote
-		});
-	}
-	async updateSubQuestProgress(planId, questId, subQuestId, updates) {
-		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/subquest-progress`, {
-			questId,
-			subQuestId,
-			...updates
-		});
-	}
-	async updateHandoff(planId, handoff) {
-		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/handoff`, handoff);
-	}
-};
-//#endregion
-//#region src/features/tavern/types.ts
-/**
-* Zod schemas and TypeScript types for the Tavern CLI integration.
+* Zod schemas and TypeScript types for the Tavern CLI integration.
 *
 * These map to the REST API shapes in apps/client/pages/api/tavern/*.
 */
@@ -5207,713 +4728,1697 @@ function createToggleHeartbeatsTool(service) {
 			}
 		},
 		toolFn: async (params) => {
-			const { enabled } = params;
-			const result = await service.toggleHeartbeats(enabled);
+			const { enabled } = params;
+			const result = await service.toggleHeartbeats(enabled);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createTriggerHeartbeatTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_trigger_heartbeat",
+			description: "Manually trigger a heartbeat cycle for all Tavern agents. Useful for testing or forcing immediate agent activity.",
+			parameters: {
+				type: "object",
+				properties: { config: {
+					type: "object",
+					description: "Optional configuration overrides for the heartbeat. Known keys: preferredModelId (string — model ID to use), costMode (\"low\" | \"normal\" | \"high\")",
+					additionalProperties: true
+				} }
+			}
+		},
+		toolFn: async (params) => {
+			const { config } = params ?? {};
+			const result = await service.triggerHeartbeat(config);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createAbortHeartbeatsTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_abort_heartbeats",
+			description: "Emergency stop — abort all in-flight Tavern agent heartbeats immediately.",
+			parameters: {
+				type: "object",
+				properties: {}
+			}
+		},
+		toolFn: async () => {
+			await service.abortHeartbeats();
+			return JSON.stringify({
+				success: true,
+				message: "All in-flight heartbeats aborted"
+			});
+		}
+	};
+}
+function createStatusTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_status",
+			description: "Get a quick overview of the Tavern: agent count, heartbeat status, active quests, and pending gates. Use this for situational awareness before taking action.",
+			parameters: {
+				type: "object",
+				properties: {}
+			}
+		},
+		toolFn: async () => {
+			const [agents, quests, gates] = await Promise.all([
+				service.listAgents(),
+				service.listQuests(),
+				service.listGates()
+			]);
+			const agentList = agents.data ?? [];
+			const heartbeatEnabled = agentList.filter((a) => a.heartbeatConfig?.enabled);
+			return JSON.stringify({
+				agents: {
+					total: agentList.length,
+					withHeartbeats: heartbeatEnabled.length,
+					names: agentList.map((a) => ({
+						name: a.name,
+						heartbeat: a.heartbeatConfig?.enabled ?? false
+					}))
+				},
+				quests: {
+					total: quests.quests.length,
+					byStatus: quests.quests.reduce((acc, q) => {
+						acc[q.status] = (acc[q.status] ?? 0) + 1;
+						return acc;
+					}, {})
+				},
+				gates: { pending: gates.gates.length }
+			});
+		}
+	};
+}
+function createGetQuestPlanTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_get_quest_plan",
+			description: "Fetch a quest master plan by ID. Returns the full plan with all quests, sub-quests, review gate status, handoff state, and progress metrics. Use this to check which sub-quests have review gates and their current status.",
+			parameters: {
+				type: "object",
+				properties: { plan_id: {
+					type: "string",
+					description: "The MongoDB ObjectId of the quest master plan"
+				} },
+				required: ["plan_id"]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id } = GetQuestPlanParamsSchema.parse(params);
+			const result = await service.getQuestPlan(plan_id);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createUpdateReviewGateTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_update_review_gate",
+			description: "Approve or reject a review gate on a sub-quest. Review gates are human approval checkpoints — when a sub-quest has reviewGate: true, the AI must stop and wait for human approval before proceeding.",
+			parameters: {
+				type: "object",
+				properties: {
+					plan_id: {
+						type: "string",
+						description: "The MongoDB ObjectId of the quest master plan"
+					},
+					quest_id: {
+						type: "string",
+						description: "The ID of the parent quest"
+					},
+					sub_quest_id: {
+						type: "string",
+						description: "The ID of the sub-quest with the review gate"
+					},
+					review_status: {
+						type: "string",
+						description: "The review decision",
+						enum: [
+							"pending",
+							"approved",
+							"rejected"
+						]
+					},
+					review_note: {
+						type: "string",
+						description: "Optional note explaining the review decision"
+					}
+				},
+				required: [
+					"plan_id",
+					"quest_id",
+					"sub_quest_id",
+					"review_status"
+				]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id, quest_id, sub_quest_id, review_status, review_note } = UpdateReviewGateParamsSchema.parse(params);
+			const result = await service.updateReviewGate(plan_id, quest_id, sub_quest_id, review_status, review_note);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createUpdateQuestProgressTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_update_quest_progress",
+			description: "Update a sub-quest's progress. Set status to track completion, add evidence of what was accomplished, and optionally record time spent. Setting status to \"in_progress\" auto-resumes a paused plan.",
+			parameters: {
+				type: "object",
+				properties: {
+					plan_id: {
+						type: "string",
+						description: "The MongoDB ObjectId of the quest master plan"
+					},
+					quest_id: {
+						type: "string",
+						description: "The ID of the parent quest"
+					},
+					sub_quest_id: {
+						type: "string",
+						description: "The ID of the sub-quest to update"
+					},
+					status: {
+						type: "string",
+						description: "New status for the sub-quest",
+						enum: [
+							"not_started",
+							"in_progress",
+							"completed",
+							"skipped",
+							"deleted"
+						]
+					},
+					evidence: {
+						type: "string",
+						description: "Evidence of completion — links to artifacts, descriptions of output, or references to results"
+					},
+					time_spent: {
+						type: "number",
+						description: "Time spent on this sub-quest in milliseconds"
+					}
+				},
+				required: [
+					"plan_id",
+					"quest_id",
+					"sub_quest_id"
+				]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id, quest_id, sub_quest_id, status, evidence, time_spent } = UpdateQuestProgressParamsSchema.parse(params);
+			const updates = {};
+			if (status !== void 0) updates.status = status;
+			if (evidence !== void 0) updates.evidence = evidence;
+			if (time_spent !== void 0) updates.timeSpent = time_spent;
+			const result = await service.updateSubQuestProgress(plan_id, quest_id, sub_quest_id, updates);
 			return JSON.stringify(result);
 		}
 	};
 }
-function createTriggerHeartbeatTool(service) {
+function createWriteHandoffTool(service) {
 	return {
 		toolSchema: {
-			name: "tavern_trigger_heartbeat",
-			description: "Manually trigger a heartbeat cycle for all Tavern agents. Useful for testing or forcing immediate agent activity.",
+			name: "tavern_write_handoff",
+			description: "Write a handoff state for session continuity. Called when ending a session so the next session can resume with full context. Includes a summary of progress, next steps, pending decisions, and blockers.",
 			parameters: {
 				type: "object",
-				properties: { config: {
-					type: "object",
-					description: "Optional configuration overrides for the heartbeat. Known keys: preferredModelId (string — model ID to use), costMode (\"low\" | \"normal\" | \"high\")",
-					additionalProperties: true
-				} }
+				properties: {
+					plan_id: {
+						type: "string",
+						description: "The MongoDB ObjectId of the quest master plan"
+					},
+					summary: {
+						type: "string",
+						description: "Summary of what was accomplished in this session"
+					},
+					next_steps: {
+						type: "array",
+						items: { type: "string" },
+						description: "List of next steps for the following session"
+					},
+					pending_decisions: {
+						type: "array",
+						items: { type: "string" },
+						description: "Decisions that still need to be made"
+					},
+					blockers: {
+						type: "array",
+						items: { type: "string" },
+						description: "Current blockers preventing progress"
+					}
+				},
+				required: [
+					"plan_id",
+					"summary",
+					"next_steps",
+					"pending_decisions",
+					"blockers"
+				]
 			}
 		},
 		toolFn: async (params) => {
-			const { config } = params ?? {};
-			const result = await service.triggerHeartbeat(config);
+			const { plan_id, summary, next_steps, pending_decisions, blockers } = WriteHandoffParamsSchema.parse(params);
+			const result = await service.updateHandoff(plan_id, {
+				summary,
+				nextSteps: next_steps,
+				pendingDecisions: pending_decisions,
+				blockers
+			});
 			return JSON.stringify(result);
 		}
 	};
 }
-function createAbortHeartbeatsTool(service) {
-	return {
-		toolSchema: {
-			name: "tavern_abort_heartbeats",
-			description: "Emergency stop — abort all in-flight Tavern agent heartbeats immediately.",
-			parameters: {
-				type: "object",
-				properties: {}
+//#endregion
+//#region src/features/tavern/TavernModule.ts
+/** Icons for heartbeat log actions shown in /tavern command */
+const ACTION_ICONS = {
+	speech: "💬",
+	thought: "💭",
+	memory: "🧠",
+	move: "🚶",
+	reply: "📩",
+	post_quest: "📜",
+	claim_quest: "⚔️",
+	complete_quest: "✅",
+	tool_use: "🔧",
+	email: "📧",
+	gate_paused: "⏸️",
+	gate_timed: "⏳",
+	gate_proceed: "▶️",
+	idle: "💤",
+	intent: "🎯",
+	report: "📋",
+	credits: "🪙",
+	move_decoration: "🎨",
+	yolo_override: "⚡"
+};
+/**
+* ICliFeatureModule implementation for the Tavern.
+*
+* Composes the service, tool adapters, WS activity stream, and slash
+* commands into a single module that the FeatureModuleRegistry can manage.
+*/
+var TavernModule = class {
+	constructor(apiClient, onLogEntry, getActivityLog) {
+		this.name = "tavern";
+		this.description = "Interact with autonomous AI agents in the B4M Tavern";
+		this.service = new TavernService(apiClient);
+		this.activityStream = new TavernActivityStream(onLogEntry);
+		this.getActivityLog = getActivityLog;
+	}
+	getTools() {
+		return createTavernTools(this.service);
+	}
+	getSystemPromptSection() {
+		return `## Tavern Integration
+You can interact with autonomous AI agents in the B4M Tavern using tavern_* tools.
+
+IMPORTANT: Many tools require agent IDs (MongoDB ObjectIds like "6540b58d1f703ade3ea1e82b"). Always use tavern_list_agents FIRST to discover agent names and their IDs before using tools that need an agent_id.
+
+Available actions:
+- **tavern_list_agents**: List all agents with their IDs, names, and status — USE THIS FIRST
+- **tavern_create_agent**: Create a new agent with a personality (heartbeats disabled by default)
+- **tavern_edit_agent**: Update an agent's personality, system prompt, or heartbeat config (per-agent toggle)
+- **tavern_delete_agent**: Permanently delete an agent
+- **tavern_mention**: Talk to a specific agent by name or broadcast to all agents
+- **tavern_list_quests**: View the quest board
+- **tavern_post_quest**: Post a new quest for agents to claim
+- **tavern_delete_quest**: Remove a quest from the board
+- **tavern_read_notebook**: Read an agent's activity history (requires agent ID from tavern_list_agents)
+- **tavern_list_gates**: See pending confidence gates awaiting human approval
+- **tavern_resolve_gate**: Approve or reject a confidence gate
+- **tavern_toggle_heartbeats**: Enable/disable agent background heartbeats
+- **tavern_trigger_heartbeat**: Manually trigger a heartbeat cycle
+- **tavern_abort_heartbeats**: Emergency stop all in-flight heartbeats
+- **tavern_status**: Quick overview of agents, quests, and gates — good for situational awareness
+- **tavern_get_quest_plan**: Fetch a quest master plan with review gate status and handoff state
+- **tavern_update_review_gate**: Approve or reject a review gate on a sub-quest
+- **tavern_update_quest_progress**: Update sub-quest status and record evidence of completion
+- **tavern_write_handoff**: Write session handoff for continuity across sessions
+
+When the user mentions talking to agents, checking the quest board, or managing the tavern, use these tools.
+Agents have personalities, moods, quests, and memories — they are autonomous entities, not chatbots.
+
+## Quest Workflow (Review Gates)
+When working on a quest plan with review gates (reviewGate: true on sub-quests), you MUST:
+1. Check review gate status with tavern_get_quest_plan before proceeding past a gated step
+2. If the next sub-quest has reviewGate: true and reviewStatus is not 'approved', STOP and inform the user
+3. Record evidence of completion with tavern_update_quest_progress when finishing a sub-quest
+4. Write a handoff with tavern_write_handoff before ending a session with an active quest plan
+
+## Session Handoff & Resume
+When the user runs /quest resume <plan_id>, read the handoff context and continue from where the previous session left off. The handoff contains: summary of prior work, next steps, pending decisions, and blockers.`;
+	}
+	getCommands() {
+		return [{
+			name: "tavern",
+			description: "Show recent Tavern agent activity stream",
+			execute: () => {
+				const activityLog = this.getActivityLog();
+				if (activityLog.length === 0) {
+					console.log("\nTavern Activity: No activity yet.");
+					console.log("  Agents broadcast activity during heartbeats.");
+					console.log("  Try: \"trigger a heartbeat cycle\" to generate activity.\n");
+					return;
+				}
+				const recentEntries = activityLog.slice(-20);
+				console.log(`\nTavern Activity (last ${recentEntries.length} of ${activityLog.length} entries):\n`);
+				for (const entry of recentEntries) {
+					const time = new Date(entry.timestamp).toLocaleTimeString();
+					const icon = ACTION_ICONS[entry.action] ?? "·";
+					const target = entry.targetAgentName ? ` \u2192 ${entry.targetAgentName}` : "";
+					const text = entry.text ? `: ${entry.text.slice(0, 120)}${entry.text.length > 120 ? "..." : ""}` : "";
+					console.log(`  ${time}  ${icon} ${entry.agentName}${target} [${entry.action}]${text}`);
+				}
+				console.log("");
+			}
+		}, {
+			name: "quest",
+			description: "Quest workflow commands: review gates, resume from handoff",
+			execute: async (args) => {
+				const subCommand = args[0];
+				if (subCommand === "resume") {
+					const planId = args[1];
+					if (!planId) {
+						console.log("\nUsage: /quest resume <plan_id>");
+						console.log("  Loads the quest plan and displays the session handoff for continuity.\n");
+						return;
+					}
+					try {
+						const plan = await this.service.getQuestPlan(planId);
+						console.log(`\nQuest Plan: ${plan.goal}`);
+						console.log(`State: ${plan.state ?? "unknown"}`);
+						if (plan.metrics) {
+							const pct = Math.round(plan.metrics.completionRate * 100);
+							console.log(`Progress: ${plan.metrics.subQuestsCompleted}/${plan.metrics.subQuestsTotal} sub-quests (${pct}%)`);
+						}
+						if (!plan.handoff) {
+							console.log("\n  No handoff found — this plan has no saved session context.");
+							console.log("  The AI can still read the plan via tavern_get_quest_plan.\n");
+							return;
+						}
+						const { handoff } = plan;
+						console.log(`\nSession Handoff (${new Date(handoff.updatedAt).toLocaleString()}):`);
+						console.log(`\n  Summary: ${handoff.summary}`);
+						if (handoff.nextSteps.length > 0) {
+							console.log("\n  Next Steps:");
+							for (const step of handoff.nextSteps) console.log(`    \u2022 ${step}`);
+						}
+						if (handoff.pendingDecisions.length > 0) {
+							console.log("\n  Pending Decisions:");
+							for (const decision of handoff.pendingDecisions) console.log(`    \u2753 ${decision}`);
+						}
+						if (handoff.blockers.length > 0) {
+							console.log("\n  Blockers:");
+							for (const blocker of handoff.blockers) console.log(`    \u{1F6D1} ${blocker}`);
+						}
+						console.log("");
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						console.log(`\nError fetching quest plan: ${message}\n`);
+					}
+					return;
+				}
+				if (subCommand === "review") {
+					const planId = args[1];
+					if (!planId) {
+						console.log("\nUsage: /quest review <plan_id>");
+						console.log("  Fetches the quest plan and shows sub-quests with pending review gates.\n");
+						return;
+					}
+					try {
+						const plan = await this.service.getQuestPlan(planId);
+						const pendingGates = [];
+						for (const quest of plan.quests) for (const sq of quest.subQuests) if (sq.reviewGate) pendingGates.push({
+							questTitle: quest.title,
+							questId: quest.id,
+							subQuestTitle: sq.title,
+							subQuestId: sq.id,
+							status: sq.reviewStatus ?? "pending"
+						});
+						if (pendingGates.length === 0) {
+							console.log(`\nQuest Plan: ${plan.goal}`);
+							console.log("  No review gates configured in this plan.\n");
+							return;
+						}
+						console.log(`\nQuest Plan: ${plan.goal}`);
+						console.log(`State: ${plan.state ?? "unknown"}\n`);
+						console.log("Review Gates:");
+						for (const gate of pendingGates) {
+							const icon = gate.status === "approved" ? "✅" : gate.status === "rejected" ? "❌" : "⏸️";
+							console.log(`  ${icon} [${gate.status}] ${gate.questTitle} > ${gate.subQuestTitle}`);
+							console.log(`     quest_id: ${gate.questId}  sub_quest_id: ${gate.subQuestId}`);
+						}
+						console.log("\n  To approve: ask the AI to approve a review gate, or use tavern_update_review_gate tool.\n");
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						console.log(`\nError fetching quest plan: ${message}\n`);
+					}
+					return;
+				}
+				console.log("\nUsage:");
+				console.log("  /quest review <plan_id>  — Show review gates and their status");
+				console.log("  /quest resume <plan_id>  — Load handoff and resume from where you left off");
+				console.log("");
 			}
-		},
-		toolFn: async () => {
-			await service.abortHeartbeats();
-			return JSON.stringify({
-				success: true,
-				message: "All in-flight heartbeats aborted"
-			});
-		}
-	};
+		}];
+	}
+	registerWsHandlers(wsManager) {
+		this.activityStream.registerHandlers(wsManager);
+	}
+	dispose() {
+		this.activityStream.dispose();
+	}
+};
+//#endregion
+//#region src/features/bridgePresence/BridgePresence.ts
+const DEFAULT_PORT = Number(process.env.CC_BRIDGE_PORT ?? 48732);
+const CONFIG_PATH = join(homedir(), ".b4m", "cc-bridge.json");
+const ANNOUNCE_TIMEOUT_MS = 2e3;
+async function readBridgeConfig() {
+	try {
+		const raw = await promises.readFile(CONFIG_PATH, "utf8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.hookSecret !== "string" || !parsed.hookSecret) return null;
+		return {
+			port: typeof parsed.port === "number" ? parsed.port : DEFAULT_PORT,
+			hookSecret: parsed.hookSecret
+		};
+	} catch {
+		return null;
+	}
 }
-function createStatusTool(service) {
-	return {
-		toolSchema: {
-			name: "tavern_status",
-			description: "Get a quick overview of the Tavern: agent count, heartbeat status, active quests, and pending gates. Use this for situational awareness before taking action.",
-			parameters: {
-				type: "object",
-				properties: {}
-			}
-		},
-		toolFn: async () => {
-			const [agents, quests, gates] = await Promise.all([
-				service.listAgents(),
-				service.listQuests(),
-				service.listGates()
-			]);
-			const agentList = agents.data ?? [];
-			const heartbeatEnabled = agentList.filter((a) => a.heartbeatConfig?.enabled);
-			return JSON.stringify({
-				agents: {
-					total: agentList.length,
-					withHeartbeats: heartbeatEnabled.length,
-					names: agentList.map((a) => ({
-						name: a.name,
-						heartbeat: a.heartbeatConfig?.enabled ?? false
-					}))
-				},
-				quests: {
-					total: quests.quests.length,
-					byStatus: quests.quests.reduce((acc, q) => {
-						acc[q.status] = (acc[q.status] ?? 0) + 1;
-						return acc;
-					}, {})
-				},
-				gates: { pending: gates.gates.length }
-			});
+var BridgePresence = class {
+	constructor() {
+		this.config = null;
+		this.instanceId = null;
+		this.ws = null;
+		this.callbacks = {};
+		this.started = false;
+		this.stopped = false;
+		this.reconnectTimer = null;
+		this.reconnectAttempts = 0;
+		this.announceRetryTimer = null;
+		this.announceAttempts = 0;
+		this.startOpts = null;
+		this.pendingWorkspaceName = null;
+		this.pendingCapabilities = null;
+		this.pendingSource = null;
+		this.emitQueue = Promise.resolve();
+	}
+	setCallbacks(cbs) {
+		this.callbacks = cbs;
+	}
+	/**
+	* Probe the local bridge and, if present, announce this CLI session.
+	* Returns true iff the announce succeeded (tavern presence is active).
+	* Safe to call multiple times — second call no-ops.
+	*
+	* If announce fails (bridge absent or not yet up), a background retry
+	* loop keeps trying with bounded backoff so the sprite appears when the
+	* bridge comes online later in the CLI's lifetime.
+	*/
+	async start(opts) {
+		if (this.started) return this.instanceId !== null;
+		this.stopped = false;
+		this.started = true;
+		const config = await readBridgeConfig();
+		if (!config) {
+			logger.debug("[tavern] cc-bridge not configured; CLI runs without tavern presence");
+			return false;
 		}
-	};
-}
-function createGetQuestPlanTool(service) {
-	return {
-		toolSchema: {
-			name: "tavern_get_quest_plan",
-			description: "Fetch a quest master plan by ID. Returns the full plan with all quests, sub-quests, review gate status, handoff state, and progress metrics. Use this to check which sub-quests have review gates and their current status.",
-			parameters: {
-				type: "object",
-				properties: { plan_id: {
-					type: "string",
-					description: "The MongoDB ObjectId of the quest master plan"
-				} },
-				required: ["plan_id"]
-			}
-		},
-		toolFn: async (params) => {
-			const { plan_id } = GetQuestPlanParamsSchema.parse(params);
-			const result = await service.getQuestPlan(plan_id);
-			return JSON.stringify(result);
+		this.config = config;
+		this.startOpts = opts;
+		this.pendingWorkspaceName = opts.workspaceName ?? (basename(opts.workspacePath) || "workspace");
+		this.pendingCapabilities = opts.capabilities ?? ["interactive"];
+		this.pendingSource = opts.source ?? "b4m-cli";
+		return this.attemptAnnounce();
+	}
+	/** One announce attempt. Schedules a retry on failure; wires up the
+	*  command WS + initial status on success. Idempotent: re-entering after
+	*  a successful announce short-circuits at the instanceId guard. */
+	async attemptAnnounce() {
+		if (this.stopped || !this.config || !this.startOpts) return false;
+		if (this.instanceId) return true;
+		const instanceId = v4();
+		const workspaceName = this.pendingWorkspaceName;
+		const capabilities = this.pendingCapabilities;
+		const source = this.pendingSource;
+		if (!await this.announce({
+			instanceId,
+			source,
+			workspaceName,
+			workspacePath: this.startOpts.workspacePath,
+			capabilities
+		})) {
+			this.scheduleAnnounceRetry();
+			return false;
 		}
-	};
-}
-function createUpdateReviewGateTool(service) {
-	return {
-		toolSchema: {
-			name: "tavern_update_review_gate",
-			description: "Approve or reject a review gate on a sub-quest. Review gates are human approval checkpoints — when a sub-quest has reviewGate: true, the AI must stop and wait for human approval before proceeding.",
-			parameters: {
-				type: "object",
-				properties: {
-					plan_id: {
-						type: "string",
-						description: "The MongoDB ObjectId of the quest master plan"
-					},
-					quest_id: {
-						type: "string",
-						description: "The ID of the parent quest"
-					},
-					sub_quest_id: {
-						type: "string",
-						description: "The ID of the sub-quest with the review gate"
-					},
-					review_status: {
-						type: "string",
-						description: "The review decision",
-						enum: [
-							"pending",
-							"approved",
-							"rejected"
-						]
-					},
-					review_note: {
-						type: "string",
-						description: "Optional note explaining the review decision"
-					}
-				},
-				required: [
-					"plan_id",
-					"quest_id",
-					"sub_quest_id",
-					"review_status"
-				]
-			}
-		},
-		toolFn: async (params) => {
-			const { plan_id, quest_id, sub_quest_id, review_status, review_note } = UpdateReviewGateParamsSchema.parse(params);
-			const result = await service.updateReviewGate(plan_id, quest_id, sub_quest_id, review_status, review_note);
-			return JSON.stringify(result);
+		this.instanceId = instanceId;
+		this.announceAttempts = 0;
+		logger.info(`[tavern] announced ${workspaceName} to cc-bridge on 127.0.0.1:${this.config.port ?? DEFAULT_PORT}`);
+		this.connectCommandWs();
+		this.emitEvent({
+			type: "status",
+			status: "idle"
+		});
+		return true;
+	}
+	scheduleAnnounceRetry() {
+		if (this.stopped || this.announceRetryTimer) return;
+		this.announceAttempts += 1;
+		const delay = Math.min(1e3 * 2 ** (this.announceAttempts - 1), 3e4);
+		this.announceRetryTimer = setTimeout(() => {
+			this.announceRetryTimer = null;
+			this.attemptAnnounce();
+		}, delay);
+	}
+	/** Emit an event for this session. No-op if the bridge isn't up. Events
+	*  leave in strict order — see `emitQueue` comment. */
+	async emitEvent(event) {
+		if (!this.config || !this.instanceId) return;
+		const task = () => this.post("/event", {
+			instanceId: this.instanceId,
+			event
+		}).catch((err) => logger.info(`[tavern] emitEvent ${event.type} failed: ${err.message}`));
+		this.emitQueue = this.emitQueue.then(task, task);
+		return this.emitQueue;
+	}
+	/**
+	* Tear down the tavern presence cleanly. Halts the announce-retry and
+	* command-WS reconnect loops, closes the socket, and best-effort signals
+	* disconnect to the bridge.
+	*
+	* After this resolves the instance is fully reset, so a later `start()`
+	* re-announces — the same singleton can be toggled off (Tavern feature
+	* disabled at runtime) and back on without restarting the CLI. The
+	* `stopped` latch is left true here purely so any straggler retry callback
+	* already queued short-circuits; `start()` clears it.
+	*/
+	async stop(reason = "cli_exit") {
+		if (this.stopped || !this.started) return;
+		this.stopped = true;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
 		}
-	};
-}
-function createUpdateQuestProgressTool(service) {
-	return {
-		toolSchema: {
-			name: "tavern_update_quest_progress",
-			description: "Update a sub-quest's progress. Set status to track completion, add evidence of what was accomplished, and optionally record time spent. Setting status to \"in_progress\" auto-resumes a paused plan.",
-			parameters: {
-				type: "object",
-				properties: {
-					plan_id: {
-						type: "string",
-						description: "The MongoDB ObjectId of the quest master plan"
-					},
-					quest_id: {
-						type: "string",
-						description: "The ID of the parent quest"
-					},
-					sub_quest_id: {
-						type: "string",
-						description: "The ID of the sub-quest to update"
-					},
-					status: {
-						type: "string",
-						description: "New status for the sub-quest",
-						enum: [
-							"not_started",
-							"in_progress",
-							"completed",
-							"skipped",
-							"deleted"
-						]
-					},
-					evidence: {
-						type: "string",
-						description: "Evidence of completion — links to artifacts, descriptions of output, or references to results"
-					},
-					time_spent: {
-						type: "number",
-						description: "Time spent on this sub-quest in milliseconds"
-					}
-				},
-				required: [
-					"plan_id",
-					"quest_id",
-					"sub_quest_id"
-				]
-			}
-		},
-		toolFn: async (params) => {
-			const { plan_id, quest_id, sub_quest_id, status, evidence, time_spent } = UpdateQuestProgressParamsSchema.parse(params);
-			const updates = {};
-			if (status !== void 0) updates.status = status;
-			if (evidence !== void 0) updates.evidence = evidence;
-			if (time_spent !== void 0) updates.timeSpent = time_spent;
-			const result = await service.updateSubQuestProgress(plan_id, quest_id, sub_quest_id, updates);
-			return JSON.stringify(result);
+		if (this.announceRetryTimer) {
+			clearTimeout(this.announceRetryTimer);
+			this.announceRetryTimer = null;
 		}
-	};
-}
-function createWriteHandoffTool(service) {
-	return {
-		toolSchema: {
-			name: "tavern_write_handoff",
-			description: "Write a handoff state for session continuity. Called when ending a session so the next session can resume with full context. Includes a summary of progress, next steps, pending decisions, and blockers.",
-			parameters: {
-				type: "object",
-				properties: {
-					plan_id: {
-						type: "string",
-						description: "The MongoDB ObjectId of the quest master plan"
-					},
-					summary: {
-						type: "string",
-						description: "Summary of what was accomplished in this session"
-					},
-					next_steps: {
-						type: "array",
-						items: { type: "string" },
-						description: "List of next steps for the following session"
-					},
-					pending_decisions: {
-						type: "array",
-						items: { type: "string" },
-						description: "Decisions that still need to be made"
-					},
-					blockers: {
-						type: "array",
-						items: { type: "string" },
-						description: "Current blockers preventing progress"
-					}
-				},
-				required: [
-					"plan_id",
-					"summary",
-					"next_steps",
-					"pending_decisions",
-					"blockers"
-				]
+		if (this.ws) {
+			try {
+				this.ws.close();
+			} catch {}
+			this.ws = null;
+		}
+		if (this.config && this.instanceId) await this.post("/disconnect", {
+			instanceId: this.instanceId,
+			reason
+		}).catch(() => {});
+		this.started = false;
+		this.instanceId = null;
+		this.config = null;
+		this.startOpts = null;
+		this.pendingWorkspaceName = null;
+		this.pendingCapabilities = null;
+		this.pendingSource = null;
+		this.announceAttempts = 0;
+		this.reconnectAttempts = 0;
+		this.emitQueue = Promise.resolve();
+	}
+	async announce(body) {
+		try {
+			await this.post("/announce", body);
+			return true;
+		} catch (err) {
+			logger.info(`[tavern] bridge announce failed: ${err.message}`);
+			return false;
+		}
+	}
+	async post(path, body) {
+		if (!this.config) throw new Error("bridge config not loaded");
+		const url = `http://127.0.0.1:${this.config.port ?? DEFAULT_PORT}${path}?secret=${encodeURIComponent(this.config.hookSecret)}`;
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(ANNOUNCE_TIMEOUT_MS)
+		});
+		if (!res.ok) throw new Error(`bridge ${path} -> ${res.status}`);
+	}
+	connectCommandWs() {
+		if (this.stopped || !this.config || !this.instanceId) return;
+		const url = `ws://127.0.0.1:${this.config.port ?? DEFAULT_PORT}/commands?instanceId=${encodeURIComponent(this.instanceId)}&secret=${encodeURIComponent(this.config.hookSecret)}`;
+		let ws;
+		try {
+			ws = new WsWebSocket(url);
+		} catch (err) {
+			logger.debug(`[tavern] command WS construct failed: ${err.message}`);
+			this.scheduleReconnect();
+			return;
+		}
+		this.ws = ws;
+		ws.on("open", () => {
+			this.reconnectAttempts = 0;
+			logger.debug("[tavern] command WS open");
+		});
+		ws.on("message", (raw) => {
+			let frame = null;
+			try {
+				frame = JSON.parse(raw.toString());
+			} catch {
+				logger.debug("[tavern] malformed command frame; ignored");
+				return;
 			}
-		},
-		toolFn: async (params) => {
-			const { plan_id, summary, next_steps, pending_decisions, blockers } = WriteHandoffParamsSchema.parse(params);
-			const result = await service.updateHandoff(plan_id, {
-				summary,
-				nextSteps: next_steps,
-				pendingDecisions: pending_decisions,
-				blockers
-			});
-			return JSON.stringify(result);
+			if (!frame?.command) return;
+			this.dispatchCommand(frame.command).catch((err) => logger.warn(`[tavern] command dispatch threw: ${err.message}`));
+		});
+		ws.on("close", () => {
+			this.ws = null;
+			if (this.stopped) return;
+			logger.debug("[tavern] command WS closed; reconnecting");
+			this.scheduleReconnect();
+		});
+		ws.on("error", (err) => {
+			logger.debug(`[tavern] command WS error: ${err.message}`);
+		});
+	}
+	scheduleReconnect() {
+		if (this.stopped || this.reconnectTimer) return;
+		this.reconnectAttempts += 1;
+		const delay = Math.min(500 * 2 ** (this.reconnectAttempts - 1), 1e4);
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.connectCommandWs();
+		}, delay);
+	}
+	async dispatchCommand(command) {
+		switch (command.type) {
+			case "send_prompt":
+				if (this.callbacks.onSendPrompt) await this.callbacks.onSendPrompt(command.text);
+				break;
+			case "resolve_permission":
+				if (this.callbacks.onResolvePermission) await this.callbacks.onResolvePermission(command.requestId, command.allow);
+				break;
+			case "abort":
+				if (this.callbacks.onAbort) await this.callbacks.onAbort();
+				break;
 		}
-	};
-}
+	}
+};
+/** Process-wide singleton — the CLI only ever has one tavern presence per run. */
+const bridgePresence = new BridgePresence();
 //#endregion
-//#region src/features/tavern/TavernModule.ts
-/** Icons for heartbeat log actions shown in /tavern command */
-const ACTION_ICONS = {
-	speech: "💬",
-	thought: "💭",
-	memory: "🧠",
-	move: "🚶",
-	reply: "📩",
-	post_quest: "📜",
-	claim_quest: "⚔️",
-	complete_quest: "✅",
-	tool_use: "🔧",
-	email: "📧",
-	gate_paused: "⏸️",
-	gate_timed: "⏳",
-	gate_proceed: "▶️",
-	idle: "💤",
-	intent: "🎯",
-	report: "📋",
-	credits: "🪙",
-	move_decoration: "🎨",
-	yolo_override: "⚡"
+//#region src/llm/MultiLlmBackend.ts
+/**
+* Routes completions between B4M server and a local Ollama instance
+* based on the selected model's backend type.
+*/
+var MultiLlmBackend = class {
+	constructor(serverBackend, ollamaBackend, serverModels, ollamaModels, initialModel) {
+		this.serverBackend = serverBackend;
+		this.ollamaBackend = ollamaBackend;
+		this.serverModels = serverModels;
+		this.ollamaModels = ollamaModels;
+		this.currentModel = initialModel;
+		this.ollamaModelIds = new Set(ollamaModels.map((m) => m.id));
+	}
+	get activeBackend() {
+		return this.ollamaModelIds.has(this.currentModel) ? this.ollamaBackend : this.serverBackend;
+	}
+	async complete(model, messages, options, callback) {
+		return (this.ollamaModelIds.has(model) ? this.ollamaBackend : this.serverBackend).complete(model, messages, options, callback);
+	}
+	pushToolMessages(messages, tool, result, thinkingBlocks) {
+		this.activeBackend.pushToolMessages(messages, tool, result, thinkingBlocks);
+	}
+	async getModelInfo() {
+		return [...this.serverModels, ...this.ollamaModels];
+	}
 };
+//#endregion
+//#region src/utils/jupyterClient.ts
 /**
-* ICliFeatureModule implementation for the Tavern.
+* Jupyter Server REST API Client
 *
-* Composes the service, tool adapters, WS activity stream, and slash
-* commands into a single module that the FeatureModuleRegistry can manage.
+* Provides methods for interacting with a local Jupyter Server instance.
+* Used by Keep commands to execute notebooks on the user's local machine.
+*
+* @see https://jupyter-server.readthedocs.io/en/latest/developers/rest-api.html
+* @see https://jupyter-client.readthedocs.io/en/latest/messaging.html
 */
-var TavernModule = class {
-	constructor(apiClient, onLogEntry, getActivityLog) {
-		this.name = "tavern";
-		this.description = "Interact with autonomous AI agents in the B4M Tavern";
-		this.service = new TavernService(apiClient);
-		this.activityStream = new TavernActivityStream(onLogEntry);
-		this.getActivityLog = getActivityLog;
+var JupyterClientError = class extends Error {
+	constructor(message, statusCode, response) {
+		super(message);
+		this.statusCode = statusCode;
+		this.response = response;
+		this.name = "JupyterClientError";
 	}
-	getTools() {
-		return createTavernTools(this.service);
+};
+/**
+* Validate Jupyter server URL
+*/
+function validateServerUrl(url) {
+	if (!url || typeof url !== "string") throw new JupyterClientError("Server URL is required");
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new JupyterClientError(`Invalid server URL: ${url}`);
 	}
-	getSystemPromptSection() {
-		return `## Tavern Integration
-You can interact with autonomous AI agents in the B4M Tavern using tavern_* tools.
-
-IMPORTANT: Many tools require agent IDs (MongoDB ObjectIds like "6540b58d1f703ade3ea1e82b"). Always use tavern_list_agents FIRST to discover agent names and their IDs before using tools that need an agent_id.
-
-Available actions:
-- **tavern_list_agents**: List all agents with their IDs, names, and status — USE THIS FIRST
-- **tavern_create_agent**: Create a new agent with a personality (heartbeats disabled by default)
-- **tavern_edit_agent**: Update an agent's personality, system prompt, or heartbeat config (per-agent toggle)
-- **tavern_delete_agent**: Permanently delete an agent
-- **tavern_mention**: Talk to a specific agent by name or broadcast to all agents
-- **tavern_list_quests**: View the quest board
-- **tavern_post_quest**: Post a new quest for agents to claim
-- **tavern_delete_quest**: Remove a quest from the board
-- **tavern_read_notebook**: Read an agent's activity history (requires agent ID from tavern_list_agents)
-- **tavern_list_gates**: See pending confidence gates awaiting human approval
-- **tavern_resolve_gate**: Approve or reject a confidence gate
-- **tavern_toggle_heartbeats**: Enable/disable agent background heartbeats
-- **tavern_trigger_heartbeat**: Manually trigger a heartbeat cycle
-- **tavern_abort_heartbeats**: Emergency stop all in-flight heartbeats
-- **tavern_status**: Quick overview of agents, quests, and gates — good for situational awareness
-- **tavern_get_quest_plan**: Fetch a quest master plan with review gate status and handoff state
-- **tavern_update_review_gate**: Approve or reject a review gate on a sub-quest
-- **tavern_update_quest_progress**: Update sub-quest status and record evidence of completion
-- **tavern_write_handoff**: Write session handoff for continuity across sessions
-
-When the user mentions talking to agents, checking the quest board, or managing the tavern, use these tools.
-Agents have personalities, moods, quests, and memories — they are autonomous entities, not chatbots.
-
-## Quest Workflow (Review Gates)
-When working on a quest plan with review gates (reviewGate: true on sub-quests), you MUST:
-1. Check review gate status with tavern_get_quest_plan before proceeding past a gated step
-2. If the next sub-quest has reviewGate: true and reviewStatus is not 'approved', STOP and inform the user
-3. Record evidence of completion with tavern_update_quest_progress when finishing a sub-quest
-4. Write a handoff with tavern_write_handoff before ending a session with an active quest plan
-
-## Session Handoff & Resume
-When the user runs /quest resume <plan_id>, read the handoff context and continue from where the previous session left off. The handoff contains: summary of prior work, next steps, pending decisions, and blockers.`;
+	if (!["http:", "https:"].includes(parsed.protocol)) throw new JupyterClientError(`Invalid protocol: ${parsed.protocol}. Only http and https are allowed`);
+}
+/**
+* Validate notebook path to prevent path traversal (throws on invalid)
+*/
+function validateNotebookPath(path) {
+	const result = validateNotebookPath$1(path);
+	if (!result.valid) throw new JupyterClientError(result.error || "Invalid notebook path");
+}
+/**
+* Validate kernel name against whitelist (throws on invalid)
+*/
+function validateKernelName(name) {
+	const result = validateJupyterKernelName(name);
+	if (!result.valid) throw new JupyterClientError(result.error || "Invalid kernel name");
+}
+var JupyterClient = class {
+	constructor(config) {
+		validateServerUrl(config.serverUrl);
+		this.serverUrl = config.serverUrl.replace(/\/$/, "");
+		this.token = config.token;
 	}
-	getCommands() {
-		return [{
-			name: "tavern",
-			description: "Show recent Tavern agent activity stream",
-			execute: () => {
-				const activityLog = this.getActivityLog();
-				if (activityLog.length === 0) {
-					console.log("\nTavern Activity: No activity yet.");
-					console.log("  Agents broadcast activity during heartbeats.");
-					console.log("  Try: \"trigger a heartbeat cycle\" to generate activity.\n");
-					return;
-				}
-				const recentEntries = activityLog.slice(-20);
-				console.log(`\nTavern Activity (last ${recentEntries.length} of ${activityLog.length} entries):\n`);
-				for (const entry of recentEntries) {
-					const time = new Date(entry.timestamp).toLocaleTimeString();
-					const icon = ACTION_ICONS[entry.action] ?? "·";
-					const target = entry.targetAgentName ? ` \u2192 ${entry.targetAgentName}` : "";
-					const text = entry.text ? `: ${entry.text.slice(0, 120)}${entry.text.length > 120 ? "..." : ""}` : "";
-					console.log(`  ${time}  ${icon} ${entry.agentName}${target} [${entry.action}]${text}`);
-				}
-				console.log("");
-			}
-		}, {
-			name: "quest",
-			description: "Quest workflow commands: review gates, resume from handoff",
-			execute: async (args) => {
-				const subCommand = args[0];
-				if (subCommand === "resume") {
-					const planId = args[1];
-					if (!planId) {
-						console.log("\nUsage: /quest resume <plan_id>");
-						console.log("  Loads the quest plan and displays the session handoff for continuity.\n");
-						return;
-					}
-					try {
-						const plan = await this.service.getQuestPlan(planId);
-						console.log(`\nQuest Plan: ${plan.goal}`);
-						console.log(`State: ${plan.state ?? "unknown"}`);
-						if (plan.metrics) {
-							const pct = Math.round(plan.metrics.completionRate * 100);
-							console.log(`Progress: ${plan.metrics.subQuestsCompleted}/${plan.metrics.subQuestsTotal} sub-quests (${pct}%)`);
-						}
-						if (!plan.handoff) {
-							console.log("\n  No handoff found — this plan has no saved session context.");
-							console.log("  The AI can still read the plan via tavern_get_quest_plan.\n");
-							return;
-						}
-						const { handoff } = plan;
-						console.log(`\nSession Handoff (${new Date(handoff.updatedAt).toLocaleString()}):`);
-						console.log(`\n  Summary: ${handoff.summary}`);
-						if (handoff.nextSteps.length > 0) {
-							console.log("\n  Next Steps:");
-							for (const step of handoff.nextSteps) console.log(`    \u2022 ${step}`);
-						}
-						if (handoff.pendingDecisions.length > 0) {
-							console.log("\n  Pending Decisions:");
-							for (const decision of handoff.pendingDecisions) console.log(`    \u2753 ${decision}`);
-						}
-						if (handoff.blockers.length > 0) {
-							console.log("\n  Blockers:");
-							for (const blocker of handoff.blockers) console.log(`    \u{1F6D1} ${blocker}`);
-						}
-						console.log("");
-					} catch (error) {
-						const message = error instanceof Error ? error.message : String(error);
-						console.log(`\nError fetching quest plan: ${message}\n`);
-					}
-					return;
-				}
-				if (subCommand === "review") {
-					const planId = args[1];
-					if (!planId) {
-						console.log("\nUsage: /quest review <plan_id>");
-						console.log("  Fetches the quest plan and shows sub-quests with pending review gates.\n");
-						return;
-					}
-					try {
-						const plan = await this.service.getQuestPlan(planId);
-						const pendingGates = [];
-						for (const quest of plan.quests) for (const sq of quest.subQuests) if (sq.reviewGate) pendingGates.push({
-							questTitle: quest.title,
-							questId: quest.id,
-							subQuestTitle: sq.title,
-							subQuestId: sq.id,
-							status: sq.reviewStatus ?? "pending"
-						});
-						if (pendingGates.length === 0) {
-							console.log(`\nQuest Plan: ${plan.goal}`);
-							console.log("  No review gates configured in this plan.\n");
-							return;
-						}
-						console.log(`\nQuest Plan: ${plan.goal}`);
-						console.log(`State: ${plan.state ?? "unknown"}\n`);
-						console.log("Review Gates:");
-						for (const gate of pendingGates) {
-							const icon = gate.status === "approved" ? "✅" : gate.status === "rejected" ? "❌" : "⏸️";
-							console.log(`  ${icon} [${gate.status}] ${gate.questTitle} > ${gate.subQuestTitle}`);
-							console.log(`     quest_id: ${gate.questId}  sub_quest_id: ${gate.subQuestId}`);
-						}
-						console.log("\n  To approve: ask the AI to approve a review gate, or use tavern_update_review_gate tool.\n");
-					} catch (error) {
-						const message = error instanceof Error ? error.message : String(error);
-						console.log(`\nError fetching quest plan: ${message}\n`);
-					}
-					return;
-				}
-				console.log("\nUsage:");
-				console.log("  /quest review <plan_id>  — Show review gates and their status");
-				console.log("  /quest resume <plan_id>  — Load handoff and resume from where you left off");
-				console.log("");
+	getHeaders() {
+		const headers = { "Content-Type": "application/json" };
+		if (this.token) headers["Authorization"] = `token ${this.token}`;
+		return headers;
+	}
+	async request(method, path, body) {
+		const url = `${this.serverUrl}${path}`;
+		const options = {
+			method,
+			headers: this.getHeaders()
+		};
+		if (body) options.body = JSON.stringify(body);
+		const response = await fetch(url, options);
+		if (!response.ok) {
+			let errorBody;
+			try {
+				errorBody = await response.json();
+			} catch {
+				errorBody = await response.text();
 			}
-		}];
+			throw new JupyterClientError(`Jupyter API error: ${response.status} ${response.statusText}`, response.status, errorBody);
+		}
+		if (response.status === 204) return {};
+		return response.json();
 	}
-	registerWsHandlers(wsManager) {
-		this.activityStream.registerHandlers(wsManager);
+	/**
+	* Check if the Jupyter server is running and accessible
+	*/
+	async checkStatus() {
+		return this.request("GET", "/api/status");
+	}
+	/**
+	* Get available kernel specifications
+	*/
+	async getKernelSpecs() {
+		return this.request("GET", "/api/kernelspecs");
 	}
-	dispose() {
-		this.activityStream.dispose();
+	/**
+	* List all active sessions
+	*/
+	async listSessions() {
+		return this.request("GET", "/api/sessions");
 	}
-};
-//#endregion
-//#region src/features/bridgePresence/BridgePresence.ts
-const DEFAULT_PORT = Number(process.env.CC_BRIDGE_PORT ?? 48732);
-const CONFIG_PATH = join(homedir(), ".b4m", "cc-bridge.json");
-const ANNOUNCE_TIMEOUT_MS = 2e3;
-async function readBridgeConfig() {
-	try {
-		const raw = await promises.readFile(CONFIG_PATH, "utf8");
-		const parsed = JSON.parse(raw);
-		if (typeof parsed.hookSecret !== "string" || !parsed.hookSecret) return null;
-		return {
-			port: typeof parsed.port === "number" ? parsed.port : DEFAULT_PORT,
-			hookSecret: parsed.hookSecret
-		};
-	} catch {
-		return null;
+	/**
+	* Start a new kernel session for a notebook
+	*/
+	async startSession(notebookPath, kernelName) {
+		validateNotebookPath(notebookPath);
+		const kernel = kernelName || "python3";
+		validateKernelName(kernel);
+		return this.request("POST", "/api/sessions", {
+			path: notebookPath,
+			type: "notebook",
+			name: notebookPath.split("/").pop() || "Untitled",
+			kernel: { name: kernel }
+		});
 	}
-}
-var BridgePresence = class {
-	constructor() {
-		this.config = null;
-		this.instanceId = null;
-		this.ws = null;
-		this.callbacks = {};
-		this.started = false;
-		this.stopped = false;
-		this.reconnectTimer = null;
-		this.reconnectAttempts = 0;
-		this.announceRetryTimer = null;
-		this.announceAttempts = 0;
-		this.startOpts = null;
-		this.pendingWorkspaceName = null;
-		this.pendingCapabilities = null;
-		this.pendingSource = null;
-		this.emitQueue = Promise.resolve();
+	/**
+	* Get a session by ID
+	*/
+	async getSession(sessionId) {
+		return this.request("GET", `/api/sessions/${sessionId}`);
 	}
-	setCallbacks(cbs) {
-		this.callbacks = cbs;
+	/**
+	* Stop a kernel session
+	*/
+	async stopSession(sessionId) {
+		await this.request("DELETE", `/api/sessions/${sessionId}`);
 	}
 	/**
-	* Probe the local bridge and, if present, announce this CLI session.
-	* Returns true iff the announce succeeded (tavern presence is active).
-	* Safe to call multiple times — second call no-ops.
-	*
-	* If announce fails (bridge absent or not yet up), a background retry
-	* loop keeps trying with bounded backoff so the sprite appears when the
-	* bridge comes online later in the CLI's lifetime.
+	* Get WebSocket URL for kernel channels
 	*/
-	async start(opts) {
-		if (this.started) return this.instanceId !== null;
-		this.stopped = false;
-		this.started = true;
-		const config = await readBridgeConfig();
-		if (!config) {
-			logger.debug("[tavern] cc-bridge not configured; CLI runs without tavern presence");
-			return false;
-		}
-		this.config = config;
-		this.startOpts = opts;
-		this.pendingWorkspaceName = opts.workspaceName ?? (basename(opts.workspacePath) || "workspace");
-		this.pendingCapabilities = opts.capabilities ?? ["interactive"];
-		this.pendingSource = opts.source ?? "b4m-cli";
-		return this.attemptAnnounce();
+	getKernelWebSocketUrl(kernelId) {
+		const httpUrl = new URL(this.serverUrl);
+		const wsUrl = `${httpUrl.protocol === "https:" ? "wss:" : "ws:"}//${httpUrl.host}/api/kernels/${kernelId}/channels`;
+		if (this.token) return `${wsUrl}?token=${this.token}`;
+		return wsUrl;
 	}
-	/** One announce attempt. Schedules a retry on failure; wires up the
-	*  command WS + initial status on success. Idempotent: re-entering after
-	*  a successful announce short-circuits at the instanceId guard. */
-	async attemptAnnounce() {
-		if (this.stopped || !this.config || !this.startOpts) return false;
-		if (this.instanceId) return true;
-		const instanceId = v4();
-		const workspaceName = this.pendingWorkspaceName;
-		const capabilities = this.pendingCapabilities;
-		const source = this.pendingSource;
-		if (!await this.announce({
-			instanceId,
-			source,
-			workspaceName,
-			workspacePath: this.startOpts.workspacePath,
-			capabilities
-		})) {
-			this.scheduleAnnounceRetry();
-			return false;
-		}
-		this.instanceId = instanceId;
-		this.announceAttempts = 0;
-		logger.info(`[tavern] announced ${workspaceName} to cc-bridge on 127.0.0.1:${this.config.port ?? DEFAULT_PORT}`);
-		this.connectCommandWs();
-		this.emitEvent({
-			type: "status",
-			status: "idle"
-		});
-		return true;
+	/**
+	* Generate a unique message ID for Jupyter protocol
+	*/
+	generateMsgId() {
+		return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
 	}
-	scheduleAnnounceRetry() {
-		if (this.stopped || this.announceRetryTimer) return;
-		this.announceAttempts += 1;
-		const delay = Math.min(1e3 * 2 ** (this.announceAttempts - 1), 3e4);
-		this.announceRetryTimer = setTimeout(() => {
-			this.announceRetryTimer = null;
-			this.attemptAnnounce();
-		}, delay);
+	/**
+	* Execute code in a kernel using the Jupyter WebSocket protocol.
+	*
+	* Connects to the kernel's channels WebSocket, sends an execute_request,
+	* and collects outputs until the kernel returns to idle state.
+	*
+	* @param kernelId - The kernel ID to execute code in
+	* @param code - The code to execute
+	* @param timeoutMs - Execution timeout in milliseconds (default: 30000)
+	*/
+	async executeCell(kernelId, code, timeoutMs = 3e4) {
+		const wsUrl = this.getKernelWebSocketUrl(kernelId);
+		const msgId = this.generateMsgId();
+		return new Promise((resolve, reject) => {
+			const outputs = [];
+			let executionCount = null;
+			let hasError = false;
+			let errorInfo;
+			const ws = new WsWebSocket(wsUrl);
+			const timeoutHandle = setTimeout(() => {
+				cleanup();
+				reject(new JupyterClientError(`Cell execution timed out after ${timeoutMs}ms`));
+			}, timeoutMs);
+			const cleanup = () => {
+				clearTimeout(timeoutHandle);
+				if (ws.readyState === WsWebSocket.OPEN || ws.readyState === WsWebSocket.CONNECTING) ws.close();
+			};
+			ws.on("error", (err) => {
+				cleanup();
+				reject(new JupyterClientError(`WebSocket error: ${err.message}`));
+			});
+			ws.on("open", () => {
+				const executeRequest = {
+					header: {
+						msg_id: msgId,
+						msg_type: "execute_request",
+						username: "b4m-cli",
+						session: this.generateMsgId(),
+						date: (/* @__PURE__ */ new Date()).toISOString(),
+						version: "5.3"
+					},
+					parent_header: {},
+					metadata: {},
+					content: {
+						code,
+						silent: false,
+						store_history: true,
+						user_expressions: {},
+						allow_stdin: false,
+						stop_on_error: true
+					},
+					buffers: [],
+					channel: "shell"
+				};
+				ws.send(JSON.stringify(executeRequest));
+			});
+			ws.on("message", (data) => {
+				try {
+					const msg = JSON.parse(data.toString());
+					if (msg.parent_header?.msg_id !== msgId) return;
+					switch (msg.header?.msg_type || msg.msg_type) {
+						case "stream":
+							outputs.push({
+								output_type: "stream",
+								name: msg.content.name,
+								text: msg.content.text
+							});
+							break;
+						case "execute_result":
+							executionCount = msg.content.execution_count;
+							outputs.push({
+								output_type: "execute_result",
+								data: msg.content.data,
+								execution_count: msg.content.execution_count,
+								metadata: msg.content.metadata
+							});
+							break;
+						case "display_data":
+							outputs.push({
+								output_type: "display_data",
+								data: msg.content.data,
+								metadata: msg.content.metadata
+							});
+							break;
+						case "error":
+							hasError = true;
+							errorInfo = {
+								ename: msg.content.ename,
+								evalue: msg.content.evalue,
+								traceback: msg.content.traceback
+							};
+							outputs.push({
+								output_type: "error",
+								ename: msg.content.ename,
+								evalue: msg.content.evalue,
+								traceback: msg.content.traceback
+							});
+							break;
+						case "execute_reply":
+							if (msg.content.status === "ok" || msg.content.status === "error") {
+								if (msg.content.execution_count !== void 0) executionCount = msg.content.execution_count;
+								cleanup();
+								resolve({
+									success: !hasError,
+									outputs,
+									executionCount,
+									error: errorInfo
+								});
+							}
+							break;
+						case "status": break;
+					}
+				} catch {}
+			});
+			ws.on("close", () => {
+				clearTimeout(timeoutHandle);
+			});
+		});
 	}
-	/** Emit an event for this session. No-op if the bridge isn't up. Events
-	*  leave in strict order — see `emitQueue` comment. */
-	async emitEvent(event) {
-		if (!this.config || !this.instanceId) return;
-		const task = () => this.post("/event", {
-			instanceId: this.instanceId,
-			event
-		}).catch((err) => logger.info(`[tavern] emitEvent ${event.type} failed: ${err.message}`));
-		this.emitQueue = this.emitQueue.then(task, task);
-		return this.emitQueue;
+	/**
+	* @deprecated Use executeCell instead. This method exists for backwards compatibility.
+	*/
+	async executeCode(kernelId, code) {
+		return this.executeCell(kernelId, code);
 	}
 	/**
-	* Tear down the tavern presence cleanly. Halts the announce-retry and
-	* command-WS reconnect loops, closes the socket, and best-effort signals
-	* disconnect to the bridge.
-	*
-	* After this resolves the instance is fully reset, so a later `start()`
-	* re-announces — the same singleton can be toggled off (Tavern feature
-	* disabled at runtime) and back on without restarting the CLI. The
-	* `stopped` latch is left true here purely so any straggler retry callback
-	* already queued short-circuits; `start()` clears it.
+	* Interrupt a running kernel
 	*/
-	async stop(reason = "cli_exit") {
-		if (this.stopped || !this.started) return;
-		this.stopped = true;
-		if (this.reconnectTimer) {
-			clearTimeout(this.reconnectTimer);
-			this.reconnectTimer = null;
-		}
-		if (this.announceRetryTimer) {
-			clearTimeout(this.announceRetryTimer);
-			this.announceRetryTimer = null;
-		}
-		if (this.ws) {
+	async interruptKernel(kernelId) {
+		await this.request("POST", `/api/kernels/${kernelId}/interrupt`);
+	}
+	/**
+	* Restart a kernel
+	*/
+	async restartKernel(kernelId) {
+		return this.request("POST", `/api/kernels/${kernelId}/restart`);
+	}
+};
+/**
+* Create a JupyterClient from environment variables or config
+*/
+function createJupyterClientFromEnv() {
+	const serverUrl = process.env.JUPYTER_SERVER_URL;
+	const token = process.env.JUPYTER_TOKEN;
+	if (!serverUrl) return null;
+	return new JupyterClient({
+		serverUrl,
+		token
+	});
+}
+//#endregion
+//#region src/commands/executeNotebookHandler.ts
+/**
+* Jupyter Notebook Execution Handler
+*
+* Handles the jupyter_execute_notebook Keep command.
+* Orchestrates cell-by-cell execution of a notebook via local Jupyter server.
+*/
+/**
+* Zod schema for validating execute notebook parameters.
+* Replaces unsafe `as` casts with proper runtime validation.
+*/
+const ExecuteNotebookParams = z.object({
+	notebookJson: z.string().min(1, "notebookJson is required"),
+	sessionId: z.string().min(1, "sessionId is required"),
+	kernelName: z.string().default("python3"),
+	timeoutPerCell: z.number().default(3e4)
+});
+/**
+* Get cell source as string (handles both string and string[] formats).
+*/
+function getCellSource(cell) {
+	return Array.isArray(cell.source) ? cell.source.join("") : cell.source;
+}
+/**
+* Execute a Jupyter notebook cell by cell.
+*
+* @param params - Validated notebook execution parameters
+* @param deps - Dependencies (jupyter client, websocket manager, logger)
+* @returns Execution result with success status and executed notebook
+*/
+async function executeNotebook(params, deps) {
+	const { jupyterClient, wsManager, logger, requestId } = deps;
+	const { notebookJson, sessionId, kernelName, timeoutPerCell } = ExecuteNotebookParams.parse(params);
+	let notebook;
+	try {
+		notebook = JSON.parse(notebookJson);
+		if (!notebook.cells || !Array.isArray(notebook.cells)) throw new Error("Invalid notebook: missing cells array");
+	} catch (parseErr) {
+		throw new Error(`Failed to parse notebook JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+	}
+	const totalCodeCells = notebook.cells.filter((c) => c.cell_type === "code").length;
+	logger.info(`[Keep] Starting notebook execution: ${totalCodeCells} code cells, kernel: ${kernelName}`);
+	const tempNotebookPath = `/tmp/b4m-notebook-${randomUUID()}.ipynb`;
+	await promises.writeFile(tempNotebookPath, notebookJson, "utf-8");
+	let jupyterSession = null;
+	let cellsExecuted = 0;
+	let cellsFailed = 0;
+	try {
+		logger.info(`[Keep] Starting Jupyter kernel: ${kernelName}`);
+		jupyterSession = await jupyterClient.startSession(tempNotebookPath, kernelName);
+		const kernelId = jupyterSession.kernel.id;
+		const jupyterSessionId = jupyterSession.id;
+		logger.info(`[Keep] Kernel started: session=${jupyterSessionId}, kernel=${kernelId}`);
+		let codeCellIndex = 0;
+		for (let i = 0; i < notebook.cells.length; i++) {
+			const cell = notebook.cells[i];
+			if (cell.cell_type !== "code") continue;
+			const cellCode = getCellSource(cell);
+			if (!cellCode.trim()) {
+				codeCellIndex++;
+				continue;
+			}
+			logger.info(`[Keep] Executing cell ${codeCellIndex + 1}/${totalCodeCells}`);
+			wsManager?.send({
+				action: "jupyter_cell_output",
+				requestId,
+				sessionId,
+				jupyterSessionId,
+				cellIndex: codeCellIndex,
+				outputType: "stream",
+				content: {
+					text: `Executing cell ${codeCellIndex + 1}/${totalCodeCells}...`,
+					name: "stdout"
+				},
+				executionCount: null,
+				isComplete: false
+			});
 			try {
-				this.ws.close();
-			} catch {}
-			this.ws = null;
+				const cellResult = await jupyterClient.executeCell(kernelId, cellCode, timeoutPerCell);
+				cell.outputs = cellResult.outputs;
+				cell.execution_count = cellResult.executionCount;
+				if (cellResult.success) {
+					cellsExecuted++;
+					wsManager?.send({
+						action: "jupyter_cell_output",
+						requestId,
+						sessionId,
+						jupyterSessionId,
+						cellIndex: codeCellIndex,
+						outputType: "execute_result",
+						content: {
+							text: cellResult.outputs.map((o) => {
+								if (o.text) return Array.isArray(o.text) ? o.text.join("") : o.text;
+								if (o.data && typeof o.data === "object" && "text/plain" in o.data) {
+									const textPlain = o.data["text/plain"];
+									return Array.isArray(textPlain) ? textPlain.join("") : String(textPlain);
+								}
+								return "";
+							}).join(""),
+							data: cellResult.outputs.find((o) => o.data)?.data
+						},
+						executionCount: cellResult.executionCount,
+						isComplete: true
+					});
+				} else {
+					cellsFailed++;
+					wsManager?.send({
+						action: "jupyter_cell_output",
+						requestId,
+						sessionId,
+						jupyterSessionId,
+						cellIndex: codeCellIndex,
+						outputType: "error",
+						content: {
+							ename: cellResult.error?.ename || "ExecutionError",
+							evalue: cellResult.error?.evalue || "Cell execution failed",
+							traceback: cellResult.error?.traceback || []
+						},
+						executionCount: cellResult.executionCount,
+						isComplete: true
+					});
+					logger.warn(`[Keep] Cell ${codeCellIndex + 1} failed: ${cellResult.error?.ename}: ${cellResult.error?.evalue}`);
+				}
+			} catch (cellErr) {
+				cellsFailed++;
+				const errMsg = cellErr instanceof Error ? cellErr.message : String(cellErr);
+				wsManager?.send({
+					action: "jupyter_cell_output",
+					requestId,
+					sessionId,
+					jupyterSessionId,
+					cellIndex: codeCellIndex,
+					outputType: "error",
+					content: {
+						ename: "ExecutionError",
+						evalue: errMsg,
+						traceback: []
+					},
+					executionCount: null,
+					isComplete: true
+				});
+				logger.error(`[Keep] Cell ${codeCellIndex + 1} threw error: ${errMsg}`);
+			}
+			codeCellIndex++;
 		}
-		if (this.config && this.instanceId) await this.post("/disconnect", {
-			instanceId: this.instanceId,
-			reason
-		}).catch(() => {});
-		this.started = false;
-		this.instanceId = null;
-		this.config = null;
-		this.startOpts = null;
-		this.pendingWorkspaceName = null;
-		this.pendingCapabilities = null;
-		this.pendingSource = null;
-		this.announceAttempts = 0;
-		this.reconnectAttempts = 0;
-		this.emitQueue = Promise.resolve();
+		return {
+			success: cellsFailed === 0,
+			cellsExecuted,
+			cellsFailed,
+			totalCodeCells,
+			executedNotebook: JSON.stringify(notebook)
+		};
+	} finally {
+		if (jupyterSession) try {
+			logger.info(`[Keep] Stopping Jupyter session: ${jupyterSession.id}`);
+			await jupyterClient.stopSession(jupyterSession.id);
+		} catch (stopErr) {
+			logger.warn(`[Keep] Failed to stop session: ${stopErr instanceof Error ? stopErr.message : String(stopErr)}`);
+		}
+		try {
+			await promises.unlink(tempNotebookPath);
+		} catch {}
 	}
-	async announce(body) {
+}
+//#endregion
+//#region src/bootstrap/registerKeepHandlers.ts
+/**
+* Get a configured JupyterClient or throw an error if not configured.
+* Centralizes the Jupyter configuration check for all Jupyter Keep commands.
+*/
+function getRequiredJupyterClient() {
+	const client = createJupyterClientFromEnv();
+	if (!client) throw new Error("Jupyter not configured. Set JUPYTER_SERVER_URL and optionally JUPYTER_TOKEN environment variables.");
+	return client;
+}
+/**
+* Register the Keep command handler on a connected WebSocket manager — allows
+* the web HUD to execute commands on this machine via the B4M cloud relay.
+*
+* Pure bootstrap seam: no React hooks, no Zustand state. The connected
+* `wsManager` is passed in by the caller. Invoked from `buildLlmBackend`'s
+* `onWsConnected` callback at exactly the point the original inline registration
+* ran, so a registration throw still propagates into the WS try/catch and
+* triggers the SSE fallback.
+*/
+function registerKeepHandlers(wsManager) {
+	wsManager.onAction("keep_command", async (message) => {
+		const { commandType, params, requestId, originConnectionId } = message;
+		let result;
+		let success = true;
+		let error;
 		try {
-			await this.post("/announce", body);
-			return true;
+			switch (commandType) {
+				case "read_file": {
+					const filePath = params.path;
+					if (!filePath) throw new Error("Missing required param: path");
+					logger.info(`[Keep] Reading file: ${filePath}`);
+					result = {
+						content: await promises.readFile(filePath, "utf-8"),
+						path: filePath
+					};
+					break;
+				}
+				case "list_directory": {
+					const dirPath = params.path || ".";
+					logger.info(`[Keep] Listing directory: ${dirPath}`);
+					result = (await promises.readdir(dirPath, { withFileTypes: true })).map((e) => ({
+						name: e.name,
+						isDirectory: e.isDirectory()
+					}));
+					break;
+				}
+				case "jupyter_get_kernelspecs":
+					logger.info("[Keep] Getting Jupyter kernel specs");
+					result = await getRequiredJupyterClient().getKernelSpecs();
+					break;
+				case "jupyter_start_kernel": {
+					const notebookPath = params.notebookPath;
+					const kernelName = params.kernelName;
+					logger.info(`[Keep] Starting Jupyter kernel for: ${notebookPath}`);
+					result = await getRequiredJupyterClient().startSession(notebookPath, kernelName);
+					break;
+				}
+				case "jupyter_stop_kernel": {
+					const sessionId = params.sessionId;
+					if (!sessionId) throw new Error("Missing required param: sessionId");
+					logger.info(`[Keep] Stopping Jupyter session: ${sessionId}`);
+					await getRequiredJupyterClient().stopSession(sessionId);
+					result = {
+						success: true,
+						sessionId
+					};
+					break;
+				}
+				case "jupyter_execute_cell": {
+					const code = params.code;
+					const kernelId = params.kernelId;
+					const timeoutMs = params.timeoutMs || 3e4;
+					if (!code) throw new Error("Missing required param: code");
+					if (!kernelId) throw new Error("Missing required param: kernelId");
+					logger.info(`[Keep] Executing cell (kernel: ${kernelId}, code length: ${code.length})`);
+					const cellResult = await getRequiredJupyterClient().executeCell(kernelId, code, timeoutMs);
+					logger.info(`[Keep] Cell execution ${cellResult.success ? "succeeded" : "failed"} (outputs: ${cellResult.outputs.length}, execution_count: ${cellResult.executionCount})`);
+					result = {
+						success: cellResult.success,
+						outputs: cellResult.outputs,
+						executionCount: cellResult.executionCount,
+						error: cellResult.error
+					};
+					break;
+				}
+				case "jupyter_execute_notebook":
+					result = await executeNotebook(params, {
+						jupyterClient: getRequiredJupyterClient(),
+						wsManager,
+						logger,
+						requestId
+					});
+					break;
+				default: throw new Error(`Unknown command type: ${commandType}`);
+			}
 		} catch (err) {
-			logger.info(`[tavern] bridge announce failed: ${err.message}`);
-			return false;
+			success = false;
+			error = err instanceof Error ? err.message : String(err);
 		}
-	}
-	async post(path, body) {
-		if (!this.config) throw new Error("bridge config not loaded");
-		const url = `http://127.0.0.1:${this.config.port ?? DEFAULT_PORT}${path}?secret=${encodeURIComponent(this.config.hookSecret)}`;
-		const res = await fetch(url, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(body),
-			signal: AbortSignal.timeout(ANNOUNCE_TIMEOUT_MS)
+		logger.info(`[Keep] Sending response: success=${success}, originConnectionId=${originConnectionId?.slice(0, 12)}..., resultSize=${JSON.stringify(result)?.length ?? 0}`);
+		try {
+			wsManager.send({
+				action: "keep_command_response",
+				requestId,
+				originConnectionId,
+				success,
+				result,
+				error
+			});
+			logger.info("[Keep] Response sent successfully");
+		} catch (sendErr) {
+			logger.info(`[Keep] Failed to send response: ${sendErr instanceof Error ? sendErr.message : String(sendErr)}`);
+		}
+	});
+}
+//#endregion
+//#region src/bootstrap/buildLlmBackend.ts
+/** Production wiring: real transport classes + the ToolRouter singleton. */
+const defaultLlmBackendDeps = {
+	connectWebSocket: async (wsUrl, tokenGetter) => {
+		const ws = new WebSocketConnectionManager(wsUrl, tokenGetter);
+		await ws.connect();
+		return ws;
+	},
+	installWebSocketToolExecutor: (ws, tokenGetter) => {
+		setWebSocketToolExecutor(new WebSocketToolExecutor(ws, tokenGetter));
+	},
+	clearWebSocketToolExecutor: () => setWebSocketToolExecutor(null),
+	createWebSocketBackend: (opts) => new WebSocketLlmBackend(opts),
+	createServerBackend: (opts) => new ServerLlmBackend(opts),
+	registerKeepHandlers,
+	createOllamaBackend: (host) => new OllamaBackend(host, {
+		debug: (...args) => logger.debug(args.map(String).join(" ")),
+		info: (...args) => logger.info(args.map(String).join(" ")),
+		warn: (...args) => logger.warn(args.map(String).join(" ")),
+		error: (...args) => logger.error(args.map(String).join(" "))
+	}),
+	createMultiBackend: (server, ollama, serverModels, ollamaModels, defaultModel) => new MultiLlmBackend(server, ollama, serverModels, ollamaModels, defaultModel)
+};
+/**
+* Resolve the model to use from the available list: the requested default if
+* present, otherwise the first available model. Pure — exported for testing.
+*/
+function resolveModelInfo(models, defaultModel) {
+	return models.find((m) => m.id === defaultModel) || models[0];
+}
+/**
+* Build the LLM backend: WebSocket transport first (bypasses CloudFront 20s
+* timeout), SSE fallback, optional Ollama multiplexing. Resolves the default
+* model and pins it on the backend.
+*
+* Pure bootstrap seam — no React hooks, no Zustand state. The WS path registers
+* the Keep command handler inline (inside the same try-block) so a registration
+* throw still triggers the SSE fallback, exactly as before. The tool-executor
+* install/clear ordering (set on connect, cleared on fallback) is preserved.
+*/
+async function buildLlmBackend(input, deps = defaultLlmBackendDeps) {
+	const { config, apiClient, tokenGetter, startupLog } = input;
+	let wsManager = null;
+	let llm;
+	let completionsUrl;
+	try {
+		const serverConfig = await apiClient.get("/api/settings/serverConfig");
+		const wsUrl = serverConfig?.websocketUrl;
+		const wsCompletionUrl = serverConfig?.wsCompletionUrl;
+		completionsUrl = serverConfig?.completionsUrl;
+		if (wsUrl && wsCompletionUrl) {
+			wsManager = await deps.connectWebSocket(wsUrl, tokenGetter);
+			deps.installWebSocketToolExecutor(wsManager, tokenGetter);
+			llm = deps.createWebSocketBackend({
+				wsManager,
+				apiClient,
+				model: config.defaultModel,
+				tokenGetter,
+				wsCompletionUrl
+			});
+			deps.registerKeepHandlers(wsManager);
+			logger.debug("🔌 Using WebSocket transport (bypasses CloudFront timeout)");
+		} else throw new Error("No websocketUrl or wsCompletionUrl in server config");
+	} catch (wsError) {
+		logger.debug("⚠️  WebSocket unavailable, using SSE fallback");
+		logger.debug(`[WebSocket] Fallback reason: ${wsError instanceof Error ? wsError.message : String(wsError)}`);
+		if (wsError instanceof Error && wsError.stack) logger.debug(`[WebSocket] Stack: ${wsError.stack}`);
+		wsManager = null;
+		deps.clearWebSocketToolExecutor();
+		llm = deps.createServerBackend({
+			apiClient,
+			model: config.defaultModel,
+			completionsUrl
 		});
-		if (!res.ok) throw new Error(`bridge ${path} -> ${res.status}`);
 	}
-	connectCommandWs() {
-		if (this.stopped || !this.config || !this.instanceId) return;
-		const url = `ws://127.0.0.1:${this.config.port ?? DEFAULT_PORT}/commands?instanceId=${encodeURIComponent(this.instanceId)}&secret=${encodeURIComponent(this.config.hookSecret)}`;
-		let ws;
+	const ollamaHost = input.ollamaHost ?? process.env.B4M_OLLAMA_HOST;
+	let models;
+	if (ollamaHost) {
+		const ollamaBackend = deps.createOllamaBackend(ollamaHost);
+		const [serverModels, ollamaModels] = await Promise.all([llm.getModelInfo(), ollamaBackend.getModelInfo()]);
+		if (serverModels.length === 0 && ollamaModels.length === 0) throw new Error(`No models available from server or Ollama at ${ollamaHost}.\nPull a model: ollama pull qwen3.5`);
+		if (ollamaModels.length === 0) startupLog.push(`⚠️  No models found in Ollama at ${ollamaHost}. Pull one with: ollama pull qwen3.5`);
+		const serverBackend = llm;
+		llm = deps.createMultiBackend(serverBackend, ollamaBackend, serverModels, ollamaModels, config.defaultModel);
+		models = await llm.getModelInfo();
+		startupLog.push(`🦙 Self-hosted Ollama: ${ollamaModels.length} model(s) added to picker`);
+	} else {
+		models = await llm.getModelInfo();
+		if (models.length === 0) throw new Error("No models available from server.");
+	}
+	logger.debug(`📋 Available models: ${models.map((m) => m.id).join(", ")}`);
+	const modelInfo = resolveModelInfo(models, config.defaultModel);
+	if (modelInfo.id !== config.defaultModel) {
+		logger.warn(`⚠️  Requested model '${config.defaultModel}' not available`);
+		logger.warn(`🤖 Using fallback model: ${modelInfo.id}`);
+	}
+	llm.currentModel = modelInfo.id;
+	return {
+		llm,
+		wsManager,
+		models,
+		modelInfo
+	};
+}
+//#endregion
+//#region src/bootstrap/buildSandbox.ts
+/**
+* Initialize the sandbox orchestrator for OS-level filesystem isolation, wire
+* the network-proxy event handler, attach the violation store, and start the
+* proxy when enabled.
+*
+* Pure bootstrap seam — no React hooks, no Zustand state. Sandbox modules are
+* imported dynamically (as before) so the cost is only paid when init runs.
+*/
+async function buildSandbox(input) {
+	const { config, sessionId, permissionManager, checkpointStore } = input;
+	const [{ createSandboxRuntime }, { SandboxOrchestrator }, { DEFAULT_SANDBOX_CONFIG }, { ProxyManager }, { ViolationLogStore }] = await Promise.all([
+		import("./SandboxRuntimeAdapter-CKelGICD.mjs"),
+		import("./SandboxOrchestrator-BS6gALNq.mjs"),
+		import("./types-CqscS34o.mjs"),
+		import("./ProxyManager-ByuAHFMq.mjs"),
+		import("./ViolationLogStore-B-plqJfn.mjs")
+	]);
+	const sandboxConfig = config.sandbox ?? DEFAULT_SANDBOX_CONFIG;
+	const [sandboxRuntime] = await Promise.all([createSandboxRuntime(), checkpointStore.init(sessionId).catch(() => {})]);
+	const proxyManager = new ProxyManager(sandboxConfig.network);
+	const sandboxOrchestrator = new SandboxOrchestrator(sandboxConfig, sandboxRuntime, proxyManager);
+	proxyManager.onEvent((event) => {
+		if (event.type === "blocked") {
+			console.error(`\n\x1b[41m\x1b[97m BLOCKED \x1b[0m \x1b[31mNetwork proxy denied connection to\x1b[0m \x1b[1m${event.domain}\x1b[0m \x1b[90m(${event.method})\x1b[0m`);
+			console.error(`\x1b[90m  Tip: /sandbox:trust-domain ${event.domain}\x1b[0m\n`);
+			sandboxOrchestrator.recordViolation({
+				type: "network",
+				domain: event.domain,
+				command: `[network] ${event.method} ${event.domain}`,
+				blockedBy: "proxy",
+				timestamp: event.timestamp,
+				detail: `Blocked ${event.method} to ${event.domain}`
+			}).catch(() => {});
+		}
+	});
+	const violationStore = new ViolationLogStore();
+	sandboxOrchestrator.setViolationStore(violationStore);
+	permissionManager.setSandboxState(sandboxConfig.mode, sandboxOrchestrator.isActive());
+	if (sandboxConfig.enabled && sandboxConfig.mode !== "disabled") {
+		if (sandboxRuntime) console.log(`🔒 Sandbox: ${sandboxConfig.mode} (${sandboxRuntime.name})`);
+		else console.log("⚠️  Sandbox: enabled but runtime not available on this platform");
+		if (sandboxConfig.network.enabled) {
+			await proxyManager.start();
+			if (proxyManager.isRunning()) console.log(`🌐 Network proxy: filtering on port ${proxyManager.getPort()} (${sandboxConfig.network.allowedDomains.length} domains)`);
+		}
+	}
+	return { sandboxOrchestrator };
+}
+//#endregion
+//#region src/bootstrap/buildSupportingStores.ts
+/**
+* Build the supporting stores and orchestration the agent needs: CLI tools
+* (permission-wrapped + server-routed), MCP manager, agent store, context
+* files, the deferred-tool registry partition, the subagent orchestrator, and
+* the background-agent manager.
+*
+* Pure bootstrap seam — no React hooks, no Zustand state. React-owned values
+* (permission/user-question prompt functions, the agent context, and the
+* background-agent status callbacks) are passed in. Tool *assembly* that weaves
+* the React workflow-store refs (decision/blocker/review-gate tools) stays in
+* the shell; this module returns only the agent-construction materials.
+*/
+async function buildSupportingStores(input) {
+	const { config, llm, modelId, permissionManager, apiClient, configStore, customCommandStore, checkpointStore, sandboxOrchestrator, additionalDirectories, agentContext, promptFn, userQuestionFn, startupLog, silentLogger, onBackgroundStatusChange, onGroupCompletion } = input;
+	const { tools: b4mTools } = await generateCliTools(config.userId, llm, modelId, permissionManager, promptFn, agentContext, configStore, apiClient, void 0, userQuestionFn, checkpointStore, sandboxOrchestrator, additionalDirectories);
+	const mcpManager = new McpManager(config);
+	const builtinAgentsDir = new URL("../agents/defaults/", import.meta.url).pathname;
+	const agentProjectDir = configStore.getProjectConfigDir();
+	const agentStore = new AgentStore(builtinAgentsDir, agentProjectDir || process.cwd());
+	const [, , contextResult] = await Promise.all([
+		mcpManager.initialize(),
+		agentStore.loadAgents(),
+		loadContextFiles(agentProjectDir)
+	]);
+	const mcpTools = mcpManager.getTools();
+	const deferredB4mToolNames = new Set([
+		"math_evaluate",
+		"dice_roll",
+		"current_datetime",
+		"recent_changes",
+		"prompt_enhancement"
+	]);
+	const deferredB4mTools = b4mTools.filter((t) => deferredB4mToolNames.has(t.toolSchema.name));
+	const loadedB4mTools = b4mTools.filter((t) => !deferredB4mToolNames.has(t.toolSchema.name));
+	deferredToolRegistry.register([...mcpTools, ...deferredB4mTools]);
+	if (mcpTools.length > 0) {
+		const serverSummaries = mcpManager.getToolCount().map((s) => `${s.serverName} (${s.count})`).join(", ");
+		startupLog.push(`🛠️ Loaded ${loadedB4mTools.length} B4M + ${mcpTools.length} MCP tool(s, ${deferredB4mTools.length + mcpTools.length} deferred): ${serverSummaries}`);
+	} else {
+		const suffix = deferredB4mTools.length > 0 ? ` (${deferredB4mTools.length} deferred)` : "";
+		startupLog.push(`🛠️ Loaded ${loadedB4mTools.length} B4M tool(s)${suffix}, no MCP tools`);
+	}
+	const agentSummary = agentStore.getSummary();
+	startupLog.push(`🤖 Loaded ${agentSummary.total} agent(s): ${agentSummary.builtin} built-in, ${agentSummary.global} global, ${agentSummary.project} project`);
+	const orchestrator = new SubagentOrchestrator({
+		userId: config.userId,
+		llm,
+		logger: silentLogger,
+		permissionManager,
+		showPermissionPrompt: promptFn,
+		configStore,
+		apiClient,
+		agentStore,
+		customCommandStore,
+		enableParallelToolExecution: config.preferences.enableParallelToolExecution === true,
+		showUserQuestion: userQuestionFn,
+		checkpointStore
+	});
+	const backgroundManager = new BackgroundAgentManager(orchestrator);
+	backgroundManager.setOnStatusChange(onBackgroundStatusChange);
+	backgroundManager.setOnGroupCompletion(onGroupCompletion);
+	return {
+		mcpManager,
+		agentStore,
+		contextResult,
+		mcpTools,
+		loadedB4mTools,
+		deferredB4mTools,
+		orchestrator,
+		backgroundManager
+	};
+}
+//#endregion
+//#region src/bootstrap/buildAgent.ts
+/**
+* Construct the main ReAct agent with the system prompt selected by config
+* variant, wire the tool_search closure to the agent's live tools array, and
+* record the agent in the shared observation context.
+*
+* Pure bootstrap seam — no React hooks, no Zustand state. The interaction-mode
+* subscription (`useCliStore.subscribe`) stays in the shell and uses the
+* returned `buildPromptForMode`. Ordering is load-bearing: agent built →
+* agentToolsRef wired → agentContext.currentAgent set, all here, before the
+* shell registers the subscription (which guards on currentAgent === agent).
+*/
+function buildAgent(input) {
+	const { config, modelId, notifyingLlm, allTools, agentContext, agentToolsRef, silentLogger, sessionId, initialInteractionMode, contextContent, agentStore, customCommandStore, enableSkillTool, additionalDirectories, featureModulePrompts } = input;
+	const promptVariant = config.preferences.promptVariant ?? "current";
+	const buildPromptForMode = (mode) => buildSystemPrompt(promptVariant, {
+		contextContent,
+		agentStore,
+		customCommands: customCommandStore.getAllCommands(),
+		enableSkillTool,
+		enableDynamicAgentCreation: config.preferences.enableDynamicAgentCreation === true,
+		additionalDirectories,
+		featureModulePrompts: featureModulePrompts || void 0,
+		planModeFilePath: mode === "plan" ? getPlanModeFilePath(sessionId) : void 0,
+		appendSystemPrompt: process.env.B4M_APPEND_SYSTEM_PROMPT,
+		deferredToolNames: deferredToolRegistry.getDirectoryNames()
+	});
+	const cliSystemPrompt = buildPromptForMode(initialInteractionMode);
+	const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
+	const agent = new ReActAgent({
+		userId: config.userId,
+		logger: silentLogger,
+		llm: notifyingLlm,
+		model: modelId,
+		tools: allTools,
+		maxIterations,
+		maxTokens: config.preferences.maxTokens,
+		temperature: config.preferences.temperature,
+		systemPrompt: cliSystemPrompt,
+		unknownToolResolver: async (toolName) => deferredToolRegistry.get(toolName) ?? null
+	});
+	agentToolsRef.current = agent.getTools();
+	agentContext.currentAgent = agent;
+	return {
+		agent,
+		buildPromptForMode
+	};
+}
+//#endregion
+//#region src/bootstrap/wireAgentEvents.ts
+/**
+* Wire the main agent's step events to the UI store and the tavern transcript,
+* and mirror the same handlers onto delegated subagents via the orchestrator's
+* before/after-run callbacks.
+*
+* Bootstrap seam: no React hooks, no useRef, no subscriptions. It reads/writes
+* the Zustand store via `getState()` (the same runtime-access pattern the agent
+* step handlers already used) and emits tavern events through the bridge
+* singleton — neither owns React-lifecycle state.
+*/
+function wireAgentEvents(input) {
+	const { agent, agentContext, orchestrator } = input;
+	agent.observationQueue = agentContext.observationQueue;
+	const stepHandler = (step) => {
+		const { pendingMessages, updatePendingMessage } = useCliStore.getState();
+		const lastIdx = pendingMessages.length - 1;
+		if (lastIdx >= 0 && pendingMessages[lastIdx].role === "assistant") {
+			const existingSteps = pendingMessages[lastIdx].metadata?.steps || [];
+			const formattedStep = formatStep(step);
+			updatePendingMessage(lastIdx, {
+				...pendingMessages[lastIdx],
+				metadata: {
+					...pendingMessages[lastIdx].metadata,
+					steps: [...existingSteps, formattedStep]
+				}
+			});
+		}
+	};
+	agent.on("thought", stepHandler);
+	agent.on("observation", stepHandler);
+	agent.on("action", stepHandler);
+	const pendingToolUseIds = /* @__PURE__ */ new Map();
+	const summarizeToolInput = (input) => {
+		if (input == null) return void 0;
+		if (typeof input === "string") return input.slice(0, 240);
 		try {
-			ws = new WsWebSocket(url);
-		} catch (err) {
-			logger.debug(`[tavern] command WS construct failed: ${err.message}`);
-			this.scheduleReconnect();
+			return JSON.stringify(input).slice(0, 240);
+		} catch {
 			return;
 		}
-		this.ws = ws;
-		ws.on("open", () => {
-			this.reconnectAttempts = 0;
-			logger.debug("[tavern] command WS open");
+	};
+	const tavernActionHandler = (step) => {
+		const toolName = step.metadata?.toolName ?? "tool";
+		const toolUseId = `${toolName}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		const queue = pendingToolUseIds.get(toolName) ?? [];
+		queue.push(toolUseId);
+		pendingToolUseIds.set(toolName, queue);
+		bridgePresence.emitEvent({
+			type: "tool_use",
+			tool: toolName,
+			toolUseId,
+			text: summarizeToolInput(step.metadata?.toolInput)
 		});
-		ws.on("message", (raw) => {
-			let frame = null;
-			try {
-				frame = JSON.parse(raw.toString());
-			} catch {
-				logger.debug("[tavern] malformed command frame; ignored");
-				return;
+	};
+	const tavernObservationHandler = (step) => {
+		const toolName = step.metadata?.toolName;
+		let toolUseId;
+		if (toolName) {
+			const queue = pendingToolUseIds.get(toolName);
+			if (queue && queue.length > 0) {
+				toolUseId = queue.shift();
+				if (queue.length === 0) pendingToolUseIds.delete(toolName);
+			}
+		}
+		if (!toolUseId) {
+			for (const [name, queue] of pendingToolUseIds.entries()) if (queue.length > 0) {
+				toolUseId = queue.shift();
+				if (queue.length === 0) pendingToolUseIds.delete(name);
+				break;
 			}
-			if (!frame?.command) return;
-			this.dispatchCommand(frame.command).catch((err) => logger.warn(`[tavern] command dispatch threw: ${err.message}`));
-		});
-		ws.on("close", () => {
-			this.ws = null;
-			if (this.stopped) return;
-			logger.debug("[tavern] command WS closed; reconnecting");
-			this.scheduleReconnect();
+		}
+		if (!toolUseId) toolUseId = `orphan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		bridgePresence.emitEvent({
+			type: "tool_result",
+			tool: toolName,
+			toolUseId,
+			text: typeof step.content === "string" ? step.content.slice(0, 4e3) : void 0
 		});
-		ws.on("error", (err) => {
-			logger.debug(`[tavern] command WS error: ${err.message}`);
+	};
+	const tavernFinalAnswerHandler = (step) => {
+		const text = typeof step.content === "string" ? step.content : "";
+		if (!text) return;
+		bridgePresence.emitEvent({
+			type: "message",
+			role: "assistant",
+			text: text.slice(0, 4e3)
 		});
-	}
-	scheduleReconnect() {
-		if (this.stopped || this.reconnectTimer) return;
-		this.reconnectAttempts += 1;
-		const delay = Math.min(500 * 2 ** (this.reconnectAttempts - 1), 1e4);
-		this.reconnectTimer = setTimeout(() => {
-			this.reconnectTimer = null;
-			this.connectCommandWs();
-		}, delay);
-	}
-	async dispatchCommand(command) {
-		switch (command.type) {
-			case "send_prompt":
-				if (this.callbacks.onSendPrompt) await this.callbacks.onSendPrompt(command.text);
-				break;
-			case "resolve_permission":
-				if (this.callbacks.onResolvePermission) await this.callbacks.onResolvePermission(command.requestId, command.allow);
-				break;
-			case "abort":
-				if (this.callbacks.onAbort) await this.callbacks.onAbort();
-				break;
-		}
-	}
-};
-/** Process-wide singleton — the CLI only ever has one tavern presence per run. */
-const bridgePresence = new BridgePresence();
+	};
+	agent.on("action", tavernActionHandler);
+	agent.on("observation", tavernObservationHandler);
+	agent.on("final_answer", tavernFinalAnswerHandler);
+	orchestrator.setBeforeRunCallback((subagent, _subagentType) => {
+		subagent.on("thought", stepHandler);
+		subagent.on("observation", stepHandler);
+		subagent.on("action", stepHandler);
+		subagent.on("action", tavernActionHandler);
+		subagent.on("observation", tavernObservationHandler);
+		subagent.on("final_answer", tavernFinalAnswerHandler);
+	});
+	orchestrator.setAfterRunCallback((subagent, _subagentType) => {
+		subagent.off("thought", stepHandler);
+		subagent.off("observation", stepHandler);
+		subagent.off("action", stepHandler);
+		subagent.off("action", tavernActionHandler);
+		subagent.off("observation", tavernObservationHandler);
+		subagent.off("final_answer", tavernFinalAnswerHandler);
+	});
+}
 //#endregion
 //#region src/index.tsx
 process.removeAllListeners("warning");
@@ -5922,15 +6427,6 @@ process.on("warning", (warning) => {
 	console.warn(warning);
 });
 /**
-* Get a configured JupyterClient or throw an error if not configured.
-* Centralizes the Jupyter configuration check for all Jupyter Keep commands.
-*/
-function getRequiredJupyterClient() {
-	const client = createJupyterClientFromEnv();
-	if (!client) throw new Error("Jupyter not configured. Set JUPYTER_SERVER_URL and optionally JUPYTER_TOKEN environment variables.");
-	return client;
-}
-/**
 * Render the first question from a UserQuestion payload as a 240-char-capped
 * summary for tavern status events. Returns undefined if the payload has no
 * questions (defensive: payload.questions[0]?.question is typed string but
@@ -6171,162 +6667,23 @@ function CliApp() {
 			const envName = getEnvironmentName(config.apiConfig);
 			startupLog.unshift(`🌍 API Environment: ${envName} (${apiBaseURL})`);
 			const apiClient = new ApiClient(apiBaseURL, state.configStore);
+			if (process.env.B4M_NO_REMOTE_SKILLS !== "1" && config.preferences.enableRemoteSkills !== false) try {
+				state.customCommandStore.setRemoteSource(new RemoteSkillSource(apiClient));
+				await state.customCommandStore.mergeRemoteCommands();
+				const remoteCount = state.customCommandStore.getCommandsBySource("remote").length;
+				if (remoteCount > 0) startupLog.push(`☁️  Synced ${remoteCount} skill${remoteCount === 1 ? "" : "s"} from B4M web`);
+			} catch (error) {
+				console.warn("Failed to sync remote skills:", error instanceof Error ? error.message : String(error));
+			}
 			const tokenGetter = async () => {
 				return (await state.configStore.getAuthTokens())?.accessToken ?? null;
 			};
-			let wsManager = null;
-			let llm;
-			let completionsUrl;
-			try {
-				const serverConfig = await apiClient.get("/api/settings/serverConfig");
-				const wsUrl = serverConfig?.websocketUrl;
-				const wsCompletionUrl = serverConfig?.wsCompletionUrl;
-				completionsUrl = serverConfig?.completionsUrl;
-				if (wsUrl && wsCompletionUrl) {
-					wsManager = new WebSocketConnectionManager(wsUrl, tokenGetter);
-					await wsManager.connect();
-					setWebSocketToolExecutor(new WebSocketToolExecutor(wsManager, tokenGetter));
-					llm = new WebSocketLlmBackend({
-						wsManager,
-						apiClient,
-						model: config.defaultModel,
-						tokenGetter,
-						wsCompletionUrl
-					});
-					wsManager.onAction("keep_command", async (message) => {
-						const { commandType, params, requestId, originConnectionId } = message;
-						let result;
-						let success = true;
-						let error;
-						try {
-							switch (commandType) {
-								case "read_file": {
-									const filePath = params.path;
-									if (!filePath) throw new Error("Missing required param: path");
-									logger.info(`[Keep] Reading file: ${filePath}`);
-									result = {
-										content: await promises.readFile(filePath, "utf-8"),
-										path: filePath
-									};
-									break;
-								}
-								case "list_directory": {
-									const dirPath = params.path || ".";
-									logger.info(`[Keep] Listing directory: ${dirPath}`);
-									result = (await promises.readdir(dirPath, { withFileTypes: true })).map((e) => ({
-										name: e.name,
-										isDirectory: e.isDirectory()
-									}));
-									break;
-								}
-								case "jupyter_get_kernelspecs":
-									logger.info("[Keep] Getting Jupyter kernel specs");
-									result = await getRequiredJupyterClient().getKernelSpecs();
-									break;
-								case "jupyter_start_kernel": {
-									const notebookPath = params.notebookPath;
-									const kernelName = params.kernelName;
-									logger.info(`[Keep] Starting Jupyter kernel for: ${notebookPath}`);
-									result = await getRequiredJupyterClient().startSession(notebookPath, kernelName);
-									break;
-								}
-								case "jupyter_stop_kernel": {
-									const sessionId = params.sessionId;
-									if (!sessionId) throw new Error("Missing required param: sessionId");
-									logger.info(`[Keep] Stopping Jupyter session: ${sessionId}`);
-									await getRequiredJupyterClient().stopSession(sessionId);
-									result = {
-										success: true,
-										sessionId
-									};
-									break;
-								}
-								case "jupyter_execute_cell": {
-									const code = params.code;
-									const kernelId = params.kernelId;
-									const timeoutMs = params.timeoutMs || 3e4;
-									if (!code) throw new Error("Missing required param: code");
-									if (!kernelId) throw new Error("Missing required param: kernelId");
-									logger.info(`[Keep] Executing cell (kernel: ${kernelId}, code length: ${code.length})`);
-									const cellResult = await getRequiredJupyterClient().executeCell(kernelId, code, timeoutMs);
-									logger.info(`[Keep] Cell execution ${cellResult.success ? "succeeded" : "failed"} (outputs: ${cellResult.outputs.length}, execution_count: ${cellResult.executionCount})`);
-									result = {
-										success: cellResult.success,
-										outputs: cellResult.outputs,
-										executionCount: cellResult.executionCount,
-										error: cellResult.error
-									};
-									break;
-								}
-								case "jupyter_execute_notebook":
-									result = await executeNotebook(params, {
-										jupyterClient: getRequiredJupyterClient(),
-										wsManager,
-										logger,
-										requestId
-									});
-									break;
-								default: throw new Error(`Unknown command type: ${commandType}`);
-							}
-						} catch (err) {
-							success = false;
-							error = err instanceof Error ? err.message : String(err);
-						}
-						logger.info(`[Keep] Sending response: success=${success}, originConnectionId=${originConnectionId?.slice(0, 12)}..., resultSize=${JSON.stringify(result)?.length ?? 0}`);
-						try {
-							wsManager.send({
-								action: "keep_command_response",
-								requestId,
-								originConnectionId,
-								success,
-								result,
-								error
-							});
-							logger.info("[Keep] Response sent successfully");
-						} catch (sendErr) {
-							logger.info(`[Keep] Failed to send response: ${sendErr instanceof Error ? sendErr.message : String(sendErr)}`);
-						}
-					});
-					logger.debug("🔌 Using WebSocket transport (bypasses CloudFront timeout)");
-				} else throw new Error("No websocketUrl or wsCompletionUrl in server config");
-			} catch (wsError) {
-				logger.debug("⚠️  WebSocket unavailable, using SSE fallback");
-				logger.debug(`[WebSocket] Fallback reason: ${wsError instanceof Error ? wsError.message : String(wsError)}`);
-				if (wsError instanceof Error && wsError.stack) logger.debug(`[WebSocket] Stack: ${wsError.stack}`);
-				wsManager = null;
-				setWebSocketToolExecutor(null);
-				llm = new ServerLlmBackend({
-					apiClient,
-					model: config.defaultModel,
-					completionsUrl
-				});
-			}
-			const ollamaHost = process.env.B4M_OLLAMA_HOST;
-			let models;
-			if (ollamaHost) {
-				const ollamaBackend = new OllamaBackend(ollamaHost, {
-					debug: (...args) => logger.debug(args.map(String).join(" ")),
-					info: (...args) => logger.info(args.map(String).join(" ")),
-					warn: (...args) => logger.warn(args.map(String).join(" ")),
-					error: (...args) => logger.error(args.map(String).join(" "))
-				});
-				const [serverModels, ollamaModels] = await Promise.all([llm.getModelInfo(), ollamaBackend.getModelInfo()]);
-				if (serverModels.length === 0 && ollamaModels.length === 0) throw new Error(`No models available from server or Ollama at ${ollamaHost}.\nPull a model: ollama pull qwen3.5`);
-				if (ollamaModels.length === 0) startupLog.push(`⚠️  No models found in Ollama at ${ollamaHost}. Pull one with: ollama pull qwen3.5`);
-				llm = new MultiLlmBackend(llm, ollamaBackend, serverModels, ollamaModels, config.defaultModel);
-				models = await llm.getModelInfo();
-				startupLog.push(`🦙 Self-hosted Ollama: ${ollamaModels.length} model(s) added to picker`);
-			} else {
-				models = await llm.getModelInfo();
-				if (models.length === 0) throw new Error("No models available from server.");
-			}
-			logger.debug(`📋 Available models: ${models.map((m) => m.id).join(", ")}`);
-			const modelInfo = models.find((m) => m.id === config.defaultModel) || models[0];
-			if (modelInfo.id !== config.defaultModel) {
-				logger.warn(`⚠️  Requested model '${config.defaultModel}' not available`);
-				logger.warn(`🤖 Using fallback model: ${modelInfo.id}`);
-			}
-			llm.currentModel = modelInfo.id;
+			const { llm, wsManager, models, modelInfo } = await buildLlmBackend({
+				config,
+				apiClient,
+				tokenGetter,
+				startupLog
+			});
 			const pinnedSessionId = process.env.B4M_SESSION_ID;
 			const resumeSessionId = process.env.B4M_RESUME_ID;
 			let newSession;
@@ -6362,43 +6719,13 @@ function CliApp() {
 				debug: () => {}
 			};
 			const permissionManager = new PermissionManager(config.trustedTools || [], void 0, config.tools.disabled || []);
-			const [{ createSandboxRuntime }, { SandboxOrchestrator }, { DEFAULT_SANDBOX_CONFIG }, { ProxyManager }, { ViolationLogStore }] = await Promise.all([
-				import("./SandboxRuntimeAdapter-CKelGICD.mjs"),
-				import("./SandboxOrchestrator-BS6gALNq.mjs"),
-				import("./types-CqscS34o.mjs"),
-				import("./ProxyManager-ByuAHFMq.mjs"),
-				import("./ViolationLogStore-B-plqJfn.mjs")
-			]);
-			const sandboxConfig = config.sandbox ?? DEFAULT_SANDBOX_CONFIG;
 			const checkpointStore = new CheckpointStore(state.configStore.getProjectConfigDir() || process.cwd());
-			const [sandboxRuntime] = await Promise.all([createSandboxRuntime(), checkpointStore.init(newSession.id).catch(() => {})]);
-			const proxyManager = new ProxyManager(sandboxConfig.network);
-			const sandboxOrchestrator = new SandboxOrchestrator(sandboxConfig, sandboxRuntime, proxyManager);
-			proxyManager.onEvent((event) => {
-				if (event.type === "blocked") {
-					console.error(`\n\x1b[41m\x1b[97m BLOCKED \x1b[0m \x1b[31mNetwork proxy denied connection to\x1b[0m \x1b[1m${event.domain}\x1b[0m \x1b[90m(${event.method})\x1b[0m`);
-					console.error(`\x1b[90m  Tip: /sandbox:trust-domain ${event.domain}\x1b[0m\n`);
-					sandboxOrchestrator.recordViolation({
-						type: "network",
-						domain: event.domain,
-						command: `[network] ${event.method} ${event.domain}`,
-						blockedBy: "proxy",
-						timestamp: event.timestamp,
-						detail: `Blocked ${event.method} to ${event.domain}`
-					}).catch(() => {});
-				}
+			const { sandboxOrchestrator } = await buildSandbox({
+				config,
+				sessionId: newSession.id,
+				permissionManager,
+				checkpointStore
 			});
-			const violationStore = new ViolationLogStore();
-			sandboxOrchestrator.setViolationStore(violationStore);
-			permissionManager.setSandboxState(sandboxConfig.mode, sandboxOrchestrator.isActive());
-			if (sandboxConfig.enabled && sandboxConfig.mode !== "disabled") {
-				if (sandboxRuntime) console.log(`🔒 Sandbox: ${sandboxConfig.mode} (${sandboxRuntime.name})`);
-				else console.log("⚠️  Sandbox: enabled but runtime not available on this platform");
-				if (sandboxConfig.network.enabled) {
-					await proxyManager.start();
-					if (proxyManager.isRunning()) console.log(`🌐 Network proxy: filtering on port ${proxyManager.getPort()} (${sandboxConfig.network.allowedDomains.length} domains)`);
-				}
-			}
 			let permissionPromptCounter = 0;
 			const promptFn = (toolName, args, preview) => {
 				return new Promise((resolve) => {
@@ -6473,57 +6800,29 @@ function CliApp() {
 				currentAgent: null,
 				observationQueue: []
 			};
-			const { tools: b4mTools } = await generateCliTools(config.userId, llm, modelInfo.id, permissionManager, promptFn, agentContext, state.configStore, apiClient, void 0, userQuestionFn, checkpointStore, sandboxOrchestrator, additionalDirectories);
-			const mcpManager = new McpManager(config);
-			const builtinAgentsDir = new URL("./agents/defaults/", import.meta.url).pathname;
-			const agentProjectDir = state.configStore.getProjectConfigDir();
-			const agentStore = new AgentStore(builtinAgentsDir, agentProjectDir || process.cwd());
-			const [, , contextResult] = await Promise.all([
-				mcpManager.initialize(),
-				agentStore.loadAgents(),
-				loadContextFiles(agentProjectDir)
-			]);
-			const mcpTools = mcpManager.getTools();
-			const deferredB4mToolNames = new Set([
-				"math_evaluate",
-				"dice_roll",
-				"current_datetime",
-				"recent_changes",
-				"prompt_enhancement"
-			]);
-			const deferredB4mTools = b4mTools.filter((t) => deferredB4mToolNames.has(t.toolSchema.name));
-			const loadedB4mTools = b4mTools.filter((t) => !deferredB4mToolNames.has(t.toolSchema.name));
-			deferredToolRegistry.register([...mcpTools, ...deferredB4mTools]);
-			if (mcpTools.length > 0) {
-				const serverSummaries = mcpManager.getToolCount().map((s) => `${s.serverName} (${s.count})`).join(", ");
-				startupLog.push(`🛠️ Loaded ${loadedB4mTools.length} B4M + ${mcpTools.length} MCP tool(s, ${deferredB4mTools.length + mcpTools.length} deferred): ${serverSummaries}`);
-			} else {
-				const suffix = deferredB4mTools.length > 0 ? ` (${deferredB4mTools.length} deferred)` : "";
-				startupLog.push(`🛠️ Loaded ${loadedB4mTools.length} B4M tool(s)${suffix}, no MCP tools`);
-			}
-			const agentSummary = agentStore.getSummary();
-			startupLog.push(`🤖 Loaded ${agentSummary.total} agent(s): ${agentSummary.builtin} built-in, ${agentSummary.global} global, ${agentSummary.project} project`);
-			const orchestrator = new SubagentOrchestrator({
-				userId: config.userId,
+			const { mcpManager, agentStore, contextResult, mcpTools, loadedB4mTools, deferredB4mTools, orchestrator, backgroundManager } = await buildSupportingStores({
+				config,
 				llm,
-				logger: silentLogger,
+				modelId: modelInfo.id,
 				permissionManager,
-				showPermissionPrompt: promptFn,
-				configStore: state.configStore,
 				apiClient,
-				agentStore,
+				configStore: state.configStore,
 				customCommandStore: state.customCommandStore,
-				enableParallelToolExecution: config.preferences.enableParallelToolExecution === true,
-				showUserQuestion: userQuestionFn,
-				checkpointStore
-			});
-			const backgroundManager = new BackgroundAgentManager(orchestrator);
-			backgroundManager.setOnStatusChange((job) => {
-				useCliStore.getState().upsertBackgroundAgent(job);
-			});
-			backgroundManager.setOnGroupCompletion((notification, groupDescription) => {
-				useCliStore.getState().addCompletedGroupNotification(notification, groupDescription);
-				useCliStore.getState().setPendingBackgroundTrigger(true);
+				checkpointStore,
+				sandboxOrchestrator,
+				additionalDirectories,
+				agentContext,
+				promptFn,
+				userQuestionFn,
+				startupLog,
+				silentLogger,
+				onBackgroundStatusChange: (job) => {
+					useCliStore.getState().upsertBackgroundAgent(job);
+				},
+				onGroupCompletion: (notification, groupDescription) => {
+					useCliStore.getState().addCompletedGroupNotification(notification, groupDescription);
+					useCliStore.getState().setPendingBackgroundTrigger(true);
+				}
 			});
 			const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id, backgroundManager);
 			const dynamicAgentTool = config.preferences.enableDynamicAgentCreation === true ? createDynamicAgentTool(orchestrator, newSession.id, backgroundManager) : null;
@@ -6600,36 +6899,23 @@ function CliApp() {
 			if (contextResult.globalContext) startupLog.push(`📄 Global context: ${contextResult.globalContext.filename}`);
 			if (contextResult.projectContext) startupLog.push(`📄 Project context: ${contextResult.projectContext.filename}`);
 			for (const error of contextResult.errors) startupLog.push(`⚠️  Context file error: ${error}`);
-			const featureModulePrompts = featureRegistry.getSystemPromptSections();
-			const promptVariant = config.preferences.promptVariant ?? "current";
-			const buildPromptForMode = (mode) => buildSystemPrompt(promptVariant, {
+			const { agent, buildPromptForMode } = buildAgent({
+				config,
+				modelId: modelInfo.id,
+				notifyingLlm,
+				allTools,
+				agentContext,
+				agentToolsRef,
+				silentLogger,
+				sessionId: newSession.id,
+				initialInteractionMode: useCliStore.getState().interactionMode,
 				contextContent: contextResult.mergedContent,
 				agentStore,
-				customCommands: state.customCommandStore.getAllCommands(),
+				customCommandStore: state.customCommandStore,
 				enableSkillTool,
-				enableDynamicAgentCreation: config.preferences.enableDynamicAgentCreation === true,
 				additionalDirectories,
-				featureModulePrompts: featureModulePrompts || void 0,
-				planModeFilePath: mode === "plan" ? getPlanModeFilePath(newSession.id) : void 0,
-				appendSystemPrompt: process.env.B4M_APPEND_SYSTEM_PROMPT,
-				deferredToolNames: deferredToolRegistry.getDirectoryNames()
-			});
-			const cliSystemPrompt = buildPromptForMode(useCliStore.getState().interactionMode);
-			const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
-			const agent = new ReActAgent({
-				userId: config.userId,
-				logger: silentLogger,
-				llm: notifyingLlm,
-				model: modelInfo.id,
-				tools: allTools,
-				maxIterations,
-				maxTokens: config.preferences.maxTokens,
-				temperature: config.preferences.temperature,
-				systemPrompt: cliSystemPrompt,
-				unknownToolResolver: async (toolName) => deferredToolRegistry.get(toolName) ?? null
+				featureModulePrompts: featureRegistry.getSystemPromptSections()
 			});
-			agentToolsRef.current = agent.getTools();
-			agentContext.currentAgent = agent;
 			let lastInteractionMode = useCliStore.getState().interactionMode;
 			useCliStore.subscribe((s) => {
 				if (s.interactionMode === lastInteractionMode) return;
@@ -6637,110 +6923,10 @@ function CliApp() {
 				if (agentContext.currentAgent !== agent) return;
 				agent.setSystemPrompt(buildPromptForMode(s.interactionMode));
 			});
-			agent.observationQueue = agentContext.observationQueue;
-			const stepHandler = (step) => {
-				const { pendingMessages, updatePendingMessage } = useCliStore.getState();
-				const lastIdx = pendingMessages.length - 1;
-				if (lastIdx >= 0 && pendingMessages[lastIdx].role === "assistant") {
-					const existingSteps = pendingMessages[lastIdx].metadata?.steps || [];
-					const formattedStep = formatStep(step);
-					updatePendingMessage(lastIdx, {
-						...pendingMessages[lastIdx],
-						metadata: {
-							...pendingMessages[lastIdx].metadata,
-							steps: [...existingSteps, formattedStep]
-						}
-					});
-				}
-			};
-			agent.on("thought", stepHandler);
-			agent.on("observation", stepHandler);
-			agent.on("action", stepHandler);
-			orchestrator.setBeforeRunCallback((subagent, _subagentType) => {
-				subagent.on("thought", stepHandler);
-				subagent.on("observation", stepHandler);
-				subagent.on("action", stepHandler);
-			});
-			orchestrator.setAfterRunCallback((subagent, _subagentType) => {
-				subagent.off("thought", stepHandler);
-				subagent.off("observation", stepHandler);
-				subagent.off("action", stepHandler);
-			});
-			const pendingToolUseIds = /* @__PURE__ */ new Map();
-			const summarizeToolInput = (input) => {
-				if (input == null) return void 0;
-				if (typeof input === "string") return input.slice(0, 240);
-				try {
-					return JSON.stringify(input).slice(0, 240);
-				} catch {
-					return;
-				}
-			};
-			const tavernActionHandler = (step) => {
-				const toolName = step.metadata?.toolName ?? "tool";
-				const toolUseId = `${toolName}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-				const queue = pendingToolUseIds.get(toolName) ?? [];
-				queue.push(toolUseId);
-				pendingToolUseIds.set(toolName, queue);
-				bridgePresence.emitEvent({
-					type: "tool_use",
-					tool: toolName,
-					toolUseId,
-					text: summarizeToolInput(step.metadata?.toolInput)
-				});
-			};
-			const tavernObservationHandler = (step) => {
-				const toolName = step.metadata?.toolName;
-				let toolUseId;
-				if (toolName) {
-					const queue = pendingToolUseIds.get(toolName);
-					if (queue && queue.length > 0) {
-						toolUseId = queue.shift();
-						if (queue.length === 0) pendingToolUseIds.delete(toolName);
-					}
-				}
-				if (!toolUseId) {
-					for (const [name, queue] of pendingToolUseIds.entries()) if (queue.length > 0) {
-						toolUseId = queue.shift();
-						if (queue.length === 0) pendingToolUseIds.delete(name);
-						break;
-					}
-				}
-				if (!toolUseId) toolUseId = `orphan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-				bridgePresence.emitEvent({
-					type: "tool_result",
-					tool: toolName,
-					toolUseId,
-					text: typeof step.content === "string" ? step.content.slice(0, 4e3) : void 0
-				});
-			};
-			const tavernFinalAnswerHandler = (step) => {
-				const text = typeof step.content === "string" ? step.content : "";
-				if (!text) return;
-				bridgePresence.emitEvent({
-					type: "message",
-					role: "assistant",
-					text: text.slice(0, 4e3)
-				});
-			};
-			agent.on("action", tavernActionHandler);
-			agent.on("observation", tavernObservationHandler);
-			agent.on("final_answer", tavernFinalAnswerHandler);
-			orchestrator.setBeforeRunCallback((subagent, _subagentType) => {
-				subagent.on("thought", stepHandler);
-				subagent.on("observation", stepHandler);
-				subagent.on("action", stepHandler);
-				subagent.on("action", tavernActionHandler);
-				subagent.on("observation", tavernObservationHandler);
-				subagent.on("final_answer", tavernFinalAnswerHandler);
-			});
-			orchestrator.setAfterRunCallback((subagent, _subagentType) => {
-				subagent.off("thought", stepHandler);
-				subagent.off("observation", stepHandler);
-				subagent.off("action", stepHandler);
-				subagent.off("action", tavernActionHandler);
-				subagent.off("observation", tavernObservationHandler);
-				subagent.off("final_answer", tavernFinalAnswerHandler);
+			wireAgentEvents({
+				agent,
+				agentContext,
+				orchestrator
 			});
 			setState((prev) => ({
 				...prev,