@bike4mind/cli 0.18.4 → 0.20.0

package/dist/commands/acpCommand.mjs

@@ -0,0 +1,798 @@
+#!/usr/bin/env node
+import { $ as RemoteSkillSource, A as FallbackLlmBackend, C as createWriteTodosTool, D as createResumeAgentTool, E as createCoordinateTaskTool, I as PermissionManager, J as setWebSocketToolExecutor, O as createBackgroundAgentTools, Q as isReadOnlyTool, S as createTodoStore, et as CustomCommandStore, k as createAgentDelegateTool, nt as SessionStore, tt as CheckpointStore, w as createSkillTool, x as createFindDefinitionTool, y as createGetFileStructureTool } from "../AgentHistoryStore-C8uUKjjC.mjs";
+import { c as requireApiUrl, n as logger, t as ConfigStore } from "../ConfigStore-DD3DcC3-.mjs";
+import { t as ApiClient } from "../ApiClient-B_CQrUiF.mjs";
+import { a as createToolSearchTool, i as buildLlmBackend, n as buildSupportingStores, o as deferredToolRegistry, r as buildSandbox, s as NotifyingLlmBackend, t as buildAgent } from "../buildAgent-mVuXU_H4.mjs";
+import { randomUUID } from "crypto";
+import { existsSync, realpathSync, statSync } from "fs";
+import { isAbsolute } from "path";
+import { Readable } from "node:stream";
+import { PROTOCOL_VERSION, RequestError, agent, methods, ndJsonStream } from "@agentclientprotocol/sdk";
+import { Mutex } from "async-mutex";
+//#region src/acp/protocol.ts
+/**
+* Pure mapping layer between the B4M agent core and the Agent Client Protocol
+* (ACP) wire types. Everything here is side-effect free so it can be unit
+* tested without a live connection - the stateful server (AcpServer) composes
+* these helpers.
+*
+* ACP spec: https://agentclientprotocol.com
+*/
+/** Protocol version this agent implements (re-exported for the server). */
+const ACP_PROTOCOL_VERSION = PROTOCOL_VERSION;
+/** Identifies this agent to ACP clients (shown in the editor's agent panel). */
+const AGENT_INFO = {
+	name: "bike4mind",
+	title: "Bike4Mind"
+};
+const ACP_MODE_PLAN = "plan";
+/** ACP mode ids that a client is permitted to select. Order = display order. */
+const SAFE_ACP_MODES = [{
+	id: "ask",
+	name: "Ask",
+	description: "Prompts for permission before every gated tool call."
+}, {
+	id: ACP_MODE_PLAN,
+	name: "Plan",
+	description: "Planning-oriented; still prompts for permission on gated tools."
+}];
+/** The mode state advertised on session/new and session/load. */
+function buildSessionModeState(currentModeId = "ask") {
+	return {
+		currentModeId,
+		availableModes: SAFE_ACP_MODES
+	};
+}
+/**
+* Map a client-selected ACP mode id to a CLI interaction mode. Returns null for
+* any id outside the safe allowlist so the caller can reject it (fail closed) -
+* this is what keeps the unsafe 'auto-accept' no-prompt mode off the wire.
+*/
+function acpModeToInteraction(modeId) {
+	switch (modeId) {
+		case "ask": return "normal";
+		case ACP_MODE_PLAN: return "plan";
+		default: return null;
+	}
+}
+/**
+* Classify a B4M tool into an ACP ToolKind so the editor can pick an icon and
+* UI treatment. Driven by tool-name heuristics (mutation verbs win over read
+* verbs); an unclassifiable tool maps to 'other' rather than being assumed
+* read-only.
+*/
+function toolKind(toolName) {
+	const name = toolName.toLowerCase();
+	if (/delete|remove|(^|_)rm(_|$)/.test(name)) return "delete";
+	if (/move|rename|(^|_)mv(_|$)/.test(name)) return "move";
+	if (/write|edit|patch|apply|create|update|append/.test(name)) return "edit";
+	if (/exec|run|shell|bash|command|terminal/.test(name)) return "execute";
+	if (/search|grep|find|glob|list/.test(name)) return "search";
+	if (/fetch|web|http|url|download|crawl/.test(name)) return "fetch";
+	if (/read|cat|view|show|open|get_file|structure|definition/.test(name)) return "read";
+	return "other";
+}
+/** Compact a tool's input into a one-line human-readable title. */
+function toolCallTitle(toolName, toolInput) {
+	const summary = summarizeInput(toolInput);
+	return summary ? `${toolName}(${summary})` : toolName;
+}
+function summarizeInput(input) {
+	if (input == null) return void 0;
+	if (typeof input === "string") return truncate(input, 80);
+	try {
+		return truncate(JSON.stringify(input), 80);
+	} catch {
+		return;
+	}
+}
+function truncate(text, max) {
+	return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+const PERMISSION_OPTION_ALLOW_ONCE = "allow-once";
+const PERMISSION_OPTION_ALLOW_ALWAYS = "allow-always";
+const PERMISSION_OPTION_REJECT = "deny";
+function buildPermissionOptions() {
+	return [
+		{
+			optionId: PERMISSION_OPTION_ALLOW_ONCE,
+			name: "Allow once",
+			kind: "allow_once"
+		},
+		{
+			optionId: PERMISSION_OPTION_ALLOW_ALWAYS,
+			name: "Always allow",
+			kind: "allow_always"
+		},
+		{
+			optionId: PERMISSION_OPTION_REJECT,
+			name: "Reject",
+			kind: "reject_once"
+		}
+	];
+}
+/**
+* Resolve an ACP permission outcome to a CLI PermissionResponse. Fails CLOSED:
+* a cancelled turn, an unknown option id, or a missing outcome all deny.
+*/
+function permissionResponseFromOutcome(outcome) {
+	if (!outcome || outcome.outcome !== "selected") return "deny";
+	switch (outcome.optionId) {
+		case PERMISSION_OPTION_ALLOW_ONCE: return "allow-once";
+		case PERMISSION_OPTION_ALLOW_ALWAYS: return "allow-always";
+		case PERMISSION_OPTION_REJECT: return "deny";
+		default: return "deny";
+	}
+}
+/**
+* Flatten a prompt's content blocks into a single text string for the agent.
+* Text blocks pass through; resource links are rendered as an @-reference so
+* the agent's file tools can pick them up. Image/audio/embedded blocks are
+* summarized as a placeholder (v1 sends text to the agent core).
+*/
+function contentBlocksToText(blocks) {
+	const parts = [];
+	for (const block of blocks) switch (block.type) {
+		case "text":
+			parts.push(block.text);
+			break;
+		case "resource_link":
+			parts.push(`@${block.uri}`);
+			break;
+		case "resource":
+			if ("resource" in block && block.resource && "text" in block.resource && typeof block.resource.text === "string") parts.push(block.resource.text);
+			else if ("resource" in block && block.resource && "uri" in block.resource) parts.push(`@${block.resource.uri}`);
+			break;
+		case "image":
+			parts.push("[image]");
+			break;
+		case "audio": parts.push("[audio]");
+	}
+	return parts.join("\n").trim();
+}
+function textChunk(text) {
+	return {
+		type: "text",
+		text
+	};
+}
+function agentMessageChunk(text) {
+	return {
+		sessionUpdate: "agent_message_chunk",
+		content: textChunk(text)
+	};
+}
+function agentThoughtChunk(text) {
+	return {
+		sessionUpdate: "agent_thought_chunk",
+		content: textChunk(text)
+	};
+}
+function userMessageChunk(text) {
+	return {
+		sessionUpdate: "user_message_chunk",
+		content: textChunk(text)
+	};
+}
+/** A tool call entering the in-progress state (emitted on an `action` step). */
+function toolCallStart(toolCallId, step) {
+	const toolName = step.metadata?.toolName ?? "tool";
+	return {
+		sessionUpdate: "tool_call",
+		toolCallId,
+		title: toolCallTitle(toolName, step.metadata?.toolInput),
+		kind: toolKind(toolName),
+		status: "in_progress",
+		rawInput: step.metadata?.toolInput ?? void 0
+	};
+}
+/** A tool call reaching a terminal state (emitted on an `observation` step). */
+function toolCallCompleted(toolCallId, content) {
+	return {
+		sessionUpdate: "tool_call_update",
+		toolCallId,
+		status: "completed",
+		content: content ? [{
+			type: "content",
+			content: textChunk(content)
+		}] : void 0
+	};
+}
+/** Notify the client of the current mode after a session/set_mode. */
+function currentModeUpdate(currentModeId) {
+	return {
+		sessionUpdate: "current_mode_update",
+		currentModeId
+	};
+}
+//#endregion
+//#region src/acp/cwd.ts
+/**
+* Working-directory validation for ACP sessions.
+*
+* The client supplies a `cwd` on session/new and session/load. Because the CLI
+* file tools resolve paths against `process.cwd()`, that directory becomes the
+* file-tool root for the session. We validate it up front and fail loud with a
+* protocol error rather than letting a bad path surface as opaque tool errors
+* later.
+*/
+/**
+* Validate a client-supplied session cwd and return its canonical (symlink-
+* resolved) absolute path. Throws an ACP invalid-params error if the path is
+* not absolute, does not exist, or is not a directory.
+*/
+function assertConfinedCwd(cwd) {
+	if (typeof cwd !== "string" || cwd.length === 0 || !isAbsolute(cwd)) throw RequestError.invalidParams(void 0, `Session cwd must be an absolute path, got: ${JSON.stringify(cwd)}`);
+	if (!existsSync(cwd) || !statSync(cwd).isDirectory()) throw RequestError.invalidParams(void 0, `Session cwd is not an existing directory: ${cwd}`);
+	return realpathSync(cwd);
+}
+//#endregion
+//#region src/acp/AcpServer.ts
+/**
+* ACP agent-side server. Bridges the Agent Client Protocol to the same B4M
+* ReAct agent core the interactive TUI and headless modes drive, so an
+* ACP-capable editor (Zed, etc.) can host a thread while we keep auth, credits,
+* and model routing server-side.
+*
+* Design notes:
+* - The heavy agent stack (LLM transport, tools, MCP, orchestrator) is built
+*   ONCE, lazily, on the first session. Individual ACP sessions are lightweight
+*   conversation contexts (history + cwd + mode) that reuse the shared agent.
+* - Because sessions share one agent instance and one process working
+*   directory, prompt turns are serialized through a single mutex. This is
+*   stricter than the spec's per-session requirement and guarantees histories
+*   can never interleave.
+* - Permission requests bridge to session/request_permission and FAIL CLOSED:
+*   a client timeout, disconnect, or cancel all resolve to a denial.
+*/
+/** Fail-closed deadline for a client permission decision. */
+const PERMISSION_TIMEOUT_MS = 3e5;
+const silentLogger = {
+	log: () => {},
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	debug: () => {}
+};
+var AcpServer = class {
+	/**
+	* @param connectionSignal aborts when the ACP connection closes; used to fail
+	*   permission prompts closed.
+	* @param version CLI version reported to the client as `agentInfo.version`.
+	*/
+	constructor(connectionSignal, version) {
+		this.connectionSignal = connectionSignal;
+		this.version = version;
+		this.configStore = new ConfigStore();
+		this.sessionStore = new SessionStore();
+		this.customCommandStore = new CustomCommandStore();
+		this.sessions = /* @__PURE__ */ new Map();
+		this.turnMutex = new Mutex();
+		this.stackPromise = null;
+		this.stack = null;
+		this.activeTurn = null;
+		this.promptFn = async (toolName, args, preview) => {
+			const turn = this.activeTurn;
+			if (!turn) return { action: "deny" };
+			const toolCall = {
+				toolCallId: `perm-${randomUUID()}`,
+				title: toolCallTitle(toolName, args),
+				kind: toolKind(toolName),
+				status: "pending",
+				rawInput: args,
+				content: preview ? [{
+					type: "content",
+					content: {
+						type: "text",
+						text: [...preview].slice(0, 4e3).join("")
+					}
+				}] : void 0
+			};
+			const decisionController = new AbortController();
+			const timer = setTimeout(() => decisionController.abort(), PERMISSION_TIMEOUT_MS);
+			const onClose = () => decisionController.abort();
+			turn.signal.addEventListener("abort", onClose);
+			this.connectionSignal.addEventListener("abort", onClose);
+			try {
+				return { action: await Promise.race([turn.client.request(methods.client.session.requestPermission, {
+					sessionId: turn.sessionId,
+					toolCall,
+					options: buildPermissionOptions()
+				}, { cancellationSignal: decisionController.signal }).then((res) => permissionResponseFromOutcome(res?.outcome)).catch(() => "deny"), new Promise((resolve) => {
+					decisionController.signal.addEventListener("abort", () => resolve("deny"), { once: true });
+				})]) };
+			} finally {
+				clearTimeout(timer);
+				turn.signal.removeEventListener("abort", onClose);
+				this.connectionSignal.removeEventListener("abort", onClose);
+			}
+		};
+		this.userQuestionFn = (_payload) => {
+			return Promise.resolve({ answers: [] });
+		};
+	}
+	initialize(_params) {
+		return {
+			protocolVersion: ACP_PROTOCOL_VERSION,
+			agentInfo: {
+				name: AGENT_INFO.name,
+				title: AGENT_INFO.title,
+				version: this.version
+			},
+			agentCapabilities: {
+				loadSession: true,
+				promptCapabilities: {
+					image: false,
+					embeddedContext: true
+				}
+			}
+		};
+	}
+	async newSession(params) {
+		const cwd = assertConfinedCwd(params.cwd);
+		const stack = await this.ensureStack();
+		const id = randomUUID();
+		const persisted = {
+			id,
+			name: `ACP ${(/* @__PURE__ */ new Date()).toISOString()}`,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			model: stack.modelId,
+			messages: [],
+			metadata: {
+				totalTokens: 0,
+				totalCost: 0,
+				toolCallCount: 0
+			}
+		};
+		this.sessions.set(id, {
+			id,
+			cwd,
+			mode: acpModeToInteraction("ask") ?? "normal",
+			history: [],
+			abortController: null,
+			persisted
+		});
+		return {
+			sessionId: id,
+			modes: buildSessionModeState("ask")
+		};
+	}
+	async loadSession(params, ctx) {
+		const cwd = assertConfinedCwd(params.cwd);
+		await this.ensureStack();
+		const persisted = await this.sessionStore.load(params.sessionId);
+		if (!persisted) throw RequestError.resourceNotFound(params.sessionId);
+		const history = persisted.messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({
+			role: m.role,
+			content: m.content
+		}));
+		this.sessions.set(params.sessionId, {
+			id: params.sessionId,
+			cwd,
+			mode: acpModeToInteraction("ask") ?? "normal",
+			history,
+			abortController: null,
+			persisted
+		});
+		for (const message of history) {
+			const update = message.role === "user" ? userMessageChunk(message.content) : agentMessageChunk(message.content);
+			await ctx.notify(methods.client.session.update, {
+				sessionId: params.sessionId,
+				update
+			});
+		}
+		return { modes: buildSessionModeState("ask") };
+	}
+	setSessionMode(params, ctx) {
+		const session = this.requireSession(params.sessionId);
+		const mode = acpModeToInteraction(params.modeId);
+		if (!mode) throw RequestError.invalidParams(void 0, `Unsupported session mode: ${params.modeId}`);
+		session.mode = mode;
+		ctx.notify(methods.client.session.update, {
+			sessionId: params.sessionId,
+			update: currentModeUpdate(params.modeId)
+		});
+		return {};
+	}
+	/** session/cancel is a notification: abort the running turn for this session. */
+	cancel(params) {
+		this.sessions.get(params.sessionId)?.abortController?.abort();
+	}
+	async prompt(params, ctx, requestSignal) {
+		const session = this.requireSession(params.sessionId);
+		const userText = contentBlocksToText(params.prompt);
+		if (!userText.trim()) return { stopReason: "end_turn" };
+		const stack = await this.ensureStack();
+		return this.turnMutex.runExclusive(async () => {
+			const abortController = new AbortController();
+			session.abortController = abortController;
+			const onExternalAbort = () => abortController.abort();
+			requestSignal.addEventListener("abort", onExternalAbort);
+			this.connectionSignal.addEventListener("abort", onExternalAbort);
+			this.activeTurn = {
+				client: ctx,
+				sessionId: params.sessionId,
+				signal: abortController.signal
+			};
+			let detachEvents = null;
+			let result = null;
+			try {
+				process.chdir(session.cwd);
+				stack.agent.setSystemPrompt(stack.buildPromptForMode(session.mode));
+				detachEvents = this.wireTurnEvents(stack.agent, ctx, params.sessionId, abortController.signal);
+				result = await stack.agent.run(userText, {
+					signal: abortController.signal,
+					previousMessages: session.history,
+					isReadOnlyTool,
+					maxHistoryIterations: 4
+				});
+			} catch (error) {
+				if (abortController.signal.aborted) return { stopReason: "cancelled" };
+				logger.error(`[acp] Prompt turn failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+				throw RequestError.internalError(void 0, error instanceof Error ? error.message : String(error));
+			} finally {
+				detachEvents?.();
+				requestSignal.removeEventListener("abort", onExternalAbort);
+				this.connectionSignal.removeEventListener("abort", onExternalAbort);
+				session.abortController = null;
+				this.activeTurn = null;
+			}
+			if (abortController.signal.aborted) return { stopReason: "cancelled" };
+			session.history.push({
+				role: "user",
+				content: userText
+			});
+			session.history.push({
+				role: "assistant",
+				content: result.finalAnswer
+			});
+			await this.persistTurn(session, userText, result).catch((err) => {
+				logger.debug(`[acp] Failed to persist session: ${err instanceof Error ? err.message : String(err)}`);
+			});
+			return {
+				stopReason: this.stopReasonFor(result),
+				usage: {
+					totalTokens: result.completionInfo.totalTokens,
+					inputTokens: result.completionInfo.totalInputTokens,
+					outputTokens: result.completionInfo.totalOutputTokens
+				}
+			};
+		});
+	}
+	/** Tear down shared resources when the connection closes. */
+	async close() {
+		this.activeTurn = null;
+		if (this.stack) {
+			await this.stack.cleanup().catch(() => {});
+			this.stack = null;
+		}
+	}
+	requireSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (!session) throw RequestError.invalidParams(void 0, `Unknown session: ${sessionId}`);
+		return session;
+	}
+	stopReasonFor(result) {
+		if (result.completionInfo.reachedMaxTotalTokens) return "max_tokens";
+		if (result.completionInfo.reachedMaxIterations) return "max_turn_requests";
+		return "end_turn";
+	}
+	/**
+	* Forward the main agent's ReAct events to the client as session/update
+	* notifications for the duration of one turn. Text is streamed via
+	* text_delta; the final_answer is emitted only if nothing streamed, to avoid
+	* duplicating the message. Returns a detach function.
+	*/
+	wireTurnEvents(agent, client, sessionId, signal) {
+		let streamedAnyText = false;
+		const pendingToolCalls = /* @__PURE__ */ new Map();
+		const notify = (update) => {
+			if (signal.aborted) return;
+			client.notify(methods.client.session.update, {
+				sessionId,
+				update
+			}).catch(() => {});
+		};
+		const onTextDelta = (info) => {
+			if (!info.delta) return;
+			streamedAnyText = true;
+			notify(agentMessageChunk(info.delta));
+		};
+		const onThought = (step) => {
+			if (step.content) notify(agentThoughtChunk(step.content));
+		};
+		const onAction = (step) => {
+			const toolName = step.metadata?.toolName ?? "tool";
+			const toolCallId = `tool-${randomUUID()}`;
+			const queue = pendingToolCalls.get(toolName) ?? [];
+			queue.push(toolCallId);
+			pendingToolCalls.set(toolName, queue);
+			notify(toolCallStart(toolCallId, step));
+		};
+		const onObservation = (step) => {
+			const toolName = step.metadata?.toolName;
+			const toolCallId = this.dequeueToolCall(pendingToolCalls, toolName);
+			if (!toolCallId) return;
+			notify(toolCallCompleted(toolCallId, typeof step.content === "string" ? step.content : ""));
+		};
+		const onFinalAnswer = (step) => {
+			if (!streamedAnyText && step.content) notify(agentMessageChunk(step.content));
+		};
+		agent.on("text_delta", onTextDelta);
+		agent.on("thought", onThought);
+		agent.on("action", onAction);
+		agent.on("observation", onObservation);
+		agent.on("final_answer", onFinalAnswer);
+		return () => {
+			agent.off("text_delta", onTextDelta);
+			agent.off("thought", onThought);
+			agent.off("action", onAction);
+			agent.off("observation", onObservation);
+			agent.off("final_answer", onFinalAnswer);
+		};
+	}
+	dequeueToolCall(pending, toolName) {
+		if (toolName) {
+			const queue = pending.get(toolName);
+			if (queue && queue.length > 0) {
+				const id = queue.shift();
+				if (queue.length === 0) pending.delete(toolName);
+				return id;
+			}
+		}
+		for (const [name, queue] of pending.entries()) if (queue.length > 0) {
+			const id = queue.shift();
+			if (queue.length === 0) pending.delete(name);
+			return id;
+		}
+	}
+	async persistTurn(session, userText, result) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		session.persisted.messages.push({
+			id: randomUUID(),
+			role: "user",
+			content: userText,
+			timestamp: now
+		}, {
+			id: randomUUID(),
+			role: "assistant",
+			content: result.finalAnswer,
+			timestamp: now
+		});
+		session.persisted.updatedAt = now;
+		session.persisted.metadata.totalTokens += result.completionInfo.totalTokens;
+		session.persisted.metadata.toolCallCount += result.completionInfo.toolCalls;
+		session.persisted.metadata.totalCredits = (session.persisted.metadata.totalCredits ?? 0) + (result.completionInfo.totalCredits ?? 0);
+		await this.sessionStore.save(session.persisted);
+	}
+	ensureStack() {
+		if (!this.stackPromise) this.stackPromise = this.buildStack().then((stack) => {
+			this.stack = stack;
+			return stack;
+		});
+		return this.stackPromise;
+	}
+	async buildStack() {
+		const config = await this.configStore.load();
+		await this.loadCustomCommands();
+		const authTokens = await this.configStore.getAuthTokens();
+		if (!authTokens) throw RequestError.authRequired(void 0, "Not authenticated. Run `b4m /login` first.");
+		if (new Date(authTokens.expiresAt) <= /* @__PURE__ */ new Date()) {
+			await this.configStore.clearAuthTokens();
+			throw RequestError.authRequired(void 0, "Authentication expired. Run `b4m /login` again.");
+		}
+		const apiBaseURL = requireApiUrl(config.apiConfig);
+		const apiClient = new ApiClient(apiBaseURL, this.configStore);
+		const tokenGetter = async () => (await this.configStore.getAuthTokens())?.accessToken ?? null;
+		await this.mergeRemoteSkills(config, apiClient);
+		const startupLog = [];
+		const { llm, wsManager, modelInfo } = await buildLlmBackend({
+			config,
+			apiClient,
+			tokenGetter,
+			startupLog
+		});
+		const permissionManager = new PermissionManager(config.trustedTools ?? [], void 0, config.tools.disabled ?? []);
+		const checkpointStore = new CheckpointStore(this.configStore.getProjectConfigDir() ?? process.cwd());
+		const stackSessionId = randomUUID();
+		const { sandboxOrchestrator } = await buildSandbox({
+			config,
+			sessionId: stackSessionId,
+			permissionManager,
+			checkpointStore
+		});
+		const additionalDirectories = await this.resolveAdditionalDirectories();
+		const agentContext = {
+			currentAgent: null,
+			observationQueue: []
+		};
+		const { agentStore, contextResult, loadedB4mTools, orchestrator, backgroundManager, historyStore, mcpManager } = await buildSupportingStores({
+			config,
+			llm,
+			modelId: modelInfo.id,
+			permissionManager,
+			apiClient,
+			configStore: this.configStore,
+			customCommandStore: this.customCommandStore,
+			checkpointStore,
+			sandboxOrchestrator,
+			additionalDirectories,
+			agentContext,
+			promptFn: this.promptFn,
+			userQuestionFn: this.userQuestionFn,
+			startupLog,
+			silentLogger,
+			onBackgroundStatusChange: () => {},
+			onGroupCompletion: () => {}
+		});
+		const llmWithFallback = config.fallbackModels && config.fallbackModels.length > 0 ? new FallbackLlmBackend(llm, config.fallbackModels, (from, to, error) => logger.debug(`[acp] Model "${from}" failed (${error.message}); falling back to "${to}"`)) : llm;
+		const notifyingLlm = new NotifyingLlmBackend(llmWithFallback, backgroundManager);
+		const cliTools = this.buildCliTools({
+			config,
+			orchestrator,
+			agentStore,
+			backgroundManager,
+			historyStore,
+			sessionId: stackSessionId
+		});
+		const agentToolsRef = { current: null };
+		const toolSearchTool = deferredToolRegistry.size() > 0 ? createToolSearchTool(() => {
+			if (!agentToolsRef.current) throw new Error("tool_search invoked before agent context was wired");
+			return agentToolsRef.current;
+		}) : null;
+		const allTools = [
+			...loadedB4mTools,
+			...toolSearchTool ? [toolSearchTool] : [],
+			...cliTools
+		];
+		const { agent, buildPromptForMode } = buildAgent({
+			config,
+			modelId: modelInfo.id,
+			notifyingLlm,
+			allTools,
+			agentContext,
+			agentToolsRef,
+			silentLogger,
+			sessionId: stackSessionId,
+			initialInteractionMode: "normal",
+			contextContent: contextResult.mergedContent,
+			agentStore,
+			customCommandStore: this.customCommandStore,
+			enableSkillTool: config.preferences.enableSkillTool !== false,
+			additionalDirectories,
+			featureModulePrompts: ""
+		});
+		const cleanup = async () => {
+			await mcpManager.disconnect().catch(() => {});
+			wsManager?.disconnect();
+			setWebSocketToolExecutor(null);
+			agent.removeAllListeners();
+		};
+		return {
+			agent,
+			buildPromptForMode,
+			permissionManager,
+			modelId: modelInfo.id,
+			cleanup
+		};
+	}
+	buildCliTools(input) {
+		const { config, orchestrator, agentStore, backgroundManager, historyStore, sessionId } = input;
+		const tools = [
+			createAgentDelegateTool(orchestrator, agentStore, sessionId, backgroundManager),
+			...createBackgroundAgentTools(backgroundManager),
+			createResumeAgentTool(orchestrator, historyStore, backgroundManager),
+			createWriteTodosTool(createTodoStore()),
+			createFindDefinitionTool(),
+			createGetFileStructureTool()
+		];
+		if (config.preferences.enableSkillTool !== false) tools.push(createSkillTool({
+			customCommandStore: this.customCommandStore,
+			subagentOrchestrator: orchestrator,
+			sessionId
+		}));
+		if (config.preferences.enableCoordinatorMode === true) tools.push(createCoordinateTaskTool(orchestrator, agentStore, sessionId));
+		return tools;
+	}
+	async loadCustomCommands() {
+		try {
+			await this.customCommandStore.loadCommands();
+		} catch {}
+	}
+	async mergeRemoteSkills(config, apiClient) {
+		if (!(process.env.B4M_NO_REMOTE_SKILLS !== "1" && config.preferences.enableRemoteSkills !== false)) return;
+		try {
+			this.customCommandStore.setRemoteSource(new RemoteSkillSource(apiClient));
+			await this.customCommandStore.mergeRemoteCommands();
+		} catch {}
+	}
+	async resolveAdditionalDirectories() {
+		const configDirs = await this.configStore.getAdditionalDirectories();
+		return [.../* @__PURE__ */ new Set([...configDirs, ...this.parseEnvDirs()])];
+	}
+	/** Parse B4M_ADDITIONAL_DIRS defensively - a malformed value must not brick bootstrap. */
+	parseEnvDirs() {
+		const raw = process.env.B4M_ADDITIONAL_DIRS;
+		if (!raw) return [];
+		try {
+			const parsed = JSON.parse(raw);
+			return Array.isArray(parsed) ? parsed.filter((d) => typeof d === "string") : [];
+		} catch {
+			logger.debug(`[acp] Ignoring malformed B4M_ADDITIONAL_DIRS: ${raw}`);
+			return [];
+		}
+	}
+};
+//#endregion
+//#region src/acp/app.ts
+/**
+* Wires the ACP agent-side request/notification handlers to an AcpServer.
+*
+* Extracted from the command entry point so the same handler graph can be
+* driven in-process by tests (via the SDK's client/agent direct connect) as
+* well as over stdio in production.
+*/
+/**
+* Build the ACP AgentApp. `getServer` is a late-bound accessor because the
+* server needs the connection's abort signal, which only exists after
+* `connect()` - the accessor lets handlers resolve the server on first use.
+*/
+function buildAcpApp(getServer) {
+	return agent({ name: AGENT_INFO.name }).onRequest(methods.agent.initialize, ({ params }) => getServer().initialize(params)).onRequest(methods.agent.session.new, ({ params }) => getServer().newSession(params)).onRequest(methods.agent.session.load, ({ params, client }) => getServer().loadSession(params, client)).onRequest(methods.agent.session.prompt, ({ params, client, signal }) => getServer().prompt(params, client, signal)).onRequest(methods.agent.session.setMode, ({ params, client }) => getServer().setSessionMode(params, client)).onNotification(methods.agent.session.cancel, ({ params }) => getServer().cancel(params));
+}
+//#endregion
+//#region src/commands/acpCommand.ts
+/**
+* `b4m acp` - run the agent as an Agent Client Protocol (ACP) server.
+*
+* ACP is "LSP for coding agents": JSON-RPC 2.0 over stdio. This turns the CLI
+* into a first-class agent backend for any ACP-capable editor (Zed today) with
+* no per-editor extension work. It sits parallel to the interactive TUI and the
+* headless stream-json mode, reusing the same agent core, permission model, and
+* session store.
+*
+* Transport contract: stdout carries the JSON-RPC stream and NOTHING else, so
+* all diagnostics are forced to stderr before the agent stack (which logs
+* freely) boots.
+*/
+/**
+* Isolate stdout for the JSON-RPC frame stream. Returns a writer bound to the
+* REAL stdout for the protocol to use, then redirects everything else -
+* `console.*` AND any stray `process.stdout.write` deep in the agent stack - to
+* stderr. stdout purity is the one invariant this transport must hold: a single
+* unrelated byte on stdout corrupts a frame, so we close the whole channel
+* rather than trusting no dependency ever prints.
+*/
+function captureStdout() {
+	const writeToRealStdout = process.stdout.write.bind(process.stdout);
+	const toStderr = (...args) => {
+		process.stderr.write(args.map(String).join(" ") + "\n");
+	};
+	console.log = toStderr;
+	console.info = toStderr;
+	console.debug = toStderr;
+	process.stdout.write = process.stderr.write.bind(process.stderr);
+	return writeToRealStdout;
+}
+async function handleAcpCommand(options) {
+	const writeFrame = captureStdout();
+	logger.setVerbose(options.verbose);
+	const input = Readable.toWeb(process.stdin);
+	const output = new WritableStream({ write(chunk) {
+		if (writeFrame(chunk)) return;
+		return new Promise((resolve) => process.stdout.once("drain", resolve));
+	} });
+	const stream = ndJsonStream(output, input);
+	let server = null;
+	const guardServer = () => {
+		if (!server) throw new Error("ACP server accessed before connection established");
+		return server;
+	};
+	const connection = buildAcpApp(guardServer).connect(stream);
+	server = new AcpServer(connection.signal, options.version);
+	await connection.closed;
+	await server.close();
+}
+//#endregion
+export { handleAcpCommand };