@bike4mind/cli 0.2.10-fix-b4m-cli-flicker.17235 → 0.2.10-fix-cli-duplicate-chat-history.17269

package/dist/index.js

@@ -79,12 +79,13 @@ import {
 } from "./chunk-PDX44BCA.js";
 
 // src/index.tsx
-import React17, { useState as useState7, useEffect as useEffect3, useCallback, useRef } from "react";
+import React17, { useState as useState8, useEffect as useEffect3, useCallback, useRef as useRef2 } from "react";
 import { render, Box as Box16, Text as Text16, useApp, useInput as useInput6 } from "ink";
+import { execSync } from "child_process";
 import { v4 as uuidv49 } from "uuid";
 
 // src/components/App.tsx
-import React11 from "react";
+import React11, { useState as useState4 } from "react";
 import { Box as Box10, Text as Text10, Static } from "ink";
 
 // src/components/StatusBar.tsx
@@ -95,7 +96,7 @@ var StatusBar = React.memo(function StatusBar2({ sessionName, model, tokenUsage
 });
 
 // src/components/InputPrompt.tsx
-import React5, { useState as useState2, useMemo, useEffect } from "react";
+import React5, { useState as useState2, useMemo, useEffect, useRef } from "react";
 import { Box as Box4, Text as Text5, useInput as useInput2 } from "ink";
 
 // src/components/CustomTextInput.tsx
@@ -209,7 +210,8 @@ function CommandAutocomplete({ commands, selectedIndex }) {
   return /* @__PURE__ */ React3.createElement(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, commands.length === 1 ? "1 command" : `${commands.length} commands`, " \u2022 Use \u2191\u2193 to navigate, Enter to select")), commands.map((cmd, index) => {
     const args = cmd.args ? ` ${cmd.args}` : "";
     const isSelected = index === selectedIndex;
-    return /* @__PURE__ */ React3.createElement(Box2, { key: cmd.name, marginLeft: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "\u25B8 " : "  ", "/", cmd.name, args, " - ", cmd.description));
+    const sourceIcon = cmd.source === "global" ? "\u{1F3E0} " : cmd.source === "project" ? "\u{1F4C1} " : cmd.source === "built-in" ? "\u{1F527} " : "";
+    return /* @__PURE__ */ React3.createElement(Box2, { key: cmd.name, marginLeft: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "\u25B8 " : "  ", sourceIcon, "/", cmd.name, args, " - ", cmd.description));
   }));
 }
 
@@ -310,7 +312,7 @@ function searchFiles(query) {
       searchPool = files;
     }
   }
