@bike4mind/cli 0.4.0 → 0.5.0

package/dist/commands/doctorCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as version, n as fetchLatestVersion, r as forceCheckForUpdate } from "../updateChecker-DcJC1C8S.mjs";
+import { i as version, n as fetchLatestVersion, r as forceCheckForUpdate } from "../updateChecker-Boy2GLk4.mjs";
 import { execSync } from "child_process";
 import { constants, existsSync, promises } from "fs";
 import { homedir } from "os";

package/dist/commands/headlessCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { B as ReActAgent, C as loadContextFiles, D as generateCliTools, E as PermissionManager, F as setWebSocketToolExecutor, H as CheckpointStore, L as buildCoreSystemPrompt, V as CustomCommandStore, W as SessionStore, _ as WebSocketLlmBackend, a as createCoordinateTaskTool, c as createAgentDelegateTool, d as createSkillTool, g as FallbackLlmBackend, h as WebSocketConnectionManager, i as createWriteTodosTool, l as AgentStore, m as WebSocketToolExecutor, n as createFindDefinitionTool, o as createBackgroundAgentTools, p as ApiClient, r as createTodoStore, s as BackgroundAgentManager, t as createGetFileStructureTool, u as SubagentOrchestrator, v as ServerLlmBackend, w as getApiUrl, y as McpManager, z as isReadOnlyTool } from "../tools-DiSJh1Dv.mjs";
+import { A as getApiUrl, C as WebSocketLlmBackend, G as isReadOnlyTool, J as CheckpointStore, K as ReActAgent, M as PermissionManager, N as generateCliTools, S as FallbackLlmBackend, T as McpManager, U as buildCoreSystemPrompt, V as setWebSocketToolExecutor, X as SessionStore, _ as createSkillTool, b as WebSocketToolExecutor, c as createFindDefinitionTool, d as createCoordinateTaskTool, f as createBackgroundAgentTools, g as SubagentOrchestrator, h as AgentStore, k as loadContextFiles, l as createTodoStore, m as createAgentDelegateTool, p as BackgroundAgentManager, q as CustomCommandStore, s as createGetFileStructureTool, u as createWriteTodosTool, w as ServerLlmBackend, x as WebSocketConnectionManager, y as ApiClient } from "../tools-V5FJ83BJ.mjs";
 import { n as logger, t as ConfigStore } from "../ConfigStore-DBUmvCfe.mjs";
 import { t as DEFAULT_SANDBOX_CONFIG } from "../types-DBEjF9YS.mjs";
 import { t as createSandboxRuntime } from "../SandboxRuntimeAdapter-C1B4t20N.mjs";

