@bike4mind/cli 0.2.71-fix-opti-hashi-data-lake-explorer.22040 → 0.2.71

package/dist/{ConfigStore-DH64GYfC.mjs → ConfigStore-CJrPFsAE.mjs}

@@ -982,7 +982,8 @@ const SreAgentConfigSchema = z.object({
 		enabled: true,
 		minConfidence: 80
 	}),
-	dryRun: z.boolean().default(false)
+	dryRun: z.boolean().default(false),
+	maxRevisions: z.number().min(0).max(5).default(2)
 });
 /**
 * Configuration schema for the SecOps Triage feature.
@@ -1568,7 +1569,8 @@ const KeepCommandType = z.enum([
 	"jupyter_start_kernel",
 	"jupyter_execute_cell",
 	"jupyter_stop_kernel",
-	"jupyter_get_kernelspecs"
+	"jupyter_get_kernelspecs",
+	"jupyter_execute_notebook"
 ]);
 /** Web HUD → Server: request a command be sent to the Keep (CLI) */
 const KeepCommandRequestAction = z.object({
@@ -1740,7 +1742,8 @@ const SceneCommandSchema = z.discriminatedUnion("type", [
 			col: z.number(),
 			row: z.number(),
 			gid: z.number()
-		}))
+		})),
+		worldVersion: z.number().optional()
 	})
 ]);
 /** Client → Server: send scene commands to broadcast to all HUD clients */
@@ -3051,6 +3054,11 @@ const CONTEXT_TELEMETRY_VALIDATION_LIMITS = {
 		max: 18e4,
 		default: 6e4
 	},