-  const fuse2 = new Fuse(searchPool, {
+  const fuse = new Fuse(searchPool, {
     keys: [{ name: "path", weight: 1 }],
     threshold: 0.4,
     // Allow some fuzzy matching
@@ -319,7 +321,7 @@ function searchFiles(query) {
     // Use extended search for better path matching
     useExtendedSearch: false
   });
-  const results = fuse2.search(query);
+  const results = fuse.search(query);
   return results.slice(0, 20).map((result) => result.item);
 }
 function isPathWithinCwd(filePath) {
@@ -494,11 +496,61 @@ var COMMANDS = [
     name: "rewind",
     description: "Rewind conversation to a previous point",
     aliases: ["undo"]
+  },
+  {
+    name: "project-config",
+    description: "Show merged project configuration"
+  },
+  {
+    name: "commands",
+    description: "List all custom commands"
+  },
+  {
+    name: "commands:new",
+    description: "Create a new custom command",
+    args: "<name>"
+  },
+  {
+    name: "commands:reload",
+    description: "Reload custom commands from disk"
   }
 ];
+function getAllCommandNames() {
+  const names = [];
+  for (const cmd of COMMANDS) {
+    names.push(cmd.name);
+    if (cmd.aliases) {
+      names.push(...cmd.aliases);
+    }
+  }
+  return names;
+}
+function isBuiltInCommand(name) {
+  return getAllCommandNames().includes(name);
+}
+function customCommandToDefinition(customCommand) {
+  return {
+    name: customCommand.name,
+    description: customCommand.description,
+    args: customCommand.argumentHint,
+    source: customCommand.source
+  };
+}
+function mergeCommands(customCommands) {
+  const builtInCommands = COMMANDS.map((cmd) => ({ ...cmd, source: "built-in" }));
+  const customDefinitions = customCommands.filter((cmd) => !isBuiltInCommand(cmd.name)).map(customCommandToDefinition);
+  const conflicts = customCommands.filter((cmd) => isBuiltInCommand(cmd.name));
+  if (conflicts.length > 0) {
+    console.warn(
+      "Warning: The following custom commands have names that conflict with built-in commands and will be ignored:",
+      conflicts.map((cmd) => cmd.name).join(", ")
+    );
+  }
+  return [...builtInCommands, ...customDefinitions];
+}
 
 // src/utils/fuzzySearch.ts
-var fuse = new Fuse2(COMMANDS, {
+var fuseOptions = {
   keys: [
     { name: "name", weight: 0.7 },
     // Prioritize command name
@@ -509,11 +561,12 @@ var fuse = new Fuse2(COMMANDS, {
   // 0 = perfect match, 1 = match anything
   includeScore: true,
   minMatchCharLength: 1
-});
-function searchCommands(query) {
+};
+function searchCommands(query, commands = COMMANDS) {
   if (!query || query.trim() === "") {
-    return COMMANDS;
+    return commands;
   }
+  const fuse = new Fuse2(commands, fuseOptions);
   const results = fuse.search(query);
   return results.map((result) => result.item);
 }
@@ -732,17 +785,20 @@ function findAtTrigger(value) {
 }
 function InputPrompt({
   onSubmit,
+  onBashCommand,
   onImageDetected,
   disabled = false,
   history = [],
+  commands = [],
   prefillInput,
-  onPrefillConsumed
+  onPrefillConsumed,
+  onBashModeChange
 }) {
   const [value, setValue] = useState2("");
   const [selectedIndex, setSelectedIndex] = useState2(0);
   const [historyIndex, setHistoryIndex] = useState2(-1);
   const [tempInput, setTempInput] = useState2("");
-  const [inputKey, setInputKey] = useState2(0);
+  const inputKey = useRef(0);
   useEffect(() => {
     if (prefillInput) {
       setValue(prefillInput);
@@ -751,12 +807,16 @@ function InputPrompt({
   }, [prefillInput, onPrefillConsumed]);
   const [fileAutocomplete, setFileAutocomplete] = useState2(null);
   const [fileSelectedIndex, setFileSelectedIndex] = useState2(0);
+  const isBashMode = value.startsWith("!");
+  useEffect(() => {
+    onBashModeChange?.(isBashMode);
+  }, [isBashMode, onBashModeChange]);
   const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active;
   const commandQuery = shouldShowCommandAutocomplete ? value.slice(1) : "";
   const filteredCommands = useMemo(() => {
     if (!shouldShowCommandAutocomplete) return [];
-    return searchCommands(commandQuery);
-  }, [shouldShowCommandAutocomplete, commandQuery]);
+    return searchCommands(commandQuery, commands);
+  }, [shouldShowCommandAutocomplete, commandQuery, commands]);
   const filteredFiles = useMemo(() => {
     if (!fileAutocomplete?.active) return [];
     return searchFiles(fileAutocomplete.query);
@@ -857,6 +917,16 @@ function InputPrompt({
       onSubmit(commandText);
       return;
     }
+    if (isBashMode && onBashCommand) {
+      const command = input.slice(1).trim();
+      if (command) {
+        onBashCommand(command);
+        setValue("");
+        setHistoryIndex(-1);
+        setFileAutocomplete(null);
+      }
+      return;
+    }
     onSubmit(input);
     setValue("");
     setHistoryIndex(-1);
@@ -887,14 +957,19 @@ function InputPrompt({
       setFileAutocomplete(null);
     }
   };
-  return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text5, { bold: true, color: "cyan" }, "> "), /* @__PURE__ */ React5.createElement(
+  const getPlaceholder = () => {
+    if (disabled) return "Thinking...";
+    if (isBashMode) return "Enter shell command to execute...";
+    return "Type your message, /help for commands, @file to reference, or ! for bash";
+  };
+  return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text5, { bold: true, color: isBashMode ? "yellow" : "cyan" }, isBashMode ? "$ " : "> "), /* @__PURE__ */ React5.createElement(
     CustomTextInput,
     {
-      key: inputKey,
+      key: inputKey.current,
       value,
       onChange: handleChange,
       onSubmit: handleSubmit,
-      placeholder: disabled ? "" : "Type your message, /help for commands, or @file to reference",
+      placeholder: getPlaceholder(),
       showCursor: !disabled
     }
   )), shouldShowCommandAutocomplete && /* @__PURE__ */ React5.createElement(CommandAutocomplete, { commands: filteredCommands, selectedIndex }), fileAutocomplete?.active && /* @__PURE__ */ React5.createElement(FileAutocomplete, { files: filteredFiles, selectedIndex: fileSelectedIndex, query: fileAutocomplete.query }));
@@ -918,6 +993,16 @@ 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] })),
@@ -1378,9 +1463,11 @@ function hasFileReferences(message) {
 function App({
   onMessage,
   onCommand,
+  onBashCommand,
   onPermissionResponse,
   onImageDetected,
   commandHistory = [],
+  commands = [],
   config,
   availableModels = [],
   onSaveConfig,
@@ -1398,6 +1485,7 @@ function App({
   const setShowConfigEditor = useCliStore((state) => state.setShowConfigEditor);
   const exitRequested = useCliStore((state) => state.exitRequested);
   const setIsThinking = useCliStore((state) => state.setIsThinking);
+  const [isBashMode, setIsBashMode] = useState4(false);
   const handleSubmit = React11.useCallback(
     async (input) => {
       const trimmed = input.trim();
@@ -1435,7 +1523,7 @@ ${errorBlock}`;
       onSave: onSaveConfig,
       onClose: () => setShowConfigEditor(false)
     }
-  )) : permissionPrompt ? /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(
+  )) : /* @__PURE__ */ React11.createElement(React11.Fragment, null, /* @__PURE__ */ React11.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React11.createElement(Box10, { key: `${message.timestamp}-${message.role}-${index}`, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(MessageItem, { message }))), /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column" }, pendingMessages.map((message, index) => /* @__PURE__ */ React11.createElement(Box10, { key: `pending-${message.timestamp}-${index}`, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(MessageItem, { message })))), permissionPrompt && /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(
     PermissionPrompt,
     {
       toolName: permissionPrompt.toolName,
@@ -1444,15 +1532,18 @@ ${errorBlock}`;
       canBeTrusted: permissionPrompt.canBeTrusted,
       onResponse: onPermissionResponse
     }
-  )) : /* @__PURE__ */ React11.createElement(React11.Fragment, null, /* @__PURE__ */ React11.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React11.createElement(Box10, { key: `${message.timestamp}-${message.role}-${index}`, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(MessageItem, { message }))), /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column" }, pendingMessages.map((message, index) => /* @__PURE__ */ React11.createElement(Box10, { key: `pending-${message.timestamp}-${index}`, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(MessageItem, { message })))), /* @__PURE__ */ React11.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React11.createElement(Box10, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), /* @__PURE__ */ React11.createElement(Box10, { borderStyle: "single", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React11.createElement(
+  )), /* @__PURE__ */ React11.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React11.createElement(Box10, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), /* @__PURE__ */ React11.createElement(Box10, { borderStyle: "single", borderColor: isBashMode ? "yellow" : "cyan", paddingX: 1 }, /* @__PURE__ */ React11.createElement(
     InputPrompt,
     {
       onSubmit: handleSubmit,
+      onBashCommand,
       onImageDetected,
       disabled: isThinking,
       history: commandHistory,
+      commands,
       prefillInput,
-      onPrefillConsumed
+      onPrefillConsumed,
+      onBashModeChange: setIsBashMode
     }
   )), /* @__PURE__ */ React11.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens })));
 }
@@ -1530,12 +1621,12 @@ function TrustLocationSelector({ inProject, onSelect, onCancel }) {
 }
 
 // src/components/RewindSelector.tsx
-import React14, { useState as useState4 } from "react";
+import React14, { useState as useState5 } from "react";
 import { Box as Box13, Text as Text13, useInput as useInput4 } from "ink";
 import SelectInput3 from "ink-select-input";
 function RewindSelector({ messages, onSelect, onCancel }) {
-  const [step, setStep] = useState4("selection");
-  const [selectedMessageIndex, setSelectedMessageIndex] = useState4(null);
+  const [step, setStep] = useState5("selection");
+  const [selectedMessageIndex, setSelectedMessageIndex] = useState5(null);
   useInput4((input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
@@ -1599,12 +1690,12 @@ function RewindSelector({ messages, onSelect, onCancel }) {
 }
 
 // src/components/SessionSelector.tsx
-import React15, { useState as useState5 } from "react";
+import React15, { useState as useState6 } from "react";
 import { Box as Box14, Text as Text14, useInput as useInput5 } from "ink";
 import SelectInput4 from "ink-select-input";
 function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
-  const [step, setStep] = useState5("selection");
-  const [selectedSession, setSelectedSession] = useState5(null);
+  const [step, setStep] = useState6("selection");
+  const [selectedSession, setSelectedSession] = useState6(null);
   useInput5((input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
@@ -1662,7 +1753,7 @@ function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
 }
 
 // src/components/LoginFlow.tsx
-import React16, { useState as useState6, useEffect as useEffect2 } from "react";
+import React16, { useState as useState7, useEffect as useEffect2 } from "react";
 import { Box as Box15, Text as Text15 } from "ink";
 import Spinner2 from "ink-spinner";
 import jwt from "jsonwebtoken";
@@ -1779,10 +1870,10 @@ var OAuthClient = class {
 
 // src/components/LoginFlow.tsx
 function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, onError }) {
-  const [status, setStatus] = useState6("initiating");
-  const [deviceFlow, setDeviceFlow] = useState6(null);
-  const [statusMessage, setStatusMessage] = useState6("Initiating device authorization...");
-  const [error, setError] = useState6(null);
+  const [status, setStatus] = useState7("initiating");
+  const [deviceFlow, setDeviceFlow] = useState7(null);
+  const [statusMessage, setStatusMessage] = useState7("Initiating device authorization...");
+  const [error, setError] = useState7(null);
   useEffect2(() => {
     const runLoginFlow = async () => {
       const oauth = new OAuthClient(apiUrl);
@@ -2672,6 +2763,261 @@ var CommandHistoryStore = class {
   }
 };
 
+// src/storage/CustomCommandStore.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+import os from "os";
+
+// src/utils/commandParser.ts
+import matter from "gray-matter";
+import { z as z2 } from "zod";
+var FrontmatterSchema = z2.object({
+  description: z2.string().optional(),
+  "argument-hint": z2.string().optional(),
+  model: z2.string().optional(),
+  // Future fields (ignored for now):
+  "allowed-tools": z2.any().optional(),
+  context: z2.any().optional(),
+  agent: z2.any().optional(),
+  "disable-model-invocation": z2.any().optional(),
+  hooks: z2.any().optional()
+});
+function extractDescriptionFromBody(body) {
+  const lines = body.trim().split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      return trimmed.length > 100 ? trimmed.substring(0, 97) + "..." : trimmed;
+    }
+  }
+  return "Custom command";
+}
+function parseCommandFile(fileContent, filePath, commandName, source) {
+  try {
+    const { data: frontmatter, content: body } = matter(fileContent);
+    const validationResult = FrontmatterSchema.safeParse(frontmatter);
+    if (!validationResult.success) {
+      console.warn(
+        `Warning: Invalid frontmatter in ${filePath}:`,
+        validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ")
+      );
+    }
+    const validFrontmatter = validationResult.success ? validationResult.data : {};
+    const description = validFrontmatter.description || extractDescriptionFromBody(body) || "Custom command";
+    return {
+      name: commandName,
+      description,
+      argumentHint: validFrontmatter["argument-hint"],
+      model: validFrontmatter.model,
+      body: body.trim(),
+      source,
+      filePath
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to parse command file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function isValidCommandName(name) {
+  if (!name || name.trim().length === 0) {
+    return false;
+  }
+  const validPattern = /^[a-z0-9-_:]+$/i;
+  return validPattern.test(name);
+}
+function extractCommandName(filename) {
+  if (!filename.endsWith(".md")) {
+    return null;
+  }
+  const name = filename.slice(0, -3);
+  if (!isValidCommandName(name)) {
+    return null;
+  }
+  return name;
+}
+
+// src/storage/CustomCommandStore.ts
+var CustomCommandStore = class {
+  constructor(projectRoot) {
+    this.commands = /* @__PURE__ */ new Map();
+    this.globalCommandsDir = path6.join(os.homedir(), ".bike4mind", "commands");
+    this.projectCommandsDir = path6.join(projectRoot || process.cwd(), ".bike4mind", "commands");
+  }
+  /**
+   * Loads all custom commands from both global and project directories
+   * Project commands override global commands with the same name
+   */
+  async loadCommands() {
+    this.commands.clear();
+    await this.loadCommandsFromDirectory(this.globalCommandsDir, "global");
+    await this.loadCommandsFromDirectory(this.projectCommandsDir, "project");
+  }
+  /**
+   * Recursively scans a directory for .md files and loads them as commands
+   *
+   * @param directory - Directory to scan
+   * @param source - Source identifier ('global' or 'project')
+   */
+  async loadCommandsFromDirectory(directory, source) {
+    try {
+      const stats = await fs6.stat(directory);
+      if (!stats.isDirectory()) {
+        return;
+      }
+      const commandFiles = await this.findCommandFiles(directory);
+      for (const filePath of commandFiles) {
+        try {
+          await this.loadCommandFile(filePath, source);
+        } catch (error) {
+          console.warn(
+            `Failed to load command from ${filePath}:`,
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        console.warn(
+          `Error accessing ${source} commands directory ${directory}:`,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+  }
+  /**
+   * Recursively finds all .md files in a directory
+   *
+   * @param directory - Directory to search
+   * @returns Array of full file paths to .md files
+   */
+  async findCommandFiles(directory) {
+    const files = [];
+    try {
+      const entries = await fs6.readdir(directory, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path6.join(directory, entry.name);
+        if (entry.isDirectory()) {
+          const subFiles = await this.findCommandFiles(fullPath);
+          files.push(...subFiles);
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      console.warn(`Error reading directory ${directory}:`, error instanceof Error ? error.message : String(error));
+    }
+    return files;
+  }
+  /**
+   * Loads a single command file
+   *
+   * @param filePath - Full path to the command file
+   * @param source - Source identifier ('global' or 'project')
+   */
+  async loadCommandFile(filePath, source) {
+    const filename = path6.basename(filePath);
+    const commandName = extractCommandName(filename);
+    if (!commandName) {
+      console.warn(`Invalid command filename: ${filename} (must end with .md and have valid name)`);
+      return;
+    }
+    const fileContent = await fs6.readFile(filePath, "utf-8");
+    const command = parseCommandFile(fileContent, filePath, commandName, source);
+    const existing = this.commands.get(commandName);
+    if (existing && existing.source === "project" && source === "global") {
+      return;
+    }
+    this.commands.set(commandName, command);
+  }
+  /**
+   * Gets a command by name
+   *
+   * @param name - Command name
+   * @returns CustomCommand if found, undefined otherwise
+   */
+  getCommand(name) {
+    return this.commands.get(name);
+  }
+  /**
+   * Gets all loaded commands
+   *
+   * @returns Array of all custom commands
+   */
+  getAllCommands() {
+    return Array.from(this.commands.values());
+  }
+  /**
+   * Gets commands filtered by source
+   *
+   * @param source - Filter by 'global' or 'project'
+   * @returns Array of commands from the specified source
+   */
+  getCommandsBySource(source) {
+    return this.getAllCommands().filter((cmd) => cmd.source === source);
+  }
+  /**
+   * Checks if a command name exists
+   *
+   * @param name - Command name to check
+   * @returns true if command exists
+   */
+  hasCommand(name) {
+    return this.commands.has(name);
+  }
+  /**
+   * Gets the number of loaded commands
+   *
+   * @returns Number of custom commands
+   */
+  getCommandCount() {
+    return this.commands.size;
+  }
+  /**
+   * Reloads all commands from directories
+   * Useful for the /commands:reload command
+   */
+  async reloadCommands() {
+    await this.loadCommands();
+  }
+  /**
+   * Creates a new command file from a template
+   *
+   * @param name - Command name
+   * @param isGlobal - If true, creates in global directory, otherwise project directory
+   * @returns Path to the created file
+   */
+  async createCommandFile(name, isGlobal = false) {
+    const targetDir = isGlobal ? this.globalCommandsDir : this.projectCommandsDir;
+    const filePath = path6.join(targetDir, `${name}.md`);
+    try {
+      await fs6.access(filePath);
+      throw new Error(`Command file already exists: ${filePath}`);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    await fs6.mkdir(targetDir, { recursive: true });
+    const template = `---
+description: ${name} command
+argument-hint: [args]
+---
+
+# ${name}
+
+Replace this with your command template.
+
+You can use:
+- $ARGUMENTS for all arguments
+- $1, $2, etc. for positional arguments
+- @filename for file references
+`;
+    await fs6.writeFile(filePath, template, "utf-8");
+    return filePath;
+  }
+};
+
 // ../../b4m-core/packages/agents/src/ReActAgent.ts
 import { EventEmitter } from "events";
 var ReActAgent = class extends EventEmitter {
@@ -2985,38 +3331,38 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
 // ../../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()
 });
 
@@ -3026,78 +3372,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 }),
@@ -3105,57 +3451,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,
@@ -3169,82 +3515,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
@@ -3391,29 +3737,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
@@ -3429,47 +3775,47 @@ import { GoogleGenerativeAI } from "@google/generative-ai";
 import OpenAI2 from "openai";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
-import fs6, { unlinkSync } from "fs";
+import fs7, { unlinkSync } from "fs";
 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
@@ -3477,38 +3823,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
@@ -3519,357 +3865,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"
@@ -3877,355 +4223,355 @@ 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()
+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()
 });
 
 // ../../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(),
-  mimeType: z86.string(),
-  fileContent: z86.string().optional(),
-  type: z86.nativeEnum(KnowledgeType),
-  system: z86.boolean().optional(),
-  systemPriority: z86.number().min(0).max(999).optional(),
-  sessionId: z86.string().optional(),
-  notes: z86.string().optional(),
-  primaryTag: z86.string().optional(),
-  tags: z86.array(z86.object({
-    name: z86.string(),
-    strength: z86.number()
+import { z as z87 } from "zod";
+var updateFabFileSchema = z87.object({
+  id: z87.string(),
+  fileName: z87.string(),
+  mimeType: z87.string(),
+  fileContent: z87.string().optional(),
+  type: z87.nativeEnum(KnowledgeType),
+  system: z87.boolean().optional(),
+  systemPriority: z87.number().min(0).max(999).optional(),
+  sessionId: z87.string().optional(),
+  notes: z87.string().optional(),
+  primaryTag: z87.string().optional(),
+  tags: z87.array(z87.object({
+    name: z87.string(),
+    strength: z87.number()
   })).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";
@@ -4616,316 +4962,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(1e3),
-  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(1e3).optional(),
-  goal: z133.string().min(1).max(1e3),
-  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(50)).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(1e3),
+  status: z134.enum(["not_started", "in_progress", "completed", "blocked"]).default("not_started"),
+  order: z134.number().min(0),
+  dependencies: z134.array(z134.string()).default([]),
+  estimatedTime: z134.string().optional()
+});
+var questResourceSchema = z134.object({
+  title: z134.string().min(1).max(255),
+  url: z134.string().url(),
+  type: z134.enum(["documentation", "tutorial", "reference", "example"])
+});
+var createQuestMasterSchema = z134.object({
+  title: z134.string().min(1).max(255),
+  description: z134.string().max(1e3).optional(),
+  goal: z134.string().min(1).max(1e3),
+  complexity: z134.enum(["beginner", "intermediate", "advanced", "expert"]),
+  estimatedTotalTime: z134.string().optional(),
+  prerequisites: z134.array(z134.string().max(200)).default([]),
+  quests: z134.array(questSchema).min(1),
+  resources: z134.array(questResourceSchema).default([]),
+  projectId: z134.string().optional(),
+  organizationId: z134.string().optional(),
+  visibility: z134.enum(["private", "project", "organization", "public"]).default("private"),
+  tags: z134.array(z134.string().max(50)).max(20).default([]),
+  permissions: z134.object({
+    canRead: z134.array(z134.string()).default([]),
+    canWrite: z134.array(z134.string()).default([]),
+    canDelete: z134.array(z134.string()).default([]),
+    isPublic: z134.boolean().default(false),
+    inheritFromProject: z134.boolean().default(true)
   }).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
@@ -4945,63 +5291,63 @@ 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/ChatCompletion.js
-import { z as z138 } from "zod";
+import { z as z139 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionInvoke.js
 import { fromZodError } from "zod-validation-error";
@@ -5115,8 +5461,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path15 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path15;
+    const path16 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path16;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -6089,17 +6435,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);
@@ -6328,8 +6674,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path15 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path15;
+  const path16 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path16;
 }
 async function updateQuestAndReturnMarkdown2(storedImagePath, context) {
   await context.onFinish?.("edit_image", storedImagePath);
@@ -7858,8 +8204,8 @@ var getHeliocentricCoords = (planet, T) => {
   const sinNode = Math.sin(longNode);
   const x = r * (cosNode * cosOmega - sinNode * sinOmega * cosI);
   const y = r * (sinNode * cosOmega + cosNode * sinOmega * cosI);
-  const z144 = r * sinOmega * sinI;
-  return { x, y, z: z144, r };
+  const z145 = r * sinOmega * sinI;
+  return { x, y, z: z145, r };
 };
 var getGeocentricEcliptic = (planet, earth) => {
   const dx = planet.x - earth.x;
@@ -8166,15 +8512,15 @@ var planetVisibilityTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
-import { promises as fs7 } from "fs";
+import { promises as fs8 } from "fs";
 import { existsSync as existsSync4, statSync as statSync4 } from "fs";
-import path6 from "path";
+import path7 from "path";
 var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 async function readFileContent(params) {
   const { path: filePath, encoding = "utf-8", maxLines } = params;
-  const normalizedPath = path6.normalize(filePath);
-  const resolvedPath = path6.resolve(process.cwd(), normalizedPath);
-  const cwd = path6.resolve(process.cwd());
+  const normalizedPath = path7.normalize(filePath);
+  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
+  const cwd = path7.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
@@ -8192,7 +8538,7 @@ async function readFileContent(params) {
   if (isBinary && encoding === "utf-8") {
     throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
   }
-  const content = await fs7.readFile(resolvedPath, encoding);
+  const content = await fs8.readFile(resolvedPath, encoding);
   if (maxLines && typeof content === "string") {
     const lines = content.split("\n");
     if (lines.length > maxLines) {
@@ -8207,7 +8553,7 @@ ${content}`;
 }
 async function checkIfBinary(filePath) {
   const buffer = Buffer.alloc(8192);
-  const fd = await fs7.open(filePath, "r");
+  const fd = await fs8.open(filePath, "r");
   try {
     const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
     const chunk = buffer.slice(0, bytesRead);
@@ -8224,7 +8570,7 @@ var fileReadTool = {
       context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
       try {
         const content = await readFileContent(params);
-        const stats = statSync4(path6.resolve(process.cwd(), path6.normalize(params.path)));
+        const stats = statSync4(path7.resolve(process.cwd(), path7.normalize(params.path)));
         context.logger.info("\u2705 FileRead: Success", {
           path: params.path,
           size: stats.size,
@@ -8233,7 +8579,8 @@ var fileReadTool = {
         return content;
       } catch (error) {
         context.logger.error("\u274C FileRead: Failed", error);
-        throw error;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return `Error reading file: ${errorMessage}`;
       }
     },
     toolSchema: {
@@ -8263,25 +8610,25 @@ var fileReadTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
-import { promises as fs8 } from "fs";
+import { promises as fs9 } from "fs";
 import { existsSync as existsSync5 } from "fs";
-import path7 from "path";
+import path8 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
-  const normalizedPath = path7.normalize(filePath);
-  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
-  const cwd = path7.resolve(process.cwd());
+  const normalizedPath = path8.normalize(filePath);
+  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
+  const cwd = path8.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
   const fileExists = existsSync5(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
-    const dir = path7.dirname(resolvedPath);
-    await fs8.mkdir(dir, { recursive: true });
+    const dir = path8.dirname(resolvedPath);
+    await fs9.mkdir(dir, { recursive: true });
   }
-  await fs8.writeFile(resolvedPath, content, "utf-8");
-  const stats = await fs8.stat(resolvedPath);
+  await fs9.writeFile(resolvedPath, content, "utf-8");
+  const stats = await fs9.stat(resolvedPath);
   const lines = content.split("\n").length;
   return `File ${action} successfully: ${filePath}
 Size: ${stats.size} bytes
@@ -8292,7 +8639,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync5(path7.resolve(process.cwd(), path7.normalize(params.path)));
+      const fileExists = existsSync5(path8.resolve(process.cwd(), path8.normalize(params.path)));
       context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
         path: params.path,
         size: params.content.length
@@ -8334,7 +8681,7 @@ var createFileTool = {
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
 import { readdir } from "fs/promises";
 import { statSync as statSync5 } from "fs";
-import path8 from "path";
+import path9 from "path";
 function matchGlob(filePath, pattern) {
   let regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
   regexPattern = regexPattern.replace(/\{\{GLOBSTAR\}\}\//g, "(.*/)?").replace(/\/\{\{GLOBSTAR\}\}/g, "(/.*)?").replace(/\{\{GLOBSTAR\}\}/g, ".*");
@@ -8352,8 +8699,8 @@ async function walkDir(dir, pattern, includeHidden, maxResults, basePath = "") {
       if (!includeHidden && entry.name.startsWith(".")) {
         continue;
       }
-      const relativePath = basePath ? path8.join(basePath, entry.name) : entry.name;
-      const fullPath = path8.join(dir, entry.name);
+      const relativePath = basePath ? path9.join(basePath, entry.name) : entry.name;
+      const fullPath = path9.join(dir, entry.name);
       if (matchGlob(relativePath, pattern)) {
         matches.push(relativePath);
       }
@@ -8369,7 +8716,7 @@ async function walkDir(dir, pattern, includeHidden, maxResults, basePath = "") {
 async function listFiles(params) {
   const { pattern, cwd: relativeCwd, includeHidden = false, maxResults = 1e3 } = params;
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path8.resolve(baseCwd, path8.normalize(relativeCwd)) : baseCwd;
+  const targetCwd = relativeCwd ? path9.resolve(baseCwd, path9.normalize(relativeCwd)) : baseCwd;
   if (!targetCwd.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot list files outside of current working directory`);
   }
@@ -8380,7 +8727,7 @@ async function listFiles(params) {
   const filesInfo = [];
   for (const match of matches) {
     try {
-      const fullPath = path8.join(targetCwd, match);
+      const fullPath = path9.join(targetCwd, match);
       const stats = statSync5(fullPath);
       filesInfo.push({
         path: match,
@@ -8463,7 +8810,7 @@ var globFilesTool = {
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
 import { readdir as readdir2 } from "fs/promises";
 import { readFileSync as readFileSync3, statSync as statSync6 } from "fs";
-import path9 from "path";
+import path10 from "path";
 var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
 function matchGlob2(filePath, pattern) {
   const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
@@ -8481,8 +8828,8 @@ async function walkDir2(dir, pattern, maxResults, basePath = "") {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const relativePath = basePath ? path9.join(basePath, entry.name) : entry.name;
-      const fullPath = path9.join(dir, entry.name);
+      const relativePath = basePath ? path10.join(basePath, entry.name) : entry.name;
+      const fullPath = path10.join(dir, entry.name);
       if (matchGlob2(relativePath, pattern)) {
         matches.push(relativePath);
       }
@@ -8498,7 +8845,7 @@ async function walkDir2(dir, pattern, maxResults, basePath = "") {
 async function searchFiles2(params) {
   const { pattern, filePattern = "**/*", cwd: relativeCwd, caseSensitive = false, maxResults = 100, contextLines = 0 } = params;
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path9.resolve(baseCwd, path9.normalize(relativeCwd)) : baseCwd;
+  const targetCwd = relativeCwd ? path10.resolve(baseCwd, path10.normalize(relativeCwd)) : baseCwd;
   if (!targetCwd.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot search files outside of current working directory`);
   }
@@ -8512,7 +8859,7 @@ async function searchFiles2(params) {
   const filesToSearch = await walkDir2(targetCwd, filePattern, 1e4);
   const filteredFiles = [];
   for (const match of filesToSearch) {
-    const fullPath = path9.join(targetCwd, match);
+    const fullPath = path10.join(targetCwd, match);
     try {
       const stats = statSync6(fullPath);
       if (stats.isDirectory() || stats.size > MAX_FILE_SIZE3) {
@@ -8536,7 +8883,7 @@ async function searchFiles2(params) {
       break;
     }
     filesSearched++;
-    const fullPath = path9.join(targetCwd, file);
+    const fullPath = path10.join(targetCwd, file);
     try {
       const content = readFileSync3(fullPath, "utf-8");
       const lines = content.split("\n");
@@ -8671,14 +9018,14 @@ var grepSearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
-import { promises as fs9 } from "fs";
+import { promises as fs10 } from "fs";
 import { existsSync as existsSync6, statSync as statSync7 } from "fs";
-import path10 from "path";
+import path11 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
-  const normalizedPath = path10.normalize(filePath);
-  const resolvedPath = path10.resolve(process.cwd(), normalizedPath);
-  const cwd = path10.resolve(process.cwd());
+  const normalizedPath = path11.normalize(filePath);
+  const resolvedPath = path11.resolve(process.cwd(), normalizedPath);
+  const cwd = path11.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
@@ -8692,10 +9039,10 @@ async function deleteFile(params) {
     throw new Error(`Path is a directory: ${filePath}. Use recursive=true to delete directories and their contents.`);
   }
   if (isDirectory) {
-    await fs9.rm(resolvedPath, { recursive: true, force: true });
+    await fs10.rm(resolvedPath, { recursive: true, force: true });
     return `Directory deleted successfully: ${filePath}`;
   } else {
-    await fs9.unlink(resolvedPath);
+    await fs10.unlink(resolvedPath);
     return `File deleted successfully: ${filePath}
 Size: ${size} bytes`;
   }
@@ -8705,7 +9052,7 @@ var deleteFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const resolvedPath = path10.resolve(process.cwd(), path10.normalize(params.path));
+      const resolvedPath = path11.resolve(process.cwd(), path11.normalize(params.path));
       const isDirectory = existsSync6(resolvedPath) && statSync7(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
@@ -8743,7 +9090,7 @@ var deleteFileTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
 import { spawn } from "child_process";
-import path11 from "path";
+import path12 from "path";
 var DEFAULT_TIMEOUT_MS = 6e4;
 var MAX_OUTPUT_SIZE = 100 * 1024;
 var DANGEROUS_PATTERNS = [
@@ -8927,7 +9274,7 @@ async function executeBashCommand(params) {
     };
   }
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path11.resolve(baseCwd, relativeCwd) : baseCwd;
+  const targetCwd = relativeCwd ? path12.resolve(baseCwd, relativeCwd) : baseCwd;
   const effectiveTimeout = Math.min(timeout, 5 * 60 * 1e3);
   return new Promise((resolve3) => {
     let stdout = "";
@@ -9261,42 +9608,42 @@ var DISABLE_SERVER_THROTTLING = process.env.DISABLE_SERVER_THROTTLING === "true"
 var questSaveMutex = new Mutex();
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletion.js
-var QuestStartBodySchema = 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()
 });
 
@@ -9304,30 +9651,9 @@ var QuestStartBodySchema = z138.object({
 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(),
-  safety_tolerance: z139.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z139.boolean().optional().default(false),
-  seed: z139.number().nullable().optional(),
-  output_format: z139.enum(["jpeg", "png"]).nullable().optional().default("png"),
-  width: z139.number().optional(),
-  height: z139.number().optional(),
-  aspect_ratio: z139.string().optional(),
-  fabFileIds: z139.array(z139.string()).optional()
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
-import axios9 from "axios";
-import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
-import { v4 as uuidv48 } from "uuid";
-import { z as z140 } from "zod";
-import { fromZodError as fromZodError3 } from "zod-validation-error";
-var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
   sessionId: z140.string(),
   questId: z140.string(),
   userId: z140.string(),
@@ -9335,35 +9661,56 @@ var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
   safety_tolerance: z140.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
   prompt_upsampling: z140.boolean().optional().default(false),
   seed: z140.number().nullable().optional(),
-  output_format: z140.enum(["jpeg", "png"]).optional().default("png"),
+  output_format: z140.enum(["jpeg", "png"]).nullable().optional().default("png"),
   width: z140.number().optional(),
   height: z140.number().optional(),
   aspect_ratio: z140.string().optional(),
-  size: z140.string().optional(),
-  fabFileIds: z140.array(z140.string()).optional(),
-  image: z140.string()
+  fabFileIds: z140.array(z140.string()).optional()
 });
 
-// ../../b4m-core/packages/services/dist/src/llm/refineText.js
+// ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
+import axios9 from "axios";
+import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
+import { v4 as uuidv48 } from "uuid";
 import { z as z141 } from "zod";
-var refineTextLLMSchema = z141.object({
-  text: z141.string(),
-  context: z141.string().optional()
+import { fromZodError as fromZodError3 } from "zod-validation-error";
+var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
+  sessionId: z141.string(),
+  questId: z141.string(),
+  userId: z141.string(),
+  prompt: z141.string(),
+  safety_tolerance: z141.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z141.boolean().optional().default(false),
+  seed: z141.number().nullable().optional(),
+  output_format: z141.enum(["jpeg", "png"]).optional().default("png"),
+  width: z141.number().optional(),
+  height: z141.number().optional(),
+  aspect_ratio: z141.string().optional(),
+  size: z141.string().optional(),
+  fabFileIds: z141.array(z141.string()).optional(),
+  image: z141.string()
+});
+
+// ../../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()
   // 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 z142 } from "zod";
-var SingleMementoEvalSchema = z142.object({
-  importance: z142.number().min(1).max(10),
+import { z as z143 } from "zod";
+var SingleMementoEvalSchema = z143.object({
+  importance: z143.number().min(1).max(10),
   // 1-10 scale for personal info importance
-  summary: z142.string(),
-  tags: z142.array(z142.string()).optional()
+  summary: z143.string(),
+  tags: z143.array(z143.string()).optional()
 });
-var MementoEvalResponseSchema = z142.object({
-  isPersonal: z142.boolean(),
-  mementos: z142.array(SingleMementoEvalSchema).optional()
+var MementoEvalResponseSchema = z143.object({
+  isPersonal: z143.boolean(),
+  mementos: z143.array(SingleMementoEvalSchema).optional()
   // Array of distinct personal information
 });
 
@@ -9420,7 +9767,7 @@ async function generateFileDeletePreview(args) {
     if (!existsSync7(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs12) => fs12.stat(args.path));
+    const stats = await import("fs/promises").then((fs13) => fs13.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -9432,9 +9779,9 @@ Last modified: ${stats.mtime.toLocaleString()}`;
 }
 
 // src/utils/Logger.ts
-import fs10 from "fs/promises";
-import path12 from "path";
-import os from "os";
+import fs11 from "fs/promises";
+import path13 from "path";
+import os2 from "os";
 var Logger2 = class _Logger {
   constructor() {
     this.logFilePath = null;
@@ -9456,9 +9803,9 @@ var Logger2 = class _Logger {
    */
   async initialize(sessionId) {
     this.sessionId = sessionId;
-    const debugDir = path12.join(os.homedir(), ".bike4mind", "debug");
-    await fs10.mkdir(debugDir, { recursive: true });
-    this.logFilePath = path12.join(debugDir, `${sessionId}.txt`);
+    const debugDir = path13.join(os2.homedir(), ".bike4mind", "debug");
+    await fs11.mkdir(debugDir, { recursive: true });
+    this.logFilePath = path13.join(debugDir, `${sessionId}.txt`);
     await this.writeToFile("INFO", "=== CLI SESSION START ===");
   }
   /**
@@ -9522,7 +9869,7 @@ var Logger2 = class _Logger {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
       const logEntry = `[${timestamp}] [${level}] ${message}
 `;
-      await fs10.appendFile(this.logFilePath, logEntry, "utf-8");
+      await fs11.appendFile(this.logFilePath, logEntry, "utf-8");
     } catch (error) {
       console.error("File logging failed:", error);
     }
@@ -9668,15 +10015,15 @@ var Logger2 = class _Logger {
   async cleanupOldLogs() {
     if (!this.fileLoggingEnabled) return;
     try {
-      const debugDir = path12.join(os.homedir(), ".bike4mind", "debug");
-      const files = await fs10.readdir(debugDir);
+      const debugDir = path13.join(os2.homedir(), ".bike4mind", "debug");
+      const files = await fs11.readdir(debugDir);
       const now = Date.now();
       const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
       for (const file of files) {
-        const filePath = path12.join(debugDir, file);
-        const stats = await fs10.stat(filePath);
+        const filePath = path13.join(debugDir, file);
+        const stats = await fs11.stat(filePath);
         if (stats.mtime.getTime() < thirtyDaysAgo) {
-          await fs10.unlink(filePath);
+          await fs11.unlink(filePath);
         }
       }
     } catch (error) {
@@ -9770,21 +10117,21 @@ var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path15) {
+  async download(path16) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path15) {
+  async delete(path16) {
   }
-  async getSignedUrl(path15) {
-    return `/tmp/${path15}`;
+  async getSignedUrl(path16) {
+    return `/tmp/${path16}`;
   }
-  getPublicUrl(path15) {
-    return `/tmp/${path15}`;
+  getPublicUrl(path16) {
+    return `/tmp/${path16}`;
   }
-  async getPreview(path15) {
-    return `/tmp/${path15}`;
+  async getPreview(path16) {
+    return `/tmp/${path16}`;
   }
-  async getMetadata(path15) {
+  async getMetadata(path16) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -9878,7 +10225,31 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
     }
   };
 }
-function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient) {
+var TOOL_NAME_MAPPING = {
+  // Claude Code -> B4M
+  read: "file_read",
+  write: "create_file",
+  edit: "edit_file",
+  delete: "delete_file",
+  glob: "glob_files",
+  grep: "grep_search",
+  bash: "bash_execute",
+  // B4M -> Claude Code (reverse mapping)
+  file_read: "read",
+  create_file: "write",
+  edit_file: "edit",
+  delete_file: "delete",
+  glob_files: "glob",
+  grep_search: "grep",
+  bash_execute: "bash"
+};
+function normalizeToolName(toolName) {
+  if (toolName.includes("_")) {
+    return toolName;
+  }
+  return TOOL_NAME_MAPPING[toolName] || toolName;
+}
+function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient, toolFilter) {
   const logger2 = new CliLogger();
   const storage = new NoOpStorage();
   const user = {
@@ -9948,15 +10319,30 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     toolConfig,
     model
   );
-  const tools2 = Object.entries(toolsMap).filter(([key]) => toolConfig[key] !== void 0).map(
+  let tools2 = Object.entries(toolsMap).filter(([key]) => toolConfig[key] !== void 0).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) => {
+      const toolName = tool.toolSchema.name;
+      if (normalizedDenied && normalizedDenied.includes(toolName)) {
+        return false;
+      }
+      if (normalizedAllowed && normalizedAllowed.length > 0) {
+        return normalizedAllowed.includes(toolName);
+      }
+      return true;
+    });
+  }
   return { tools: tools2, agentContext };
 }
 
 // src/config/toolSafety.ts
-import { z as z143 } from "zod";
-var ToolCategorySchema = z143.enum([
+import { z as z144 } from "zod";
+var ToolCategorySchema = z144.enum([
   "auto_approve",
   // Safe tools that run automatically without permission
   "prompt_always",
@@ -9964,9 +10350,9 @@ var ToolCategorySchema = z143.enum([
   "prompt_default"
   // Tools that prompt by default but can be trusted
 ]);
-var ToolSafetyConfigSchema = z143.object({
-  categories: z143.record(z143.string(), ToolCategorySchema),
-  trustedTools: z143.array(z143.string())
+var ToolSafetyConfigSchema = z144.object({
+  categories: z144.record(z144.string(), ToolCategorySchema),
+  trustedTools: z144.array(z144.string())
 });
 var DEFAULT_TOOL_CATEGORIES = {
   // ===== AUTO APPROVE (Safe tools) =====
@@ -10146,8 +10532,8 @@ function getEnvironmentName(configApiConfig) {
 }
 
 // src/utils/contextLoader.ts
-import * as fs11 from "fs";
-import * as path13 from "path";
+import * as fs12 from "fs";
+import * as path14 from "path";
 import { homedir as homedir4 } from "os";
 var CONTEXT_FILE_SIZE_LIMIT = 100 * 1024;
 var PROJECT_CONTEXT_FILES = [
@@ -10168,9 +10554,9 @@ function formatFileSize2(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 function tryReadContextFile(dir, filename, source) {
-  const filePath = path13.join(dir, filename);
+  const filePath = path14.join(dir, filename);
   try {
-    const stats = fs11.lstatSync(filePath);
+    const stats = fs12.lstatSync(filePath);
     if (stats.isDirectory()) {
       return null;
     }
@@ -10184,7 +10570,7 @@ function tryReadContextFile(dir, filename, source) {
         error: `${source === "global" ? "Global" : "Project"} ${filename} exceeds 100KB limit (${formatFileSize2(stats.size)})`
       };
     }
-    const content = fs11.readFileSync(filePath, "utf-8");
+    const content = fs12.readFileSync(filePath, "utf-8");
     return {
       filename,
       content,
@@ -10236,7 +10622,7 @@ ${project.content}`;
 }
 async function loadContextFiles(projectDir) {
   const errors = [];
-  const globalDir = path13.join(homedir4(), ".bike4mind");
+  const globalDir = path14.join(homedir4(), ".bike4mind");
   const projectDirectory = projectDir || process.cwd();
   const [globalResult, projectResult] = await Promise.all([
     Promise.resolve(findContextFile(globalDir, GLOBAL_CONTEXT_FILES, "global")),
@@ -10257,10 +10643,22 @@ async function loadContextFiles(projectDir) {
   };
 }
 
+// src/utils/argumentSubstitution.ts
+function substituteArguments(template, args) {
+  let result = template;
+  for (let i = args.length; i >= 1; i--) {
+    const pattern = new RegExp(`\\$${i}`, "g");
+    result = result.replace(pattern, args[i - 1] || "");
+  }
+  const allArgsString = args.join(" ");
+  result = result.replace(/\$ARGUMENTS/g, allArgsString);
+  return result;
+}
+
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path14 from "path";
+import path15 from "path";
 import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
@@ -10301,16 +10699,16 @@ var MCPClient = class {
         const root = process.env.INIT_CWD || process.cwd();
         const candidatePaths = [
           // When running from SST Lambda with node_modules structure (copyFiles)
-          path14.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda deployed environment (/var/task)
-          path14.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda (.sst/artifacts/mcpHandler-dev), navigate to monorepo root (3 levels up)
-          path14.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from packages/client (Next.js app), navigate to monorepo root (2 levels up)
-          path14.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // Original paths (backward compatibility)
-          path14.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-          path14.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+          path15.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
         ];
         const serverScriptPath = candidatePaths.find((p) => existsSync8(p));
         if (!serverScriptPath) {
@@ -11114,7 +11512,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.10-fix-b4m-cli-flicker.17235+479bb7772",
+  version: "0.2.10-fix-cli-duplicate-chat-history.17269+1be89f2b4",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -11184,6 +11582,7 @@ var package_default = {
     "eventsource-parser": "^3.0.6",
     "file-type": "^18.7.0",
     "fuse.js": "^7.1.0",
+    "gray-matter": "^4.0.3",
     ink: "^6.5.1",
     "ink-select-input": "^6.2.0",
     "ink-spinner": "^5.0.0",
@@ -11217,10 +11616,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.39.1-fix-b4m-cli-flicker.17235+479bb7772",
-    "@bike4mind/mcp": "1.20.4-fix-b4m-cli-flicker.17235+479bb7772",
-    "@bike4mind/services": "2.34.2-fix-b4m-cli-flicker.17235+479bb7772",
-    "@bike4mind/utils": "2.1.4-fix-b4m-cli-flicker.17235+479bb7772",
+    "@bike4mind/common": "2.39.1-fix-cli-duplicate-chat-history.17269+1be89f2b4",
+    "@bike4mind/mcp": "1.20.4-fix-cli-duplicate-chat-history.17269+1be89f2b4",
+    "@bike4mind/services": "2.34.2-fix-cli-duplicate-chat-history.17269+1be89f2b4",
+    "@bike4mind/utils": "2.1.4-fix-cli-duplicate-chat-history.17269+1be89f2b4",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -11233,7 +11632,7 @@ var package_default = {
     typescript: "^5.9.3",
     vitest: "^3.2.4"
   },
-  gitHead: "479bb77726d7e49cda72367ba8fd3c84e346474d"
+  gitHead: "1be89f2b4af11a0ce89c8d4822dda698ded0f703"
 };
 
 // src/config/constants.ts
@@ -11241,6 +11640,331 @@ var USAGE_DAYS = 30;
 var MODEL_NAME_COLUMN_WIDTH = 18;
 var USAGE_CACHE_TTL = 5 * 60 * 1e3;
 
+// src/agents/SubagentOrchestrator.ts
+var SubagentOrchestrator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Delegate a task to a specialized subagent
+   *
+   * @param options - Configuration for subagent execution
+   * @returns Subagent result with summary
+   */
+  async delegateToSubagent(options) {
+    const { task, type, thoroughness, parentSessionId, config: configOverride } = options;
+    const baseConfig = this.deps.subagentConfigs.get(type);
+    if (!baseConfig) {
+      throw new Error(`No configuration found for subagent type: ${type}`);
+    }
+    const config = {
+      ...baseConfig,
+      ...configOverride,
+      type
+    };
+    const model = config.model || "claude-3-5-haiku-20241022";
+    const maxIterations = this.getMaxIterations(config, thoroughness);
+    const toolFilter = {
+      allowedTools: config.allowedTools,
+      deniedTools: config.deniedTools
+    };
+    const agentContext = {
+      currentAgent: null,
+      observationQueue: []
+    };
+    const { tools: tools2, agentContext: updatedContext } = generateCliTools(
+      this.deps.userId,
+      this.deps.llm,
+      model,
+      this.deps.permissionManager,
+      this.deps.showPermissionPrompt,
+      agentContext,
+      this.deps.configStore,
+      this.deps.apiClient,
+      toolFilter
+    );
+    this.deps.logger.debug(`Spawning ${type} subagent with ${tools2.length} tools, thoroughness: ${thoroughness}`);
+    const subagent = new ReActAgent({
+      userId: this.deps.userId,
+      logger: this.deps.logger,
+      llm: this.deps.llm,
+      model,
+      tools: tools2,
+      maxIterations,
+      systemPrompt: config.systemPrompt || this.getDefaultSystemPrompt(type)
+    });
+    updatedContext.currentAgent = subagent;
+    const startTime = Date.now();
+    const result = await subagent.run(task, {
+      maxIterations
+    });
+    const duration = Date.now() - startTime;
+    this.deps.logger.debug(
+      `Subagent completed in ${duration}ms, ${result.completionInfo.iterations} iterations, ${result.completionInfo.totalTokens} tokens`
+    );
+    const summary = this.summarizeResult(result, type);
+    const subagentResult = {
+      ...result,
+      subagentType: type,
+      thoroughness,
+      summary,
+      parentSessionId
+    };
+    return subagentResult;
+  }
+  /**
+   * Get max iterations based on thoroughness and config
+   */
+  getMaxIterations(config, thoroughness) {
+    const defaults = {
+      quick: 2,
+      medium: 5,
+      very_thorough: 10
+    };
+    const configIterations = config.maxIterations || defaults;
+    return configIterations[thoroughness];
+  }
+  /**
+   * Get default system prompt for subagent type
+   */
+  getDefaultSystemPrompt(type) {
+    switch (type) {
+      case "explore":
+        return `You are a code exploration specialist. Your job is to search and analyze codebases efficiently.
+
+Focus on:
+- Finding relevant files and functions
+- Understanding code structure and patterns
+- Providing clear, concise summaries
+
+You have read-only access. Use file_read, grep_search, and glob_files to explore.
+
+When you find what you're looking for, provide a clear summary including:
+1. What you found (files, functions, patterns)
+2. Key insights or observations
+3. Relevant code locations
+
+Be thorough but concise. Your summary will be used by the main agent.`;
+      case "plan":
+        return `You are a task planning specialist. Your job is to break down complex tasks into clear, actionable steps.
+
+Focus on:
+- Identifying dependencies and blockers
+- Creating logical sequence of steps
+- Estimating scope and priorities
+
+Provide a structured plan that the main agent can execute.`;
+      case "review":
+        return `You are a code review specialist. Your job is to analyze code quality and identify issues.
+
+Focus on:
+- Code quality and best practices
+- Potential bugs and edge cases
+- Performance and security considerations
+
+Provide actionable feedback with specific file and line references.`;
+      default:
+        return "You are a helpful AI assistant.";
+    }
+  }
+  /**
+   * Summarize subagent result for parent agent
+   */
+  summarizeResult(result, type) {
+    const { finalAnswer, steps, completionInfo } = result;
+    const toolCalls = steps.filter((s) => s.type === "action");
+    const filesRead = toolCalls.filter((s) => s.metadata?.toolName === "file_read").length;
+    const searches = toolCalls.filter((s) => s.metadata?.toolName === "grep_search").length;
+    const globs = toolCalls.filter((s) => s.metadata?.toolName === "glob_files").length;
+    let summary = `**${type.charAt(0).toUpperCase() + type.slice(1)} Subagent Results**
+
+`;
+    summary += `*Execution: ${completionInfo.iterations} iterations, ${completionInfo.toolCalls} tool calls*
+
+`;
+    if (type === "explore") {
+      summary += `*Exploration: ${filesRead} files read, ${searches} searches, ${globs} glob patterns*
+
+`;
+    }
+    const maxLength = 1e3;
+    if (finalAnswer.length > maxLength) {
+      summary += finalAnswer.slice(0, maxLength) + "\n\n...(truncated)";
+    } else {
+      summary += finalAnswer;
+    }
+    return summary;
+  }
+};
+
+// src/agents/configs.ts
+var EXPLORE_CONFIG = {
+  type: "explore",
+  model: "claude-3-5-haiku-20241022",
+  systemPrompt: `You are a code exploration specialist. Your job is to search and analyze codebases efficiently.
+
+Focus on:
+- Finding relevant files and functions
+- Understanding code structure and patterns
+- Providing clear, concise summaries
+
+You have read-only access. Use file_read, grep_search, and glob_files to explore.
+
+When you find what you're looking for, provide a clear summary including:
+1. What you found (files, functions, patterns)
+2. Key insights or observations
+3. Relevant code locations
+
+Be thorough but concise. Your summary will be used by the main agent.`,
+  allowedTools: [
+    "file_read",
+    "grep_search",
+    "glob_files",
+    "bash_execute",
+    // Only for read-only commands like ls, cat, find
+    "current_datetime",
+    "math_evaluate"
+  ],
+  deniedTools: [
+    "create_file",
+    "edit_file",
+    "delete_file",
+    "web_search",
+    "weather_info",
+    "blog_publish",
+    "blog_edit",
+    "blog_draft"
+  ],
+  maxIterations: {
+    quick: 2,
+    medium: 5,
+    very_thorough: 10
+  },
+  defaultThoroughness: "medium"
+};
+var PLAN_CONFIG = {
+  type: "plan",
+  model: "claude-3-5-haiku-20241022",
+  systemPrompt: `You are a task planning specialist. Your job is to break down complex tasks into clear, actionable steps.
+
+Focus on:
+- Identifying dependencies and blockers
+- Creating logical sequence of steps
+- Estimating scope and priorities
+
+You can explore the codebase to understand the current architecture before planning.
+
+Provide a structured plan that the main agent can execute.`,
+  allowedTools: ["file_read", "grep_search", "glob_files", "bash_execute", "current_datetime", "math_evaluate"],
+  deniedTools: ["create_file", "edit_file", "delete_file", "web_search", "weather_info"],
+  maxIterations: {
+    quick: 3,
+    medium: 7,
+    very_thorough: 12
+  },
+  defaultThoroughness: "medium"
+};
+var REVIEW_CONFIG = {
+  type: "review",
+  model: "claude-sonnet-4-5-20250929",
+  // Use latest Sonnet for better reasoning
+  systemPrompt: `You are a code review specialist. Your job is to analyze code quality and identify issues.
+
+Focus on:
+- Code quality and best practices
+- Potential bugs and edge cases
+- Performance and security considerations
+
+You have read-only access to analyze code.
+
+Provide actionable feedback with specific file and line references.`,
+  allowedTools: ["file_read", "grep_search", "glob_files", "bash_execute", "current_datetime"],
+  deniedTools: ["create_file", "edit_file", "delete_file", "web_search", "weather_info"],
+  maxIterations: {
+    quick: 3,
+    medium: 8,
+    very_thorough: 15
+  },
+  defaultThoroughness: "medium"
+};
+function getDefaultSubagentConfigs() {
+  return /* @__PURE__ */ new Map([
+    ["explore", EXPLORE_CONFIG],
+    ["plan", PLAN_CONFIG],
+    ["review", REVIEW_CONFIG]
+  ]);
+}
+
+// src/agents/delegateTool.ts
+function createSubagentDelegateTool(orchestrator, parentSessionId) {
+  return {
+    toolFn: async (args) => {
+      const params = args;
+      if (!params.task) {
+        throw new Error("subagent_delegate: task parameter is required");
+      }
+      if (!params.type) {
+        throw new Error("subagent_delegate: type parameter is required");
+      }
+      const thoroughness = params.thoroughness || "medium";
+      const type = params.type;
+      const result = await orchestrator.delegateToSubagent({
+        task: params.task,
+        type,
+        thoroughness,
+        parentSessionId
+      });
+      return result.summary;
+    },
+    toolSchema: {
+      name: "subagent_delegate",
+      description: `Delegate a task to a specialized subagent for focused work.
+
+**When to use this tool:**
+- **Explore**: When you need to search through the codebase, find files, or understand code structure (read-only)
+- **Plan**: When you need to break down a complex task into actionable steps
+- **Review**: When you need to analyze code quality and identify potential issues
+
+**Benefits:**
+- Keeps main conversation focused and clean
+- Uses specialized prompts optimized for each task type
+- Faster execution with appropriate models (Haiku for explore/plan, Sonnet for review)
+
+**Example uses:**
+- "Find all files that use the authentication system" \u2192 explore
+- "Search for components that handle user input" \u2192 explore
+- "Break down implementing a new feature into steps" \u2192 plan
+- "Review this module for potential bugs" \u2192 review`,
+      parameters: {
+        type: "object",
+        properties: {
+          task: {
+            type: "string",
+            description: "Clear description of what you want the subagent to do. Be specific about what you're looking for or what needs to be accomplished."
+          },
+          type: {
+            type: "string",
+            enum: ["explore", "plan", "review"],
+            description: `Type of subagent to use:
+- explore: Read-only codebase exploration and search (fast, uses Haiku)
+- plan: Task breakdown and planning (uses Haiku)
+- review: Code quality analysis and review (uses Sonnet for better reasoning)`
+          },
+          thoroughness: {
+            type: "string",
+            enum: ["quick", "medium", "very_thorough"],
+            description: `How thoroughly to execute:
+- quick: Fast lookup, 1-2 iterations
+- medium: Balanced exploration, 3-5 iterations (default)
+- very_thorough: Comprehensive analysis, 8-10 iterations`
+          }
+        },
+        required: ["task", "type"]
+      }
+    }
+  };
+}
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -11255,11 +11979,12 @@ var usageCache = null;
 function CliApp() {
   const { exit } = useApp();
   const imageRenderer = new ImageRenderer();
-  const [state, setState] = useState7({
+  const [state, setState] = useState8({
     session: null,
     sessionStore: new SessionStore(),
     configStore: new ConfigStore(),
     commandHistoryStore: new CommandHistoryStore(),
+    customCommandStore: new CustomCommandStore(),
     imageStore: null,
     // Lazy-loaded on first use
     imageRenderer,
@@ -11272,10 +11997,10 @@ function CliApp() {
     rewindSelector: null,
     sessionSelector: null
   });
-  const [isInitialized, setIsInitialized] = useState7(false);
-  const [initError, setInitError] = useState7(null);
-  const [commandHistory, setCommandHistory] = useState7([]);
-  const imageStoreInitPromise = useRef(null);
+  const [isInitialized, setIsInitialized] = useState8(false);
+  const [initError, setInitError] = useState8(null);
+  const [commandHistory, setCommandHistory] = useState8([]);
+  const imageStoreInitPromise = useRef2(null);
   const setStoreSession = useCliStore((state2) => state2.setSession);
   const setPermissionPrompt = useCliStore((state2) => state2.setPermissionPrompt);
   const setShowConfigEditor = useCliStore((state2) => state2.setShowConfigEditor);
@@ -11339,6 +12064,15 @@ function CliApp() {
       const config = await state.configStore.load();
       const history = await state.commandHistoryStore.load();
       setCommandHistory(history);
+      try {
+        await state.customCommandStore.loadCommands();
+        const customCommandCount = state.customCommandStore.getCommandCount();
+        if (customCommandCount > 0) {
+          console.log(`\u{1F4DD} Loaded ${customCommandCount} custom command${customCommandCount !== 1 ? "s" : ""}`);
+        }
+      } catch (error) {
+        console.warn("Failed to load custom commands:", error instanceof Error ? error.message : String(error));
+      }
       const authTokens = await state.configStore.getAuthTokens();
       let isAuthenticated = false;
       if (!authTokens) {
@@ -11478,7 +12212,34 @@ function CliApp() {
           console.log(`  \u{1F4E1} ${serverName}: ${count} tool(s)`);
         });
       }
-      const allTools = [...b4mTools, ...mcpTools];
+      const subagentConfigs = getDefaultSubagentConfigs();
+      if (config.subagents) {
+        if (config.subagents.explore) {
+          const currentConfig = subagentConfigs.get("explore");
+          subagentConfigs.set("explore", { ...currentConfig, ...config.subagents.explore });
+        }
+        if (config.subagents.plan) {
+          const currentConfig = subagentConfigs.get("plan");
+          subagentConfigs.set("plan", { ...currentConfig, ...config.subagents.plan });
+        }
+        if (config.subagents.review) {
+          const currentConfig = subagentConfigs.get("review");
+          subagentConfigs.set("review", { ...currentConfig, ...config.subagents.review });
+        }
+      }
+      const orchestrator = new SubagentOrchestrator({
+        userId: config.userId,
+        llm,
+        logger: silentLogger,
+        permissionManager,
+        showPermissionPrompt: promptFn,
+        configStore: state.configStore,
+        apiClient,
+        subagentConfigs
+      });
+      const subagentDelegateTool = createSubagentDelegateTool(orchestrator, newSession.id);
+      const allTools = [...b4mTools, ...mcpTools, subagentDelegateTool];
+      console.log(`\u{1F916} Subagent delegation enabled (explore, plan, review)`);
       const projectDir = state.configStore.getProjectConfigDir();
       const contextResult = await loadContextFiles(projectDir);
       if (contextResult.globalContext) {
@@ -11515,6 +12276,15 @@ FOR CODING TASKS:
 - When searching for code: Use grep_search or glob_files to find relevant files
 - Permission system will ask for approval before any file writes
 
+SUBAGENT DELEGATION:
+- You have access to specialized subagents via the subagent_delegate tool
+- Use subagents for focused exploration, planning, or review tasks:
+  * explore: Fast read-only codebase search (e.g., "find all auth files", "locate API endpoints")
+  * plan: Break down complex tasks into actionable steps
+  * review: Analyze code quality and identify issues
+- Subagents keep the main conversation clean and run faster with optimized models
+- Delegate when you need to search extensively or analyze code structure
+
 FOR GENERAL TASKS:
 - Use available tools to get information (weather, web search, calculations, etc.)
 - When user asks follow-up questions, use conversation context to understand what they're referring to
@@ -11525,6 +12295,7 @@ EXAMPLES:
 - "how about Japan?" \u2192 use weather tool for Japan (applying same question from context)
 - "enhance README" \u2192 file_read \u2192 generate \u2192 create_file
 - "what packages installed?" \u2192 glob_files "**/package.json" \u2192 file_read
+- "find all components using React hooks" \u2192 subagent_delegate(task="find all components using React hooks", type="explore")
 
 Remember: Use context from previous messages to understand follow-up questions.${contextSection}`;
       const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
@@ -11571,8 +12342,164 @@ Remember: Use context from previous messages to understand follow-up questions.$
   useEffect3(() => {
     init();
   }, [init]);
+  const handleCustomCommandMessage = async (fullTemplate, displayMessage) => {
+    if (!state.agent || !state.session) {
+      console.error("\u274C Agent or session not initialized");
+      return;
+    }
+    const authTokens = await state.configStore.getAuthTokens();
+    if (!authTokens || new Date(authTokens.expiresAt) <= /* @__PURE__ */ new Date()) {
+      console.log("\n\u274C Authentication required to use AI features.");
+      console.log("\u{1F4A1} Run /login to authenticate with your B4M account.\n");
+      return;
+    }
+    useCliStore.getState().setIsThinking(true);
+    const currentSteps = [];
+    const stepHandler = (step) => {
+      currentSteps.push(step);
+      const currentSession = useCliStore.getState().session;
+      if (currentSession) {
+        const messages = [...currentSession.messages];
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage && lastMessage.role === "assistant") {
+          messages[messages.length - 1] = {
+            ...lastMessage,
+            metadata: {
+              ...lastMessage.metadata,
+              steps: [...currentSteps]
+            }
+          };
+          setStoreSession({
+            ...currentSession,
+            messages
+          });
+        }
+      }
+    };
+    state.agent.on("action", stepHandler);
+    try {
+      let messageContent = fullTemplate;
+      const userMessageContent = displayMessage;
+      if (state.messageBuilder && state.messageBuilder.hasImages(fullTemplate)) {
+        const { message: multimodalMessage } = await state.messageBuilder.buildMessage(fullTemplate);
+        messageContent = multimodalMessage.content;
+      }
+      const userMessage = {
+        role: "user",
+        content: userMessageContent,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const pendingAssistantMessage = {
+        role: "assistant",
+        content: "...",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: {
+          steps: []
+        }
+      };
+      const sessionWithMessages = {
+        ...state.session,
+        messages: [...state.session.messages, userMessage, pendingAssistantMessage],
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setState((prev) => ({ ...prev, session: sessionWithMessages }));
+      setStoreSession(sessionWithMessages);
+      const recentMessages = state.session.messages.slice(-20);
+      const previousMessages = recentMessages.filter((msg) => msg.role === "user" || msg.role === "assistant").map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      }));
+      const result = await state.agent.run(messageContent, {
+        previousMessages: previousMessages.length > 0 ? previousMessages : void 0
+      });
+      const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
+      if (permissionDenied) {
+        console.log("\n\u26A0\uFE0F  Action denied by user\n");
+      }
+      const successfulToolCalls = result.steps.filter((s) => s.type === "observation").length;
+      const currentSession = useCliStore.getState().session;
+      if (!currentSession) return;
+      const updatedMessages = [...currentSession.messages];
+      updatedMessages[updatedMessages.length - 1] = {
+        role: "assistant",
+        content: result.finalAnswer,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: {
+          steps: result.steps,
+          tokenUsage: {
+            prompt: 0,
+            completion: 0,
+            total: result.completionInfo.totalTokens
+          },
+          model: state.session.model,
+          permissionDenied
+        }
+      };
+      const finalSession = {
+        ...currentSession,
+        messages: updatedMessages,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: {
+          ...currentSession.metadata,
+          totalTokens: currentSession.metadata.totalTokens + result.completionInfo.totalTokens,
+          toolCallCount: currentSession.metadata.toolCallCount + successfulToolCalls
+        }
+      };
+      setState((prev) => ({ ...prev, session: finalSession }));
+      setStoreSession(finalSession);
+      await state.sessionStore.save(finalSession);
+      usageCache = null;
+      useCliStore.getState().setIsThinking(false);
+    } catch (error) {
+      useCliStore.getState().setIsThinking(false);
+      if (error?.message?.includes("Permission denied")) {
+        console.log("\n\u26A0\uFE0F  Action blocked by permission settings");
+        const currentSession2 = useCliStore.getState().session;
+        if (!currentSession2) return;
+        const sessionWithDenied = { ...currentSession2 };
+        const messages2 = [...sessionWithDenied.messages];
+        const lastMessage2 = messages2[messages2.length - 1];
+        if (lastMessage2 && lastMessage2.role === "assistant") {
+          messages2[messages2.length - 1] = {
+            ...lastMessage2,
+            content: error.message,
+            metadata: {
+              ...lastMessage2.metadata,
+              permissionDenied: true
+            }
+          };
+        }
+        sessionWithDenied.messages = messages2;
+        setState((prev) => ({ ...prev, session: sessionWithDenied }));
+        setStoreSession(sessionWithDenied);
+        await state.sessionStore.save(sessionWithDenied);
+        return;
+      }
+      console.error("Error executing command:", error);
+      console.error(error.stack);
+      const currentSession = useCliStore.getState().session;
+      if (!currentSession) return;
+      const sessionWithError = { ...currentSession };
+      const messages = [...sessionWithError.messages];
+      const lastMessage = messages[messages.length - 1];
+      if (lastMessage && lastMessage.role === "assistant") {
+        messages[messages.length - 1] = {
+          ...lastMessage,
+          content: `\u274C Error: ${error.message || "Unknown error occurred"}`
+        };
+      }
+      sessionWithError.messages = messages;
+      setState((prev) => ({ ...prev, session: sessionWithError }));
+      setStoreSession(sessionWithError);
+    } finally {
+      state.agent.off("action", stepHandler);
+    }
+  };
   const handleMessage = async (message) => {
-    if (!state.agent || !state.session) return;
+    if (!state.agent || !state.session) {
+      console.error("\u274C Agent or session not initialized");
+      return;
+    }
     await state.commandHistoryStore.add(message);
     const updatedHistory = await state.commandHistoryStore.list();
     setCommandHistory(updatedHistory);
@@ -11582,6 +12509,7 @@ Remember: Use context from previous messages to understand follow-up questions.$
       console.log("\u{1F4A1} Run /login to authenticate with your B4M account.\n");
       return;
     }
+    useCliStore.getState().setIsThinking(true);
     const currentSteps = [];
     const stepHandler = (step) => {
       currentSteps.push(step);
@@ -11683,6 +12611,46 @@ Remember: Use context from previous messages to understand follow-up questions.$
       state.agent.off("action", stepHandler);
     }
   };
+  const handleBashCommand = useCallback(
+    (command) => {
+      if (!state.session) return;
+      let output;
+      let isError = false;
+      try {
+        output = execSync(command, {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"],
+          cwd: process.cwd(),
+          maxBuffer: 10 * 1024 * 1024
+          // 10MB buffer
+        });
+      } catch (error) {
+        const execError = error;
+        output = execError.stderr || execError.message || "Command failed";
+        isError = true;
+      }
+      const userMessage = {
+        role: "user",
+        content: `$ ${command}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const assistantMessage = {
+        role: "assistant",
+        content: isError ? `\u274C Error:
+${output}` : output.trim() || "(no output)",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const updatedSession = {
+        ...state.session,
+        messages: [...state.session.messages, userMessage, assistantMessage],
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setState((prev) => ({ ...prev, session: updatedSession }));
+      setStoreSession(updatedSession);
+      state.sessionStore.save(updatedSession);
+    },
+    [state.session, state.sessionStore]
+  );
   const handleImageDetected = async (imageData) => {
     try {
       let imageStore = state.imageStore;
@@ -11737,8 +12705,48 @@ Remember: Use context from previous messages to understand follow-up questions.$
     };
   };
   const handleCommand = async (command, args) => {
+    const customCommand = state.customCommandStore.getCommand(command);
+    if (customCommand) {
+      try {
+        const sourceIcon = customCommand.source === "global" ? "\u{1F3E0}" : "\u{1F4C1}";
+        console.log(`${sourceIcon} Executing custom command: /${command}`);
+        let substitutedBody = substituteArguments(customCommand.body, args);
+        const processed = await processFileReferences(substitutedBody);
+        substitutedBody = processed.content;
+        if (processed.errors.length > 0) {
+          processed.errors.forEach((error) => console.warn(`Warning: ${error}`));
+        }
+        if (process.env.B4M_VERBOSE === "1") {
+          console.log("\u{1F4DD} Expanded command:\n", substitutedBody);
+        }
+        const displayMessage = `/${command}${args.length > 0 ? " " + args.join(" ") : ""}`;
+        if (customCommand.model && state.agent) {
+          console.log(`\u{1F504} Using model override: ${customCommand.model}`);
+          const originalModel = state.session?.model;
+          if (state.session) {
+            state.session.model = customCommand.model;
+          }
+          await handleCustomCommandMessage(substitutedBody, displayMessage);
+          if (state.session && originalModel) {
+            state.session.model = originalModel;
+          }
+        } else {
+          console.log("\u{1F916} Sending to agent...\n");
+          await handleCustomCommandMessage(substitutedBody, displayMessage);
+        }
+        return;
+      } catch (error) {
+        console.error(
+          `\u274C Failed to execute custom command /${command}:`,
+          error instanceof Error ? error.message : String(error)
+        );
+        return;
+      }
+    }
     switch (command) {
-      case "help":
+      case "help": {
+        const customCommands = state.customCommandStore.getAllCommands();
+        const hasCustomCommands = customCommands.length > 0;
         console.log(`
 Available commands:
   /help - Show this help message
@@ -11765,8 +12773,19 @@ Tool Permissions:
 
 Project Configuration:
   /project-config - Show merged project configuration
+
+Custom Commands:
+  /commands - List all custom commands
+  /commands:new <name> - Create a new custom command
+  /commands:reload - Reload custom commands from disk${hasCustomCommands ? "\n\n\u{1F4DD} Custom Commands Available:" : ""}${hasCustomCommands ? customCommands.map((cmd) => {
+          const source = cmd.source === "global" ? "\u{1F3E0}" : "\u{1F4C1}";
+          const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
+          return `
+  ${source} /${cmd.name}${argHint} - ${cmd.description}`;
+        }).join("") : ""}
         `);
         break;
+      }
       case "exit":
       case "quit":
         logger.debug("[EXIT /exit command - cleaning up and exiting...");
@@ -12254,6 +13273,71 @@ No usage data available for the last ${USAGE_DAYS} days.`);
         console.log("");
         break;
       }
+      case "commands": {
+        const customCommands = state.customCommandStore.getAllCommands();
+        const globalCommands = state.customCommandStore.getCommandsBySource("global");
+        const projectCommands = state.customCommandStore.getCommandsBySource("project");
+        console.log("\n\u{1F4DD} Custom Commands:\n");
+        if (customCommands.length === 0) {
+          console.log("No custom commands found.");
+          console.log("\nTo create a custom command:");
+          console.log("  /commands:new <name> - Create a new command");
+          console.log("\nCustom commands can be stored in:");
+          console.log("  \u{1F3E0} Global: ~/.bike4mind/commands/ (available in all projects)");
+          console.log("  \u{1F4C1} Project: .bike4mind/commands/ (team-shared, committed to git)");
+        } else {
+          if (globalCommands.length > 0) {
+            console.log("\u{1F3E0} Global Commands (~/.bike4mind/commands/):");
+            globalCommands.forEach((cmd) => {
+              const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
+              console.log(`  /${cmd.name}${argHint} - ${cmd.description}`);
+            });
+            console.log("");
+          }
+          if (projectCommands.length > 0) {
+            console.log("\u{1F4C1} Project Commands (.bike4mind/commands/):");
+            projectCommands.forEach((cmd) => {
+              const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
+              console.log(`  /${cmd.name}${argHint} - ${cmd.description}`);
+            });
+            console.log("");
+          }
+          console.log(`Total: ${customCommands.length} custom command${customCommands.length !== 1 ? "s" : ""}`);
+        }
+        console.log("");
+        break;
+      }
+      case "commands:new": {
+        const commandName = args[0];
+        if (!commandName) {
+          console.log("\u274C Please provide a command name");
+          console.log("Usage: /commands:new <name>");
+          break;
+        }
+        console.log("\nWhere should this command be stored?");
+        console.log("  1. \u{1F3E0} Global (~/.bike4mind/commands/) - available in all projects");
+        console.log("  2. \u{1F4C1} Project (.bike4mind/commands/) - team-shared");
+        console.log("\nDefaulting to global. Creating command file...");
+        try {
+          const filePath = await state.customCommandStore.createCommandFile(commandName, true);
+          console.log(`\u2705 Created command file: ${filePath}`);
+          console.log("\nEdit this file to customize your command.");
+          console.log("Then run: /commands:reload to load it");
+        } catch (error) {
+          console.error("\u274C Failed to create command file:", error instanceof Error ? error.message : String(error));
+        }
+        break;
+      }
+      case "commands:reload": {
+        try {
+          await state.customCommandStore.reloadCommands();
+          const count = state.customCommandStore.getCommandCount();
+          console.log(`\u2705 Reloaded ${count} custom command${count !== 1 ? "s" : ""}`);
+        } catch (error) {
+          console.error("\u274C Failed to reload commands:", error instanceof Error ? error.message : String(error));
+        }
+        break;
+      }
       default:
         console.log(`Unknown command: /${command}`);
         console.log("Type /help for available commands");
@@ -12261,7 +13345,28 @@ No usage data available for the last ${USAGE_DAYS} days.`);
   };
   const handleSaveConfig = async (updatedConfig) => {
     await state.configStore.save(updatedConfig);
-    setState((prev) => ({ ...prev, config: updatedConfig }));
+    const modelChanged = state.config?.defaultModel !== updatedConfig.defaultModel;
+    setState((prev) => {
+      if (modelChanged && prev.session) {
+        const updatedSession = {
+          ...prev.session,
+          model: updatedConfig.defaultModel,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        setStoreSession(updatedSession);
+        if (prev.agent) {
+          prev.agent.context.model = updatedConfig.defaultModel;
+        }
+        return { ...prev, config: updatedConfig, session: updatedSession };
+      }
+      return { ...prev, config: updatedConfig };
+    });
+    if (modelChanged && state.agent) {
+      const llm = state.agent.context.llm;
+      if (llm) {
+        llm.currentModel = updatedConfig.defaultModel;
+      }
+    }
   };
   if (initError) {
     return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React17.createElement(Text16, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React17.createElement(Text16, null, initError), /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
@@ -12350,13 +13455,16 @@ No usage data available for the last ${USAGE_DAYS} days.`);
   if (!isInitialized) {
     return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React17.createElement(Text16, null, "\u{1F680} Initializing..."));
   }
+  const allCommands = mergeCommands(state.customCommandStore.getAllCommands());
   return /* @__PURE__ */ React17.createElement(
     App,
     {
       onMessage: handleMessage,
       onCommand: handleCommand,
+      onBashCommand: handleBashCommand,
       onImageDetected: handleImageDetected,
       commandHistory,
+      commands: allCommands,
       config: state.config,
       availableModels: state.availableModels,
       onSaveConfig: handleSaveConfig,