@bike4mind/cli 0.2.13 → 0.2.14-feat-cli-mcp-management.17477

package/dist/index.js

@@ -4,22 +4,24 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-3MT5HI3G.js";
-import "./chunk-PMY7IPOC.js";
-import "./chunk-K44CDTQN.js";
+} from "./chunk-SKGB6N3S.js";
+import {
+  ConfigStore
+} from "./chunk-FFJX3FF3.js";
+import "./chunk-TOMWAKIL.js";
+import "./chunk-B6HTF2IE.js";
 import {
   BFLImageService,
   BaseStorage,
   GeminiImageService,
+  MAX_DESCRIPTION_LENGTH,
+  MAX_GOAL_LENGTH,
+  MAX_TAG_LENGTH,
   NotFoundError,
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-SZXO7HOF.js";
-import {
-  Logger
-} from "./chunk-OCYRD7D6.js";
-import "./chunk-BPFEGDC7.js";
+} from "./chunk-GFL7CMSL.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -74,16 +76,20 @@ import {
   b4mLLMTools,
   getMcpProviderMetadata
 } from "./chunk-A7POWM75.js";
+import {
+  Logger
+} from "./chunk-OCYRD7D6.js";
+import "./chunk-BPFEGDC7.js";
 
 // src/index.tsx
-import React17, { useState as useState8, useEffect as useEffect3, useCallback, useRef as useRef2 } from "react";
-import { render, Box as Box16, Text as Text16, useApp, useInput as useInput6 } from "ink";
+import React18, { useState as useState8, useEffect as useEffect3, useCallback, useRef as useRef2 } from "react";
+import { render, Box as Box17, Text as Text17, useApp, useInput as useInput8 } from "ink";
 import { execSync } from "child_process";
-import { v4 as uuidv410 } from "uuid";
+import { v4 as uuidv49 } from "uuid";
 
 // src/components/App.tsx
-import React11, { useState as useState4 } from "react";
-import { Box as Box10, Text as Text10, Static } from "ink";
+import React12, { useState as useState4 } from "react";
+import { Box as Box11, Text as Text11, Static, useInput as useInput5 } from "ink";
 
 // src/components/StatusBar.tsx
 import React from "react";
@@ -511,6 +517,11 @@ var COMMANDS = [
   {
     name: "commands:reload",
     description: "Reload custom commands from disk"
+  },
+  {
+    name: "mcp",
+    description: "Show MCP server status and connected tools",
+    aliases: ["mcp:list"]
   }
 ];
 function getAllCommandNames() {
@@ -1056,6 +1067,9 @@ var useCliStore = create((set) => ({
   // Config editor
   showConfigEditor: false,
   setShowConfigEditor: (show) => set({ showConfigEditor: show }),
+  // MCP viewer
+  showMcpViewer: false,
+  setShowMcpViewer: (show) => set({ showMcpViewer: show }),
   // Exit handling
   exitRequested: false,
   setExitRequested: (requested) => set({ exitRequested: requested })
@@ -1342,24 +1356,84 @@ function ConfigEditor({ config, availableModels, onSave, onClose }) {
   })), /* @__PURE__ */ React9.createElement(Box8, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "\u2191/\u2193: Navigate | Space/\u2190/\u2192: Change | q/Esc: Save & Exit")));
 }
 
-// src/components/MessageItem.tsx
+// src/components/McpViewer.tsx
 import React10 from "react";
-import { Box as Box9, Text as Text9 } from "ink";
+import { Box as Box9, Text as Text9, useInput as useInput4 } from "ink";
+function McpViewer({ config, mcpManager, onClose }) {
+  useInput4((input, key) => {
+    if (key.escape || input === "q") {
+      onClose();
+    }
+  });
+  if (config.mcpServers.length === 0) {
+    return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React10.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "cyan" }, "\u{1F4E1} MCP Server Status")), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "No MCP servers configured."), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "To add MCP servers, edit your config file:")), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Global: ~/.bike4mind/config.json"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Project: .bike4mind/config.json"), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 2 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true, italic: true }, "Press Esc or q to close")));
+  }
+  const enabledServers = config.mcpServers.filter((s) => s.enabled);
+  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React10.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "cyan" }, "\u{1F4E1} MCP Server Status")), /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", marginBottom: 2 }, /* @__PURE__ */ React10.createElement(Text9, { bold: true, dimColor: true }, "Configured Servers:"), config.mcpServers.map((server) => {
+    const status = server.enabled ? "\u2705 Enabled" : "\u23F8\uFE0F  Disabled";
+    const commandInfo = server.command ? `${server.command} ${(server.args || []).join(" ")}` : "(internal)";
+    return /* @__PURE__ */ React10.createElement(Box9, { key: server.name, flexDirection: "column", marginTop: 1, marginLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, null, "\u2022 ", /* @__PURE__ */ React10.createElement(Text9, { bold: true }, server.name), " - ", /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, status)), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Command: ", commandInfo), Object.keys(server.env).length > 0 && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Env vars: ", Object.keys(server.env).join(", ")));
+  })), enabledServers.length > 0 && mcpManager && /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", marginBottom: 2 }, /* @__PURE__ */ React10.createElement(Text9, { bold: true, dimColor: true }, "Connection Status:"), enabledServers.map((server) => {
+    const state = mcpManager.getConnectionState(server.name);
+    let icon;
+    let statusText;
+    let color;
+    switch (state) {
+      case "connected":
+        icon = "\u2714";
+        statusText = "connected";
+        color = "green";
+        break;
+      case "connecting":
+        icon = "\u25EF";
+        statusText = "connecting\u2026";
+        color = "yellow";
+        break;
+      case "failed":
+        icon = "\u2717";
+        statusText = "failed";
+        color = "red";
+        break;
+      default:
+        icon = "\u25EF";
+        statusText = "connecting\u2026";
+        color = "gray";
+    }
+    const toolCounts = mcpManager.getToolCount();
+    const serverTools = toolCounts.find((t) => t.serverName === server.name);
+    const toolCount = serverTools?.count || 0;
+    const toolInfo = state === "connected" && toolCount > 0 ? ` (${toolCount} tool${toolCount === 1 ? "" : "s"})` : "";
+    return /* @__PURE__ */ React10.createElement(Box9, { key: server.name, marginTop: 1, marginLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, null, "\u2022 ", /* @__PURE__ */ React10.createElement(Text9, { bold: true }, server.name), " \xB7 ", /* @__PURE__ */ React10.createElement(Text9, { color }, icon), " ", /* @__PURE__ */ React10.createElement(Text9, { color }, statusText), toolInfo && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, toolInfo)));
+  }), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, marginLeft: 2 }, (() => {
+    const toolCounts = mcpManager.getToolCount();
+    const totalTools = toolCounts.reduce((sum2, s) => sum2 + s.count, 0);
+    if (totalTools > 0) {
+      return /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "green" }, "Total: ", totalTools, " MCP tool", totalTools === 1 ? "" : "s", " available");
+    } else {
+      return /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "No MCP tools available yet (servers still connecting)");
+    }
+  })())), enabledServers.length === 0 && /* @__PURE__ */ React10.createElement(Box9, { marginBottom: 2 }, /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u26A0\uFE0F No MCP servers enabled"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Use `b4m mcp enable <name>` to enable a server")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true, italic: true }, "Press Esc or q to close")));
+}
+
+// src/components/MessageItem.tsx
+import React11 from "react";
+import { Box as Box10, Text as Text10 } from "ink";
 function MessageItem({ message }) {
   const isUser = message.role === "user";
-  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: isUser ? "cyan" : "green" }, isUser ? "\u{1F464} You" : "\u{1F916} Assistant"), isUser && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), isUser && message.content && /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, { backgroundColor: "whiteBright", color: "black" }, " ", message.content, " ")), !isUser && message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " ", "tools used, ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+  const isSystem = message.role === "system";
+  return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { bold: true, color: isUser ? "cyan" : isSystem ? "gray" : "green" }, isUser ? "\u{1F464} You" : isSystem ? "\u2139\uFE0F  System" : "\u{1F916} Assistant"), isUser && /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), isUser && message.content && /* @__PURE__ */ React11.createElement(Box10, { paddingLeft: 2 }, /* @__PURE__ */ React11.createElement(Text10, { backgroundColor: "whiteBright", color: "black" }, " ", message.content, " ")), !isUser && message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React11.createElement(Box10, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " ", "tools used, ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
     if (step.type === "thought") {
-      return /* @__PURE__ */ React10.createElement(Box9, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `   ${step.content}`));
+      return /* @__PURE__ */ React11.createElement(Box10, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React11.createElement(Text10, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, `   ${step.content}`));
     }
     if (step.type === "action") {
       const toolName = step.metadata?.toolName || "unknown";
       const toolInput = step.metadata?.toolInput;
       const observationStep = message.metadata.steps[idx + 1];
       const result = observationStep?.type === "observation" ? observationStep.content : null;
-      return /* @__PURE__ */ React10.createElement(Box9, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
+      return /* @__PURE__ */ React11.createElement(Box10, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
     }
     return null;
-  }).filter(Boolean)), !isUser && message.content !== "..." && /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2, marginTop: message.metadata?.steps?.length ? 1 : 0 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React10.createElement(Text9, null, message.content)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
+  }).filter(Boolean)), !isUser && message.content !== "..." && /* @__PURE__ */ React11.createElement(Box10, { paddingLeft: 2, marginTop: message.metadata?.steps?.length ? 1 : 0 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React11.createElement(Text10, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React11.createElement(Text10, null, message.content)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React11.createElement(Box10, { paddingLeft: 2 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
 }
 
 // src/utils/processFileReferences.ts
@@ -1489,7 +1563,10 @@ function App({
   availableModels = [],
   onSaveConfig,
   prefillInput,
-  onPrefillConsumed
+  onPrefillConsumed,
+  commandOutput,
+  onCommandOutputDismiss,
+  mcpManager
 }) {
   const messages = useCliStore((state) => state.session?.messages || []);
   const pendingMessages = useCliStore((state) => state.pendingMessages);
@@ -1500,13 +1577,23 @@ function App({
   const permissionPrompt = useCliStore((state) => state.permissionPrompt);
   const showConfigEditor = useCliStore((state) => state.showConfigEditor);
   const setShowConfigEditor = useCliStore((state) => state.setShowConfigEditor);
+  const showMcpViewer = useCliStore((state) => state.showMcpViewer);
+  const setShowMcpViewer = useCliStore((state) => state.setShowMcpViewer);
   const exitRequested = useCliStore((state) => state.exitRequested);
   const setIsThinking = useCliStore((state) => state.setIsThinking);
   const [isBashMode, setIsBashMode] = useState4(false);
-  const handleSubmit = React11.useCallback(
+  useInput5((input, key) => {
+    if (key.escape && commandOutput && onCommandOutputDismiss) {
+      onCommandOutputDismiss();
+    }
+  });
+  const handleSubmit = React12.useCallback(
     async (input) => {
       const trimmed = input.trim();
       if (!trimmed) return;
+      if (commandOutput && onCommandOutputDismiss) {
+        onCommandOutputDismiss();
+      }
       if (trimmed.startsWith("/") && !trimmed.match(/^\/[A-Z]/)) {
         const [command, ...args] = trimmed.slice(1).split(" ");
         await onCommand(command, args);
@@ -1530,9 +1617,9 @@ ${errorBlock}`;
         setIsThinking(false);
       }
     },
-    [onMessage, onCommand, setIsThinking]
+    [onMessage, onCommand, setIsThinking, commandOutput, onCommandOutputDismiss]
   );
-  return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column" }, showConfigEditor && config && onSaveConfig ? /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(
+  return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column" }, showConfigEditor && config && onSaveConfig ? /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React12.createElement(
     ConfigEditor,
     {
       config,
@@ -1540,7 +1627,10 @@ ${errorBlock}`;
       onSave: onSaveConfig,
       onClose: () => setShowConfigEditor(false)
     }
-  )) : /* @__PURE__ */ React11.createElement(React11.Fragment, null, /* @__PURE__ */ React11.createElement(Static, { items: messages }, (message) => /* @__PURE__ */ React11.createElement(Box10, { key: message.id, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(MessageItem, { message }))), /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column" }, pendingMessages.map((message) => /* @__PURE__ */ React11.createElement(Box10, { key: message.id, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(MessageItem, { message })))), permissionPrompt && /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(
+  )) : showMcpViewer && config ? (
+    /* MCP Viewer - full screen takeover */
+    /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React12.createElement(McpViewer, { config, mcpManager, onClose: () => setShowMcpViewer(false) }))
+  ) : /* @__PURE__ */ React12.createElement(React12.Fragment, null, /* @__PURE__ */ React12.createElement(Static, { items: messages }, (message) => /* @__PURE__ */ React12.createElement(Box11, { key: message.id, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React12.createElement(MessageItem, { message }))), /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column" }, pendingMessages.map((message) => /* @__PURE__ */ React12.createElement(Box11, { key: message.id, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React12.createElement(MessageItem, { message })))), permissionPrompt && /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React12.createElement(
     PermissionPrompt,
     {
       toolName: permissionPrompt.toolName,
@@ -1549,7 +1639,7 @@ ${errorBlock}`;
       canBeTrusted: permissionPrompt.canBeTrusted,
       onResponse: onPermissionResponse
     }
-  )), !permissionPrompt && /* @__PURE__ */ React11.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React11.createElement(Box10, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), /* @__PURE__ */ React11.createElement(Box10, { borderStyle: "single", borderColor: isBashMode ? "yellow" : "cyan", paddingX: 1 }, /* @__PURE__ */ React11.createElement(
+  )), !permissionPrompt && /* @__PURE__ */ React12.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React12.createElement(Box11, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), commandOutput && /* @__PURE__ */ React12.createElement(Box11, { paddingX: 1, marginBottom: 1, flexDirection: "column", borderStyle: "round", borderColor: "gray" }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, commandOutput), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true, italic: true }, "Press Esc to dismiss")), /* @__PURE__ */ React12.createElement(Box11, { borderStyle: "single", borderColor: isBashMode ? "yellow" : "cyan", paddingX: 1 }, /* @__PURE__ */ React12.createElement(
     InputPrompt,
     {
       onSubmit: handleSubmit,
@@ -1562,24 +1652,24 @@ ${errorBlock}`;
       onPrefillConsumed,
       onBashModeChange: setIsBashMode
     }
-  )), /* @__PURE__ */ React11.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens })));
+  )), /* @__PURE__ */ React12.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens })));
 }
 
 // src/components/MessageList.tsx
