@bike4mind/cli 0.18.5 → 0.20.0

package/dist/commands/apiCommand.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
-import { a as getDefaultApiUrl, t as ConfigStore } from "../ConfigStore-D39UqFnY.mjs";
+import { l as resolveApiEndpoint, s as parseApiUrl, t as ConfigStore } from "../ConfigStore-DD3DcC3-.mjs";
 //#region src/commands/apiCommand.ts
 /**
 * External API config command (--api-url / --reset-api)
 * Runs outside the interactive CLI session, before any auth flow.
 *
-* - `--reset-api`: clears customUrl, falling back to the build-time default service
+* - `--reset-api`: clears customUrl, falling back to whatever the CLI resolves
+*   without one (build-time default, the source-mode local dev server, or - for
+*   a published unbranded fork - nothing, in which case `b4m` prompts for one)
 * - `--api-url <url>`: sets a custom API URL (e.g. http://localhost:3000)
 *
 * Both clear auth tokens because they're bound to the old origin, and both
@@ -14,20 +16,13 @@ import { a as getDefaultApiUrl, t as ConfigStore } from "../ConfigStore-D39UqFnY
 async function handleApiCommand(options) {
 	const configStore = new ConfigStore();
 	if (options.mode === "set") {
-		const url = options.url.trim().replace(/\/+$/, "");
-		let parsed;
-		try {
-			parsed = new URL(url);
-		} catch {
-			console.error(`❌ Invalid URL: ${url}`);
-			console.error("   Example: --api-url http://localhost:3000");
-			process.exit(1);
-		}
-		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-			console.error(`❌ Only http:// and https:// URLs are supported (got ${parsed.protocol}//)`);
+		const result = parseApiUrl(options.url);
+		if ("error" in result) {
+			console.error(`❌ ${result.error}`);
 			console.error("   Example: --api-url http://localhost:3000");
 			process.exit(1);
 		}
+		const { url } = result;
 		await configStore.setCustomApiUrl(url);
 		await configStore.clearAuthTokens();
 		console.log(`\n✅ API URL set to ${url}`);
@@ -37,10 +32,13 @@ async function handleApiCommand(options) {
 	}
 	await configStore.setCustomApiUrl(null);
 	await configStore.clearAuthTokens();
-	const defaultUrl = getDefaultApiUrl();
-	console.log(`\n✅ API URL reset to the default service${defaultUrl ? ` (${defaultUrl})` : ""}`);
+	const endpoint = resolveApiEndpoint();
+	console.log("\n✅ Custom API URL cleared");
 	console.log("🔓 Authentication cleared");
-	console.log("💡 Run `b4m` to authenticate.\n");
+	if (endpoint.status === "configured") {
+		console.log(`🌍 The CLI will now use ${endpoint.url}`);
+		console.log("💡 Run `b4m` to authenticate.\n");
+	} else console.log("💡 Run `b4m` and you'll be prompted to choose a backend.\n");
 }
 //#endregion
 export { handleApiCommand };

package/dist/commands/doctorCommand.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { t as version } from "../package-I_v_WFUn.mjs";
-import { a as fetchLatestVersion, c as isNpmPrefixWritable, i as compareSemver } from "../updateChecker-C8xsNY2L.mjs";
+import { t as version } from "../package-BqKSCbso.mjs";
+import { a as fetchLatestVersion, c as isNpmPrefixWritable, i as compareSemver } from "../updateChecker-CQW8bxo6.mjs";
 import { t as checkRipgrep } from "../ripgrepCheck-BmkyTK2i.mjs";
 import { execSync } from "child_process";
 import { existsSync } from "fs";
@@ -17,15 +17,15 @@ async function handleDoctorCommand() {
 	console.log("Running diagnostics...\n");
 	const results = [];
 	const nodeVersion = process.version;
-	if (parseInt(nodeVersion.slice(1).split(".")[0], 10) >= 18) results.push({
+	if (parseInt(nodeVersion.slice(1).split(".")[0], 10) >= 24) results.push({
 		name: "Node.js version",
 		status: "pass",
-		message: `${nodeVersion} (>= 18 required)`
+		message: `${nodeVersion} (>= 24 required)`
 	});
 	else results.push({
 		name: "Node.js version",
 		status: "fail",
-		message: `${nodeVersion} (>= 18 required, please upgrade)`
+		message: `${nodeVersion} (>= 24 required, please upgrade)`
 	});
 	const currentVersion = version;
 	const latestVersion = await fetchLatestVersion();

package/dist/commands/envCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as ConfigStore } from "../ConfigStore-D39UqFnY.mjs";
+import { t as ConfigStore } from "../ConfigStore-DD3DcC3-.mjs";
 //#region src/commands/envCommand.ts
 /**
 * Environment switching for the `--dev` / `--prod` launch flags.

package/dist/commands/headlessCommand.mjs

@@ -1,12 +1,180 @@
 #!/usr/bin/env node
-import { C as createCoordinateTaskTool, D as FallbackLlmBackend, E as ApiClient, F as generateCliTools, G as ReActAgent, N as loadContextFiles, O as ServerLlmBackend, P as PermissionManager, Q as CheckpointStore, T as createAgentDelegateTool, W as setWebSocketToolExecutor, X as RemoteSkillSource, Y as isReadOnlyTool, Z as CustomCommandStore, _ as createGetFileStructureTool, a as WebSocketToolExecutor, b as createWriteTodosTool, et as SessionStore, i as McpManager, n as SubagentOrchestrator, o as WebSocketConnectionManager, q as buildSystemPrompt, r as AgentStore, s as WebSocketLlmBackend, t as BackgroundAgentManager, v as createFindDefinitionTool, w as createBackgroundAgentTools, x as createSkillTool, y as createTodoStore } from "../BackgroundAgentManager-D-xsWd3C.mjs";
-import { n as logger, r as getApiUrl, t as ConfigStore } from "../ConfigStore-D39UqFnY.mjs";
+import { $ as RemoteSkillSource, A as FallbackLlmBackend, B as classifyCommandRisk, C as createWriteTodosTool, D as createResumeAgentTool, E as createCoordinateTaskTool, F as loadContextFiles, I as PermissionManager, J as setWebSocketToolExecutor, L as generateCliTools, M as ReActAgent, O as createBackgroundAgentTools, Q as isReadOnlyTool, S as createTodoStore, X as buildSystemPrompt, a as McpManager, b as createWorkItemTools, et as CustomCommandStore, i as AgentStore, k as createAgentDelegateTool, n as BackgroundAgentManager, nt as SessionStore, o as createSseBackend, r as SubagentOrchestrator, t as AgentHistoryStore, tt as CheckpointStore, w as createSkillTool, x as createFindDefinitionTool, y as createGetFileStructureTool, z as SHELL_LIKE_TOOL_COMMAND_FIELDS } 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 { t as DEFAULT_SANDBOX_CONFIG } from "../types-LyRNHOiS.mjs";
+import { r as reconstructTurnBlocks, t as WorkItemsClient } from "../WorkItemsClient-Cow6nXx7.mjs";
 import { t as createSandboxRuntime } from "../SandboxRuntimeAdapter-ChGlxSGQ.mjs";
-import { t as SandboxOrchestrator } from "../SandboxOrchestrator-BoINxbX4.mjs";
-import { t as ProxyManager } from "../ProxyManager-CV94yZUW.mjs";
+import { t as SandboxOrchestrator } from "../SandboxOrchestrator-C8uleDn2.mjs";
+import { t as ProxyManager } from "../ProxyManager-C5H0pUyK.mjs";
 import { randomBytes } from "crypto";
 import { v4 } from "uuid";
+import { readFile } from "fs/promises";
+//#region src/commands/headlessProtocol.ts
+/**
+* Headless stream-JSON protocol contract.
+*
+* `b4m -p "..." --output-format stream-json` emits one JSON object per line
+* (NDJSON). This module owns that wire contract so CI and other tooling can
+* depend on it: the schema version, the event shapes, and (later milestones)
+* the permission protocol and strict input validation.
+*
+* Human-readable spec: packages/cli/docs/headless-protocol.md. Keep the two in
+* sync - every event type and field documented there must be produced here.
+*/
+/**
+* Protocol schema version (semver). Bump the MAJOR when removing/renaming a
+* field or event type (breaking change); bump the MINOR when adding an optional
+* field or a new event type (backward-compatible). Consumers should reject a
+* MAJOR they do not understand.
+*/
+const HEADLESS_SCHEMA_VERSION = "1.0.0";
+/** Serialize an event with the protocol envelope stamped on. Exposed for tests. */
+function stampEvent(runId, event) {
+	return {
+		...event,
+		schemaVersion: HEADLESS_SCHEMA_VERSION,
+		runId
+	};
+}
+/**
+* Build an NDJSON emitter that stamps schemaVersion + runId onto every event.
+* `write` receives one serialized line including its trailing newline.
+*/
+function createHeadlessEmitter(runId, write) {
+	return (event) => {
+		write(JSON.stringify(stampEvent(runId, event)) + "\n");
+	};
+}
+/**
+* Raised when a structured headless input is malformed or carries a field
+* outside its allowlist. Headless input fails loud on protocol drift rather
+* than silently ignoring unknown fields.
+*/
+var HeadlessInputError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "HeadlessInputError";
+	}
+};
+/**
+* Decode a JSON string to a plain object and reject any key outside
+* `allowedKeys`. `inputType` names the input in error messages. Throws
+* HeadlessInputError on invalid JSON, a non-object payload, or an unknown key.
+*/
+function parseStrictObject(raw, allowedKeys, inputType) {
+	let decoded;
+	try {
+		decoded = JSON.parse(raw);
+	} catch (e) {
+		throw new HeadlessInputError(`${inputType}: invalid JSON (${e instanceof Error ? e.message : String(e)})`);
+	}
+	if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) throw new HeadlessInputError(`${inputType}: expected a JSON object`);
+	const allowed = new Set(allowedKeys);
+	const unknownKeys = Object.keys(decoded).filter((k) => !allowed.has(k));
+	if (unknownKeys.length > 0) throw new HeadlessInputError(`${inputType}: unknown field(s): ${unknownKeys.join(", ")}. Allowed: ${allowedKeys.join(", ")}`);
+	return decoded;
+}
+/**
+* Decode a JSON string to an array of strings, rejecting any other shape.
+* Used for list-shaped inputs such as the B4M_ADDITIONAL_DIRS bridge.
+*/
+function parseStringArray(raw, inputType) {
+	let decoded;
+	try {
+		decoded = JSON.parse(raw);
+	} catch (e) {
+		throw new HeadlessInputError(`${inputType}: invalid JSON (${e instanceof Error ? e.message : String(e)})`);
+	}
+	if (!Array.isArray(decoded) || decoded.some((v) => typeof v !== "string")) throw new HeadlessInputError(`${inputType}: expected a JSON array of strings`);
+	return decoded;
+}
+/**
+* Classify the risk of a single tool invocation for the permission protocol.
+* Shell-like tools are classified from their actual command text (reusing the
+* shared command-risk tokenizer); every other tool falls back to a level derived
+* from its permission category (auto_approve -> low, prompt_always -> high, else
+* medium). Never throws: a classifier failure fails closed at `high`.
+*/
+function classifyToolRisk(toolName, args, category) {
+	const field = SHELL_LIKE_TOOL_COMMAND_FIELDS[toolName];
+	const command = field && args !== null && typeof args === "object" ? args[field] : void 0;
+	if (typeof command === "string") try {
+		return classifyCommandRisk(command);
+	} catch {
+		return {
+			level: "high",
+			reasons: ["command risk analysis failed (fail closed)"]
+		};
+	}
+	return {
+		level: category === "auto_approve" ? "low" : category === "prompt_always" ? "high" : "medium",
+		reasons: []
+	};
+}
+const HEADLESS_PERMISSION_POLICY_KEYS = [
+	"allow",
+	"deny",
+	"maxAutoAllowRisk",
+	"defaultAction"
+];
+const RISK_RANK = {
+	low: 0,
+	medium: 1,
+	high: 2
+};
+function readOptionalStringArray(value, label) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) throw new HeadlessInputError(`${label} must be an array of strings`);
+	return value;
+}
+/**
+* Parse and strictly validate a permission policy from its JSON text. Rejects
+* unknown fields and malformed values with HeadlessInputError. Missing lists
+* default to empty and a missing defaultAction defaults to 'deny'.
+*/
+function parsePermissionPolicy(raw) {
+	const obj = parseStrictObject(raw, HEADLESS_PERMISSION_POLICY_KEYS, "permission policy");
+	const allow = readOptionalStringArray(obj.allow, "permission policy: allow");
+	const deny = readOptionalStringArray(obj.deny, "permission policy: deny");
+	let maxAutoAllowRisk;
+	if (obj.maxAutoAllowRisk !== void 0) {
+		if (obj.maxAutoAllowRisk !== "low" && obj.maxAutoAllowRisk !== "medium" && obj.maxAutoAllowRisk !== "high") throw new HeadlessInputError("permission policy: maxAutoAllowRisk must be one of low|medium|high");
+		maxAutoAllowRisk = obj.maxAutoAllowRisk;
+	}
+	let defaultAction = "deny";
+	if (obj.defaultAction !== void 0) {
+		if (obj.defaultAction !== "allow" && obj.defaultAction !== "deny") throw new HeadlessInputError("permission policy: defaultAction must be one of allow|deny");
+		defaultAction = obj.defaultAction;
+	}
+	if (maxAutoAllowRisk !== void 0 && defaultAction === "allow") throw new HeadlessInputError("permission policy: maxAutoAllowRisk has no effect with defaultAction 'allow' (tools above the threshold are allowed anyway); set defaultAction to 'deny' or remove maxAutoAllowRisk");
+	return {
+		allow,
+		deny,
+		maxAutoAllowRisk,
+		defaultAction
+	};
+}
+/** Evaluate a policy against a tool and its classified risk. Never throws. */
+function evaluatePermissionPolicy(policy, toolName, riskLevel) {
+	if (policy.deny.includes(toolName)) return {
+		action: "deny",
+		reason: "tool in policy deny list"
+	};
+	if (policy.allow.includes(toolName)) return {
+		action: "allow",
+		reason: "tool in policy allow list"
+	};
+	if (policy.maxAutoAllowRisk && RISK_RANK[riskLevel] <= RISK_RANK[policy.maxAutoAllowRisk]) return {
+		action: "allow",
+		reason: `risk ${riskLevel} <= maxAutoAllowRisk ${policy.maxAutoAllowRisk}`
+	};
+	return {
+		action: policy.defaultAction,
+		reason: `policy default (${policy.defaultAction})`
+	};
+}
+//#endregion
 //#region src/commands/headlessCommand.ts
 /**
 * Headless/programmatic mode command (b4m -p "query")
@@ -32,22 +200,33 @@ const silentLogger = {
 	debug: () => {}
 };
 async function handleHeadlessCommand(options) {
-	const { prompt, outputFormat, dangerouslySkipPermissions, addDirs } = options;
+	const { prompt, outputFormat, dangerouslySkipPermissions, addDirs, permissionPolicyPath } = options;
 	logger.setVerbose(options.verbose);
 	const stdinContent = await readStdin();
 	const fullPrompt = stdinContent ? `${prompt}\n\n<stdin>\n${stdinContent}\n</stdin>` : prompt;
 	const configStore = new ConfigStore();
 	const sessionStore = new SessionStore();
 	const customCommandStore = new CustomCommandStore();
+	const runId = v4();
 	try {
 		const config = await configStore.load();
 		const configDirs = await configStore.getAdditionalDirectories();
-		const flagDirs = process.env.B4M_ADDITIONAL_DIRS ? JSON.parse(process.env.B4M_ADDITIONAL_DIRS) : [];
-		const additionalDirectories = [...new Set([
+		const flagDirs = process.env.B4M_ADDITIONAL_DIRS ? parseStringArray(process.env.B4M_ADDITIONAL_DIRS, "B4M_ADDITIONAL_DIRS") : [];
+		const additionalDirectories = [.../* @__PURE__ */ new Set([
 			...configDirs,
 			...flagDirs,
 			...addDirs
 		])];