+	llmAnalysisThreshold: {
+		min: 0,
+		max: 100,
+		default: 30
+	},
 	alertThreshold: {
 		min: 0,
 		max: 100,
@@ -3081,6 +3089,31 @@ const CONTEXT_TELEMETRY_VALIDATION_LIMITS = {
 		max: 168,
 		default: 24
 	},
+	baselineWindowDays: {
+		min: 3,
+		max: 30,
+		default: 7
+	},
+	sloResponseTimeP95Ms: {
+		min: 500,
+		max: 3e5,
+		default: 6e4
+	},
+	sloFirstTokenTimeMs: {
+		min: 500,
+		max: 6e4,
+		default: 5e3
+	},
+	sloErrorRatePercent: {
+		min: 0,
+		max: 100,
+		default: 2
+	},
+	sloContextUtilizationPercent: {
+		min: 50,
+		max: 100,
+		default: 85
+	},
 	maxIssuesPerHour: {
 		min: 1,
 		max: 200,
@@ -3103,6 +3136,7 @@ const ContextTelemetryAlertsSchema = z.object({
 	temperature: z.number().min(CT.temperature.min).max(CT.temperature.max).default(CT.temperature.default),
 	maxTokens: z.number().min(CT.maxTokens.min).max(CT.maxTokens.max).default(CT.maxTokens.default),
 	timeoutMs: z.number().min(CT.timeoutMs.min).max(CT.timeoutMs.max).default(CT.timeoutMs.default),
+	llmAnalysisThreshold: z.number().min(CT.llmAnalysisThreshold.min).max(CT.llmAnalysisThreshold.max).default(CT.llmAnalysisThreshold.default),
 	alertThreshold: z.number().min(CT.alertThreshold.min).max(CT.alertThreshold.max).default(CT.alertThreshold.default),
 	criticalThreshold: z.number().min(CT.criticalThreshold.min).max(CT.criticalThreshold.max).default(CT.criticalThreshold.default),
 	dedupWindowMinutes: z.number().min(CT.dedupWindowMinutes.min).max(CT.dedupWindowMinutes.max).default(CT.dedupWindowMinutes.default),
@@ -3111,6 +3145,11 @@ const ContextTelemetryAlertsSchema = z.object({
 	duplicateAlertCooldownHours: z.number().min(CT.duplicateAlertCooldownHours.min).max(CT.duplicateAlertCooldownHours.max).default(CT.duplicateAlertCooldownHours.default),
 	enableLlmPriority: z.boolean().default(false),
 	promptTemplate: z.string().min(CT.promptTemplate.min, `Prompt template must be at least ${CT.promptTemplate.min} characters`).max(CT.promptTemplate.max, `Prompt template cannot exceed ${CT.promptTemplate.max.toLocaleString()} characters`).trim().optional(),
+	baselineWindowDays: z.number().min(CT.baselineWindowDays.min).max(CT.baselineWindowDays.max).default(CT.baselineWindowDays.default),
+	sloResponseTimeP95Ms: z.number().min(CT.sloResponseTimeP95Ms.min).max(CT.sloResponseTimeP95Ms.max).default(CT.sloResponseTimeP95Ms.default),
+	sloFirstTokenTimeMs: z.number().min(CT.sloFirstTokenTimeMs.min).max(CT.sloFirstTokenTimeMs.max).default(CT.sloFirstTokenTimeMs.default),
+	sloErrorRatePercent: z.number().min(CT.sloErrorRatePercent.min).max(CT.sloErrorRatePercent.max).default(CT.sloErrorRatePercent.default),
+	sloContextUtilizationPercent: z.number().min(CT.sloContextUtilizationPercent.min).max(CT.sloContextUtilizationPercent.max).default(CT.sloContextUtilizationPercent.default),
 	maxIssuesPerHour: z.number().min(CT.maxIssuesPerHour.min).max(CT.maxIssuesPerHour.max).default(CT.maxIssuesPerHour.default),
 	dryRun: z.boolean().default(false)
 });
@@ -4921,6 +4960,7 @@ makeStringSetting({
 		temperature: CONTEXT_TELEMETRY_VALIDATION_LIMITS.temperature.default,
 		maxTokens: CONTEXT_TELEMETRY_VALIDATION_LIMITS.maxTokens.default,
 		timeoutMs: CONTEXT_TELEMETRY_VALIDATION_LIMITS.timeoutMs.default,
+		llmAnalysisThreshold: CONTEXT_TELEMETRY_VALIDATION_LIMITS.llmAnalysisThreshold.default,
 		alertThreshold: CONTEXT_TELEMETRY_VALIDATION_LIMITS.alertThreshold.default,
 		criticalThreshold: CONTEXT_TELEMETRY_VALIDATION_LIMITS.criticalThreshold.default,
 		dedupWindowMinutes: CONTEXT_TELEMETRY_VALIDATION_LIMITS.dedupWindowMinutes.default,
@@ -4928,6 +4968,11 @@ makeStringSetting({
 		regressionGracePeriodHours: CONTEXT_TELEMETRY_VALIDATION_LIMITS.regressionGracePeriodHours.default,
 		duplicateAlertCooldownHours: CONTEXT_TELEMETRY_VALIDATION_LIMITS.duplicateAlertCooldownHours.default,
 		enableLlmPriority: false,
+		baselineWindowDays: CONTEXT_TELEMETRY_VALIDATION_LIMITS.baselineWindowDays.default,
+		sloResponseTimeP95Ms: CONTEXT_TELEMETRY_VALIDATION_LIMITS.sloResponseTimeP95Ms.default,
+		sloFirstTokenTimeMs: CONTEXT_TELEMETRY_VALIDATION_LIMITS.sloFirstTokenTimeMs.default,
+		sloErrorRatePercent: CONTEXT_TELEMETRY_VALIDATION_LIMITS.sloErrorRatePercent.default,
+		sloContextUtilizationPercent: CONTEXT_TELEMETRY_VALIDATION_LIMITS.sloContextUtilizationPercent.default,
 		maxIssuesPerHour: CONTEXT_TELEMETRY_VALIDATION_LIMITS.maxIssuesPerHour.default,
 		dryRun: false
 	},
@@ -5192,6 +5237,23 @@ const ALERT_THRESHOLDS = {
 	warning: 30,
 	critical: 50
 };
+z.object({
+	avgResponseTimeMs: z.number(),
+	p95ResponseTimeMs: z.number(),
+	avgUtilization: z.number(),
+	utilizationRange: z.object({
+		low: z.number(),
+		high: z.number()
+	}),
+	sampleCount: z.number(),
+	windowDays: z.number()
+});
+z.enum([
+	"no_action",
+	"monitor",
+	"investigate_soon",
+	"immediate_action"
+]);
 const PromptMetaModelParametersSchema = z.object({
 	temperature: z.number().optional(),
 	topP: z.number().optional(),
@@ -8091,7 +8153,8 @@ const CliConfigSchema = z.object({
 	features: z.object({ tavern: z.boolean().optional() }).optional().prefault({}),
 	trustedTools: z.array(z.string()).optional().prefault([]),
 	sandbox: SandboxConfigSchema.optional(),
-	additionalDirectories: z.array(z.string()).optional().prefault([])
+	additionalDirectories: z.array(z.string()).optional().prefault([]),
+	fallbackModels: z.array(z.string()).optional()
 });
 /**
 * Zod schema for ProjectConfig validation

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-bL3tE6X7.mjs";
+import { i as version, n as fetchLatestVersion, r as forceCheckForUpdate } from "../updateChecker-Cxb7mnxO.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 { I as isReadOnlyTool, L as ReActAgent, M as setWebSocketToolExecutor, P as buildCoreSystemPrompt, R as CustomCommandStore, S as getApiUrl, T as generateCliTools, V as SessionStore, _ as McpManager, a as createBackgroundAgentTools, c as AgentStore, f as ApiClient, g as ServerLlmBackend, h as WebSocketLlmBackend, i as createWriteTodosTool, l as SubagentOrchestrator, m as WebSocketConnectionManager, n as createFindDefinitionTool, o as BackgroundAgentManager, p as WebSocketToolExecutor, r as createTodoStore, s as createAgentDelegateTool, t as createGetFileStructureTool, u as createSkillTool, w as PermissionManager, x as loadContextFiles, z as CheckpointStore } from "../tools-CcSulyLi.mjs";
-import { n as logger, t as ConfigStore } from "../ConfigStore-DH64GYfC.mjs";
+import { B as CustomCommandStore, C as getApiUrl, E as generateCliTools, I as buildCoreSystemPrompt, P as setWebSocketToolExecutor, R as isReadOnlyTool, S as loadContextFiles, T as PermissionManager, U as SessionStore, V as CheckpointStore, _ as ServerLlmBackend, a as createBackgroundAgentTools, c as AgentStore, f as ApiClient, g as WebSocketLlmBackend, h as FallbackLlmBackend, i as createWriteTodosTool, l as SubagentOrchestrator, m as WebSocketConnectionManager, n as createFindDefinitionTool, o as BackgroundAgentManager, p as WebSocketToolExecutor, r as createTodoStore, s as createAgentDelegateTool, t as createGetFileStructureTool, u as createSkillTool, v as McpManager, z as ReActAgent } from "../tools-DmUrRjzs.mjs";
+import { n as logger, t as ConfigStore } from "../ConfigStore-CJrPFsAE.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";
@@ -97,6 +97,9 @@ async function handleHeadlessCommand(options) {
 		if (models.length === 0) throw new Error("No models available from server.");
 		const modelInfo = models.find((m) => m.id === config.defaultModel) ?? models[0];
 		llm.currentModel = modelInfo.id;
+		const effectiveLlm = config.fallbackModels && config.fallbackModels.length > 0 ? new FallbackLlmBackend(llm, config.fallbackModels, (fromModel, toModel, error) => {
+			process.stderr.write(`⚠️  Model "${fromModel}" failed (${error.message}). Falling back to "${toModel}"...\n`);
+		}) : llm;
 		const session = {
 			id: v4(),
 			name: `Headless ${(/* @__PURE__ */ new Date()).toISOString()}`,
@@ -195,7 +198,7 @@ async function handleHeadlessCommand(options) {
 		const agent = new ReActAgent({
 			userId: config.userId,
 			logger: silentLogger,
-			llm,
+			llm: effectiveLlm,
 			model: modelInfo.id,
 			tools: allTools,
 			maxIterations,

package/dist/commands/mcpCommand.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as ConfigStore } from "../ConfigStore-DH64GYfC.mjs";
+import { t as ConfigStore } from "../ConfigStore-CJrPFsAE.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-bL3tE6X7.mjs";
+import { i as version, r as forceCheckForUpdate } from "../updateChecker-Cxb7mnxO.mjs";
 import { execSync } from "child_process";
 //#region src/commands/updateCommand.ts
 /**

package/dist/index.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { n as useCliStore, t as selectActiveBackgroundAgents } from "./store-Dw1nZX2Y.mjs";
-import { A as clearFeatureModuleTools, B as CommandHistoryStore, C as getEnvironmentName, D as DEFAULT_AGENT_MODEL, E as ALWAYS_DENIED_FOR_AGENTS, F as buildSkillsPromptSection, G as searchCommands, H as OAuthClient, I as isReadOnlyTool, J as searchFiles, K as mergeCommands, L as ReActAgent, M as setWebSocketToolExecutor, N as OllamaBackend, O as DEFAULT_MAX_ITERATIONS, P as buildCoreSystemPrompt, R as CustomCommandStore, S as getApiUrl, T as generateCliTools, U as hasFileReferences, V as SessionStore, W as processFileReferences, Y as warmFileCache, _ as McpManager, a as createBackgroundAgentTools, b as extractCompactInstructions, c as AgentStore, d as parseAgentConfig, f as ApiClient, g as ServerLlmBackend, h as WebSocketLlmBackend, i as createWriteTodosTool, j as registerFeatureModuleTools, k as DEFAULT_THOROUGHNESS, l as SubagentOrchestrator, m as WebSocketConnectionManager, n as createFindDefinitionTool, o as BackgroundAgentManager, p as WebSocketToolExecutor, q as formatFileSize, r as createTodoStore, s as createAgentDelegateTool, t as createGetFileStructureTool, u as createSkillTool, v as substituteArguments, w as PermissionManager, x as loadContextFiles, y as formatStep, z as CheckpointStore } from "./tools-CcSulyLi.mjs";
-import { Dt as validateNotebookPath$1, Et as validateJupyterKernelName, g as ChatModels, m as CREDIT_DEDUCT_TRANSACTION_TYPES, n as logger, t as ConfigStore } from "./ConfigStore-DH64GYfC.mjs";
-import { i as version, t as checkForUpdate } from "./updateChecker-bL3tE6X7.mjs";
+import { A as DEFAULT_RETRY_CONFIG, B as CustomCommandStore, C as getApiUrl, D as ALWAYS_DENIED_FOR_AGENTS, E as generateCliTools, F as OllamaBackend, G as hasFileReferences, H as CommandHistoryStore, I as buildCoreSystemPrompt, J as mergeCommands, K as processFileReferences, L as buildSkillsPromptSection, M as clearFeatureModuleTools, N as registerFeatureModuleTools, O as DEFAULT_AGENT_MODEL, P as setWebSocketToolExecutor, R as isReadOnlyTool, S as loadContextFiles, T as PermissionManager, U as SessionStore, V as CheckpointStore, W as OAuthClient, X as searchFiles, Y as formatFileSize, Z as warmFileCache, _ as ServerLlmBackend, a as createBackgroundAgentTools, b as formatStep, c as AgentStore, d as parseAgentConfig, f as ApiClient, g as WebSocketLlmBackend, h as FallbackLlmBackend, i as createWriteTodosTool, j as DEFAULT_THOROUGHNESS, k as DEFAULT_MAX_ITERATIONS, l as SubagentOrchestrator, m as WebSocketConnectionManager, n as createFindDefinitionTool, o as BackgroundAgentManager, p as WebSocketToolExecutor, q as searchCommands, r as createTodoStore, s as createAgentDelegateTool, t as createGetFileStructureTool, u as createSkillTool, v as McpManager, w as getEnvironmentName, x as extractCompactInstructions, y as substituteArguments, z as ReActAgent } from "./tools-DmUrRjzs.mjs";
+import { Dt as validateNotebookPath$1, Et as validateJupyterKernelName, g as ChatModels, m as CREDIT_DEDUCT_TRANSACTION_TYPES, n as logger, t as ConfigStore } from "./ConfigStore-CJrPFsAE.mjs";
+import { i as version, t as checkForUpdate } from "./updateChecker-Cxb7mnxO.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";
-import { randomBytes } from "crypto";
+import { randomBytes, randomUUID } from "crypto";
 import { existsSync, promises, readFileSync, statSync } from "fs";
 import { homedir } from "os";
 import path, { extname } from "path";
@@ -2931,6 +2931,171 @@ function createJupyterClientFromEnv() {
 	});
 }
 //#endregion
+//#region src/commands/executeNotebookHandler.ts
+/**
+* Jupyter Notebook Execution Handler
+*
+* Handles the jupyter_execute_notebook Keep command.
+* Orchestrates cell-by-cell execution of a notebook via local Jupyter server.
+*/
+/**
+* Zod schema for validating execute notebook parameters.
+* Replaces unsafe `as` casts with proper runtime validation.
+*/
+const ExecuteNotebookParams = z.object({
+	notebookJson: z.string().min(1, "notebookJson is required"),
+	sessionId: z.string().min(1, "sessionId is required"),
+	kernelName: z.string().default("python3"),
+	timeoutPerCell: z.number().default(3e4)
+});
+/**
+* Get cell source as string (handles both string and string[] formats).
+*/
+function getCellSource(cell) {
+	return Array.isArray(cell.source) ? cell.source.join("") : cell.source;
+}
+/**
+* Execute a Jupyter notebook cell by cell.
+*
+* @param params - Validated notebook execution parameters
+* @param deps - Dependencies (jupyter client, websocket manager, logger)
+* @returns Execution result with success status and executed notebook
+*/
+async function executeNotebook(params, deps) {
+	const { jupyterClient, wsManager, logger, requestId } = deps;
+	const { notebookJson, sessionId, kernelName, timeoutPerCell } = ExecuteNotebookParams.parse(params);
+	let notebook;
+	try {
+		notebook = JSON.parse(notebookJson);
+		if (!notebook.cells || !Array.isArray(notebook.cells)) throw new Error("Invalid notebook: missing cells array");
+	} catch (parseErr) {
+		throw new Error(`Failed to parse notebook JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+	}
+	const totalCodeCells = notebook.cells.filter((c) => c.cell_type === "code").length;
+	logger.info(`[Keep] Starting notebook execution: ${totalCodeCells} code cells, kernel: ${kernelName}`);
+	const tempNotebookPath = `/tmp/b4m-notebook-${randomUUID()}.ipynb`;
+	await promises.writeFile(tempNotebookPath, notebookJson, "utf-8");
+	let jupyterSession = null;
+	let cellsExecuted = 0;
+	let cellsFailed = 0;
+	try {
+		logger.info(`[Keep] Starting Jupyter kernel: ${kernelName}`);
+		jupyterSession = await jupyterClient.startSession(tempNotebookPath, kernelName);
+		const kernelId = jupyterSession.kernel.id;
+		const jupyterSessionId = jupyterSession.id;
+		logger.info(`[Keep] Kernel started: session=${jupyterSessionId}, kernel=${kernelId}`);
+		let codeCellIndex = 0;
+		for (let i = 0; i < notebook.cells.length; i++) {
+			const cell = notebook.cells[i];
+			if (cell.cell_type !== "code") continue;
+			const cellCode = getCellSource(cell);
+			if (!cellCode.trim()) {
+				codeCellIndex++;
+				continue;
+			}
+			logger.info(`[Keep] Executing cell ${codeCellIndex + 1}/${totalCodeCells}`);
+			wsManager?.send({
+				action: "jupyter_cell_output",
+				requestId,
+				sessionId,
+				jupyterSessionId,
+				cellIndex: codeCellIndex,
+				outputType: "stream",
+				content: {
+					text: `Executing cell ${codeCellIndex + 1}/${totalCodeCells}...`,
+					name: "stdout"
+				},
+				executionCount: null,
+				isComplete: false
+			});
+			try {
+				const cellResult = await jupyterClient.executeCell(kernelId, cellCode, timeoutPerCell);
+				cell.outputs = cellResult.outputs;
+				cell.execution_count = cellResult.executionCount;
+				if (cellResult.success) {
+					cellsExecuted++;
+					wsManager?.send({
+						action: "jupyter_cell_output",
+						requestId,
+						sessionId,
+						jupyterSessionId,
+						cellIndex: codeCellIndex,
+						outputType: "execute_result",
+						content: {
+							text: cellResult.outputs.map((o) => {
+								if (o.text) return Array.isArray(o.text) ? o.text.join("") : o.text;
+								if (o.data && typeof o.data === "object" && "text/plain" in o.data) {
+									const textPlain = o.data["text/plain"];
+									return Array.isArray(textPlain) ? textPlain.join("") : String(textPlain);
+								}
+								return "";
+							}).join(""),
+							data: cellResult.outputs.find((o) => o.data)?.data
+						},
+						executionCount: cellResult.executionCount,
+						isComplete: true
+					});
+				} else {
+					cellsFailed++;
+					wsManager?.send({
+						action: "jupyter_cell_output",
+						requestId,
+						sessionId,
+						jupyterSessionId,
+						cellIndex: codeCellIndex,
+						outputType: "error",
+						content: {
+							ename: cellResult.error?.ename || "ExecutionError",
+							evalue: cellResult.error?.evalue || "Cell execution failed",
+							traceback: cellResult.error?.traceback || []
+						},
+						executionCount: cellResult.executionCount,
+						isComplete: true
+					});
+					logger.warn(`[Keep] Cell ${codeCellIndex + 1} failed: ${cellResult.error?.ename}: ${cellResult.error?.evalue}`);
+				}
+			} catch (cellErr) {
+				cellsFailed++;
+				const errMsg = cellErr instanceof Error ? cellErr.message : String(cellErr);
+				wsManager?.send({
+					action: "jupyter_cell_output",
+					requestId,
+					sessionId,
+					jupyterSessionId,
+					cellIndex: codeCellIndex,
+					outputType: "error",
+					content: {
+						ename: "ExecutionError",
+						evalue: errMsg,
+						traceback: []
+					},
+					executionCount: null,
+					isComplete: true
+				});
+				logger.error(`[Keep] Cell ${codeCellIndex + 1} threw error: ${errMsg}`);
+			}
+			codeCellIndex++;
+		}
+		return {
+			success: cellsFailed === 0,
+			cellsExecuted,
+			cellsFailed,
+			totalCodeCells,
+			executedNotebook: JSON.stringify(notebook)
+		};
+	} finally {
+		if (jupyterSession) try {
+			logger.info(`[Keep] Stopping Jupyter session: ${jupyterSession.id}`);
+			await jupyterClient.stopSession(jupyterSession.id);
+		} catch (stopErr) {
+			logger.warn(`[Keep] Failed to stop session: ${stopErr instanceof Error ? stopErr.message : String(stopErr)}`);
+		}
+		try {
+			await promises.unlink(tempNotebookPath);
+		} catch {}
+	}
+}
+//#endregion
 //#region src/llm/NotifyingLlmBackend.ts
 /**
 * LLM backend wrapper that injects background agent notifications
@@ -3030,7 +3195,8 @@ function createDynamicAgentTool(orchestrator, parentSessionId, backgroundManager
 				deniedTools,
 				maxIterations: { ...DEFAULT_MAX_ITERATIONS },
 				defaultThoroughness: DEFAULT_THOROUGHNESS,
-				defaultVariables: params.variables
+				defaultVariables: params.variables,
+				retry: { ...DEFAULT_RETRY_CONFIG }
 			};
 			const spawnOptions = {
 				task: params.task,
@@ -4408,6 +4574,14 @@ function CliApp() {
 									};
 									break;
 								}
+								case "jupyter_execute_notebook":
+									result = await executeNotebook(params, {
+										jupyterClient: getRequiredJupyterClient(),
+										wsManager,
+										logger,
+										requestId
+									});
+									break;
 								default: throw new Error(`Unknown command type: ${commandType}`);
 							}
 						} catch (err) {
@@ -4606,7 +4780,9 @@ function CliApp() {
 			const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id, backgroundManager);
 			const dynamicAgentTool = config.preferences.enableDynamicAgentCreation === true ? createDynamicAgentTool(orchestrator, newSession.id, backgroundManager) : null;
 			const backgroundTools = createBackgroundAgentTools(backgroundManager);
-			const notifyingLlm = new NotifyingLlmBackend(llm, backgroundManager);
+			const notifyingLlm = new NotifyingLlmBackend(config.fallbackModels && config.fallbackModels.length > 0 ? new FallbackLlmBackend(llm, config.fallbackModels, (fromModel, toModel, error) => {
+				logger.warn(`⚠️  Model "${fromModel}" failed (${error.message}) — falling back to "${toModel}"`);
+			}) : llm, backgroundManager);
 			const writeTodosTool = createWriteTodosTool(createTodoStore());
 			const enableSkillTool = config.preferences.enableSkillTool !== false;
 			const skillTool = enableSkillTool ? createSkillTool({

package/dist/{tools-CcSulyLi.mjs → tools-DmUrRjzs.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as RegInviteEvents, A as ImageGenerationUsageTransaction, B as OpenAIEmbeddingModel, C as FileEvents, Ct as isGPTImageModel, D as GenericCreditAddTransaction, E as GenerateImageToolCallSchema, F as KnowledgeType, G as ProjectEvents, H as Permission, I as LLMEvents, J as QuestMasterParamsSchema, K as PromptMetaZodSchema, L as MiscEvents, M as InboxEvents, N as InviteEvents, O as GenericCreditDeductTransaction, Ot as CollectionType, P as InviteType, Q as RechartsChartTypeList, R as ModalEvents, S as FeedbackEvents, St as getViewById, T as GEMINI_IMAGE_MODELS, Tt as sanitizeTelemetryError, U as PermissionDeniedError, V as OpenAIImageGenerationInput, W as ProfileEvents, X as RealtimeVoiceUsageTransaction, Y as REASONING_SUPPORTED_MODELS, Z as ReceivedCreditTransaction, _ as CompletionApiUsageTransaction, _t as VoyageAIEmbeddingModel, a as ApiKeyEvents, at as SpeechToTextModels, b as FIXED_TEMPERATURE_MODELS, bt as getDataLakeTags, c as AppFileEvents, ct as TagType, d as BFL_IMAGE_MODELS, dt as ToolUsageTransaction, et as ResearchModeParamsSchema, f as BFL_SAFETY_TOLERANCE, ft as TransferCreditTransaction, g as ChatModels, gt as VideoModels, h as ChatCompletionCreateInputSchema, ht as VideoGenerationUsageTransaction, i as AiEvents, it as SessionEvents, j as ImageModels, k as ImageEditUsageTransaction, l as ArtifactTypeSchema, lt as TaskScheduleHandler, mt as VIDEO_SIZE_CONSTRAINTS, n as logger, nt as ResearchTaskPeriodicFrequencyType, o as ApiKeyScope, ot as SubscriptionCreditTransaction, p as BedrockEmbeddingModel, pt as UiNavigationEvents, q as PurchaseTransaction, r as ALERT_THRESHOLDS, rt as ResearchTaskType, s as ApiKeyType, st as SupportedFabFileMimeTypes, t as ConfigStore, tt as ResearchTaskExecutionType, u as AuthEvents, ut as TextGenerationUsageTransaction, v as DashboardParamsSchema, vt as XAI_IMAGE_MODELS, w as FriendshipEvents, wt as resolveNavigationIntents, x as FavoriteDocumentType, xt as getMcpProviderMetadata, y as ElabsEvents, yt as b4mLLMTools, z as ModelBackend } from "./ConfigStore-DH64GYfC.mjs";
+import { $ as RegInviteEvents, A as ImageGenerationUsageTransaction, B as OpenAIEmbeddingModel, C as FileEvents, Ct as isGPTImageModel, D as GenericCreditAddTransaction, E as GenerateImageToolCallSchema, F as KnowledgeType, G as ProjectEvents, H as Permission, I as LLMEvents, J as QuestMasterParamsSchema, K as PromptMetaZodSchema, L as MiscEvents, M as InboxEvents, N as InviteEvents, O as GenericCreditDeductTransaction, Ot as CollectionType, P as InviteType, Q as RechartsChartTypeList, R as ModalEvents, S as FeedbackEvents, St as getViewById, T as GEMINI_IMAGE_MODELS, Tt as sanitizeTelemetryError, U as PermissionDeniedError, V as OpenAIImageGenerationInput, W as ProfileEvents, X as RealtimeVoiceUsageTransaction, Y as REASONING_SUPPORTED_MODELS, Z as ReceivedCreditTransaction, _ as CompletionApiUsageTransaction, _t as VoyageAIEmbeddingModel, a as ApiKeyEvents, at as SpeechToTextModels, b as FIXED_TEMPERATURE_MODELS, bt as getDataLakeTags, c as AppFileEvents, ct as TagType, d as BFL_IMAGE_MODELS, dt as ToolUsageTransaction, et as ResearchModeParamsSchema, f as BFL_SAFETY_TOLERANCE, ft as TransferCreditTransaction, g as ChatModels, gt as VideoModels, h as ChatCompletionCreateInputSchema, ht as VideoGenerationUsageTransaction, i as AiEvents, it as SessionEvents, j as ImageModels, k as ImageEditUsageTransaction, l as ArtifactTypeSchema, lt as TaskScheduleHandler, mt as VIDEO_SIZE_CONSTRAINTS, n as logger, nt as ResearchTaskPeriodicFrequencyType, o as ApiKeyScope, ot as SubscriptionCreditTransaction, p as BedrockEmbeddingModel, pt as UiNavigationEvents, q as PurchaseTransaction, r as ALERT_THRESHOLDS, rt as ResearchTaskType, s as ApiKeyType, st as SupportedFabFileMimeTypes, t as ConfigStore, tt as ResearchTaskExecutionType, u as AuthEvents, ut as TextGenerationUsageTransaction, v as DashboardParamsSchema, vt as XAI_IMAGE_MODELS, w as FriendshipEvents, wt as resolveNavigationIntents, x as FavoriteDocumentType, xt as getMcpProviderMetadata, y as ElabsEvents, yt as b4mLLMTools, z as ModelBackend } from "./ConfigStore-CJrPFsAE.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";
@@ -16812,6 +16812,13 @@ var HookBlockedError = class extends Error {
 */
 const ALWAYS_DENIED_FOR_AGENTS = ["agent_delegate", "create_dynamic_agent"];
 /**
+* Default retry configuration for agent execution
+*/
+const DEFAULT_RETRY_CONFIG = {
+	maxRetries: 2,
+	initialDelayMs: 1e3
+};
+/**
 * Schema for a command hook definition
 */
 const CommandHookSchema = z.object({
@@ -16868,7 +16875,11 @@ const AgentFrontmatterSchema = z.object({
 		"very_thorough"
 	]).optional(),
 	variables: z.record(z.string(), z.string()).optional(),
-	hooks: AgentHooksSchema
+	hooks: AgentHooksSchema,
+	retry: z.object({
+		maxRetries: z.int().nonnegative().optional(),
+		initialDelay: z.number().positive().optional()
+	}).optional()
 });
 /**
 * Default iteration limits for agents
@@ -18189,16 +18200,16 @@ var StreamLogger = class StreamLogger {
 	}
 };
 //#endregion
-//#region src/llm/ServerLlmBackend.ts
+//#region src/llm/streamAccumulator.ts
 /**
-* Strip <think>...</think> blocks from text
-* Claude's extended thinking should not be shown in final output
+* Strip <think>...</think> blocks from text.
+* Claude's extended thinking should not be shown in final output.
 */
-function stripThinkingBlocks$1(text) {
+function stripThinkingBlocks(text) {
 	return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
 /**
-* Extract usage and credit information from SSE event
+* Extract usage and credit information into CompletionInfo shape.
 */
 function extractUsageInfo(parsed) {
 	return {
@@ -18209,6 +18220,68 @@ function extractUsageInfo(parsed) {
 	};
 }
 /**
+* Accumulates streaming LLM response chunks (text, tool calls, thinking blocks, usage)
+* and fires the completion callback once at the end.
+*
+* Shared between ServerLlmBackend (SSE) and WebSocketLlmBackend (WebSocket frames)
+* so accumulation logic lives in exactly one place.
+*/
+var StreamAccumulator = class {
+	constructor() {
+		this.accumulatedText = "";
+		this.toolsUsed = [];
+		this.thinkingBlocks = [];
+		this.lastUsageInfo = {};
+	}
+	onContent(text, usage, credits) {
+		this.accumulatedText += text;
+		if (usage || credits) this.lastUsageInfo = extractUsageInfo({
+			usage,
+			credits
+		});
+	}
+	onToolUse(text, tools, thinking, usage, credits) {
+		if (text) this.accumulatedText += text;
+		if (tools && tools.length > 0) this.toolsUsed = tools;
+		if (thinking && thinking.length > 0) this.thinkingBlocks = thinking;
+		if (usage || credits) this.lastUsageInfo = extractUsageInfo({
+			usage,
+			credits
+		});
+	}
+	/** True when neither text nor tools have been accumulated (stream produced nothing useful). */
+	isEmpty() {
+		return this.accumulatedText.trim().length === 0 && this.toolsUsed.length === 0;
+	}
+	get accumulatedLength() {
+		return this.accumulatedText.length;
+	}
+	get toolCount() {
+		return this.toolsUsed.length;
+	}
+	/** Raw accumulated text before thinking-block stripping (for debug logging). */
+	get rawText() {
+		return this.accumulatedText;
+	}
+	/**
+	* Calls the completion callback with all accumulated content.
+	* Strips thinking blocks from text before delivering.
+	*/
+	async finalize(callback) {
+		const cleanedText = stripThinkingBlocks(this.accumulatedText);
+		if (this.toolsUsed.length > 0) {
+			const info = {
+				toolsUsed: this.toolsUsed,
+				thinking: this.thinkingBlocks.length > 0 ? this.thinkingBlocks : void 0,
+				...this.lastUsageInfo
+			};
+			await callback([cleanedText], info);
+		} else if (cleanedText) await callback([cleanedText], this.lastUsageInfo);
+	}
+};
+//#endregion
+//#region src/llm/ServerLlmBackend.ts
+/**
 * Server-side LLM backend that proxies requests through Bike4Mind API
 * Uses Server-Sent Events (SSE) for streaming responses
 * API keys remain secure on server - never exposed to CLI
@@ -18311,10 +18384,7 @@ var ServerLlmBackend = class ServerLlmBackend {
 			const streamLogger = new StreamLogger(logger, "ServerLlmBackend", process.env.B4M_VERBOSE === "1", process.env.B4M_DEBUG_STREAM === "1");
 			streamLogger.streamStart();
 			let eventCount = 0;
-			let accumulatedText = "";
-			let lastUsageInfo = {};
-			let toolsUsed = [];
-			let thinkingBlocks = [];
+			const accumulator = new StreamAccumulator();
 			let receivedDone = false;
 			const parser = createParser({ onEvent: (event) => {
 				eventCount++;
@@ -18322,28 +18392,15 @@ var ServerLlmBackend = class ServerLlmBackend {
 				const data = event.data;
 				if (data === "[DONE]") {
 					receivedDone = true;
-					streamLogger.onCriticalEvent(eventCount, "[DONE]", `accumulated text length: ${accumulatedText.length}`);
-					const cleanedText = stripThinkingBlocks$1(accumulatedText);
-					streamLogger.streamComplete(accumulatedText);
-					if (toolsUsed.length > 0) {
-						const info = {
-							toolsUsed,
-							thinking: thinkingBlocks.length > 0 ? thinkingBlocks : void 0,
-							...lastUsageInfo
-						};
-						logger.debug(`[ServerLlmBackend] Calling callback with tools, thinking blocks: ${thinkingBlocks.length}`);
-						callback([cleanedText], info).catch((err) => {
-							logger.error("[ServerLlmBackend] Callback error:", err);
-							reject(err);
-						}).then(() => {
-							logger.debug("[ServerLlmBackend] Callback completed, resolving");
-							resolve();
-						});
-					} else if (cleanedText) callback([cleanedText], lastUsageInfo).catch((err) => {
+					streamLogger.onCriticalEvent(eventCount, "[DONE]", `accumulated text length: ${accumulator.accumulatedLength}`);
+					streamLogger.streamComplete(accumulator.rawText);
+					accumulator.finalize(callback).catch((err) => {
 						logger.error("[ServerLlmBackend] Callback error:", err);
 						reject(err);
-					}).then(() => resolve());
-					else resolve();
+					}).then(() => {
+						logger.debug("[ServerLlmBackend] Callback completed, resolving");
+						resolve();
+					});
 					return;
 				}
 				try {
@@ -18355,9 +18412,8 @@ var ServerLlmBackend = class ServerLlmBackend {
 					}
 					if (parsed.type === "content") {
 						const textChunk = parsed.text || "";
-						accumulatedText += textChunk;
-						if (parsed.usage || parsed.credits) lastUsageInfo = extractUsageInfo(parsed);
-						streamLogger.onContent(eventCount, textChunk, accumulatedText);
+						accumulator.onContent(textChunk, parsed.usage, parsed.credits);
+						streamLogger.onContent(eventCount, textChunk, accumulator.rawText);
 					} else if (parsed.type === "tool_use") {
 						streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${parsed.tools?.length}`);
 						if (parsed.tools && parsed.tools.length > 0) for (const tool of parsed.tools) {
@@ -18369,14 +18425,8 @@ var ServerLlmBackend = class ServerLlmBackend {
 								logger.debug(`  Params: [Unable to stringify]`);
 							}
 						}
-						const textChunk = parsed.text || "";
-						if (textChunk) accumulatedText += textChunk;
-						if (parsed.tools && parsed.tools.length > 0) toolsUsed = parsed.tools;
-						if (parsed.thinking && parsed.thinking.length > 0) {
-							thinkingBlocks = parsed.thinking;
-							streamLogger.onCriticalEvent(eventCount, "THINKING", `${thinkingBlocks.length} thinking blocks`);
-						}
-						if (parsed.usage || parsed.credits) lastUsageInfo = extractUsageInfo(parsed);
+						accumulator.onToolUse(parsed.text || "", parsed.tools, parsed.thinking, parsed.usage, parsed.credits);
+						if (parsed.thinking && parsed.thinking.length > 0) streamLogger.onCriticalEvent(eventCount, "THINKING", `${parsed.thinking.length} thinking blocks`);
 					}
 				} catch (parseError) {
 					streamLogger.streamError(parseError);
@@ -18403,20 +18453,10 @@ var ServerLlmBackend = class ServerLlmBackend {
 			});
 			response.data.on("end", () => {
 				if (!receivedDone) {
-					const hasAccumulatedData = accumulatedText.trim().length > 0 || toolsUsed.length > 0;
-					logger.warn(`[ServerLlmBackend] Stream ended without [DONE] signal. Accumulated text: ${accumulatedText.length} chars, tools: ${toolsUsed.length}`);
-					if (hasAccumulatedData) {
-						const cleanedText = stripThinkingBlocks$1(accumulatedText);
-						streamLogger.streamComplete(accumulatedText);
-						if (toolsUsed.length > 0) {
-							const info = {
-								toolsUsed,
-								thinking: thinkingBlocks.length > 0 ? thinkingBlocks : void 0,
-								...lastUsageInfo
-							};
-							callback([cleanedText], info).then(() => resolve(), reject);
-						} else if (cleanedText) callback([cleanedText], lastUsageInfo).then(() => resolve(), reject);
-						else resolve();
+					logger.warn(`[ServerLlmBackend] Stream ended without [DONE] signal. Accumulated text: ${accumulator.accumulatedLength} chars, tools: ${accumulator.toolCount}`);
+					if (!accumulator.isEmpty()) {
+						streamLogger.streamComplete(accumulator.rawText);
+						accumulator.finalize(callback).then(() => resolve(), reject);
 					} else reject(/* @__PURE__ */ new Error("Stream ended prematurely without receiving any data. The server may be experiencing issues."));
 				} else logger.debug("[ServerLlmBackend] Stream ended, [DONE] handler will resolve");
 			});
@@ -18537,9 +18577,6 @@ var ServerLlmBackend = class ServerLlmBackend {
 };
 //#endregion
 //#region src/llm/WebSocketLlmBackend.ts
-function stripThinkingBlocks(text) {
-	return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
-}
 /**
 * Hybrid HTTP + WebSocket LLM backend for CLI completions.
 *
@@ -18573,10 +18610,7 @@ var WebSocketLlmBackend = class {
 			const streamLogger = new StreamLogger(logger, "WebSocketLlmBackend", process.env.B4M_VERBOSE === "1", process.env.B4M_DEBUG_STREAM === "1");
 			streamLogger.streamStart();
 			let eventCount = 0;
-			let accumulatedText = "";
-			let lastUsageInfo = {};
-			let toolsUsed = [];
-			let thinkingBlocks = [];
+			const accumulator = new StreamAccumulator();
 			let settled = false;
 			const settle = (action) => {
 				if (settled) return;
@@ -18604,12 +18638,6 @@ var WebSocketLlmBackend = class {
 				}
 				options.abortSignal.addEventListener("abort", abortHandler, { once: true });
 			}
-			const updateUsage = (usage) => {
-				if (usage) lastUsageInfo = {
-					inputTokens: usage.inputTokens,
-					outputTokens: usage.outputTokens
-				};
-			};
 			this.wsManager.onRequest(requestId, (message) => {
 				if (options.abortSignal?.aborted) return;
 				const action = message.action;
@@ -18617,28 +18645,20 @@ var WebSocketLlmBackend = class {
 					eventCount++;
 					const chunk = message.chunk;
 					streamLogger.onEvent(eventCount, JSON.stringify(chunk));
-					const textChunk = chunk.text || "";
-					if (textChunk) accumulatedText += textChunk;
-					updateUsage(chunk.usage);
-					if (chunk.type === "content") streamLogger.onContent(eventCount, textChunk, accumulatedText);
-					else if (chunk.type === "tool_use") {
+					if (chunk.type === "content") {
+						accumulator.onContent(chunk.text || "", chunk.usage);
+						streamLogger.onContent(eventCount, chunk.text || "", accumulator.rawText);
+					} else if (chunk.type === "tool_use") {
 						streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${chunk.tools?.length}`);
-						if (chunk.tools && chunk.tools.length > 0) toolsUsed = chunk.tools;
-						if (chunk.thinking && chunk.thinking.length > 0) thinkingBlocks = chunk.thinking;
+						accumulator.onToolUse(chunk.text || "", chunk.tools, chunk.thinking, chunk.usage);
 					}
 				} else if (action === "cli_completion_done") {
-					streamLogger.streamComplete(accumulatedText);
-					const cleanedText = stripThinkingBlocks(accumulatedText);
-					if (!cleanedText && toolsUsed.length === 0) {
+					streamLogger.streamComplete(accumulator.rawText);
+					if (accumulator.isEmpty()) {
 						settleResolve();
 						return;
 					}
-					const info = {
-						...lastUsageInfo,
-						...toolsUsed.length > 0 && { toolsUsed },
-						...thinkingBlocks.length > 0 && { thinking: thinkingBlocks }
-					};
-					callback([cleanedText], info).then(() => settleResolve()).catch((err) => settleReject(err));
+					accumulator.finalize(callback).then(() => settleResolve()).catch((err) => settleReject(err));
 				} else if (action === "cli_completion_error") {
 					const errorMsg = message.error || "Server error";
 					streamLogger.onCriticalEvent(eventCount, "ERROR", errorMsg);
@@ -18739,6 +18759,65 @@ var WebSocketLlmBackend = class {
 	}
 };
 //#endregion
+//#region src/llm/FallbackLlmBackend.ts
+/**
+* LLM backend decorator that provides model-level fallback routing.
+*
+* When the primary model fails (after the inner backend's own retries are exhausted),
+* FallbackLlmBackend tries the next model in the configured fallback chain.
+*
+* Example chain: Opus → Sonnet → Haiku (graceful degradation under rate limits)
+*
+* Configured via `CliConfig.fallbackModels`. Wraps any `ICompletionBackend`,
+* fitting cleanly into the existing decorator pattern (NotifyingLlmBackend, etc.).
+*/
+var FallbackLlmBackend = class {
+	constructor(inner, fallbackModels, onFallback) {
+		this.inner = inner;
+		this.fallbackModels = fallbackModels;
+		this.onFallback = onFallback;
+	}
+	get currentModel() {
+		return this.inner.currentModel;
+	}
+	set currentModel(model) {
+		this.inner.currentModel = model;
+	}
+	async complete(model, messages, options, callback) {
+		if (options.abortSignal?.aborted) return this.inner.complete(model, messages, options, callback);
+		const modelsToTry = [model, ...this.fallbackModels.filter((m) => m !== model)];
+		let callbackInvoked = false;
+		const guardedCallback = async (text, completionInfo) => {
+			callbackInvoked = true;
+			return callback(text, completionInfo);
+		};
+		let lastError;
+		for (let i = 0; i < modelsToTry.length; i++) {
+			const modelToTry = modelsToTry[i];
+			try {
+				await this.inner.complete(modelToTry, messages, options, guardedCallback);
+				return;
+			} catch (error) {
+				if (options.abortSignal?.aborted) throw error;
+				if (callbackInvoked) throw error;
+				lastError = error instanceof Error ? error : new Error(String(error));
+				const nextModel = modelsToTry[i + 1];
+				if (nextModel) {
+					logger.warn(`[FallbackLlmBackend] Model "${modelToTry}" failed: ${lastError.message}`);
+					this.onFallback(modelToTry, nextModel, lastError);
+				}
+			}
+		}
+		throw lastError ?? /* @__PURE__ */ new Error("All fallback models exhausted");
+	}
+	pushToolMessages(messages, tool, result, thinkingBlocks) {
+		this.inner.pushToolMessages(messages, tool, result, thinkingBlocks);
+	}
+	async getModelInfo() {
+		return this.inner.getModelInfo();
+	}
+};
+//#endregion
 //#region src/ws/WebSocketConnectionManager.ts
 const useWsPolyfill = typeof globalThis.WebSocket === "undefined";
 const WS = useWsPolyfill ? WsWebSocket : globalThis.WebSocket;
@@ -19423,7 +19502,7 @@ var SubagentOrchestrator = class {
 	* @returns Agent result with summary
 	*/
 	async delegateToAgent(options) {
-		const { task, agentName, thoroughness, variables, parentSessionId, model, allowedTools } = options;
+		const { task, agentName, thoroughness, variables, parentSessionId, model, allowedTools, abortSignal } = options;
 		let agentDef;
 		if (options.agentDefinition) agentDef = {
 			...options.agentDefinition,
@@ -19498,11 +19577,22 @@ var SubagentOrchestrator = class {
 		const startTime = Date.now();
 		let result;
 		try {
-			result = await agent.run(task, {
+			const { result: agentResult, attempts } = await withRetry(() => agent.run(task, {
 				maxIterations,
 				parallelExecution: this.deps.enableParallelToolExecution === true,
 				isReadOnlyTool
+			}), {
+				maxRetries: agentDef.retry.maxRetries,
+				initialDelayMs: agentDef.retry.initialDelayMs,
+				isRetryable: isRetryableError,
+				abortSignal,
+				logger: {
+					info: (msg, meta) => this.deps.logger.info(`[${agentName}] ${msg}`, meta),
+					warn: (msg, meta) => this.deps.logger.warn(`[${agentName}] ${msg}`, meta)
+				}
 			});
+			if (attempts > 0) this.deps.logger.info(`[${agentName}] Recovered after ${attempts} retry attempt${attempts === 1 ? "" : "s"}`);
+			result = agentResult;
 		} catch (error) {
 			if (error instanceof HookBlockedError) {
 				if (this.afterRunCallback) this.afterRunCallback(agent, agentName);
@@ -19844,7 +19934,11 @@ var AgentStore = class {
 			hooks: parsed.hooks,
 			source,
 			filePath,
-			modelResolved: resolution.resolved
+			modelResolved: resolution.resolved,
+			retry: {
+				maxRetries: parsed.retry?.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
+				initialDelayMs: parsed.retry?.initialDelay ?? DEFAULT_RETRY_CONFIG.initialDelayMs
+			}
 		};
 	}
 	/**
@@ -20297,7 +20391,10 @@ var BackgroundAgentManager = class {
 		this.runningCount++;
 		this.updateJob(internal.job.id, { status: "running" });
 		const { job, options } = internal;
-		internal.promise = this.orchestrator.delegateToAgent(options).then((result) => {
+		internal.promise = this.orchestrator.delegateToAgent({
+			...options,
+			abortSignal: internal.abortController.signal
+		}).then((result) => {
 			this.updateJob(job.id, {
 				status: "completed",
 				endTime: Date.now(),
@@ -20920,4 +21017,4 @@ function createGetFileStructureTool() {
 	};
 }
 //#endregion
-export { clearFeatureModuleTools as A, CommandHistoryStore as B, getEnvironmentName as C, DEFAULT_AGENT_MODEL as D, ALWAYS_DENIED_FOR_AGENTS as E, buildSkillsPromptSection as F, searchCommands as G, OAuthClient as H, isReadOnlyTool as I, searchFiles as J, mergeCommands as K, ReActAgent as L, setWebSocketToolExecutor as M, OllamaBackend as N, DEFAULT_MAX_ITERATIONS as O, buildCoreSystemPrompt as P, CustomCommandStore as R, getApiUrl as S, generateCliTools as T, hasFileReferences as U, SessionStore as V, processFileReferences as W, warmFileCache as Y, McpManager as _, createBackgroundAgentTools as a, extractCompactInstructions as b, AgentStore as c, parseAgentConfig as d, ApiClient as f, ServerLlmBackend as g, WebSocketLlmBackend as h, createWriteTodosTool as i, registerFeatureModuleTools as j, DEFAULT_THOROUGHNESS as k, SubagentOrchestrator as l, WebSocketConnectionManager as m, createFindDefinitionTool as n, BackgroundAgentManager as o, WebSocketToolExecutor as p, formatFileSize$1 as q, createTodoStore as r, createAgentDelegateTool as s, createGetFileStructureTool as t, createSkillTool as u, substituteArguments as v, PermissionManager as w, loadContextFiles as x, formatStep as y, CheckpointStore as z };
+export { DEFAULT_RETRY_CONFIG as A, CustomCommandStore as B, getApiUrl as C, ALWAYS_DENIED_FOR_AGENTS as D, generateCliTools as E, OllamaBackend as F, hasFileReferences as G, CommandHistoryStore as H, buildCoreSystemPrompt as I, mergeCommands as J, processFileReferences as K, buildSkillsPromptSection as L, clearFeatureModuleTools as M, registerFeatureModuleTools as N, DEFAULT_AGENT_MODEL as O, setWebSocketToolExecutor as P, isReadOnlyTool as R, loadContextFiles as S, PermissionManager as T, SessionStore as U, CheckpointStore as V, OAuthClient as W, searchFiles as X, formatFileSize$1 as Y, warmFileCache as Z, ServerLlmBackend as _, createBackgroundAgentTools as a, formatStep as b, AgentStore as c, parseAgentConfig as d, ApiClient as f, WebSocketLlmBackend as g, FallbackLlmBackend as h, createWriteTodosTool as i, DEFAULT_THOROUGHNESS as j, DEFAULT_MAX_ITERATIONS as k, SubagentOrchestrator as l, WebSocketConnectionManager as m, createFindDefinitionTool as n, BackgroundAgentManager as o, WebSocketToolExecutor as p, searchCommands as q, createTodoStore as r, createAgentDelegateTool as s, createGetFileStructureTool as t, createSkillTool as u, McpManager as v, getEnvironmentName as w, extractCompactInstructions as x, substituteArguments as y, ReActAgent as z };

package/dist/{updateChecker-bL3tE6X7.mjs → updateChecker-Cxb7mnxO.mjs}

@@ -4,7 +4,7 @@ import { homedir } from "os";
 import path from "path";
 import axios from "axios";
 //#region package.json
-var version = "0.2.71-fix-opti-hashi-data-lake-explorer.22040+12bd59509";
+var version = "0.2.71";
 //#endregion
 //#region src/utils/updateChecker.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bike4mind/cli",
-  "version": "0.2.71-fix-opti-hashi-data-lake-explorer.22040+12bd59509",
+  "version": "0.2.71",
   "type": "module",
   "description": "Interactive CLI tool for Bike4Mind with ReAct agents",
   "license": "UNLICENSED",
@@ -115,11 +115,11 @@
     "zustand": "^4.5.4"
   },
   "devDependencies": {
-    "@bike4mind/agents": "0.4.8-fix-opti-hashi-data-lake-explorer.22040+12bd59509",
-    "@bike4mind/common": "2.78.1-fix-opti-hashi-data-lake-explorer.22040+12bd59509",
-    "@bike4mind/mcp": "1.33.27-fix-opti-hashi-data-lake-explorer.22040+12bd59509",
-    "@bike4mind/services": "2.71.2-fix-opti-hashi-data-lake-explorer.22040+12bd59509",
-    "@bike4mind/utils": "2.16.9-fix-opti-hashi-data-lake-explorer.22040+12bd59509",
+    "@bike4mind/agents": "0.4.8",
+    "@bike4mind/common": "2.79.0",
+    "@bike4mind/mcp": "1.33.27",
+    "@bike4mind/services": "2.72.0",
+    "@bike4mind/utils": "2.16.9",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -136,5 +136,5 @@
   "optionalDependencies": {
     "@vscode/ripgrep": "^1.17.1"
   },
-  "gitHead": "12bd59509be441d15195d7abbb0079298356065d"
+  "gitHead": "1d7b05a3d32a0bda3e9b32aab784a26775eab784"
 }