@bike4mind/cli 0.3.0 → 0.5.0

package/dist/{ConfigStore-o5AblHqQ.mjs → ConfigStore-DBUmvCfe.mjs}

@@ -1930,7 +1930,14 @@ const SceneCommandSchema = z.discriminatedUnion("type", [
 			row: z.number(),
 			gid: z.number()
 		})),
-		worldVersion: z.number().optional()
+		worldVersion: z.number().optional(),
+		floorId: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("change_floor"),
+		id: z.string(),
+		floorId: z.string(),
+		position: TilePositionSchema
 	}),
 	z.object({
 		type: z.literal("update_metadata"),

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-CEeSpbaK.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,6 +1,6 @@
 #!/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-BImjpPlR.mjs";
-import { n as logger, t as ConfigStore } from "../ConfigStore-o5AblHqQ.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";
 import { t as SandboxOrchestrator } from "../SandboxOrchestrator-BEW3rqYi.mjs";

package/dist/commands/mcpCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as ConfigStore } from "../ConfigStore-o5AblHqQ.mjs";
+import { t as ConfigStore } from "../ConfigStore-DBUmvCfe.mjs";
 //#region src/commands/mcpCommand.ts
 /**
 * External MCP commands (b4m mcp list, b4m mcp add, etc.)

package/dist/commands/updateCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as version, r as forceCheckForUpdate } from "../updateChecker-CEeSpbaK.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-BImjpPlR.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-o5AblHqQ.mjs";
-import { i as version, t as checkForUpdate } from "./updateChecker-CEeSpbaK.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-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";
@@ -3439,6 +3439,27 @@ var TavernService = class {
 	async abortHeartbeats() {
 		await this.apiClient.post("/api/tavern/abort-heartbeats", { abort: true });
 	}
+	async getQuestPlan(planId) {
+		return this.apiClient.get(`/api/quest-master-plans/${encodeURIComponent(planId)}`);
+	}
+	async updateReviewGate(planId, questId, subQuestId, reviewStatus, reviewNote) {
+		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/review-gate`, {
+			questId,
+			subQuestId,
+			reviewStatus,
+			reviewNote
+		});
+	}
+	async updateSubQuestProgress(planId, questId, subQuestId, updates) {
+		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/subquest-progress`, {
+			questId,
+			subQuestId,
+			...updates
+		});
+	}
+	async updateHandoff(planId, handoff) {
+		return this.apiClient.post(`/api/quest-master-plans/${encodeURIComponent(planId)}/handoff`, handoff);
+	}
 };
 //#endregion
 //#region src/features/tavern/types.ts
@@ -3626,6 +3647,109 @@ z.object({
 		error: z.string().optional()
 	}))
 });
+/** Sub-quest within a quest */
+const SubQuestSchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	status: z.enum([
+		"not_started",
+		"in_progress",
+		"completed",
+		"skipped",
+		"deleted"
+	]),
+	questId: z.string().optional(),
+	startedAt: z.number().optional(),
+	evidence: z.string().optional(),
+	reviewGate: z.boolean().optional(),
+	reviewStatus: z.enum([
+		"pending",
+		"approved",
+		"rejected"
+	]).optional(),
+	reviewNote: z.string().optional()
+});
+/** Quest containing sub-quests */
+const QuestDataSchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	description: z.string(),
+	complexity: z.string(),
+	subQuests: z.array(SubQuestSchema)
+});
+/** Handoff state for session continuity */
+const HandoffSchema = z.object({
+	summary: z.string(),
+	nextSteps: z.array(z.string()),
+	pendingDecisions: z.array(z.string()),
+	blockers: z.array(z.string()),
+	lastUpdatedBy: z.string(),
+	updatedAt: z.string()
+});
+z.object({
+	_id: z.string(),
+	notebookId: z.string(),
+	goal: z.string(),
+	quests: z.array(QuestDataSchema),
+	state: z.enum([
+		"draft",
+		"active",
+		"paused",
+		"completed",
+		"archived"
+	]).optional(),
+	handoff: HandoffSchema.optional(),
+	metrics: z.object({
+		totalTimeSpent: z.number(),
+		completionRate: z.number(),
+		subQuestsCompleted: z.number(),
+		subQuestsTotal: z.number(),
+		lastProgress: z.string().optional()
+	}).optional()
+});
+z.object({
+	planId: z.string(),
+	questId: z.string(),
+	subQuestId: z.string(),
+	reviewStatus: z.enum([
+		"pending",
+		"approved",
+		"rejected"
+	]),
+	reviewNote: z.string().optional()
+});
+z.object({
+	planId: z.string(),
+	questId: z.string(),
+	subQuestId: z.string(),
+	status: z.enum([
+		"not_started",
+		"in_progress",
+		"completed",
+		"skipped",
+		"deleted"
+	]).optional(),
+	evidence: z.string().optional(),
+	timeSpent: z.number().optional()
+});
+z.object({
+	planId: z.string(),
+	summary: z.string(),
+	nextSteps: z.array(z.string()),
+	pendingDecisions: z.array(z.string()),
+	blockers: z.array(z.string())
+});
+z.object({
+	success: z.boolean(),
+	plan: z.unknown().optional(),
+	metrics: z.object({
+		totalTimeSpent: z.number(),
+		completionRate: z.number(),
+		subQuestsCompleted: z.number(),
+		subQuestsTotal: z.number(),
+		lastProgress: z.string().optional()
+	}).optional()
+});
 //#endregion
 //#region src/features/tavern/TavernActivityStream.ts
 /**
@@ -3660,6 +3784,39 @@ var TavernActivityStream = class {
 };
 //#endregion
 //#region src/features/tavern/tavernTools.ts
+const GetQuestPlanParamsSchema = z.object({ plan_id: z.string().min(1) });
+const UpdateReviewGateParamsSchema = z.object({
+	plan_id: z.string().min(1),
+	quest_id: z.string().min(1),
+	sub_quest_id: z.string().min(1),
+	review_status: z.enum([
+		"pending",
+		"approved",
+		"rejected"
+	]),
+	review_note: z.string().optional()
+});
+const UpdateQuestProgressParamsSchema = z.object({
+	plan_id: z.string().min(1),
+	quest_id: z.string().min(1),
+	sub_quest_id: z.string().min(1),
+	status: z.enum([
+		"not_started",
+		"in_progress",
+		"completed",
+		"skipped",
+		"deleted"
+	]).optional(),
+	evidence: z.string().optional(),
+	time_spent: z.number().min(0).optional()
+});
+const WriteHandoffParamsSchema = z.object({
+	plan_id: z.string().min(1),
+	summary: z.string().min(1),
+	next_steps: z.array(z.string()),
+	pending_decisions: z.array(z.string()),
+	blockers: z.array(z.string())
+});
 /**
 * Factory that creates ICompletionOptionTools[] for the Tavern feature.
 *
@@ -3682,7 +3839,11 @@ function createTavernTools(service) {
 		createToggleHeartbeatsTool(service),
 		createTriggerHeartbeatTool(service),
 		createAbortHeartbeatsTool(service),
-		createStatusTool(service)
+		createStatusTool(service),
+		createGetQuestPlanTool(service),
+		createUpdateReviewGateTool(service),
+		createUpdateQuestProgressTool(service),
+		createWriteHandoffTool(service)
 	];
 }
 function createListAgentsTool(service) {
@@ -4211,6 +4372,187 @@ function createStatusTool(service) {
 		}
 	};
 }
+function createGetQuestPlanTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_get_quest_plan",
+			description: "Fetch a quest master plan by ID. Returns the full plan with all quests, sub-quests, review gate status, handoff state, and progress metrics. Use this to check which sub-quests have review gates and their current status.",
+			parameters: {
+				type: "object",
+				properties: { plan_id: {
+					type: "string",
+					description: "The MongoDB ObjectId of the quest master plan"
+				} },
+				required: ["plan_id"]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id } = GetQuestPlanParamsSchema.parse(params);
+			const result = await service.getQuestPlan(plan_id);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createUpdateReviewGateTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_update_review_gate",
+			description: "Approve or reject a review gate on a sub-quest. Review gates are human approval checkpoints — when a sub-quest has reviewGate: true, the AI must stop and wait for human approval before proceeding.",
+			parameters: {
+				type: "object",
+				properties: {
+					plan_id: {
+						type: "string",
+						description: "The MongoDB ObjectId of the quest master plan"
+					},
+					quest_id: {
+						type: "string",
+						description: "The ID of the parent quest"
+					},
+					sub_quest_id: {
+						type: "string",
+						description: "The ID of the sub-quest with the review gate"
+					},
+					review_status: {
+						type: "string",
+						description: "The review decision",
+						enum: [
+							"pending",
+							"approved",
+							"rejected"
+						]
+					},
+					review_note: {
+						type: "string",
+						description: "Optional note explaining the review decision"
+					}
+				},
+				required: [
+					"plan_id",
+					"quest_id",
+					"sub_quest_id",
+					"review_status"
+				]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id, quest_id, sub_quest_id, review_status, review_note } = UpdateReviewGateParamsSchema.parse(params);
+			const result = await service.updateReviewGate(plan_id, quest_id, sub_quest_id, review_status, review_note);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createUpdateQuestProgressTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_update_quest_progress",
+			description: "Update a sub-quest's progress. Set status to track completion, add evidence of what was accomplished, and optionally record time spent. Setting status to \"in_progress\" auto-resumes a paused plan.",
+			parameters: {
+				type: "object",
+				properties: {
+					plan_id: {
+						type: "string",
+						description: "The MongoDB ObjectId of the quest master plan"
+					},
+					quest_id: {
+						type: "string",
+						description: "The ID of the parent quest"
+					},
+					sub_quest_id: {
+						type: "string",
+						description: "The ID of the sub-quest to update"
+					},
+					status: {
+						type: "string",
+						description: "New status for the sub-quest",
+						enum: [
+							"not_started",
+							"in_progress",
+							"completed",
+							"skipped",
+							"deleted"
+						]
+					},
+					evidence: {
+						type: "string",
+						description: "Evidence of completion — links to artifacts, descriptions of output, or references to results"
+					},
+					time_spent: {
+						type: "number",
+						description: "Time spent on this sub-quest in milliseconds"
+					}
+				},
+				required: [
+					"plan_id",
+					"quest_id",
+					"sub_quest_id"
+				]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id, quest_id, sub_quest_id, status, evidence, time_spent } = UpdateQuestProgressParamsSchema.parse(params);
+			const updates = {};
+			if (status !== void 0) updates.status = status;
+			if (evidence !== void 0) updates.evidence = evidence;
+			if (time_spent !== void 0) updates.timeSpent = time_spent;
+			const result = await service.updateSubQuestProgress(plan_id, quest_id, sub_quest_id, updates);
+			return JSON.stringify(result);
+		}
+	};
+}
+function createWriteHandoffTool(service) {
+	return {
+		toolSchema: {
+			name: "tavern_write_handoff",
+			description: "Write a handoff state for session continuity. Called when ending a session so the next session can resume with full context. Includes a summary of progress, next steps, pending decisions, and blockers.",
+			parameters: {
+				type: "object",
+				properties: {
+					plan_id: {
+						type: "string",
+						description: "The MongoDB ObjectId of the quest master plan"
+					},
+					summary: {
+						type: "string",
+						description: "Summary of what was accomplished in this session"
+					},
+					next_steps: {
+						type: "array",
+						items: { type: "string" },
+						description: "List of next steps for the following session"
+					},
+					pending_decisions: {
+						type: "array",
+						items: { type: "string" },
+						description: "Decisions that still need to be made"
+					},
+					blockers: {
+						type: "array",
+						items: { type: "string" },
+						description: "Current blockers preventing progress"
+					}
+				},
+				required: [
+					"plan_id",
+					"summary",
+					"next_steps",
+					"pending_decisions",
+					"blockers"
+				]
+			}
+		},
+		toolFn: async (params) => {
+			const { plan_id, summary, next_steps, pending_decisions, blockers } = WriteHandoffParamsSchema.parse(params);
+			const result = await service.updateHandoff(plan_id, {
+				summary,
+				nextSteps: next_steps,
+				pendingDecisions: pending_decisions,
+				blockers
+			});
+			return JSON.stringify(result);
+		}
+	};
+}
 //#endregion
 //#region src/features/tavern/TavernModule.ts
 /** Icons for heartbeat log actions shown in /tavern command */