-import React12 from "react";
-import { Box as Box11, Text as Text11 } from "ink";
+import React13 from "react";
+import { Box as Box12, Text as Text12 } from "ink";
 function stripThinkingTags(content) {
   return content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
-var MessageList = React12.memo(
+var MessageList = React13.memo(
   function MessageList2({ messages }) {
     if (messages.length === 0) {
-      return /* @__PURE__ */ React12.createElement(Box11, { paddingY: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "No messages yet. Type a message to start!"));
+      return /* @__PURE__ */ React13.createElement(Box12, { paddingY: 1 }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "No messages yet. Type a message to start!"));
     }
-    return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React12.createElement(Box11, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React12.createElement(Box11, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React12.createElement(Text11, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React12.createElement(Box11, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " tools used,", " ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+    return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React13.createElement(Box12, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React13.createElement(Box12, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React13.createElement(Text12, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React13.createElement(Text12, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React13.createElement(Box12, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " tools used,", " ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
       if (step.type === "thought") {
-        return /* @__PURE__ */ React12.createElement(Box11, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React12.createElement(Text11, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React12.createElement(
-          Text11,
+        return /* @__PURE__ */ React13.createElement(Box12, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React13.createElement(Text12, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React13.createElement(
+          Text12,
           {
             dimColor: true
           },
@@ -1591,10 +1681,10 @@ var MessageList = React12.memo(
         const toolInput = step.metadata?.toolInput;
         const observationStep = message.metadata.steps[idx + 1];
         const result = observationStep?.type === "observation" ? observationStep.content : null;
-        return /* @__PURE__ */ React12.createElement(Box11, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
+        return /* @__PURE__ */ React13.createElement(Box12, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React13.createElement(Text12, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
       }
       return null;
-    }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React12.createElement(Box11, { paddingLeft: 2 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
+    }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React13.createElement(Box12, { paddingLeft: 2 }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
   },
   (prevProps, nextProps) => {
     if (prevProps.messages.length !== nextProps.messages.length) {
@@ -1605,8 +1695,8 @@ var MessageList = React12.memo(
 );
 
 // src/components/TrustLocationSelector.tsx
-import React13 from "react";
-import { Box as Box12, Text as Text12 } from "ink";
+import React14 from "react";
+import { Box as Box13, Text as Text13 } from "ink";
 import SelectInput2 from "ink-select-input";
 function TrustLocationSelector({ inProject, onSelect, onCancel }) {
   const items = [];
@@ -1627,24 +1717,24 @@ function TrustLocationSelector({ inProject, onSelect, onCancel }) {
   const handleSelect = (item) => {
     onSelect(item.value);
   };
-  return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React13.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, { bold: true }, "Where should this rule be saved?")), /* @__PURE__ */ React13.createElement(
+  return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React14.createElement(Box13, { marginBottom: 1 }, /* @__PURE__ */ React14.createElement(Text13, { bold: true }, "Where should this rule be saved?")), /* @__PURE__ */ React14.createElement(
     SelectInput2,
     {
       items,
       onSelect: handleSelect,
-      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
     }
-  ), /* @__PURE__ */ React13.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Ctrl+C to cancel")));
+  ), /* @__PURE__ */ React14.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Ctrl+C to cancel")));
 }
 
 // src/components/RewindSelector.tsx
-import React14, { useState as useState5 } from "react";
-import { Box as Box13, Text as Text13, useInput as useInput4 } from "ink";
+import React15, { useState as useState5 } from "react";
+import { Box as Box14, Text as Text14, useInput as useInput6 } from "ink";
 import SelectInput3 from "ink-select-input";
 function RewindSelector({ messages, onSelect, onCancel }) {
   const [step, setStep] = useState5("selection");
   const [selectedMessageIndex, setSelectedMessageIndex] = useState5(null);
-  useInput4((input, key) => {
+  useInput6((input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
         setStep("selection");
@@ -1681,14 +1771,14 @@ function RewindSelector({ messages, onSelect, onCancel }) {
     return sum2 + (msg.metadata?.tokenUsage?.total || 0);
   }, 0);
   if (step === "selection") {
-    return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React14.createElement(Box13, { marginBottom: 1 }, /* @__PURE__ */ React14.createElement(Text13, { bold: true }, "Select a point to rewind to:")), /* @__PURE__ */ React14.createElement(
+    return /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React15.createElement(Box14, { marginBottom: 1 }, /* @__PURE__ */ React15.createElement(Text14, { bold: true }, "Select a point to rewind to:")), /* @__PURE__ */ React15.createElement(
       SelectInput3,
       {
         items,
         onSelect: handleSelectionSelect,
-        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React15.createElement(Box14, null, /* @__PURE__ */ React15.createElement(Text14, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
       }
-    ), /* @__PURE__ */ React14.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
+    ), /* @__PURE__ */ React15.createElement(Box14, { marginTop: 1 }, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
   }
   const confirmationItems = [
     { label: "Yes, rewind to this point", value: "confirm" },
@@ -1696,24 +1786,24 @@ function RewindSelector({ messages, onSelect, onCancel }) {
   ];
   const selectedMessage = selectedMessageIndex !== null && selectedMessageIndex >= 0 && selectedMessageIndex < messages.length ? messages[selectedMessageIndex] : null;
   const selectedPreview = selectedMessage ? selectedMessage.content.length > 50 ? selectedMessage.content.substring(0, 50) + "..." : selectedMessage.content : "";
-  return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React14.createElement(Box13, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { bold: true }, "Confirm rewind operation:"), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "Message: ", selectedPreview), /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "This will remove ", messagesToRemove.length, " message(s) (", tokensToRemove.toLocaleString(), " tokens)"), /* @__PURE__ */ React14.createElement(Text13, { color: "cyan" }, "The selected message will be placed in your input for editing.")), /* @__PURE__ */ React14.createElement(
+  return /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React15.createElement(Box14, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React15.createElement(Text14, { bold: true }, "Confirm rewind operation:"), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "Message: ", selectedPreview), /* @__PURE__ */ React15.createElement(Text14, { color: "yellow" }, "This will remove ", messagesToRemove.length, " message(s) (", tokensToRemove.toLocaleString(), " tokens)"), /* @__PURE__ */ React15.createElement(Text14, { color: "cyan" }, "The selected message will be placed in your input for editing.")), /* @__PURE__ */ React15.createElement(
     SelectInput3,
     {
       items: confirmationItems,
       onSelect: handleConfirmationSelect,
-      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React15.createElement(Box14, null, /* @__PURE__ */ React15.createElement(Text14, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
     }
-  ), /* @__PURE__ */ React14.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
+  ), /* @__PURE__ */ React15.createElement(Box14, { marginTop: 1 }, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
 }
 
 // src/components/SessionSelector.tsx
-import React15, { useState as useState6 } from "react";
-import { Box as Box14, Text as Text14, useInput as useInput5 } from "ink";
+import React16, { useState as useState6 } from "react";
+import { Box as Box15, Text as Text15, useInput as useInput7 } from "ink";
 import SelectInput4 from "ink-select-input";
 function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
   const [step, setStep] = useState6("selection");
   const [selectedSession, setSelectedSession] = useState6(null);
-  useInput5((input, key) => {
+  useInput7((input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
         setStep("selection");
@@ -1746,32 +1836,32 @@ function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
     }
   };
   if (step === "selection") {
-    return /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React15.createElement(Box14, { marginBottom: 1 }, /* @__PURE__ */ React15.createElement(Text14, { bold: true }, "Select a session to resume:")), /* @__PURE__ */ React15.createElement(
+    return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1 }, /* @__PURE__ */ React16.createElement(Text15, { bold: true }, "Select a session to resume:")), /* @__PURE__ */ React16.createElement(
       SelectInput4,
       {
         items,
         onSelect: handleSelectionSelect,
-        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React15.createElement(Box14, null, /* @__PURE__ */ React15.createElement(Text14, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
       }
-    ), /* @__PURE__ */ React15.createElement(Box14, { marginTop: 1 }, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
+    ), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
   }
   const confirmationItems = [
     { label: "Yes, resume this session", value: "confirm" },
     { label: "No, go back to selection", value: "cancel" }
   ];
-  return /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React15.createElement(Box14, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React15.createElement(Text14, { bold: true }, 'Resume session: "', selectedSession?.name, '"'), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, selectedSession?.messages.length, " messages | ", selectedSession?.model, " |", " ", selectedSession?.metadata?.totalTokens?.toLocaleString() ?? 0, " tokens"), hasUnsavedWork && /* @__PURE__ */ React15.createElement(Text14, { color: "yellow" }, "Warning: Your current session has unsaved messages. Use /save first if needed.")), /* @__PURE__ */ React15.createElement(
+  return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React16.createElement(Text15, { bold: true }, 'Resume session: "', selectedSession?.name, '"'), /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, selectedSession?.messages.length, " messages | ", selectedSession?.model, " |", " ", selectedSession?.metadata?.totalTokens?.toLocaleString() ?? 0, " tokens"), hasUnsavedWork && /* @__PURE__ */ React16.createElement(Text15, { color: "yellow" }, "Warning: Your current session has unsaved messages. Use /save first if needed.")), /* @__PURE__ */ React16.createElement(
     SelectInput4,
     {
       items: confirmationItems,
       onSelect: handleConfirmationSelect,
-      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React15.createElement(Box14, null, /* @__PURE__ */ React15.createElement(Text14, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
     }
-  ), /* @__PURE__ */ React15.createElement(Box14, { marginTop: 1 }, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
+  ), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
 }
 
 // src/components/LoginFlow.tsx
-import React16, { useState as useState7, useEffect as useEffect2 } from "react";
-import { Box as Box15, Text as Text15 } from "ink";
+import React17, { useState as useState7, useEffect as useEffect2 } from "react";
+import { Box as Box16, Text as Text16 } from "ink";
 import Spinner2 from "ink-spinner";
 import jwt from "jsonwebtoken";
 import open from "open";
@@ -1934,15 +2024,15 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
     }
   }, [deviceFlow, status]);
   if (status === "initiating") {
-    return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { color: "cyan" }, /* @__PURE__ */ React16.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
+    return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React17.createElement(Box16, null, /* @__PURE__ */ React17.createElement(Text16, { color: "cyan" }, /* @__PURE__ */ React17.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
   }
   if (status === "error") {
-    return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1 }, /* @__PURE__ */ React16.createElement(Text15, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { color: "red" }, error)));
+    return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1 }, /* @__PURE__ */ React17.createElement(Text16, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React17.createElement(Box16, null, /* @__PURE__ */ React17.createElement(Text16, { color: "red" }, error)));
   }
   if (status === "success") {
-    return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1 }, /* @__PURE__ */ React16.createElement(Text15, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "You can now use B4M CLI with your account.")));
+    return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1 }, /* @__PURE__ */ React17.createElement(Text16, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React17.createElement(Box16, null, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "You can now use B4M CLI with your account.")));
   }
-  return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1 }, /* @__PURE__ */ React16.createElement(Text15, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1 }, /* @__PURE__ */ React16.createElement(Text15, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React16.createElement(Text15, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1 }, /* @__PURE__ */ React16.createElement(Text15, null, "And enter this code when prompted:")), /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React16.createElement(Text15, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { color: "cyan" }, /* @__PURE__ */ React16.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
+  return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1 }, /* @__PURE__ */ React17.createElement(Text16, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1 }, /* @__PURE__ */ React17.createElement(Text16, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React17.createElement(Text16, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1 }, /* @__PURE__ */ React17.createElement(Text16, null, "And enter this code when prompted:")), /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React17.createElement(Text16, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { color: "cyan" }, /* @__PURE__ */ React17.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
 }
 
 // src/storage/SessionStore.ts
@@ -2078,629 +2168,23 @@ var SessionStore = class {
   }
 };
 
-// src/storage/ConfigStore.ts
-import { promises as fs4, existsSync as existsSync3 } from "fs";
+// src/storage/CommandHistoryStore.ts
+import { promises as fs4 } from "fs";
 import path4 from "path";
 import { homedir as homedir2 } from "os";
-import { v4 as uuidv42 } from "uuid";
-import { z } from "zod";
-var AuthTokensSchema = z.object({
-  accessToken: z.string(),
-  refreshToken: z.string(),
-  expiresAt: z.string(),
-  userId: z.string()
-});
-var ApiConfigSchema = z.object({
-  customUrl: z.string().url().optional()
-});
-var CliConfigSchema = z.object({
-  version: z.string(),
-  userId: z.string(),
-  auth: AuthTokensSchema.optional(),
-  defaultModel: z.string(),
-  apiConfig: ApiConfigSchema.optional(),
-  toolApiKeys: z.object({
-    openweather: z.string().optional(),
-    serper: z.string().optional()
-  }).optional(),
-  mcpServers: z.array(
-    z.object({
-      name: z.string(),
-      command: z.string().optional(),
-      args: z.array(z.string()).optional(),
-      env: z.record(z.string()),
-      enabled: z.boolean()
-    })
-  ),
-  preferences: z.object({
-    maxTokens: z.number(),
-    temperature: z.number(),
-    autoSave: z.boolean(),
-    theme: z.enum(["light", "dark"]),
-    exportFormat: z.enum(["markdown", "json"]),
-    maxIterations: z.number().nullable().default(10)
-  }),
-  tools: z.object({
-    enabled: z.array(z.string()),
-    disabled: z.array(z.string()),
-    config: z.record(z.any())
-  }),
-  trustedTools: z.array(z.string()).optional().default([])
-});
-var ProjectConfigSchema = z.object({
-  tools: z.object({
-    enabled: z.array(z.string()).optional(),
-    denied: z.array(z.string()).optional(),
-    config: z.record(z.any()).optional()
-  }).optional(),
-  defaultModel: z.string().optional(),
-  mcpServers: z.array(
-    z.object({
-      name: z.string(),
-      command: z.string().optional(),
-      args: z.array(z.string()).optional(),
-      env: z.record(z.string()),
-      enabled: z.boolean()
-    })
-  ).optional(),
-  preferences: z.object({
-    maxTokens: z.number().optional(),
-    temperature: z.number().optional(),
-    autoSave: z.boolean().optional(),
-    theme: z.enum(["light", "dark"]).optional(),
-    exportFormat: z.enum(["markdown", "json"]).optional()
-  }).optional()
-});
-var ProjectLocalConfigSchema = z.object({
-  trustedTools: z.array(z.string()).optional(),
-  toolApiKeys: z.object({
-    openweather: z.string().optional(),
-    serper: z.string().optional()
-  }).optional(),
-  preferences: z.object({
-    maxTokens: z.number().optional(),
-    temperature: z.number().optional(),
-    autoSave: z.boolean().optional(),
-    theme: z.enum(["light", "dark"]).optional(),
-    exportFormat: z.enum(["markdown", "json"]).optional()
-  }).optional(),
-  mcpServers: z.array(
-    z.object({
-      name: z.string(),
-      command: z.string().optional(),
-      args: z.array(z.string()).optional(),
-      env: z.record(z.string()),
-      enabled: z.boolean()
-    })
-  ).optional()
-});
-var DEFAULT_CONFIG = {
-  version: "0.1.0",
-  userId: uuidv42(),
-  defaultModel: "claude-sonnet-4-5-20250929",
-  toolApiKeys: {
-    openweather: void 0,
-    serper: void 0
-  },
-  mcpServers: [],
-  preferences: {
-    maxTokens: 4096,
-    temperature: 0.7,
-    autoSave: true,
-    theme: "dark",
-    exportFormat: "markdown",
-    maxIterations: 10
-  },
-  tools: {
-    enabled: [],
-    disabled: ["blog_publish", "blog_edit", "blog_draft"],
-    // Web-only tools
-    config: {}
-  },
-  trustedTools: []
-  // No tools trusted by default
-};
-function findProjectConfigDir(startDir = process.cwd()) {
-  let currentDir = startDir;
-  const { root } = path4.parse(currentDir);
-  while (currentDir !== root) {
-    const gitPath = path4.join(currentDir, ".git");
-    try {
-      if (existsSync3(gitPath)) {
-        return currentDir;
-      }
-    } catch {
-    }
-    currentDir = path4.dirname(currentDir);
-  }
-  return process.cwd();
-}
-async function loadProjectConfig(projectDir) {
-  const configPath = path4.join(projectDir, ".bike4mind", "config.json");
-  try {
-    const data = await fs4.readFile(configPath, "utf-8");
-    const rawConfig = JSON.parse(data);
-    const validated = ProjectConfigSchema.parse(rawConfig);
-    return validated;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    if (error instanceof z.ZodError) {
-      console.error("Project config validation error:", error.errors);
-      return null;
-    }
-    console.error("Failed to load project config:", error);
-    return null;
-  }
-}
-async function loadProjectLocalConfig(projectDir) {
-  const configPath = path4.join(projectDir, ".bike4mind", "local.json");
-  try {
-    const data = await fs4.readFile(configPath, "utf-8");
-    const rawConfig = JSON.parse(data);
-    const validated = ProjectLocalConfigSchema.parse(rawConfig);
-    return validated;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    if (error instanceof z.ZodError) {
-      console.error("Project local config validation error:", error.errors);
-      return null;
-    }
-    console.error("Failed to load project local config:", error);
-    return null;
-  }
-}
-function mergeMcpServers(...serverArrays) {
-  const serverMap = /* @__PURE__ */ new Map();
-  for (const servers of serverArrays) {
-    if (servers) {
-      for (const server of servers) {
-        serverMap.set(server.name, server);
-      }
-    }
-  }
-  return Array.from(serverMap.values());
-}
-function mergeConfigs(global, project, local) {
-  const merged = { ...global };
-  if (project) {
-    if (project.defaultModel) {
-      merged.defaultModel = project.defaultModel;
-    }
-    if (project.preferences) {
-      merged.preferences = {
-        ...merged.preferences,
-        ...project.preferences
-      };
-    }
-    if (project.tools) {
-      merged.tools = {
-        ...merged.tools,
-        enabled: [...merged.tools.enabled || [], ...project.tools.enabled || []],
-        disabled: [...merged.tools.disabled, ...project.tools.denied || []],
-        config: {
-          ...merged.tools.config,
-          ...project.tools.config
-        }
-      };
-    }
-    if (project.mcpServers) {
-      merged.mcpServers = mergeMcpServers(merged.mcpServers, project.mcpServers);
-    }
-  }
-  if (local) {
-    if (local.trustedTools) {
-      const trustedSet = /* @__PURE__ */ new Set([...merged.trustedTools || [], ...local.trustedTools]);
-      merged.trustedTools = Array.from(trustedSet);
-    }
-    if (local.toolApiKeys) {
-      merged.toolApiKeys = {
-        ...merged.toolApiKeys,
-        ...local.toolApiKeys
-      };
-    }
-    if (local.preferences) {
-      merged.preferences = {
-        ...merged.preferences,
-        ...local.preferences
-      };
-    }
-    if (local.mcpServers) {
-      merged.mcpServers = mergeMcpServers(merged.mcpServers, local.mcpServers);
-    }
-  }
-  return merged;
-}
-var ConfigStore = class {
-  constructor(configPath) {
-    this.config = null;
-    this.projectConfigDir = null;
-    this.configPath = configPath || path4.join(homedir2(), ".bike4mind", "config.json");
-  }
-  /**
-   * Initialize config directory
-   */
-  async init() {
-    const dir = path4.dirname(this.configPath);
-    try {
-      await fs4.mkdir(dir, { recursive: true });
-    } catch (error) {
-      console.error("Failed to initialize config directory:", error);
-      throw error;
-    }
-  }
-  /**
-   * Load configuration from disk with Zod validation
-   * Merges global → project → local configs
-   */
-  async load() {
-    if (this.config) {
-      return this.config;
-    }
-    try {
-      let globalConfig;
-      try {
-        try {
-          const stats = await fs4.stat(this.configPath);
-          const mode = stats.mode & 511;
-          if (mode !== 384) {
-            console.warn(`\u26A0\uFE0F  Config file has insecure permissions (${mode.toString(8)}). Setting to 0600...`);
-            await fs4.chmod(this.configPath, 384);
-          }
-        } catch (statError) {
-        }
-        const data = await fs4.readFile(this.configPath, "utf-8");
-        const rawConfig = JSON.parse(data);
-        if (rawConfig.apiConfig && "environment" in rawConfig.apiConfig) {
-          const oldApiConfig = rawConfig.apiConfig;
-          if (oldApiConfig.environment === "custom" && oldApiConfig.customUrl) {
-            rawConfig.apiConfig = { customUrl: oldApiConfig.customUrl };
-          } else {
-            rawConfig.apiConfig = {};
-          }
-        }
-        const validated = CliConfigSchema.parse(rawConfig);
-        globalConfig = {
-          ...DEFAULT_CONFIG,
-          ...validated,
-          auth: validated.auth,
-          // Explicitly preserve auth field
-          preferences: {
-            ...DEFAULT_CONFIG.preferences,
-            ...validated.preferences
-          },
-          tools: {
-            ...DEFAULT_CONFIG.tools,
-            ...validated.tools
-          },
-          toolApiKeys: {
-            ...DEFAULT_CONFIG.toolApiKeys,
-            ...validated.toolApiKeys || {}
-          },
-          trustedTools: validated.trustedTools || []
-        };
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          globalConfig = { ...DEFAULT_CONFIG };
-        } else if (error instanceof z.ZodError) {
-          console.error("Global config validation error:", error.errors);
-          console.error("Using default configuration");
-          globalConfig = { ...DEFAULT_CONFIG };
-        } else {
-          throw error;
-        }
-      }
-      let projectConfig = null;
-      let projectLocalConfig = null;
-      if (process.env.B4M_NO_PROJECT_CONFIG !== "1") {
-        this.projectConfigDir = findProjectConfigDir();
-        if (this.projectConfigDir) {
-          projectConfig = await loadProjectConfig(this.projectConfigDir);
-          projectLocalConfig = await loadProjectLocalConfig(this.projectConfigDir);
-          if (projectConfig) {
-            console.log(`\u{1F4C1} Project config loaded from: ${this.projectConfigDir}/.bike4mind/`);
-          }
-        }
-      } else {
-        this.projectConfigDir = null;
-      }
-      this.config = mergeConfigs(globalConfig, projectConfig, projectLocalConfig);
-      return this.config;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return this.reset();
-      }
-      if (error instanceof z.ZodError) {
-        console.error("Config validation error:", error.errors);
-        console.error("Resetting to default configuration");
-        return this.reset();
-      }
-      console.error("Failed to load config:", error);
-      throw error;
-    }
-  }
-  /**
-   * Save configuration to disk
-   */
-  async save(config) {
-    await this.init();
-    if (config) {
-      const existingConfig = await this.load();
-      this.config = {
-        ...existingConfig,
-        ...config,
-        auth: config.auth !== void 0 ? config.auth : existingConfig.auth,
-        preferences: {
-          ...existingConfig.preferences,
-          ...config.preferences || {}
-        },
-        tools: {
-          ...existingConfig.tools,
-          ...config.tools || {}
-        },
-        toolApiKeys: {
-          ...existingConfig.toolApiKeys,
-          ...config.toolApiKeys || {}
-        }
-      };
-    }
-    if (!this.config) {
-      throw new Error("No configuration to save");
-    }
-    try {
-      await fs4.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
-      await fs4.chmod(this.configPath, 384);
-    } catch (error) {
-      console.error("Failed to save config:", error);
-      throw error;
-    }
-  }
-  /**
-   * Reset configuration to defaults
-   */
-  async reset() {
-    this.config = { ...DEFAULT_CONFIG, userId: uuidv42() };
-    await this.save();
-    return this.config;
-  }
-  /**
-   * Get current configuration
-   */
-  async get() {
-    return this.load();
-  }
-  /**
-   * Update a specific configuration value
-   */
-  async update(updates) {
-    await this.save(updates);
-  }
-  /**
-   * Add MCP server configuration
-   */
-  async addMcpServer(server) {
-    const config = await this.load();
-    config.mcpServers = config.mcpServers.filter((s) => s.name !== server.name);
-    config.mcpServers.push(server);
-    await this.save(config);
-  }
-  /**
-   * Remove MCP server configuration
-   */
-  async removeMcpServer(name) {
-    const config = await this.load();
-    config.mcpServers = config.mcpServers.filter((s) => s.name !== name);
-    await this.save(config);
-  }
-  /**
-   * Enable/disable MCP server
-   */
-  async toggleMcpServer(name, enabled) {
-    const config = await this.load();
-    const server = config.mcpServers.find((s) => s.name === name);
-    if (server) {
-      server.enabled = enabled;
-      await this.save(config);
-    }
-  }
-  /**
-   * Add a tool to trusted tools list
-   */
-  async trustTool(toolName) {
-    const config = await this.load();
-    if (!config.trustedTools) {
-      config.trustedTools = [];
-    }
-    if (!config.trustedTools.includes(toolName)) {
-      config.trustedTools.push(toolName);
-      await this.save(config);
-    }
-  }
-  /**
-   * Remove a tool from trusted tools list
-   */
-  async untrustTool(toolName) {
-    const config = await this.load();
-    if (config.trustedTools) {
-      config.trustedTools = config.trustedTools.filter((t) => t !== toolName);
-      await this.save(config);
-    }
-  }
-  /**
-   * Get list of trusted tools
-   */
-  async getTrustedTools() {
-    const config = await this.load();
-    return config.trustedTools || [];
-  }
-  /**
-   * Clear all trusted tools
-   */
-  async clearTrustedTools() {
-    const config = await this.load();
-    config.trustedTools = [];
-    await this.save(config);
-  }
-  /**
-   * Get authentication tokens
-   */
-  async getAuthTokens() {
-    const config = await this.load();
-    return config.auth || null;
-  }
-  /**
-   * Set authentication tokens
-   */
-  async setAuthTokens(tokens) {
-    const config = await this.load();
-    config.auth = tokens;
-    await this.save(config);
-  }
-  /**
-   * Clear authentication tokens (logout)
-   */
-  async clearAuthTokens() {
-    const config = await this.load();
-    config.auth = void 0;
-    await this.save(config);
-  }
-  /**
-   * Check if user is authenticated
-   */
-  async isAuthenticated() {
-    const tokens = await this.getAuthTokens();
-    if (!tokens) return false;
-    const expiresAt = new Date(tokens.expiresAt);
-    return expiresAt > /* @__PURE__ */ new Date();
-  }
-  /**
-   * Get API configuration
-   */
-  async getApiConfig() {
-    const config = await this.load();
-    return config.apiConfig;
-  }
-  /**
-   * Set custom API URL for self-hosted Bike4Mind instance
-   * Pass null to reset to Bike4Mind main service
-   */
-  async setCustomApiUrl(url) {
-    const config = await this.load();
-    if (url === null) {
-      config.apiConfig = void 0;
-    } else {
-      config.apiConfig = { customUrl: url };
-    }
-    await this.save(config);
-  }
-  /**
-   * Get project config directory (if any)
-   */
-  getProjectConfigDir() {
-    return this.projectConfigDir;
-  }
-  /**
-   * Initialize project config directory
-   * Creates .bike4mind/ directory and ensures local.json is gitignored
-   * Does NOT auto-create config.json (user creates that manually)
-   */
-  async initProjectConfig() {
-    const projectDir = this.projectConfigDir || findProjectConfigDir();
-    if (!projectDir) {
-      return;
-    }
-    const configDir = path4.join(projectDir, ".bike4mind");
-    await fs4.mkdir(configDir, { recursive: true });
-    await this.ensureGitignore(projectDir);
-  }
-  /**
-   * Ensure .gitignore includes .bike4mind/local.json
-   */
-  async ensureGitignore(projectDir) {
-    const gitignorePath = path4.join(projectDir, ".gitignore");
-    const entryToAdd = ".bike4mind/local.json";
-    try {
-      let gitignoreContent = "";
-      try {
-        gitignoreContent = await fs4.readFile(gitignorePath, "utf-8");
-      } catch {
-      }
-      if (gitignoreContent.includes(entryToAdd)) {
-        return;
-      }
-      const newContent = gitignoreContent.trim() + (gitignoreContent ? "\n" : "") + `
-# Bike4Mind local config (developer-specific)
-${entryToAdd}
-`;
-      await fs4.writeFile(gitignorePath, newContent, "utf-8");
-      console.log(`\u2705 Added ${entryToAdd} to .gitignore`);
-    } catch (error) {
-      console.warn(`\u26A0\uFE0F  Failed to update .gitignore:`, error);
-    }
-  }
-  /**
-   * Save project config to .bike4mind/config.json
-   */
-  async saveProjectConfig(config, projectDir) {
-    const targetDir = projectDir || this.projectConfigDir || process.cwd();
-    const configPath = path4.join(targetDir, ".bike4mind", "config.json");
-    await fs4.mkdir(path4.dirname(configPath), { recursive: true });
-    const validated = ProjectConfigSchema.parse(config);
-    await fs4.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
-    console.log(`\u2705 Saved project config to: ${configPath}`);
-  }
-  /**
-   * Save project-local config to .bike4mind/local.json
-   */
-  async saveProjectLocalConfig(config, projectDir) {
-    const targetDir = projectDir || this.projectConfigDir || process.cwd();
-    const configPath = path4.join(targetDir, ".bike4mind", "local.json");
-    await fs4.mkdir(path4.dirname(configPath), { recursive: true });
-    const validated = ProjectLocalConfigSchema.parse(config);
-    await fs4.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
-    await fs4.chmod(configPath, 384);
-    console.log(`\u2705 Saved project-local config to: ${configPath}`);
-  }
-  /**
-   * Load raw project config (without merging)
-   */
-  async loadRawProjectConfig() {
-    if (!this.projectConfigDir) {
-      return null;
-    }
-    return loadProjectConfig(this.projectConfigDir);
-  }
-  /**
-   * Load raw project-local config (without merging)
-   */
-  async loadRawProjectLocalConfig() {
-    if (!this.projectConfigDir) {
-      return null;
-    }
-    return loadProjectLocalConfig(this.projectConfigDir);
-  }
-};
-
-// src/storage/CommandHistoryStore.ts
-import { promises as fs5 } from "fs";
-import path5 from "path";
-import { homedir as homedir3 } from "os";
 var MAX_HISTORY_ENTRIES = 1e3;
 var CommandHistoryStore = class {
   constructor(historyPath) {
     this.history = null;
-    this.historyPath = historyPath || path5.join(homedir3(), ".bike4mind", "history.jsonl");
+    this.historyPath = historyPath || path4.join(homedir2(), ".bike4mind", "history.jsonl");
   }
   /**
    * Initialize history directory
    */
   async init() {
-    const dir = path5.dirname(this.historyPath);
+    const dir = path4.dirname(this.historyPath);
     try {
-      await fs5.mkdir(dir, { recursive: true });
+      await fs4.mkdir(dir, { recursive: true });
     } catch (error) {
       console.error("Failed to initialize history directory:", error);
       throw error;
@@ -2715,7 +2199,7 @@ var CommandHistoryStore = class {
       return this.history;
     }
     try {
-      const data = await fs5.readFile(this.historyPath, "utf-8");
+      const data = await fs4.readFile(this.historyPath, "utf-8");
       const lines = data.trim().split("\n").filter((line) => line.length > 0);
       const entries = lines.map((line) => {
         try {
@@ -2752,7 +2236,7 @@ var CommandHistoryStore = class {
     };
     await this.init();
     const line = JSON.stringify(entry) + "\n";
-    await fs5.appendFile(this.historyPath, line, "utf-8");
+    await fs4.appendFile(this.historyPath, line, "utf-8");
     this.history = [command, ...this.history || []];
     if (this.history.length > MAX_HISTORY_ENTRIES) {
       await this.trim();
@@ -2775,7 +2259,7 @@ var CommandHistoryStore = class {
       };
       return JSON.stringify(entry);
     }).join("\n");
-    await fs5.writeFile(this.historyPath, lines + "\n", "utf-8");
+    await fs4.writeFile(this.historyPath, lines + "\n", "utf-8");
     this.history = trimmedCommands;
   }
   /**
@@ -2783,7 +2267,7 @@ var CommandHistoryStore = class {
    */
   async clear() {
     try {
-      await fs5.unlink(this.historyPath);
+      await fs4.unlink(this.historyPath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -2800,23 +2284,23 @@ var CommandHistoryStore = class {
 };
 
 // src/storage/CustomCommandStore.ts
-import fs6 from "fs/promises";
-import path6 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 import os from "os";
 
 // src/utils/commandParser.ts
 import matter from "gray-matter";
-import { z as z2 } from "zod";
-var FrontmatterSchema = z2.object({
-  description: z2.string().optional(),
-  "argument-hint": z2.string().optional(),
-  model: z2.string().optional(),
+import { z } from "zod";
+var FrontmatterSchema = z.object({
+  description: z.string().optional(),
+  "argument-hint": z.string().optional(),
+  model: z.string().optional(),
   // Future fields (ignored for now):
-  "allowed-tools": z2.any().optional(),
-  context: z2.any().optional(),
-  agent: z2.any().optional(),
-  "disable-model-invocation": z2.any().optional(),
-  hooks: z2.any().optional()
+  "allowed-tools": z.any().optional(),
+  context: z.any().optional(),
+  agent: z.any().optional(),
+  "disable-model-invocation": z.any().optional(),
+  hooks: z.any().optional()
 });
 function extractDescriptionFromBody(body) {
   const lines = body.trim().split("\n");
@@ -2877,8 +2361,8 @@ function extractCommandName(filename) {
 var CustomCommandStore = class {
   constructor(projectRoot) {
     this.commands = /* @__PURE__ */ new Map();
-    this.globalCommandsDir = path6.join(os.homedir(), ".bike4mind", "commands");
-    this.projectCommandsDir = path6.join(projectRoot || process.cwd(), ".bike4mind", "commands");
+    this.globalCommandsDir = path5.join(os.homedir(), ".bike4mind", "commands");
+    this.projectCommandsDir = path5.join(projectRoot || process.cwd(), ".bike4mind", "commands");
   }
   /**
    * Loads all custom commands from both global and project directories
@@ -2897,7 +2381,7 @@ var CustomCommandStore = class {
    */
   async loadCommandsFromDirectory(directory, source) {
     try {
-      const stats = await fs6.stat(directory);
+      const stats = await fs5.stat(directory);
       if (!stats.isDirectory()) {
         return;
       }
@@ -2930,9 +2414,9 @@ var CustomCommandStore = class {
   async findCommandFiles(directory) {
     const files = [];
     try {
-      const entries = await fs6.readdir(directory, { withFileTypes: true });
+      const entries = await fs5.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path6.join(directory, entry.name);
+        const fullPath = path5.join(directory, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.findCommandFiles(fullPath);
           files.push(...subFiles);
@@ -2952,13 +2436,13 @@ var CustomCommandStore = class {
    * @param source - Source identifier ('global' or 'project')
    */
   async loadCommandFile(filePath, source) {
-    const filename = path6.basename(filePath);
+    const filename = path5.basename(filePath);
     const commandName = extractCommandName(filename);
     if (!commandName) {
       console.warn(`Invalid command filename: ${filename} (must end with .md and have valid name)`);
       return;
     }
-    const fileContent = await fs6.readFile(filePath, "utf-8");
+    const fileContent = await fs5.readFile(filePath, "utf-8");
     const command = parseCommandFile(fileContent, filePath, commandName, source);
     const existing = this.commands.get(commandName);
     if (existing && existing.source === "project" && source === "global") {
@@ -3025,16 +2509,16 @@ var CustomCommandStore = class {
    */
   async createCommandFile(name, isGlobal = false) {
     const targetDir = isGlobal ? this.globalCommandsDir : this.projectCommandsDir;
-    const filePath = path6.join(targetDir, `${name}.md`);
+    const filePath = path5.join(targetDir, `${name}.md`);
     try {
-      await fs6.access(filePath);
+      await fs5.access(filePath);
       throw new Error(`Command file already exists: ${filePath}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
     }
-    await fs6.mkdir(targetDir, { recursive: true });
+    await fs5.mkdir(targetDir, { recursive: true });
     const template = `---
 description: ${name} command
 argument-hint: [args]
@@ -3049,7 +2533,7 @@ You can use:
 - $1, $2, etc. for positional arguments
 - @filename for file references
 `;
-    await fs6.writeFile(filePath, template, "utf-8");
+    await fs5.writeFile(filePath, template, "utf-8");
     return filePath;
   }
 };
@@ -3459,38 +2943,38 @@ Remember: Use context from previous messages to understand follow-up questions.$
 // ../../b4m-core/packages/services/dist/src/referService/generateCodes.js
 import { randomBytes } from "crypto";
 import range from "lodash/range.js";
-import { z as z3 } from "zod";
-var generateReferralCodesSchema = z3.object({
-  count: z3.number().optional(),
-  unlimitedUse: z3.boolean().optional(),
-  expiresAt: z3.date().optional()
+import { z as z2 } from "zod";
+var generateReferralCodesSchema = z2.object({
+  count: z2.number().optional(),
+  unlimitedUse: z2.boolean().optional(),
+  expiresAt: z2.date().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/referService/delete.js
-import { z as z4 } from "zod";
-var deleteInviteCodesSchema = z4.object({
-  ids: z4.array(z4.string())
+import { z as z3 } from "zod";
+var deleteInviteCodesSchema = z3.object({
+  ids: z3.array(z3.string())
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/login.js
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 import bcrypt from "bcryptjs";
-var loginUserSchema = z5.object({
-  usernameOrEmail: z5.string(),
-  password: z5.string(),
-  metadata: z5.object({
-    loginTime: z5.date(),
-    userAgent: z5.string(),
-    browser: z5.string(),
-    operatingSystem: z5.string(),
-    deviceType: z5.string(),
-    screenResolution: z5.string(),
-    viewportSize: z5.string(),
-    colorDepth: z5.number(),
-    pixelDepth: z5.number(),
-    devicePixelRatio: z5.number(),
-    ip: z5.string().optional().default(""),
-    location: z5.string().optional()
+var loginUserSchema = z4.object({
+  usernameOrEmail: z4.string(),
+  password: z4.string(),
+  metadata: z4.object({
+    loginTime: z4.date(),
+    userAgent: z4.string(),
+    browser: z4.string(),
+    operatingSystem: z4.string(),
+    deviceType: z4.string(),
+    screenResolution: z4.string(),
+    viewportSize: z4.string(),
+    colorDepth: z4.number(),
+    pixelDepth: z4.number(),
+    devicePixelRatio: z4.number(),
+    ip: z4.string().optional().default(""),
+    location: z4.string().optional()
   }).optional()
 });
 
@@ -3500,78 +2984,78 @@ import escapeRegExp from "lodash/escapeRegExp.js";
 
 // ../../b4m-core/packages/services/dist/src/userService/forgotPassword.js
 import { randomUUID } from "crypto";
-import { z as z6 } from "zod";
-var forgotPasswordUserSchema = z6.object({
-  email: z6.string().email()
+import { z as z5 } from "zod";
+var forgotPasswordUserSchema = z5.object({
+  email: z5.string().email()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/update.js
 import bcrypt3 from "bcryptjs";
-import { z as z7 } from "zod";
-var updateUserSchema = z7.object({
-  name: z7.string().optional(),
-  username: z7.string().optional(),
+import { z as z6 } from "zod";
+var updateUserSchema = z6.object({
+  name: z6.string().optional(),
+  username: z6.string().optional(),
   // email field removed - users must use the secure email change verification flow
   // See requestEmailChange and verifyEmailChange in userService
-  password: z7.string().nullable().optional(),
-  team: z7.string().nullable().optional(),
-  role: z7.string().nullable().optional(),
-  phone: z7.string().nullable().optional(),
-  preferredLanguage: z7.string().nullable().optional(),
-  preferredContact: z7.string().nullable().optional(),
-  preferredVoice: z7.string().nullable().optional(),
-  tshirtSize: z7.string().nullable().optional(),
-  geoLocation: z7.string().nullable().optional(),
-  lastNotebookId: z7.string().nullable().optional(),
-  tags: z7.array(z7.string()).nullable().optional(),
-  lastCreditsPurchasedAt: z7.date().nullable().optional(),
-  systemFiles: z7.array(z7.object({
-    fileId: z7.string(),
-    enabled: z7.boolean()
+  password: z6.string().nullable().optional(),
+  team: z6.string().nullable().optional(),
+  role: z6.string().nullable().optional(),
+  phone: z6.string().nullable().optional(),
+  preferredLanguage: z6.string().nullable().optional(),
+  preferredContact: z6.string().nullable().optional(),
+  preferredVoice: z6.string().nullable().optional(),
+  tshirtSize: z6.string().nullable().optional(),
+  geoLocation: z6.string().nullable().optional(),
+  lastNotebookId: z6.string().nullable().optional(),
+  tags: z6.array(z6.string()).nullable().optional(),
+  lastCreditsPurchasedAt: z6.date().nullable().optional(),
+  systemFiles: z6.array(z6.object({
+    fileId: z6.string(),
+    enabled: z6.boolean()
   })).nullable().optional(),
-  securityQuestions: z7.array(z7.object({ question: z7.string(), answer: z7.string() })).nullable().optional(),
-  photoUrl: z7.string().nullable().optional(),
-  showCreditsUsed: z7.boolean().optional()
+  securityQuestions: z6.array(z6.object({ question: z6.string(), answer: z6.string() })).nullable().optional(),
+  photoUrl: z6.string().nullable().optional(),
+  showCreditsUsed: z6.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminUpdate.js
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/sendFriendRequest.js
-import { z as z8 } from "zod";
-var sendFriendRequestSchema = z8.object({
-  requesterId: z8.string(),
-  recipientId: z8.string(),
-  message: z8.string().optional()
+import { z as z7 } from "zod";
+var sendFriendRequestSchema = z7.object({
+  requesterId: z7.string(),
+  recipientId: z7.string(),
+  message: z7.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminUpdate.js
 var adminUpdateUserSchema = updateUserSchema.extend({
-  id: z9.string(),
+  id: z8.string(),
   // Admins can directly update email addresses without verification
-  email: z9.string().email().optional(),
-  role: z9.string().optional().nullable(),
-  isAdmin: z9.boolean().optional(),
-  organizationId: z9.string().optional().nullable(),
-  storageLimit: z9.number().optional(),
-  currentCredits: z9.number().optional(),
-  isBanned: z9.boolean().optional(),
-  isModerated: z9.boolean().optional(),
-  subscribedUntil: z9.string().optional().nullable(),
-  systemFiles: z9.array(z9.object({ fileId: z9.string(), enabled: z9.boolean() })).optional(),
-  level: z9.enum(["DemoUser", "PaidUser", "VIPUser", "ManagerUser", "AdminUser"]).optional(),
-  lastNotebookId: z9.string().optional().nullable(),
-  userNotes: z9.array(z9.object({ timestamp: z9.string(), note: z9.string(), userName: z9.string() })).optional(),
-  numReferralsAvailable: z9.number().optional()
+  email: z8.string().email().optional(),
+  role: z8.string().optional().nullable(),
+  isAdmin: z8.boolean().optional(),
+  organizationId: z8.string().optional().nullable(),
+  storageLimit: z8.number().optional(),
+  currentCredits: z8.number().optional(),
+  isBanned: z8.boolean().optional(),
+  isModerated: z8.boolean().optional(),
+  subscribedUntil: z8.string().optional().nullable(),
+  systemFiles: z8.array(z8.object({ fileId: z8.string(), enabled: z8.boolean() })).optional(),
+  level: z8.enum(["DemoUser", "PaidUser", "VIPUser", "ManagerUser", "AdminUser"]).optional(),
+  lastNotebookId: z8.string().optional().nullable(),
+  userNotes: z8.array(z8.object({ timestamp: z8.string(), note: z8.string(), userName: z8.string() })).optional(),
+  numReferralsAvailable: z8.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/register.js
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 import bcrypt4 from "bcryptjs";
 
 // ../../b4m-core/packages/services/dist/src/creditService/addCredits.js
-import { z as z10 } from "zod";
-var AddCreditsSchema = z10.discriminatedUnion("type", [
+import { z as z9 } from "zod";
+var AddCreditsSchema = z9.discriminatedUnion("type", [
   PurchaseTransaction.omit({ createdAt: true, updatedAt: true }),
   SubscriptionCreditTransaction.omit({ createdAt: true, updatedAt: true }),
   GenericCreditAddTransaction.omit({ createdAt: true, updatedAt: true }),
@@ -3579,57 +3063,57 @@ var AddCreditsSchema = z10.discriminatedUnion("type", [
 ]);
 
 // ../../b4m-core/packages/services/dist/src/userService/register.js
-var registerUserSchema = z11.object({
-  username: z11.string(),
-  email: z11.string(),
-  name: z11.string(),
-  inviteCode: z11.string(),
-  password: z11.string(),
-  metadata: z11.object({
-    loginTime: z11.date(),
-    userAgent: z11.string(),
-    browser: z11.string(),
-    operatingSystem: z11.string(),
-    deviceType: z11.string(),
-    screenResolution: z11.string(),
-    viewportSize: z11.string(),
-    colorDepth: z11.number(),
-    pixelDepth: z11.number(),
-    devicePixelRatio: z11.number(),
-    ip: z11.string().optional().default(""),
-    location: z11.string().optional()
+var registerUserSchema = z10.object({
+  username: z10.string(),
+  email: z10.string(),
+  name: z10.string(),
+  inviteCode: z10.string(),
+  password: z10.string(),
+  metadata: z10.object({
+    loginTime: z10.date(),
+    userAgent: z10.string(),
+    browser: z10.string(),
+    operatingSystem: z10.string(),
+    deviceType: z10.string(),
+    screenResolution: z10.string(),
+    viewportSize: z10.string(),
+    colorDepth: z10.number(),
+    pixelDepth: z10.number(),
+    devicePixelRatio: z10.number(),
+    ip: z10.string().optional().default(""),
+    location: z10.string().optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminDelete.js
-import { z as z12 } from "zod";
-var adminDeleteUserSchema = z12.object({
-  id: z12.string()
+import { z as z11 } from "zod";
+var adminDeleteUserSchema = z11.object({
+  id: z11.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/searchUserCollection.js
-import { z as z13 } from "zod";
-var searchUserCollectionSchema = z13.object({
-  userId: z13.string(),
-  page: z13.coerce.number().optional().default(1),
-  limit: z13.coerce.number().optional().default(10),
-  search: z13.string().optional().default(""),
-  type: z13.nativeEnum(CollectionType).optional()
+import { z as z12 } from "zod";
+var searchUserCollectionSchema = z12.object({
+  userId: z12.string(),
+  page: z12.coerce.number().optional().default(1),
+  limit: z12.coerce.number().optional().default(10),
+  search: z12.string().optional().default(""),
+  type: z12.nativeEnum(CollectionType).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/recalculateUserStorage.js
-import { z as z14 } from "zod";
-var recalculateUserStorageSchema = z14.object({
+import { z as z13 } from "zod";
+var recalculateUserStorageSchema = z13.object({
   /**
    * The user to recalculate the storage for
    */
-  userId: z14.string()
+  userId: z13.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/listRecentActivities.js
-import { z as z15 } from "zod";
-var listRecentActivitiesSchema = z15.object({
-  coverage: z15.enum(["all", "important"]).default("important")
+import { z as z14 } from "zod";
+var listRecentActivitiesSchema = z14.object({
+  coverage: z14.enum(["all", "important"]).default("important")
 });
 var IMPORTANT_COUNTER_NAMES = [
   SessionEvents.CREATE_SESSION,
@@ -3643,82 +3127,82 @@ var IMPORTANT_COUNTER_NAMES = [
 
 // ../../b4m-core/packages/services/dist/src/userService/sendEmailVerification.js
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z16 } from "zod";
-var sendEmailVerificationSchema = z16.object({
-  userId: z16.string()
+import { z as z15 } from "zod";
+var sendEmailVerificationSchema = z15.object({
+  userId: z15.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailToken.js
-import { z as z17 } from "zod";
+import { z as z16 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/utils/crypto.js
 import crypto from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailToken.js
-var verifyEmailTokenSchema = z17.object({
-  token: z17.string()
+var verifyEmailTokenSchema = z16.object({
+  token: z16.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/resendEmailVerification.js
 import { randomUUID as randomUUID3 } from "crypto";
-import { z as z18 } from "zod";
-var resendEmailVerificationSchema = z18.object({
-  userId: z18.string()
+import { z as z17 } from "zod";
+var resendEmailVerificationSchema = z17.object({
+  userId: z17.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/requestEmailChange.js
 import { randomUUID as randomUUID4 } from "crypto";
-import { z as z19 } from "zod";
-var requestEmailChangeSchema = z19.object({
-  userId: z19.string(),
-  newEmail: z19.string().email(),
-  password: z19.string()
+import { z as z18 } from "zod";
+var requestEmailChangeSchema = z18.object({
+  userId: z18.string(),
+  newEmail: z18.string().email(),
+  password: z18.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailChange.js
-import { z as z20 } from "zod";
-var verifyEmailChangeSchema = z20.object({
-  token: z20.string()
+import { z as z19 } from "zod";
+var verifyEmailChangeSchema = z19.object({
+  token: z19.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/cancelEmailChange.js
-import { z as z21 } from "zod";
-var cancelEmailChangeSchema = z21.object({
-  userId: z21.string()
+import { z as z20 } from "zod";
+var cancelEmailChangeSchema = z20.object({
+  userId: z20.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/create.js
 import { randomBytes as randomBytes2 } from "crypto";
 import bcrypt5 from "bcryptjs";
-import { z as z22 } from "zod";
-var createUserApiKeySchema = z22.object({
-  name: z22.string().min(1).max(100),
-  scopes: z22.array(z22.nativeEnum(ApiKeyScope)).min(1),
-  expiresAt: z22.date().optional(),
-  rateLimit: z22.object({
-    requestsPerMinute: z22.number().min(1).max(1e3).default(60),
-    requestsPerDay: z22.number().min(1).max(1e4).default(1e3)
+import { z as z21 } from "zod";
+var createUserApiKeySchema = z21.object({
+  name: z21.string().min(1).max(100),
+  scopes: z21.array(z21.nativeEnum(ApiKeyScope)).min(1),
+  expiresAt: z21.date().optional(),
+  rateLimit: z21.object({
+    requestsPerMinute: z21.number().min(1).max(1e3).default(60),
+    requestsPerDay: z21.number().min(1).max(1e4).default(1e3)
   }).optional(),
-  metadata: z22.object({
-    clientIP: z22.string().optional(),
-    userAgent: z22.string().optional(),
-    createdFrom: z22.enum(["dashboard", "cli", "api"])
+  metadata: z21.object({
+    clientIP: z21.string().optional(),
+    userAgent: z21.string().optional(),
+    createdFrom: z21.enum(["dashboard", "cli", "api"])
   })
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/revoke.js
-import { z as z23 } from "zod";
-var revokeUserApiKeySchema = z23.object({
-  keyId: z23.string(),
-  reason: z23.string().optional()
+import { z as z22 } from "zod";
+var revokeUserApiKeySchema = z22.object({
+  keyId: z22.string(),
+  reason: z22.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/rotate.js
 import { randomBytes as randomBytes3 } from "crypto";
 import bcrypt6 from "bcryptjs";
-import { z as z24 } from "zod";
-var rotateUserApiKeySchema = z24.object({
-  keyId: z24.string()
+import { z as z23 } from "zod";
+var rotateUserApiKeySchema = z23.object({
+  keyId: z23.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/validate.js
@@ -3865,29 +3349,29 @@ var EVENT_GROUPS = [
 ];
 
 // ../../b4m-core/packages/services/dist/src/countersService/generateReport.js
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/countersService/getAllCounterFrom24Hours.js
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 import dayjs2 from "dayjs";
-var getCounterTotalsForLast24HoursSchema = z25.object({
-  date: z25.string(),
-  endDate: z25.string().optional()
+var getCounterTotalsForLast24HoursSchema = z24.object({
+  date: z24.string(),
+  endDate: z24.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/generateReport.js
-var generateDailyReportSchema = z26.object({
-  date: z26.string(),
-  startDate: z26.string().optional(),
-  endDate: z26.string().optional()
+var generateDailyReportSchema = z25.object({
+  date: z25.string(),
+  startDate: z25.string().optional(),
+  endDate: z25.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/incrementUserCounter.js
-import { z as z27 } from "zod";
-var incrementUserCounterSchema = z27.object({
-  action: z27.string(),
-  increment: z27.coerce.number().default(1).optional(),
-  metadata: z27.record(z27.unknown()).optional()
+import { z as z26 } from "zod";
+var incrementUserCounterSchema = z26.object({
+  action: z26.string(),
+  increment: z26.coerce.number().default(1).optional(),
+  metadata: z26.record(z26.unknown()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/sendSlackReport.js
@@ -3903,47 +3387,47 @@ import { GoogleGenerativeAI } from "@google/generative-ai";
 import OpenAI2 from "openai";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
-import fs7, { unlinkSync } from "fs";
+import fs6, { unlinkSync } from "fs";
 import yauzl from "yauzl";
 import axios3 from "axios";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/importOpenaiHistory.js
-import { z as z28 } from "zod";
+import { z as z27 } from "zod";
 import last from "lodash/last.js";
-var epochDate = () => z28.preprocess((val) => new Date(Number(val) * 1e3), z28.date());
-var openaiConversationSchema = z28.object({
-  id: z28.string(),
-  title: z28.string(),
+var epochDate = () => z27.preprocess((val) => new Date(Number(val) * 1e3), z27.date());
+var openaiConversationSchema = z27.object({
+  id: z27.string(),
+  title: z27.string(),
   create_time: epochDate(),
   update_time: epochDate().nullable(),
-  mapping: z28.record(
-    z28.string(),
-    z28.object({
-      id: z28.string(),
-      parent: z28.string().nullable(),
-      children: z28.array(z28.string()),
-      message: z28.object({
-        id: z28.string(),
+  mapping: z27.record(
+    z27.string(),
+    z27.object({
+      id: z27.string(),
+      parent: z27.string().nullable(),
+      children: z27.array(z27.string()),
+      message: z27.object({
+        id: z27.string(),
         create_time: epochDate(),
         update_time: epochDate().nullable(),
-        author: z28.object({
-          role: z28.string(),
-          name: z28.string().nullable(),
-          metadata: z28.any()
+        author: z27.object({
+          role: z27.string(),
+          name: z27.string().nullable(),
+          metadata: z27.any()
           // Accept any metadata structure
         }).passthrough(),
         // Allow extra fields in author
-        content: z28.object({
-          content_type: z28.string(),
-          parts: z28.array(z28.any()).optional()
+        content: z27.object({
+          content_type: z27.string(),
+          parts: z27.array(z27.any()).optional()
           // Accept any type in parts array (strings, objects, etc.)
         }).passthrough(),
         // Allow extra fields in content
-        status: z28.string(),
-        end_turn: z28.boolean().nullable(),
-        metadata: z28.any(),
+        status: z27.string(),
+        end_turn: z27.boolean().nullable(),
+        metadata: z27.any(),
         // Accept any metadata structure since it varies widely
-        recipient: z28.string()
+        recipient: z27.string()
       }).passthrough().nullable()
     }).passthrough()
     // Allow extra fields in mapping node
@@ -3951,38 +3435,38 @@ var openaiConversationSchema = z28.object({
 }).passthrough();
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/importClaudeHistory.js
-import { z as z29 } from "zod";
-var claudeChatMessageSchema = z29.object({
-  uuid: z29.string().uuid(),
-  text: z29.string(),
-  content: z29.array(
-    z29.object({
-      type: z29.string(),
+import { z as z28 } from "zod";
+var claudeChatMessageSchema = z28.object({
+  uuid: z28.string().uuid(),
+  text: z28.string(),
+  content: z28.array(
+    z28.object({
+      type: z28.string(),
       // Accept any type: "text", "image", "tool_result", etc.
-      text: z29.string().optional()
+      text: z28.string().optional()
       // Make text optional since tool_result may not have it
     }).passthrough()
     // Allow all other fields
   ),
-  sender: z29.enum(["human", "assistant"]),
-  created_at: z29.coerce.date(),
-  updated_at: z29.coerce.date(),
-  attachments: z29.array(z29.any()),
+  sender: z28.enum(["human", "assistant"]),
+  created_at: z28.coerce.date(),
+  updated_at: z28.coerce.date(),
+  attachments: z28.array(z28.any()),
   // Accept any attachment structure
-  files: z29.array(z29.any())
+  files: z28.array(z28.any())
   // Accept any file structure
 }).passthrough();
-var claudeConversationSchema = z29.object({
-  uuid: z29.string().uuid(),
-  name: z29.string(),
-  summary: z29.string().optional(),
+var claudeConversationSchema = z28.object({
+  uuid: z28.string().uuid(),
+  name: z28.string(),
+  summary: z28.string().optional(),
   // Summary field is optional
-  created_at: z29.coerce.date(),
-  updated_at: z29.coerce.date(),
-  account: z29.object({
-    uuid: z29.string().uuid()
+  created_at: z28.coerce.date(),
+  updated_at: z28.coerce.date(),
+  account: z28.object({
+    uuid: z28.string().uuid()
   }),
-  chat_messages: z29.array(claudeChatMessageSchema)
+  chat_messages: z28.array(claudeChatMessageSchema)
 }).passthrough();
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
@@ -3993,357 +3477,357 @@ var ImportSource;
 })(ImportSource || (ImportSource = {}));
 
 // ../../b4m-core/packages/services/dist/src/sessionService/create.js
-import { z as z30 } from "zod";
-var createSessionParametersSchema = z30.object({
-  name: z30.string(),
-  knowledgeIds: z30.array(z30.string()).optional(),
-  artifactIds: z30.array(z30.string()).optional(),
-  agentIds: z30.array(z30.string()).optional(),
-  tags: z30.array(z30.object({ name: z30.string(), strength: z30.number() })).optional(),
-  summary: z30.string().optional(),
-  summaryAt: z30.date().optional(),
-  clonedSourceId: z30.string().optional().nullable(),
-  forkedSourceId: z30.string().optional().nullable(),
-  projectId: z30.string().optional(),
-  lastUsedModel: z30.string().optional().nullable()
+import { z as z29 } from "zod";
+var createSessionParametersSchema = z29.object({
+  name: z29.string(),
+  knowledgeIds: z29.array(z29.string()).optional(),
+  artifactIds: z29.array(z29.string()).optional(),
+  agentIds: z29.array(z29.string()).optional(),
+  tags: z29.array(z29.object({ name: z29.string(), strength: z29.number() })).optional(),
+  summary: z29.string().optional(),
+  summaryAt: z29.date().optional(),
+  clonedSourceId: z29.string().optional().nullable(),
+  forkedSourceId: z29.string().optional().nullable(),
+  projectId: z29.string().optional(),
+  lastUsedModel: z29.string().optional().nullable()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/delete.js
-import { z as z31 } from "zod";
-var deleteSessionSchema = z31.object({
-  id: z31.string()
+import { z as z30 } from "zod";
+var deleteSessionSchema = z30.object({
+  id: z30.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/sumarize.js
-import { z as z32 } from "zod";
-var sumarizeSessionSchema = z32.object({
-  id: z32.string()
+import { z as z31 } from "zod";
+var sumarizeSessionSchema = z31.object({
+  id: z31.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/create.js
-import { z as z33 } from "zod";
-var createProjectSchema = z33.object({
-  name: z33.string().min(1),
-  description: z33.string().min(1),
-  sessionIds: z33.array(z33.string()).optional(),
-  fileIds: z33.array(z33.string()).optional()
+import { z as z32 } from "zod";
+var createProjectSchema = z32.object({
+  name: z32.string().min(1),
+  description: z32.string().min(1),
+  sessionIds: z32.array(z32.string()).optional(),
+  fileIds: z32.array(z32.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/search.js
-import { z as z34 } from "zod";
-var searchProjectsSchema = z34.object({
-  search: z34.string().optional(),
-  filters: z34.object({
-    favorite: z34.coerce.boolean().optional(),
-    scope: z34.record(z34.any()).optional()
+import { z as z33 } from "zod";
+var searchProjectsSchema = z33.object({
+  search: z33.string().optional(),
+  filters: z33.object({
+    favorite: z33.coerce.boolean().optional(),
+    scope: z33.record(z33.any()).optional()
   }).optional(),
-  pagination: z34.object({
-    page: z34.coerce.number().optional(),
-    limit: z34.coerce.number().optional()
+  pagination: z33.object({
+    page: z33.coerce.number().optional(),
+    limit: z33.coerce.number().optional()
   }).optional(),
-  orderBy: z34.object({
-    by: z34.enum(["createdAt", "updatedAt"]).optional(),
-    direction: z34.enum(["asc", "desc"]).optional()
+  orderBy: z33.object({
+    by: z33.enum(["createdAt", "updatedAt"]).optional(),
+    direction: z33.enum(["asc", "desc"]).optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addSessions.js
-import { z as z45 } from "zod";
+import { z as z44 } from "zod";
 import uniq2 from "lodash/uniq.js";
 
 // ../../b4m-core/packages/services/dist/src/sharingService/accept.js
-import { z as z35 } from "zod";
-var acceptInviteSchema = z35.object({
-  id: z35.string()
+import { z as z34 } from "zod";
+var acceptInviteSchema = z34.object({
+  id: z34.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/cancel.js
-import { z as z36 } from "zod";
-var cancelInviteSchema = z36.object({
-  id: z36.string(),
-  type: z36.nativeEnum(InviteType),
-  email: z36.string().email().optional()
+import { z as z35 } from "zod";
+var cancelInviteSchema = z35.object({
+  id: z35.string(),
+  type: z35.nativeEnum(InviteType),
+  email: z35.string().email().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/cancelOwnDocument.js
-import { z as z37 } from "zod";
-var cancelOwnDocumentInvitesSchema = z37.object({
-  documentId: z37.string(),
-  type: z37.nativeEnum(InviteType)
+import { z as z36 } from "zod";
+var cancelOwnDocumentInvitesSchema = z36.object({
+  documentId: z36.string(),
+  type: z36.nativeEnum(InviteType)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/create.js
-import { z as z38 } from "zod";
+import { z as z37 } from "zod";
 var defaultExpiration = () => new Date((/* @__PURE__ */ new Date()).getFullYear() + 100, (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate());
 var DEFAULT_AVAILABLE = 1;
-var createInviteSchema = z38.object({
-  id: z38.string(),
-  type: z38.nativeEnum(InviteType),
-  permissions: z38.array(z38.nativeEnum(Permission)),
-  recipients: z38.string().array().optional(),
-  description: z38.string().optional(),
-  expiresAt: z38.date().optional().default(defaultExpiration()),
-  available: z38.number().optional().default(DEFAULT_AVAILABLE)
+var createInviteSchema = z37.object({
+  id: z37.string(),
+  type: z37.nativeEnum(InviteType),
+  permissions: z37.array(z37.nativeEnum(Permission)),
+  recipients: z37.string().array().optional(),
+  description: z37.string().optional(),
+  expiresAt: z37.date().optional().default(defaultExpiration()),
+  available: z37.number().optional().default(DEFAULT_AVAILABLE)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/get.js
-import { z as z39 } from "zod";
-var getInviteSchema = z39.object({
-  id: z39.string(),
-  withUsername: z39.boolean().optional()
+import { z as z38 } from "zod";
+var getInviteSchema = z38.object({
+  id: z38.string(),
+  withUsername: z38.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/listByDocumentIdAndType.js
-import { z as z40 } from "zod";
-var listInviteByDocumentIdAndTypeSchema = z40.object({
-  documentId: z40.string(),
-  type: z40.nativeEnum(InviteType)
+import { z as z39 } from "zod";
+var listInviteByDocumentIdAndTypeSchema = z39.object({
+  documentId: z39.string(),
+  type: z39.nativeEnum(InviteType)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/listOwnPending.js
-import { z as z41 } from "zod";
-var listOwnPendingInvitesSchema = z41.object({
-  limit: z41.number().min(1).max(100).default(20),
-  page: z41.number().min(1).default(1)
+import { z as z40 } from "zod";
+var listOwnPendingInvitesSchema = z40.object({
+  limit: z40.number().min(1).max(100).default(20),
+  page: z40.number().min(1).default(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/refuse.js
-import { z as z42 } from "zod";
-var refuseInviteSchema = z42.object({
-  id: z42.string()
+import { z as z41 } from "zod";
+var refuseInviteSchema = z41.object({
+  id: z41.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/revoke.js
-import { z as z43 } from "zod";
-var revokeSharingSchema = z43.object({
-  id: z43.string(),
-  type: z43.enum(["files", "sessions", "projects"]),
-  userId: z43.string(),
-  projectId: z43.string().optional()
+import { z as z42 } from "zod";
+var revokeSharingSchema = z42.object({
+  id: z42.string(),
+  type: z42.enum(["files", "sessions", "projects"]),
+  userId: z42.string(),
+  projectId: z42.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addFiles.js
-import { z as z44 } from "zod";
+import { z as z43 } from "zod";
 import uniq from "lodash/uniq.js";
-var addFilesProjectSchema = z44.object({
-  projectId: z44.string().nonempty(),
-  fileIds: z44.array(z44.string().nonempty())
+var addFilesProjectSchema = z43.object({
+  projectId: z43.string().nonempty(),
+  fileIds: z43.array(z43.string().nonempty())
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addSessions.js
-var addSessionsProjectSchema = z45.object({
-  projectId: z45.string().nonempty(),
-  sessionIds: z45.array(z45.string().nonempty())
+var addSessionsProjectSchema = z44.object({
+  projectId: z44.string().nonempty(),
+  sessionIds: z44.array(z44.string().nonempty())
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/get.js
-import { z as z46 } from "zod";
-var getProjectSchema = z46.object({
-  id: z46.string()
+import { z as z45 } from "zod";
+var getProjectSchema = z45.object({
+  id: z45.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/update.js
-import { z as z47 } from "zod";
-var updateProjectSchema = z47.object({
-  id: z47.string(),
-  name: z47.string().optional(),
-  description: z47.string().optional()
+import { z as z46 } from "zod";
+var updateProjectSchema = z46.object({
+  id: z46.string(),
+  name: z46.string().optional(),
+  description: z46.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/delete.js
-import { z as z48 } from "zod";
-var deleteProjectSchema = z48.object({
-  id: z48.string()
+import { z as z47 } from "zod";
+var deleteProjectSchema = z47.object({
+  id: z47.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/removeFiles.js
+import { z as z48 } from "zod";
+var removeProjectFilesSchema = z48.object({
+  projectId: z48.string(),
+  fileIds: z48.array(z48.string())
+});
+
+// ../../b4m-core/packages/services/dist/src/projectService/removeSessions.js
 import { z as z49 } from "zod";
-var removeProjectFilesSchema = z49.object({
+var removeProjectSessionsSchema = z49.object({
   projectId: z49.string(),
-  fileIds: z49.array(z49.string())
+  sessionIds: z49.array(z49.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeSessions.js
+// ../../b4m-core/packages/services/dist/src/projectService/listSessions.js
 import { z as z50 } from "zod";
-var removeProjectSessionsSchema = z50.object({
-  projectId: z50.string(),
-  sessionIds: z50.array(z50.string())
+var listProjectSessionsSchema = z50.object({
+  projectId: z50.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listSessions.js
+// ../../b4m-core/packages/services/dist/src/projectService/listFiles.js
 import { z as z51 } from "zod";
-var listProjectSessionsSchema = z51.object({
+var listProjectFilesSchema = z51.object({
   projectId: z51.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listFiles.js
+// ../../b4m-core/packages/services/dist/src/projectService/listInvites.js
 import { z as z52 } from "zod";
-var listProjectFilesSchema = z52.object({
-  projectId: z52.string()
+var listProjectInvitesParamsSchema = z52.object({
+  id: z52.string(),
+  statuses: z52.string().optional().default(""),
+  limit: z52.coerce.number().optional().default(10),
+  page: z52.coerce.number().optional().default(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listInvites.js
+// ../../b4m-core/packages/services/dist/src/projectService/addSystemPrompts.js
 import { z as z53 } from "zod";
-var listProjectInvitesParamsSchema = z53.object({
-  id: z53.string(),
-  statuses: z53.string().optional().default(""),
-  limit: z53.coerce.number().optional().default(10),
-  page: z53.coerce.number().optional().default(1)
+var addSystemPromptsSchema = z53.object({
+  projectId: z53.string(),
+  fileIds: z53.array(z53.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/addSystemPrompts.js
+// ../../b4m-core/packages/services/dist/src/projectService/toggleSystemPrompt.js
 import { z as z54 } from "zod";
-var addSystemPromptsSchema = z54.object({
+var toggleSystemPromptSchema = z54.object({
   projectId: z54.string(),
-  fileIds: z54.array(z54.string())
+  fileId: z54.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/toggleSystemPrompt.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeSystemPrompt.js
 import { z as z55 } from "zod";
-var toggleSystemPromptSchema = z55.object({
+var removeSystemPromptSchema = z55.object({
   projectId: z55.string(),
   fileId: z55.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeSystemPrompt.js
-import { z as z56 } from "zod";
-var removeSystemPromptSchema = z56.object({
-  projectId: z56.string(),
-  fileId: z56.string()
-});
-
 // ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
-import { z as z59 } from "zod";
+import { z as z58 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/favoriteService/create.js
-import { z as z57 } from "zod";
-var createFavoriteParametersSchema = z57.object({
-  documentId: z57.string(),
-  documentType: z57.nativeEnum(FavoriteDocumentType)
+import { z as z56 } from "zod";
+var createFavoriteParametersSchema = z56.object({
+  documentId: z56.string(),
+  documentType: z56.nativeEnum(FavoriteDocumentType)
 });
 
 // ../../b4m-core/packages/services/dist/src/favoriteService/delete.js
-import { z as z58 } from "zod";
-var deleteFavoriteParametersSchema = z58.object({
-  documentId: z58.string(),
-  documentType: z58.nativeEnum(FavoriteDocumentType)
+import { z as z57 } from "zod";
+var deleteFavoriteParametersSchema = z57.object({
+  documentId: z57.string(),
+  documentType: z57.nativeEnum(FavoriteDocumentType)
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
-var addFavoriteParametersSchema = z59.object({
-  projectId: z59.string()
+var addFavoriteParametersSchema = z58.object({
+  projectId: z58.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/deleteFavorite.js
-import { z as z60 } from "zod";
-var deleteFavoriteParametersSchema2 = z60.object({
-  projectId: z60.string()
+import { z as z59 } from "zod";
+var deleteFavoriteParametersSchema2 = z59.object({
+  projectId: z59.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/removeNonExistentFiles.js
-import { z as z61 } from "zod";
-var removeNonExistentFilesSchema = z61.object({
-  projectId: z61.string()
+import { z as z60 } from "zod";
+var removeNonExistentFilesSchema = z60.object({
+  projectId: z60.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/leaveProject.js
-import { z as z62 } from "zod";
-var leaveProjectParamsSchema = z62.object({
-  id: z62.string(),
-  userIdToRemove: z62.string().optional()
+import { z as z61 } from "zod";
+var leaveProjectParamsSchema = z61.object({
+  id: z61.string(),
+  userIdToRemove: z61.string().optional()
   // Optional: if provided, this is a removal by owner
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/update.js
 import uniq3 from "lodash/uniq.js";
 import isEqual from "lodash/isEqual.js";
-import { z as z63 } from "zod";
-var updateSessionParamtersSchema = z63.object({
-  id: z63.string(),
-  name: z63.string().optional(),
-  knowledgeIds: z63.array(z63.string()).optional(),
-  artifactIds: z63.array(z63.string()).optional(),
-  tags: z63.array(z63.object({ name: z63.string(), strength: z63.number() })).optional(),
-  lastUsedModel: z63.string().optional()
+import { z as z62 } from "zod";
+var updateSessionParamtersSchema = z62.object({
+  id: z62.string(),
+  name: z62.string().optional(),
+  knowledgeIds: z62.array(z62.string()).optional(),
+  artifactIds: z62.array(z62.string()).optional(),
+  tags: z62.array(z62.object({ name: z62.string(), strength: z62.number() })).optional(),
+  lastUsedModel: z62.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/clone.js
-import { z as z64 } from "zod";
-var cloneSessionSchema = z64.object({
-  id: z64.string()
+import { z as z63 } from "zod";
+var cloneSessionSchema = z63.object({
+  id: z63.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/fork.js
+import { z as z64 } from "zod";
+var forkSessionSchema = z64.object({
+  sessionId: z64.string(),
+  messageId: z64.string()
+});
+
+// ../../b4m-core/packages/services/dist/src/sessionService/snip.js
 import { z as z65 } from "zod";
-var forkSessionSchema = z65.object({
+var snipSessionSchema = z65.object({
   sessionId: z65.string(),
   messageId: z65.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/snip.js
+// ../../b4m-core/packages/services/dist/src/sessionService/get.js
 import { z as z66 } from "zod";
-var snipSessionSchema = z66.object({
-  sessionId: z66.string(),
-  messageId: z66.string()
+var getSessionSchema = z66.object({
+  id: z66.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/get.js
+// ../../b4m-core/packages/services/dist/src/sessionService/deleteMessage.js
 import { z as z67 } from "zod";
-var getSessionSchema = z67.object({
-  id: z67.string()
+var deleteSessionMessageSchema = z67.object({
+  sessionId: z67.string(),
+  messageId: z67.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/deleteMessage.js
+// ../../b4m-core/packages/services/dist/src/sessionService/addFavorite.js
 import { z as z68 } from "zod";
-var deleteSessionMessageSchema = z68.object({
-  sessionId: z68.string(),
-  messageId: z68.string()
+var addFavoriteParametersSchema2 = z68.object({
+  sessionId: z68.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/addFavorite.js
+// ../../b4m-core/packages/services/dist/src/sessionService/deleteFavorite.js
 import { z as z69 } from "zod";
-var addFavoriteParametersSchema2 = z69.object({
+var deleteFavoriteParametersSchema3 = z69.object({
   sessionId: z69.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/deleteFavorite.js
-import { z as z70 } from "zod";
-var deleteFavoriteParametersSchema3 = z70.object({
-  sessionId: z70.string()
-});
-
 // ../../b4m-core/packages/services/dist/src/sessionService/autoName.js
-import { z as z71 } from "zod";
-var autoNameParameterSchema = z71.object({
-  sessionId: z71.string(),
+import { z as z70 } from "zod";
+var autoNameParameterSchema = z70.object({
+  sessionId: z70.string(),
   /** The maximum number of words to include in the title */
-  maxWords: z71.number().optional()
+  maxWords: z70.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/search.js
-import { z as z72 } from "zod";
-var searchSchema2 = z72.object({
+import { z as z71 } from "zod";
+var searchSchema2 = z71.object({
   /**
    * Text search query (searches in name and description)
    */
-  query: z72.string().optional(),
+  query: z71.string().optional(),
   /**
    * Filter by personal organizations
    */
-  filters: z72.object({
-    personal: z72.union([z72.enum(["true", "false"]).transform((val) => val === "true"), z72.boolean()]).optional(),
-    userId: z72.string().optional()
+  filters: z71.object({
+    personal: z71.union([z71.enum(["true", "false"]).transform((val) => val === "true"), z71.boolean()]).optional(),
+    userId: z71.string().optional()
   }).default({}),
-  pagination: z72.object({
-    page: z72.coerce.number().int().positive().default(1),
-    limit: z72.coerce.number().int().positive().max(100).default(10)
+  pagination: z71.object({
+    page: z71.coerce.number().int().positive().default(1),
+    limit: z71.coerce.number().int().positive().max(100).default(10)
   }).default({
     page: 1,
     limit: 10
   }),
-  orderBy: z72.object({
-    field: z72.enum(["name", "createdAt", "updatedAt"]).default("name"),
-    direction: z72.enum(["asc", "desc"]).default("asc")
+  orderBy: z71.object({
+    field: z71.enum(["name", "createdAt", "updatedAt"]).default("name"),
+    direction: z71.enum(["asc", "desc"]).default("asc")
   }).default({
     field: "name",
     direction: "asc"
@@ -4351,355 +3835,355 @@ var searchSchema2 = z72.object({
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/get.js
-import { z as z73 } from "zod";
-var getSchema = z73.object({
+import { z as z72 } from "zod";
+var getSchema = z72.object({
   /**
    * Organization ID
    */
-  id: z73.string().min(1)
+  id: z72.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/addMember.js
-import { z as z74 } from "zod";
-var addMemberSchema = z74.object({
-  userId: z74.string().optional(),
-  email: z74.string().optional(),
-  organizationId: z74.string(),
-  force: z74.boolean().optional()
+import { z as z73 } from "zod";
+var addMemberSchema = z73.object({
+  userId: z73.string().optional(),
+  email: z73.string().optional(),
+  organizationId: z73.string(),
+  force: z73.boolean().optional()
   // If true, add the user to the organization even if it's at full capacity
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/getUsers.js
-import { z as z75 } from "zod";
-var getUsersSchema = z75.object({
-  id: z75.string()
+import { z as z74 } from "zod";
+var getUsersSchema = z74.object({
+  id: z74.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/create.js
-import { z as z76 } from "zod";
-var createSchema = z76.object({
-  name: z76.string(),
-  personal: z76.boolean().default(false),
-  seats: z76.number().default(1),
-  stripeCustomerId: z76.string().nullable(),
-  billingOwnerId: z76.string().optional(),
+import { z as z75 } from "zod";
+var createSchema = z75.object({
+  name: z75.string(),
+  personal: z75.boolean().default(false),
+  seats: z75.number().default(1),
+  stripeCustomerId: z75.string().nullable(),
+  billingOwnerId: z75.string().optional(),
   // Optional billing owner (defaults to user if not provided)
-  managerId: z76.string().optional()
+  managerId: z75.string().optional()
   // Optional team manager
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/update.js
-import { z as z77 } from "zod";
-var updateSchema = z77.object({
-  id: z77.string(),
-  name: z77.string().optional(),
-  description: z77.string().optional(),
-  billingContact: z77.string().optional(),
-  currentCredits: z77.coerce.number().optional()
+import { z as z76 } from "zod";
+var updateSchema = z76.object({
+  id: z76.string(),
+  name: z76.string().optional(),
+  description: z76.string().optional(),
+  billingContact: z76.string().optional(),
+  currentCredits: z76.coerce.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/delete.js
-import { z as z78 } from "zod";
-var deleteSchema = z78.object({
+import { z as z77 } from "zod";
+var deleteSchema = z77.object({
   /**
    * Organization ID
    */
-  id: z78.string().min(1)
+  id: z77.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/listPendingUsers.js
-import { z as z79 } from "zod";
-var listPendingUsersSchema = z79.object({
-  organizationId: z79.string()
+import { z as z78 } from "zod";
+var listPendingUsersSchema = z78.object({
+  organizationId: z78.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/revokeAccess.js
-import { z as z80 } from "zod";
-var revokeAccessSchema = z80.object({
-  id: z80.string(),
-  userId: z80.string()
+import { z as z79 } from "zod";
+var revokeAccessSchema = z79.object({
+  id: z79.string(),
+  userId: z79.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/leave.js
-import { z as z81 } from "zod";
-var organizationLeaveSchema = z81.object({
-  id: z81.string()
+import { z as z80 } from "zod";
+var organizationLeaveSchema = z80.object({
+  id: z80.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/create.js
-import { z as z82 } from "zod";
-var createApiKeySchema = z82.object({
-  apiKey: z82.string().min(6),
-  description: z82.string().optional().default(""),
-  isActive: z82.boolean().optional().default(true),
-  type: z82.nativeEnum(ApiKeyType),
-  expireDays: z82.number().min(1).max(365).default(90)
+import { z as z81 } from "zod";
+var createApiKeySchema = z81.object({
+  apiKey: z81.string().min(6),
+  description: z81.string().optional().default(""),
+  isActive: z81.boolean().optional().default(true),
+  type: z81.nativeEnum(ApiKeyType),
+  expireDays: z81.number().min(1).max(365).default(90)
   // Default 90-day expiration
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/set.js
-import { z as z83 } from "zod";
-var setApiKeySchema = z83.object({
-  id: z83.string(),
-  type: z83.nativeEnum(ApiKeyType)
+import { z as z82 } from "zod";
+var setApiKeySchema = z82.object({
+  id: z82.string(),
+  type: z82.nativeEnum(ApiKeyType)
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/delete.js
-import { z as z84 } from "zod";
-var deleteApiKeySchema = z84.object({
-  id: z84.string()
+import { z as z83 } from "zod";
+var deleteApiKeySchema = z83.object({
+  id: z83.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/get.js
-import { z as z85 } from "zod";
-var getFabFileSchema = z85.object({
-  id: z85.string()
+import { z as z84 } from "zod";
+var getFabFileSchema = z84.object({
+  id: z84.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/list.js
-import { z as z86 } from "zod";
-var listFabFilesSchema = z86.object({
-  ids: z86.array(z86.string()).optional()
+import { z as z85 } from "zod";
+var listFabFilesSchema = z85.object({
+  ids: z85.array(z85.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/update.js
 import mime from "mime-types";
-import { v4 as uuidv43 } from "uuid";
-import { z as z87 } from "zod";
-var updateFabFileSchema = z87.object({
-  id: z87.string(),
-  fileName: z87.string(),
-  mimeType: z87.string(),
-  fileContent: z87.string().optional(),
-  type: z87.nativeEnum(KnowledgeType),
-  system: z87.boolean().optional(),
-  systemPriority: z87.number().min(0).max(999).optional(),
-  sessionId: z87.string().optional(),
-  notes: z87.string().optional(),
-  primaryTag: z87.string().optional(),
-  tags: z87.array(z87.object({
-    name: z87.string(),
-    strength: z87.number()
+import { v4 as uuidv42 } from "uuid";
+import { z as z86 } from "zod";
+var updateFabFileSchema = z86.object({
+  id: z86.string(),
+  fileName: z86.string(),
+  mimeType: z86.string(),
+  fileContent: z86.string().optional(),
+  type: z86.nativeEnum(KnowledgeType),
+  system: z86.boolean().optional(),
+  systemPriority: z86.number().min(0).max(999).optional(),
+  sessionId: z86.string().optional(),
+  notes: z86.string().optional(),
+  primaryTag: z86.string().optional(),
+  tags: z86.array(z86.object({
+    name: z86.string(),
+    strength: z86.number()
   })).optional(),
-  error: z87.string().nullable().optional()
+  error: z86.string().nullable().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/delete.js
-import { z as z88 } from "zod";
-var deleteFabFileSchema = z88.object({
-  id: z88.string()
+import { z as z87 } from "zod";
+var deleteFabFileSchema = z87.object({
+  id: z87.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/chunk.js
-import { z as z89 } from "zod";
-var chunkFileSchema = z89.object({
-  fabFileId: z89.string(),
-  embeddingModel: z89.string()
+import { z as z88 } from "zod";
+var chunkFileSchema = z88.object({
+  fabFileId: z88.string(),
+  embeddingModel: z88.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/vectorize.js
-import { z as z90 } from "zod";
-var vectorizeFabFileChunkSchema = z90.object({
-  fabFileId: z90.string(),
-  chunkId: z90.string()
+import { z as z89 } from "zod";
+var vectorizeFabFileChunkSchema = z89.object({
+  fabFileId: z89.string(),
+  chunkId: z89.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/listBySession.js
-import { z as z91 } from "zod";
-var listFabFilesBySessionSchema = z91.object({
-  sessionId: z91.string()
+import { z as z90 } from "zod";
+var listFabFilesBySessionSchema = z90.object({
+  sessionId: z90.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/listByQuest.js
-import { z as z92 } from "zod";
-var listFabFilesByQuestSchema = z92.object({
-  questId: z92.string()
+import { z as z91 } from "zod";
+var listFabFilesByQuestSchema = z91.object({
+  questId: z91.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/createByUrl.js
-import { z as z93 } from "zod";
-var createFabFileByUrlSchema = z93.object({
-  url: z93.string().regex(/^(?!https?:\/\/(drive|docs)\.google\.com\/(?:file\/d\/|open\?id=|uc\?id=|document\/d\/|spreadsheets\/d\/|presentation\/d\/|forms\/d\/|drive\/folders\/)([a-zA-Z0-9_-]{10,})).+/)
+import { z as z92 } from "zod";
+var createFabFileByUrlSchema = z92.object({
+  url: z92.string().regex(/^(?!https?:\/\/(drive|docs)\.google\.com\/(?:file\/d\/|open\?id=|uc\?id=|document\/d\/|spreadsheets\/d\/|presentation\/d\/|forms\/d\/|drive\/folders\/)([a-zA-Z0-9_-]{10,})).+/)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/search.js
-import { z as z94 } from "zod";
-var searchFabFilesSchema = z94.object({
-  search: z94.string().optional(),
-  filters: z94.object({
-    tags: z94.array(z94.string()).optional(),
-    type: z94.enum(["text", "pdf", "url", "image", "excel", "word", "json", "csv", "markdown", "code"]).optional(),
-    shared: z94.coerce.boolean().optional(),
+import { z as z93 } from "zod";
+var searchFabFilesSchema = z93.object({
+  search: z93.string().optional(),
+  filters: z93.object({
+    tags: z93.array(z93.string()).optional(),
+    type: z93.enum(["text", "pdf", "url", "image", "excel", "word", "json", "csv", "markdown", "code"]).optional(),
+    shared: z93.coerce.boolean().optional(),
     // Indicates if the user is searching for shared files
-    curated: z94.coerce.boolean().optional(),
+    curated: z93.coerce.boolean().optional(),
     // Indicates if the user is searching for curated notebook files
-    projectId: z94.string().optional(),
-    ids: z94.array(z94.string()).optional()
+    projectId: z93.string().optional(),
+    ids: z93.array(z93.string()).optional()
     // Add support for filtering by IDs
   }).optional(),
-  pagination: z94.object({
-    page: z94.coerce.number(),
-    limit: z94.coerce.number()
+  pagination: z93.object({
+    page: z93.coerce.number(),
+    limit: z93.coerce.number()
   }).optional(),
-  order: z94.object({
-    by: z94.enum(["createdAt", "fileName", "fileSize"]),
-    direction: z94.enum(["asc", "desc"])
+  order: z93.object({
+    by: z93.enum(["createdAt", "fileName", "fileSize"]),
+    direction: z93.enum(["asc", "desc"])
   }).optional(),
-  options: z94.object({
-    includeShared: z94.coerce.boolean().optional()
+  options: z93.object({
+    includeShared: z93.coerce.boolean().optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/addFavorite.js
-import { z as z95 } from "zod";
-var addFavoriteParametersSchema3 = z95.object({
-  fileId: z95.string()
+import { z as z94 } from "zod";
+var addFavoriteParametersSchema3 = z94.object({
+  fileId: z94.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/deleteFavorite.js
-import { z as z96 } from "zod";
-var deleteFavoriteParametersSchema4 = z96.object({
-  fileId: z96.string()
+import { z as z95 } from "zod";
+var deleteFavoriteParametersSchema4 = z95.object({
+  fileId: z95.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/toggleTags.js
-import { z as z97 } from "zod";
-var fabFileToggleTagsSchema = z97.object({
-  ids: z97.array(z97.string()),
-  tags: z97.array(z97.string())
+import { z as z96 } from "zod";
+var fabFileToggleTagsSchema = z96.object({
+  ids: z96.array(z96.string()),
+  tags: z96.array(z96.string())
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/edit.js
-import { z as z98 } from "zod";
+import { z as z97 } from "zod";
 import { diffLines } from "diff";
-var editFabFileSchema = z98.object({
-  id: z98.string(),
-  instruction: z98.string(),
-  selection: z98.object({
-    start: z98.number(),
-    end: z98.number()
+var editFabFileSchema = z97.object({
+  id: z97.string(),
+  instruction: z97.string(),
+  selection: z97.object({
+    start: z97.number(),
+    end: z97.number()
   }).optional(),
-  preserveFormatting: z98.boolean().optional().default(true),
-  applyImmediately: z98.boolean().optional().default(false)
+  preserveFormatting: z97.boolean().optional().default(true),
+  applyImmediately: z97.boolean().optional().default(false)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/applyEdit.js
 import mime2 from "mime-types";
-import { v4 as uuidv44 } from "uuid";
-import { z as z99 } from "zod";
-var applyEditSchema = z99.object({
-  id: z99.string(),
-  modifiedContent: z99.string(),
-  createBackup: z99.boolean().optional().default(true)
+import { v4 as uuidv43 } from "uuid";
+import { z as z98 } from "zod";
+var applyEditSchema = z98.object({
+  id: z98.string(),
+  modifiedContent: z98.string(),
+  createBackup: z98.boolean().optional().default(true)
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/respondToFriendRequest.js
-import { z as z100 } from "zod";
-var respondToFriendRequestSchema = z100.object({
-  id: z100.string(),
+import { z as z99 } from "zod";
+var respondToFriendRequestSchema = z99.object({
+  id: z99.string(),
   /** The user ID of the recipient of the friend request */
-  userId: z100.string(),
-  accept: z100.boolean()
+  userId: z99.string(),
+  accept: z99.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/unfriend.js
-import { z as z101 } from "zod";
-var unfriendSchema = z101.object({
-  friendshipId: z101.string(),
+import { z as z100 } from "zod";
+var unfriendSchema = z100.object({
+  friendshipId: z100.string(),
   /** The user ID of the user who wants to unfriend the other user */
-  userId: z101.string()
+  userId: z100.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/list.js
-import { z as z102 } from "zod";
-var listFriendsSchema = z102.object({
-  userId: z102.string()
+import { z as z101 } from "zod";
+var listFriendsSchema = z101.object({
+  userId: z101.string()
 });
-var listPendingFriendRequestsSchema = z102.object({
-  userId: z102.string()
+var listPendingFriendRequestsSchema = z101.object({
+  userId: z101.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/adminService/loginAs.js
-import { z as z103 } from "zod";
-var loginAsSchema = z103.object({
-  targetUserId: z103.string()
+import { z as z102 } from "zod";
+var loginAsSchema = z102.object({
+  targetUserId: z102.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/get.js
-import { z as z104 } from "zod";
-var getParamsSchema = z104.object({
-  key: z104.string()
+import { z as z103 } from "zod";
+var getParamsSchema = z103.object({
+  key: z103.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/set.js
-import { z as z105 } from "zod";
-var setParamsSchema = z105.object({
-  key: z105.string(),
-  value: z105.any(),
+import { z as z104 } from "zod";
+var setParamsSchema = z104.object({
+  key: z104.string(),
+  value: z104.any(),
   /**
    * Time to live in milliseconds
    */
-  ttl: z105.number(),
-  recache: z105.boolean().optional()
+  ttl: z104.number(),
+  recache: z104.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/ttl.js
-import { z as z106 } from "zod";
-var ttlParamsSchema = z106.object({
-  key: z106.string()
+import { z as z105 } from "zod";
+var ttlParamsSchema = z105.object({
+  key: z105.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/weeklyReports.js
-import { z as z107 } from "zod";
+import { z as z106 } from "zod";
 import dayjs3 from "dayjs";
-var weeklyReportSchema = z107.object({
-  startDate: z107.string(),
-  endDate: z107.string(),
-  report: z107.string(),
-  aiInsights: z107.string().nullable()
+var weeklyReportSchema = z106.object({
+  startDate: z106.string(),
+  endDate: z106.string(),
+  report: z106.string(),
+  aiInsights: z106.string().nullable()
 });
 
 // ../../b4m-core/packages/services/dist/src/embeddingCacheService/generateCacheKey.js
 import crypto2 from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/researchAgentService/create.js
+import { z as z107 } from "zod";
+var researchAgentCreateSchema = z107.object({
+  name: z107.string().min(1),
+  description: z107.string().min(1)
+});
+
+// ../../b4m-core/packages/services/dist/src/researchAgentService/update.js
 import { z as z108 } from "zod";
-var researchAgentCreateSchema = z108.object({
+var researchAgentUpdateSchema = z108.object({
+  id: z108.string(),
   name: z108.string().min(1),
   description: z108.string().min(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/update.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
 import { z as z109 } from "zod";
-var researchAgentUpdateSchema = z109.object({
-  id: z109.string(),
-  name: z109.string().min(1),
-  description: z109.string().min(1)
+var researchAgentRemoveSchema = z109.object({
+  id: z109.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
 import { z as z110 } from "zod";
-var researchAgentRemoveSchema = z110.object({
+var researchAgentGetSchema = z110.object({
   id: z110.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
-import { z as z111 } from "zod";
-var researchAgentGetSchema = z111.object({
-  id: z111.string()
-});
-
 // ../../b4m-core/packages/services/dist/src/researchAgentService/listFiles.js
-import { z as z112 } from "zod";
-var researchAgentListFilesSchema = z112.object({
+import { z as z111 } from "zod";
+var researchAgentListFilesSchema = z111.object({
   /**
    * The ID of the research agent
    */
-  id: z112.string()
+  id: z111.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-import { z as z113 } from "zod";
+import { z as z112 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/lib/turndown.js
 import turndown from "turndown";
@@ -5090,316 +4574,316 @@ var deepResearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-var ResearchTaskProcessSchema = z113.object({
-  id: z113.string()
+var ResearchTaskProcessSchema = z112.object({
+  id: z112.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/create.js
-import { z as z114 } from "zod";
-var researchTaskCreateSchema = z114.object({
-  researchAgentId: z114.string(),
-  title: z114.string().max(100),
-  description: z114.string().max(500),
-  prompt: z114.string().max(500).optional(),
-  type: z114.nativeEnum(ResearchTaskType),
-  executionType: z114.nativeEnum(ResearchTaskExecutionType).default(ResearchTaskExecutionType.ON_DEMAND),
-  fileTagId: z114.string().optional(),
-  autoGeneratedTag: z114.object({
-    name: z114.string(),
-    icon: z114.string(),
-    color: z114.string()
+import { z as z113 } from "zod";
+var researchTaskCreateSchema = z113.object({
+  researchAgentId: z113.string(),
+  title: z113.string().max(100),
+  description: z113.string().max(500),
+  prompt: z113.string().max(500).optional(),
+  type: z113.nativeEnum(ResearchTaskType),
+  executionType: z113.nativeEnum(ResearchTaskExecutionType).default(ResearchTaskExecutionType.ON_DEMAND),
+  fileTagId: z113.string().optional(),
+  autoGeneratedTag: z113.object({
+    name: z113.string(),
+    icon: z113.string(),
+    color: z113.string()
   }).optional()
 });
 var researchTaskScrapeCreateSchema = researchTaskCreateSchema.extend({
-  urls: z114.array(z114.string().url()).min(1),
-  canDiscoverLinks: z114.boolean()
+  urls: z113.array(z113.string().url()).min(1),
+  canDiscoverLinks: z113.boolean()
 });
 var researchTaskPeriodicCreateSchema = researchTaskCreateSchema.extend({
-  executionPeriodicStartAt: z114.coerce.date(),
-  executionPeriodicEndAt: z114.coerce.date(),
-  executionPeriodicFrequency: z114.nativeEnum(ResearchTaskPeriodicFrequencyType)
+  executionPeriodicStartAt: z113.coerce.date(),
+  executionPeriodicEndAt: z113.coerce.date(),
+  executionPeriodicFrequency: z113.nativeEnum(ResearchTaskPeriodicFrequencyType)
 });
 var researchTaskScheduledCreateSchema = researchTaskCreateSchema.extend({
-  executionScheduledAt: z114.coerce.date()
+  executionScheduledAt: z113.coerce.date()
 });
 var researchTaskDeepResearchCreateSchema = researchTaskCreateSchema.extend({
-  maxDepth: z114.number().min(1).max(10).optional()
+  maxDepth: z113.number().min(1).max(10).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/search.js
-import { z as z115 } from "zod";
-var searchResearchTasksSchema = z115.object({
-  search: z115.string().optional(),
+import { z as z114 } from "zod";
+var searchResearchTasksSchema = z114.object({
+  search: z114.string().optional(),
   // ADD FILTERS SCHEMA HERE
   // filters: z
   //   .object({
   //     userId: z.string().optional(),
   //   })
   //   .optional(),
-  pagination: z115.object({
-    page: z115.coerce.number().optional(),
-    limit: z115.coerce.number().optional()
+  pagination: z114.object({
+    page: z114.coerce.number().optional(),
+    limit: z114.coerce.number().optional()
   }).optional(),
-  orderBy: z115.object({
-    by: z115.enum(["createdAt", "updatedAt"]).optional(),
-    direction: z115.enum(["asc", "desc"]).optional()
+  orderBy: z114.object({
+    by: z114.enum(["createdAt", "updatedAt"]).optional(),
+    direction: z114.enum(["asc", "desc"]).optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/get.js
-import { z as z116 } from "zod";
-var getResearchTaskSchema = z116.object({
-  id: z116.string().min(1)
+import { z as z115 } from "zod";
+var getResearchTaskSchema = z115.object({
+  id: z115.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/update.js
-import { z as z117 } from "zod";
-var updateResearchTaskSchema = z117.object({
-  id: z117.string(),
-  title: z117.string(),
-  description: z117.string(),
-  type: z117.nativeEnum(ResearchTaskType)
+import { z as z116 } from "zod";
+var updateResearchTaskSchema = z116.object({
+  id: z116.string(),
+  title: z116.string(),
+  description: z116.string(),
+  type: z116.nativeEnum(ResearchTaskType)
 });
 var researchTaskScrapeUpdateSchema = updateResearchTaskSchema.extend({
-  urls: z117.array(z117.string().url()).min(1),
-  canDiscoverLinks: z117.boolean()
+  urls: z116.array(z116.string().url()).min(1),
+  canDiscoverLinks: z116.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/listByAgentId.js
-import { z as z118 } from "zod";
-var listByAgentIdSchema = z118.object({
-  researchAgentId: z118.string()
+import { z as z117 } from "zod";
+var listByAgentIdSchema = z117.object({
+  researchAgentId: z117.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/remove.js
-import { z as z119 } from "zod";
-var researchTaskRemoveSchema = z119.object({
-  id: z119.string().min(1)
+import { z as z118 } from "zod";
+var researchTaskRemoveSchema = z118.object({
+  id: z118.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/retry.js
-import { z as z120 } from "zod";
-var researchTaskRetrySchema = z120.object({
-  id: z120.string(),
-  userId: z120.string()
+import { z as z119 } from "zod";
+var researchTaskRetrySchema = z119.object({
+  id: z119.string(),
+  userId: z119.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/processDiscoveredLinks.js
 import axios4 from "axios";
-import { z as z121 } from "zod";
+import { z as z120 } from "zod";
 import plimit from "p-limit";
 import pLimit2 from "p-limit";
-var researchTaskProcessDiscoveredLinksSchema = z121.object({
-  id: z121.string()
+var researchTaskProcessDiscoveredLinksSchema = z120.object({
+  id: z120.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/downloadRelevantLinks.js
-import { z as z122 } from "zod";
+import { z as z121 } from "zod";
 import plimit2 from "p-limit";
 import axios5 from "axios";
 import { fileTypeFromBuffer } from "file-type";
-var researchTaskDownloadRelevantLinksSchema = z122.object({
-  id: z122.string()
+var researchTaskDownloadRelevantLinksSchema = z121.object({
+  id: z121.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchData/remove.js
-import { z as z123 } from "zod";
-var researchDataRemoveSchema = z123.object({
-  id: z123.string(),
-  researchAgentId: z123.string()
+import { z as z122 } from "zod";
+var researchDataRemoveSchema = z122.object({
+  id: z122.string(),
+  researchAgentId: z122.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/taskSchedulerService/create.js
-import { z as z124 } from "zod";
-var researchTaskPayload = z124.object({
-  id: z124.string(),
-  userId: z124.string()
+import { z as z123 } from "zod";
+var researchTaskPayload = z123.object({
+  id: z123.string(),
+  userId: z123.string()
 });
-var customTaskPayload = z124.object({
-  test: z124.string()
+var customTaskPayload = z123.object({
+  test: z123.string()
 });
-var taskSchedulerCreate = z124.discriminatedUnion("handler", [
-  z124.object({
-    handler: z124.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
+var taskSchedulerCreate = z123.discriminatedUnion("handler", [
+  z123.object({
+    handler: z123.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
     payload: researchTaskPayload,
-    processDate: z124.date()
+    processDate: z123.date()
   }),
-  z124.object({
-    handler: z124.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
+  z123.object({
+    handler: z123.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
     payload: customTaskPayload,
-    processDate: z124.date()
+    processDate: z123.date()
   })
 ]);
 
 // ../../b4m-core/packages/services/dist/src/tagService/createFileTag.js
+import { z as z124 } from "zod";
+var tagCreateFileTagSchema = z124.object({
+  name: z124.string(),
+  icon: z124.string().optional(),
+  color: z124.string().optional(),
+  description: z124.string().optional()
+});
+
+// ../../b4m-core/packages/services/dist/src/tagService/create.js
 import { z as z125 } from "zod";
-var tagCreateFileTagSchema = z125.object({
+var tagCreateSchema = z125.object({
   name: z125.string(),
   icon: z125.string().optional(),
+  description: z125.string().optional(),
   color: z125.string().optional(),
-  description: z125.string().optional()
+  type: z125.nativeEnum(TagType)
 });
 
-// ../../b4m-core/packages/services/dist/src/tagService/create.js
+// ../../b4m-core/packages/services/dist/src/tagService/update.js
 import { z as z126 } from "zod";
-var tagCreateSchema = z126.object({
-  name: z126.string(),
+var tagUpdateSchema = z126.object({
+  id: z126.string(),
+  name: z126.string().optional(),
   icon: z126.string().optional(),
   description: z126.string().optional(),
-  color: z126.string().optional(),
-  type: z126.nativeEnum(TagType)
-});
-
-// ../../b4m-core/packages/services/dist/src/tagService/update.js
-import { z as z127 } from "zod";
-var tagUpdateSchema = z127.object({
-  id: z127.string(),
-  name: z127.string().optional(),
-  icon: z127.string().optional(),
-  description: z127.string().optional(),
-  color: z127.string().optional()
+  color: z126.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/tagService/remove.js
-import { z as z128 } from "zod";
-var tagRemoveSchema = z128.object({
-  id: z128.string()
+import { z as z127 } from "zod";
+var tagRemoveSchema = z127.object({
+  id: z127.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/create.js
-import { z as z129 } from "zod";
-var createArtifactSchema = z129.object({
-  id: z129.string().optional(),
+import { z as z128 } from "zod";
+var createArtifactSchema = z128.object({
+  id: z128.string().optional(),
   // Allow custom ID for AI-generated artifacts
-  type: z129.enum(["mermaid", "recharts", "python", "react", "html", "svg", "code", "quest", "file", "questmaster"]),
-  title: z129.string().min(1).max(255),
-  description: z129.string().max(1e3).optional(),
-  content: z129.string().min(1),
-  projectId: z129.string().optional(),
-  organizationId: z129.string().optional(),
-  visibility: z129.enum(["private", "project", "organization", "public"]).default("private"),
-  tags: z129.array(z129.string().max(50)).max(20).default([]),
-  versionTag: z129.string().max(100).optional(),
-  sourceQuestId: z129.string().optional(),
-  sessionId: z129.string().optional(),
-  parentArtifactId: z129.string().optional(),
-  permissions: z129.object({
-    canRead: z129.array(z129.string()).default([]),
-    canWrite: z129.array(z129.string()).default([]),
-    canDelete: z129.array(z129.string()).default([]),
-    isPublic: z129.boolean().default(false),
-    inheritFromProject: z129.boolean().default(true)
+  type: z128.enum(["mermaid", "recharts", "python", "react", "html", "svg", "code", "quest", "file", "questmaster"]),
+  title: z128.string().min(1).max(255),
+  description: z128.string().max(1e3).optional(),
+  content: z128.string().min(1),
+  projectId: z128.string().optional(),
+  organizationId: z128.string().optional(),
+  visibility: z128.enum(["private", "project", "organization", "public"]).default("private"),
+  tags: z128.array(z128.string().max(50)).max(20).default([]),
+  versionTag: z128.string().max(100).optional(),
+  sourceQuestId: z128.string().optional(),
+  sessionId: z128.string().optional(),
+  parentArtifactId: z128.string().optional(),
+  permissions: z128.object({
+    canRead: z128.array(z128.string()).default([]),
+    canWrite: z128.array(z128.string()).default([]),
+    canDelete: z128.array(z128.string()).default([]),
+    isPublic: z128.boolean().default(false),
+    inheritFromProject: z128.boolean().default(true)
   }).optional(),
-  metadata: z129.record(z129.unknown()).default({})
+  metadata: z128.record(z128.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/get.js
-import { z as z130 } from "zod";
-var getArtifactSchema = z130.object({
-  id: z130.string(),
-  includeContent: z130.boolean().default(false),
-  includeVersions: z130.boolean().default(false),
-  version: z130.number().optional()
+import { z as z129 } from "zod";
+var getArtifactSchema = z129.object({
+  id: z129.string(),
+  includeContent: z129.boolean().default(false),
+  includeVersions: z129.boolean().default(false),
+  version: z129.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/list.js
-import { z as z131 } from "zod";
-var listArtifactsSchema = z131.object({
-  type: z131.string().optional(),
-  status: z131.enum(["draft", "review", "published", "archived"]).optional(),
-  visibility: z131.enum(["private", "project", "organization", "public"]).optional(),
-  projectId: z131.string().optional(),
-  sessionId: z131.string().optional(),
-  tags: z131.array(z131.string()).optional(),
-  search: z131.string().optional(),
-  limit: z131.number().min(1).max(100).default(20),
-  offset: z131.number().min(0).default(0),
-  sortBy: z131.enum(["createdAt", "updatedAt", "title", "type"]).default("updatedAt"),
-  sortOrder: z131.enum(["asc", "desc"]).default("desc"),
-  includeDeleted: z131.boolean().default(false)
+import { z as z130 } from "zod";
+var listArtifactsSchema = z130.object({
+  type: z130.string().optional(),
+  status: z130.enum(["draft", "review", "published", "archived"]).optional(),
+  visibility: z130.enum(["private", "project", "organization", "public"]).optional(),
+  projectId: z130.string().optional(),
+  sessionId: z130.string().optional(),
+  tags: z130.array(z130.string()).optional(),
+  search: z130.string().optional(),
+  limit: z130.number().min(1).max(100).default(20),
+  offset: z130.number().min(0).default(0),
+  sortBy: z130.enum(["createdAt", "updatedAt", "title", "type"]).default("updatedAt"),
+  sortOrder: z130.enum(["asc", "desc"]).default("desc"),
+  includeDeleted: z130.boolean().default(false)
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/update.js
-import { z as z132 } from "zod";
-var updateArtifactSchema = z132.object({
-  id: z132.string(),
-  title: z132.string().min(1).max(255).optional(),
-  description: z132.string().max(1e3).optional(),
-  content: z132.string().optional(),
-  visibility: z132.enum(["private", "project", "organization", "public"]).optional(),
-  status: z132.enum(["draft", "review", "published", "archived"]).optional(),
-  tags: z132.array(z132.string().max(50)).max(20).optional(),
-  versionTag: z132.string().max(100).optional(),
-  permissions: z132.object({
-    canRead: z132.array(z132.string()).optional(),
-    canWrite: z132.array(z132.string()).optional(),
-    canDelete: z132.array(z132.string()).optional(),
-    isPublic: z132.boolean().optional(),
-    inheritFromProject: z132.boolean().optional()
+import { z as z131 } from "zod";
+var updateArtifactSchema = z131.object({
+  id: z131.string(),
+  title: z131.string().min(1).max(255).optional(),
+  description: z131.string().max(1e3).optional(),
+  content: z131.string().optional(),
+  visibility: z131.enum(["private", "project", "organization", "public"]).optional(),
+  status: z131.enum(["draft", "review", "published", "archived"]).optional(),
+  tags: z131.array(z131.string().max(50)).max(20).optional(),
+  versionTag: z131.string().max(100).optional(),
+  permissions: z131.object({
+    canRead: z131.array(z131.string()).optional(),
+    canWrite: z131.array(z131.string()).optional(),
+    canDelete: z131.array(z131.string()).optional(),
+    isPublic: z131.boolean().optional(),
+    inheritFromProject: z131.boolean().optional()
   }).optional(),
-  metadata: z132.record(z132.unknown()).optional(),
-  changes: z132.array(z132.string()).optional(),
-  changeDescription: z132.string().max(1e3).optional(),
-  createNewVersion: z132.boolean().optional(),
-  versionMessage: z132.string().max(500).optional()
+  metadata: z131.record(z131.unknown()).optional(),
+  changes: z131.array(z131.string()).optional(),
+  changeDescription: z131.string().max(1e3).optional(),
+  createNewVersion: z131.boolean().optional(),
+  versionMessage: z131.string().max(500).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/delete.js
-import { z as z133 } from "zod";
-var deleteArtifactSchema = z133.object({
-  id: z133.string(),
-  hardDelete: z133.boolean().default(false)
+import { z as z132 } from "zod";
+var deleteArtifactSchema = z132.object({
+  id: z132.string(),
+  hardDelete: z132.boolean().default(false)
   // For future implementation
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/create.js
-import { z as z134 } from "zod";
-var questSchema = z134.object({
-  id: z134.string(),
-  title: z134.string().min(1).max(255),
-  description: z134.string().max(1e3),
-  status: z134.enum(["not_started", "in_progress", "completed", "blocked"]).default("not_started"),
-  order: z134.number().min(0),
-  dependencies: z134.array(z134.string()).default([]),
-  estimatedTime: z134.string().optional()
-});
-var questResourceSchema = z134.object({
-  title: z134.string().min(1).max(255),
-  url: z134.string().url(),
-  type: z134.enum(["documentation", "tutorial", "reference", "example"])
-});
-var createQuestMasterSchema = z134.object({
-  title: z134.string().min(1).max(255),
-  description: z134.string().max(1e3).optional(),
-  goal: z134.string().min(1).max(1e3),
-  complexity: z134.enum(["beginner", "intermediate", "advanced", "expert"]),
-  estimatedTotalTime: z134.string().optional(),
-  prerequisites: z134.array(z134.string().max(200)).default([]),
-  quests: z134.array(questSchema).min(1),
-  resources: z134.array(questResourceSchema).default([]),
-  projectId: z134.string().optional(),
-  organizationId: z134.string().optional(),
-  visibility: z134.enum(["private", "project", "organization", "public"]).default("private"),
-  tags: z134.array(z134.string().max(50)).max(20).default([]),
-  permissions: z134.object({
-    canRead: z134.array(z134.string()).default([]),
-    canWrite: z134.array(z134.string()).default([]),
-    canDelete: z134.array(z134.string()).default([]),
-    isPublic: z134.boolean().default(false),
-    inheritFromProject: z134.boolean().default(true)
+import { z as z133 } from "zod";
+var questSchema = z133.object({
+  id: z133.string(),
+  title: z133.string().min(1).max(255),
+  description: z133.string().max(MAX_DESCRIPTION_LENGTH),
+  status: z133.enum(["not_started", "in_progress", "completed", "blocked"]).default("not_started"),
+  order: z133.number().min(0),
+  dependencies: z133.array(z133.string()).default([]),
+  estimatedTime: z133.string().optional()
+});
+var questResourceSchema = z133.object({
+  title: z133.string().min(1).max(255),
+  url: z133.string().url(),
+  type: z133.enum(["documentation", "tutorial", "reference", "example"])
+});
+var createQuestMasterSchema = z133.object({
+  title: z133.string().min(1).max(255),
+  description: z133.string().max(MAX_DESCRIPTION_LENGTH).optional(),
+  goal: z133.string().min(1).max(MAX_GOAL_LENGTH),
+  complexity: z133.enum(["beginner", "intermediate", "advanced", "expert"]),
+  estimatedTotalTime: z133.string().optional(),
+  prerequisites: z133.array(z133.string().max(200)).default([]),
+  quests: z133.array(questSchema).min(1),
+  resources: z133.array(questResourceSchema).default([]),
+  projectId: z133.string().optional(),
+  organizationId: z133.string().optional(),
+  visibility: z133.enum(["private", "project", "organization", "public"]).default("private"),
+  tags: z133.array(z133.string().max(MAX_TAG_LENGTH)).max(20).default([]),
+  permissions: z133.object({
+    canRead: z133.array(z133.string()).default([]),
+    canWrite: z133.array(z133.string()).default([]),
+    canDelete: z133.array(z133.string()).default([]),
+    isPublic: z133.boolean().default(false),
+    inheritFromProject: z133.boolean().default(true)
   }).optional(),
-  sourceQuestId: z134.string().optional(),
-  sessionId: z134.string().optional(),
-  metadata: z134.record(z134.unknown()).default({})
+  sourceQuestId: z133.string().optional(),
+  sessionId: z133.string().optional(),
+  metadata: z133.record(z133.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/updateQuestStatus.js
-import { z as z135 } from "zod";
-var updateQuestStatusSchema = z135.object({
-  artifactId: z135.string(),
-  questId: z135.string(),
-  status: z135.enum(["not_started", "in_progress", "completed", "blocked"]),
-  completionNote: z135.string().max(500).optional()
+import { z as z134 } from "zod";
+var updateQuestStatusSchema = z134.object({
+  artifactId: z134.string(),
+  questId: z134.string(),
+  status: z134.enum(["not_started", "in_progress", "completed", "blocked"]),
+  completionNote: z134.string().max(500).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/dataLakeService/opensearchClient.js
@@ -5413,69 +4897,69 @@ import { toFile } from "openai/uploads";
 import { Readable } from "stream";
 import { TranscribeClient, StartTranscriptionJobCommand, GetTranscriptionJobCommand, LanguageCode, MediaFormat } from "@aws-sdk/client-transcribe";
 import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand } from "@aws-sdk/client-s3";
-import { v4 as uuidv45 } from "uuid";
+import { v4 as uuidv44 } from "uuid";
 
 // ../../b4m-core/packages/services/dist/src/emailIngestionService/processIngestedEmail.js
 import { randomUUID as randomUUID5 } from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/emailIngestionService/types.js
-import { z as z136 } from "zod";
-var processIngestedEmailOptionsSchema = z136.object({
-  platformDomain: z136.string().optional(),
-  isNewsletter: z136.boolean().optional()
+import { z as z135 } from "zod";
+var processIngestedEmailOptionsSchema = z135.object({
+  platformDomain: z135.string().optional(),
+  isNewsletter: z135.boolean().optional()
 }).optional();
-var emailAttachmentSchema = z136.object({
-  filename: z136.string().optional(),
-  contentType: z136.string().optional(),
-  contentDisposition: z136.string().optional(),
-  size: z136.number().min(0),
-  content: z136.instanceof(Buffer),
-  related: z136.boolean().optional()
-});
-var parsedEmailObjectSchema = z136.object({
-  messageId: z136.string().optional(),
-  inReplyTo: z136.string().optional(),
-  references: z136.union([z136.string(), z136.array(z136.string())]).optional(),
-  from: z136.any().optional(),
+var emailAttachmentSchema = z135.object({
+  filename: z135.string().optional(),
+  contentType: z135.string().optional(),
+  contentDisposition: z135.string().optional(),
+  size: z135.number().min(0),
+  content: z135.instanceof(Buffer),
+  related: z135.boolean().optional()
+});
+var parsedEmailObjectSchema = z135.object({
+  messageId: z135.string().optional(),
+  inReplyTo: z135.string().optional(),
+  references: z135.union([z135.string(), z135.array(z135.string())]).optional(),
+  from: z135.any().optional(),
   // Complex email address object
-  to: z136.any().optional(),
-  cc: z136.any().optional(),
-  bcc: z136.any().optional(),
-  subject: z136.string().optional(),
-  date: z136.date().optional(),
-  text: z136.string().optional(),
-  html: z136.string().optional(),
-  attachments: z136.array(emailAttachmentSchema).optional()
-});
-var processIngestedEmailSchema = z136.object({
+  to: z135.any().optional(),
+  cc: z135.any().optional(),
+  bcc: z135.any().optional(),
+  subject: z135.string().optional(),
+  date: z135.date().optional(),
+  text: z135.string().optional(),
+  html: z135.string().optional(),
+  attachments: z135.array(emailAttachmentSchema).optional()
+});
+var processIngestedEmailSchema = z135.object({
   parsedEmail: parsedEmailObjectSchema,
-  rawEmailS3Key: z136.string().min(1, "rawEmailS3Key cannot be empty"),
+  rawEmailS3Key: z135.string().min(1, "rawEmailS3Key cannot be empty"),
   options: processIngestedEmailOptionsSchema
 });
 
 // ../../b4m-core/packages/services/dist/src/emailAnalysisService/types.js
-import { z as z137 } from "zod";
-var llmAnalysisResponseSchema = z137.object({
-  summary: z137.string().min(1, "Summary cannot be empty"),
-  entities: z137.object({
-    companies: z137.array(z137.string()).default([]),
-    people: z137.array(z137.string()).default([]),
-    products: z137.array(z137.string()).default([]),
-    technologies: z137.array(z137.string()).default([])
+import { z as z136 } from "zod";
+var llmAnalysisResponseSchema = z136.object({
+  summary: z136.string().min(1, "Summary cannot be empty"),
+  entities: z136.object({
+    companies: z136.array(z136.string()).default([]),
+    people: z136.array(z136.string()).default([]),
+    products: z136.array(z136.string()).default([]),
+    technologies: z136.array(z136.string()).default([])
   }),
-  sentiment: z137.enum(["positive", "neutral", "negative", "urgent"]),
-  actionItems: z137.array(z137.object({
-    description: z137.string(),
-    deadline: z137.string().optional()
+  sentiment: z136.enum(["positive", "neutral", "negative", "urgent"]),
+  actionItems: z136.array(z136.object({
+    description: z136.string(),
+    deadline: z136.string().optional()
     // ISO date string from LLM
   })).default([]),
-  privacyRecommendation: z137.enum(["public", "team", "private"]),
-  embargoDetected: z137.boolean().default(false),
-  suggestedTags: z137.array(z137.string()).default([])
+  privacyRecommendation: z136.enum(["public", "team", "private"]),
+  embargoDetected: z136.boolean().default(false),
+  suggestedTags: z136.array(z136.string()).default([])
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletion.js
-import { z as z139 } from "zod";
+import { z as z138 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionInvoke.js
 import { fromZodError } from "zod-validation-error";
@@ -5484,7 +4968,7 @@ import { fromZodError } from "zod-validation-error";
 var BUILT_IN_TOOL_SET = new Set(b4mLLMTools.options);
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/ToolCacheManager.js
-var DEFAULT_CONFIG2 = {
+var DEFAULT_CONFIG = {
   ttl: 5 * 60 * 1e3,
   // 5 minutes
   maxFailures: 3
@@ -5574,7 +5058,7 @@ var weatherTool = {
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/imageGeneration/index.js
 import axios6 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer2 } from "file-type";
-import { v4 as uuidv46 } from "uuid";
+import { v4 as uuidv45 } from "uuid";
 async function downloadImage(url) {
   if (url.startsWith("data:image/")) {
     const base64Data = url.split(",")[1];
@@ -5588,9 +5072,9 @@ async function processAndStoreImages(images, context) {
   return Promise.all(images.map(async (image) => {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
-    const filename = `${uuidv46()}.${fileType?.ext}`;
-    const path17 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path17;
+    const filename = `${uuidv45()}.${fileType?.ext}`;
+    const path16 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path16;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -6563,17 +6047,17 @@ var rechartsTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editFile/index.js
-import { z as z138 } from "zod";
+import { z as z137 } from "zod";
 import { diffLines as diffLines2 } from "diff";
-var editFileSchema = z138.object({
-  fileId: z138.string().describe("The ID of the file to edit"),
-  instruction: z138.string().describe("Natural language instruction describing the changes to make"),
-  selection: z138.object({
-    start: z138.number().describe("Starting character position of the selection"),
-    end: z138.number().describe("Ending character position of the selection")
+var editFileSchema = z137.object({
+  fileId: z137.string().describe("The ID of the file to edit"),
+  instruction: z137.string().describe("Natural language instruction describing the changes to make"),
+  selection: z137.object({
+    start: z137.number().describe("Starting character position of the selection"),
+    end: z137.number().describe("Ending character position of the selection")
   }).optional().describe("Optional selection range to edit within the file"),
-  preserveFormatting: z138.boolean().optional().default(true).describe("Whether to preserve the original formatting style"),
-  returnDiff: z138.boolean().optional().default(true).describe("Whether to return a diff of the changes")
+  preserveFormatting: z137.boolean().optional().default(true).describe("Whether to preserve the original formatting style"),
+  returnDiff: z137.boolean().optional().default(true).describe("Whether to return a diff of the changes")
 });
 function generateSimpleDiff(original, modified) {
   const differences = diffLines2(original, modified);
@@ -6757,7 +6241,7 @@ Return only the edited content without any markdown code blocks or explanations.
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/imageEdit/index.js
 import axios7 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer3 } from "file-type";
-import { v4 as uuidv47 } from "uuid";
+import { v4 as uuidv46 } from "uuid";
 async function downloadImage2(url) {
   if (url.startsWith("data:image/")) {
     const base64Data = url.split(",")[1];
@@ -6801,9 +6285,9 @@ async function getImageFromFileId(fileId, context) {
 async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
-  const filename = `${uuidv47()}.${fileType?.ext}`;
-  const path17 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path17;
+  const filename = `${uuidv46()}.${fileType?.ext}`;
+  const path16 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path16;
 }
 async function updateQuestAndReturnMarkdown2(storedImagePath, context) {
   await context.onFinish?.("edit_image", storedImagePath);
@@ -8332,8 +7816,8 @@ var getHeliocentricCoords = (planet, T) => {
   const sinNode = Math.sin(longNode);
   const x = r * (cosNode * cosOmega - sinNode * sinOmega * cosI);
   const y = r * (sinNode * cosOmega + cosNode * sinOmega * cosI);
-  const z145 = r * sinOmega * sinI;
-  return { x, y, z: z145, r };
+  const z144 = r * sinOmega * sinI;
+  return { x, y, z: z144, r };
 };
 var getGeocentricEcliptic = (planet, earth) => {
   const dx = planet.x - earth.x;
@@ -8640,19 +8124,19 @@ var planetVisibilityTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
-import { promises as fs8 } from "fs";
-import { existsSync as existsSync4, statSync as statSync4 } from "fs";
-import path7 from "path";
+import { promises as fs7 } from "fs";
+import { existsSync as existsSync3, statSync as statSync4 } from "fs";
+import path6 from "path";
 var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 async function readFileContent(params) {
   const { path: filePath, encoding = "utf-8", maxLines } = params;
-  const normalizedPath = path7.normalize(filePath);
-  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
-  const cwd = path7.resolve(process.cwd());
+  const normalizedPath = path6.normalize(filePath);
+  const resolvedPath = path6.resolve(process.cwd(), normalizedPath);
+  const cwd = path6.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
-  if (!existsSync4(resolvedPath)) {
+  if (!existsSync3(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   const stats = statSync4(resolvedPath);
@@ -8666,7 +8150,7 @@ async function readFileContent(params) {
   if (isBinary && encoding === "utf-8") {
     throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
   }
-  const content = await fs8.readFile(resolvedPath, encoding);
+  const content = await fs7.readFile(resolvedPath, encoding);
   if (maxLines && typeof content === "string") {
     const lines = content.split("\n");
     if (lines.length > maxLines) {
@@ -8681,7 +8165,7 @@ ${content}`;
 }
 async function checkIfBinary(filePath) {
   const buffer = Buffer.alloc(8192);
-  const fd = await fs8.open(filePath, "r");
+  const fd = await fs7.open(filePath, "r");
   try {
     const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
     const chunk = buffer.slice(0, bytesRead);
@@ -8698,7 +8182,7 @@ var fileReadTool = {
       context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
       try {
         const content = await readFileContent(params);
-        const stats = statSync4(path7.resolve(process.cwd(), path7.normalize(params.path)));
+        const stats = statSync4(path6.resolve(process.cwd(), path6.normalize(params.path)));
         context.logger.info("\u2705 FileRead: Success", {
           path: params.path,
           size: stats.size,
@@ -8738,25 +8222,25 @@ var fileReadTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
-import { promises as fs9 } from "fs";
-import { existsSync as existsSync5 } from "fs";
-import path8 from "path";
+import { promises as fs8 } from "fs";
+import { existsSync as existsSync4 } from "fs";
+import path7 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
-  const normalizedPath = path8.normalize(filePath);
-  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
-  const cwd = path8.resolve(process.cwd());
+  const normalizedPath = path7.normalize(filePath);
+  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
+  const cwd = path7.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
-  const fileExists = existsSync5(resolvedPath);
+  const fileExists = existsSync4(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
-    const dir = path8.dirname(resolvedPath);
-    await fs9.mkdir(dir, { recursive: true });
+    const dir = path7.dirname(resolvedPath);
+    await fs8.mkdir(dir, { recursive: true });
   }
-  await fs9.writeFile(resolvedPath, content, "utf-8");
-  const stats = await fs9.stat(resolvedPath);
+  await fs8.writeFile(resolvedPath, content, "utf-8");
+  const stats = await fs8.stat(resolvedPath);
   const lines = content.split("\n").length;
   return `File ${action} successfully: ${filePath}
 Size: ${stats.size} bytes
@@ -8767,7 +8251,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync5(path8.resolve(process.cwd(), path8.normalize(params.path)));
+      const fileExists = existsSync4(path7.resolve(process.cwd(), path7.normalize(params.path)));
       context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
         path: params.path,
         size: params.content.length
@@ -8809,7 +8293,7 @@ var createFileTool = {
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
 import { glob } from "glob";
 import { stat } from "fs/promises";
-import path9 from "path";
+import path8 from "path";
 var DEFAULT_IGNORE_PATTERNS2 = [
   "**/node_modules/**",
   "**/.git/**",
@@ -8825,7 +8309,7 @@ var DEFAULT_IGNORE_PATTERNS2 = [
 async function findFiles(params) {
   const { pattern, dir_path, case_sensitive = true, respect_git_ignore = true } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path9.resolve(baseCwd, path9.normalize(dir_path)) : baseCwd;
+  const targetDir = dir_path ? path8.resolve(baseCwd, path8.normalize(dir_path)) : baseCwd;
   if (!targetDir.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot search outside of current working directory`);
   }
@@ -8865,7 +8349,7 @@ async function findFiles(params) {
   const summary = `Found ${filesWithStats.length} file(s)${truncated ? ` (showing first ${MAX_RESULTS})` : ""} matching: ${pattern}`;
   const dirInfo = dir_path ? `
 Directory: ${dir_path}` : "";
-  const filesList = results.map((file) => path9.relative(baseCwd, file.path)).join("\n");
+  const filesList = results.map((file) => path8.relative(baseCwd, file.path)).join("\n");
   return `${summary}${dirInfo}
 
 ${filesList}`;
@@ -8920,7 +8404,7 @@ var globFilesTool = {
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
 import { globStream } from "glob";
 import { readFile, stat as stat2 } from "fs/promises";
-import path10 from "path";
+import path9 from "path";
 var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
 var DEFAULT_IGNORE_PATTERNS3 = [
   "**/node_modules/**",
@@ -8949,14 +8433,14 @@ async function isBinaryFile2(filePath) {
   }
 }
 function isPathWithinWorkspace(targetPath, baseCwd) {
-  const resolvedTarget = path10.resolve(targetPath);
-  const resolvedBase = path10.resolve(baseCwd);
+  const resolvedTarget = path9.resolve(targetPath);
+  const resolvedBase = path9.resolve(baseCwd);
   return resolvedTarget.startsWith(resolvedBase);
 }
 async function searchFiles2(params) {
   const { pattern, dir_path, include } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path10.resolve(baseCwd, dir_path) : baseCwd;
+  const targetDir = dir_path ? path9.resolve(baseCwd, dir_path) : baseCwd;
   if (!isPathWithinWorkspace(targetDir, baseCwd)) {
     throw new Error(`Path validation failed: "${dir_path}" resolves outside the allowed workspace directory`);
   }
@@ -9009,7 +8493,7 @@ async function searchFiles2(params) {
       lines.forEach((line, index) => {
         if (allMatches.length < maxMatches && searchRegex.test(line)) {
           allMatches.push({
-            filePath: path10.relative(targetDir, fileAbsPath) || path10.basename(fileAbsPath),
+            filePath: path9.relative(targetDir, fileAbsPath) || path9.basename(fileAbsPath),
             lineNumber: index + 1,
             line
           });
@@ -9102,18 +8586,18 @@ var grepSearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
-import { promises as fs10 } from "fs";
-import { existsSync as existsSync6, statSync as statSync5 } from "fs";
-import path11 from "path";
+import { promises as fs9 } from "fs";
+import { existsSync as existsSync5, statSync as statSync5 } from "fs";
+import path10 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
-  const normalizedPath = path11.normalize(filePath);
-  const resolvedPath = path11.resolve(process.cwd(), normalizedPath);
-  const cwd = path11.resolve(process.cwd());
+  const normalizedPath = path10.normalize(filePath);
+  const resolvedPath = path10.resolve(process.cwd(), normalizedPath);
+  const cwd = path10.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
-  if (!existsSync6(resolvedPath)) {
+  if (!existsSync5(resolvedPath)) {
     throw new Error(`File or directory not found: ${filePath}`);
   }
   const stats = statSync5(resolvedPath);
@@ -9123,10 +8607,10 @@ async function deleteFile(params) {
     throw new Error(`Path is a directory: ${filePath}. Use recursive=true to delete directories and their contents.`);
   }
   if (isDirectory) {
-    await fs10.rm(resolvedPath, { recursive: true, force: true });
+    await fs9.rm(resolvedPath, { recursive: true, force: true });
     return `Directory deleted successfully: ${filePath}`;
   } else {
-    await fs10.unlink(resolvedPath);
+    await fs9.unlink(resolvedPath);
     return `File deleted successfully: ${filePath}
 Size: ${size} bytes`;
   }
@@ -9136,8 +8620,8 @@ var deleteFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const resolvedPath = path11.resolve(process.cwd(), path11.normalize(params.path));
-      const isDirectory = existsSync6(resolvedPath) && statSync5(resolvedPath).isDirectory();
+      const resolvedPath = path10.resolve(process.cwd(), path10.normalize(params.path));
+      const isDirectory = existsSync5(resolvedPath) && statSync5(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -9174,7 +8658,7 @@ var deleteFileTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
 import { spawn } from "child_process";
-import path12 from "path";
+import path11 from "path";
 var DEFAULT_TIMEOUT_MS = 6e4;
 var MAX_OUTPUT_SIZE = 100 * 1024;
 var DANGEROUS_PATTERNS = [
@@ -9358,7 +8842,7 @@ async function executeBashCommand(params) {
     };
   }
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path12.resolve(baseCwd, relativeCwd) : baseCwd;
+  const targetCwd = relativeCwd ? path11.resolve(baseCwd, relativeCwd) : baseCwd;
   const effectiveTimeout = Math.min(timeout, 5 * 60 * 1e3);
   return new Promise((resolve3) => {
     let stdout = "";
@@ -9548,9 +9032,9 @@ BLOCKED OPERATIONS:
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editLocalFile/index.js
-import { promises as fs11 } from "fs";
-import { existsSync as existsSync7 } from "fs";
-import path13 from "path";
+import { promises as fs10 } from "fs";
+import { existsSync as existsSync6 } from "fs";
+import path12 from "path";
 import { diffLines as diffLines3 } from "diff";
 function generateDiff(original, modified) {
   const differences = diffLines3(original, modified);
@@ -9574,16 +9058,16 @@ function generateDiff(original, modified) {
 }
 async function editLocalFile(params) {
   const { path: filePath, old_string, new_string } = params;
-  const normalizedPath = path13.normalize(filePath);
-  const resolvedPath = path13.resolve(process.cwd(), normalizedPath);
-  const cwd = path13.resolve(process.cwd());
+  const normalizedPath = path12.normalize(filePath);
+  const resolvedPath = path12.resolve(process.cwd(), normalizedPath);
+  const cwd = path12.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot edit files outside of current working directory`);
   }
-  if (!existsSync7(resolvedPath)) {
+  if (!existsSync6(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const currentContent = await fs11.readFile(resolvedPath, "utf-8");
+  const currentContent = await fs10.readFile(resolvedPath, "utf-8");
   if (!currentContent.includes(old_string)) {
     const preview = old_string.length > 100 ? old_string.substring(0, 100) + "..." : old_string;
     throw new Error(`String to replace not found in file. Make sure the old_string matches exactly (including whitespace and line endings). Searched for: "${preview}"`);
@@ -9593,7 +9077,7 @@ async function editLocalFile(params) {
     throw new Error(`Found ${occurrences} occurrences of the string to replace. Please provide a more specific old_string that matches exactly one location.`);
   }
   const newContent = currentContent.replace(old_string, new_string);
-  await fs11.writeFile(resolvedPath, newContent, "utf-8");
+  await fs10.writeFile(resolvedPath, newContent, "utf-8");
   const diffResult = generateDiff(old_string, new_string);
   return `File edited successfully: ${filePath}
 Changes: +${diffResult.additions} lines, -${diffResult.deletions} lines
@@ -9729,7 +9213,7 @@ var generateMcpTools = async (mcpData) => {
     };
     const optionTools = {
       toolFn: async (args) => {
-        console.log(`Calling ${name} tool via ${mcpData.serverName}`, args);
+        Logger.debug(`Calling ${name} tool via ${mcpData.serverName}`, args);
         try {
           const toolResult = await mcpData.callTool(name, args);
           const contentBlocks = toolResult?.content;
@@ -9740,11 +9224,11 @@ var generateMcpTools = async (mcpData) => {
               }
               return JSON.stringify(entry);
             }).join("\n");
-            console.log(`[Tool Result] ${name}:`, normalized);
+            Logger.debug(`[Tool Result] ${name}:`, normalized);
             return normalized;
           }
           const serialized = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult);
-          console.warn(`[Tool Result] Unexpected format for ${name}, returning serialized output`);
+          Logger.debug(`[Tool Result] Unexpected format for ${name}, returning serialized output`);
           return serialized;
         } catch (error) {
           const serverName2 = mcpData.serverName?.toLowerCase();
@@ -9773,7 +9257,7 @@ var generateMcpTools = async (mcpData) => {
       // Mark as MCP tool to enable tool chaining
     };
   }, {});
-  console.log(`\u{1F527} generateMcpTools: Generated ${result.length} tool implementations for ${mcpData.serverName}`);
+  Logger.debug(`\u{1F527} generateMcpTools: Generated ${result.length} tool implementations for ${mcpData.serverName}`);
   return result;
 };
 
@@ -9791,52 +9275,73 @@ var DISABLE_SERVER_THROTTLING = process.env.DISABLE_SERVER_THROTTLING === "true"
 var questSaveMutex = new Mutex();
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletion.js
-var QuestStartBodySchema = z139.object({
-  userId: z139.string(),
-  sessionId: z139.string(),
-  questId: z139.string(),
-  message: z139.string(),
-  messageFileIds: z139.array(z139.string()),
-  historyCount: z139.number(),
-  fabFileIds: z139.array(z139.string()),
+var QuestStartBodySchema = z138.object({
+  userId: z138.string(),
+  sessionId: z138.string(),
+  questId: z138.string(),
+  message: z138.string(),
+  messageFileIds: z138.array(z138.string()),
+  historyCount: z138.number(),
+  fabFileIds: z138.array(z138.string()),
   params: ChatCompletionCreateInputSchema,
   dashboardParams: DashboardParamsSchema.optional(),
-  enableQuestMaster: z139.boolean().optional(),
-  enableMementos: z139.boolean().optional(),
-  enableArtifacts: z139.boolean().optional(),
-  enableAgents: z139.boolean().optional(),
+  enableQuestMaster: z138.boolean().optional(),
+  enableMementos: z138.boolean().optional(),
+  enableArtifacts: z138.boolean().optional(),
+  enableAgents: z138.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
-  tools: z139.array(z139.union([b4mLLMTools, z139.string()])).optional(),
-  mcpServers: z139.array(z139.string()).optional(),
-  projectId: z139.string().optional(),
-  organizationId: z139.string().nullable().optional(),
+  tools: z138.array(z138.union([b4mLLMTools, z138.string()])).optional(),
+  mcpServers: z138.array(z138.string()).optional(),
+  projectId: z138.string().optional(),
+  organizationId: z138.string().nullable().optional(),
   questMaster: QuestMasterParamsSchema.optional(),
-  toolPromptId: z139.string().optional(),
+  toolPromptId: z138.string().optional(),
   researchMode: ResearchModeParamsSchema.optional(),
-  fallbackModel: z139.string().optional(),
-  embeddingModel: z139.string().optional(),
-  queryComplexity: z139.string(),
+  fallbackModel: z138.string().optional(),
+  embeddingModel: z138.string().optional(),
+  queryComplexity: z138.string(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z139.object({
-    maxDepth: z139.number().optional(),
-    duration: z139.number().optional(),
+  deepResearchConfig: z138.object({
+    maxDepth: z138.number().optional(),
+    duration: z138.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z139.array(z139.any()).optional()
+    searchers: z138.array(z138.any()).optional()
   }).optional(),
-  extraContextMessages: z139.array(z139.object({
-    role: z139.enum(["user", "assistant", "system", "function", "tool"]),
-    content: z139.union([z139.string(), z139.array(z139.any())]),
-    fabFileIds: z139.array(z139.string()).optional()
+  extraContextMessages: z138.array(z138.object({
+    role: z138.enum(["user", "assistant", "system", "function", "tool"]),
+    content: z138.union([z138.string(), z138.array(z138.any())]),
+    fabFileIds: z138.array(z138.string()).optional()
   })).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ImageGeneration.js
 import axios8 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer4 } from "file-type";
-import { v4 as uuidv48 } from "uuid";
-import { z as z140 } from "zod";
+import { v4 as uuidv47 } from "uuid";
+import { z as z139 } from "zod";
 import { fromZodError as fromZodError2 } from "zod-validation-error";
 var ImageGenerationBodySchema = OpenAIImageGenerationInput.extend({
+  sessionId: z139.string(),
+  questId: z139.string(),
+  userId: z139.string(),
+  prompt: z139.string(),
+  safety_tolerance: z139.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z139.boolean().optional().default(false),
+  seed: z139.number().nullable().optional(),
+  output_format: z139.enum(["jpeg", "png"]).nullable().optional().default("png"),
+  width: z139.number().optional(),
+  height: z139.number().optional(),
+  aspect_ratio: z139.string().optional(),
+  fabFileIds: z139.array(z139.string()).optional()
+});
+
+// ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
+import axios9 from "axios";
+import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
+import { v4 as uuidv48 } from "uuid";
+import { z as z140 } from "zod";
+import { fromZodError as fromZodError3 } from "zod-validation-error";
+var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
   sessionId: z140.string(),
   questId: z140.string(),
   userId: z140.string(),
@@ -9844,56 +9349,35 @@ var ImageGenerationBodySchema = OpenAIImageGenerationInput.extend({
   safety_tolerance: z140.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
   prompt_upsampling: z140.boolean().optional().default(false),
   seed: z140.number().nullable().optional(),
-  output_format: z140.enum(["jpeg", "png"]).nullable().optional().default("png"),
+  output_format: z140.enum(["jpeg", "png"]).optional().default("png"),
   width: z140.number().optional(),
   height: z140.number().optional(),
   aspect_ratio: z140.string().optional(),
-  fabFileIds: z140.array(z140.string()).optional()
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
-import axios9 from "axios";
-import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
-import { v4 as uuidv49 } from "uuid";
-import { z as z141 } from "zod";
-import { fromZodError as fromZodError3 } from "zod-validation-error";
-var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z141.string(),
-  questId: z141.string(),
-  userId: z141.string(),
-  prompt: z141.string(),
-  safety_tolerance: z141.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z141.boolean().optional().default(false),
-  seed: z141.number().nullable().optional(),
-  output_format: z141.enum(["jpeg", "png"]).optional().default("png"),
-  width: z141.number().optional(),
-  height: z141.number().optional(),
-  aspect_ratio: z141.string().optional(),
-  size: z141.string().optional(),
-  fabFileIds: z141.array(z141.string()).optional(),
-  image: z141.string()
+  size: z140.string().optional(),
+  fabFileIds: z140.array(z140.string()).optional(),
+  image: z140.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/refineText.js
-import { z as z142 } from "zod";
-var refineTextLLMSchema = z142.object({
-  text: z142.string(),
-  context: z142.string().optional()
+import { z as z141 } from "zod";
+var refineTextLLMSchema = z141.object({
+  text: z141.string(),
+  context: z141.string().optional()
   // tone: z.enum(['formal', 'informal', 'neutral']).optional(),
   // style: z.enum(['technical', 'creative', 'academic', 'business', 'narrative']).optional(),
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/MementoEvaluationService.js
-import { z as z143 } from "zod";
-var SingleMementoEvalSchema = z143.object({
-  importance: z143.number().min(1).max(10),
+import { z as z142 } from "zod";
+var SingleMementoEvalSchema = z142.object({
+  importance: z142.number().min(1).max(10),
   // 1-10 scale for personal info importance
-  summary: z143.string(),
-  tags: z143.array(z143.string()).optional()
+  summary: z142.string(),
+  tags: z142.array(z142.string()).optional()
 });
-var MementoEvalResponseSchema = z143.object({
-  isPersonal: z143.boolean(),
-  mementos: z143.array(SingleMementoEvalSchema).optional()
+var MementoEvalResponseSchema = z142.object({
+  isPersonal: z142.boolean(),
+  mementos: z142.array(SingleMementoEvalSchema).optional()
   // Array of distinct personal information
 });
 
@@ -9914,10 +9398,10 @@ var ToolErrorType;
 // src/utils/diffPreview.ts
 import * as Diff from "diff";
 import { readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 async function generateFileDiffPreview(args) {
   try {
-    if (!existsSync8(args.path)) {
+    if (!existsSync7(args.path)) {
       const lines2 = args.content.split("\n");
       const preview = lines2.slice(0, 20).join("\n");
       const hasMore = lines2.length > 20;
@@ -9955,10 +9439,10 @@ ${diffLines4.join("\n")}`;
 }
 async function generateFileDeletePreview(args) {
   try {
-    if (!existsSync8(args.path)) {
+    if (!existsSync7(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs14) => fs14.stat(args.path));
+    const stats = await import("fs/promises").then((fs13) => fs13.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -9970,8 +9454,8 @@ Last modified: ${stats.mtime.toLocaleString()}`;
 }
 
 // src/utils/Logger.ts
-import fs12 from "fs/promises";
-import path14 from "path";
+import fs11 from "fs/promises";
+import path13 from "path";
 import os2 from "os";
 var Logger2 = class _Logger {
   constructor() {
@@ -9994,9 +9478,9 @@ var Logger2 = class _Logger {
    */
   async initialize(sessionId) {
     this.sessionId = sessionId;
-    const debugDir = path14.join(os2.homedir(), ".bike4mind", "debug");
-    await fs12.mkdir(debugDir, { recursive: true });
-    this.logFilePath = path14.join(debugDir, `${sessionId}.txt`);
+    const debugDir = path13.join(os2.homedir(), ".bike4mind", "debug");
+    await fs11.mkdir(debugDir, { recursive: true });
+    this.logFilePath = path13.join(debugDir, `${sessionId}.txt`);
     await this.writeToFile("INFO", "=== CLI SESSION START ===");
   }
   /**
@@ -10060,7 +9544,7 @@ var Logger2 = class _Logger {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
       const logEntry = `[${timestamp}] [${level}] ${message}
 `;
-      await fs12.appendFile(this.logFilePath, logEntry, "utf-8");
+      await fs11.appendFile(this.logFilePath, logEntry, "utf-8");
     } catch (error) {
       console.error("File logging failed:", error);
     }
@@ -10206,15 +9690,15 @@ var Logger2 = class _Logger {
   async cleanupOldLogs() {
     if (!this.fileLoggingEnabled) return;
     try {
-      const debugDir = path14.join(os2.homedir(), ".bike4mind", "debug");
-      const files = await fs12.readdir(debugDir);
+      const debugDir = path13.join(os2.homedir(), ".bike4mind", "debug");
+      const files = await fs11.readdir(debugDir);
       const now = Date.now();
       const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
       for (const file of files) {
-        const filePath = path14.join(debugDir, file);
-        const stats = await fs12.stat(filePath);
+        const filePath = path13.join(debugDir, file);
+        const stats = await fs11.stat(filePath);
         if (stats.mtime.getTime() < thirtyDaysAgo) {
-          await fs12.unlink(filePath);
+          await fs11.unlink(filePath);
         }
       }
     } catch (error) {
@@ -10308,21 +9792,21 @@ var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path17) {
+  async download(path16) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path17) {
+  async delete(path16) {
   }
-  async getSignedUrl(path17) {
-    return `/tmp/${path17}`;
+  async getSignedUrl(path16) {
+    return `/tmp/${path16}`;
   }
-  getPublicUrl(path17) {
-    return `/tmp/${path17}`;
+  getPublicUrl(path16) {
+    return `/tmp/${path16}`;
   }
-  async getPreview(path17) {
-    return `/tmp/${path17}`;
+  async getPreview(path16) {
+    return `/tmp/${path16}`;
   }
-  async getMetadata(path17) {
+  async getMetadata(path16) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -10534,8 +10018,8 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
 }
 
 // src/config/toolSafety.ts
-import { z as z144 } from "zod";
-var ToolCategorySchema = z144.enum([
+import { z as z143 } from "zod";
+var ToolCategorySchema = z143.enum([
   "auto_approve",
   // Safe tools that run automatically without permission
   "prompt_always",
@@ -10543,9 +10027,9 @@ var ToolCategorySchema = z144.enum([
   "prompt_default"
   // Tools that prompt by default but can be trusted
 ]);
-var ToolSafetyConfigSchema = z144.object({
-  categories: z144.record(z144.string(), ToolCategorySchema),
-  trustedTools: z144.array(z144.string())
+var ToolSafetyConfigSchema = z143.object({
+  categories: z143.record(z143.string(), ToolCategorySchema),
+  trustedTools: z143.array(z143.string())
 });
 var DEFAULT_TOOL_CATEGORIES = {
   // ===== AUTO APPROVE (Safe tools) =====
@@ -10726,9 +10210,9 @@ function getEnvironmentName(configApiConfig) {
 }
 
 // src/utils/contextLoader.ts
-import * as fs13 from "fs";
-import * as path15 from "path";
-import { homedir as homedir4 } from "os";
+import * as fs12 from "fs";
+import * as path14 from "path";
+import { homedir as homedir3 } from "os";
 var CONTEXT_FILE_SIZE_LIMIT = 100 * 1024;
 var PROJECT_CONTEXT_FILES = [
   "CLAUDE.local.md",
@@ -10748,9 +10232,9 @@ function formatFileSize2(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 function tryReadContextFile(dir, filename, source) {
-  const filePath = path15.join(dir, filename);
+  const filePath = path14.join(dir, filename);
   try {
-    const stats = fs13.lstatSync(filePath);
+    const stats = fs12.lstatSync(filePath);
     if (stats.isDirectory()) {
       return null;
     }
@@ -10764,7 +10248,7 @@ function tryReadContextFile(dir, filename, source) {
         error: `${source === "global" ? "Global" : "Project"} ${filename} exceeds 100KB limit (${formatFileSize2(stats.size)})`
       };
     }
-    const content = fs13.readFileSync(filePath, "utf-8");
+    const content = fs12.readFileSync(filePath, "utf-8");
     return {
       filename,
       content,
@@ -10816,7 +10300,7 @@ ${project.content}`;
 }
 async function loadContextFiles(projectDir) {
   const errors = [];
-  const globalDir = path15.join(homedir4(), ".bike4mind");
+  const globalDir = path14.join(homedir3(), ".bike4mind");
   const projectDirectory = projectDir || process.cwd();
   const [globalResult, projectResult] = await Promise.all([
     Promise.resolve(findContextFile(globalDir, GLOBAL_CONTEXT_FILES, "global")),
@@ -10928,8 +10412,8 @@ function substituteArguments(template, args) {
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path16 from "path";
-import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
+import path15 from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
@@ -10937,14 +10421,16 @@ var MCPClient = class {
   envVariables;
   customCommand;
   customArgs;
+  suppressStderr;
   tools = [];
   serverName;
-  constructor({ envVariables, name, selectedRepositories, command, args }) {
+  constructor({ envVariables, name, selectedRepositories, command, args, suppressStderr = false }) {
     this.mcp = new Client2({ name: "mcp-client-cli", version: "1.0.0" });
     this.envVariables = [...envVariables];
     this.serverName = name;
     this.customCommand = command;
     this.customArgs = args;
+    this.suppressStderr = suppressStderr;
     if (name === "github" && selectedRepositories) {
       const reposJson = JSON.stringify(selectedRepositories);
       this.envVariables.push({
@@ -10969,18 +10455,18 @@ var MCPClient = class {
         const root = process.env.INIT_CWD || process.cwd();
         const candidatePaths = [
           // When running from SST Lambda with node_modules structure (copyFiles)
-          path16.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda deployed environment (/var/task)
-          path16.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda (.sst/artifacts/mcpHandler-dev), navigate to monorepo root (3 levels up)
-          path16.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from packages/client (Next.js app), navigate to monorepo root (2 levels up)
-          path16.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // Original paths (backward compatibility)
-          path16.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-          path16.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+          path15.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
         ];
-        const serverScriptPath = candidatePaths.find((p) => existsSync9(p));
+        const serverScriptPath = candidatePaths.find((p) => existsSync8(p));
         if (!serverScriptPath) {
           const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
           console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
@@ -10991,25 +10477,20 @@ var MCPClient = class {
         args = [serverScriptPath];
         console.log(`[MCP] Using server: ${this.serverName} at ${serverScriptPath}`);
       }
-      this.transport = new StdioClientTransport({
+      const transportConfig = {
         command,
         args,
         env: {
           ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0)),
           ...envVarsObject
-        }
-      });
+        },
+        // Suppress stderr in CLI context to prevent MCP server startup logs from breaking layout
+        ...this.suppressStderr && { stderr: "ignore" }
+      };
+      this.transport = new StdioClientTransport(transportConfig);
       this.transport.onerror = (error) => {
         console.error(`[MCP] Transport error for ${this.serverName}:`, error);
       };
-      this.mcp.onerror = (error) => {
-        const isExpectedError = error.message.includes("Connection closed") || error.message.includes("-32000") || error.message.includes("EPIPE") || error.message.includes("ECONNRESET");
-        if (isExpectedError) {
-          console.log(`[MCP] Expected connection close for ${this.serverName}:`, error.message);
-        } else {
-          console.error(`[MCP] Unexpected client error for ${this.serverName}:`, error);
-        }
-      };
       await this.mcp.connect(this.transport);
       await new Promise((resolve3) => setTimeout(resolve3, 100));
       const toolsResult = await this.mcp.listTools();
@@ -11070,6 +10551,7 @@ var MCPClient = class {
 var McpManager = class {
   constructor(config) {
     this.servers = /* @__PURE__ */ new Map();
+    this.connectionStates = /* @__PURE__ */ new Map();
     this.config = config;
   }
   /**
@@ -11078,24 +10560,25 @@ var McpManager = class {
   async initialize() {
     const enabledServers = this.config.mcpServers.filter((s) => s.enabled);
     if (enabledServers.length === 0) {
-      logger.info("\u{1F4E1} No MCP servers enabled");
+      logger.debug("\u{1F4E1} No MCP servers enabled");
       return;
     }
-    logger.info(`\u{1F4E1} Initializing ${enabledServers.length} MCP server(s)...`);
+    logger.debug(`\u{1F4E1} Initializing ${enabledServers.length} MCP server(s)...`);
     const results = await Promise.allSettled(enabledServers.map((serverConfig) => this.connectServer(serverConfig)));
     const successful = results.filter((r) => r.status === "fulfilled").length;
     const failed = results.filter((r) => r.status === "rejected").length;
     if (successful > 0) {
-      logger.info(`\u2705 Connected to ${successful} MCP server(s)`);
+      logger.debug(`\u2705 Connected to ${successful} MCP server(s)`);
     }
     if (failed > 0) {
-      logger.warn(`\u26A0\uFE0F  Failed to connect to ${failed} MCP server(s)`);
+      logger.debug(`\u26A0\uFE0F  Failed to connect to ${failed} MCP server(s)`);
     }
   }
   /**
    * Connect to a single MCP server
    */
   async connectServer(serverConfig) {
+    this.connectionStates.set(serverConfig.name, "connecting");
     try {
       logger.debug(`\u{1F504} Connecting to ${serverConfig.name}...`);
       const envVariables = Object.entries(serverConfig.env).map(([key, value]) => ({
@@ -11106,7 +10589,8 @@ var McpManager = class {
         envVariables,
         name: serverConfig.name,
         command: serverConfig.command,
-        args: serverConfig.args
+        args: serverConfig.args,
+        suppressStderr: true
       });
       await client.connectToServer();
       const mcpData = {
@@ -11120,10 +10604,11 @@ var McpManager = class {
         client,
         tools: tools2
       });
-      logger.info(`\u2705 Connected to ${serverConfig.name} (${tools2.length} tools)`);
+      this.connectionStates.set(serverConfig.name, "connected");
+      logger.debug(`\u2705 Connected to ${serverConfig.name} (${tools2.length} tools)`);
     } catch (error) {
-      logger.error(`\u274C Failed to connect to ${serverConfig.name}:`, error);
-      throw error;
+      this.connectionStates.set(serverConfig.name, "failed");
+      logger.debug(`\u274C Failed to connect to ${serverConfig.name}: ${error}`);
     }
   }
   /**
@@ -11176,6 +10661,16 @@ var McpManager = class {
   getServerNames() {
     return Array.from(this.servers.keys());
   }
+  /**
+   * Get connection state for a server
+   */
+  getConnectionState(serverName) {
+    const serverConfig = this.config.mcpServers.find((s) => s.name === serverName);
+    if (!serverConfig?.enabled) {
+      return "disabled";
+    }
+    return this.connectionStates.get(serverName) || "connecting";
+  }
 };
 
 // src/utils/imageRenderer.ts
@@ -11828,7 +11323,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.13",
+  version: "0.2.14-feat-cli-mcp-management.17477+50a7d8e58",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -11933,11 +11428,11 @@ var package_default = {
     zustand: "^4.5.4"
   },
   devDependencies: {
-    "@bike4mind/agents": "workspace:*",
-    "@bike4mind/common": "workspace:*",
-    "@bike4mind/mcp": "workspace:*",
-    "@bike4mind/services": "workspace:*",
-    "@bike4mind/utils": "workspace:*",
+    "@bike4mind/agents": "0.1.0",
+    "@bike4mind/common": "2.42.1-feat-cli-mcp-management.17477+50a7d8e58",
+    "@bike4mind/mcp": "1.21.3-feat-cli-mcp-management.17477+50a7d8e58",
+    "@bike4mind/services": "2.37.1-feat-cli-mcp-management.17477+50a7d8e58",
+    "@bike4mind/utils": "2.1.8-feat-cli-mcp-management.17477+50a7d8e58",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -11950,7 +11445,8 @@ var package_default = {
     tsx: "^4.21.0",
     typescript: "^5.9.3",
     vitest: "^3.2.4"
-  }
+  },
+  gitHead: "50a7d8e58345e84ae2bed8bbc91bb61108f58879"
 };
 
 // src/config/constants.ts
@@ -12472,6 +11968,7 @@ function CliApp() {
   const setStoreSession = useCliStore((state2) => state2.setSession);
   const setPermissionPrompt = useCliStore((state2) => state2.setPermissionPrompt);
   const setShowConfigEditor = useCliStore((state2) => state2.setShowConfigEditor);
+  const setShowMcpViewer = useCliStore((state2) => state2.setShowMcpViewer);
   const setExitRequested = useCliStore((state2) => state2.setExitRequested);
   const performCleanup = useCallback(async () => {
     const cleanupTasks = [];
@@ -12508,7 +12005,7 @@ function CliApp() {
       process.exit(0);
     }, 100);
   }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
-  useInput6((input, key) => {
+  useInput8((input, key) => {
     if (key.escape) {
       if (state.abortController) {
         logger.debug("[ABORT] ESC pressed - aborting current operation...");
@@ -12572,7 +12069,7 @@ function CliApp() {
       if (!isAuthenticated) {
         console.log("\u2139\uFE0F  AI features disabled. Available commands: /login, /help, /config\n");
         const minimalSession = {
-          id: uuidv410(),
+          id: uuidv49(),
           name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12616,7 +12113,7 @@ function CliApp() {
       }
       llm.currentModel = modelInfo.id;
       const newSession = {
-        id: uuidv410(),
+        id: uuidv49(),
         name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12684,10 +12181,10 @@ function CliApp() {
       await mcpManager.initialize();
       const mcpTools = mcpManager.getTools();
       if (mcpTools.length > 0) {
-        const toolCounts = mcpManager.getToolCount();
-        toolCounts.forEach(({ serverName, count }) => {
-          console.log(`  \u{1F4E1} ${serverName}: ${count} tool(s)`);
-        });
+        const toolNames = mcpTools.map((t) => t.toolSchema.name).join(", ");
+        console.log(`\u{1F4E1} Loaded ${mcpTools.length} MCP tool(s): ${toolNames}`);
+      } else {
+        console.log(`\u{1F4E1} No MCP tools loaded`);
       }
       const subagentConfigs = getDefaultSubagentConfigs();
       if (config.subagents) {
@@ -12719,6 +12216,9 @@ function CliApp() {
       const writeTodosTool = createWriteTodosTool(todoStore);
       const allTools = [...b4mTools, ...mcpTools, subagentDelegateTool, writeTodosTool];
       console.log(`\u{1F916} Subagent delegation enabled (explore, plan, review)`);
+      logger.debug(
+        `Total tools available to agent: ${allTools.length} (${b4mTools.length} B4M + ${mcpTools.length} MCP + 2 CLI)`
+      );
       const projectDir = state.configStore.getProjectConfigDir();
       const contextResult = await loadContextFiles(projectDir);
       if (contextResult.globalContext) {
@@ -12858,13 +12358,13 @@ ${contextResult.mergedContent}` : "";
         messageContent = multimodalMessage.content;
       }
       const userMessage = {
-        id: uuidv410(),
+        id: uuidv49(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv410(),
+        id: uuidv49(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -13029,13 +12529,13 @@ ${contextResult.mergedContent}` : "";
         userMessageContent = message;
       }
       const userMessage = {
-        id: uuidv410(),
+        id: uuidv49(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv410(),
+        id: uuidv49(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -13103,7 +12603,7 @@ ${contextResult.mergedContent}` : "";
         const currentSession = useCliStore.getState().session;
         if (currentSession) {
           const cancelMessage = {
-            id: uuidv410(),
+            id: uuidv49(),
             role: "assistant",
             content: "\u26A0\uFE0F Operation cancelled by user",
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -13154,13 +12654,13 @@ ${contextResult.mergedContent}` : "";
         isError = true;
       }
       const userMessage = {
-        id: uuidv410(),
+        id: uuidv49(),
         role: "user",
         content: `$ ${command}`,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const assistantMessage = {
-        id: uuidv410(),
+        id: uuidv49(),
         role: "assistant",
         content: isError ? `\u274C Error:
 ${output}` : output.trim() || "(no output)",
@@ -13570,7 +13070,7 @@ Custom Commands:
         console.clear();
         const model = state.session?.model || state.config?.defaultModel || "claude-sonnet";
         const newSession = {
-          id: uuidv410(),
+          id: uuidv49(),
           name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -13862,6 +13362,11 @@ No usage data available for the last ${USAGE_DAYS} days.`);
         }
         break;
       }
+      case "mcp":
+      case "mcp:list": {
+        setShowMcpViewer(true);
+        break;
+      }
       default:
         console.log(`Unknown command: /${command}`);
         console.log("Type /help for available commands");
@@ -13893,12 +13398,12 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     }
   };
   if (initError) {
-    return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React17.createElement(Text16, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React17.createElement(Text16, null, initError), /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
+    return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React18.createElement(Text17, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React18.createElement(Text17, null, initError), /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
   }
   if (state.trustLocationSelector) {
     const projectDir = state.configStore.getProjectConfigDir();
     const inProject = projectDir !== null;
-    return /* @__PURE__ */ React17.createElement(
+    return /* @__PURE__ */ React18.createElement(
       TrustLocationSelector,
       {
         inProject,
@@ -13916,7 +13421,7 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     );
   }
   if (state.rewindSelector && state.session) {
-    return /* @__PURE__ */ React17.createElement(
+    return /* @__PURE__ */ React18.createElement(
       RewindSelector,
       {
         messages: state.session.messages,
@@ -13934,7 +13439,7 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     );
   }
   if (state.sessionSelector) {
-    return /* @__PURE__ */ React17.createElement(
+    return /* @__PURE__ */ React18.createElement(
       SessionSelector,
       {
         sessions: state.sessionSelector.sessions,
@@ -13954,7 +13459,7 @@ No usage data available for the last ${USAGE_DAYS} days.`);
   }
   if (state.showLoginFlow) {
     const loginApiUrl = getApiUrl(state.config?.apiConfig);
-    return /* @__PURE__ */ React17.createElement(
+    return /* @__PURE__ */ React18.createElement(
       LoginFlow,
       {
         apiUrl: loginApiUrl,
@@ -13977,10 +13482,10 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     );
   }
   if (!isInitialized) {
-    return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React17.createElement(Text16, null, "\u{1F680} Initializing..."));
+    return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React18.createElement(Text17, null, "\u{1F680} Initializing..."));
   }
   const allCommands = mergeCommands(state.customCommandStore.getAllCommands());
-  return /* @__PURE__ */ React17.createElement(
+  return /* @__PURE__ */ React18.createElement(
     App,
     {
       onMessage: handleMessage,
@@ -13996,6 +13501,7 @@ No usage data available for the last ${USAGE_DAYS} days.`);
       onPrefillConsumed: () => {
         setState((prev) => ({ ...prev, prefillInput: void 0 }));
       },
+      mcpManager: state.mcpManager ?? void 0,
       onPermissionResponse: (response) => {
         if (state.permissionPrompt) {
           state.permissionPrompt.resolve({ action: response });
@@ -14021,6 +13527,6 @@ var isDevMode = import.meta.url.includes("/src/") || process.env.NODE_ENV === "d
 if (isDevMode) {
   logger.debug("\u{1F527} Running in development mode (using TypeScript source)\n");
 }
-render(/* @__PURE__ */ React17.createElement(CliApp, null), {
+render(/* @__PURE__ */ React18.createElement(CliApp, null), {
   exitOnCtrlC: false
 });