@bike4mind/cli 0.2.25-cli-file-read-offset.18514 → 0.2.25-cli-file-read-offset.18541

package/dist/index.js

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
+import "./chunk-BPFEGDC7.js";
 import "./chunk-BDQBOLYG.js";
 import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-FV2VQXYX.js";
+} from "./chunk-ETQCFCFT.js";
 import {
   ConfigStore
 } from "./chunk-23T2XGSZ.js";
-import "./chunk-JHCQOESZ.js";
-import "./chunk-GGQZHK5U.js";
+import {
+  useCliStore
+} from "./chunk-EIDW3VBS.js";
+import "./chunk-TNLRJZRH.js";
+import "./chunk-QDD3PG2I.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -21,7 +25,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-XFN2ICKP.js";
+} from "./chunk-KGERFIL4.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -77,27 +81,27 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-LOIWIBZT.js";
+} from "./chunk-CRG4F6FD.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
-import "./chunk-BPFEGDC7.js";
 
 // src/index.tsx
 import React19, { useState as useState8, useEffect as useEffect4, useCallback, useRef as useRef3 } from "react";
-import { render, Box as Box18, Text as Text18, useApp, useInput as useInput7 } from "ink";
+import { render, Box as Box18, Text as Text18, useApp, useInput as useInput8 } from "ink";
 import { execSync } from "child_process";
 import { v4 as uuidv411 } from "uuid";
 
 // src/components/App.tsx
 import React13, { useState as useState4 } from "react";
-import { Box as Box12, Text as Text12, Static } from "ink";
+import { Box as Box12, Text as Text12, Static, useInput as useInput5 } from "ink";
 
 // src/components/StatusBar.tsx
 import React from "react";
 import { Box, Text } from "ink";
 var StatusBar = React.memo(function StatusBar2({ sessionName, model, tokenUsage }) {
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, sessionName), /* @__PURE__ */ React.createElement(Box, { gap: 2 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, tokenUsage.toLocaleString(), " tokens"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, model)));
+  const autoAcceptEdits = useCliStore((state) => state.autoAcceptEdits);
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, sessionName), /* @__PURE__ */ React.createElement(Box, { gap: 2 }, autoAcceptEdits && /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "AUTO ACCEPT: Edits"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, tokenUsage.toLocaleString(), " tokens"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, model)));
 });
 
 // src/components/InputPrompt.tsx
@@ -899,66 +903,6 @@ var ImageInputDetector = class {
   }
 };
 