package/dist/commands/updateCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as version, r as forceCheckForUpdate } from "../updateChecker-DcJC1C8S.mjs";
+import { i as version, r as forceCheckForUpdate } from "../updateChecker-Boy2GLk4.mjs";
 import { execSync } from "child_process";
 //#region src/commands/updateCommand.ts
 /**

package/dist/index.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { n as useCliStore, t as selectActiveBackgroundAgents } from "./store-B7-LLvvx.mjs";
-import { A as DEFAULT_MAX_ITERATIONS, B as ReActAgent, C as loadContextFiles, D as generateCliTools, E as PermissionManager, F as setWebSocketToolExecutor, G as OAuthClient, H as CheckpointStore, I as OllamaBackend, J as searchCommands, K as hasFileReferences, L as buildCoreSystemPrompt, M as DEFAULT_THOROUGHNESS, N as clearFeatureModuleTools, O as ALWAYS_DENIED_FOR_AGENTS, P as registerFeatureModuleTools, Q as warmFileCache, R as buildSkillsPromptSection, S as extractCompactInstructions, T as getEnvironmentName, U as CommandHistoryStore, V as CustomCommandStore, W as SessionStore, X as formatFileSize, Y as mergeCommands, Z as searchFiles, _ as WebSocketLlmBackend, a as createCoordinateTaskTool, b as substituteArguments, c as createAgentDelegateTool, d as createSkillTool, f as parseAgentConfig, g as FallbackLlmBackend, h as WebSocketConnectionManager, i as createWriteTodosTool, j as DEFAULT_RETRY_CONFIG, k as DEFAULT_AGENT_MODEL, l as AgentStore, m as WebSocketToolExecutor, n as createFindDefinitionTool, o as createBackgroundAgentTools, p as ApiClient, q as processFileReferences, r as createTodoStore, s as BackgroundAgentManager, t as createGetFileStructureTool, u as SubagentOrchestrator, v as ServerLlmBackend, w as getApiUrl, x as formatStep, y as McpManager, z as isReadOnlyTool } from "./tools-DiSJh1Dv.mjs";
+import { $ as processFileReferences, A as getApiUrl, B as registerFeatureModuleTools, C as WebSocketLlmBackend, D as formatStep, E as substituteArguments, F as DEFAULT_AGENT_MODEL, G as isReadOnlyTool, H as OllamaBackend, I as DEFAULT_MAX_ITERATIONS, J as CheckpointStore, K as ReActAgent, L as DEFAULT_RETRY_CONFIG, M as PermissionManager, N as generateCliTools, O as extractCompactInstructions, P as ALWAYS_DENIED_FOR_AGENTS, Q as hasFileReferences, R as DEFAULT_THOROUGHNESS, S as FallbackLlmBackend, T as McpManager, U as buildCoreSystemPrompt, V as setWebSocketToolExecutor, W as buildSkillsPromptSection, X as SessionStore, Y as CommandHistoryStore, Z as OAuthClient, _ as createSkillTool, a as createDecisionStore, b as WebSocketToolExecutor, c as createFindDefinitionTool, d as createCoordinateTaskTool, et as searchCommands, f as createBackgroundAgentTools, g as SubagentOrchestrator, h as AgentStore, i as createDecisionLogTool, it as warmFileCache, j as getEnvironmentName, k as loadContextFiles, l as createTodoStore, m as createAgentDelegateTool, n as createBlockerTools, nt as formatFileSize, o as formatDecisionsOutput, p as BackgroundAgentManager, q as CustomCommandStore, r as formatBlockersOutput, rt as searchFiles, s as createGetFileStructureTool, t as createBlockerStore, tt as mergeCommands, u as createWriteTodosTool, v as parseAgentConfig, w as ServerLlmBackend, x as WebSocketConnectionManager, y as ApiClient, z as clearFeatureModuleTools } from "./tools-V5FJ83BJ.mjs";
 import { Mt as validateNotebookPath$1, g as ChatModels, jt as validateJupyterKernelName, m as CREDIT_DEDUCT_TRANSACTION_TYPES, n as logger, t as ConfigStore } from "./ConfigStore-DBUmvCfe.mjs";
-import { i as version, t as checkForUpdate } from "./updateChecker-DcJC1C8S.mjs";
+import { i as version, t as checkForUpdate } from "./updateChecker-Boy2GLk4.mjs";
 import React, { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
 import { Box, Static, Text, render, useApp, useInput } from "ink";
 import { execSync } from "child_process";
@@ -5036,6 +5036,8 @@ function CliApp() {
 	const [initError, setInitError] = useState(null);
 	const [commandHistory, setCommandHistory] = useState([]);
 	const imageStoreInitPromise = useRef(null);
+	const decisionStoreRef = useRef(createDecisionStore());
+	const blockerStoreRef = useRef(createBlockerStore());
 	const setStoreSession = useCliStore((state) => state.setSession);
 	const enqueuePermissionPrompt = useCliStore((state) => state.enqueuePermissionPrompt);
 	const enqueueUserQuestionPrompt = useCliStore((state) => state.enqueueUserQuestionPrompt);
@@ -5478,6 +5480,15 @@ function CliApp() {
 				logger.warn(`⚠️  Model "${fromModel}" failed (${error.message}) — falling back to "${toModel}"`);
 			}) : llm, backgroundManager);
 			const writeTodosTool = createWriteTodosTool(createTodoStore());
+			const decisionLogTool = createDecisionLogTool(decisionStoreRef.current);
+			const blockerTools = createBlockerTools(blockerStoreRef.current);
+			if (newSession.metadata.workflow) {
+				decisionStoreRef.current.decisions = [...newSession.metadata.workflow.decisions];
+				blockerStoreRef.current.blockers = [...newSession.metadata.workflow.blockers];
+			} else {
+				decisionStoreRef.current.decisions = [];
+				blockerStoreRef.current.blockers = [];
+			}
 			const enableSkillTool = config.preferences.enableSkillTool !== false;
 			const skillTool = enableSkillTool ? createSkillTool({
 				customCommandStore: state.customCommandStore,
@@ -5495,6 +5506,8 @@ function CliApp() {
 				agentDelegateTool,
 				...backgroundTools,
 				writeTodosTool,
+				decisionLogTool,
+				...blockerTools,
 				findDefinitionTool,
 				getFileStructureTool
 			];
@@ -5924,7 +5937,13 @@ function CliApp() {
 					...currentSession.metadata,
 					totalTokens: currentSession.metadata.totalTokens + result.completionInfo.totalTokens,
 					totalCredits: (currentSession.metadata.totalCredits || 0) + (result.completionInfo.totalCredits || 0),
-					toolCallCount: currentSession.metadata.toolCallCount + successfulToolCalls
+					toolCallCount: currentSession.metadata.toolCallCount + successfulToolCalls,
+					workflow: decisionStoreRef.current.decisions.length > 0 || blockerStoreRef.current.blockers.length > 0 ? {
+						decisions: decisionStoreRef.current.decisions,
+						blockers: blockerStoreRef.current.blockers,
+						handoff: currentSession.metadata.workflow?.handoff,
+						reviewGates: currentSession.metadata.workflow?.reviewGates
+					} : currentSession.metadata.workflow
 				}
 			};
 			setState((prev) => ({
@@ -6540,6 +6559,12 @@ Multi-line Input:
 				}
 				const sessionName = args.join(" ") || state.session.name;
 				state.session.name = sessionName;
+				if (decisionStoreRef.current.decisions.length > 0 || blockerStoreRef.current.blockers.length > 0) state.session.metadata.workflow = {
+					decisions: decisionStoreRef.current.decisions,
+					blockers: blockerStoreRef.current.blockers,
+					handoff: state.session.metadata.workflow?.handoff,
+					reviewGates: state.session.metadata.workflow?.reviewGates
+				};
 				await state.sessionStore.save(state.session);
 				console.log(`✅ Session saved as "${sessionName}"`);
 				break;
@@ -6800,6 +6825,8 @@ Multi-line Input:
 				};
 				await logger.initialize(newSession.id);
 				logger.debug("=== New Session Started via /clear ===");
+				decisionStoreRef.current.decisions = [];
+				blockerStoreRef.current.blockers = [];
 				if (state.checkpointStore) state.checkpointStore.setSessionId(newSession.id);
 				setState((prev) => ({
 					...prev,
@@ -7491,6 +7518,16 @@ Multi-line Input:
 				console.log(`✅ Removed directory: ${resolvedRemovePath}`);
 				break;
 			}
+			case "decisions":
+				console.log("\n📋 Decision Log\n");
+				console.log(formatDecisionsOutput(decisionStoreRef.current.decisions));
+				console.log("");
+				break;
+			case "blockers":
+				console.log("\n🚧 Blockers\n");
+				console.log(formatBlockersOutput(blockerStoreRef.current.blockers));
+				console.log("");
+				break;
 			case "dirs": {
 				const additionalDirs = await state.configStore.getAdditionalDirectories();
 				const cwd = process.cwd();

package/dist/{tools-DiSJh1Dv.mjs → tools-V5FJ83BJ.mjs}

@@ -522,6 +522,14 @@ const COMMANDS = [
 	{
 		name: "dirs",
 		description: "List all accessible directories"
+	},
+	{
+		name: "decisions",
+		description: "Show decision log for current session"
+	},
+	{
+		name: "blockers",
+		description: "Show tracked blockers for current session"
 	}
 ];
 /**
@@ -3015,7 +3023,18 @@ EXAMPLES:
 - "what packages installed?" → ${TOOL_GLOB_FILES} "**/package.json" → ${TOOL_FILE_READ}
 - "find all components using React hooks" → ${TOOL_SUBAGENT_DELEGATE}(task="find all components using React hooks", type="explore")
 