+		let permissionPolicy = null;
+		if (permissionPolicyPath) {
+			let policyRaw;
+			try {
+				policyRaw = await readFile(permissionPolicyPath, "utf-8");
+			} catch (e) {
+				throw new Error(`Cannot read permission policy at "${permissionPolicyPath}": ${e instanceof Error ? e.message : String(e)}`);
+			}
+			permissionPolicy = parsePermissionPolicy(policyRaw);
+		}
 		try {
 			await customCommandStore.loadCommands();
 		} catch {}
@@ -61,45 +240,22 @@ async function handleHeadlessCommand(options) {
 			process.stderr.write("Error: Authentication token expired. Run `b4m /login` to re-authenticate.\n");
 			process.exit(1);
 		}
-		const apiClient = new ApiClient(getApiUrl(config.apiConfig), configStore);
+		let apiBaseURL;
+		try {
+			apiBaseURL = requireApiUrl(config.apiConfig);
+		} catch (error) {
+			process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+			process.exit(1);
+		}
+		const apiClient = new ApiClient(apiBaseURL, configStore);
 		if (process.env.B4M_NO_REMOTE_SKILLS !== "1" && config.preferences.enableRemoteSkills !== false) try {
 			customCommandStore.setRemoteSource(new RemoteSkillSource(apiClient));
 			await customCommandStore.mergeRemoteCommands();
 		} catch {}