@@ -4274,9 +4616,23 @@ Available actions:
 - **tavern_trigger_heartbeat**: Manually trigger a heartbeat cycle
 - **tavern_abort_heartbeats**: Emergency stop all in-flight heartbeats
 - **tavern_status**: Quick overview of agents, quests, and gates — good for situational awareness
+- **tavern_get_quest_plan**: Fetch a quest master plan with review gate status and handoff state
+- **tavern_update_review_gate**: Approve or reject a review gate on a sub-quest
+- **tavern_update_quest_progress**: Update sub-quest status and record evidence of completion
+- **tavern_write_handoff**: Write session handoff for continuity across sessions
 
 When the user mentions talking to agents, checking the quest board, or managing the tavern, use these tools.
-Agents have personalities, moods, quests, and memories — they are autonomous entities, not chatbots.`;
+Agents have personalities, moods, quests, and memories — they are autonomous entities, not chatbots.
+
+## Quest Workflow (Review Gates)
+When working on a quest plan with review gates (reviewGate: true on sub-quests), you MUST:
+1. Check review gate status with tavern_get_quest_plan before proceeding past a gated step
+2. If the next sub-quest has reviewGate: true and reviewStatus is not 'approved', STOP and inform the user
+3. Record evidence of completion with tavern_update_quest_progress when finishing a sub-quest
+4. Write a handoff with tavern_write_handoff before ending a session with an active quest plan
+
+## Session Handoff & Resume
+When the user runs /quest resume <plan_id>, read the handoff context and continue from where the previous session left off. The handoff contains: summary of prior work, next steps, pending decisions, and blockers.`;
 	}
 	getCommands() {
 		return [{
@@ -4301,6 +4657,95 @@ Agents have personalities, moods, quests, and memories — they are autonomous e
 				}
 				console.log("");
 			}
+		}, {
+			name: "quest",
+			description: "Quest workflow commands: review gates, resume from handoff",
+			execute: async (args) => {
+				const subCommand = args[0];
+				if (subCommand === "resume") {
+					const planId = args[1];
+					if (!planId) {
+						console.log("\nUsage: /quest resume <plan_id>");
+						console.log("  Loads the quest plan and displays the session handoff for continuity.\n");
+						return;
+					}
+					try {
+						const plan = await this.service.getQuestPlan(planId);
+						console.log(`\nQuest Plan: ${plan.goal}`);
+						console.log(`State: ${plan.state ?? "unknown"}`);
+						if (plan.metrics) {
+							const pct = Math.round(plan.metrics.completionRate * 100);
+							console.log(`Progress: ${plan.metrics.subQuestsCompleted}/${plan.metrics.subQuestsTotal} sub-quests (${pct}%)`);
+						}
+						if (!plan.handoff) {
+							console.log("\n  No handoff found — this plan has no saved session context.");
+							console.log("  The AI can still read the plan via tavern_get_quest_plan.\n");
+							return;
+						}
+						const { handoff } = plan;
+						console.log(`\nSession Handoff (${new Date(handoff.updatedAt).toLocaleString()}):`);
+						console.log(`\n  Summary: ${handoff.summary}`);
+						if (handoff.nextSteps.length > 0) {
+							console.log("\n  Next Steps:");
+							for (const step of handoff.nextSteps) console.log(`    \u2022 ${step}`);
+						}
+						if (handoff.pendingDecisions.length > 0) {
+							console.log("\n  Pending Decisions:");
+							for (const decision of handoff.pendingDecisions) console.log(`    \u2753 ${decision}`);
+						}
+						if (handoff.blockers.length > 0) {
+							console.log("\n  Blockers:");
+							for (const blocker of handoff.blockers) console.log(`    \u{1F6D1} ${blocker}`);
+						}
+						console.log("");
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						console.log(`\nError fetching quest plan: ${message}\n`);
+					}
+					return;
+				}
+				if (subCommand === "review") {
+					const planId = args[1];
+					if (!planId) {
+						console.log("\nUsage: /quest review <plan_id>");
+						console.log("  Fetches the quest plan and shows sub-quests with pending review gates.\n");
+						return;
+					}
+					try {
+						const plan = await this.service.getQuestPlan(planId);
+						const pendingGates = [];
+						for (const quest of plan.quests) for (const sq of quest.subQuests) if (sq.reviewGate) pendingGates.push({
+							questTitle: quest.title,
+							questId: quest.id,
+							subQuestTitle: sq.title,
+							subQuestId: sq.id,
+							status: sq.reviewStatus ?? "pending"
+						});
+						if (pendingGates.length === 0) {
+							console.log(`\nQuest Plan: ${plan.goal}`);
+							console.log("  No review gates configured in this plan.\n");
+							return;
+						}
+						console.log(`\nQuest Plan: ${plan.goal}`);
+						console.log(`State: ${plan.state ?? "unknown"}\n`);
+						console.log("Review Gates:");
+						for (const gate of pendingGates) {
+							const icon = gate.status === "approved" ? "✅" : gate.status === "rejected" ? "❌" : "⏸️";
+							console.log(`  ${icon} [${gate.status}] ${gate.questTitle} > ${gate.subQuestTitle}`);
+							console.log(`     quest_id: ${gate.questId}  sub_quest_id: ${gate.subQuestId}`);
+						}
+						console.log("\n  To approve: ask the AI to approve a review gate, or use tavern_update_review_gate tool.\n");
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						console.log(`\nError fetching quest plan: ${message}\n`);
+					}
+					return;
+				}
+				console.log("\nUsage:");
+				console.log("  /quest review <plan_id>  — Show review gates and their status");
+				console.log("  /quest resume <plan_id>  — Load handoff and resume from where you left off");
+				console.log("");
+			}
 		}];
 	}
 	registerWsHandlers(wsManager) {
@@ -4591,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);
@@ -5033,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,
@@ -5050,6 +5506,8 @@ function CliApp() {
 				agentDelegateTool,
 				...backgroundTools,
 				writeTodosTool,
+				decisionLogTool,
+				...blockerTools,
 				findDefinitionTool,
 				getFileStructureTool
 			];
