@bike4mind/cli 1.2.0 → 2.1.0

package/dist/{WorkItemsClient-Cow6nXx7.mjs → WorkItemsClient-ClBC49y0.mjs}

@@ -1,12 +1,27 @@
 #!/usr/bin/env node
+import { bt as tokenEstimateMultiplier } from "./ConfigStore-BygzEI6H.mjs";
 import { v4 } from "uuid";
 import { get_encoding } from "tiktoken";
+//#region ../../b4m-core/utils/dist/calibratedTokenizer.mjs
+/**
+* Scale a raw cl100k_base count by `multiplier`, rounded up to the nearest whole token. Paired with
+* tokenEstimateMultiplier (@bike4mind/common) to bring a raw count up to a Claude model's tokenizer.
+* The sync counterpart of withTokenEstimateMultiplier, for callers whose counter is synchronous.
+*/
+function scaleTokenEstimate(count, multiplier) {
+	if (multiplier === 1) return count;
+	const hundredths = Math.round(multiplier * 100);
+	return Math.ceil(count * hundredths / 100);
+}
+//#endregion
 //#region src/utils/tokenCounter.ts
 const DEFAULT_CONTEXT_WINDOW = 2e5;
 const IMAGE_BLOCK_TOKEN_ESTIMATE = 1600;
 /**
 * Token counting utility for context window management.
-* Uses tiktoken (cl100k_base encoding) which works for Claude and GPT-4.
+* Uses tiktoken (cl100k_base encoding), the encoding GPT-4 reports. Claude's tokenizers spend more
+* tokens on the same text, so call `forModel(modelId)` before comparing a count against a model's
+* context window (see tokenEstimateMultiplier in @bike4mind/common).
 */
 var TokenCounter = class {
 	constructor() {
@@ -17,6 +32,16 @@ var TokenCounter = class {
 		return this.encoder;
 	}
 	/**
+	* A view of this counter whose counts are scaled to `modelId`'s own tokenizer, or `this` when the
+	* model needs no scaling (non-Claude, or a Claude version tokenEstimateMultiplier leaves at 1). Use
+	* it wherever a count is compared against a model's context window, so a Claude session compacts
+	* and reports against real token usage rather than a cl100k_base undercount.
+	*/
+	forModel(modelId) {
+		const multiplier = tokenEstimateMultiplier(modelId);
+		return multiplier === 1 ? this : new CalibratedTokenCounter(this, multiplier);
+	}
+	/**
 	* Count tokens in a text string
 	*/
 	countTokens(text) {
@@ -80,6 +105,24 @@ var TokenCounter = class {
 		}
 	}
 };
+/**
+* A calibrated view over a raw `TokenCounter`. `countTokens` is the one primitive every other count
+* routes through, so overriding it calibrates message, session and tool-schema counts at once. The
+* flat image estimate stays unscaled because it is not a tiktoken count. The view holds no encoder of
+* its own - it reads through `raw` - so `dispose` is a no-op and disposing the view never frees the
+* shared encoder.
+*/
+var CalibratedTokenCounter = class extends TokenCounter {
+	constructor(raw, multiplier) {
+		super();
+		this.raw = raw;
+		this.multiplier = multiplier;
+	}
+	countTokens(text) {
+		return scaleTokenEstimate(this.raw.countTokens(text), this.multiplier);
+	}
+	dispose() {}
+};
 let tokenCounter = null;
 /**
 * Get the singleton TokenCounter instance
@@ -151,7 +194,8 @@ var ConversationContext = class ConversationContext {
 	* rendering each turn's bounded tool trace - plus the system prompt, and
 	* compares against `thresholdRatio` of the context window. Rich-content aware:
 	* replaces the old string-only `content` sum so a session whose weight lives
-	* in tool traces still triggers compaction.
+	* in tool traces still triggers compaction. Counts are calibrated to
+	* `opts.model`, so `systemPromptTokens` must be too (the caller owns it).
 	*/
 	needsCompaction(systemPromptTokens, opts, thresholdRatio = .8) {
 		return this.estimateSessionTokens(systemPromptTokens, opts) >= opts.contextWindow * thresholdRatio;
@@ -162,7 +206,7 @@ var ConversationContext = class ConversationContext {
 	* system prompt. Used by `needsCompaction`.
 	*/
 	estimateSessionTokens(systemPromptTokens, opts) {
-		return systemPromptTokens + this.messages.filter((m) => m.role === "user" || m.role === "assistant").reduce((sum, m) => sum + this.estimateTokens(this.renderHistoryMessage(m, opts)), 0);
+		return systemPromptTokens + this.messages.filter((m) => m.role === "user" || m.role === "assistant").reduce((sum, m) => sum + this.estimateTokens(this.renderHistoryMessage(m, opts), opts), 0);
 	}
 	/** Serialize back to a Session for on-disk persistence (rich content preserved). */
 	toSession() {
@@ -181,12 +225,12 @@ var ConversationContext = class ConversationContext {
 	*/
 	windowedHistory(newInput, opts) {
 		const reserved = opts.reservedTokens ?? 8e3;
-		const currentTokens = this.estimateTokens(this.inputToIMessage(newInput));
+		const currentTokens = this.estimateTokens(this.inputToIMessage(newInput), opts);
 		const history = this.messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => this.renderHistoryMessage(m, opts));
 		let remaining = opts.contextWindow - reserved - currentTokens;
 		const kept = [];
 		for (let i = history.length - 1; i >= 0; i--) {
-			const cost = this.estimateTokens(history[i]);
+			const cost = this.estimateTokens(history[i], opts);
 			if (cost > remaining) break;
 			remaining -= cost;
 			kept.unshift(history[i]);
@@ -250,7 +294,7 @@ var ConversationContext = class ConversationContext {
 			if (b.type !== "tool_use") continue;
 			const resultText = b.id && results.get(b.id) || "";
 			const line = `[tool ${b.name}] ${this.brief(JSON.stringify(b.input ?? {}))} -> ${this.brief(resultText)}`;
-			const cost = this.counter.countTokens(line);
+			const cost = this.counter.forModel(opts.model).countTokens(line);
 			if (used + cost > budget) {
 				omitted++;
 				continue;
@@ -272,8 +316,8 @@ var ConversationContext = class ConversationContext {
 			content: input
 		};
 	}
-	estimateTokens(message) {
-		return this.counter.countMessageContent(message.content);
+	estimateTokens(message, opts) {
+		return this.counter.forModel(opts.model).countMessageContent(message.content);
 	}
 };
 /**

package/dist/{buildAgent-C-C-VGff.mjs → buildAgent-B7cMwRAy.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { I as generateCliTools, J as setWebSocketToolExecutor, L as wrapTools, N as ReActAgent, X as buildSystemPrompt, Y as getPlanModeFilePath, a as loadProjectContext, c as createSseBackend, i as buildProjectAgentStore, it as Logger, l as ServerLlmBackend, n as BackgroundAgentManager, o as McpManager, r as SubagentOrchestrator, t as AgentHistoryStore } from "./AgentHistoryStore-B2NEOvSW.mjs";
-import { D as MODEL_INFO_FIELD_GROUP_OF, H as escapeThinkMarkers, P as PermissionDeniedError, S as CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS, V as createThinkMarkerEscaper, W as getQuestErrorCode, Y as isUserInitiatedAbort, k as ModelBackend, n as logger, w as ChatModels } from "./ConfigStore-qV7NrCgZ.mjs";
+import { I as generateCliTools, J as setWebSocketToolExecutor, L as wrapTools, N as ReActAgent, X as buildSystemPrompt, Y as getPlanModeFilePath, a as loadProjectContext, c as createSseBackend, i as buildProjectAgentStore, it as Logger, l as ServerLlmBackend, n as BackgroundAgentManager, o as McpManager, r as SubagentOrchestrator, t as AgentHistoryStore } from "./AgentHistoryStore-DdYKfx7C.mjs";
+import { $ as escapeThinkMarkers, A as ChatModels, C as ARTIFACT_REMOVED_PLACEHOLDER, L as MODEL_INFO_FIELD_GROUP_OF, O as CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS, Q as createThinkMarkerEscaper, S as ARTIFACT_DELIVERED_PLACEHOLDER, W as PermissionDeniedError, _t as stripDeliveredArtifactBlocks, at as hasDeliverablePinnedArtifact, et as filterToolArtifactMarkup, lt as isUserInitiatedAbort, n as logger, rt as getQuestErrorCode, vt as stripToolArtifactMarkup, z as ModelBackend } from "./ConfigStore-BygzEI6H.mjs";
 import "crypto";
 import { v4 } from "uuid";
 import { z as z$1 } from "zod";
@@ -24,6 +24,23 @@ import WebSocket from "ws";
 function isTerminalToolError(error) {
 	return error instanceof PermissionDeniedError || getQuestErrorCode(error) !== void 0;
 }
+/** Whether the named tool is flagged `endsTurnAfterText` in the offered tool list. */
+function isTurnEndingTool(name, tools) {
+	return tools?.find((tool) => tool.toolSchema.name === name)?.endsTurnAfterText === true;
+}
+/**
+* Whether the tool loop should end the turn after this round's tool batch instead of making
+* the follow-up model call. True only when the round already streamed non-empty answer text
+* AND every tool it called is flagged `endsTurnAfterText`: the follow-up round would only
+* repeat the answer. A tool-only round still recurses so the model gets to answer.
+*
+* The single decision point for every adapter's tool loop - keep them from drifting.
+*/
+function shouldEndTurnAfterTools(calledToolNames, tools, roundText) {
+	const names = calledToolNames.filter((name) => Boolean(name));
+	if (names.length === 0 || !roundText?.trim()) return false;
+	return names.every((name) => isTurnEndingTool(name, tools));
+}
 /**
 * Execute an array of async tasks either in parallel (with concurrency limiting)
 * or sequentially, returning outcomes in the original order.
@@ -135,6 +152,96 @@ function attachFullToolResult(entry, observation) {
 		writable: true
 	});
 }
+/** The `artifactType` the named tool declared at registration, for the helpers below. */
+function declaredArtifactType(tools, toolName) {
+	return tools?.find((t) => t.toolSchema.name === toolName)?.artifactType;
+}
+/**
+* Helper function to handle tool result streaming for artifact-generating tools
+* This ensures tools like recharts that generate artifacts are streamed immediately
+* rather than waiting for recursive completion calls.
+*
+* Only the emitters in TOOL_ARTIFACT_EMITTERS (or a tool that declared `artifactType`, see
+* declaredArtifactType) stream, and only their pinned artifact type: streamed text is parsed
+* into reply artifacts, so any other tool's markup would render.
+*
+* What does stream is still a raw tool artifact rather than reply prose, so `streamCallback`
+* receives the channel tag and a public surface drops the text on that tag alone.
+*/
+async function handleToolResultStreaming(toolName, toolResult, streamCallback, artifactType) {
+	const filtered = filterToolArtifactMarkup(toolName, String(toolResult), artifactType);
+	if (filtered !== null) await streamCallback([filtered], { channel: "tool-artifact" });
+}
+/**
+* Strips artifact markup from a tool result before it re-enters history, so the model cannot echo
+* it into a second card. Live-emitting backends pass `delivered` = whether their tool-artifact
+* emit fired. The `hasDeliverablePinnedArtifact` fallback is for the OpenAI Responses path, whose
+* artifact reaches the client through sharedToolBuilder extraction instead.
+*
+* The delivered/removed choice is made once per result and stamped on every block it contains.
+* That holds because each emitter emits one pinned block; a result mixing a foreign-type block
+* with a pinned one would label both DELIVERED.
+*/
+function stripUnstreamedToolResult(toolName, result, delivered) {
+	return stripToolArtifactMarkup(result, delivered ?? hasDeliverablePinnedArtifact(toolName, result) ? ARTIFACT_DELIVERED_PLACEHOLDER : ARTIFACT_REMOVED_PLACEHOLDER);
+}
+/**
+* Buffers a recursive completion's text instead of streaming it live, so an <artifact> tag the
+* model echoes back (after seeing its own tool result, even sanitized) can be stripped before the
+* client ever renders a second, empty card for it. Only removes blocks whose `identifier` matches
+* one already delivered this turn (stripDeliveredArtifactBlocks) - a stray "<artifact" the model's
+* prose merely mentions, or a genuinely NEW artifact the model composes with a different
+* identifier, must not cost the rest of a legitimate reply, unlike the tool-output-facing
+* stripToolArtifactMarkup.
+*
+* One instance is created lazily by whichever level first streams an artifact in a recursive
+* chain, and reused UNCHANGED by every deeper level (never recreated per level) - see each
+* backend's `_internal.artifactGuard`. A chained tool call's artifact goes through `emitArtifact`
+* on this same shared instance, which flushes any text already buffered ahead of it before
+* sending the artifact through - so ordering survives even when the chained call happens several
+* recursion levels below where the guard was created.
+*/
+function createRecursiveArtifactGuard(cb) {
+	let buffer = "";
+	let deliveredMarkup = "";
+	let meta = {};
+	const callback = (async (text, info) => {
+		for (const chunk of text) if (chunk != null) buffer += chunk;
+		if (info?.inputTokens || info?.outputTokens) meta = { ...info };
+	});
+	const emitArtifact = async (results, info) => {
+		if (buffer) {
+			const pending = buffer;
+			buffer = "";
+			const stripped = stripDeliveredArtifactBlocks(pending, deliveredMarkup);
+			if (stripped.trim()) await cb([stripped], {});
+		}
+		deliveredMarkup += results.join("");
+		await cb(results, info);
+	};
+	const markDelivered = (markup) => {
+		deliveredMarkup += markup;
+	};
+	let flushPromise = null;
+	const flush = () => {
+		if (flushPromise) return flushPromise;
+		const cleaned = stripDeliveredArtifactBlocks(buffer, deliveredMarkup).trim();
+		let resolve;
+		let reject;
+		flushPromise = new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		(async () => cb(cleaned ? [cleaned] : [], meta))().then(() => resolve(), reject);
+		return flushPromise;
+	};
+	return {
+		callback,
+		emitArtifact,
+		markDelivered,
+		flush
+	};
+}
 /**
 * Drops the messages whose instructions assume a tool is attached (see `IMessage.requiresTool`).
 *
@@ -850,20 +957,32 @@ var OllamaBackend = class OllamaBackend {
 				parallel: options.parallelToolExecution !== false,
 				maxConcurrency: options.maxParallelTools
 			});
+			const inheritedArtifactGuard = options._internal?.artifactGuard;
+			let artifactGuard = inheritedArtifactGuard;
 			const observations = [];
-			outcomes.forEach((outcome, i) => {
+			for (let i = 0; i < outcomes.length; i++) {
+				const outcome = outcomes[i];
 				const { tc } = resolved[i];
 				const params = tc.arguments || "{}";
 				if (outcome.ok) {
-					observations[i] = outcome.result;
+					let emitted = false;
+					await handleToolResultStreaming(tc.name, outcome.result, async (results, artifactInfo) => {
+						emitted = true;
+						if (!artifactGuard) artifactGuard = createRecursiveArtifactGuard(callback);
+						await artifactGuard.emitArtifact(results, {
+							toolsUsed,
+							...artifactInfo
+						});
+					}, declaredArtifactType(options.tools, tc.name));
+					observations[i] = stripUnstreamedToolResult(tc.name, outcome.result, emitted);
 					this.pushToolMessages(messages, {
 						id: tc.id,
 						name: tc.name,
 						parameters: params
-					}, outcome.result);
+					}, observations[i]);
 				} else {
 					if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
-					const errorMsg = `Error running ${tc.name}: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`;
+					const errorMsg = stripToolArtifactMarkup(`Error running ${tc.name}: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`, ARTIFACT_REMOVED_PLACEHOLDER);
 					observations[i] = errorMsg;
 					this.pushToolMessages(messages, {
 						id: tc.id,
@@ -871,7 +990,7 @@ var OllamaBackend = class OllamaBackend {
 						parameters: params
 					}, errorMsg);
 				}
-			});
+			}
 			const executedToolsUsed = [...priorToolsUsed, ...resolved.map(({ tc }, i) => {
 				const entry = {
 					name: tc.name,
@@ -884,11 +1003,26 @@ var OllamaBackend = class OllamaBackend {
 				return entry;
 			})];
 			if (options.abortSignal?.aborted) {
-				await callback([""], {
+				await (artifactGuard?.callback ?? callback)([""], {
 					inputTokens,
 					outputTokens,
 					toolsUsed: executedToolsUsed
 				});
+				if (!inheritedArtifactGuard && artifactGuard) await artifactGuard.flush();
+				return;
+			}
+			if (round.toolCalls.length > 0 && shouldEndTurnAfterTools(toolCalls.map((tc) => tc.name), options.tools, round.content)) {
+				this._logger.info("[Tool Execution] Ending turn: answer already produced, only end-of-turn tools ran", {
+					model,
+					toolsExecuted: toolCalls.map((tc) => tc.name)
+				});
+				await (artifactGuard?.callback ?? callback)([round.content], {
+					inputTokens,
+					outputTokens,
+					toolsUsed: executedToolsUsed,
+					stopReason: "tool_use"
+				});
+				if (!inheritedArtifactGuard && artifactGuard) await artifactGuard.flush();
 				return;
 			}
 			await this.complete(model, messages, {
@@ -898,9 +1032,11 @@ var OllamaBackend = class OllamaBackend {
 					toolCallCount: toolCallCount + 1,
 					accumToolsUsed: executedToolsUsed,
 					accumInputTokens: inputTokens,
-					accumOutputTokens: outputTokens
+					accumOutputTokens: outputTokens,
+					artifactGuard
 				}
-			}, callback);
+			}, artifactGuard?.callback ?? callback);
+			if (!inheritedArtifactGuard && artifactGuard) await artifactGuard.flush();
 		} catch (error) {
 			if (error instanceof Error && isUserInitiatedAbort(error, options.abortSignal)) this._logger.debug("[OllamaBackend] Ollama request cancelled by the caller");
 			else this._logger.error("[OllamaBackend] Error during Ollama API call:", error);

package/dist/commands/acpCommand.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { $ as CustomCommandStore, A as createAgentDelegateTool, C as createTodoStore, D as createCoordinateTaskTool, F as PermissionManager, J as setWebSocketToolExecutor, L as wrapTools, O as createResumeAgentTool, Q as RemoteSkillSource, S as createFindDefinitionTool, T as createSkillTool, b as createGetFileStructureTool, et as CheckpointStore, j as FallbackLlmBackend, k as createBackgroundAgentTools, s as buildSandbox, tt as SessionStore, w as createWriteTodosTool } from "../AgentHistoryStore-B2NEOvSW.mjs";
-import { h as requireApiUrl, n as logger, s as isReadOnlyTool, t as ConfigStore } from "../ConfigStore-qV7NrCgZ.mjs";
-import { a as deferredToolRegistry, i as createToolSearchTool, n as buildSupportingStores, o as NotifyingLlmBackend, r as buildLlmBackend, t as buildAgent } from "../buildAgent-C-C-VGff.mjs";
-import { t as ApiClient } from "../ApiClient-D0fQ2FT6.mjs";
+import { $ as CustomCommandStore, A as createAgentDelegateTool, C as createTodoStore, D as createCoordinateTaskTool, F as PermissionManager, J as setWebSocketToolExecutor, L as wrapTools, O as createResumeAgentTool, Q as RemoteSkillSource, S as createFindDefinitionTool, T as createSkillTool, b as createGetFileStructureTool, et as CheckpointStore, j as FallbackLlmBackend, k as createBackgroundAgentTools, s as buildSandbox, tt as SessionStore, w as createWriteTodosTool } from "../AgentHistoryStore-DdYKfx7C.mjs";
+import { _ as requireApiUrl, d as isReadOnlyTool, n as logger, t as ConfigStore } from "../ConfigStore-BygzEI6H.mjs";
+import { a as deferredToolRegistry, i as createToolSearchTool, n as buildSupportingStores, o as NotifyingLlmBackend, r as buildLlmBackend, t as buildAgent } from "../buildAgent-B7cMwRAy.mjs";
+import { t as ApiClient } from "../ApiClient-dIB3YQc2.mjs";
 import { randomUUID } from "crypto";
 import { existsSync, realpathSync, statSync } from "fs";
 import { isAbsolute } from "path";
@@ -575,6 +575,7 @@ var AcpServer = class {
 	}
 	async buildStack() {
 		const config = await this.configStore.load();
+		this.configStore.warnPendingMcpApprovals();
 		await this.loadCustomCommands();
 		const authTokens = await this.configStore.getAuthTokens();
 		if (!authTokens) throw RequestError.authRequired(void 0, "Not authenticated. Run `b4m /login` first.");

package/dist/commands/apiCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { g as resolveApiEndpoint, m as parseApiUrl, t as ConfigStore } from "../ConfigStore-qV7NrCgZ.mjs";
+import { g as parseApiUrl, t as ConfigStore, v as resolveApiEndpoint } from "../ConfigStore-BygzEI6H.mjs";
 //#region src/commands/apiCommand.ts
 /**
 * External API config command (--api-url / --reset-api)

package/dist/commands/doctorCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "../package-CGZIoxcs.mjs";
+import { t as version } from "../package-CRNnNXxq.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";

package/dist/commands/envCommand.mjs

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

package/dist/commands/headlessCommand.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { $ as CustomCommandStore, A as createAgentDelegateTool, C as createTodoStore, D as createCoordinateTaskTool, F as PermissionManager, G as classifyCommandRisk, I as generateCliTools, J as setWebSocketToolExecutor, L as wrapTools, N as ReActAgent, O as createResumeAgentTool, Q as RemoteSkillSource, S as createFindDefinitionTool, T as createSkillTool, X as buildSystemPrompt, a as loadProjectContext, b as createGetFileStructureTool, c as createSseBackend, et as CheckpointStore, i as buildProjectAgentStore, j as FallbackLlmBackend, k as createBackgroundAgentTools, n as BackgroundAgentManager, o as McpManager, r as SubagentOrchestrator, s as buildSandbox, t as AgentHistoryStore, tt as SessionStore, w as createWriteTodosTool, x as createWorkItemTools, z as SHELL_LIKE_TOOL_COMMAND_FIELDS } from "../AgentHistoryStore-B2NEOvSW.mjs";
-import { h as requireApiUrl, n as logger, s as isReadOnlyTool, t as ConfigStore } from "../ConfigStore-qV7NrCgZ.mjs";
-import { t as ApiClient } from "../ApiClient-D0fQ2FT6.mjs";
-import { r as reconstructTurnBlocks, t as WorkItemsClient } from "../WorkItemsClient-Cow6nXx7.mjs";
+import { $ as CustomCommandStore, A as createAgentDelegateTool, C as createTodoStore, D as createCoordinateTaskTool, F as PermissionManager, G as classifyCommandRisk, I as generateCliTools, J as setWebSocketToolExecutor, L as wrapTools, N as ReActAgent, O as createResumeAgentTool, Q as RemoteSkillSource, S as createFindDefinitionTool, T as createSkillTool, X as buildSystemPrompt, a as loadProjectContext, b as createGetFileStructureTool, c as createSseBackend, et as CheckpointStore, i as buildProjectAgentStore, j as FallbackLlmBackend, k as createBackgroundAgentTools, n as BackgroundAgentManager, o as McpManager, r as SubagentOrchestrator, s as buildSandbox, t as AgentHistoryStore, tt as SessionStore, w as createWriteTodosTool, x as createWorkItemTools, z as SHELL_LIKE_TOOL_COMMAND_FIELDS } from "../AgentHistoryStore-DdYKfx7C.mjs";
+import { _ as requireApiUrl, d as isReadOnlyTool, n as logger, t as ConfigStore } from "../ConfigStore-BygzEI6H.mjs";
+import { r as reconstructTurnBlocks, t as WorkItemsClient } from "../WorkItemsClient-ClBC49y0.mjs";
+import { t as ApiClient } from "../ApiClient-dIB3YQc2.mjs";
 import { randomBytes } from "crypto";
 import { v4 } from "uuid";
 import { readFile } from "fs/promises";
@@ -250,6 +250,7 @@ async function handleHeadlessCommand(options) {
 	const runId = v4();
 	try {
 		const config = await configStore.load();
+		configStore.warnPendingMcpApprovals();
 		const configDirs = await configStore.getAdditionalDirectories();
 		const flagDirs = process.env.B4M_ADDITIONAL_DIRS ? parseStringArray(process.env.B4M_ADDITIONAL_DIRS, "B4M_ADDITIONAL_DIRS") : [];
 		const additionalDirectories = [.../* @__PURE__ */ new Set([

package/dist/commands/mcpCommand.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { t as ConfigStore } from "../ConfigStore-qV7NrCgZ.mjs";
-import { t as version } from "../package-CGZIoxcs.mjs";
+import { t as ConfigStore } from "../ConfigStore-BygzEI6H.mjs";
+import { t as version } from "../package-CRNnNXxq.mjs";
 //#region src/commands/mcpCommand.ts
 /**
 * External MCP commands (b4m mcp list, b4m mcp add, etc.)
@@ -70,7 +70,7 @@ async function handleMcpCommand(subcommand, argv) {
 			await handleDisable(config, argv.name, configStore);
 			break;
 		case "serve": {
-			const { handleMcpServeCommand } = await import("../serve-CPXqcEZr.mjs");
+			const { handleMcpServeCommand } = await import("../serve-DM7ld3-o.mjs");
 			await handleMcpServeCommand({
 				http: Boolean(argv.http),
 				port: typeof argv.port === "number" ? argv.port : void 0,

package/dist/commands/pluginCommand.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { n as getDefaultPluginsDir, r as isFeatureEnabled, t as PluginStore } from "../PluginStore-DwvOJ-G3.mjs";
-import { t as ConfigStore } from "../ConfigStore-qV7NrCgZ.mjs";
+import { t as ConfigStore } from "../ConfigStore-BygzEI6H.mjs";
 import { execFileSync } from "child_process";
 import { promises } from "fs";
 import path from "path";

package/dist/commands/updateCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "../package-CGZIoxcs.mjs";
+import { t as version } from "../package-CRNnNXxq.mjs";
 import { c as isNpmPrefixWritable, l as setAutoUpdatePreference, n as REEXEC_GUARD_ENV, o as forceCheckForUpdate, r as checkForUpdate, s as getAutoUpdatePreference, t as INSTALL_CMD, u as shouldAttemptAutoUpdate } from "../updateChecker-CQW8bxo6.mjs";
 import { t as checkRipgrep } from "../ripgrepCheck-BmkyTK2i.mjs";
 import { execSync, spawnSync } from "child_process";