-		const tokenGetter = async () => {
-			return (await 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
-				});
-				logger.debug("[headless] Using WebSocket transport");
-			} else throw new Error("No websocketUrl or wsCompletionUrl in server config");
-		} catch {
-			wsManager = null;
-			setWebSocketToolExecutor(null);
-			llm = new ServerLlmBackend({
-				apiClient,
-				model: config.defaultModel,
-				completionsUrl
-			});
-			logger.debug("[headless] Using SSE transport fallback");
-		}
+		const { llm } = await createSseBackend({
+			apiClient,
+			model: config.defaultModel
+		});
 		const models = await llm.getModelInfo();
 		if (models.length === 0) throw new Error("No models available from server.");
 		const modelInfo = models.find((m) => m.id === config.defaultModel) ?? models[0];
@@ -122,22 +278,51 @@ async function handleHeadlessCommand(options) {
 		};
 		await logger.initialize(session.id);
 		const permissionManager = new PermissionManager(config.trustedTools ?? [], void 0, config.tools.disabled);
-		const promptFn = (toolName, _args, _preview) => {
-			if (dangerouslySkipPermissions) {
-				logger.debug(`[headless] Auto-allowing tool: ${toolName}`);
-				return Promise.resolve({ action: "allow-once" });
-			}
-			process.stderr.write(`Warning: Tool "${toolName}" requires permission and was denied. Use --dangerously-skip-permissions to auto-allow tools in headless mode.\n`);
-			return Promise.resolve({ action: "deny" });
+		const emit = createHeadlessEmitter(runId, (line) => process.stdout.write(line));
+		const streaming = outputFormat === "stream-json";
+		const promptFn = (toolName, args, _preview) => {
+			const risk = classifyToolRisk(toolName, args, permissionManager.getCategory(toolName));
+			if (streaming) emit({
+				type: "permission_request",
+				toolName,
+				risk
+			});
+			let decision;
+			if (dangerouslySkipPermissions) decision = {
+				action: "allow-once",
+				reason: "dangerously-skip-permissions"
+			};
+			else if (permissionPolicy) {
+				const verdict = evaluatePermissionPolicy(permissionPolicy, toolName, risk.level);
+				decision = {
+					action: verdict.action === "allow" ? "allow-once" : "deny",
+					reason: verdict.reason
+				};
+			} else decision = {
+				action: "deny",
+				reason: "no permission policy; default deny"
+			};
+			if (streaming) emit({
+				type: "permission_decision",
+				toolName,
+				action: decision.action,
+				reason: decision.reason,
+				risk: risk.level
+			});
+			else if (decision.action === "deny") process.stderr.write(`Warning: Tool "${toolName}" requires permission and was denied (${decision.reason}). Grant it via --permission-policy, or --dangerously-skip-permissions to allow all tools.\n`);
+			if (decision.action === "allow-once") logger.debug(`[headless] Auto-allowing tool: ${toolName}`);
+			return Promise.resolve({ action: decision.action });
 		};
 		const userQuestionFn = (_payload) => {
 			process.stderr.write("Warning: Agent requested user input; headless mode cannot respond interactively. Answering with empty response.\n");
 			return Promise.resolve({ answers: [] });
 		};
 		const sandboxConfig = config.sandbox ?? DEFAULT_SANDBOX_CONFIG;
-		const checkpointStore = new CheckpointStore(configStore.getProjectConfigDir() ?? process.cwd());
+		const checkpointProjectDir = configStore.getProjectConfigDir() ?? process.cwd();
+		const checkpointStore = new CheckpointStore(checkpointProjectDir);
 		const [sandboxRuntime] = await Promise.all([createSandboxRuntime(), checkpointStore.init(session.id).catch(() => {})]);
-		const sandboxOrchestrator = new SandboxOrchestrator(sandboxConfig, sandboxRuntime, new ProxyManager(sandboxConfig.network));
+		const proxyManager = new ProxyManager(sandboxConfig.network);
+		const sandboxOrchestrator = new SandboxOrchestrator(sandboxConfig, sandboxRuntime, proxyManager);
 		permissionManager.setSandboxState(sandboxConfig.mode, sandboxOrchestrator.isActive());
 		const agentContext = {
 			currentAgent: null,
@@ -154,6 +339,7 @@ async function handleHeadlessCommand(options) {
 			loadContextFiles(projectConfigDir)
 		]);
 		const mcpTools = mcpManager.getTools();
+		const historyStore = new AgentHistoryStore(config.preferences.subagentHistoryTtlMs ?? 36e5);
 		const orchestrator = new SubagentOrchestrator({
 			userId: config.userId,
 			llm,
@@ -166,14 +352,18 @@ async function handleHeadlessCommand(options) {
 			customCommandStore,
 			enableParallelToolExecution: config.preferences.enableParallelToolExecution === true,
 			showUserQuestion: userQuestionFn,
-			checkpointStore
+			checkpointStore,
+			historyStore
 		});
 		const backgroundManager = new BackgroundAgentManager(orchestrator);
 		const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, session.id, backgroundManager);
 		const backgroundTools = createBackgroundAgentTools(backgroundManager);
-		const writeTodosTool = createWriteTodosTool(createTodoStore());
+		const resumeAgentTool = createResumeAgentTool(orchestrator, historyStore, backgroundManager);
+		const todoStore = createTodoStore();
+		const writeTodosTool = createWriteTodosTool(todoStore);
 		const findDefinitionTool = createFindDefinitionTool();
 		const getFileStructureTool = createGetFileStructureTool();
+		const workItemTools = config.preferences.enableWorkItemTools ? createWorkItemTools(new WorkItemsClient(apiClient)) : [];
 		const enableSkillTool = config.preferences.enableSkillTool !== false;
 		const skillTool = enableSkillTool ? createSkillTool({
 			customCommandStore,
@@ -183,9 +373,11 @@ async function handleHeadlessCommand(options) {
 		const cliTools = [
 			agentDelegateTool,
 			...backgroundTools,
+			resumeAgentTool,
 			writeTodosTool,
 			findDefinitionTool,
-			getFileStructureTool
+			getFileStructureTool,
+			...workItemTools
 		];
 		if (skillTool) cliTools.push(skillTool);
 		if (config.preferences.enableCoordinatorMode === true) {
@@ -219,16 +411,15 @@ async function handleHeadlessCommand(options) {
 		});
 		agentContext.currentAgent = agent;
 		agent.observationQueue = agentContext.observationQueue;
-		if (outputFormat === "stream-json") {
-			const emitNdjson = (obj) => process.stdout.write(JSON.stringify(obj) + "\n");
+		if (streaming) {
 			agent.on("thought", (step) => {
-				emitNdjson({
+				emit({
 					type: "thought",
 					content: step.content
 				});
 			});
 			agent.on("action", (step) => {
-				emitNdjson({
+				emit({
 					type: "action",
 					content: step.content,
 					toolName: step.metadata?.toolName,
@@ -236,7 +427,7 @@ async function handleHeadlessCommand(options) {
 				});
 			});
 			agent.on("observation", (step) => {
-				emitNdjson({
+				emit({
 					type: "observation",
 					content: step.content,
 					toolName: step.metadata?.toolName
@@ -255,6 +446,7 @@ async function handleHeadlessCommand(options) {
 		} finally {
 			backgroundManager.setCurrentTurn(null);
 		}
+		const richContent = reconstructTurnBlocks(result.steps, result.finalAnswer);
 		const finalSession = {
 			...session,
 			messages: [{
@@ -266,6 +458,7 @@ async function handleHeadlessCommand(options) {
 				id: v4(),
 				role: "assistant",
 				content: result.finalAnswer,
+				...richContent ? { richContent } : {},
 				timestamp: (/* @__PURE__ */ new Date()).toISOString()
 			}],
 			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -282,6 +475,8 @@ async function handleHeadlessCommand(options) {
 				break;
 			case "json": {
 				const jsonResult = {
+					schemaVersion: HEADLESS_SCHEMA_VERSION,
+					runId,
 					result: result.finalAnswer,
 					steps: result.steps.map((s) => ({
 						type: s.type,
@@ -300,32 +495,33 @@ async function handleHeadlessCommand(options) {
 				process.stdout.write(JSON.stringify(jsonResult, null, 2) + "\n");
 				break;
 			}
-			case "stream-json":
-				process.stdout.write(JSON.stringify({
-					type: "result",
-					content: result.finalAnswer,
-					tokenUsage: {
-						totalTokens: result.completionInfo.totalTokens,
-						inputTokens: result.completionInfo.totalInputTokens,
-						outputTokens: result.completionInfo.totalOutputTokens
-					},
-					iterations: result.completionInfo.iterations,
-					toolCalls: result.completionInfo.toolCalls
-				}) + "\n");
-				break;
+			case "stream-json": emit({
+				type: "result",
+				content: result.finalAnswer,
+				tokenUsage: {
+					totalTokens: result.completionInfo.totalTokens,
+					inputTokens: result.completionInfo.totalInputTokens,
+					outputTokens: result.completionInfo.totalOutputTokens
+				},
+				iterations: result.completionInfo.iterations,
+				toolCalls: result.completionInfo.toolCalls
+			});
 		}
 		await mcpManager.disconnect().catch(() => {});
-		if (wsManager) wsManager.disconnect();
 		setWebSocketToolExecutor(null);
 		agent.removeAllListeners();
 		process.exit(0);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		if (outputFormat === "json") process.stdout.write(JSON.stringify({ error: message }) + "\n");
-		else if (outputFormat === "stream-json") process.stdout.write(JSON.stringify({
-			type: "error",
+		if (outputFormat === "json") process.stdout.write(JSON.stringify({
+			schemaVersion: HEADLESS_SCHEMA_VERSION,
+			runId,
 			error: message
 		}) + "\n");
+		else if (outputFormat === "stream-json") createHeadlessEmitter(runId, (line) => process.stdout.write(line))({
+			type: "error",
+			error: message
+		});
 		else process.stderr.write(`Error: ${message}\n`);
 		process.exit(1);
 	}

package/dist/commands/mcpCommand.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { t as ConfigStore } from "../ConfigStore-D39UqFnY.mjs";
+import { t as ConfigStore } from "../ConfigStore-DD3DcC3-.mjs";
+import { t as version } from "../package-BqKSCbso.mjs";
 //#region src/commands/mcpCommand.ts
 /**
 * External MCP commands (b4m mcp list, b4m mcp add, etc.)
@@ -68,6 +69,17 @@ async function handleMcpCommand(subcommand, argv) {
 			}
 			await handleDisable(config, argv.name, configStore);
 			break;
+		case "serve": {
+			const { handleMcpServeCommand } = await import("../serve-CuF0I5en.mjs");
+			await handleMcpServeCommand({
+				http: Boolean(argv.http),
+				port: typeof argv.port === "number" ? argv.port : void 0,
+				apiKey: typeof argv.apiKey === "string" ? argv.apiKey : void 0,
+				apiUrl: typeof argv.apiUrl === "string" ? argv.apiUrl : void 0,
+				version
+			});
+			break;
+		}
 		default:
 			console.error(`❌ Unknown MCP subcommand: ${subcommand}`);
 			console.error("");
@@ -77,6 +89,7 @@ async function handleMcpCommand(subcommand, argv) {
 			console.error("  b4m mcp remove <name>             - Remove an MCP server");
 			console.error("  b4m mcp enable <name>             - Enable an MCP server");
 			console.error("  b4m mcp disable <name>            - Disable an MCP server");
+			console.error("  b4m mcp serve [--http] [--port]   - Run Bike4Mind as an MCP server");
 			process.exit(1);
 	}
 }