-Remember: Use context from previous messages to understand follow-up questions.${directoriesSection}${projectContextSection}${skillsSection}${featureModulesSection}`;
+Remember: Use context from previous messages to understand follow-up questions.
+
+DURABLE WORKFLOW TRACKING:
+You have tools for tracking decisions and blockers during your work. These create an audit trail that persists across sessions, enabling anyone to understand why things were done and what's still outstanding.
+
+- log_decision: When you make a significant decision (architecture choice, scope narrowing, interpretation of ambiguous requirements, trade-off between alternatives), log it with rationale. Do NOT log trivial decisions. Log decisions that would matter if someone needed to understand WHY you did something or if they needed to resume this work.
+
+- track_blocker: When you encounter something blocking progress (missing information, unclear requirements, external dependencies, ambiguous specs that need human clarification), track it. This makes blockers visible so they can be addressed.
+
+- resolve_blocker: When a blocker is cleared, record how it was resolved. Use the blocker ID from the track_blocker output.
+
+These tools are lightweight — use them naturally as part of your work, not as a ceremony.${directoriesSection}${projectContextSection}${skillsSection}${featureModulesSection}`;
 }
 /**
 * Build the dynamic agent creation prompt section
@@ -6675,15 +6694,26 @@ const webSearchTool = {
 };
 //#endregion
 //#region ../../b4m-core/services/dist/llm/tools/implementation/webfetch/index.mjs
+const DEFAULT_TIMEOUT_MS = 6e4;
+const PDF_TIMEOUT_MS = 9e4;
+function isPdfUrl(url) {
+	try {
+		const { pathname } = new URL(url);
+		return pathname.toLowerCase().endsWith(".pdf");
+	} catch {
+		return false;
+	}
+}
 /**
 * Fetch URL content using Firecrawl (shared function, no ToolContext)
 * Pattern follows serpApiSearch from websearch tool
 *
 * @param adapters - Database adapters for fetching Firecrawl API key
 * @param url - URL to fetch
+* @param options - Optional configuration (e.g. maxTimeoutMs for Lambda-constrained callers)
 * @returns Markdown content and title
 */