@@ -5479,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) => ({
@@ -6095,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;
@@ -6355,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,
@@ -7046,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-BImjpPlR.mjs → tools-V5FJ83BJ.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as RechartsChartTypeList, A as ImageGenerationUsageTransaction, At as secureParameters, B as NotFoundError, C as FileEvents, Ct as getMcpProviderMetadata, D as GenericCreditAddTransaction, Dt as obfuscateApiKey, E as GenerateImageToolCallSchema, Et as isGPTImageModel, F as KnowledgeType, G as ProfileEvents, H as OpenAIImageGenerationInput, I as LLMEvents, J as PurchaseTransaction, K as ProjectEvents, L as MiscEvents, M as InboxEvents, N as InviteEvents, Nt as CollectionType, O as GenericCreditDeductTransaction, Ot as resolveNavigationIntents, P as InviteType, Q as ReceivedCreditTransaction, R as ModalEvents, S as FeedbackEvents, St as getDataLakeTags, T as GEMINI_IMAGE_MODELS, Tt as isGPTImage2Model, U as Permission, V as OpenAIEmbeddingModel, W as PermissionDeniedError, X as REASONING_SUPPORTED_MODELS, Y as QuestMasterParamsSchema, Z as RealtimeVoiceUsageTransaction, _ as CompletionApiUsageTransaction, _t as VideoModels, a as ApiKeyEvents, at as SessionEvents, b as FIXED_TEMPERATURE_MODELS, bt as b4mLLMTools, c as AppFileEvents, ct as SupportedFabFileMimeTypes, d as BFL_IMAGE_MODELS, dt as TextGenerationUsageTransaction, et as RegInviteEvents, f as BFL_SAFETY_TOLERANCE, ft as ToolUsageTransaction, g as ChatModels, gt as VideoGenerationUsageTransaction, h as ChatCompletionCreateInputSchema, ht as VIDEO_SIZE_CONSTRAINTS, i as AiEvents, it as ResearchTaskType, j as ImageModels, k as ImageEditUsageTransaction, kt as sanitizeTelemetryError, l as ArtifactTypeSchema, lt as TagType, mt as UiNavigationEvents, n as logger, nt as ResearchTaskExecutionType, o as ApiKeyScope, ot as SpeechToTextModels, p as BedrockEmbeddingModel, pt as TransferCreditTransaction, q as PromptMetaZodSchema, r as ALERT_THRESHOLDS, rt as ResearchTaskPeriodicFrequencyType, s as ApiKeyType, st as SubscriptionCreditTransaction, t as ConfigStore, tt as ResearchModeParamsSchema, u as AuthEvents, ut as TaskScheduleHandler, v as DashboardParamsSchema, vt as VoyageAIEmbeddingModel, w as FriendshipEvents, wt as getViewById, x as FavoriteDocumentType, xt as getAccessibleDataLakes, y as ElabsEvents, yt as XAI_IMAGE_MODELS, z as ModelBackend } from "./ConfigStore-o5AblHqQ.mjs";
+import { $ as RechartsChartTypeList, A as ImageGenerationUsageTransaction, At as secureParameters, B as NotFoundError, C as FileEvents, Ct as getMcpProviderMetadata, D as GenericCreditAddTransaction, Dt as obfuscateApiKey, E as GenerateImageToolCallSchema, Et as isGPTImageModel, F as KnowledgeType, G as ProfileEvents, H as OpenAIImageGenerationInput, I as LLMEvents, J as PurchaseTransaction, K as ProjectEvents, L as MiscEvents, M as InboxEvents, N as InviteEvents, Nt as CollectionType, O as GenericCreditDeductTransaction, Ot as resolveNavigationIntents, P as InviteType, Q as ReceivedCreditTransaction, R as ModalEvents, S as FeedbackEvents, St as getDataLakeTags, T as GEMINI_IMAGE_MODELS, Tt as isGPTImage2Model, U as Permission, V as OpenAIEmbeddingModel, W as PermissionDeniedError, X as REASONING_SUPPORTED_MODELS, Y as QuestMasterParamsSchema, Z as RealtimeVoiceUsageTransaction, _ as CompletionApiUsageTransaction, _t as VideoModels, a as ApiKeyEvents, at as SessionEvents, b as FIXED_TEMPERATURE_MODELS, bt as b4mLLMTools, c as AppFileEvents, ct as SupportedFabFileMimeTypes, d as BFL_IMAGE_MODELS, dt as TextGenerationUsageTransaction, et as RegInviteEvents, f as BFL_SAFETY_TOLERANCE, ft as ToolUsageTransaction, g as ChatModels, gt as VideoGenerationUsageTransaction, h as ChatCompletionCreateInputSchema, ht as VIDEO_SIZE_CONSTRAINTS, i as AiEvents, it as ResearchTaskType, j as ImageModels, k as ImageEditUsageTransaction, kt as sanitizeTelemetryError, l as ArtifactTypeSchema, lt as TagType, mt as UiNavigationEvents, n as logger, nt as ResearchTaskExecutionType, o as ApiKeyScope, ot as SpeechToTextModels, p as BedrockEmbeddingModel, pt as TransferCreditTransaction, q as PromptMetaZodSchema, r as ALERT_THRESHOLDS, rt as ResearchTaskPeriodicFrequencyType, s as ApiKeyType, st as SubscriptionCreditTransaction, t as ConfigStore, tt as ResearchModeParamsSchema, u as AuthEvents, ut as TaskScheduleHandler, v as DashboardParamsSchema, vt as VoyageAIEmbeddingModel, w as FriendshipEvents, wt as getViewById, x as FavoriteDocumentType, xt as getAccessibleDataLakes, y as ElabsEvents, yt as XAI_IMAGE_MODELS, z as ModelBackend } from "./ConfigStore-DBUmvCfe.mjs";
 import { n as isPathAllowed, t as assertPathAllowed } from "./pathValidation-CIytuhr3-Dt5dntLx.mjs";
 import { execFile, execFileSync, spawn } from "child_process";
 import { createHash, randomBytes } from "crypto";
@@ -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",
@@ -15356,9 +15394,12 @@ z.object({
 		direction: z.enum(["asc", "desc"])
 	}).optional(),
 	options: z.object({
+		textSearch: z.coerce.boolean().optional(),
 		includeShared: z.coerce.boolean().optional(),
 		userGroups: z.array(z.string()).optional(),
-		dataLakeTags: z.array(z.string()).optional()
+		dataLakeTags: z.array(z.string()).optional(),
+		dataLakeTagPrefixes: z.array(z.string()).optional(),
+		excludeContent: z.coerce.boolean().optional()
 	}).optional()
 });
 z.object({ fileId: z.string() });
@@ -23476,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-CEeSpbaK.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.3.0";
+var version = "0.5.0";
 //#endregion
 //#region src/utils/updateChecker.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bike4mind/cli",
-  "version": "0.3.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.0",
-    "@bike4mind/common": "2.87.0",
-    "@bike4mind/mcp": "1.35.9",
-    "@bike4mind/services": "2.76.8",
-    "@bike4mind/utils": "2.18.7"
+    "@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"