@bike4mind/cli 0.18.4 → 0.20.0

package/dist/buildAgent-mVuXU_H4.mjs

@@ -0,0 +1,824 @@
+#!/usr/bin/env node
+import { F as loadContextFiles, J as setWebSocketToolExecutor, L as generateCliTools, M as ReActAgent, X as buildSystemPrompt, Y as getPlanModeFilePath, a as McpManager, i as AgentStore, l as OllamaBackend, n as BackgroundAgentManager, o as createSseBackend, r as SubagentOrchestrator, s as ServerLlmBackend, t as AgentHistoryStore } from "./AgentHistoryStore-C8uUKjjC.mjs";
+import { n as logger } from "./ConfigStore-DD3DcC3-.mjs";
+import { z as z$1 } from "zod";
+import WebSocket from "ws";
+//#region src/llm/NotifyingLlmBackend.ts
+/**
+* LLM backend wrapper that injects background agent notifications
+* into the message array before each completion call.
+*
+* 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 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/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();
+		this.directoryNames = [];
+	}
+	/** 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);
+		this.directoryNames = Object.freeze([...this.byName.keys()].sort());
+		logger.debug(`[DeferredToolRegistry] Registered ${tools.length} deferred tool(s)`);
+	}
+	clear() {
+		this.byName.clear();
+		this.directoryNames = Object.freeze([]);
+	}
+	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);
+	}
+	/**
+	* Directory entries rendered into the cache-stamped system-prompt reminder.
+	* Returns the frozen snapshot captured at `register()`, NOT live `byName`
+	* keys, so loading a tool mid-session can never change a byte of the cached
+	* system block (issue #213). A loaded tool remaining listed here is
+	* harmless: re-selecting it via `tool_search` is an idempotent no-op.
+	*/
+	getDirectoryNames() {
+		return [...this.directoryNames];
+	}
+};
+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$1.object({
+	query: z$1.string().min(1, "query must be a non-empty string"),
+	max_results: z$1.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/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/ws/WebSocketConnectionManager.ts
+const useWsPolyfill = typeof globalThis.WebSocket === "undefined";
+const WS = useWsPolyfill ? WebSocket : globalThis.WebSocket;
+/**
+* Manages a persistent WebSocket connection for CLI <-> server communication.
+* Handles heartbeat, reconnection, and message routing by requestId.
+*
+* Uses Node.js built-in WebSocket (Node 22+) with `ws` package fallback for Node 20.
+*/
+var WebSocketConnectionManager = class {
+	/**
+	* @param verifySession - Optional. Called when a connect ATTEMPT fails (the socket closed
+	*   without ever opening) - exactly the signal an auth-rejected handshake produces. Omit to
+	*   preserve the old always-retry-forever behavior.
+	*/
+	constructor(wsUrl, getToken, verifySession) {
+		this.ws = null;
+		this.heartbeatInterval = null;
+		this.reconnectAttempts = 0;
+		this.maxReconnectDelay = 3e4;
+		this.handlers = /* @__PURE__ */ new Map();
+		this.actionHandlers = /* @__PURE__ */ new Map();
+		this.disconnectHandlers = /* @__PURE__ */ new Set();
+		this.revokedHandlers = /* @__PURE__ */ new Set();
+		this.reconnectTimer = null;
+		this.connected = false;
+		this.connecting = false;
+		this.closed = false;
+		this.openedThisAttempt = false;
+		this.verifyingSession = false;
+		this.revoked = false;
+		this.wsUrl = wsUrl;
+		this.getToken = getToken;
+		this.verifySession = verifySession;
+	}
+	/**
+	* Connect to the WebSocket server.
+	* Resolves when connection is established, rejects on failure.
+	*/
+	async connect() {
+		if (this.connected || this.connecting) return;
+		this.connecting = true;
+		this.openedThisAttempt = false;
+		const token = await this.getToken();
+		if (!token) {
+			this.connecting = false;
+			throw new Error("No access token available for WebSocket connection");
+		}
+		return new Promise((resolve, reject) => {
+			logger.debug(`[WS] Connecting to ${this.wsUrl}...`);
+			if (useWsPolyfill) this.ws = new WebSocket(this.wsUrl, { headers: { "Sec-WebSocket-Protocol": `access_token.${token}` } });
+			else this.ws = new WS(this.wsUrl, [`access_token.${token}`]);
+			this.ws.onopen = () => {
+				logger.debug("[WS] Connected");
+				this.connected = true;
+				this.connecting = false;
+				this.openedThisAttempt = true;
+				this.reconnectAttempts = 0;
+				this.startHeartbeat();
+				resolve();
+			};
+			this.ws.onmessage = (event) => {
+				try {
+					const data = typeof event.data === "string" ? event.data : event.data.toString();
+					const message = JSON.parse(data);
+					const requestId = message.requestId;
+					if (requestId && this.handlers.has(requestId)) this.handlers.get(requestId)(message);
+					else {
+						const action = message.action;
+						if (action && this.actionHandlers.has(action)) this.actionHandlers.get(action)(message);
+						else logger.debug(`[WS] Unhandled message: ${action || "unknown"}`);
+					}
+				} catch (err) {
+					logger.debug(`[WS] Failed to parse message: ${err}`);
+				}
+			};
+			this.ws.onclose = () => {
+				logger.debug("[WS] Connection closed");
+				const openedThisAttempt = this.openedThisAttempt;
+				this.cleanup();
+				this.notifyDisconnect();
+				if (this.closed || this.revoked) return;
+				if (openedThisAttempt || !this.verifySession) {
+					this.scheduleReconnect();
+					return;
+				}
+				this.verifyThenReconnect();
+			};
+			this.ws.onerror = (err) => {
+				const detail = err.error?.message || String(err);
+				logger.debug(`[WS] Error: ${detail}`);
+				if (this.connecting) {
+					this.connecting = false;
+					this.connected = false;
+					reject(/* @__PURE__ */ new Error(`WebSocket connection failed: ${detail}`));
+				}
+			};
+		});
+	}
+	/** Whether the connection is currently established */
+	get isConnected() {
+		return this.connected;
+	}
+	/**
+	* Send a JSON message over the WebSocket connection.
+	*/
+	send(data) {
+		if (!this.ws || this.ws.readyState !== WS.OPEN) throw new Error("WebSocket is not connected");
+		const payload = JSON.stringify(data);
+		const sizeKB = (payload.length / 1024).toFixed(1);
+		logger.debug(`[WS] Sending ${sizeKB} KB (action: ${data.action})`);
+		if (payload.length > 32e3) logger.warn(`[WS] Payload ${sizeKB} KB exceeds API Gateway 32 KB frame limit — connection will be closed`);
+		this.ws.send(payload);
+	}
+	/**
+	* Register a handler for messages matching a specific requestId.
+	*/
+	onRequest(requestId, handler) {
+		this.handlers.set(requestId, handler);
+	}
+	/**
+	* Remove a handler for a specific requestId.
+	*/
+	offRequest(requestId) {
+		this.handlers.delete(requestId);
+	}
+	/**
+	* Register a handler for messages matching a specific action type.
+	* Used for server-pushed commands like keep_command.
+	*/
+	onAction(action, handler) {
+		this.actionHandlers.set(action, handler);
+	}
+	/**
+	* Remove a handler for a specific action type.
+	*/
+	offAction(action) {
+		this.actionHandlers.delete(action);
+	}
+	/**
+	* Register a handler that fires when the connection drops.
+	*/
+	onDisconnect(handler) {
+		this.disconnectHandlers.add(handler);
+	}
+	/**
+	* Remove a disconnect handler.
+	*/
+	offDisconnect(handler) {
+		this.disconnectHandlers.delete(handler);
+	}
+	/**
+	* Register a handler that fires once the session is confirmed revoked (verifySession
+	* returned false) and the reconnect loop has permanently stopped.
+	*/
+	onRevoked(handler) {
+		this.revokedHandlers.add(handler);
+	}
+	/**
+	* Remove a revoked handler.
+	*/
+	offRevoked(handler) {
+		this.revokedHandlers.delete(handler);
+	}
+	/** Whether the session has been confirmed revoked (reconnecting has permanently stopped). */
+	get isRevoked() {
+		return this.revoked;
+	}
+	/**
+	* Close the connection and stop all heartbeat/reconnect logic.
+	*/
+	disconnect() {
+		this.closed = true;
+		this.cleanup();
+		if (this.ws) {
+			this.ws.close();
+			this.ws = null;
+		}
+		this.handlers.clear();
+		this.actionHandlers.clear();
+		this.disconnectHandlers.clear();
+		this.revokedHandlers.clear();
+	}
+	startHeartbeat() {
+		this.stopHeartbeat();
+		this.heartbeatInterval = setInterval(() => {
+			if (this.ws && this.ws.readyState === WS.OPEN) {
+				this.ws.send(JSON.stringify({ action: "heartbeat" }));
+				logger.debug("[WS] Heartbeat sent");
+			}
+		}, 3e5);
+	}
+	stopHeartbeat() {
+		if (this.heartbeatInterval) {
+			clearInterval(this.heartbeatInterval);
+			this.heartbeatInterval = null;
+		}
+	}
+	cleanup() {
+		this.connected = false;
+		this.connecting = false;
+		this.stopHeartbeat();
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+	}
+	notifyDisconnect() {
+		for (const handler of this.disconnectHandlers) try {
+			handler();
+		} catch {}
+	}
+	notifyRevoked() {
+		for (const handler of this.revokedHandlers) try {
+			handler();
+		} catch {}
+	}
+	/**
+	* Called when a connect attempt fails to open at all - the signal a 401 handshake refusal
+	* produces. Verifies the session via the injected `verifySession` (single-flighted) before
+	* deciding whether to keep retrying. A verification that itself errors (network blip, 5xx)
+	* is treated as transient - only an explicit `false` result stops the loop.
+	*/
+	async verifyThenReconnect() {
+		if (this.verifyingSession) return;
+		this.verifyingSession = true;
+		try {
+			if (!await this.verifySession()) {
+				logger.debug("[WS] Session verification failed - session revoked, stopping reconnect");
+				this.revoked = true;
+				this.notifyRevoked();
+				return;
+			}
+		} catch (err) {
+			logger.debug(`[WS] Session verification errored - treating as transient: ${err}`);
+		} finally {
+			this.verifyingSession = false;
+		}
+		this.scheduleReconnect();
+	}
+	scheduleReconnect() {
+		if (this.closed || this.revoked) return;
+		this.reconnectAttempts++;
+		const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+		logger.debug(`[WS] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+		this.reconnectTimer = setTimeout(async () => {
+			this.reconnectTimer = null;
+			if (this.closed) return;
+			try {
+				await this.connect();
+			} catch {
+				logger.debug("[WS] Reconnection failed");
+			}
+		}, delay);
+	}
+};
+//#endregion
+//#region src/bootstrap/buildLlmBackend.ts
+/** Production wiring: real transport classes + the ToolRouter singleton. */
+const defaultLlmBackendDeps = {
+	connectWebSocket: async (wsUrl, tokenGetter, verifySession) => {
+		const ws = new WebSocketConnectionManager(wsUrl, tokenGetter, verifySession);
+		ws.onRevoked(() => {
+			logger.warn("Session revoked - run `b4m login` again. WebSocket reconnect stopped.");
+		});
+		try {
+			await ws.connect();
+		} catch (err) {
+			ws.disconnect();
+			throw err;
+		}
+		return ws;
+	},
+	clearWebSocketToolExecutor: () => setWebSocketToolExecutor(null),
+	createServerBackend: (opts) => new ServerLlmBackend(opts),
+	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)
+};
+/**
+* True when some enabled feature module consumes realtime server events. Only
+* Tavern does today (TavernModule.registerWsHandlers -> TavernActivityStream);
+* keep this in sync with the module registration in index.tsx. Everything else
+* runs socket-free, so the common path never opens a WebSocket.
+*/
+function needsFeatureEventSocket(config) {
+	return config.features?.tavern === true;
+}
+/**
+* Connect the events-only socket that feature modules register handlers on.
+* Returns null when it isn't needed, isn't advertised, or won't connect - a
+* feature's live updates degrading is never a reason to fail startup, since
+* completions no longer depend on this socket at all.
+*/
+async function connectFeatureEventSocket(config, websocketUrl, deps, auth) {
+	if (!needsFeatureEventSocket(config)) return null;
+	if (!websocketUrl) {
+		logger.debug("[WS] No websocketUrl in server config - feature live updates disabled");
+		return null;
+	}
+	try {
+		return await deps.connectWebSocket(websocketUrl, auth.tokenGetter, auth.verifySession);
+	} catch (err) {
+		logger.warn(`Realtime socket unavailable - live feature updates are disabled: ${err instanceof Error ? err.message : String(err)}`);
+		return null;
+	}
+}
+/**
+* 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: HTTP+SSE transport (ServerLlmBackend), optional Ollama
+* multiplexing. Resolves the default model and pins it on the backend.
+*
+* The WebSocket COMPLETION transport was removed - completions always use SSE,
+* because relays that emit the generic `streamed_chat_completion` action drop
+* every CLI chunk. The socket itself is still connected, but only when a
+* WS-consuming feature module is enabled, and only to carry that module's events
+* (see `wsManager`); Keep relay and WS server-side tool execution stay off.
+*
+* Pure bootstrap seam: no React hooks, no Zustand state.
+*/
+async function buildLlmBackend(input, deps = defaultLlmBackendDeps) {
+	const { config, apiClient, startupLog, tokenGetter } = input;
+	const sse = await createSseBackend({
+		apiClient,
+		model: config.defaultModel
+	}, {
+		createServerBackend: deps.createServerBackend,
+		clearWebSocketToolExecutor: deps.clearWebSocketToolExecutor
+	});
+	let llm = sse.llm;
+	const wsManager = await connectFeatureEventSocket(config, sse.serverConfig.websocketUrl, deps, {
+		tokenGetter,
+		verifySession: () => apiClient.checkSessionValid()
+	});
+	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-BFPVpmB5.mjs"),
+		import("./types-CqscS34o.mjs"),
+		import("./ProxyManager-Bqr7Lmsd.mjs"),
+		import("./ViolationLogStore-byEhxa2A.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, onSubagentUsage } = 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 = /* @__PURE__ */ 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 historyStore = new AgentHistoryStore(config.preferences.subagentHistoryTtlMs ?? 36e5);
+	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,
+		onSubagentUsage,
+		historyStore
+	});
+	const backgroundManager = new BackgroundAgentManager(orchestrator);
+	backgroundManager.setOnStatusChange(onBackgroundStatusChange);
+	backgroundManager.setOnGroupCompletion(onGroupCompletion);
+	return {
+		mcpManager,
+		agentStore,
+		contextResult,
+		mcpTools,
+		loadedB4mTools,
+		deferredB4mTools,
+		orchestrator,
+		backgroundManager,
+		historyStore
+	};
+}
+//#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
+export { createToolSearchTool as a, buildLlmBackend as i, buildSupportingStores as n, deferredToolRegistry as o, buildSandbox as r, NotifyingLlmBackend as s, buildAgent as t };