-async function firecrawlFetch(adapters, url) {
+async function firecrawlFetch(adapters, url, options) {
 	if (!/^https?:\/\/.+/i.test(url)) throw new Error(`Invalid URL format: ${url}. URL must start with http:// or https://`);
 	const apiKeySetting = await adapters.db.adminSettings.findBySettingName("FirecrawlApiKey");
 	if (!apiKeySetting?.settingValue) {
@@ -6691,45 +6721,45 @@ async function firecrawlFetch(adapters, url) {
 		throw new Error("Firecrawl API key not configured");
 	}
 	const app = new FirecrawlApp({ apiKey: apiKeySetting.settingValue });
-	const controller = new AbortController();
-	const timeoutId = setTimeout(() => controller.abort(), 6e4);
-	try {
-		console.log("📥 WebFetch Tool: Scraping URL with Firecrawl...");
-		let result;
-		try {
-			result = await app.scrapeUrl(url, {
-				formats: ["markdown"],
-				actions: [{
-					type: "wait",
-					milliseconds: 1e3
-				}]
-			});
-		} catch (scrapeError) {
-			if ((scrapeError instanceof Error ? scrapeError.message : "").includes("Actions are not supported")) {
-				console.log("📥 WebFetch Tool: Actions not supported, retrying without actions...");
-				result = await app.scrapeUrl(url, { formats: ["markdown"] });
-			} else throw scrapeError;
-		}
-		clearTimeout(timeoutId);
-		if (!result || result.error) {
-			const errorMessage = result?.error || "Unknown error";
-			console.error("❌ WebFetch Tool: Firecrawl error:", errorMessage);
-			throw new Error(`Failed to fetch content from URL: ${errorMessage}`);
-		}
-		if (!("markdown" in result) || !result.markdown) {
-			console.error("❌ WebFetch Tool: No markdown content returned");
-			throw new Error("No content could be extracted from the URL");
-		}
-		const markdown = result.markdown.slice(0, 5e4);
-		console.log(`📄 WebFetch Tool: Extracted ${markdown.length} characters of content`);
-		return {
-			markdown,
-			title: result.metadata?.title
-		};
-	} catch (error) {
-		clearTimeout(timeoutId);
-		throw error;
-	}
+	const isPdf = isPdfUrl(url);
+	const desiredTimeout = isPdf ? PDF_TIMEOUT_MS : DEFAULT_TIMEOUT_MS;
+	const timeoutMs = options?.maxTimeoutMs ? Math.min(desiredTimeout, options.maxTimeoutMs) : desiredTimeout;
+	console.log(`📥 WebFetch Tool: Scraping URL with Firecrawl${isPdf ? " (PDF mode, extended timeout)" : ""}...`);
+	const baseParams = {
+		formats: ["markdown"],
+		timeout: timeoutMs
+	};
+	let result;
+	if (isPdf) result = await app.scrapeUrl(url, baseParams);
+	else try {
+		result = await app.scrapeUrl(url, {
+			...baseParams,
+			actions: [{
+				type: "wait",
+				milliseconds: 1e3
+			}]
+		});
+	} catch (scrapeError) {
+		if ((scrapeError instanceof Error ? scrapeError.message : "").includes("Actions are not supported")) {
+			console.log("📥 WebFetch Tool: Actions not supported, retrying without actions...");
+			result = await app.scrapeUrl(url, baseParams);
+		} else throw scrapeError;
+	}
+	if (!result || result.error) {
+		const errorMessage = result?.error || "Unknown error";
+		console.error("❌ WebFetch Tool: Firecrawl error:", errorMessage);
+		throw new Error(`Failed to fetch content from URL: ${errorMessage}`);
+	}
+	if (!("markdown" in result) || !result.markdown) {
+		console.error("❌ WebFetch Tool: No markdown content returned");
+		throw new Error("No content could be extracted from the URL");
+	}
+	const markdown = result.markdown.slice(0, 5e4);
+	console.log(`📄 WebFetch Tool: Extracted ${markdown.length} characters of content`);
+	return {
+		markdown,
+		title: result.metadata?.title
+	};
 }
 const webFetchTool = {
 	name: "web_fetch",
@@ -6785,6 +6815,14 @@ const webFetchTool = {
 					await context.statusUpdate({}, `WebFetch: ${statusLabel}`);
 					return userMessage;
 				}
+				if (error instanceof FirecrawlError && error.statusCode === 500 && errorMessage.includes("PDF")) {
+					context.logger.warn("WebFetch PDF too large for Firecrawl", {
+						url: params.url,
+						error: errorMessage
+					});
+					await context.statusUpdate({}, "WebFetch: PDF too large");
+					return `This PDF is too large to process via URL. Please download the file and upload it directly instead.`;
+				}
 				if ([
 					"no response received",
 					"econnrefused",
@@ -23479,4 +23517,234 @@ function createGetFileStructureTool() {
 	};
 }
 //#endregion
-export { DEFAULT_MAX_ITERATIONS as A, ReActAgent as B, loadContextFiles as C, generateCliTools as D, PermissionManager as E, setWebSocketToolExecutor as F, OAuthClient as G, CheckpointStore as H, OllamaBackend as I, searchCommands as J, hasFileReferences as K, buildCoreSystemPrompt as L, DEFAULT_THOROUGHNESS as M, clearFeatureModuleTools as N, ALWAYS_DENIED_FOR_AGENTS as O, registerFeatureModuleTools as P, warmFileCache as Q, buildSkillsPromptSection as R, extractCompactInstructions as S, getEnvironmentName as T, CommandHistoryStore as U, CustomCommandStore as V, SessionStore as W, formatFileSize$1 as X, mergeCommands as Y, searchFiles as Z, WebSocketLlmBackend as _, createCoordinateTaskTool as a, substituteArguments as b, createAgentDelegateTool as c, createSkillTool as d, parseAgentConfig as f, FallbackLlmBackend as g, WebSocketConnectionManager as h, createWriteTodosTool as i, DEFAULT_RETRY_CONFIG as j, DEFAULT_AGENT_MODEL as k, AgentStore as l, WebSocketToolExecutor as m, createFindDefinitionTool as n, createBackgroundAgentTools as o, ApiClient as p, processFileReferences as q, createTodoStore as r, BackgroundAgentManager as s, createGetFileStructureTool as t, SubagentOrchestrator as u, ServerLlmBackend as v, getApiUrl as w, formatStep as x, McpManager as y, isReadOnlyTool as z };
+//#region src/tools/decisionLogTool.ts
+/**
+* Validate log_decision parameters
+* @throws Error if validation fails
+*/
+function validateParams(args) {
+	const params = args;
+	if (typeof params.summary !== "string" || params.summary.trim() === "") throw new Error("log_decision: summary must be a non-empty string");
+	if (typeof params.rationale !== "string" || params.rationale.trim() === "") throw new Error("log_decision: rationale must be a non-empty string");
+	if (params.alternatives !== void 0) {
+		if (!Array.isArray(params.alternatives)) throw new Error("log_decision: alternatives must be an array of strings");
+		for (const alt of params.alternatives) if (typeof alt !== "string") throw new Error("log_decision: each alternative must be a string");
+	}
+	if (params.context !== void 0 && typeof params.context !== "string") throw new Error("log_decision: context must be a string");
+	return {
+		summary: params.summary.trim(),
+		rationale: params.rationale.trim(),
+		alternatives: params.alternatives,
+		context: typeof params.context === "string" ? params.context.trim() : void 0
+	};
+}
+/**
+* Format decisions for display output
+*/
+function formatDecisionsOutput(decisions) {
+	if (decisions.length === 0) return "No decisions logged in this session.";
+	return decisions.map((decision, index) => {
+		const lines = [`${index + 1}. **${decision.summary}**`, `   Rationale: ${decision.rationale}`];
+		if (decision.alternatives && decision.alternatives.length > 0) lines.push(`   Alternatives considered: ${decision.alternatives.join(", ")}`);
+		if (decision.context) lines.push(`   Context: ${decision.context}`);
+		const timestamp = new Date(decision.timestamp).toLocaleTimeString();
+		lines.push(`   Logged at: ${timestamp}`);
+		return lines.join("\n");
+	}).join("\n\n");
+}
+/**
+* Create the log_decision tool.
+*
+* Allows the AI to record significant decisions with rationale during a session.
+* Decisions are persisted in the session's workflow state for audit trail
+* and cross-session continuity.
+*/
+function createDecisionLogTool(store) {
+	return {
+		toolFn: async (args) => {
+			const params = validateParams(args);
+			const decision = {
+				id: v4(),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				summary: params.summary,
+				rationale: params.rationale,
+				alternatives: params.alternatives,
+				context: params.context
+			};
+			store.decisions.push(decision);
+			if (store.onUpdate) store.onUpdate(store.decisions);
+			return `Decision logged (#${store.decisions.length}): ${decision.summary}`;
+		},
+		toolSchema: {
+			name: "log_decision",
+			description: `Record a significant decision with its rationale for audit trail and session continuity.
+
+**When to use:**
+- Architecture or design choices (e.g., "chose Zustand over Redux because...")
+- Scope narrowing or direction changes in research
+- Trade-off decisions between viable alternatives
+- Interpretation of ambiguous requirements
+
+**When NOT to use:**
+- Routine operations (reading files, running tests)
+- Trivial choices that wouldn't matter to someone resuming this work
+- Implementation details that are obvious from the code
+
+Log decisions that would matter if someone needed to understand WHY you did something.`,
+			parameters: {
+				type: "object",
+				properties: {
+					summary: {
+						type: "string",
+						description: "What was decided — a clear, concise statement"
+					},
+					rationale: {
+						type: "string",
+						description: "Why this decision was made — the reasoning behind it"
+					},
+					alternatives: {
+						type: "array",
+						items: { type: "string" },
+						description: "What alternatives were considered (optional)"
+					},
+					context: {
+						type: "string",
+						description: "What triggered this decision — the situation or constraint (optional)"
+					}
+				},
+				required: ["summary", "rationale"]
+			}
+		}
+	};
+}
+/**
+* Create a new empty DecisionStore
+*/
+function createDecisionStore(onUpdate) {
+	return {
+		decisions: [],
+		onUpdate
+	};
+}
+//#endregion
+//#region src/tools/blockerTool.ts
+/**
+* Format blockers for display output
+*/
+function formatBlockersOutput(blockers) {
+	if (blockers.length === 0) return "No blockers tracked in this session.";
+	const open = blockers.filter((b) => b.status === "open");
+	const resolved = blockers.filter((b) => b.status === "resolved");
+	const lines = [];
+	if (open.length > 0) {
+		lines.push(`**Open blockers (${open.length}):**`);
+		for (const blocker of open) lines.push(`  - [${blocker.id.slice(0, 8)}] ${blocker.description}`);
+	}
+	if (resolved.length > 0) {
+		if (open.length > 0) lines.push("");
+		lines.push(`**Resolved blockers (${resolved.length}):**`);
+		for (const blocker of resolved) {
+			lines.push(`  - [${blocker.id.slice(0, 8)}] ${blocker.description}`);
+			lines.push(`    Resolution: ${blocker.resolution ?? "(no resolution recorded)"}`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Create the track_blocker and resolve_blocker tools.
+*
+* Allows the AI to track what's blocking progress and record resolutions.
+* Blockers are persisted in the session's workflow state for audit trail
+* and cross-session continuity.
+*/
+function createBlockerTools(store) {
+	return [{
+		toolFn: async (args) => {
+			const params = args;
+			if (typeof params.description !== "string" || params.description.trim() === "") throw new Error("track_blocker: description must be a non-empty string");
+			const blocker = {
+				id: v4(),
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				description: params.description.trim(),
+				status: "open"
+			};
+			store.blockers.push(blocker);
+			if (store.onUpdate) store.onUpdate(store.blockers);
+			const openCount = store.blockers.filter((b) => b.status === "open").length;
+			return `Blocker tracked [${blocker.id.slice(0, 8)}]: ${blocker.description}\n(${openCount} open blocker${openCount === 1 ? "" : "s"})`;
+		},
+		toolSchema: {
+			name: "track_blocker",
+			description: `Track something that is blocking progress.
+
+**When to use:**
+- Missing information or unclear requirements
+- External dependencies (waiting on API access, credentials, data)
+- Technical constraints discovered during work
+- Ambiguous requirements that need human clarification
+
+**When NOT to use:**
+- Normal challenges that are part of the work
+- Things you can resolve immediately`,
+			parameters: {
+				type: "object",
+				properties: { description: {
+					type: "string",
+					description: "What is blocking progress — be specific about what is needed to unblock"
+				} },
+				required: ["description"]
+			}
+		}
+	}, {
+		toolFn: async (args) => {
+			const params = args;
+			if (typeof params.blocker_id !== "string" || params.blocker_id.trim() === "") throw new Error("resolve_blocker: blocker_id must be a non-empty string");
+			if (typeof params.resolution !== "string" || params.resolution.trim() === "") throw new Error("resolve_blocker: resolution must be a non-empty string");
+			const blockerId = params.blocker_id.trim();
+			const blocker = store.blockers.find((b) => b.id === blockerId || b.id.startsWith(blockerId));
+			if (!blocker) {
+				const openBlockers = store.blockers.filter((b) => b.status === "open");
+				if (openBlockers.length === 0) return "No open blockers to resolve.";
+				return `Blocker not found. Open blockers:\n${openBlockers.map((b) => `  [${b.id.slice(0, 8)}] ${b.description}`).join("\n")}`;
+			}
+			if (blocker.status === "resolved") return `Blocker [${blocker.id.slice(0, 8)}] is already resolved.`;
+			blocker.status = "resolved";
+			blocker.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+			blocker.resolution = params.resolution.trim();
+			if (store.onUpdate) store.onUpdate(store.blockers);
+			const openCount = store.blockers.filter((b) => b.status === "open").length;
+			return `Blocker resolved [${blocker.id.slice(0, 8)}]: ${blocker.resolution}\n(${openCount} open blocker${openCount === 1 ? "" : "s"} remaining)`;
+		},
+		toolSchema: {
+			name: "resolve_blocker",
+			description: `Mark a blocker as resolved with a description of how it was resolved.
+
+Use the blocker ID (or its first 8 characters) from the track_blocker output.`,
+			parameters: {
+				type: "object",
+				properties: {
+					blocker_id: {
+						type: "string",
+						description: "The ID of the blocker to resolve (full ID or first 8 characters)"
+					},
+					resolution: {
+						type: "string",
+						description: "How the blocker was resolved"
+					}
+				},
+				required: ["blocker_id", "resolution"]
+			}
+		}
+	}];
+}
+/**
+* Create a new empty BlockerStore
+*/
+function createBlockerStore(onUpdate) {
+	return {
+		blockers: [],
+		onUpdate
+	};
+}
+//#endregion
+export { processFileReferences as $, getApiUrl as A, registerFeatureModuleTools as B, WebSocketLlmBackend as C, formatStep as D, substituteArguments as E, DEFAULT_AGENT_MODEL as F, isReadOnlyTool as G, OllamaBackend as H, DEFAULT_MAX_ITERATIONS as I, CheckpointStore as J, ReActAgent as K, DEFAULT_RETRY_CONFIG as L, PermissionManager as M, generateCliTools as N, extractCompactInstructions as O, ALWAYS_DENIED_FOR_AGENTS as P, hasFileReferences as Q, DEFAULT_THOROUGHNESS as R, FallbackLlmBackend as S, McpManager as T, buildCoreSystemPrompt as U, setWebSocketToolExecutor as V, buildSkillsPromptSection as W, SessionStore as X, CommandHistoryStore as Y, OAuthClient as Z, createSkillTool as _, createDecisionStore as a, WebSocketToolExecutor as b, createFindDefinitionTool as c, createCoordinateTaskTool as d, searchCommands as et, createBackgroundAgentTools as f, SubagentOrchestrator as g, AgentStore as h, createDecisionLogTool as i, warmFileCache as it, getEnvironmentName as j, loadContextFiles as k, createTodoStore as l, createAgentDelegateTool as m, createBlockerTools as n, formatFileSize$1 as nt, formatDecisionsOutput as o, BackgroundAgentManager as p, CustomCommandStore as q, formatBlockersOutput as r, searchFiles as rt, createGetFileStructureTool as s, createBlockerStore as t, mergeCommands as tt, createWriteTodosTool as u, parseAgentConfig as v, ServerLlmBackend as w, WebSocketConnectionManager as x, ApiClient as y, clearFeatureModuleTools as z };

package/dist/{updateChecker-DcJC1C8S.mjs → updateChecker-Boy2GLk4.mjs}

@@ -4,7 +4,7 @@ import { homedir } from "os";
 import path from "path";
 import axios from "axios";
 //#region package.json
-var version = "0.4.0";
+var version = "0.5.0";
 //#endregion
 //#region src/utils/updateChecker.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bike4mind/cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "Interactive CLI tool for Bike4Mind with ReAct agents",
   "license": "UNLICENSED",
@@ -118,11 +118,11 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.1.2",
-    "@bike4mind/agents": "0.5.2",
-    "@bike4mind/common": "2.88.0",
-    "@bike4mind/mcp": "1.35.11",
-    "@bike4mind/services": "2.76.10",
-    "@bike4mind/utils": "2.18.9"
+    "@bike4mind/agents": "0.5.3",
+    "@bike4mind/common": "2.89.0",
+    "@bike4mind/mcp": "1.36.0",
+    "@bike4mind/services": "2.77.0",
+    "@bike4mind/utils": "2.18.10"
   },
   "optionalDependencies": {
     "@vscode/ripgrep": "^1.17.1"