-// src/store/index.ts
-import { create } from "zustand";
-var useCliStore = create((set) => ({
-  // Session state
-  session: null,
-  setSession: (session) => set({ session }),
-  addMessage: (message) => set((state) => {
-    if (!state.session) return state;
-    return {
-      session: {
-        ...state.session,
-        messages: [...state.session.messages, message],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }),
-  // Pending messages
-  pendingMessages: [],
-  addPendingMessage: (message) => set((state) => ({ pendingMessages: [...state.pendingMessages, message] })),
-  updatePendingMessage: (index, message) => set((state) => {
-    const updated = [...state.pendingMessages];
-    updated[index] = message;
-    return { pendingMessages: updated };
-  }),
-  clearPendingMessages: () => set({ pendingMessages: [] }),
-  completePendingMessage: (index, finalMessage) => set((state) => {
-    const pending = [...state.pendingMessages];
-    pending.splice(index, 1);
-    const session = state.session;
-    if (!session) return { pendingMessages: pending };
-    return {
-      pendingMessages: pending,
-      session: {
-        ...session,
-        messages: [...session.messages, finalMessage],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }),
-  // UI state
-  isThinking: false,
-  setIsThinking: (thinking) => set({ isThinking: thinking }),
-  // Input state (for Ctrl+C clearing)
-  inputValue: "",
-  setInputValue: (value) => set({ inputValue: value }),
-  clearInput: () => set({ inputValue: "" }),
-  // Permission prompt
-  permissionPrompt: null,
-  setPermissionPrompt: (prompt) => set({ permissionPrompt: prompt }),
-  // 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 })
-}));
-
 // src/components/InputPrompt.tsx
 function looksLikeFilePath(input) {
   const trimmed = input.trim();
@@ -1032,7 +976,7 @@ function InputPrompt({
     setFileSelectedIndex(0);
   }, [filteredFiles]);
   useInput2(
-    (_input, key) => {
+    (input, key) => {
       if (fileAutocomplete?.active && filteredFiles.length > 0) {
         if (key.upArrow) {
           setFileSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredFiles.length - 1);
@@ -1817,6 +1761,12 @@ function App({
   const setShowMcpViewer = useCliStore((state) => state.setShowMcpViewer);
   const exitRequested = useCliStore((state) => state.exitRequested);
   const setIsThinking = useCliStore((state) => state.setIsThinking);
+  const toggleAutoAcceptEdits = useCliStore((state) => state.toggleAutoAcceptEdits);
+  useInput5((_input, key) => {
+    if (key.tab && key.shift) {
+      toggleAutoAcceptEdits();
+    }
+  });
   const [isBashMode, setIsBashMode] = useState4(false);
   const handleSubmit = React13.useCallback(
     async (input) => {
@@ -1957,12 +1907,12 @@ function TrustLocationSelector({ inProject, onSelect, onCancel }) {
 
 // src/components/RewindSelector.tsx
 import React16, { useState as useState5 } from "react";
-import { Box as Box15, Text as Text15, useInput as useInput5 } from "ink";
+import { Box as Box15, Text as Text15, 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);
-  useInput5((input, key) => {
+  useInput6((input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
         setStep("selection");
@@ -2026,12 +1976,12 @@ function RewindSelector({ messages, onSelect, onCancel }) {
 
 // src/components/SessionSelector.tsx
 import React17, { useState as useState6 } from "react";
-import { Box as Box16, Text as Text16, useInput as useInput6 } from "ink";
+import { Box as Box16, Text as Text16, 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);
-  useInput6((input, key) => {
+  useInput7((_input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
         setStep("selection");
@@ -2042,12 +1992,29 @@ function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
     }
   });
   const hasUnsavedWork = currentSession && currentSession.messages.length > 0;
+  const formatTimeAgo = (timestamp) => {
+    const now = /* @__PURE__ */ new Date();
+    const then = new Date(timestamp);
+    const diffMs = now.getTime() - then.getTime();
+    const diffMins = Math.floor(diffMs / 6e4);
+    const diffHours = Math.floor(diffMs / 36e5);
+    const diffDays = Math.floor(diffMs / 864e5);
+    if (diffMins < 60) {
+      return `${diffMins}m`;
+    } else if (diffHours < 24) {
+      return `${diffHours}h`;
+    } else {
+      return `${diffDays}d`;
+    }
+  };
   const items = sessions.map((session, index) => {
-    const messageCount = session.messages.length;
-    const lastUpdated = new Date(session.updatedAt).toLocaleString();
+    const userMessages = session.messages.filter((msg) => msg.role === "user");
+    const lastUserMessage = userMessages[userMessages.length - 1];
+    const preview = lastUserMessage ? lastUserMessage.content.slice(0, 50).replace(/\n/g, " ") + (lastUserMessage.content.length > 50 ? "..." : "") : "No messages";
+    const timeAgo = formatTimeAgo(session.updatedAt);
     return {
-      label: `[${index + 1}] ${session.name} (${messageCount} msg, ${session.model})
-      Last updated: ${lastUpdated}`,
+      key: session.id,
+      label: `[${index + 1}] ${preview} (${timeAgo})`,
       value: session
     };
   });
@@ -2287,6 +2254,9 @@ var SessionStore = class {
    * Save a session to disk
    */
   async save(session) {
+    if (session.messages.length === 0) {
+      throw new Error("Cannot save session with no messages");
+    }
     await this.init();
     const filePath = path3.join(this.basePath, `${session.id}.json`);
     try {
@@ -2329,13 +2299,14 @@ var SessionStore = class {
   }
   /**
    * List all saved sessions
+   * @param limit - Optional limit on number of sessions to return (returns most recent)
    */
-  async list() {
+  async list(limit) {
     await this.init();
     try {
       const files = await fs3.readdir(this.basePath);
       const jsonFiles = files.filter((f) => f.endsWith(".json"));
-      const sessions = await Promise.all(
+      const sessionsWithFiles = await Promise.all(
         jsonFiles.map(async (file) => {
           const filePath = path3.join(this.basePath, file);
           const data = await fs3.readFile(filePath, "utf-8");
@@ -2346,10 +2317,23 @@ var SessionStore = class {
             }
             return msg;
           });
-          return session;
+          return { session, filePath };
         })
       );
-      return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+      const validSessions = [];
+      for (const { session, filePath } of sessionsWithFiles) {
+        if (session.messages.length === 0) {
+          try {
+            await fs3.unlink(filePath);
+          } catch (error) {
+            console.error(`Failed to delete empty session ${session.id}:`, error);
+          }
+        } else {
+          validSessions.push(session);
+        }
+      }
+      const sorted = validSessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+      return limit ? sorted.slice(0, limit) : sorted;
     } catch (error) {
       console.error("Failed to list sessions:", error);
       return [];
@@ -3132,6 +3116,127 @@ You can use:
 
 // ../../b4m-core/packages/agents/src/ReActAgent.ts
 import { EventEmitter } from "events";
+
+// ../../b4m-core/packages/agents/src/toolParallelizer.ts
+var DEFAULT_WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "edit_file",
+  "edit_local_file",
+  "create_file",
+  "delete_file",
+  "shell_execute",
+  "bash_execute",
+  "git_commit",
+  "git_push"
+]);
+function defaultIsReadOnlyTool(toolName) {
+  return !DEFAULT_WRITE_TOOLS.has(toolName);
+}
+function getToolId(tool) {
+  return `${tool.name}_${JSON.stringify(tool.arguments)}`;
+}
+function categorizeTools(toolsUsed, isReadOnly = defaultIsReadOnlyTool) {
+  const parallelBatch = [];
+  const sequentialBatch = [];
+  const originalOrder = [];
+  for (const tool of toolsUsed) {
+    originalOrder.push(getToolId(tool));
+    if (isReadOnly(tool.name)) {
+      parallelBatch.push(tool);
+    } else {
+      sequentialBatch.push(tool);
+    }
+  }
+  return {
+    parallelBatch,
+    sequentialBatch,
+    originalOrder
+  };
+}
+async function executeToolsInParallel(plan, executor, signal) {
+  const results = /* @__PURE__ */ new Map();
+  if (signal?.aborted) {
+    throw new Error("Tool execution aborted");
+  }
+  if (plan.parallelBatch.length > 0) {
+    const parallelPromises = plan.parallelBatch.map(async (tool) => {
+      const toolId = getToolId(tool);
+      if (signal?.aborted) {
+        return {
+          toolId,
+          result: {
+            toolName: tool.name,
+            error: new Error("Tool execution aborted"),
+            status: "rejected"
+          }
+        };
+      }
+      try {
+        const result = await executor(tool);
+        return {
+          toolId,
+          result: {
+            toolName: tool.name,
+            result,
+            status: "fulfilled"
+          }
+        };
+      } catch (error) {
+        return {
+          toolId,
+          result: {
+            toolName: tool.name,
+            error: error instanceof Error ? error : new Error(String(error)),
+            status: "rejected"
+          }
+        };
+      }
+    });
+    const settledResults = await Promise.allSettled(parallelPromises);
+    for (const settled of settledResults) {
+      if (settled.status === "fulfilled") {
+        results.set(settled.value.toolId, settled.value.result);
+      }
+    }
+  }
+  if (signal?.aborted) {
+    throw new Error("Tool execution aborted");
+  }
+  for (const tool of plan.sequentialBatch) {
+    const toolId = getToolId(tool);
+    if (signal?.aborted) {
+      results.set(toolId, {
+        toolName: tool.name,
+        error: new Error("Tool execution aborted"),
+        status: "rejected"
+      });
+      throw new Error("Tool execution aborted");
+    }
+    try {
+      const result = await executor(tool);
+      results.set(toolId, {
+        toolName: tool.name,
+        result,
+        status: "fulfilled"
+      });
+    } catch (error) {
+      results.set(toolId, {
+        toolName: tool.name,
+        error: error instanceof Error ? error : new Error(String(error)),
+        status: "rejected"
+      });
+    }
+  }
+  return results;
+}
+function shouldUseParallelExecution(toolsUsed, isReadOnly = defaultIsReadOnlyTool) {
+  if (toolsUsed.length < 2) {
+    return false;
+  }
+  const readOnlyCount = toolsUsed.filter((tool) => isReadOnly(tool.name)).length;
+  return readOnlyCount >= 2;
+}
+
+// ../../b4m-core/packages/agents/src/ReActAgent.ts
 var ReActAgent = class extends EventEmitter {
   constructor(context) {
     super();
@@ -3259,77 +3364,51 @@ ${options.context}` : this.getSystemPrompt()
               if (completionInfo.toolsUsed && completionInfo.toolsUsed.length > 0) {
                 hadToolCalls = true;
                 const thinkingBlocks = completionInfo.thinking || [];
+                const unprocessedTools = [];
                 for (const toolUse of completionInfo.toolsUsed) {
-                  const toolCallId = `${toolUse.name}_${JSON.stringify(toolUse.arguments)}`;
-                  if (processedToolIds.has(toolCallId)) {
-                    continue;
+                  const toolCallIdStr = getToolId(toolUse);
+                  if (!processedToolIds.has(toolCallIdStr)) {
+                    processedToolIds.add(toolCallIdStr);
+                    unprocessedTools.push(toolUse);
                   }
-                  processedToolIds.add(toolCallId);
-                  this.toolCallCount++;
-                  const actionStep = {
-                    type: "action",
-                    content: `Using tool: ${toolUse.name}`,
-                    metadata: {
-                      toolName: toolUse.name,
-                      toolInput: toolUse.arguments,
-                      timestamp: Date.now()
-                    }
-                  };
-                  this.steps.push(actionStep);
-                  this.emit("action", actionStep);
-                  const queuedObs = this.observationQueue.find((obs) => obs.toolName === toolUse.name);
-                  let observation;
-                  if (queuedObs) {
-                    observation = queuedObs.result;
-                    const index = this.observationQueue.indexOf(queuedObs);
-                    this.observationQueue.splice(index, 1);
-                  } else {
-                    const tool = this.context.tools.find((t) => t.toolSchema.name === toolUse.name);
-                    if (!tool) {
-                      throw new Error(`Tool ${toolUse.name} not found in agent context`);
-                    }
-                    const params = typeof toolUse.arguments === "string" ? JSON.parse(toolUse.arguments) : toolUse.arguments;
-                    observation = await tool.toolFn(params);
-                    const toolCallId2 = `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-                    const assistantContent = [
-                      // Include thinking blocks first (required by Anthropic when thinking is enabled)
-                      ...thinkingBlocks,
-                      // Then the tool use
-                      {
-                        type: "tool_use",
-                        id: toolCallId2,
-                        name: toolUse.name,
-                        input: params
-                      }
-                    ];
-                    this.context.logger.debug(
-                      `[assistantContent] ${assistantContent.length} blocks (${thinkingBlocks.length} thinking, 1 tool_use)`
-                    );
-                    messages.push({
-                      role: "assistant",
-                      content: assistantContent
-                    });
-                    messages.push({
-                      role: "user",
-                      content: [
-                        {
-                          type: "tool_result",
-                          tool_use_id: toolCallId2,
-                          content: typeof observation === "string" ? observation : JSON.stringify(observation)
-                        }
-                      ]
-                    });
+                }
+                if (unprocessedTools.length === 0) {
+                } else if (options.parallelExecution && shouldUseParallelExecution(unprocessedTools, options.isReadOnlyTool ?? defaultIsReadOnlyTool)) {
+                  this.context.logger.debug(
+                    `[ReActAgent] Parallel execution enabled for ${unprocessedTools.length} tools`
+                  );
+                  for (const toolUse of unprocessedTools) {
+                    this.emitActionStep(toolUse);
                   }
-                  const observationStep = {
-                    type: "observation",
-                    content: typeof observation === "string" ? observation : JSON.stringify(observation),
-                    metadata: {
-                      toolName: toolUse.name,
-                      timestamp: Date.now()
+                  const plan = categorizeTools(unprocessedTools, options.isReadOnlyTool ?? defaultIsReadOnlyTool);
+                  const results = await executeToolsInParallel(
+                    plan,
+                    (toolUse) => this.executeToolWithQueueFallback(toolUse),
+                    options.signal
+                  );
+                  for (const toolUse of unprocessedTools) {
+                    const toolIdStr = getToolId(toolUse);
+                    const result2 = results.get(toolIdStr);
+                    const observation = result2?.status === "fulfilled" ? result2.result ?? "" : `Error: ${result2?.error?.message ?? "Unknown error"}`;
+                    this.appendToolMessages(messages, toolUse, observation, thinkingBlocks);
+                    this.emitObservationStep(toolUse.name, observation);
+                  }
+                } else {
+                  for (const toolUse of unprocessedTools) {
+                    this.emitActionStep(toolUse);
+                    const queuedObs = this.observationQueue.find((obs) => obs.toolId === getToolId(toolUse));
+                    let observation;
+                    if (queuedObs) {
+                      const result2 = queuedObs.result;
+                      const index = this.observationQueue.indexOf(queuedObs);
+                      this.observationQueue.splice(index, 1);
+                      observation = typeof result2 === "string" ? result2 : JSON.stringify(result2);
+                    } else {
+                      observation = await this.executeToolWithQueueFallback(toolUse);
+                      this.appendToolMessages(messages, toolUse, observation, thinkingBlocks);
                     }
-                  };
-                  this.steps.push(observationStep);
-                  this.emit("observation", observationStep);
+                    this.emitObservationStep(toolUse.name, observation);
+                  }
                 }
               }
             }
@@ -3466,7 +3545,159 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
   getToolCallCount() {
     return this.toolCallCount;
   }
+  /**
+   * Create and emit an action step for a tool use
+   */
+  emitActionStep(toolUse) {
+    this.toolCallCount++;
+    const actionStep = {
+      type: "action",
+      content: `Using tool: ${toolUse.name}`,
+      metadata: {
+        toolName: toolUse.name,
+        toolInput: toolUse.arguments,
+        timestamp: Date.now()
+      }
+    };
+    this.steps.push(actionStep);
+    this.emit("action", actionStep);
+  }
+  /**
+   * Create and emit an observation step
+   */
+  emitObservationStep(toolName, observation) {
+    const observationStep = {
+      type: "observation",
+      content: observation,
+      metadata: {
+        toolName,
+        timestamp: Date.now()
+      }
+    };
+    this.steps.push(observationStep);
+    this.emit("observation", observationStep);
+  }
+  /**
+   * Parse tool arguments, handling both string and object forms
+   */
+  parseToolArguments(args) {
+    return typeof args === "string" ? JSON.parse(args) : args;
+  }
+  /**
+   * Execute a tool and return the result as a string.
+   * Checks observation queue first for backward compatibility.
+   */
+  async executeToolWithQueueFallback(toolUse) {
+    const queuedObs = this.observationQueue.find((obs) => obs.toolId === getToolId(toolUse));
+    if (queuedObs) {
+      const result2 = queuedObs.result;
+      const index = this.observationQueue.indexOf(queuedObs);
+      this.observationQueue.splice(index, 1);
+      return typeof result2 === "string" ? result2 : JSON.stringify(result2);
+    }
+    const tool = this.context.tools.find((t) => t.toolSchema.name === toolUse.name);
+    if (!tool) {
+      throw new Error(`Tool ${toolUse.name} not found in agent context`);
+    }
+    const params = this.parseToolArguments(toolUse.arguments);
+    const result = await tool.toolFn(params);
+    return typeof result === "string" ? result : JSON.stringify(result);
+  }
+  /**
+   * Build and append tool call/result messages for the conversation history
+   */
+  appendToolMessages(messages, toolUse, observation, thinkingBlocks) {
+    const params = this.parseToolArguments(toolUse.arguments);
+    const msgToolCallId = `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const assistantContent = [
+      ...thinkingBlocks,
+      {
+        type: "tool_use",
+        id: msgToolCallId,
+        name: toolUse.name,
+        input: params
+      }
+    ];
+    messages.push({
+      role: "assistant",
+      content: assistantContent
+    });
+    messages.push({
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: msgToolCallId,
+          content: observation
+        }
+      ]
+    });
+  }
+};
+
+// src/config/toolSafety.ts
+import { z as z2 } from "zod";
+var ToolCategorySchema = z2.enum([
+  "auto_approve",
+  // Safe tools that run automatically without permission
+  "prompt_always",
+  // Dangerous tools that ALWAYS require permission (cannot be trusted)
+  "prompt_default"
+  // Tools that prompt by default but can be trusted
+]);
+var ToolSafetyConfigSchema = z2.object({
+  categories: z2.record(z2.string(), ToolCategorySchema),
+  trustedTools: z2.array(z2.string())
+});
+var DEFAULT_TOOL_CATEGORIES = {
+  // ===== AUTO APPROVE (Safe tools) =====
+  // These tools have no side effects and are always safe to execute
+  math_evaluate: "auto_approve",
+  current_datetime: "auto_approve",
+  dice_roll: "auto_approve",
+  prompt_enhancement: "auto_approve",
+  weather_info: "prompt_default",
+  // ===== PROMPT ALWAYS (Dangerous tools) =====
+  // These tools can modify files, execute code, or have other dangerous side effects
+  // They ALWAYS require permission and cannot be trusted automatically
+  edit_file: "prompt_always",
+  edit_local_file: "prompt_always",
+  create_file: "prompt_always",
+  delete_file: "prompt_always",
+  shell_execute: "prompt_always",
+  bash_execute: "prompt_always",
+  git_commit: "prompt_always",
+  git_push: "prompt_always",
+  // ===== PROMPT DEFAULT (Repository read tools) =====
+  // These tools read from the repository but don't modify anything
+  // Users can trust them if they want to avoid prompts
+  web_search: "prompt_default",
+  deep_research: "prompt_default",
+  file_read: "prompt_default",
+  grep_search: "prompt_default",
+  glob_files: "prompt_default",
+  get_file_tree: "prompt_default",
+  git_status: "prompt_default",
+  git_diff: "prompt_default",
+  git_log: "prompt_default",
+  git_branch: "prompt_default"
 };
+function getToolCategory(toolName, customCategories) {
+  if (customCategories && toolName in customCategories) {
+    return customCategories[toolName];
+  }
+  if (toolName in DEFAULT_TOOL_CATEGORIES) {
+    return DEFAULT_TOOL_CATEGORIES[toolName];
+  }
+  return "prompt_default";
+}
+function canTrustTool(toolName, customCategories) {
+  const category = getToolCategory(toolName, customCategories);
+  return category !== "prompt_always";
+}
+function isReadOnlyTool(toolName, customCategories) {
+  return getToolCategory(toolName, customCategories) !== "prompt_always";
+}
 
 // src/core/prompts.ts
 var TOOL_GREP_SEARCH = "grep_search";
@@ -3576,38 +3807,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 z2 } from "zod";
-var generateReferralCodesSchema = z2.object({
-  count: z2.number().optional(),
-  unlimitedUse: z2.boolean().optional(),
-  expiresAt: z2.date().optional()
+import { z as z3 } from "zod";
+var generateReferralCodesSchema = z3.object({
+  count: z3.number().optional(),
+  unlimitedUse: z3.boolean().optional(),
+  expiresAt: z3.date().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/referService/delete.js
-import { z as z3 } from "zod";
-var deleteInviteCodesSchema = z3.object({
-  ids: z3.array(z3.string())
+import { z as z4 } from "zod";
+var deleteInviteCodesSchema = z4.object({
+  ids: z4.array(z4.string())
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/login.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 import bcrypt from "bcryptjs";
-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()
+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()
   }).optional()
 });
 
@@ -3617,78 +3848,78 @@ import escapeRegExp from "lodash/escapeRegExp.js";
 
 // ../../b4m-core/packages/services/dist/src/userService/forgotPassword.js
 import { randomUUID } from "crypto";
-import { z as z5 } from "zod";
-var forgotPasswordUserSchema = z5.object({
-  email: z5.string().email()
+import { z as z6 } from "zod";
+var forgotPasswordUserSchema = z6.object({
+  email: z6.string().email()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/update.js
 import bcrypt3 from "bcryptjs";
-import { z as z6 } from "zod";
-var updateUserSchema = z6.object({
-  name: z6.string().optional(),
-  username: z6.string().optional(),
+import { z as z7 } from "zod";
+var updateUserSchema = z7.object({
+  name: z7.string().optional(),
+  username: z7.string().optional(),
   // email field removed - users must use the secure email change verification flow
   // See requestEmailChange and verifyEmailChange in userService
-  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()
+  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()
   })).nullable().optional(),
-  securityQuestions: z6.array(z6.object({ question: z6.string(), answer: z6.string() })).nullable().optional(),
-  photoUrl: z6.string().nullable().optional(),
-  showCreditsUsed: z6.boolean().optional()
+  securityQuestions: z7.array(z7.object({ question: z7.string(), answer: z7.string() })).nullable().optional(),
+  photoUrl: z7.string().nullable().optional(),
+  showCreditsUsed: z7.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminUpdate.js
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/sendFriendRequest.js
-import { z as z7 } from "zod";
-var sendFriendRequestSchema = z7.object({
-  requesterId: z7.string(),
-  recipientId: z7.string(),
-  message: z7.string().optional()
+import { z as z8 } from "zod";
+var sendFriendRequestSchema = z8.object({
+  requesterId: z8.string(),
+  recipientId: z8.string(),
+  message: z8.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminUpdate.js
 var adminUpdateUserSchema = updateUserSchema.extend({
-  id: z8.string(),
+  id: z9.string(),
   // Admins can directly update email addresses without verification
-  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()
+  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()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/register.js
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 import bcrypt4 from "bcryptjs";
 
 // ../../b4m-core/packages/services/dist/src/creditService/addCredits.js
-import { z as z9 } from "zod";
-var AddCreditsSchema = z9.discriminatedUnion("type", [
+import { z as z10 } from "zod";
+var AddCreditsSchema = z10.discriminatedUnion("type", [
   PurchaseTransaction.omit({ createdAt: true, updatedAt: true }),
   SubscriptionCreditTransaction.omit({ createdAt: true, updatedAt: true }),
   GenericCreditAddTransaction.omit({ createdAt: true, updatedAt: true }),
@@ -3696,57 +3927,57 @@ var AddCreditsSchema = z9.discriminatedUnion("type", [
 ]);
 
 // ../../b4m-core/packages/services/dist/src/userService/register.js
-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()
+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()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminDelete.js
-import { z as z11 } from "zod";
-var adminDeleteUserSchema = z11.object({
-  id: z11.string()
+import { z as z12 } from "zod";
+var adminDeleteUserSchema = z12.object({
+  id: z12.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/searchUserCollection.js
-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()
+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()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/recalculateUserStorage.js
-import { z as z13 } from "zod";
-var recalculateUserStorageSchema = z13.object({
+import { z as z14 } from "zod";
+var recalculateUserStorageSchema = z14.object({
   /**
    * The user to recalculate the storage for
    */
-  userId: z13.string()
+  userId: z14.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/listRecentActivities.js
-import { z as z14 } from "zod";
-var listRecentActivitiesSchema = z14.object({
-  coverage: z14.enum(["all", "important"]).default("important")
+import { z as z15 } from "zod";
+var listRecentActivitiesSchema = z15.object({
+  coverage: z15.enum(["all", "important"]).default("important")
 });
 var IMPORTANT_COUNTER_NAMES = [
   SessionEvents.CREATE_SESSION,
@@ -3760,82 +3991,82 @@ var IMPORTANT_COUNTER_NAMES = [
 
 // ../../b4m-core/packages/services/dist/src/userService/sendEmailVerification.js
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z15 } from "zod";
-var sendEmailVerificationSchema = z15.object({
-  userId: z15.string()
+import { z as z16 } from "zod";
+var sendEmailVerificationSchema = z16.object({
+  userId: z16.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailToken.js
-import { z as z16 } from "zod";
+import { z as z17 } 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 = z16.object({
-  token: z16.string()
+var verifyEmailTokenSchema = z17.object({
+  token: z17.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/resendEmailVerification.js
 import { randomUUID as randomUUID3 } from "crypto";
-import { z as z17 } from "zod";
-var resendEmailVerificationSchema = z17.object({
-  userId: z17.string()
+import { z as z18 } from "zod";
+var resendEmailVerificationSchema = z18.object({
+  userId: z18.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/requestEmailChange.js
 import { randomUUID as randomUUID4 } from "crypto";
-import { z as z18 } from "zod";
-var requestEmailChangeSchema = z18.object({
-  userId: z18.string(),
-  newEmail: z18.string().email(),
-  password: z18.string()
+import { z as z19 } from "zod";
+var requestEmailChangeSchema = z19.object({
+  userId: z19.string(),
+  newEmail: z19.string().email(),
+  password: z19.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailChange.js
-import { z as z19 } from "zod";
-var verifyEmailChangeSchema = z19.object({
-  token: z19.string()
+import { z as z20 } from "zod";
+var verifyEmailChangeSchema = z20.object({
+  token: z20.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/cancelEmailChange.js
-import { z as z20 } from "zod";
-var cancelEmailChangeSchema = z20.object({
-  userId: z20.string()
+import { z as z21 } from "zod";
+var cancelEmailChangeSchema = z21.object({
+  userId: z21.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/create.js
 import { randomBytes as randomBytes2 } from "crypto";
 import bcrypt5 from "bcryptjs";
-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)
+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)
   }).optional(),
-  metadata: z21.object({
-    clientIP: z21.string().optional(),
-    userAgent: z21.string().optional(),
-    createdFrom: z21.enum(["dashboard", "cli", "api"])
+  metadata: z22.object({
+    clientIP: z22.string().optional(),
+    userAgent: z22.string().optional(),
+    createdFrom: z22.enum(["dashboard", "cli", "api"])
   })
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/revoke.js
-import { z as z22 } from "zod";
-var revokeUserApiKeySchema = z22.object({
-  keyId: z22.string(),
-  reason: z22.string().optional()
+import { z as z23 } from "zod";
+var revokeUserApiKeySchema = z23.object({
+  keyId: z23.string(),
+  reason: z23.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/rotate.js
 import { randomBytes as randomBytes3 } from "crypto";
 import bcrypt6 from "bcryptjs";
-import { z as z23 } from "zod";
-var rotateUserApiKeySchema = z23.object({
-  keyId: z23.string()
+import { z as z24 } from "zod";
+var rotateUserApiKeySchema = z24.object({
+  keyId: z24.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/validate.js
@@ -3982,29 +4213,29 @@ var EVENT_GROUPS = [
 ];
 
 // ../../b4m-core/packages/services/dist/src/countersService/generateReport.js
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/countersService/getAllCounterFrom24Hours.js
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 import dayjs2 from "dayjs";
-var getCounterTotalsForLast24HoursSchema = z24.object({
-  date: z24.string(),
-  endDate: z24.string().optional()
+var getCounterTotalsForLast24HoursSchema = z25.object({
+  date: z25.string(),
+  endDate: z25.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/generateReport.js
-var generateDailyReportSchema = z25.object({
-  date: z25.string(),
-  startDate: z25.string().optional(),
-  endDate: z25.string().optional()
+var generateDailyReportSchema = z26.object({
+  date: z26.string(),
+  startDate: z26.string().optional(),
+  endDate: z26.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/incrementUserCounter.js
-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()
+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()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/sendSlackReport.js
@@ -4025,42 +4256,42 @@ import yauzl from "yauzl";
 import axios3 from "axios";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/importOpenaiHistory.js
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 import last from "lodash/last.js";
-var epochDate = () => z27.preprocess((val) => new Date(Number(val) * 1e3), z27.date());
-var openaiConversationSchema = z27.object({
-  id: z27.string(),
-  title: z27.string(),
+var epochDate = () => z28.preprocess((val) => new Date(Number(val) * 1e3), z28.date());
+var openaiConversationSchema = z28.object({
+  id: z28.string(),
+  title: z28.string(),
   create_time: epochDate(),
   update_time: epochDate().nullable(),
-  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(),
+  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(),
         create_time: epochDate(),
         update_time: epochDate().nullable(),
-        author: z27.object({
-          role: z27.string(),
-          name: z27.string().nullable(),
-          metadata: z27.any()
+        author: z28.object({
+          role: z28.string(),
+          name: z28.string().nullable(),
+          metadata: z28.any()
           // Accept any metadata structure
         }).passthrough(),
         // Allow extra fields in author
-        content: z27.object({
-          content_type: z27.string(),
-          parts: z27.array(z27.any()).optional()
+        content: z28.object({
+          content_type: z28.string(),
+          parts: z28.array(z28.any()).optional()
           // Accept any type in parts array (strings, objects, etc.)
         }).passthrough(),
         // Allow extra fields in content
-        status: z27.string(),
-        end_turn: z27.boolean().nullable(),
-        metadata: z27.any(),
+        status: z28.string(),
+        end_turn: z28.boolean().nullable(),
+        metadata: z28.any(),
         // Accept any metadata structure since it varies widely
-        recipient: z27.string()
+        recipient: z28.string()
       }).passthrough().nullable()
     }).passthrough()
     // Allow extra fields in mapping node
@@ -4068,38 +4299,38 @@ var openaiConversationSchema = z27.object({
 }).passthrough();
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/importClaudeHistory.js
-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(),
+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(),
       // Accept any type: "text", "image", "tool_result", etc.
-      text: z28.string().optional()
+      text: z29.string().optional()
       // Make text optional since tool_result may not have it
     }).passthrough()
     // Allow all other fields
   ),
-  sender: z28.enum(["human", "assistant"]),
-  created_at: z28.coerce.date(),
-  updated_at: z28.coerce.date(),
-  attachments: z28.array(z28.any()),
+  sender: z29.enum(["human", "assistant"]),
+  created_at: z29.coerce.date(),
+  updated_at: z29.coerce.date(),
+  attachments: z29.array(z29.any()),
   // Accept any attachment structure
-  files: z28.array(z28.any())
+  files: z29.array(z29.any())
   // Accept any file structure
 }).passthrough();
-var claudeConversationSchema = z28.object({
-  uuid: z28.string().uuid(),
-  name: z28.string(),
-  summary: z28.string().optional(),
+var claudeConversationSchema = z29.object({
+  uuid: z29.string().uuid(),
+  name: z29.string(),
+  summary: z29.string().optional(),
   // Summary field is optional
-  created_at: z28.coerce.date(),
-  updated_at: z28.coerce.date(),
-  account: z28.object({
-    uuid: z28.string().uuid()
+  created_at: z29.coerce.date(),
+  updated_at: z29.coerce.date(),
+  account: z29.object({
+    uuid: z29.string().uuid()
   }),
-  chat_messages: z28.array(claudeChatMessageSchema)
+  chat_messages: z29.array(claudeChatMessageSchema)
 }).passthrough();
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
@@ -4110,357 +4341,357 @@ var ImportSource;
 })(ImportSource || (ImportSource = {}));
 
 // ../../b4m-core/packages/services/dist/src/sessionService/create.js
-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()
+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()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/delete.js
-import { z as z30 } from "zod";
-var deleteSessionSchema = z30.object({
-  id: z30.string()
+import { z as z31 } from "zod";
+var deleteSessionSchema = z31.object({
+  id: z31.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/sumarize.js
-import { z as z31 } from "zod";
-var sumarizeSessionSchema = z31.object({
-  id: z31.string()
+import { z as z32 } from "zod";
+var sumarizeSessionSchema = z32.object({
+  id: z32.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/create.js
-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()
+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()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/search.js
-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()
+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()
   }).optional(),
-  pagination: z33.object({
-    page: z33.coerce.number().optional(),
-    limit: z33.coerce.number().optional()
+  pagination: z34.object({
+    page: z34.coerce.number().optional(),
+    limit: z34.coerce.number().optional()
   }).optional(),
-  orderBy: z33.object({
-    by: z33.enum(["createdAt", "updatedAt"]).optional(),
-    direction: z33.enum(["asc", "desc"]).optional()
+  orderBy: z34.object({
+    by: z34.enum(["createdAt", "updatedAt"]).optional(),
+    direction: z34.enum(["asc", "desc"]).optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addSessions.js
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 import uniq2 from "lodash/uniq.js";
 
 // ../../b4m-core/packages/services/dist/src/sharingService/accept.js
-import { z as z34 } from "zod";
-var acceptInviteSchema = z34.object({
-  id: z34.string()
+import { z as z35 } from "zod";
+var acceptInviteSchema = z35.object({
+  id: z35.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/cancel.js
-import { z as z35 } from "zod";
-var cancelInviteSchema = z35.object({
-  id: z35.string(),
-  type: z35.nativeEnum(InviteType),
-  email: z35.string().email().optional()
+import { z as z36 } from "zod";
+var cancelInviteSchema = z36.object({
+  id: z36.string(),
+  type: z36.nativeEnum(InviteType),
+  email: z36.string().email().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/cancelOwnDocument.js
-import { z as z36 } from "zod";
-var cancelOwnDocumentInvitesSchema = z36.object({
-  documentId: z36.string(),
-  type: z36.nativeEnum(InviteType)
+import { z as z37 } from "zod";
+var cancelOwnDocumentInvitesSchema = z37.object({
+  documentId: z37.string(),
+  type: z37.nativeEnum(InviteType)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/create.js
-import { z as z37 } from "zod";
+import { z as z38 } 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 = 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)
+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)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/get.js
-import { z as z38 } from "zod";
-var getInviteSchema = z38.object({
-  id: z38.string(),
-  withUsername: z38.boolean().optional()
+import { z as z39 } from "zod";
+var getInviteSchema = z39.object({
+  id: z39.string(),
+  withUsername: z39.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/listByDocumentIdAndType.js
-import { z as z39 } from "zod";
-var listInviteByDocumentIdAndTypeSchema = z39.object({
-  documentId: z39.string(),
-  type: z39.nativeEnum(InviteType)
+import { z as z40 } from "zod";
+var listInviteByDocumentIdAndTypeSchema = z40.object({
+  documentId: z40.string(),
+  type: z40.nativeEnum(InviteType)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/listOwnPending.js
-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)
+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)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/refuse.js
-import { z as z41 } from "zod";
-var refuseInviteSchema = z41.object({
-  id: z41.string()
+import { z as z42 } from "zod";
+var refuseInviteSchema = z42.object({
+  id: z42.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/revoke.js
-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()
+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()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addFiles.js
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 import uniq from "lodash/uniq.js";
-var addFilesProjectSchema = z43.object({
-  projectId: z43.string().nonempty(),
-  fileIds: z43.array(z43.string().nonempty())
+var addFilesProjectSchema = z44.object({
+  projectId: z44.string().nonempty(),
+  fileIds: z44.array(z44.string().nonempty())
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addSessions.js
-var addSessionsProjectSchema = z44.object({
-  projectId: z44.string().nonempty(),
-  sessionIds: z44.array(z44.string().nonempty())
+var addSessionsProjectSchema = z45.object({
+  projectId: z45.string().nonempty(),
+  sessionIds: z45.array(z45.string().nonempty())
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/get.js
-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 z46 } from "zod";
-var updateProjectSchema = z46.object({
-  id: z46.string(),
-  name: z46.string().optional(),
-  description: z46.string().optional()
+var getProjectSchema = z46.object({
+  id: z46.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/delete.js
+// ../../b4m-core/packages/services/dist/src/projectService/update.js
 import { z as z47 } from "zod";
-var deleteProjectSchema = z47.object({
-  id: z47.string()
+var updateProjectSchema = z47.object({
+  id: z47.string(),
+  name: z47.string().optional(),
+  description: z47.string().optional()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeFiles.js
+// ../../b4m-core/packages/services/dist/src/projectService/delete.js
 import { z as z48 } from "zod";
-var removeProjectFilesSchema = z48.object({
-  projectId: z48.string(),
-  fileIds: z48.array(z48.string())
+var deleteProjectSchema = z48.object({
+  id: z48.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeSessions.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeFiles.js
 import { z as z49 } from "zod";
-var removeProjectSessionsSchema = z49.object({
+var removeProjectFilesSchema = z49.object({
   projectId: z49.string(),
-  sessionIds: z49.array(z49.string())
+  fileIds: z49.array(z49.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listSessions.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeSessions.js
 import { z as z50 } from "zod";
-var listProjectSessionsSchema = z50.object({
-  projectId: z50.string()
+var removeProjectSessionsSchema = z50.object({
+  projectId: z50.string(),
+  sessionIds: z50.array(z50.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listFiles.js
+// ../../b4m-core/packages/services/dist/src/projectService/listSessions.js
 import { z as z51 } from "zod";
-var listProjectFilesSchema = z51.object({
+var listProjectSessionsSchema = z51.object({
   projectId: z51.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listInvites.js
+// ../../b4m-core/packages/services/dist/src/projectService/listFiles.js
 import { z as z52 } from "zod";
-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)
+var listProjectFilesSchema = z52.object({
+  projectId: z52.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/addSystemPrompts.js
+// ../../b4m-core/packages/services/dist/src/projectService/listInvites.js
 import { z as z53 } from "zod";
-var addSystemPromptsSchema = z53.object({
-  projectId: z53.string(),
-  fileIds: z53.array(z53.string())
+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)
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/toggleSystemPrompt.js
+// ../../b4m-core/packages/services/dist/src/projectService/addSystemPrompts.js
 import { z as z54 } from "zod";
-var toggleSystemPromptSchema = z54.object({
+var addSystemPromptsSchema = z54.object({
   projectId: z54.string(),
-  fileId: z54.string()
+  fileIds: z54.array(z54.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeSystemPrompt.js
+// ../../b4m-core/packages/services/dist/src/projectService/toggleSystemPrompt.js
 import { z as z55 } from "zod";
-var removeSystemPromptSchema = z55.object({
+var toggleSystemPromptSchema = z55.object({
   projectId: z55.string(),
   fileId: z55.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
-import { z as z58 } from "zod";
-
-// ../../b4m-core/packages/services/dist/src/favoriteService/create.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeSystemPrompt.js
 import { z as z56 } from "zod";
-var createFavoriteParametersSchema = z56.object({
-  documentId: z56.string(),
-  documentType: z56.nativeEnum(FavoriteDocumentType)
+var removeSystemPromptSchema = z56.object({
+  projectId: z56.string(),
+  fileId: z56.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/favoriteService/delete.js
+// ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
+import { z as z59 } from "zod";
+
+// ../../b4m-core/packages/services/dist/src/favoriteService/create.js
 import { z as z57 } from "zod";
-var deleteFavoriteParametersSchema = z57.object({
+var createFavoriteParametersSchema = z57.object({
   documentId: z57.string(),
   documentType: z57.nativeEnum(FavoriteDocumentType)
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
-var addFavoriteParametersSchema = z58.object({
-  projectId: z58.string()
+// ../../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)
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/deleteFavorite.js
-import { z as z59 } from "zod";
-var deleteFavoriteParametersSchema2 = z59.object({
+// ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
+var addFavoriteParametersSchema = z59.object({
   projectId: z59.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeNonExistentFiles.js
+// ../../b4m-core/packages/services/dist/src/projectService/deleteFavorite.js
 import { z as z60 } from "zod";
-var removeNonExistentFilesSchema = z60.object({
+var deleteFavoriteParametersSchema2 = z60.object({
   projectId: z60.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/leaveProject.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeNonExistentFiles.js
 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
+var removeNonExistentFilesSchema = z61.object({
+  projectId: z61.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/update.js
-import uniq3 from "lodash/uniq.js";
-import isEqual from "lodash/isEqual.js";
+// ../../b4m-core/packages/services/dist/src/projectService/leaveProject.js
 import { z as z62 } from "zod";
-var updateSessionParamtersSchema = z62.object({
+var leaveProjectParamsSchema = 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()
+  userIdToRemove: z62.string().optional()
+  // Optional: if provided, this is a removal by owner
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/clone.js
+// ../../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 cloneSessionSchema = z63.object({
-  id: z63.string()
+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()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/fork.js
+// ../../b4m-core/packages/services/dist/src/sessionService/clone.js
 import { z as z64 } from "zod";
-var forkSessionSchema = z64.object({
-  sessionId: z64.string(),
-  messageId: z64.string()
+var cloneSessionSchema = z64.object({
+  id: z64.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/snip.js
+// ../../b4m-core/packages/services/dist/src/sessionService/fork.js
 import { z as z65 } from "zod";
-var snipSessionSchema = z65.object({
+var forkSessionSchema = z65.object({
   sessionId: z65.string(),
   messageId: z65.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/get.js
+// ../../b4m-core/packages/services/dist/src/sessionService/snip.js
 import { z as z66 } from "zod";
-var getSessionSchema = z66.object({
-  id: z66.string()
+var snipSessionSchema = z66.object({
+  sessionId: z66.string(),
+  messageId: z66.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/deleteMessage.js
+// ../../b4m-core/packages/services/dist/src/sessionService/get.js
 import { z as z67 } from "zod";
-var deleteSessionMessageSchema = z67.object({
-  sessionId: z67.string(),
-  messageId: z67.string()
+var getSessionSchema = z67.object({
+  id: z67.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/addFavorite.js
+// ../../b4m-core/packages/services/dist/src/sessionService/deleteMessage.js
 import { z as z68 } from "zod";
-var addFavoriteParametersSchema2 = z68.object({
-  sessionId: z68.string()
+var deleteSessionMessageSchema = z68.object({
+  sessionId: z68.string(),
+  messageId: z68.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/deleteFavorite.js
+// ../../b4m-core/packages/services/dist/src/sessionService/addFavorite.js
 import { z as z69 } from "zod";
-var deleteFavoriteParametersSchema3 = z69.object({
+var addFavoriteParametersSchema2 = z69.object({
   sessionId: z69.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/autoName.js
+// ../../b4m-core/packages/services/dist/src/sessionService/deleteFavorite.js
 import { z as z70 } from "zod";
-var autoNameParameterSchema = z70.object({
-  sessionId: z70.string(),
+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(),
   /** The maximum number of words to include in the title */
-  maxWords: z70.number().optional()
+  maxWords: z71.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/search.js
-import { z as z71 } from "zod";
-var searchSchema2 = z71.object({
+import { z as z72 } from "zod";
+var searchSchema2 = z72.object({
   /**
    * Text search query (searches in name and description)
    */
-  query: z71.string().optional(),
+  query: z72.string().optional(),
   /**
    * Filter by personal organizations
    */
-  filters: z71.object({
-    personal: z71.union([z71.enum(["true", "false"]).transform((val) => val === "true"), z71.boolean()]).optional(),
-    userId: z71.string().optional()
+  filters: z72.object({
+    personal: z72.union([z72.enum(["true", "false"]).transform((val) => val === "true"), z72.boolean()]).optional(),
+    userId: z72.string().optional()
   }).default({}),
-  pagination: z71.object({
-    page: z71.coerce.number().int().positive().default(1),
-    limit: z71.coerce.number().int().positive().max(100).default(10)
+  pagination: z72.object({
+    page: z72.coerce.number().int().positive().default(1),
+    limit: z72.coerce.number().int().positive().max(100).default(10)
   }).default({
     page: 1,
     limit: 10
   }),
-  orderBy: z71.object({
-    field: z71.enum(["name", "createdAt", "updatedAt"]).default("name"),
-    direction: z71.enum(["asc", "desc"]).default("asc")
+  orderBy: z72.object({
+    field: z72.enum(["name", "createdAt", "updatedAt"]).default("name"),
+    direction: z72.enum(["asc", "desc"]).default("asc")
   }).default({
     field: "name",
     direction: "asc"
@@ -4468,357 +4699,357 @@ var searchSchema2 = z71.object({
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/get.js
-import { z as z72 } from "zod";
-var getSchema = z72.object({
+import { z as z73 } from "zod";
+var getSchema = z73.object({
   /**
    * Organization ID
    */
-  id: z72.string().min(1)
+  id: z73.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/addMember.js
-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()
+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()
   // 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 z74 } from "zod";
-var getUsersSchema = z74.object({
-  id: z74.string()
+import { z as z75 } from "zod";
+var getUsersSchema = z75.object({
+  id: z75.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/create.js
-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(),
+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(),
   // Optional billing owner (defaults to user if not provided)
-  managerId: z75.string().optional()
+  managerId: z76.string().optional()
   // Optional team manager
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/update.js
-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(),
-  systemPrompt: z76.string().max(1e4).optional()
+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(),
+  systemPrompt: z77.string().max(1e4).optional()
   // ~2500 tokens
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/delete.js
-import { z as z77 } from "zod";
-var deleteSchema = z77.object({
+import { z as z78 } from "zod";
+var deleteSchema = z78.object({
   /**
    * Organization ID
    */
-  id: z77.string().min(1)
+  id: z78.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/listPendingUsers.js
-import { z as z78 } from "zod";
-var listPendingUsersSchema = z78.object({
-  organizationId: z78.string()
+import { z as z79 } from "zod";
+var listPendingUsersSchema = z79.object({
+  organizationId: z79.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/revokeAccess.js
-import { z as z79 } from "zod";
-var revokeAccessSchema = z79.object({
-  id: z79.string(),
-  userId: z79.string()
+import { z as z80 } from "zod";
+var revokeAccessSchema = z80.object({
+  id: z80.string(),
+  userId: z80.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/leave.js
-import { z as z80 } from "zod";
-var organizationLeaveSchema = z80.object({
-  id: z80.string()
+import { z as z81 } from "zod";
+var organizationLeaveSchema = z81.object({
+  id: z81.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/create.js
-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)
+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)
   // Default 90-day expiration
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/set.js
-import { z as z82 } from "zod";
-var setApiKeySchema = z82.object({
-  id: z82.string(),
-  type: z82.nativeEnum(ApiKeyType)
+import { z as z83 } from "zod";
+var setApiKeySchema = z83.object({
+  id: z83.string(),
+  type: z83.nativeEnum(ApiKeyType)
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/delete.js
-import { z as z83 } from "zod";
-var deleteApiKeySchema = z83.object({
-  id: z83.string()
+import { z as z84 } from "zod";
+var deleteApiKeySchema = z84.object({
+  id: z84.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/get.js
-import { z as z84 } from "zod";
-var getFabFileSchema = z84.object({
-  id: z84.string()
+import { z as z85 } from "zod";
+var getFabFileSchema = z85.object({
+  id: z85.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/list.js
-import { z as z85 } from "zod";
-var listFabFilesSchema = z85.object({
-  ids: z85.array(z85.string()).optional()
+import { z as z86 } from "zod";
+var listFabFilesSchema = z86.object({
+  ids: z86.array(z86.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/update.js
 import mime from "mime-types";
 import { v4 as uuidv42 } from "uuid";
-import { z as z86 } from "zod";
-var updateFabFileSchema = z86.object({
-  id: z86.string(),
-  fileName: z86.string().optional(),
-  mimeType: z86.string().optional(),
-  fileContent: z86.string().optional(),
-  type: z86.nativeEnum(KnowledgeType).optional(),
-  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()
+import { z as z87 } from "zod";
+var updateFabFileSchema = z87.object({
+  id: z87.string(),
+  fileName: z87.string().optional(),
+  mimeType: z87.string().optional(),
+  fileContent: z87.string().optional(),
+  type: z87.nativeEnum(KnowledgeType).optional(),
+  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()
   })).optional(),
-  error: z86.string().nullable().optional()
+  error: z87.string().nullable().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/delete.js
-import { z as z87 } from "zod";
-var deleteFabFileSchema = z87.object({
-  id: z87.string()
+import { z as z88 } from "zod";
+var deleteFabFileSchema = z88.object({
+  id: z88.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/chunk.js
-import { z as z88 } from "zod";
-var chunkFileSchema = z88.object({
-  fabFileId: z88.string(),
-  embeddingModel: z88.string()
+import { z as z89 } from "zod";
+var chunkFileSchema = z89.object({
+  fabFileId: z89.string(),
+  embeddingModel: z89.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/vectorize.js
-import { z as z89 } from "zod";
-var vectorizeFabFileChunkSchema = z89.object({
-  fabFileId: z89.string(),
-  chunkId: z89.string()
+import { z as z90 } from "zod";
+var vectorizeFabFileChunkSchema = z90.object({
+  fabFileId: z90.string(),
+  chunkId: z90.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/listBySession.js
-import { z as z90 } from "zod";
-var listFabFilesBySessionSchema = z90.object({
-  sessionId: z90.string()
+import { z as z91 } from "zod";
+var listFabFilesBySessionSchema = z91.object({
+  sessionId: z91.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/listByQuest.js
-import { z as z91 } from "zod";
-var listFabFilesByQuestSchema = z91.object({
-  questId: z91.string()
+import { z as z92 } from "zod";
+var listFabFilesByQuestSchema = z92.object({
+  questId: z92.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/createByUrl.js
-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,})).+/)
+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,})).+/)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/search.js
-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(),
+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(),
     // Indicates if the user is searching for shared files
-    curated: z93.coerce.boolean().optional(),
+    curated: z94.coerce.boolean().optional(),
     // Indicates if the user is searching for curated notebook files
-    projectId: z93.string().optional(),
-    ids: z93.array(z93.string()).optional()
+    projectId: z94.string().optional(),
+    ids: z94.array(z94.string()).optional()
     // Add support for filtering by IDs
   }).optional(),
-  pagination: z93.object({
-    page: z93.coerce.number(),
-    limit: z93.coerce.number()
+  pagination: z94.object({
+    page: z94.coerce.number(),
+    limit: z94.coerce.number()
   }).optional(),
-  order: z93.object({
-    by: z93.enum(["createdAt", "fileName", "fileSize"]),
-    direction: z93.enum(["asc", "desc"])
+  order: z94.object({
+    by: z94.enum(["createdAt", "fileName", "fileSize"]),
+    direction: z94.enum(["asc", "desc"])
   }).optional(),
-  options: z93.object({
-    includeShared: z93.coerce.boolean().optional()
+  options: z94.object({
+    includeShared: z94.coerce.boolean().optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/addFavorite.js
-import { z as z94 } from "zod";
-var addFavoriteParametersSchema3 = z94.object({
-  fileId: z94.string()
+import { z as z95 } from "zod";
+var addFavoriteParametersSchema3 = z95.object({
+  fileId: z95.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/deleteFavorite.js
-import { z as z95 } from "zod";
-var deleteFavoriteParametersSchema4 = z95.object({
-  fileId: z95.string()
+import { z as z96 } from "zod";
+var deleteFavoriteParametersSchema4 = z96.object({
+  fileId: z96.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/toggleTags.js
-import { z as z96 } from "zod";
-var fabFileToggleTagsSchema = z96.object({
-  ids: z96.array(z96.string()),
-  tags: z96.array(z96.string())
+import { z as z97 } from "zod";
+var fabFileToggleTagsSchema = z97.object({
+  ids: z97.array(z97.string()),
+  tags: z97.array(z97.string())
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/edit.js
-import { z as z97 } from "zod";
+import { z as z98 } from "zod";
 import { diffLines } from "diff";
-var editFabFileSchema = z97.object({
-  id: z97.string(),
-  instruction: z97.string(),
-  selection: z97.object({
-    start: z97.number(),
-    end: z97.number()
+var editFabFileSchema = z98.object({
+  id: z98.string(),
+  instruction: z98.string(),
+  selection: z98.object({
+    start: z98.number(),
+    end: z98.number()
   }).optional(),
-  preserveFormatting: z97.boolean().optional().default(true),
-  applyImmediately: z97.boolean().optional().default(false)
+  preserveFormatting: z98.boolean().optional().default(true),
+  applyImmediately: z98.boolean().optional().default(false)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/applyEdit.js
 import mime2 from "mime-types";
 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)
+import { z as z99 } from "zod";
+var applyEditSchema = z99.object({
+  id: z99.string(),
+  modifiedContent: z99.string(),
+  createBackup: z99.boolean().optional().default(true)
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/respondToFriendRequest.js
-import { z as z99 } from "zod";
-var respondToFriendRequestSchema = z99.object({
-  id: z99.string(),
+import { z as z100 } from "zod";
+var respondToFriendRequestSchema = z100.object({
+  id: z100.string(),
   /** The user ID of the recipient of the friend request */
-  userId: z99.string(),
-  accept: z99.boolean()
+  userId: z100.string(),
+  accept: z100.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/unfriend.js
-import { z as z100 } from "zod";
-var unfriendSchema = z100.object({
-  friendshipId: z100.string(),
+import { z as z101 } from "zod";
+var unfriendSchema = z101.object({
+  friendshipId: z101.string(),
   /** The user ID of the user who wants to unfriend the other user */
-  userId: z100.string()
+  userId: z101.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/list.js
-import { z as z101 } from "zod";
-var listFriendsSchema = z101.object({
-  userId: z101.string()
+import { z as z102 } from "zod";
+var listFriendsSchema = z102.object({
+  userId: z102.string()
 });
-var listPendingFriendRequestsSchema = z101.object({
-  userId: z101.string()
+var listPendingFriendRequestsSchema = z102.object({
+  userId: z102.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/adminService/loginAs.js
-import { z as z102 } from "zod";
-var loginAsSchema = z102.object({
-  targetUserId: z102.string()
+import { z as z103 } from "zod";
+var loginAsSchema = z103.object({
+  targetUserId: z103.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/get.js
-import { z as z103 } from "zod";
-var getParamsSchema = z103.object({
-  key: z103.string()
+import { z as z104 } from "zod";
+var getParamsSchema = z104.object({
+  key: z104.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/set.js
-import { z as z104 } from "zod";
-var setParamsSchema = z104.object({
-  key: z104.string(),
-  value: z104.any(),
+import { z as z105 } from "zod";
+var setParamsSchema = z105.object({
+  key: z105.string(),
+  value: z105.any(),
   /**
    * Time to live in milliseconds
    */
-  ttl: z104.number(),
-  recache: z104.boolean().optional()
+  ttl: z105.number(),
+  recache: z105.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/ttl.js
-import { z as z105 } from "zod";
-var ttlParamsSchema = z105.object({
-  key: z105.string()
+import { z as z106 } from "zod";
+var ttlParamsSchema = z106.object({
+  key: z106.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/weeklyReports.js
-import { z as z106 } from "zod";
+import { z as z107 } from "zod";
 import dayjs3 from "dayjs";
-var weeklyReportSchema = z106.object({
-  startDate: z106.string(),
-  endDate: z106.string(),
-  report: z106.string(),
-  aiInsights: z106.string().nullable()
+var weeklyReportSchema = z107.object({
+  startDate: z107.string(),
+  endDate: z107.string(),
+  report: z107.string(),
+  aiInsights: z107.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 researchAgentUpdateSchema = z108.object({
-  id: z108.string(),
+var researchAgentCreateSchema = z108.object({
   name: z108.string().min(1),
   description: z108.string().min(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/update.js
 import { z as z109 } from "zod";
-var researchAgentRemoveSchema = z109.object({
-  id: z109.string()
+var researchAgentUpdateSchema = z109.object({
+  id: z109.string(),
+  name: z109.string().min(1),
+  description: z109.string().min(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
 import { z as z110 } from "zod";
-var researchAgentGetSchema = z110.object({
+var researchAgentRemoveSchema = z110.object({
   id: z110.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/listFiles.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
 import { z as z111 } from "zod";
-var researchAgentListFilesSchema = z111.object({
+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({
   /**
    * The ID of the research agent
    */
-  id: z111.string()
+  id: z112.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-import { z as z112 } from "zod";
+import { z as z113 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/lib/turndown.js
 import turndown from "turndown";
@@ -5209,316 +5440,316 @@ var deepResearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-var ResearchTaskProcessSchema = z112.object({
-  id: z112.string()
+var ResearchTaskProcessSchema = z113.object({
+  id: z113.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/create.js
-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()
+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()
   }).optional()
 });
 var researchTaskScrapeCreateSchema = researchTaskCreateSchema.extend({
-  urls: z113.array(z113.string().url()).min(1),
-  canDiscoverLinks: z113.boolean()
+  urls: z114.array(z114.string().url()).min(1),
+  canDiscoverLinks: z114.boolean()
 });
 var researchTaskPeriodicCreateSchema = researchTaskCreateSchema.extend({
-  executionPeriodicStartAt: z113.coerce.date(),
-  executionPeriodicEndAt: z113.coerce.date(),
-  executionPeriodicFrequency: z113.nativeEnum(ResearchTaskPeriodicFrequencyType)
+  executionPeriodicStartAt: z114.coerce.date(),
+  executionPeriodicEndAt: z114.coerce.date(),
+  executionPeriodicFrequency: z114.nativeEnum(ResearchTaskPeriodicFrequencyType)
 });
 var researchTaskScheduledCreateSchema = researchTaskCreateSchema.extend({
-  executionScheduledAt: z113.coerce.date()
+  executionScheduledAt: z114.coerce.date()
 });
 var researchTaskDeepResearchCreateSchema = researchTaskCreateSchema.extend({
-  maxDepth: z113.number().min(1).max(10).optional()
+  maxDepth: z114.number().min(1).max(10).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/search.js
-import { z as z114 } from "zod";
-var searchResearchTasksSchema = z114.object({
-  search: z114.string().optional(),
+import { z as z115 } from "zod";
+var searchResearchTasksSchema = z115.object({
+  search: z115.string().optional(),
   // ADD FILTERS SCHEMA HERE
   // filters: z
   //   .object({
   //     userId: z.string().optional(),
   //   })
   //   .optional(),
-  pagination: z114.object({
-    page: z114.coerce.number().optional(),
-    limit: z114.coerce.number().optional()
+  pagination: z115.object({
+    page: z115.coerce.number().optional(),
+    limit: z115.coerce.number().optional()
   }).optional(),
-  orderBy: z114.object({
-    by: z114.enum(["createdAt", "updatedAt"]).optional(),
-    direction: z114.enum(["asc", "desc"]).optional()
+  orderBy: z115.object({
+    by: z115.enum(["createdAt", "updatedAt"]).optional(),
+    direction: z115.enum(["asc", "desc"]).optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/get.js
-import { z as z115 } from "zod";
-var getResearchTaskSchema = z115.object({
-  id: z115.string().min(1)
+import { z as z116 } from "zod";
+var getResearchTaskSchema = z116.object({
+  id: z116.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/update.js
-import { z as z116 } from "zod";
-var updateResearchTaskSchema = z116.object({
-  id: z116.string(),
-  title: z116.string(),
-  description: z116.string(),
-  type: z116.nativeEnum(ResearchTaskType)
+import { z as z117 } from "zod";
+var updateResearchTaskSchema = z117.object({
+  id: z117.string(),
+  title: z117.string(),
+  description: z117.string(),
+  type: z117.nativeEnum(ResearchTaskType)
 });
 var researchTaskScrapeUpdateSchema = updateResearchTaskSchema.extend({
-  urls: z116.array(z116.string().url()).min(1),
-  canDiscoverLinks: z116.boolean()
+  urls: z117.array(z117.string().url()).min(1),
+  canDiscoverLinks: z117.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/listByAgentId.js
-import { z as z117 } from "zod";
-var listByAgentIdSchema = z117.object({
-  researchAgentId: z117.string()
+import { z as z118 } from "zod";
+var listByAgentIdSchema = z118.object({
+  researchAgentId: z118.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/remove.js
-import { z as z118 } from "zod";
-var researchTaskRemoveSchema = z118.object({
-  id: z118.string().min(1)
+import { z as z119 } from "zod";
+var researchTaskRemoveSchema = z119.object({
+  id: z119.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/retry.js
-import { z as z119 } from "zod";
-var researchTaskRetrySchema = z119.object({
-  id: z119.string(),
-  userId: z119.string()
+import { z as z120 } from "zod";
+var researchTaskRetrySchema = z120.object({
+  id: z120.string(),
+  userId: z120.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/processDiscoveredLinks.js
 import axios4 from "axios";
-import { z as z120 } from "zod";
+import { z as z121 } from "zod";
 import plimit from "p-limit";
 import pLimit2 from "p-limit";
-var researchTaskProcessDiscoveredLinksSchema = z120.object({
-  id: z120.string()
+var researchTaskProcessDiscoveredLinksSchema = z121.object({
+  id: z121.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/downloadRelevantLinks.js
-import { z as z121 } from "zod";
+import { z as z122 } from "zod";
 import plimit2 from "p-limit";
 import axios5 from "axios";
 import { fileTypeFromBuffer } from "file-type";
-var researchTaskDownloadRelevantLinksSchema = z121.object({
-  id: z121.string()
+var researchTaskDownloadRelevantLinksSchema = z122.object({
+  id: z122.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchData/remove.js
-import { z as z122 } from "zod";
-var researchDataRemoveSchema = z122.object({
-  id: z122.string(),
-  researchAgentId: z122.string()
+import { z as z123 } from "zod";
+var researchDataRemoveSchema = z123.object({
+  id: z123.string(),
+  researchAgentId: z123.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/taskSchedulerService/create.js
-import { z as z123 } from "zod";
-var researchTaskPayload = z123.object({
-  id: z123.string(),
-  userId: z123.string()
+import { z as z124 } from "zod";
+var researchTaskPayload = z124.object({
+  id: z124.string(),
+  userId: z124.string()
 });
-var customTaskPayload = z123.object({
-  test: z123.string()
+var customTaskPayload = z124.object({
+  test: z124.string()
 });
-var taskSchedulerCreate = z123.discriminatedUnion("handler", [
-  z123.object({
-    handler: z123.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
+var taskSchedulerCreate = z124.discriminatedUnion("handler", [
+  z124.object({
+    handler: z124.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
     payload: researchTaskPayload,
-    processDate: z123.date()
+    processDate: z124.date()
   }),
-  z123.object({
-    handler: z123.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
+  z124.object({
+    handler: z124.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
     payload: customTaskPayload,
-    processDate: z123.date()
+    processDate: z124.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 tagCreateSchema = z125.object({
+var tagCreateFileTagSchema = z125.object({
   name: z125.string(),
   icon: z125.string().optional(),
-  description: z125.string().optional(),
   color: z125.string().optional(),
-  type: z125.nativeEnum(TagType)
+  description: z125.string().optional()
 });
 
-// ../../b4m-core/packages/services/dist/src/tagService/update.js
+// ../../b4m-core/packages/services/dist/src/tagService/create.js
 import { z as z126 } from "zod";
-var tagUpdateSchema = z126.object({
-  id: z126.string(),
-  name: z126.string().optional(),
+var tagCreateSchema = z126.object({
+  name: z126.string(),
   icon: z126.string().optional(),
   description: z126.string().optional(),
-  color: z126.string().optional()
+  color: z126.string().optional(),
+  type: z126.nativeEnum(TagType)
 });
 
-// ../../b4m-core/packages/services/dist/src/tagService/remove.js
+// ../../b4m-core/packages/services/dist/src/tagService/update.js
 import { z as z127 } from "zod";
-var tagRemoveSchema = z127.object({
-  id: z127.string()
+var tagUpdateSchema = z127.object({
+  id: z127.string(),
+  name: z127.string().optional(),
+  icon: z127.string().optional(),
+  description: z127.string().optional(),
+  color: z127.string().optional()
 });
 
-// ../../b4m-core/packages/services/dist/src/artifactService/create.js
+// ../../b4m-core/packages/services/dist/src/tagService/remove.js
 import { z as z128 } from "zod";
-var createArtifactSchema = z128.object({
-  id: z128.string().optional(),
+var tagRemoveSchema = z128.object({
+  id: z128.string()
+});
+
+// ../../b4m-core/packages/services/dist/src/artifactService/create.js
+import { z as z129 } from "zod";
+var createArtifactSchema = z129.object({
+  id: z129.string().optional(),
   // Allow custom ID for AI-generated artifacts
-  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)
+  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)
   }).optional(),
-  metadata: z128.record(z128.unknown()).default({})
+  metadata: z129.record(z129.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/get.js
-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()
+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()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/list.js
-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)
+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)
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/update.js
-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()
+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()
   }).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()
+  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()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/delete.js
-import { z as z132 } from "zod";
-var deleteArtifactSchema = z132.object({
-  id: z132.string(),
-  hardDelete: z132.boolean().default(false)
+import { z as z133 } from "zod";
+var deleteArtifactSchema = z133.object({
+  id: z133.string(),
+  hardDelete: z133.boolean().default(false)
   // For future implementation
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/create.js
-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)
+import { z as z134 } from "zod";
+var questSchema = z134.object({
+  id: z134.string(),
+  title: z134.string().min(1).max(255),
+  description: z134.string().max(MAX_DESCRIPTION_LENGTH),
+  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(MAX_DESCRIPTION_LENGTH).optional(),
+  goal: z134.string().min(1).max(MAX_GOAL_LENGTH),
+  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(MAX_TAG_LENGTH)).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)
   }).optional(),
-  sourceQuestId: z133.string().optional(),
-  sessionId: z133.string().optional(),
-  metadata: z133.record(z133.unknown()).default({})
+  sourceQuestId: z134.string().optional(),
+  sessionId: z134.string().optional(),
+  metadata: z134.record(z134.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/updateQuestStatus.js
-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()
+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()
 });
 
 // ../../b4m-core/packages/services/dist/src/dataLakeService/opensearchClient.js
@@ -5538,59 +5769,59 @@ import { v4 as uuidv44 } from "uuid";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/emailIngestionService/types.js
-import { z as z135 } from "zod";
-var processIngestedEmailOptionsSchema = z135.object({
-  platformDomain: z135.string().optional(),
-  isNewsletter: z135.boolean().optional()
+import { z as z136 } from "zod";
+var processIngestedEmailOptionsSchema = z136.object({
+  platformDomain: z136.string().optional(),
+  isNewsletter: z136.boolean().optional()
 }).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(),
+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(),
   // Complex email address 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({
+  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({
   parsedEmail: parsedEmailObjectSchema,
-  rawEmailS3Key: z135.string().min(1, "rawEmailS3Key cannot be empty"),
+  rawEmailS3Key: z136.string().min(1, "rawEmailS3Key cannot be empty"),
   options: processIngestedEmailOptionsSchema
 });
 
 // ../../b4m-core/packages/services/dist/src/emailAnalysisService/types.js
-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([])
+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([])
   }),
-  sentiment: z136.enum(["positive", "neutral", "negative", "urgent"]),
-  actionItems: z136.array(z136.object({
-    description: z136.string(),
-    deadline: z136.string().optional()
+  sentiment: z137.enum(["positive", "neutral", "negative", "urgent"]),
+  actionItems: z137.array(z137.object({
+    description: z137.string(),
+    deadline: z137.string().optional()
     // ISO date string from LLM
   })).default([]),
-  privacyRecommendation: z136.enum(["public", "team", "private"]),
-  embargoDetected: z136.boolean().default(false),
-  suggestedTags: z136.array(z136.string()).default([])
+  privacyRecommendation: z137.enum(["public", "team", "private"]),
+  embargoDetected: z137.boolean().default(false),
+  suggestedTags: z137.array(z137.string()).default([])
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/ToolCacheManager.js
@@ -6063,8 +6294,8 @@ var webFetchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/math/index.js
-import { create as create6, all } from "mathjs";
-var math = create6(all, {
+import { create as create5, all } from "mathjs";
+var math = create5(all, {
   number: "BigNumber",
   precision: 14
 });
@@ -6776,17 +7007,17 @@ var rechartsTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editFile/index.js
-import { z as z137 } from "zod";
+import { z as z138 } from "zod";
 import { diffLines as diffLines2 } from "diff";
-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")
+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")
   }).optional().describe("Optional selection range to edit within the file"),
-  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")
+  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")
 });
 function generateSimpleDiff(original, modified) {
   const differences = diffLines2(original, modified);
@@ -9981,8 +10212,343 @@ var editLocalFileTool = {
   })
 };
 
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/recentChanges/index.js
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_SINCE = "7 days ago";
+var DEFAULT_LIMIT = 50;
+var DEFAULT_INCLUDE_STATS = false;
+function parseStatusLine(line) {
+  const results = [];
+  if (line.length < 4)
+    return results;
+  const indexStatus = line[0];
+  const workTreeStatus = line[1];
+  const filePath = line.slice(3);
+  const typeMap = {
+    M: "modified",
+    A: "added",
+    D: "deleted",
+    R: "renamed",
+    C: "copied"
+  };
+  if (indexStatus !== " " && indexStatus !== "?") {
+    results.push({
+      path: filePath,
+      status: "staged",
+      type: typeMap[indexStatus] || "modified"
+    });
+  }
+  if (workTreeStatus !== " " && workTreeStatus !== "?") {
+    results.push({
+      path: filePath,
+      status: "unstaged",
+      type: typeMap[workTreeStatus] || "modified"
+    });
+  }
+  if (indexStatus === "?" && workTreeStatus === "?") {
+    results.push({
+      path: filePath,
+      status: "untracked",
+      type: "added"
+    });
+  }
+  return results;
+}
+async function getWorkingTreeChanges(filterPath) {
+  const args = ["status", "--porcelain"];
+  if (filterPath) {
+    args.push("--", filterPath);
+  }
+  return new Promise((resolve3) => {
+    const proc = spawn2("git", args, {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.on("close", (exitCode) => {
+      if (exitCode !== 0) {
+        resolve3([]);
+        return;
+      }
+      const files = stdout.split("\n").filter((line) => line.length > 0).flatMap(parseStatusLine);
+      resolve3(files);
+    });
+    proc.on("error", () => {
+      resolve3([]);
+    });
+  });
+}
+async function getRecentChanges(params) {
+  const { since = DEFAULT_SINCE, path: filterPath, limit = DEFAULT_LIMIT, include_stats = DEFAULT_INCLUDE_STATS } = params;
+  const args = ["log", `--since=${since}`, "--name-only", "--pretty=format:"];
+  if (filterPath) {
+    args.push("--", filterPath);
+  }
+  return new Promise((resolve3) => {
+    const proc = spawn2("git", args, {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", async (exitCode) => {
+      const workingTree = await getWorkingTreeChanges(filterPath);
+      if (exitCode !== 0) {
+        resolve3({
+          files: [],
+          workingTree,
+          timeRange: since,
+          totalFiles: 0,
+          error: stderr || "Git command failed"
+        });
+        return;
+      }
+      const files = stdout.split("\n").filter((line) => line.trim().length > 0).reduce((acc, filePath) => {
+        const existing = acc.find((f) => f.path === filePath);
+        if (existing) {
+          existing.changes++;
+        } else {
+          acc.push({ path: filePath, changes: 1 });
+        }
+        return acc;
+      }, []);
+      files.sort((a, b) => b.changes - a.changes);
+      const limitedFiles = files.slice(0, limit);
+      if (include_stats && limitedFiles.length > 0) {
+        const filesWithStats = await getFileStats(limitedFiles, since, filterPath);
+        resolve3({
+          files: filesWithStats,
+          workingTree,
+          timeRange: since,
+          totalFiles: files.length
+        });
+      } else {
+        resolve3({
+          files: limitedFiles,
+          workingTree,
+          timeRange: since,
+          totalFiles: files.length
+        });
+      }
+    });
+    proc.on("error", async (error) => {
+      const workingTree = await getWorkingTreeChanges(filterPath);
+      resolve3({
+        files: [],
+        workingTree,
+        timeRange: since,
+        totalFiles: 0,
+        error: `Failed to execute git command: ${error.message}`
+      });
+    });
+  });
+}
+async function getFileStats(files, since, filterPath) {
+  const args = ["log", `--since=${since}`, "--numstat", "--pretty=format:"];
+  if (filterPath) {
+    args.push("--", filterPath);
+  }
+  return new Promise((resolve3) => {
+    const proc = spawn2("git", args, {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.on("close", () => {
+      const stats = /* @__PURE__ */ new Map();
+      stdout.split("\n").forEach((line) => {
+        const match = line.match(/^(\d+)\s+(\d+)\s+(.+)$/);
+        if (match) {
+          const [, additions, deletions, filePath] = match;
+          const existing = stats.get(filePath);
+          if (existing) {
+            existing.additions += parseInt(additions, 10);
+            existing.deletions += parseInt(deletions, 10);
+          } else {
+            stats.set(filePath, {
+              additions: parseInt(additions, 10),
+              deletions: parseInt(deletions, 10)
+            });
+          }
+        }
+      });
+      const result = files.map((file) => {
+        const stat3 = stats.get(file.path);
+        if (stat3) {
+          return { ...file, ...stat3 };
+        }
+        return file;
+      });
+      resolve3(result);
+    });
+    proc.on("error", () => {
+      resolve3(files);
+    });
+  });
+}
+function formatResult2(result) {
+  const parts = [];
+  if (result.error) {
+    parts.push(`Error: ${result.error}`);
+    parts.push("");
+    parts.push("Make sure you are running this command in a git repository.");
+    if (result.workingTree.length > 0) {
+      parts.push("");
+      parts.push(formatWorkingTree(result.workingTree));
+    }
+    return parts.join("\n");
+  }
+  if (result.workingTree.length > 0) {
+    parts.push(formatWorkingTree(result.workingTree));
+    parts.push("");
+  }
+  parts.push(`Recently committed files (${result.timeRange}):`);
+  parts.push("");
+  if (result.files.length === 0) {
+    parts.push("No files changed in this time period.");
+  } else {
+    result.files.forEach((file, index) => {
+      const stats = file.additions !== void 0 && file.deletions !== void 0 ? ` (+${file.additions}/-${file.deletions})` : "";
+      parts.push(`${index + 1}. ${file.path} (${file.changes} commits)${stats}`);
+    });
+    if (result.totalFiles > result.files.length) {
+      parts.push("");
+      parts.push(`Showing ${result.files.length} of ${result.totalFiles} changed files.`);
+      parts.push(`Use the 'limit' parameter to see more files.`);
+    }
+  }
+  return parts.join("\n");
+}
+function formatWorkingTree(workingTree) {
+  const parts = [];
+  const staged = workingTree.filter((f) => f.status === "staged");
+  const unstaged = workingTree.filter((f) => f.status === "unstaged");
+  const untracked = workingTree.filter((f) => f.status === "untracked");
+  parts.push("Working tree changes:");
+  if (staged.length > 0) {
+    parts.push("");
+    parts.push(`  Staged (${staged.length}):`);
+    staged.forEach((f) => parts.push(`    ${f.type}: ${f.path}`));
+  }
+  if (unstaged.length > 0) {
+    parts.push("");
+    parts.push(`  Unstaged (${unstaged.length}):`);
+    unstaged.forEach((f) => parts.push(`    ${f.type}: ${f.path}`));
+  }
+  if (untracked.length > 0) {
+    parts.push("");
+    parts.push(`  Untracked (${untracked.length}):`);
+    untracked.forEach((f) => parts.push(`    ${f.path}`));
+  }
+  return parts.join("\n");
+}
+var recentChangesTool = {
+  name: "recent_changes",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      context.logger.info("RecentChanges: Getting recently changed files", {
+        since: params.since || DEFAULT_SINCE,
+        path: params.path || "all",
+        limit: params.limit || DEFAULT_LIMIT,
+        include_stats: params.include_stats || DEFAULT_INCLUDE_STATS
+      });
+      if (context.onStart) {
+        await context.onStart("recent_changes", {
+          since: params.since,
+          path: params.path
+        });
+      }
+      try {
+        const result = await getRecentChanges(params);
+        const formattedResult = formatResult2(result);
+        context.logger.info("RecentChanges: Retrieved file changes", {
+          totalFiles: result.totalFiles,
+          displayedFiles: result.files.length,
+          error: result.error
+        });
+        if (context.onFinish) {
+          await context.onFinish("recent_changes", {
+            totalFiles: result.totalFiles,
+            displayedFiles: result.files.length
+          });
+        }
+        return formattedResult;
+      } catch (error) {
+        context.logger.error("RecentChanges: Failed to get changes", error);
+        if (context.onFinish) {
+          await context.onFinish("recent_changes", {
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+        throw error;
+      }
+    },
+    toolSchema: {
+      name: "recent_changes",
+      description: `Get a list of recently changed files in the git repository, including uncommitted working tree changes (staged, unstaged, and untracked files) plus committed changes sorted by activity. This tool is extremely useful for:
+
+- **Debugging recent issues**: "Something broke after my last commit" \u2192 See exactly what changed
+- **Understanding active development**: "What are we working on?" \u2192 See most active files and current work-in-progress
+- **Code review preparation**: "What changed since last release?" \u2192 Get comprehensive file list
+- **Feature context**: "What files are part of the new dashboard?" \u2192 Filter by path
+- **Current work-in-progress**: See staged, unstaged, and untracked files alongside commit history
+
+The tool combines git status (working tree) with git log (commit history) to give a complete picture of recent activity. Working tree changes are shown first, followed by committed files ranked by number of commits (most active first).
+
+**Time Range Examples:**
+- "7 days ago" (default)
+- "2 hours ago"
+- "3 weeks ago"
+- "2025-01-01"
+- "yesterday"
+
+**Path Filter Examples:**
+- "src/components" - Only files in components directory
+- "apps/client" - Only client app files
+- "**/*.test.ts" - Only test files (use glob patterns)
+
+**Performance:** Very fast (< 1 second) since it only queries git metadata, not file contents.`,
+      parameters: {
+        type: "object",
+        properties: {
+          since: {
+            type: "string",
+            description: 'Time range for changes (default: "7 days ago"). Examples: "2 hours ago", "3 weeks ago", "2025-01-01", "yesterday".'
+          },
+          path: {
+            type: "string",
+            description: 'Optional path filter to limit results to specific directory or pattern. Examples: "src/components", "apps/client", "**/*.test.ts".'
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of files to return (default: 50). Files are sorted by activity (most commits first)."
+          },
+          include_stats: {
+            type: "boolean",
+            description: "Include lines added/removed statistics for each file (default: false). Note: This makes the command slightly slower."
+          }
+        },
+        required: []
+      }
+    }
+  })
+};
+
 // ../../b4m-core/packages/services/dist/src/llm/tools/index.js
-var tools = {
+var b4mTools = {
   dice_roll: diceRollTool,
   weather_info: weatherTool,
   image_generation: imageGenerationTool,
@@ -10005,18 +10571,23 @@ var tools = {
   sunrise_sunset: sunriseSunsetTool,
   iss_tracker: issTrackerTool,
   planet_visibility: planetVisibilityTool,
+  // Knowledge base search
+  search_knowledge_base: knowledgeBaseSearchTool
+};
+var cliOnlyTools = {
+  // File operation tools
   file_read: fileReadTool,
   create_file: createFileTool,
   edit_local_file: editLocalFileTool,
   glob_files: globFilesTool,
   grep_search: grepSearchTool,
   delete_file: deleteFileTool,
-  // Knowledge base search
-  search_knowledge_base: knowledgeBaseSearchTool,
   // Shell execution
-  bash_execute: bashExecuteTool
+  bash_execute: bashExecuteTool,
+  // Git operations
+  recent_changes: recentChangesTool
 };
-var generateTools = (userId, user, logger2, { db }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model) => {
+var generateTools = (userId, user, logger2, { db }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model, tools = b4mTools) => {
   const context = {
     userId,
     user,
@@ -10037,9 +10608,9 @@ var generateTools = (userId, user, logger2, { db }, storage, imageGenerateStorag
 };
 var ATLASSIAN_RECONNECT_MESSAGE = "\u26A0\uFE0F Your Atlassian connection has expired.\n\nPlease reconnect your Atlassian account in Settings > Connected Apps to continue using Confluence and Jira tools.";
 var generateMcpTools = async (mcpData) => {
-  let tools2;
+  let tools;
   try {
-    tools2 = await mcpData.getTools();
+    tools = await mcpData.getTools();
   } catch (error) {
     const errorName = error instanceof Error ? error.name : "";
     if (errorName === "AtlassianReconnectRequiredError") {
@@ -10048,12 +10619,12 @@ var generateMcpTools = async (mcpData) => {
     }
     throw error;
   }
-  const toolList = Array.isArray(tools2) ? tools2 : tools2?.tools || [];
-  if (!Array.isArray(tools2)) {
-    console.warn(`MCP server ${mcpData.serverName} returned unexpected tools payload:`, JSON.stringify(tools2));
+  const toolList = Array.isArray(tools) ? tools : tools?.tools || [];
+  if (!Array.isArray(tools)) {
+    console.warn(`MCP server ${mcpData.serverName} returned unexpected tools payload:`, JSON.stringify(tools));
   }
   if (!Array.isArray(toolList)) {
-    throw new Error(`Expected getTools() to return an array, but got ${typeof tools2}`);
+    throw new Error(`Expected getTools() to return an array, but got ${typeof tools}`);
   }
   const result = toolList.map((item) => {
     const { name: originalToolName, ...rest } = item;
@@ -10123,47 +10694,47 @@ var generateMcpTools = async (mcpData) => {
 import throttle2 from "lodash/throttle.js";
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionFeatures.js
-import { z as z138 } from "zod";
+import { z as z139 } from "zod";
 import uniq4 from "lodash/uniq.js";
-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()),
+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()),
   params: ChatCompletionCreateInputSchema,
   dashboardParams: DashboardParamsSchema.optional(),
-  enableQuestMaster: z138.boolean().optional(),
-  enableMementos: z138.boolean().optional(),
-  enableArtifacts: z138.boolean().optional(),
-  enableAgents: z138.boolean().optional(),
+  enableQuestMaster: z139.boolean().optional(),
+  enableMementos: z139.boolean().optional(),
+  enableArtifacts: z139.boolean().optional(),
+  enableAgents: z139.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
-  tools: z138.array(z138.union([b4mLLMTools, z138.string()])).optional(),
-  mcpServers: z138.array(z138.string()).optional(),
-  projectId: z138.string().optional(),
-  organizationId: z138.string().nullable().optional(),
+  tools: z139.array(z139.union([b4mLLMTools, z139.string()])).optional(),
+  mcpServers: z139.array(z139.string()).optional(),
+  projectId: z139.string().optional(),
+  organizationId: z139.string().nullable().optional(),
   questMaster: QuestMasterParamsSchema.optional(),
-  toolPromptId: z138.string().optional(),
+  toolPromptId: z139.string().optional(),
   researchMode: ResearchModeParamsSchema.optional(),
-  fallbackModel: z138.string().optional(),
-  embeddingModel: z138.string().optional(),
-  queryComplexity: z138.string(),
+  fallbackModel: z139.string().optional(),
+  embeddingModel: z139.string().optional(),
+  queryComplexity: z139.string(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z138.object({
-    maxDepth: z138.number().optional(),
-    duration: z138.number().optional(),
+  deepResearchConfig: z139.object({
+    maxDepth: z139.number().optional(),
+    duration: z139.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z138.array(z138.any()).optional()
+    searchers: z139.array(z139.any()).optional()
   }).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()
+  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()
   })).optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z138.string().optional()
+  timezone: z139.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/StatusManager.js
@@ -10183,89 +10754,89 @@ var BUILT_IN_TOOL_SET = new Set(b4mLLMTools.options);
 import axios8 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer4 } from "file-type";
 import { v4 as uuidv47 } from "uuid";
-import { z as z139 } from "zod";
+import { z as z140 } 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(),
-  organizationId: z139.string().nullable().optional(),
-  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()
+  sessionId: z140.string(),
+  questId: z140.string(),
+  userId: z140.string(),
+  prompt: z140.string(),
+  organizationId: z140.string().nullable().optional(),
+  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"),
+  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/VideoGeneration.js
 import axios9 from "axios";
 import { v4 as uuidv48 } from "uuid";
-import { z as z140 } from "zod";
+import { z as z141 } from "zod";
 import { fromZodError as fromZodError3 } from "zod-validation-error";
-var VideoGenerationBodySchema = z140.object({
-  sessionId: z140.string(),
-  questId: z140.string(),
-  userId: z140.string(),
-  prompt: z140.string(),
-  model: z140.nativeEnum(VideoModels).default(VideoModels.SORA_2),
-  seconds: z140.union([z140.literal(4), z140.literal(8), z140.literal(12)]).default(4),
-  size: z140.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize),
-  organizationId: z140.string().nullable().optional()
+var VideoGenerationBodySchema = z141.object({
+  sessionId: z141.string(),
+  questId: z141.string(),
+  userId: z141.string(),
+  prompt: z141.string(),
+  model: z141.nativeEnum(VideoModels).default(VideoModels.SORA_2),
+  seconds: z141.union([z141.literal(4), z141.literal(8), z141.literal(12)]).default(4),
+  size: z141.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize),
+  organizationId: z141.string().nullable().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
 import axios10 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
 import { v4 as uuidv49 } from "uuid";
-import { z as z141 } from "zod";
+import { z as z142 } from "zod";
 import { fromZodError as fromZodError4 } from "zod-validation-error";
 var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z141.string(),
-  questId: z141.string(),
-  userId: z141.string(),
-  prompt: z141.string(),
-  organizationId: z141.string().nullable().optional(),
-  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()
+  sessionId: z142.string(),
+  questId: z142.string(),
+  userId: z142.string(),
+  prompt: z142.string(),
+  organizationId: z142.string().nullable().optional(),
+  safety_tolerance: z142.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z142.boolean().optional().default(false),
+  seed: z142.number().nullable().optional(),
+  output_format: z142.enum(["jpeg", "png"]).optional().default("png"),
+  width: z142.number().optional(),
+  height: z142.number().optional(),
+  aspect_ratio: z142.string().optional(),
+  size: z142.string().optional(),
+  fabFileIds: z142.array(z142.string()).optional(),
+  image: z142.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 z143 } from "zod";
+var refineTextLLMSchema = z143.object({
+  text: z143.string(),
+  context: z143.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 z144 } from "zod";
+var SingleMementoEvalSchema = z144.object({
+  importance: z144.number().min(1).max(10),
   // 1-10 scale for personal info importance
-  summary: z143.string(),
-  tags: z143.array(z143.string()).optional()
+  summary: z144.string(),
+  tags: z144.array(z144.string()).optional()
 });
-var MementoEvalResponseSchema = z143.object({
-  isPersonal: z143.boolean(),
-  mementos: z143.array(SingleMementoEvalSchema).optional()
+var MementoEvalResponseSchema = z144.object({
+  isPersonal: z144.boolean(),
+  mementos: z144.array(SingleMementoEvalSchema).optional()
   // Array of distinct personal information
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/SmallLLMService.js
-import { z as z144 } from "zod";
+import { z as z145 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/auth/AccessTokenGeneratorService.js
 import jwt2 from "jsonwebtoken";
@@ -10392,7 +10963,8 @@ var LOCAL_TOOLS = [
   "dice_roll",
   "math_evaluate",
   "current_datetime",
-  "bash_execute"
+  "bash_execute",
+  "recent_changes"
 ];
 function isServerTool(toolName) {
   return SERVER_TOOLS.includes(toolName);
@@ -10418,11 +10990,11 @@ async function executeTool(toolName, input, apiClient, localToolFn) {
 }
 
 // src/utils/shellRunner.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 async function runShellCommand(options) {
   const { command, cwd, timeoutMs, env, stdin } = options;
   return new Promise((resolve3) => {
-    const child = spawn2("bash", ["-c", command], {
+    const child = spawn3("bash", ["-c", command], {
       cwd,
       env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -10557,7 +11129,7 @@ function buildHookContext(params) {
 }
 
 // src/agents/types.ts
-import { z as z145 } from "zod";
+import { z as z146 } from "zod";
 var HookBlockedError = class extends Error {
   constructor(toolName, reason) {
     super(`Hook blocked execution of ${toolName}: ${reason || "No reason provided"}`);
@@ -10569,39 +11141,39 @@ var ALWAYS_DENIED_FOR_AGENTS = [
   "agent_delegate"
   // No agent chaining
 ];
-var CommandHookSchema = z145.object({
-  type: z145.literal("command"),
-  command: z145.string().min(1, "Command is required for command hooks"),
-  timeout: z145.number().optional()
-});
-var PromptHookSchema = z145.object({
-  type: z145.literal("prompt"),
-  prompt: z145.string().min(1, "Prompt is required for prompt hooks"),
-  timeout: z145.number().optional()
-});
-var HookDefinitionSchema = z145.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
-var HookMatcherSchema = z145.object({
-  matcher: z145.string().optional(),
-  hooks: z145.array(HookDefinitionSchema)
-});
-var AgentHooksSchema = z145.object({
-  PreToolUse: z145.array(HookMatcherSchema).optional(),
-  PostToolUse: z145.array(HookMatcherSchema).optional(),
-  PostToolUseFailure: z145.array(HookMatcherSchema).optional(),
-  Stop: z145.array(HookMatcherSchema).optional()
+var CommandHookSchema = z146.object({
+  type: z146.literal("command"),
+  command: z146.string().min(1, "Command is required for command hooks"),
+  timeout: z146.number().optional()
+});
+var PromptHookSchema = z146.object({
+  type: z146.literal("prompt"),
+  prompt: z146.string().min(1, "Prompt is required for prompt hooks"),
+  timeout: z146.number().optional()
+});
+var HookDefinitionSchema = z146.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
+var HookMatcherSchema = z146.object({
+  matcher: z146.string().optional(),
+  hooks: z146.array(HookDefinitionSchema)
+});
+var AgentHooksSchema = z146.object({
+  PreToolUse: z146.array(HookMatcherSchema).optional(),
+  PostToolUse: z146.array(HookMatcherSchema).optional(),
+  PostToolUseFailure: z146.array(HookMatcherSchema).optional(),
+  Stop: z146.array(HookMatcherSchema).optional()
 }).optional();
-var AgentFrontmatterSchema = z145.object({
-  description: z145.string().min(1, "Agent description is required"),
-  model: z145.string().optional(),
-  "allowed-tools": z145.array(z145.string()).optional(),
-  "denied-tools": z145.array(z145.string()).optional(),
-  "max-iterations": z145.object({
-    quick: z145.number().int().positive().optional(),
-    medium: z145.number().int().positive().optional(),
-    very_thorough: z145.number().int().positive().optional()
+var AgentFrontmatterSchema = z146.object({
+  description: z146.string().min(1, "Agent description is required"),
+  model: z146.string().optional(),
+  "allowed-tools": z146.array(z146.string()).optional(),
+  "denied-tools": z146.array(z146.string()).optional(),
+  "max-iterations": z146.object({
+    quick: z146.number().int().positive().optional(),
+    medium: z146.number().int().positive().optional(),
+    very_thorough: z146.number().int().positive().optional()
   }).optional(),
-  "default-thoroughness": z145.enum(["quick", "medium", "very_thorough"]).optional(),
-  variables: z145.record(z145.string()).optional(),
+  "default-thoroughness": z146.enum(["quick", "medium", "very_thorough"]).optional(),
+  variables: z146.record(z146.string()).optional(),
   hooks: AgentHooksSchema
 });
 var DEFAULT_MAX_ITERATIONS = {
@@ -10662,6 +11234,12 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
         agentContext.observationQueue.push({ toolName, result: result2 });
         return result2;
       }
+      const { useCliStore: useCliStore2 } = await import("./store-JNTO6SRG.js");
+      if (useCliStore2.getState().autoAcceptEdits) {
+        const result2 = await executeTool(toolName, args, apiClient, originalFn);
+        agentContext.observationQueue.push({ toolName, result: result2 });
+        return result2;
+      }
       let preview;
       if (toolName === "edit_local_file" && args?.path && args?.old_string && typeof args?.new_string === "string") {
         try {
@@ -10845,37 +11423,21 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
       adminSettings: mockAdminSettings
     }
   };
-  const toolConfig = {
+  const enabledB4mToolNames = [
     // Local-only tools (no external API keys needed)
-    dice_roll: {},
-    math_evaluate: {},
-    current_datetime: {},
-    prompt_enhancement: {},
-    // File operation tools (CLI-specific, local execution)
-    file_read: {},
-    create_file: {},
-    edit_local_file: {},
-    glob_files: {},
-    grep_search: {},
-    delete_file: {},
-    // Shell execution (always requires permission)
-    bash_execute: {},
+    "dice_roll",
+    "math_evaluate",
+    "current_datetime",
+    "prompt_enhancement",
     // Server-side tools (executed via /api/ai/v1/tools Lambda)
-    // Routed by ToolRouter to use B4M company API keys
-    weather_info: {},
-    web_search: {},
-    web_fetch: {}
-    // Disable web-only tools
-    // blog_publish: undefined,
-    // blog_edit: undefined,
-    // blog_draft: undefined,
-    // image_generation: undefined,
-    // edit_image: undefined,
-    // mermaid_chart: undefined,
-    // recharts: undefined,
-    // edit_file: undefined,
-    // deep_research: undefined,
-  };
+    "weather_info",
+    "web_search",
+    "web_fetch"
+  ];
+  const filteredB4mTools = Object.fromEntries(
+    enabledB4mToolNames.filter((name) => name in b4mTools).map((name) => [name, b4mTools[name]])
+  );
+  const tools_to_generate = { ...filteredB4mTools, ...cliOnlyTools };
   const toolsMap = generateTools(
     userId,
     user,
@@ -10888,17 +11450,18 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     onStart,
     onFinish,
     llm,
-    toolConfig,
-    model
+    {},
+    model,
+    tools_to_generate
   );
-  let tools2 = Object.entries(toolsMap).filter(([key]) => toolConfig[key] !== void 0).map(
+  let tools = Object.entries(toolsMap).map(
     ([_, tool]) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient)
   );
   if (toolFilter) {
     const { allowedTools, deniedTools } = toolFilter;
     const normalizedAllowed = allowedTools?.map(normalizeToolName);
     const normalizedDenied = deniedTools?.map(normalizeToolName);
-    tools2 = tools2.filter((tool) => {
+    tools = tools.filter((tool) => {
       const toolName = tool.toolSchema.name;
       if (normalizedDenied && normalizedDenied.includes(toolName)) {
         return false;
@@ -10909,68 +11472,7 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
       return true;
     });
   }
-  return { tools: tools2, agentContext };
-}
-
-// src/config/toolSafety.ts
-import { z as z146 } from "zod";
-var ToolCategorySchema = z146.enum([
-  "auto_approve",
-  // Safe tools that run automatically without permission
-  "prompt_always",
-  // Dangerous tools that ALWAYS require permission (cannot be trusted)
-  "prompt_default"
-  // Tools that prompt by default but can be trusted
-]);
-var ToolSafetyConfigSchema = z146.object({
-  categories: z146.record(z146.string(), ToolCategorySchema),
-  trustedTools: z146.array(z146.string())
-});
-var DEFAULT_TOOL_CATEGORIES = {
-  // ===== AUTO APPROVE (Safe tools) =====
-  // These tools have no side effects and are always safe to execute
-  math_evaluate: "auto_approve",
-  current_datetime: "auto_approve",
-  dice_roll: "auto_approve",
-  prompt_enhancement: "auto_approve",
-  weather_info: "prompt_default",
-  // ===== PROMPT ALWAYS (Dangerous tools) =====
-  // These tools can modify files, execute code, or have other dangerous side effects
-  // They ALWAYS require permission and cannot be trusted automatically
-  edit_file: "prompt_always",
-  edit_local_file: "prompt_always",
-  create_file: "prompt_always",
-  delete_file: "prompt_always",
-  shell_execute: "prompt_always",
-  bash_execute: "prompt_always",
-  git_commit: "prompt_always",
-  git_push: "prompt_always",
-  // ===== PROMPT DEFAULT (Repository read tools) =====
-  // These tools read from the repository but don't modify anything
-  // Users can trust them if they want to avoid prompts
-  web_search: "prompt_default",
-  deep_research: "prompt_default",
-  file_read: "prompt_default",
-  grep_search: "prompt_default",
-  glob_files: "prompt_default",
-  get_file_tree: "prompt_default",
-  git_status: "prompt_default",
-  git_diff: "prompt_default",
-  git_log: "prompt_default",
-  git_branch: "prompt_default"
-};
-function getToolCategory(toolName, customCategories) {
-  if (customCategories && toolName in customCategories) {
-    return customCategories[toolName];
-  }
-  if (toolName in DEFAULT_TOOL_CATEGORIES) {
-    return DEFAULT_TOOL_CATEGORIES[toolName];
-  }
-  return "prompt_default";
-}
-function canTrustTool(toolName, customCategories) {
-  const category = getToolCategory(toolName, customCategories);
-  return category !== "prompt_always";
+  return { tools, agentContext };
 }
 
 // src/utils/PermissionManager.ts
@@ -11348,9 +11850,9 @@ var TokenCounter = class {
    * Count tokens in tool schemas.
    * Tool schemas are sent as part of the API call and consume context.
    */
-  countToolSchemaTokens(tools2) {
-    if (tools2.length === 0) return 0;
-    const schemaText = tools2.map(
+  countToolSchemaTokens(tools) {
+    if (tools.length === 0) return 0;
+    const schemaText = tools.map(
       ({ toolSchema }) => `Tool: ${toolSchema.name}
 Description: ${toolSchema.description}
 Parameters: ${JSON.stringify(toolSchema.parameters)}`
@@ -11652,14 +12154,14 @@ var McpManager = class {
         getTools: async () => client.tools,
         callTool: async (name, args) => client.callTool(name, args)
       };
-      const tools2 = await generateMcpTools(mcpData);
+      const tools = await generateMcpTools(mcpData);
       this.servers.set(serverConfig.name, {
         name: serverConfig.name,
         client,
-        tools: tools2
+        tools
       });
       this.connectionStates.set(serverConfig.name, "connected");
-      logger.debug(`\u2705 Connected to ${serverConfig.name} (${tools2.length} tools)`);
+      logger.debug(`\u2705 Connected to ${serverConfig.name} (${tools.length} tools)`);
     } catch (error) {
       this.connectionStates.set(serverConfig.name, "failed");
       logger.debug(`\u274C Failed to connect to ${serverConfig.name}: ${error}`);
@@ -12544,7 +13046,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.25-cli-file-read-offset.18514+53b238fc9",
+  version: "0.2.25-cli-file-read-offset.18541+a5717c121",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -12652,10 +13154,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.47.2-cli-file-read-offset.18514+53b238fc9",
-    "@bike4mind/mcp": "1.28.1-cli-file-read-offset.18514+53b238fc9",
-    "@bike4mind/services": "2.45.2-cli-file-read-offset.18514+53b238fc9",
-    "@bike4mind/utils": "2.3.4-cli-file-read-offset.18514+53b238fc9",
+    "@bike4mind/common": "2.47.2-cli-file-read-offset.18541+a5717c121",
+    "@bike4mind/mcp": "1.28.1-cli-file-read-offset.18541+a5717c121",
+    "@bike4mind/services": "2.45.2-cli-file-read-offset.18541+a5717c121",
+    "@bike4mind/utils": "2.3.4-cli-file-read-offset.18541+a5717c121",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -12672,7 +13174,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "53b238fc928978c41a9cb6e4081b79f3f92db65f"
+  gitHead: "a5717c121a35ad3b958b4f8471fe5a3b94781c42"
 };
 
 // src/config/constants.ts
@@ -12791,7 +13293,9 @@ var SubagentOrchestrator = class {
     let result;
     try {
       result = await agent.run(task, {
-        maxIterations
+        maxIterations,
+        parallelExecution: this.deps.enableParallelToolExecution === true,
+        isReadOnlyTool
       });
     } catch (error) {
       if (error instanceof HookBlockedError) {
@@ -13790,7 +14294,7 @@ function CliApp() {
       process.exit(0);
     }, 100);
   }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
-  useInput7((input, key) => {
+  useInput8((input, key) => {
     if (key.escape) {
       if (state.abortController) {
         logger.debug("[ABORT] ESC pressed - aborting current operation...");
@@ -13955,7 +14459,7 @@ function CliApp() {
         currentAgent: null,
         observationQueue: []
       };
-      const { tools: b4mTools } = generateCliTools(
+      const { tools: b4mTools2 } = generateCliTools(
         config.userId,
         llm,
         modelInfo.id,
@@ -13965,7 +14469,7 @@ function CliApp() {
         state.configStore,
         apiClient
       );
-      console.log(`\u{1F6E0}\uFE0F Loaded ${b4mTools.length} B4M tool(s)`);
+      console.log(`\u{1F6E0}\uFE0F Loaded ${b4mTools2.length} B4M tool(s)`);
       const mcpManager = new McpManager(config);
       await mcpManager.initialize();
       const mcpTools = mcpManager.getTools();
@@ -13991,7 +14495,8 @@ function CliApp() {
         showPermissionPrompt: promptFn,
         configStore: state.configStore,
         apiClient,
-        agentStore
+        agentStore,
+        enableParallelToolExecution: config.preferences.enableParallelToolExecution === true
       });
       const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id);
       const todoStore = createTodoStore();
@@ -14006,7 +14511,7 @@ function CliApp() {
       if (skillTool) {
         cliTools.push(skillTool);
       }
-      const allTools = [...b4mTools, ...mcpTools, ...cliTools];
+      const allTools = [...b4mTools2, ...mcpTools, ...cliTools];
       console.log(`\u{1F4C2} Working directory: ${process.cwd()}`);
       console.log(`\u{1F916} Subagent delegation enabled (explore, plan, review)`);
       if (skillTool) {
@@ -14016,7 +14521,7 @@ function CliApp() {
         }
       }
       logger.debug(
-        `Total tools available to agent: ${allTools.length} (${b4mTools.length} B4M + ${mcpTools.length} MCP + ${cliTools.length} CLI)`
+        `Total tools available to agent: ${allTools.length} (${b4mTools2.length} B4M + ${mcpTools.length} MCP + ${cliTools.length} CLI)`
       );
       const projectDir = state.configStore.getProjectConfigDir();
       const contextResult = await loadContextFiles(projectDir);
@@ -14191,9 +14696,12 @@ ${contextResult.mergedContent}` : "";
         role: msg.role,
         content: msg.content
       }));
+      const cliConfig = await state.configStore.get();
       const result = await state.agent.run(messageContent, {
         previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
-        signal: abortController.signal
+        signal: abortController.signal,
+        parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
+        isReadOnlyTool
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {
@@ -14394,9 +14902,12 @@ ${contextResult.mergedContent}` : "";
         role: msg.role,
         content: msg.content
       }));
+      const cliConfig = await state.configStore.get();
       const result = await state.agent.run(messageContent, {
         previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
-        signal: abortController.signal
+        signal: abortController.signal,
+        parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
+        isReadOnlyTool
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {
@@ -14695,13 +15206,17 @@ Custom Commands:
           console.log("No active session to save");
           return;
         }
+        if (state.session.messages.length === 0) {
+          console.log("\u274C Cannot save session with no messages");
+          return;
+        }
         const sessionName = args.join(" ") || state.session.name;
         state.session.name = sessionName;
         await state.sessionStore.save(state.session);
         console.log(`\u2705 Session saved as "${sessionName}"`);
         break;
       case "sessions": {
-        const sessions = await state.sessionStore.list();
+        const sessions = await state.sessionStore.list(20);
         if (sessions.length === 0) {
           console.log("\n\u{1F4DA} No saved sessions found.");
           console.log("\u{1F4A1} Use /save <name> to save your current session.\n");