@bike4mind/cli 0.2.21-feat-parallel-tool-execution.18205 → 0.2.21-feat-cli-skill-frontmatter-spec.18206

package/dist/index.js

@@ -4,12 +4,12 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-YLRAYIDX.js";
+} from "./chunk-NAIQUTDD.js";
 import {
   ConfigStore
 } from "./chunk-VFQF2JIT.js";
-import "./chunk-HERXMXE5.js";
-import "./chunk-JDCBPT4Y.js";
+import "./chunk-4UPFBOWT.js";
+import "./chunk-3NN5PD22.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -21,7 +21,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-QKJ4CHK6.js";
+} from "./chunk-HXWD4UGK.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -77,7 +77,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-VDLQKG5O.js";
+} from "./chunk-QZAVSLFW.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -2500,10 +2500,8 @@ import { z } from "zod";
 var flexibleString = z.union([z.string(), z.array(z.string())]).transform((val) => Array.isArray(val) ? val.join(" ") : val).optional();
 function needsQuoting(value) {
   const firstChar = value.charAt(0);
-  const isAlreadyQuoted = firstChar === '"' || firstChar === "'";
-  const isStructured = firstChar === "[" || firstChar === "{";
-  const containsColon = value.includes(":");
-  return containsColon && !isAlreadyQuoted && !isStructured;
+  const isProtected = firstChar === '"' || firstChar === "'" || firstChar === "[" || firstChar === "{";
+  return value.includes(":") && !isProtected;
 }
 function preprocessFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -2525,29 +2523,66 @@ function preprocessFrontmatter(content) {
 ${processedFrontmatter}
 ---`);
 }
+var HooksSchema = z.object({
+  /** Script to run before skill execution */
+  "pre-invoke": z.string().optional(),
+  /** Script to run after successful skill execution */
+  "post-invoke": z.string().optional(),
+  /** Script to run when skill execution fails */
+  "on-error": z.string().optional()
+}).optional();
+var AgentConfigSchema = z.union([
+  z.string(),
+  // Simple: "explore"
+  z.object({
+    // Complex config
+    type: z.string(),
+    // Agent type name
+    thoroughness: z.enum(["quick", "medium", "very_thorough"]).optional(),
+    config: z.record(z.any()).optional()
+    // Additional agent-specific config
+  })
+]);
+var VALID_MODELS = ["opus", "sonnet", "haiku"];
 var FrontmatterSchema = z.object({
+  // Display name for the skill (defaults to filename if not specified)
+  name: z.string().optional(),
   description: flexibleString,
   "argument-hint": flexibleString,
+  // Model override - validated against allowed values (opus, sonnet, haiku)
   model: z.string().optional(),
   // Agent integration fields
-  agent: z.string().optional(),
+  agent: AgentConfigSchema.optional(),
   thoroughness: z.enum(["quick", "medium", "very_thorough"]).optional(),
   variables: z.record(z.string()).optional(),
-  // Future fields (ignored for now):
-  "allowed-tools": z.any().optional(),
-  context: z.any().optional(),
-  "disable-model-invocation": z.any().optional(),
-  hooks: z.any().optional()
-});
+  // Tool filtering - restrict which tools are available during skill execution
+  "allowed-tools": z.array(z.string()).optional(),
+  // Execution context: 'inline' (default) runs in main context, 'fork' runs in subagent
+  context: z.enum(["fork", "inline"]).default("inline"),
+  // Visibility controls
+  /** When true, skill is hidden from AI's auto-loading in system prompt */
+  "disable-model-invocation": z.boolean().default(false),
+  /** When false, skill is hidden from /commands menu but still callable */
+  "user-invocable": z.boolean().default(true),
+  // Lifecycle hooks
+  hooks: HooksSchema
+});
+var DESCRIPTION_MAX_LENGTH = 100;
+var DEFAULT_DESCRIPTION = "Custom command";
 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;
-    }
+  const firstContentLine = lines.find((line) => {
+    const trimmed2 = line.trim();
+    return trimmed2 && !trimmed2.startsWith("#");
+  });
+  if (!firstContentLine) {
+    return DEFAULT_DESCRIPTION;
   }
-  return "Custom command";
+  const trimmed = firstContentLine.trim();
+  if (trimmed.length <= DESCRIPTION_MAX_LENGTH) {
+    return trimmed;
+  }
+  return trimmed.substring(0, DESCRIPTION_MAX_LENGTH - 3) + "...";
 }
 function parseCommandFile(fileContent, filePath, commandName, source) {
   try {
@@ -2561,9 +2596,20 @@ function parseCommandFile(fileContent, filePath, commandName, source) {
       );
     }
     const validFrontmatter = validationResult.success ? validationResult.data : {};
-    const description = validFrontmatter.description || extractDescriptionFromBody(body) || "Custom command";
+    const description = validFrontmatter.description || extractDescriptionFromBody(body);
+    if (validFrontmatter.model && !VALID_MODELS.includes(validFrontmatter.model)) {
+      console.warn(
+        `Warning: Invalid model "${validFrontmatter.model}" in ${filePath}. Valid values are: ${VALID_MODELS.join(", ")}`
+      );
+    }
+    if (validFrontmatter.agent && validFrontmatter.context !== "fork") {
+      console.warn(
+        `Warning: Skill "${commandName}" has "agent" specified but "context" is not "fork". The agent field is only used when context is "fork". Consider adding "context: fork" to the frontmatter.`
+      );
+    }
     return {
       name: commandName,
+      displayName: validFrontmatter.name,
       description,
       argumentHint: validFrontmatter["argument-hint"],
       model: validFrontmatter.model,
@@ -2572,7 +2618,14 @@ function parseCommandFile(fileContent, filePath, commandName, source) {
       filePath,
       agent: validFrontmatter.agent,
       thoroughness: validFrontmatter.thoroughness,
-      variables: validFrontmatter.variables
+      variables: validFrontmatter.variables,
+      // New Claude Code spec fields
+      allowedTools: validFrontmatter["allowed-tools"],
+      context: validFrontmatter.context || "inline",
+      disableModelInvocation: validFrontmatter["disable-model-invocation"] || false,
+      userInvocable: validFrontmatter["user-invocable"] !== false,
+      // Default true
+      hooks: validFrontmatter.hooks
     };
   } catch (error) {
     throw new Error(
@@ -2580,12 +2633,9 @@ function parseCommandFile(fileContent, filePath, commandName, source) {
     );
   }
 }
+var COMMAND_NAME_PATTERN = /^[a-z0-9-_:]+$/i;
 function isValidCommandName(name) {
-  if (!name || name.trim().length === 0) {
-    return false;
-  }
-  const validPattern = /^[a-z0-9-_:]+$/i;
-  return validPattern.test(name);
+  return Boolean(name) && COMMAND_NAME_PATTERN.test(name);
 }
 function extractCommandName(filename) {
   if (!filename.endsWith(".md")) {
@@ -2803,127 +2853,6 @@ You can use:
 
 // ../../b4m-core/packages/agents/src/ReActAgent.ts
 import { EventEmitter } from "events";
-
-// ../../b4m-core/packages/agents/src/toolParallelizer.ts
-var DEFAULT_WRITE_TOOLS = /* @__PURE__ */ new Set([
-  "edit_file",
-  "edit_local_file",
-  "create_file",
-  "delete_file",
-  "shell_execute",
-  "bash_execute",
-  "git_commit",
-  "git_push"
-]);
-function defaultIsReadOnlyTool(toolName) {
-  return !DEFAULT_WRITE_TOOLS.has(toolName);
-}
-function getToolId(tool) {
-  return `${tool.name}_${JSON.stringify(tool.arguments)}`;
-}
-function categorizeTools(toolsUsed, isReadOnly = defaultIsReadOnlyTool) {
-  const parallelBatch = [];
-  const sequentialBatch = [];
-  const originalOrder = [];
-  for (const tool of toolsUsed) {
-    originalOrder.push(getToolId(tool));
-    if (isReadOnly(tool.name)) {
-      parallelBatch.push(tool);
-    } else {
-      sequentialBatch.push(tool);
-    }
-  }
-  return {
-    parallelBatch,
-    sequentialBatch,
-    originalOrder
-  };
-}
-async function executeToolsInParallel(plan, executor, signal) {
-  const results = /* @__PURE__ */ new Map();
-  if (signal?.aborted) {
-    throw new Error("Tool execution aborted");
-  }
-  if (plan.parallelBatch.length > 0) {
-    const parallelPromises = plan.parallelBatch.map(async (tool) => {
-      const toolId = getToolId(tool);
-      if (signal?.aborted) {
-        return {
-          toolId,
-          result: {
-            toolName: tool.name,
-            error: new Error("Tool execution aborted"),
-            status: "rejected"
-          }
-        };
-      }
-      try {
-        const result = await executor(tool);
-        return {
-          toolId,
-          result: {
-            toolName: tool.name,
-            result,
-            status: "fulfilled"
-          }
-        };
-      } catch (error) {
-        return {
-          toolId,
-          result: {
-            toolName: tool.name,
-            error: error instanceof Error ? error : new Error(String(error)),
-            status: "rejected"
-          }
-        };
-      }
-    });
-    const settledResults = await Promise.allSettled(parallelPromises);
-    for (const settled of settledResults) {
-      if (settled.status === "fulfilled") {
-        results.set(settled.value.toolId, settled.value.result);
-      }
-    }
-  }
-  if (signal?.aborted) {
-    throw new Error("Tool execution aborted");
-  }
-  for (const tool of plan.sequentialBatch) {
-    const toolId = getToolId(tool);
-    if (signal?.aborted) {
-      results.set(toolId, {
-        toolName: tool.name,
-        error: new Error("Tool execution aborted"),
-        status: "rejected"
-      });
-      throw new Error("Tool execution aborted");
-    }
-    try {
-      const result = await executor(tool);
-      results.set(toolId, {
-        toolName: tool.name,
-        result,
-        status: "fulfilled"
-      });
-    } catch (error) {
-      results.set(toolId, {
-        toolName: tool.name,
-        error: error instanceof Error ? error : new Error(String(error)),
-        status: "rejected"
-      });
-    }
-  }
-  return results;
-}
-function shouldUseParallelExecution(toolsUsed, isReadOnly = defaultIsReadOnlyTool) {
-  if (toolsUsed.length < 2) {
-    return false;
-  }
-  const readOnlyCount = toolsUsed.filter((tool) => isReadOnly(tool.name)).length;
-  return readOnlyCount >= 2;
-}
-
-// ../../b4m-core/packages/agents/src/ReActAgent.ts
 var ReActAgent = class extends EventEmitter {
   constructor(context) {
     super();
@@ -3051,51 +2980,77 @@ ${options.context}` : this.getSystemPrompt()
               if (completionInfo.toolsUsed && completionInfo.toolsUsed.length > 0) {
                 hadToolCalls = true;
                 const thinkingBlocks = completionInfo.thinking || [];
-                const unprocessedTools = [];
                 for (const toolUse of completionInfo.toolsUsed) {
-                  const toolCallIdStr = getToolId(toolUse);
-                  if (!processedToolIds.has(toolCallIdStr)) {
-                    processedToolIds.add(toolCallIdStr);
-                    unprocessedTools.push(toolUse);
+                  const toolCallId = `${toolUse.name}_${JSON.stringify(toolUse.arguments)}`;
+                  if (processedToolIds.has(toolCallId)) {
+                    continue;
                   }
-                }
-                if (unprocessedTools.length === 0) {
-                } else if (options.parallelExecution && shouldUseParallelExecution(unprocessedTools, options.isReadOnlyTool ?? defaultIsReadOnlyTool)) {
-                  this.context.logger.debug(
-                    `[ReActAgent] Parallel execution enabled for ${unprocessedTools.length} tools`
-                  );
-                  for (const toolUse of unprocessedTools) {
-                    this.emitActionStep(toolUse);
-                  }
-                  const plan = categorizeTools(unprocessedTools, options.isReadOnlyTool ?? defaultIsReadOnlyTool);
-                  const results = await executeToolsInParallel(
-                    plan,
-                    (toolUse) => this.executeToolWithQueueFallback(toolUse),
-                    options.signal
-                  );
-                  for (const toolUse of unprocessedTools) {
-                    const toolIdStr = getToolId(toolUse);
-                    const result2 = results.get(toolIdStr);
-                    const observation = result2?.status === "fulfilled" ? result2.result ?? "" : `Error: ${result2?.error?.message ?? "Unknown error"}`;
-                    this.appendToolMessages(messages, toolUse, observation, thinkingBlocks);
-                    this.emitObservationStep(toolUse.name, observation);
-                  }
-                } else {
-                  for (const toolUse of unprocessedTools) {
-                    this.emitActionStep(toolUse);
-                    const queuedObs = this.observationQueue.find((obs) => obs.toolName === toolUse.name);
-                    let observation;
-                    if (queuedObs) {
-                      const result2 = queuedObs.result;
-                      const index = this.observationQueue.indexOf(queuedObs);
-                      this.observationQueue.splice(index, 1);
-                      observation = typeof result2 === "string" ? result2 : JSON.stringify(result2);
-                    } else {
-                      observation = await this.executeToolWithQueueFallback(toolUse);
-                      this.appendToolMessages(messages, toolUse, observation, thinkingBlocks);
+                  processedToolIds.add(toolCallId);
+                  this.toolCallCount++;
+                  const actionStep = {
+                    type: "action",
+                    content: `Using tool: ${toolUse.name}`,
+                    metadata: {
+                      toolName: toolUse.name,
+                      toolInput: toolUse.arguments,
+                      timestamp: Date.now()
                     }
-                    this.emitObservationStep(toolUse.name, observation);
+                  };
+                  this.steps.push(actionStep);
+                  this.emit("action", actionStep);
+                  const queuedObs = this.observationQueue.find((obs) => obs.toolName === toolUse.name);
+                  let observation;
+                  if (queuedObs) {
+                    observation = queuedObs.result;
+                    const index = this.observationQueue.indexOf(queuedObs);
+                    this.observationQueue.splice(index, 1);
+                  } else {
+                    const tool = this.context.tools.find((t) => t.toolSchema.name === toolUse.name);
+                    if (!tool) {
+                      throw new Error(`Tool ${toolUse.name} not found in agent context`);
+                    }
+                    const params = typeof toolUse.arguments === "string" ? JSON.parse(toolUse.arguments) : toolUse.arguments;
+                    observation = await tool.toolFn(params);
+                    const toolCallId2 = `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                    const assistantContent = [
+                      // Include thinking blocks first (required by Anthropic when thinking is enabled)
+                      ...thinkingBlocks,
+                      // Then the tool use
+                      {
+                        type: "tool_use",
+                        id: toolCallId2,
+                        name: toolUse.name,
+                        input: params
+                      }
+                    ];
+                    this.context.logger.debug(
+                      `[assistantContent] ${assistantContent.length} blocks (${thinkingBlocks.length} thinking, 1 tool_use)`
+                    );
+                    messages.push({
+                      role: "assistant",
+                      content: assistantContent
+                    });
+                    messages.push({
+                      role: "user",
+                      content: [
+                        {
+                          type: "tool_result",
+                          tool_use_id: toolCallId2,
+                          content: typeof observation === "string" ? observation : JSON.stringify(observation)
+                        }
+                      ]
+                    });
                   }
+                  const observationStep = {
+                    type: "observation",
+                    content: typeof observation === "string" ? observation : JSON.stringify(observation),
+                    metadata: {
+                      toolName: toolUse.name,
+                      timestamp: Date.now()
+                    }
+                  };
+                  this.steps.push(observationStep);
+                  this.emit("observation", observationStep);
                 }
               }
             }
@@ -3232,159 +3187,7 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
   getToolCallCount() {
     return this.toolCallCount;
   }
-  /**
-   * Create and emit an action step for a tool use
-   */
-  emitActionStep(toolUse) {
-    this.toolCallCount++;
-    const actionStep = {
-      type: "action",
-      content: `Using tool: ${toolUse.name}`,
-      metadata: {
-        toolName: toolUse.name,
-        toolInput: toolUse.arguments,
-        timestamp: Date.now()
-      }
-    };
-    this.steps.push(actionStep);
-    this.emit("action", actionStep);
-  }
-  /**
-   * Create and emit an observation step
-   */
-  emitObservationStep(toolName, observation) {
-    const observationStep = {
-      type: "observation",
-      content: observation,
-      metadata: {
-        toolName,
-        timestamp: Date.now()
-      }
-    };
-    this.steps.push(observationStep);
-    this.emit("observation", observationStep);
-  }
-  /**
-   * Parse tool arguments, handling both string and object forms
-   */
-  parseToolArguments(args) {
-    return typeof args === "string" ? JSON.parse(args) : args;
-  }
-  /**
-   * Execute a tool and return the result as a string.
-   * Checks observation queue first for backward compatibility.
-   */
-  async executeToolWithQueueFallback(toolUse) {
-    const queuedObs = this.observationQueue.find((obs) => obs.toolName === toolUse.name);
-    if (queuedObs) {
-      const result2 = queuedObs.result;
-      const index = this.observationQueue.indexOf(queuedObs);
-      this.observationQueue.splice(index, 1);
-      return typeof result2 === "string" ? result2 : JSON.stringify(result2);
-    }
-    const tool = this.context.tools.find((t) => t.toolSchema.name === toolUse.name);
-    if (!tool) {
-      throw new Error(`Tool ${toolUse.name} not found in agent context`);
-    }
-    const params = this.parseToolArguments(toolUse.arguments);
-    const result = await tool.toolFn(params);
-    return typeof result === "string" ? result : JSON.stringify(result);
-  }
-  /**
-   * Build and append tool call/result messages for the conversation history
-   */
-  appendToolMessages(messages, toolUse, observation, thinkingBlocks) {
-    const params = this.parseToolArguments(toolUse.arguments);
-    const msgToolCallId = `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    const assistantContent = [
-      ...thinkingBlocks,
-      {
-        type: "tool_use",
-        id: msgToolCallId,
-        name: toolUse.name,
-        input: params
-      }
-    ];
-    messages.push({
-      role: "assistant",
-      content: assistantContent
-    });
-    messages.push({
-      role: "user",
-      content: [
-        {
-          type: "tool_result",
-          tool_use_id: msgToolCallId,
-          content: observation
-        }
-      ]
-    });
-  }
-};
-
-// src/config/toolSafety.ts
-import { z as z2 } from "zod";
-var ToolCategorySchema = z2.enum([
-  "auto_approve",
-  // Safe tools that run automatically without permission
-  "prompt_always",
-  // Dangerous tools that ALWAYS require permission (cannot be trusted)
-  "prompt_default"
-  // Tools that prompt by default but can be trusted
-]);
-var ToolSafetyConfigSchema = z2.object({
-  categories: z2.record(z2.string(), ToolCategorySchema),
-  trustedTools: z2.array(z2.string())
-});
-var DEFAULT_TOOL_CATEGORIES = {
-  // ===== AUTO APPROVE (Safe tools) =====
-  // These tools have no side effects and are always safe to execute
-  math_evaluate: "auto_approve",
-  current_datetime: "auto_approve",
-  dice_roll: "auto_approve",
-  prompt_enhancement: "auto_approve",
-  weather_info: "prompt_default",
-  // ===== PROMPT ALWAYS (Dangerous tools) =====
-  // These tools can modify files, execute code, or have other dangerous side effects
-  // They ALWAYS require permission and cannot be trusted automatically
-  edit_file: "prompt_always",
-  edit_local_file: "prompt_always",
-  create_file: "prompt_always",
-  delete_file: "prompt_always",
-  shell_execute: "prompt_always",
-  bash_execute: "prompt_always",
-  git_commit: "prompt_always",
-  git_push: "prompt_always",
-  // ===== PROMPT DEFAULT (Repository read tools) =====
-  // These tools read from the repository but don't modify anything
-  // Users can trust them if they want to avoid prompts
-  web_search: "prompt_default",
-  deep_research: "prompt_default",
-  file_read: "prompt_default",
-  grep_search: "prompt_default",
-  glob_files: "prompt_default",
-  get_file_tree: "prompt_default",
-  git_status: "prompt_default",
-  git_diff: "prompt_default",
-  git_log: "prompt_default",
-  git_branch: "prompt_default"
 };
-function getToolCategory(toolName, customCategories) {
-  if (customCategories && toolName in customCategories) {
-    return customCategories[toolName];
-  }
-  if (toolName in DEFAULT_TOOL_CATEGORIES) {
-    return DEFAULT_TOOL_CATEGORIES[toolName];
-  }
-  return "prompt_default";
-}
-function canTrustTool(toolName, customCategories) {
-  const category = getToolCategory(toolName, customCategories);
-  return category !== "prompt_always";
-}
-function isReadOnlyTool(toolName, customCategories) {
-  return getToolCategory(toolName, customCategories) !== "prompt_always";
-}
 
 // src/core/prompts.ts
 var TOOL_GREP_SEARCH = "grep_search";
@@ -3486,38 +3289,38 @@ Remember: Use context from previous messages to understand follow-up questions.$
 // ../../b4m-core/packages/services/dist/src/referService/generateCodes.js
 import { randomBytes } from "crypto";
 import range from "lodash/range.js";
-import { z as z3 } from "zod";
-var generateReferralCodesSchema = z3.object({
-  count: z3.number().optional(),
-  unlimitedUse: z3.boolean().optional(),
-  expiresAt: z3.date().optional()
+import { z as z2 } from "zod";
+var generateReferralCodesSchema = z2.object({
+  count: z2.number().optional(),
+  unlimitedUse: z2.boolean().optional(),
+  expiresAt: z2.date().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/referService/delete.js
-import { z as z4 } from "zod";
-var deleteInviteCodesSchema = z4.object({
-  ids: z4.array(z4.string())
+import { z as z3 } from "zod";
+var deleteInviteCodesSchema = z3.object({
+  ids: z3.array(z3.string())
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/login.js
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 import bcrypt from "bcryptjs";
-var loginUserSchema = z5.object({
-  usernameOrEmail: z5.string(),
-  password: z5.string(),
-  metadata: z5.object({
-    loginTime: z5.date(),
-    userAgent: z5.string(),
-    browser: z5.string(),
-    operatingSystem: z5.string(),
-    deviceType: z5.string(),
-    screenResolution: z5.string(),
-    viewportSize: z5.string(),
-    colorDepth: z5.number(),
-    pixelDepth: z5.number(),
-    devicePixelRatio: z5.number(),
-    ip: z5.string().optional().default(""),
-    location: z5.string().optional()
+var loginUserSchema = z4.object({
+  usernameOrEmail: z4.string(),
+  password: z4.string(),
+  metadata: z4.object({
+    loginTime: z4.date(),
+    userAgent: z4.string(),
+    browser: z4.string(),
+    operatingSystem: z4.string(),
+    deviceType: z4.string(),
+    screenResolution: z4.string(),
+    viewportSize: z4.string(),
+    colorDepth: z4.number(),
+    pixelDepth: z4.number(),
+    devicePixelRatio: z4.number(),
+    ip: z4.string().optional().default(""),
+    location: z4.string().optional()
   }).optional()
 });
 
@@ -3527,78 +3330,78 @@ import escapeRegExp from "lodash/escapeRegExp.js";
 
 // ../../b4m-core/packages/services/dist/src/userService/forgotPassword.js
 import { randomUUID } from "crypto";
-import { z as z6 } from "zod";
-var forgotPasswordUserSchema = z6.object({
-  email: z6.string().email()
+import { z as z5 } from "zod";
+var forgotPasswordUserSchema = z5.object({
+  email: z5.string().email()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/update.js
 import bcrypt3 from "bcryptjs";
-import { z as z7 } from "zod";
-var updateUserSchema = z7.object({
-  name: z7.string().optional(),
-  username: z7.string().optional(),
+import { z as z6 } from "zod";
+var updateUserSchema = z6.object({
+  name: z6.string().optional(),
+  username: z6.string().optional(),
   // email field removed - users must use the secure email change verification flow
   // See requestEmailChange and verifyEmailChange in userService
-  password: z7.string().nullable().optional(),
-  team: z7.string().nullable().optional(),
-  role: z7.string().nullable().optional(),
-  phone: z7.string().nullable().optional(),
-  preferredLanguage: z7.string().nullable().optional(),
-  preferredContact: z7.string().nullable().optional(),
-  preferredVoice: z7.string().nullable().optional(),
-  tshirtSize: z7.string().nullable().optional(),
-  geoLocation: z7.string().nullable().optional(),
-  lastNotebookId: z7.string().nullable().optional(),
-  tags: z7.array(z7.string()).nullable().optional(),
-  lastCreditsPurchasedAt: z7.date().nullable().optional(),
-  systemFiles: z7.array(z7.object({
-    fileId: z7.string(),
-    enabled: z7.boolean()
+  password: z6.string().nullable().optional(),
+  team: z6.string().nullable().optional(),
+  role: z6.string().nullable().optional(),
+  phone: z6.string().nullable().optional(),
+  preferredLanguage: z6.string().nullable().optional(),
+  preferredContact: z6.string().nullable().optional(),
+  preferredVoice: z6.string().nullable().optional(),
+  tshirtSize: z6.string().nullable().optional(),
+  geoLocation: z6.string().nullable().optional(),
+  lastNotebookId: z6.string().nullable().optional(),
+  tags: z6.array(z6.string()).nullable().optional(),
+  lastCreditsPurchasedAt: z6.date().nullable().optional(),
+  systemFiles: z6.array(z6.object({
+    fileId: z6.string(),
+    enabled: z6.boolean()
   })).nullable().optional(),
-  securityQuestions: z7.array(z7.object({ question: z7.string(), answer: z7.string() })).nullable().optional(),
-  photoUrl: z7.string().nullable().optional(),
-  showCreditsUsed: z7.boolean().optional()
+  securityQuestions: z6.array(z6.object({ question: z6.string(), answer: z6.string() })).nullable().optional(),
+  photoUrl: z6.string().nullable().optional(),
+  showCreditsUsed: z6.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminUpdate.js
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/sendFriendRequest.js
-import { z as z8 } from "zod";
-var sendFriendRequestSchema = z8.object({
-  requesterId: z8.string(),
-  recipientId: z8.string(),
-  message: z8.string().optional()
+import { z as z7 } from "zod";
+var sendFriendRequestSchema = z7.object({
+  requesterId: z7.string(),
+  recipientId: z7.string(),
+  message: z7.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminUpdate.js
 var adminUpdateUserSchema = updateUserSchema.extend({
-  id: z9.string(),
+  id: z8.string(),
   // Admins can directly update email addresses without verification
-  email: z9.string().email().optional(),
-  role: z9.string().optional().nullable(),
-  isAdmin: z9.boolean().optional(),
-  organizationId: z9.string().optional().nullable(),
-  storageLimit: z9.number().optional(),
-  currentCredits: z9.number().optional(),
-  isBanned: z9.boolean().optional(),
-  isModerated: z9.boolean().optional(),
-  subscribedUntil: z9.string().optional().nullable(),
-  systemFiles: z9.array(z9.object({ fileId: z9.string(), enabled: z9.boolean() })).optional(),
-  level: z9.enum(["DemoUser", "PaidUser", "VIPUser", "ManagerUser", "AdminUser"]).optional(),
-  lastNotebookId: z9.string().optional().nullable(),
-  userNotes: z9.array(z9.object({ timestamp: z9.string(), note: z9.string(), userName: z9.string() })).optional(),
-  numReferralsAvailable: z9.number().optional()
+  email: z8.string().email().optional(),
+  role: z8.string().optional().nullable(),
+  isAdmin: z8.boolean().optional(),
+  organizationId: z8.string().optional().nullable(),
+  storageLimit: z8.number().optional(),
+  currentCredits: z8.number().optional(),
+  isBanned: z8.boolean().optional(),
+  isModerated: z8.boolean().optional(),
+  subscribedUntil: z8.string().optional().nullable(),
+  systemFiles: z8.array(z8.object({ fileId: z8.string(), enabled: z8.boolean() })).optional(),
+  level: z8.enum(["DemoUser", "PaidUser", "VIPUser", "ManagerUser", "AdminUser"]).optional(),
+  lastNotebookId: z8.string().optional().nullable(),
+  userNotes: z8.array(z8.object({ timestamp: z8.string(), note: z8.string(), userName: z8.string() })).optional(),
+  numReferralsAvailable: z8.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/register.js
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 import bcrypt4 from "bcryptjs";
 
 // ../../b4m-core/packages/services/dist/src/creditService/addCredits.js
-import { z as z10 } from "zod";
-var AddCreditsSchema = z10.discriminatedUnion("type", [
+import { z as z9 } from "zod";
+var AddCreditsSchema = z9.discriminatedUnion("type", [
   PurchaseTransaction.omit({ createdAt: true, updatedAt: true }),
   SubscriptionCreditTransaction.omit({ createdAt: true, updatedAt: true }),
   GenericCreditAddTransaction.omit({ createdAt: true, updatedAt: true }),
@@ -3606,57 +3409,57 @@ var AddCreditsSchema = z10.discriminatedUnion("type", [
 ]);
 
 // ../../b4m-core/packages/services/dist/src/userService/register.js
-var registerUserSchema = z11.object({
-  username: z11.string(),
-  email: z11.string(),
-  name: z11.string(),
-  inviteCode: z11.string(),
-  password: z11.string(),
-  metadata: z11.object({
-    loginTime: z11.date(),
-    userAgent: z11.string(),
-    browser: z11.string(),
-    operatingSystem: z11.string(),
-    deviceType: z11.string(),
-    screenResolution: z11.string(),
-    viewportSize: z11.string(),
-    colorDepth: z11.number(),
-    pixelDepth: z11.number(),
-    devicePixelRatio: z11.number(),
-    ip: z11.string().optional().default(""),
-    location: z11.string().optional()
+var registerUserSchema = z10.object({
+  username: z10.string(),
+  email: z10.string(),
+  name: z10.string(),
+  inviteCode: z10.string(),
+  password: z10.string(),
+  metadata: z10.object({
+    loginTime: z10.date(),
+    userAgent: z10.string(),
+    browser: z10.string(),
+    operatingSystem: z10.string(),
+    deviceType: z10.string(),
+    screenResolution: z10.string(),
+    viewportSize: z10.string(),
+    colorDepth: z10.number(),
+    pixelDepth: z10.number(),
+    devicePixelRatio: z10.number(),
+    ip: z10.string().optional().default(""),
+    location: z10.string().optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminDelete.js
-import { z as z12 } from "zod";
-var adminDeleteUserSchema = z12.object({
-  id: z12.string()
+import { z as z11 } from "zod";
+var adminDeleteUserSchema = z11.object({
+  id: z11.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/searchUserCollection.js
-import { z as z13 } from "zod";
-var searchUserCollectionSchema = z13.object({
-  userId: z13.string(),
-  page: z13.coerce.number().optional().default(1),
-  limit: z13.coerce.number().optional().default(10),
-  search: z13.string().optional().default(""),
-  type: z13.nativeEnum(CollectionType).optional()
+import { z as z12 } from "zod";
+var searchUserCollectionSchema = z12.object({
+  userId: z12.string(),
+  page: z12.coerce.number().optional().default(1),
+  limit: z12.coerce.number().optional().default(10),
+  search: z12.string().optional().default(""),
+  type: z12.nativeEnum(CollectionType).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/recalculateUserStorage.js
-import { z as z14 } from "zod";
-var recalculateUserStorageSchema = z14.object({
+import { z as z13 } from "zod";
+var recalculateUserStorageSchema = z13.object({
   /**
    * The user to recalculate the storage for
    */
-  userId: z14.string()
+  userId: z13.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/listRecentActivities.js
-import { z as z15 } from "zod";
-var listRecentActivitiesSchema = z15.object({
-  coverage: z15.enum(["all", "important"]).default("important")
+import { z as z14 } from "zod";
+var listRecentActivitiesSchema = z14.object({
+  coverage: z14.enum(["all", "important"]).default("important")
 });
 var IMPORTANT_COUNTER_NAMES = [
   SessionEvents.CREATE_SESSION,
@@ -3670,82 +3473,82 @@ var IMPORTANT_COUNTER_NAMES = [
 
 // ../../b4m-core/packages/services/dist/src/userService/sendEmailVerification.js
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z16 } from "zod";
-var sendEmailVerificationSchema = z16.object({
-  userId: z16.string()
+import { z as z15 } from "zod";
+var sendEmailVerificationSchema = z15.object({
+  userId: z15.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailToken.js
-import { z as z17 } from "zod";
+import { z as z16 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/utils/crypto.js
 import crypto from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailToken.js
-var verifyEmailTokenSchema = z17.object({
-  token: z17.string()
+var verifyEmailTokenSchema = z16.object({
+  token: z16.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/resendEmailVerification.js
 import { randomUUID as randomUUID3 } from "crypto";
-import { z as z18 } from "zod";
-var resendEmailVerificationSchema = z18.object({
-  userId: z18.string()
+import { z as z17 } from "zod";
+var resendEmailVerificationSchema = z17.object({
+  userId: z17.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/requestEmailChange.js
 import { randomUUID as randomUUID4 } from "crypto";
-import { z as z19 } from "zod";
-var requestEmailChangeSchema = z19.object({
-  userId: z19.string(),
-  newEmail: z19.string().email(),
-  password: z19.string()
+import { z as z18 } from "zod";
+var requestEmailChangeSchema = z18.object({
+  userId: z18.string(),
+  newEmail: z18.string().email(),
+  password: z18.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailChange.js
-import { z as z20 } from "zod";
-var verifyEmailChangeSchema = z20.object({
-  token: z20.string()
+import { z as z19 } from "zod";
+var verifyEmailChangeSchema = z19.object({
+  token: z19.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/cancelEmailChange.js
-import { z as z21 } from "zod";
-var cancelEmailChangeSchema = z21.object({
-  userId: z21.string()
+import { z as z20 } from "zod";
+var cancelEmailChangeSchema = z20.object({
+  userId: z20.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/create.js
 import { randomBytes as randomBytes2 } from "crypto";
 import bcrypt5 from "bcryptjs";
-import { z as z22 } from "zod";
-var createUserApiKeySchema = z22.object({
-  name: z22.string().min(1).max(100),
-  scopes: z22.array(z22.nativeEnum(ApiKeyScope)).min(1),
-  expiresAt: z22.date().optional(),
-  rateLimit: z22.object({
-    requestsPerMinute: z22.number().min(1).max(1e3).default(60),
-    requestsPerDay: z22.number().min(1).max(1e4).default(1e3)
+import { z as z21 } from "zod";
+var createUserApiKeySchema = z21.object({
+  name: z21.string().min(1).max(100),
+  scopes: z21.array(z21.nativeEnum(ApiKeyScope)).min(1),
+  expiresAt: z21.date().optional(),
+  rateLimit: z21.object({
+    requestsPerMinute: z21.number().min(1).max(1e3).default(60),
+    requestsPerDay: z21.number().min(1).max(1e4).default(1e3)
   }).optional(),
-  metadata: z22.object({
-    clientIP: z22.string().optional(),
-    userAgent: z22.string().optional(),
-    createdFrom: z22.enum(["dashboard", "cli", "api"])
+  metadata: z21.object({
+    clientIP: z21.string().optional(),
+    userAgent: z21.string().optional(),
+    createdFrom: z21.enum(["dashboard", "cli", "api"])
   })
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/revoke.js
-import { z as z23 } from "zod";
-var revokeUserApiKeySchema = z23.object({
-  keyId: z23.string(),
-  reason: z23.string().optional()
+import { z as z22 } from "zod";
+var revokeUserApiKeySchema = z22.object({
+  keyId: z22.string(),
+  reason: z22.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/rotate.js
 import { randomBytes as randomBytes3 } from "crypto";
 import bcrypt6 from "bcryptjs";
-import { z as z24 } from "zod";
-var rotateUserApiKeySchema = z24.object({
-  keyId: z24.string()
+import { z as z23 } from "zod";
+var rotateUserApiKeySchema = z23.object({
+  keyId: z23.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/validate.js
@@ -3892,29 +3695,29 @@ var EVENT_GROUPS = [
 ];
 
 // ../../b4m-core/packages/services/dist/src/countersService/generateReport.js
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/countersService/getAllCounterFrom24Hours.js
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 import dayjs2 from "dayjs";
-var getCounterTotalsForLast24HoursSchema = z25.object({
-  date: z25.string(),
-  endDate: z25.string().optional()
+var getCounterTotalsForLast24HoursSchema = z24.object({
+  date: z24.string(),
+  endDate: z24.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/generateReport.js
-var generateDailyReportSchema = z26.object({
-  date: z26.string(),
-  startDate: z26.string().optional(),
-  endDate: z26.string().optional()
+var generateDailyReportSchema = z25.object({
+  date: z25.string(),
+  startDate: z25.string().optional(),
+  endDate: z25.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/incrementUserCounter.js
-import { z as z27 } from "zod";
-var incrementUserCounterSchema = z27.object({
-  action: z27.string(),
-  increment: z27.coerce.number().default(1).optional(),
-  metadata: z27.record(z27.unknown()).optional()
+import { z as z26 } from "zod";
+var incrementUserCounterSchema = z26.object({
+  action: z26.string(),
+  increment: z26.coerce.number().default(1).optional(),
+  metadata: z26.record(z26.unknown()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/sendSlackReport.js
@@ -3935,42 +3738,42 @@ import yauzl from "yauzl";
 import axios3 from "axios";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/importOpenaiHistory.js
-import { z as z28 } from "zod";
+import { z as z27 } from "zod";
 import last from "lodash/last.js";
-var epochDate = () => z28.preprocess((val) => new Date(Number(val) * 1e3), z28.date());
-var openaiConversationSchema = z28.object({
-  id: z28.string(),
-  title: z28.string(),
+var epochDate = () => z27.preprocess((val) => new Date(Number(val) * 1e3), z27.date());
+var openaiConversationSchema = z27.object({
+  id: z27.string(),
+  title: z27.string(),
   create_time: epochDate(),
   update_time: epochDate().nullable(),
-  mapping: z28.record(
-    z28.string(),
-    z28.object({
-      id: z28.string(),
-      parent: z28.string().nullable(),
-      children: z28.array(z28.string()),
-      message: z28.object({
-        id: z28.string(),
+  mapping: z27.record(
+    z27.string(),
+    z27.object({
+      id: z27.string(),
+      parent: z27.string().nullable(),
+      children: z27.array(z27.string()),
+      message: z27.object({
+        id: z27.string(),
         create_time: epochDate(),
         update_time: epochDate().nullable(),
-        author: z28.object({
-          role: z28.string(),
-          name: z28.string().nullable(),
-          metadata: z28.any()
+        author: z27.object({
+          role: z27.string(),
+          name: z27.string().nullable(),
+          metadata: z27.any()
           // Accept any metadata structure
         }).passthrough(),
         // Allow extra fields in author
-        content: z28.object({
-          content_type: z28.string(),
-          parts: z28.array(z28.any()).optional()
+        content: z27.object({
+          content_type: z27.string(),
+          parts: z27.array(z27.any()).optional()
           // Accept any type in parts array (strings, objects, etc.)
         }).passthrough(),
         // Allow extra fields in content
-        status: z28.string(),
-        end_turn: z28.boolean().nullable(),
-        metadata: z28.any(),
+        status: z27.string(),
+        end_turn: z27.boolean().nullable(),
+        metadata: z27.any(),
         // Accept any metadata structure since it varies widely
-        recipient: z28.string()
+        recipient: z27.string()
       }).passthrough().nullable()
     }).passthrough()
     // Allow extra fields in mapping node
@@ -3978,38 +3781,38 @@ var openaiConversationSchema = z28.object({
 }).passthrough();
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/importClaudeHistory.js
-import { z as z29 } from "zod";
-var claudeChatMessageSchema = z29.object({
-  uuid: z29.string().uuid(),
-  text: z29.string(),
-  content: z29.array(
-    z29.object({
-      type: z29.string(),
+import { z as z28 } from "zod";
+var claudeChatMessageSchema = z28.object({
+  uuid: z28.string().uuid(),
+  text: z28.string(),
+  content: z28.array(
+    z28.object({
+      type: z28.string(),
       // Accept any type: "text", "image", "tool_result", etc.
-      text: z29.string().optional()
+      text: z28.string().optional()
       // Make text optional since tool_result may not have it
     }).passthrough()
     // Allow all other fields
   ),
-  sender: z29.enum(["human", "assistant"]),
-  created_at: z29.coerce.date(),
-  updated_at: z29.coerce.date(),
-  attachments: z29.array(z29.any()),
+  sender: z28.enum(["human", "assistant"]),
+  created_at: z28.coerce.date(),
+  updated_at: z28.coerce.date(),
+  attachments: z28.array(z28.any()),
   // Accept any attachment structure
-  files: z29.array(z29.any())
+  files: z28.array(z28.any())
   // Accept any file structure
 }).passthrough();
-var claudeConversationSchema = z29.object({
-  uuid: z29.string().uuid(),
-  name: z29.string(),
-  summary: z29.string().optional(),
+var claudeConversationSchema = z28.object({
+  uuid: z28.string().uuid(),
+  name: z28.string(),
+  summary: z28.string().optional(),
   // Summary field is optional
-  created_at: z29.coerce.date(),
-  updated_at: z29.coerce.date(),
-  account: z29.object({
-    uuid: z29.string().uuid()
+  created_at: z28.coerce.date(),
+  updated_at: z28.coerce.date(),
+  account: z28.object({
+    uuid: z28.string().uuid()
   }),
-  chat_messages: z29.array(claudeChatMessageSchema)
+  chat_messages: z28.array(claudeChatMessageSchema)
 }).passthrough();
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
@@ -4020,357 +3823,357 @@ var ImportSource;
 })(ImportSource || (ImportSource = {}));
 
 // ../../b4m-core/packages/services/dist/src/sessionService/create.js
-import { z as z30 } from "zod";
-var createSessionParametersSchema = z30.object({
-  name: z30.string(),
-  knowledgeIds: z30.array(z30.string()).optional(),
-  artifactIds: z30.array(z30.string()).optional(),
-  agentIds: z30.array(z30.string()).optional(),
-  tags: z30.array(z30.object({ name: z30.string(), strength: z30.number() })).optional(),
-  summary: z30.string().optional(),
-  summaryAt: z30.date().optional(),
-  clonedSourceId: z30.string().optional().nullable(),
-  forkedSourceId: z30.string().optional().nullable(),
-  projectId: z30.string().optional(),
-  lastUsedModel: z30.string().optional().nullable()
+import { z as z29 } from "zod";
+var createSessionParametersSchema = z29.object({
+  name: z29.string(),
+  knowledgeIds: z29.array(z29.string()).optional(),
+  artifactIds: z29.array(z29.string()).optional(),
+  agentIds: z29.array(z29.string()).optional(),
+  tags: z29.array(z29.object({ name: z29.string(), strength: z29.number() })).optional(),
+  summary: z29.string().optional(),
+  summaryAt: z29.date().optional(),
+  clonedSourceId: z29.string().optional().nullable(),
+  forkedSourceId: z29.string().optional().nullable(),
+  projectId: z29.string().optional(),
+  lastUsedModel: z29.string().optional().nullable()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/delete.js
-import { z as z31 } from "zod";
-var deleteSessionSchema = z31.object({
-  id: z31.string()
+import { z as z30 } from "zod";
+var deleteSessionSchema = z30.object({
+  id: z30.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/sumarize.js
-import { z as z32 } from "zod";
-var sumarizeSessionSchema = z32.object({
-  id: z32.string()
+import { z as z31 } from "zod";
+var sumarizeSessionSchema = z31.object({
+  id: z31.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/create.js
-import { z as z33 } from "zod";
-var createProjectSchema = z33.object({
-  name: z33.string().min(1),
-  description: z33.string().min(1),
-  sessionIds: z33.array(z33.string()).optional(),
-  fileIds: z33.array(z33.string()).optional()
+import { z as z32 } from "zod";
+var createProjectSchema = z32.object({
+  name: z32.string().min(1),
+  description: z32.string().min(1),
+  sessionIds: z32.array(z32.string()).optional(),
+  fileIds: z32.array(z32.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/search.js
-import { z as z34 } from "zod";
-var searchProjectsSchema = z34.object({
-  search: z34.string().optional(),
-  filters: z34.object({
-    favorite: z34.coerce.boolean().optional(),
-    scope: z34.record(z34.any()).optional()
+import { z as z33 } from "zod";
+var searchProjectsSchema = z33.object({
+  search: z33.string().optional(),
+  filters: z33.object({
+    favorite: z33.coerce.boolean().optional(),
+    scope: z33.record(z33.any()).optional()
   }).optional(),
-  pagination: z34.object({
-    page: z34.coerce.number().optional(),
-    limit: z34.coerce.number().optional()
+  pagination: z33.object({
+    page: z33.coerce.number().optional(),
+    limit: z33.coerce.number().optional()
   }).optional(),
-  orderBy: z34.object({
-    by: z34.enum(["createdAt", "updatedAt"]).optional(),
-    direction: z34.enum(["asc", "desc"]).optional()
+  orderBy: z33.object({
+    by: z33.enum(["createdAt", "updatedAt"]).optional(),
+    direction: z33.enum(["asc", "desc"]).optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addSessions.js
-import { z as z45 } from "zod";
+import { z as z44 } from "zod";
 import uniq2 from "lodash/uniq.js";
 
 // ../../b4m-core/packages/services/dist/src/sharingService/accept.js
-import { z as z35 } from "zod";
-var acceptInviteSchema = z35.object({
-  id: z35.string()
+import { z as z34 } from "zod";
+var acceptInviteSchema = z34.object({
+  id: z34.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/cancel.js
-import { z as z36 } from "zod";
-var cancelInviteSchema = z36.object({
-  id: z36.string(),
-  type: z36.nativeEnum(InviteType),
-  email: z36.string().email().optional()
+import { z as z35 } from "zod";
+var cancelInviteSchema = z35.object({
+  id: z35.string(),
+  type: z35.nativeEnum(InviteType),
+  email: z35.string().email().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/cancelOwnDocument.js
-import { z as z37 } from "zod";
-var cancelOwnDocumentInvitesSchema = z37.object({
-  documentId: z37.string(),
-  type: z37.nativeEnum(InviteType)
+import { z as z36 } from "zod";
+var cancelOwnDocumentInvitesSchema = z36.object({
+  documentId: z36.string(),
+  type: z36.nativeEnum(InviteType)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/create.js
-import { z as z38 } from "zod";
+import { z as z37 } from "zod";
 var defaultExpiration = () => new Date((/* @__PURE__ */ new Date()).getFullYear() + 100, (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate());
 var DEFAULT_AVAILABLE = 1;
-var createInviteSchema = z38.object({
-  id: z38.string(),
-  type: z38.nativeEnum(InviteType),
-  permissions: z38.array(z38.nativeEnum(Permission)),
-  recipients: z38.string().array().optional(),
-  description: z38.string().optional(),
-  expiresAt: z38.date().optional().default(defaultExpiration()),
-  available: z38.number().optional().default(DEFAULT_AVAILABLE)
+var createInviteSchema = z37.object({
+  id: z37.string(),
+  type: z37.nativeEnum(InviteType),
+  permissions: z37.array(z37.nativeEnum(Permission)),
+  recipients: z37.string().array().optional(),
+  description: z37.string().optional(),
+  expiresAt: z37.date().optional().default(defaultExpiration()),
+  available: z37.number().optional().default(DEFAULT_AVAILABLE)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/get.js
-import { z as z39 } from "zod";
-var getInviteSchema = z39.object({
-  id: z39.string(),
-  withUsername: z39.boolean().optional()
+import { z as z38 } from "zod";
+var getInviteSchema = z38.object({
+  id: z38.string(),
+  withUsername: z38.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/listByDocumentIdAndType.js
-import { z as z40 } from "zod";
-var listInviteByDocumentIdAndTypeSchema = z40.object({
-  documentId: z40.string(),
-  type: z40.nativeEnum(InviteType)
+import { z as z39 } from "zod";
+var listInviteByDocumentIdAndTypeSchema = z39.object({
+  documentId: z39.string(),
+  type: z39.nativeEnum(InviteType)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/listOwnPending.js
-import { z as z41 } from "zod";
-var listOwnPendingInvitesSchema = z41.object({
-  limit: z41.number().min(1).max(100).default(20),
-  page: z41.number().min(1).default(1)
+import { z as z40 } from "zod";
+var listOwnPendingInvitesSchema = z40.object({
+  limit: z40.number().min(1).max(100).default(20),
+  page: z40.number().min(1).default(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/refuse.js
-import { z as z42 } from "zod";
-var refuseInviteSchema = z42.object({
-  id: z42.string()
+import { z as z41 } from "zod";
+var refuseInviteSchema = z41.object({
+  id: z41.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/revoke.js
-import { z as z43 } from "zod";
-var revokeSharingSchema = z43.object({
-  id: z43.string(),
-  type: z43.enum(["files", "sessions", "projects"]),
-  userId: z43.string(),
-  projectId: z43.string().optional()
+import { z as z42 } from "zod";
+var revokeSharingSchema = z42.object({
+  id: z42.string(),
+  type: z42.enum(["files", "sessions", "projects"]),
+  userId: z42.string(),
+  projectId: z42.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addFiles.js
-import { z as z44 } from "zod";
+import { z as z43 } from "zod";
 import uniq from "lodash/uniq.js";
-var addFilesProjectSchema = z44.object({
-  projectId: z44.string().nonempty(),
-  fileIds: z44.array(z44.string().nonempty())
+var addFilesProjectSchema = z43.object({
+  projectId: z43.string().nonempty(),
+  fileIds: z43.array(z43.string().nonempty())
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addSessions.js
-var addSessionsProjectSchema = z45.object({
-  projectId: z45.string().nonempty(),
-  sessionIds: z45.array(z45.string().nonempty())
+var addSessionsProjectSchema = z44.object({
+  projectId: z44.string().nonempty(),
+  sessionIds: z44.array(z44.string().nonempty())
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/get.js
-import { z as z46 } from "zod";
-var getProjectSchema = z46.object({
-  id: z46.string()
+import { z as z45 } from "zod";
+var getProjectSchema = z45.object({
+  id: z45.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/update.js
-import { z as z47 } from "zod";
-var updateProjectSchema = z47.object({
-  id: z47.string(),
-  name: z47.string().optional(),
-  description: z47.string().optional()
+import { z as z46 } from "zod";
+var updateProjectSchema = z46.object({
+  id: z46.string(),
+  name: z46.string().optional(),
+  description: z46.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/delete.js
-import { z as z48 } from "zod";
-var deleteProjectSchema = z48.object({
-  id: z48.string()
+import { z as z47 } from "zod";
+var deleteProjectSchema = z47.object({
+  id: z47.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/removeFiles.js
+import { z as z48 } from "zod";
+var removeProjectFilesSchema = z48.object({
+  projectId: z48.string(),
+  fileIds: z48.array(z48.string())
+});
+
+// ../../b4m-core/packages/services/dist/src/projectService/removeSessions.js
 import { z as z49 } from "zod";
-var removeProjectFilesSchema = z49.object({
+var removeProjectSessionsSchema = z49.object({
   projectId: z49.string(),
-  fileIds: z49.array(z49.string())
+  sessionIds: z49.array(z49.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeSessions.js
+// ../../b4m-core/packages/services/dist/src/projectService/listSessions.js
 import { z as z50 } from "zod";
-var removeProjectSessionsSchema = z50.object({
-  projectId: z50.string(),
-  sessionIds: z50.array(z50.string())
+var listProjectSessionsSchema = z50.object({
+  projectId: z50.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listSessions.js
+// ../../b4m-core/packages/services/dist/src/projectService/listFiles.js
 import { z as z51 } from "zod";
-var listProjectSessionsSchema = z51.object({
+var listProjectFilesSchema = z51.object({
   projectId: z51.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listFiles.js
+// ../../b4m-core/packages/services/dist/src/projectService/listInvites.js
 import { z as z52 } from "zod";
-var listProjectFilesSchema = z52.object({
-  projectId: z52.string()
+var listProjectInvitesParamsSchema = z52.object({
+  id: z52.string(),
+  statuses: z52.string().optional().default(""),
+  limit: z52.coerce.number().optional().default(10),
+  page: z52.coerce.number().optional().default(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listInvites.js
+// ../../b4m-core/packages/services/dist/src/projectService/addSystemPrompts.js
 import { z as z53 } from "zod";
-var listProjectInvitesParamsSchema = z53.object({
-  id: z53.string(),
-  statuses: z53.string().optional().default(""),
-  limit: z53.coerce.number().optional().default(10),
-  page: z53.coerce.number().optional().default(1)
+var addSystemPromptsSchema = z53.object({
+  projectId: z53.string(),
+  fileIds: z53.array(z53.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/addSystemPrompts.js
+// ../../b4m-core/packages/services/dist/src/projectService/toggleSystemPrompt.js
 import { z as z54 } from "zod";
-var addSystemPromptsSchema = z54.object({
+var toggleSystemPromptSchema = z54.object({
   projectId: z54.string(),
-  fileIds: z54.array(z54.string())
+  fileId: z54.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/toggleSystemPrompt.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeSystemPrompt.js
 import { z as z55 } from "zod";
-var toggleSystemPromptSchema = z55.object({
+var removeSystemPromptSchema = z55.object({
   projectId: z55.string(),
   fileId: z55.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeSystemPrompt.js
-import { z as z56 } from "zod";
-var removeSystemPromptSchema = z56.object({
-  projectId: z56.string(),
-  fileId: z56.string()
-});
-
 // ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
-import { z as z59 } from "zod";
+import { z as z58 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/favoriteService/create.js
-import { z as z57 } from "zod";
-var createFavoriteParametersSchema = z57.object({
-  documentId: z57.string(),
-  documentType: z57.nativeEnum(FavoriteDocumentType)
+import { z as z56 } from "zod";
+var createFavoriteParametersSchema = z56.object({
+  documentId: z56.string(),
+  documentType: z56.nativeEnum(FavoriteDocumentType)
 });
 
 // ../../b4m-core/packages/services/dist/src/favoriteService/delete.js
-import { z as z58 } from "zod";
-var deleteFavoriteParametersSchema = z58.object({
-  documentId: z58.string(),
-  documentType: z58.nativeEnum(FavoriteDocumentType)
+import { z as z57 } from "zod";
+var deleteFavoriteParametersSchema = z57.object({
+  documentId: z57.string(),
+  documentType: z57.nativeEnum(FavoriteDocumentType)
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
-var addFavoriteParametersSchema = z59.object({
-  projectId: z59.string()
+var addFavoriteParametersSchema = z58.object({
+  projectId: z58.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/deleteFavorite.js
-import { z as z60 } from "zod";
-var deleteFavoriteParametersSchema2 = z60.object({
-  projectId: z60.string()
+import { z as z59 } from "zod";
+var deleteFavoriteParametersSchema2 = z59.object({
+  projectId: z59.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/removeNonExistentFiles.js
-import { z as z61 } from "zod";
-var removeNonExistentFilesSchema = z61.object({
-  projectId: z61.string()
+import { z as z60 } from "zod";
+var removeNonExistentFilesSchema = z60.object({
+  projectId: z60.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/leaveProject.js
-import { z as z62 } from "zod";
-var leaveProjectParamsSchema = z62.object({
-  id: z62.string(),
-  userIdToRemove: z62.string().optional()
+import { z as z61 } from "zod";
+var leaveProjectParamsSchema = z61.object({
+  id: z61.string(),
+  userIdToRemove: z61.string().optional()
   // Optional: if provided, this is a removal by owner
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/update.js
 import uniq3 from "lodash/uniq.js";
 import isEqual from "lodash/isEqual.js";
-import { z as z63 } from "zod";
-var updateSessionParamtersSchema = z63.object({
-  id: z63.string(),
-  name: z63.string().optional(),
-  knowledgeIds: z63.array(z63.string()).optional(),
-  artifactIds: z63.array(z63.string()).optional(),
-  tags: z63.array(z63.object({ name: z63.string(), strength: z63.number() })).optional(),
-  lastUsedModel: z63.string().optional()
+import { z as z62 } from "zod";
+var updateSessionParamtersSchema = z62.object({
+  id: z62.string(),
+  name: z62.string().optional(),
+  knowledgeIds: z62.array(z62.string()).optional(),
+  artifactIds: z62.array(z62.string()).optional(),
+  tags: z62.array(z62.object({ name: z62.string(), strength: z62.number() })).optional(),
+  lastUsedModel: z62.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/clone.js
-import { z as z64 } from "zod";
-var cloneSessionSchema = z64.object({
-  id: z64.string()
+import { z as z63 } from "zod";
+var cloneSessionSchema = z63.object({
+  id: z63.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/fork.js
+import { z as z64 } from "zod";
+var forkSessionSchema = z64.object({
+  sessionId: z64.string(),
+  messageId: z64.string()
+});
+
+// ../../b4m-core/packages/services/dist/src/sessionService/snip.js
 import { z as z65 } from "zod";
-var forkSessionSchema = z65.object({
+var snipSessionSchema = z65.object({
   sessionId: z65.string(),
   messageId: z65.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/snip.js
+// ../../b4m-core/packages/services/dist/src/sessionService/get.js
 import { z as z66 } from "zod";
-var snipSessionSchema = z66.object({
-  sessionId: z66.string(),
-  messageId: z66.string()
+var getSessionSchema = z66.object({
+  id: z66.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/get.js
+// ../../b4m-core/packages/services/dist/src/sessionService/deleteMessage.js
 import { z as z67 } from "zod";
-var getSessionSchema = z67.object({
-  id: z67.string()
+var deleteSessionMessageSchema = z67.object({
+  sessionId: z67.string(),
+  messageId: z67.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/deleteMessage.js
+// ../../b4m-core/packages/services/dist/src/sessionService/addFavorite.js
 import { z as z68 } from "zod";
-var deleteSessionMessageSchema = z68.object({
-  sessionId: z68.string(),
-  messageId: z68.string()
+var addFavoriteParametersSchema2 = z68.object({
+  sessionId: z68.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/addFavorite.js
+// ../../b4m-core/packages/services/dist/src/sessionService/deleteFavorite.js
 import { z as z69 } from "zod";
-var addFavoriteParametersSchema2 = z69.object({
+var deleteFavoriteParametersSchema3 = z69.object({
   sessionId: z69.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/deleteFavorite.js
-import { z as z70 } from "zod";
-var deleteFavoriteParametersSchema3 = z70.object({
-  sessionId: z70.string()
-});
-
 // ../../b4m-core/packages/services/dist/src/sessionService/autoName.js
-import { z as z71 } from "zod";
-var autoNameParameterSchema = z71.object({
-  sessionId: z71.string(),
+import { z as z70 } from "zod";
+var autoNameParameterSchema = z70.object({
+  sessionId: z70.string(),
   /** The maximum number of words to include in the title */
-  maxWords: z71.number().optional()
+  maxWords: z70.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/search.js
-import { z as z72 } from "zod";
-var searchSchema2 = z72.object({
+import { z as z71 } from "zod";
+var searchSchema2 = z71.object({
   /**
    * Text search query (searches in name and description)
    */
-  query: z72.string().optional(),
+  query: z71.string().optional(),
   /**
    * Filter by personal organizations
    */
-  filters: z72.object({
-    personal: z72.union([z72.enum(["true", "false"]).transform((val) => val === "true"), z72.boolean()]).optional(),
-    userId: z72.string().optional()
+  filters: z71.object({
+    personal: z71.union([z71.enum(["true", "false"]).transform((val) => val === "true"), z71.boolean()]).optional(),
+    userId: z71.string().optional()
   }).default({}),
-  pagination: z72.object({
-    page: z72.coerce.number().int().positive().default(1),
-    limit: z72.coerce.number().int().positive().max(100).default(10)
+  pagination: z71.object({
+    page: z71.coerce.number().int().positive().default(1),
+    limit: z71.coerce.number().int().positive().max(100).default(10)
   }).default({
     page: 1,
     limit: 10
   }),
-  orderBy: z72.object({
-    field: z72.enum(["name", "createdAt", "updatedAt"]).default("name"),
-    direction: z72.enum(["asc", "desc"]).default("asc")
+  orderBy: z71.object({
+    field: z71.enum(["name", "createdAt", "updatedAt"]).default("name"),
+    direction: z71.enum(["asc", "desc"]).default("asc")
   }).default({
     field: "name",
     direction: "asc"
@@ -4378,357 +4181,357 @@ var searchSchema2 = z72.object({
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/get.js
-import { z as z73 } from "zod";
-var getSchema = z73.object({
+import { z as z72 } from "zod";
+var getSchema = z72.object({
   /**
    * Organization ID
    */
-  id: z73.string().min(1)
+  id: z72.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/addMember.js
-import { z as z74 } from "zod";
-var addMemberSchema = z74.object({
-  userId: z74.string().optional(),
-  email: z74.string().optional(),
-  organizationId: z74.string(),
-  force: z74.boolean().optional()
+import { z as z73 } from "zod";
+var addMemberSchema = z73.object({
+  userId: z73.string().optional(),
+  email: z73.string().optional(),
+  organizationId: z73.string(),
+  force: z73.boolean().optional()
   // If true, add the user to the organization even if it's at full capacity
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/getUsers.js
-import { z as z75 } from "zod";
-var getUsersSchema = z75.object({
-  id: z75.string()
+import { z as z74 } from "zod";
+var getUsersSchema = z74.object({
+  id: z74.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/create.js
-import { z as z76 } from "zod";
-var createSchema = z76.object({
-  name: z76.string(),
-  personal: z76.boolean().default(false),
-  seats: z76.number().default(1),
-  stripeCustomerId: z76.string().nullable(),
-  billingOwnerId: z76.string().optional(),
+import { z as z75 } from "zod";
+var createSchema = z75.object({
+  name: z75.string(),
+  personal: z75.boolean().default(false),
+  seats: z75.number().default(1),
+  stripeCustomerId: z75.string().nullable(),
+  billingOwnerId: z75.string().optional(),
   // Optional billing owner (defaults to user if not provided)
-  managerId: z76.string().optional()
+  managerId: z75.string().optional()
   // Optional team manager
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/update.js
-import { z as z77 } from "zod";
-var updateSchema = z77.object({
-  id: z77.string(),
-  name: z77.string().optional(),
-  description: z77.string().optional(),
-  billingContact: z77.string().optional(),
-  currentCredits: z77.coerce.number().optional(),
-  systemPrompt: z77.string().max(1e4).optional()
+import { z as z76 } from "zod";
+var updateSchema = z76.object({
+  id: z76.string(),
+  name: z76.string().optional(),
+  description: z76.string().optional(),
+  billingContact: z76.string().optional(),
+  currentCredits: z76.coerce.number().optional(),
+  systemPrompt: z76.string().max(1e4).optional()
   // ~2500 tokens
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/delete.js
-import { z as z78 } from "zod";
-var deleteSchema = z78.object({
+import { z as z77 } from "zod";
+var deleteSchema = z77.object({
   /**
    * Organization ID
    */
-  id: z78.string().min(1)
+  id: z77.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/listPendingUsers.js
-import { z as z79 } from "zod";
-var listPendingUsersSchema = z79.object({
-  organizationId: z79.string()
+import { z as z78 } from "zod";
+var listPendingUsersSchema = z78.object({
+  organizationId: z78.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/revokeAccess.js
-import { z as z80 } from "zod";
-var revokeAccessSchema = z80.object({
-  id: z80.string(),
-  userId: z80.string()
+import { z as z79 } from "zod";
+var revokeAccessSchema = z79.object({
+  id: z79.string(),
+  userId: z79.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/leave.js
-import { z as z81 } from "zod";
-var organizationLeaveSchema = z81.object({
-  id: z81.string()
+import { z as z80 } from "zod";
+var organizationLeaveSchema = z80.object({
+  id: z80.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/create.js
-import { z as z82 } from "zod";
-var createApiKeySchema = z82.object({
-  apiKey: z82.string().min(6),
-  description: z82.string().optional().default(""),
-  isActive: z82.boolean().optional().default(true),
-  type: z82.nativeEnum(ApiKeyType),
-  expireDays: z82.number().min(1).max(365).default(90)
+import { z as z81 } from "zod";
+var createApiKeySchema = z81.object({
+  apiKey: z81.string().min(6),
+  description: z81.string().optional().default(""),
+  isActive: z81.boolean().optional().default(true),
+  type: z81.nativeEnum(ApiKeyType),
+  expireDays: z81.number().min(1).max(365).default(90)
   // Default 90-day expiration
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/set.js
-import { z as z83 } from "zod";
-var setApiKeySchema = z83.object({
-  id: z83.string(),
-  type: z83.nativeEnum(ApiKeyType)
+import { z as z82 } from "zod";
+var setApiKeySchema = z82.object({
+  id: z82.string(),
+  type: z82.nativeEnum(ApiKeyType)
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/delete.js
-import { z as z84 } from "zod";
-var deleteApiKeySchema = z84.object({
-  id: z84.string()
+import { z as z83 } from "zod";
+var deleteApiKeySchema = z83.object({
+  id: z83.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/get.js
-import { z as z85 } from "zod";
-var getFabFileSchema = z85.object({
-  id: z85.string()
+import { z as z84 } from "zod";
+var getFabFileSchema = z84.object({
+  id: z84.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/list.js
-import { z as z86 } from "zod";
-var listFabFilesSchema = z86.object({
-  ids: z86.array(z86.string()).optional()
+import { z as z85 } from "zod";
+var listFabFilesSchema = z85.object({
+  ids: z85.array(z85.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/update.js
 import mime from "mime-types";
 import { v4 as uuidv42 } from "uuid";
-import { z as z87 } from "zod";
-var updateFabFileSchema = z87.object({
-  id: z87.string(),
-  fileName: z87.string().optional(),
-  mimeType: z87.string().optional(),
-  fileContent: z87.string().optional(),
-  type: z87.nativeEnum(KnowledgeType).optional(),
-  system: z87.boolean().optional(),
-  systemPriority: z87.number().min(0).max(999).optional(),
-  sessionId: z87.string().optional(),
-  notes: z87.string().optional(),
-  primaryTag: z87.string().optional(),
-  tags: z87.array(z87.object({
-    name: z87.string(),
-    strength: z87.number()
+import { z as z86 } from "zod";
+var updateFabFileSchema = z86.object({
+  id: z86.string(),
+  fileName: z86.string().optional(),
+  mimeType: z86.string().optional(),
+  fileContent: z86.string().optional(),
+  type: z86.nativeEnum(KnowledgeType).optional(),
+  system: z86.boolean().optional(),
+  systemPriority: z86.number().min(0).max(999).optional(),
+  sessionId: z86.string().optional(),
+  notes: z86.string().optional(),
+  primaryTag: z86.string().optional(),
+  tags: z86.array(z86.object({
+    name: z86.string(),
+    strength: z86.number()
   })).optional(),
-  error: z87.string().nullable().optional()
+  error: z86.string().nullable().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/delete.js
-import { z as z88 } from "zod";
-var deleteFabFileSchema = z88.object({
-  id: z88.string()
+import { z as z87 } from "zod";
+var deleteFabFileSchema = z87.object({
+  id: z87.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/chunk.js
-import { z as z89 } from "zod";
-var chunkFileSchema = z89.object({
-  fabFileId: z89.string(),
-  embeddingModel: z89.string()
+import { z as z88 } from "zod";
+var chunkFileSchema = z88.object({
+  fabFileId: z88.string(),
+  embeddingModel: z88.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/vectorize.js
-import { z as z90 } from "zod";
-var vectorizeFabFileChunkSchema = z90.object({
-  fabFileId: z90.string(),
-  chunkId: z90.string()
+import { z as z89 } from "zod";
+var vectorizeFabFileChunkSchema = z89.object({
+  fabFileId: z89.string(),
+  chunkId: z89.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/listBySession.js
-import { z as z91 } from "zod";
-var listFabFilesBySessionSchema = z91.object({
-  sessionId: z91.string()
+import { z as z90 } from "zod";
+var listFabFilesBySessionSchema = z90.object({
+  sessionId: z90.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/listByQuest.js
-import { z as z92 } from "zod";
-var listFabFilesByQuestSchema = z92.object({
-  questId: z92.string()
+import { z as z91 } from "zod";
+var listFabFilesByQuestSchema = z91.object({
+  questId: z91.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/createByUrl.js
-import { z as z93 } from "zod";
-var createFabFileByUrlSchema = z93.object({
-  url: z93.string().regex(/^(?!https?:\/\/(drive|docs)\.google\.com\/(?:file\/d\/|open\?id=|uc\?id=|document\/d\/|spreadsheets\/d\/|presentation\/d\/|forms\/d\/|drive\/folders\/)([a-zA-Z0-9_-]{10,})).+/)
+import { z as z92 } from "zod";
+var createFabFileByUrlSchema = z92.object({
+  url: z92.string().regex(/^(?!https?:\/\/(drive|docs)\.google\.com\/(?:file\/d\/|open\?id=|uc\?id=|document\/d\/|spreadsheets\/d\/|presentation\/d\/|forms\/d\/|drive\/folders\/)([a-zA-Z0-9_-]{10,})).+/)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/search.js
-import { z as z94 } from "zod";
-var searchFabFilesSchema = z94.object({
-  search: z94.string().optional(),
-  filters: z94.object({
-    tags: z94.array(z94.string()).optional(),
-    type: z94.enum(["text", "pdf", "url", "image", "excel", "word", "json", "csv", "markdown", "code"]).optional(),
-    shared: z94.coerce.boolean().optional(),
+import { z as z93 } from "zod";
+var searchFabFilesSchema = z93.object({
+  search: z93.string().optional(),
+  filters: z93.object({
+    tags: z93.array(z93.string()).optional(),
+    type: z93.enum(["text", "pdf", "url", "image", "excel", "word", "json", "csv", "markdown", "code"]).optional(),
+    shared: z93.coerce.boolean().optional(),
     // Indicates if the user is searching for shared files
-    curated: z94.coerce.boolean().optional(),
+    curated: z93.coerce.boolean().optional(),
     // Indicates if the user is searching for curated notebook files
-    projectId: z94.string().optional(),
-    ids: z94.array(z94.string()).optional()
+    projectId: z93.string().optional(),
+    ids: z93.array(z93.string()).optional()
     // Add support for filtering by IDs
   }).optional(),
-  pagination: z94.object({
-    page: z94.coerce.number(),
-    limit: z94.coerce.number()
+  pagination: z93.object({
+    page: z93.coerce.number(),
+    limit: z93.coerce.number()
   }).optional(),
-  order: z94.object({
-    by: z94.enum(["createdAt", "fileName", "fileSize"]),
-    direction: z94.enum(["asc", "desc"])
+  order: z93.object({
+    by: z93.enum(["createdAt", "fileName", "fileSize"]),
+    direction: z93.enum(["asc", "desc"])
   }).optional(),
-  options: z94.object({
-    includeShared: z94.coerce.boolean().optional()
+  options: z93.object({
+    includeShared: z93.coerce.boolean().optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/addFavorite.js
-import { z as z95 } from "zod";
-var addFavoriteParametersSchema3 = z95.object({
-  fileId: z95.string()
+import { z as z94 } from "zod";
+var addFavoriteParametersSchema3 = z94.object({
+  fileId: z94.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/deleteFavorite.js
-import { z as z96 } from "zod";
-var deleteFavoriteParametersSchema4 = z96.object({
-  fileId: z96.string()
+import { z as z95 } from "zod";
+var deleteFavoriteParametersSchema4 = z95.object({
+  fileId: z95.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/toggleTags.js
-import { z as z97 } from "zod";
-var fabFileToggleTagsSchema = z97.object({
-  ids: z97.array(z97.string()),
-  tags: z97.array(z97.string())
+import { z as z96 } from "zod";
+var fabFileToggleTagsSchema = z96.object({
+  ids: z96.array(z96.string()),
+  tags: z96.array(z96.string())
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/edit.js
-import { z as z98 } from "zod";
+import { z as z97 } from "zod";
 import { diffLines } from "diff";
-var editFabFileSchema = z98.object({
-  id: z98.string(),
-  instruction: z98.string(),
-  selection: z98.object({
-    start: z98.number(),
-    end: z98.number()
+var editFabFileSchema = z97.object({
+  id: z97.string(),
+  instruction: z97.string(),
+  selection: z97.object({
+    start: z97.number(),
+    end: z97.number()
   }).optional(),
-  preserveFormatting: z98.boolean().optional().default(true),
-  applyImmediately: z98.boolean().optional().default(false)
+  preserveFormatting: z97.boolean().optional().default(true),
+  applyImmediately: z97.boolean().optional().default(false)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/applyEdit.js
 import mime2 from "mime-types";
 import { v4 as uuidv43 } from "uuid";
-import { z as z99 } from "zod";
-var applyEditSchema = z99.object({
-  id: z99.string(),
-  modifiedContent: z99.string(),
-  createBackup: z99.boolean().optional().default(true)
+import { z as z98 } from "zod";
+var applyEditSchema = z98.object({
+  id: z98.string(),
+  modifiedContent: z98.string(),
+  createBackup: z98.boolean().optional().default(true)
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/respondToFriendRequest.js
-import { z as z100 } from "zod";
-var respondToFriendRequestSchema = z100.object({
-  id: z100.string(),
+import { z as z99 } from "zod";
+var respondToFriendRequestSchema = z99.object({
+  id: z99.string(),
   /** The user ID of the recipient of the friend request */
-  userId: z100.string(),
-  accept: z100.boolean()
+  userId: z99.string(),
+  accept: z99.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/unfriend.js
-import { z as z101 } from "zod";
-var unfriendSchema = z101.object({
-  friendshipId: z101.string(),
+import { z as z100 } from "zod";
+var unfriendSchema = z100.object({
+  friendshipId: z100.string(),
   /** The user ID of the user who wants to unfriend the other user */
-  userId: z101.string()
+  userId: z100.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/list.js
-import { z as z102 } from "zod";
-var listFriendsSchema = z102.object({
-  userId: z102.string()
+import { z as z101 } from "zod";
+var listFriendsSchema = z101.object({
+  userId: z101.string()
 });
-var listPendingFriendRequestsSchema = z102.object({
-  userId: z102.string()
+var listPendingFriendRequestsSchema = z101.object({
+  userId: z101.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/adminService/loginAs.js
-import { z as z103 } from "zod";
-var loginAsSchema = z103.object({
-  targetUserId: z103.string()
+import { z as z102 } from "zod";
+var loginAsSchema = z102.object({
+  targetUserId: z102.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/get.js
-import { z as z104 } from "zod";
-var getParamsSchema = z104.object({
-  key: z104.string()
+import { z as z103 } from "zod";
+var getParamsSchema = z103.object({
+  key: z103.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/set.js
-import { z as z105 } from "zod";
-var setParamsSchema = z105.object({
-  key: z105.string(),
-  value: z105.any(),
+import { z as z104 } from "zod";
+var setParamsSchema = z104.object({
+  key: z104.string(),
+  value: z104.any(),
   /**
    * Time to live in milliseconds
    */
-  ttl: z105.number(),
-  recache: z105.boolean().optional()
+  ttl: z104.number(),
+  recache: z104.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/ttl.js
-import { z as z106 } from "zod";
-var ttlParamsSchema = z106.object({
-  key: z106.string()
+import { z as z105 } from "zod";
+var ttlParamsSchema = z105.object({
+  key: z105.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/weeklyReports.js
-import { z as z107 } from "zod";
+import { z as z106 } from "zod";
 import dayjs3 from "dayjs";
-var weeklyReportSchema = z107.object({
-  startDate: z107.string(),
-  endDate: z107.string(),
-  report: z107.string(),
-  aiInsights: z107.string().nullable()
+var weeklyReportSchema = z106.object({
+  startDate: z106.string(),
+  endDate: z106.string(),
+  report: z106.string(),
+  aiInsights: z106.string().nullable()
 });
 
 // ../../b4m-core/packages/services/dist/src/embeddingCacheService/generateCacheKey.js
 import crypto2 from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/researchAgentService/create.js
+import { z as z107 } from "zod";
+var researchAgentCreateSchema = z107.object({
+  name: z107.string().min(1),
+  description: z107.string().min(1)
+});
+
+// ../../b4m-core/packages/services/dist/src/researchAgentService/update.js
 import { z as z108 } from "zod";
-var researchAgentCreateSchema = z108.object({
+var researchAgentUpdateSchema = z108.object({
+  id: z108.string(),
   name: z108.string().min(1),
   description: z108.string().min(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/update.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
 import { z as z109 } from "zod";
-var researchAgentUpdateSchema = z109.object({
-  id: z109.string(),
-  name: z109.string().min(1),
-  description: z109.string().min(1)
+var researchAgentRemoveSchema = z109.object({
+  id: z109.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
 import { z as z110 } from "zod";
-var researchAgentRemoveSchema = z110.object({
+var researchAgentGetSchema = z110.object({
   id: z110.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
-import { z as z111 } from "zod";
-var researchAgentGetSchema = z111.object({
-  id: z111.string()
-});
-
 // ../../b4m-core/packages/services/dist/src/researchAgentService/listFiles.js
-import { z as z112 } from "zod";
-var researchAgentListFilesSchema = z112.object({
+import { z as z111 } from "zod";
+var researchAgentListFilesSchema = z111.object({
   /**
    * The ID of the research agent
    */
-  id: z112.string()
+  id: z111.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-import { z as z113 } from "zod";
+import { z as z112 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/lib/turndown.js
 import turndown from "turndown";
@@ -5119,316 +4922,316 @@ var deepResearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-var ResearchTaskProcessSchema = z113.object({
-  id: z113.string()
+var ResearchTaskProcessSchema = z112.object({
+  id: z112.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/create.js
-import { z as z114 } from "zod";
-var researchTaskCreateSchema = z114.object({
-  researchAgentId: z114.string(),
-  title: z114.string().max(100),
-  description: z114.string().max(500),
-  prompt: z114.string().max(500).optional(),
-  type: z114.nativeEnum(ResearchTaskType),
-  executionType: z114.nativeEnum(ResearchTaskExecutionType).default(ResearchTaskExecutionType.ON_DEMAND),
-  fileTagId: z114.string().optional(),
-  autoGeneratedTag: z114.object({
-    name: z114.string(),
-    icon: z114.string(),
-    color: z114.string()
+import { z as z113 } from "zod";
+var researchTaskCreateSchema = z113.object({
+  researchAgentId: z113.string(),
+  title: z113.string().max(100),
+  description: z113.string().max(500),
+  prompt: z113.string().max(500).optional(),
+  type: z113.nativeEnum(ResearchTaskType),
+  executionType: z113.nativeEnum(ResearchTaskExecutionType).default(ResearchTaskExecutionType.ON_DEMAND),
+  fileTagId: z113.string().optional(),
+  autoGeneratedTag: z113.object({
+    name: z113.string(),
+    icon: z113.string(),
+    color: z113.string()
   }).optional()
 });
 var researchTaskScrapeCreateSchema = researchTaskCreateSchema.extend({
-  urls: z114.array(z114.string().url()).min(1),
-  canDiscoverLinks: z114.boolean()
+  urls: z113.array(z113.string().url()).min(1),
+  canDiscoverLinks: z113.boolean()
 });
 var researchTaskPeriodicCreateSchema = researchTaskCreateSchema.extend({
-  executionPeriodicStartAt: z114.coerce.date(),
-  executionPeriodicEndAt: z114.coerce.date(),
-  executionPeriodicFrequency: z114.nativeEnum(ResearchTaskPeriodicFrequencyType)
+  executionPeriodicStartAt: z113.coerce.date(),
+  executionPeriodicEndAt: z113.coerce.date(),
+  executionPeriodicFrequency: z113.nativeEnum(ResearchTaskPeriodicFrequencyType)
 });
 var researchTaskScheduledCreateSchema = researchTaskCreateSchema.extend({
-  executionScheduledAt: z114.coerce.date()
+  executionScheduledAt: z113.coerce.date()
 });
 var researchTaskDeepResearchCreateSchema = researchTaskCreateSchema.extend({
-  maxDepth: z114.number().min(1).max(10).optional()
+  maxDepth: z113.number().min(1).max(10).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/search.js
-import { z as z115 } from "zod";
-var searchResearchTasksSchema = z115.object({
-  search: z115.string().optional(),
+import { z as z114 } from "zod";
+var searchResearchTasksSchema = z114.object({
+  search: z114.string().optional(),
   // ADD FILTERS SCHEMA HERE
   // filters: z
   //   .object({
   //     userId: z.string().optional(),
   //   })
   //   .optional(),
-  pagination: z115.object({
-    page: z115.coerce.number().optional(),
-    limit: z115.coerce.number().optional()
+  pagination: z114.object({
+    page: z114.coerce.number().optional(),
+    limit: z114.coerce.number().optional()
   }).optional(),
-  orderBy: z115.object({
-    by: z115.enum(["createdAt", "updatedAt"]).optional(),
-    direction: z115.enum(["asc", "desc"]).optional()
+  orderBy: z114.object({
+    by: z114.enum(["createdAt", "updatedAt"]).optional(),
+    direction: z114.enum(["asc", "desc"]).optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/get.js
-import { z as z116 } from "zod";
-var getResearchTaskSchema = z116.object({
-  id: z116.string().min(1)
+import { z as z115 } from "zod";
+var getResearchTaskSchema = z115.object({
+  id: z115.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/update.js
-import { z as z117 } from "zod";
-var updateResearchTaskSchema = z117.object({
-  id: z117.string(),
-  title: z117.string(),
-  description: z117.string(),
-  type: z117.nativeEnum(ResearchTaskType)
+import { z as z116 } from "zod";
+var updateResearchTaskSchema = z116.object({
+  id: z116.string(),
+  title: z116.string(),
+  description: z116.string(),
+  type: z116.nativeEnum(ResearchTaskType)
 });
 var researchTaskScrapeUpdateSchema = updateResearchTaskSchema.extend({
-  urls: z117.array(z117.string().url()).min(1),
-  canDiscoverLinks: z117.boolean()
+  urls: z116.array(z116.string().url()).min(1),
+  canDiscoverLinks: z116.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/listByAgentId.js
-import { z as z118 } from "zod";
-var listByAgentIdSchema = z118.object({
-  researchAgentId: z118.string()
+import { z as z117 } from "zod";
+var listByAgentIdSchema = z117.object({
+  researchAgentId: z117.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/remove.js
-import { z as z119 } from "zod";
-var researchTaskRemoveSchema = z119.object({
-  id: z119.string().min(1)
+import { z as z118 } from "zod";
+var researchTaskRemoveSchema = z118.object({
+  id: z118.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/retry.js
-import { z as z120 } from "zod";
-var researchTaskRetrySchema = z120.object({
-  id: z120.string(),
-  userId: z120.string()
+import { z as z119 } from "zod";
+var researchTaskRetrySchema = z119.object({
+  id: z119.string(),
+  userId: z119.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/processDiscoveredLinks.js
 import axios4 from "axios";
-import { z as z121 } from "zod";
+import { z as z120 } from "zod";
 import plimit from "p-limit";
 import pLimit2 from "p-limit";
-var researchTaskProcessDiscoveredLinksSchema = z121.object({
-  id: z121.string()
+var researchTaskProcessDiscoveredLinksSchema = z120.object({
+  id: z120.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/downloadRelevantLinks.js
-import { z as z122 } from "zod";
+import { z as z121 } from "zod";
 import plimit2 from "p-limit";
 import axios5 from "axios";
 import { fileTypeFromBuffer } from "file-type";
-var researchTaskDownloadRelevantLinksSchema = z122.object({
-  id: z122.string()
+var researchTaskDownloadRelevantLinksSchema = z121.object({
+  id: z121.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchData/remove.js
-import { z as z123 } from "zod";
-var researchDataRemoveSchema = z123.object({
-  id: z123.string(),
-  researchAgentId: z123.string()
+import { z as z122 } from "zod";
+var researchDataRemoveSchema = z122.object({
+  id: z122.string(),
+  researchAgentId: z122.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/taskSchedulerService/create.js
-import { z as z124 } from "zod";
-var researchTaskPayload = z124.object({
-  id: z124.string(),
-  userId: z124.string()
+import { z as z123 } from "zod";
+var researchTaskPayload = z123.object({
+  id: z123.string(),
+  userId: z123.string()
 });
-var customTaskPayload = z124.object({
-  test: z124.string()
+var customTaskPayload = z123.object({
+  test: z123.string()
 });
-var taskSchedulerCreate = z124.discriminatedUnion("handler", [
-  z124.object({
-    handler: z124.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
+var taskSchedulerCreate = z123.discriminatedUnion("handler", [
+  z123.object({
+    handler: z123.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
     payload: researchTaskPayload,
-    processDate: z124.date()
+    processDate: z123.date()
   }),
-  z124.object({
-    handler: z124.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
+  z123.object({
+    handler: z123.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
     payload: customTaskPayload,
-    processDate: z124.date()
+    processDate: z123.date()
   })
 ]);
 
 // ../../b4m-core/packages/services/dist/src/tagService/createFileTag.js
+import { z as z124 } from "zod";
+var tagCreateFileTagSchema = z124.object({
+  name: z124.string(),
+  icon: z124.string().optional(),
+  color: z124.string().optional(),
+  description: z124.string().optional()
+});
+
+// ../../b4m-core/packages/services/dist/src/tagService/create.js
 import { z as z125 } from "zod";
-var tagCreateFileTagSchema = z125.object({
+var tagCreateSchema = z125.object({
   name: z125.string(),
   icon: z125.string().optional(),
+  description: z125.string().optional(),
   color: z125.string().optional(),
-  description: z125.string().optional()
+  type: z125.nativeEnum(TagType)
 });
 
-// ../../b4m-core/packages/services/dist/src/tagService/create.js
+// ../../b4m-core/packages/services/dist/src/tagService/update.js
 import { z as z126 } from "zod";
-var tagCreateSchema = z126.object({
-  name: z126.string(),
+var tagUpdateSchema = z126.object({
+  id: z126.string(),
+  name: z126.string().optional(),
   icon: z126.string().optional(),
   description: z126.string().optional(),
-  color: z126.string().optional(),
-  type: z126.nativeEnum(TagType)
-});
-
-// ../../b4m-core/packages/services/dist/src/tagService/update.js
-import { z as z127 } from "zod";
-var tagUpdateSchema = z127.object({
-  id: z127.string(),
-  name: z127.string().optional(),
-  icon: z127.string().optional(),
-  description: z127.string().optional(),
-  color: z127.string().optional()
+  color: z126.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/tagService/remove.js
-import { z as z128 } from "zod";
-var tagRemoveSchema = z128.object({
-  id: z128.string()
+import { z as z127 } from "zod";
+var tagRemoveSchema = z127.object({
+  id: z127.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/create.js
-import { z as z129 } from "zod";
-var createArtifactSchema = z129.object({
-  id: z129.string().optional(),
+import { z as z128 } from "zod";
+var createArtifactSchema = z128.object({
+  id: z128.string().optional(),
   // Allow custom ID for AI-generated artifacts
-  type: z129.enum(["mermaid", "recharts", "python", "react", "html", "svg", "code", "quest", "file", "questmaster"]),
-  title: z129.string().min(1).max(255),
-  description: z129.string().max(1e3).optional(),
-  content: z129.string().min(1),
-  projectId: z129.string().optional(),
-  organizationId: z129.string().optional(),
-  visibility: z129.enum(["private", "project", "organization", "public"]).default("private"),
-  tags: z129.array(z129.string().max(50)).max(20).default([]),
-  versionTag: z129.string().max(100).optional(),
-  sourceQuestId: z129.string().optional(),
-  sessionId: z129.string().optional(),
-  parentArtifactId: z129.string().optional(),
-  permissions: z129.object({
-    canRead: z129.array(z129.string()).default([]),
-    canWrite: z129.array(z129.string()).default([]),
-    canDelete: z129.array(z129.string()).default([]),
-    isPublic: z129.boolean().default(false),
-    inheritFromProject: z129.boolean().default(true)
+  type: z128.enum(["mermaid", "recharts", "python", "react", "html", "svg", "code", "quest", "file", "questmaster"]),
+  title: z128.string().min(1).max(255),
+  description: z128.string().max(1e3).optional(),
+  content: z128.string().min(1),
+  projectId: z128.string().optional(),
+  organizationId: z128.string().optional(),
+  visibility: z128.enum(["private", "project", "organization", "public"]).default("private"),
+  tags: z128.array(z128.string().max(50)).max(20).default([]),
+  versionTag: z128.string().max(100).optional(),
+  sourceQuestId: z128.string().optional(),
+  sessionId: z128.string().optional(),
+  parentArtifactId: z128.string().optional(),
+  permissions: z128.object({
+    canRead: z128.array(z128.string()).default([]),
+    canWrite: z128.array(z128.string()).default([]),
+    canDelete: z128.array(z128.string()).default([]),
+    isPublic: z128.boolean().default(false),
+    inheritFromProject: z128.boolean().default(true)
   }).optional(),
-  metadata: z129.record(z129.unknown()).default({})
+  metadata: z128.record(z128.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/get.js
-import { z as z130 } from "zod";
-var getArtifactSchema = z130.object({
-  id: z130.string(),
-  includeContent: z130.boolean().default(false),
-  includeVersions: z130.boolean().default(false),
-  version: z130.number().optional()
+import { z as z129 } from "zod";
+var getArtifactSchema = z129.object({
+  id: z129.string(),
+  includeContent: z129.boolean().default(false),
+  includeVersions: z129.boolean().default(false),
+  version: z129.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/list.js
-import { z as z131 } from "zod";
-var listArtifactsSchema = z131.object({
-  type: z131.string().optional(),
-  status: z131.enum(["draft", "review", "published", "archived"]).optional(),
-  visibility: z131.enum(["private", "project", "organization", "public"]).optional(),
-  projectId: z131.string().optional(),
-  sessionId: z131.string().optional(),
-  tags: z131.array(z131.string()).optional(),
-  search: z131.string().optional(),
-  limit: z131.number().min(1).max(100).default(20),
-  offset: z131.number().min(0).default(0),
-  sortBy: z131.enum(["createdAt", "updatedAt", "title", "type"]).default("updatedAt"),
-  sortOrder: z131.enum(["asc", "desc"]).default("desc"),
-  includeDeleted: z131.boolean().default(false)
+import { z as z130 } from "zod";
+var listArtifactsSchema = z130.object({
+  type: z130.string().optional(),
+  status: z130.enum(["draft", "review", "published", "archived"]).optional(),
+  visibility: z130.enum(["private", "project", "organization", "public"]).optional(),
+  projectId: z130.string().optional(),
+  sessionId: z130.string().optional(),
+  tags: z130.array(z130.string()).optional(),
+  search: z130.string().optional(),
+  limit: z130.number().min(1).max(100).default(20),
+  offset: z130.number().min(0).default(0),
+  sortBy: z130.enum(["createdAt", "updatedAt", "title", "type"]).default("updatedAt"),
+  sortOrder: z130.enum(["asc", "desc"]).default("desc"),
+  includeDeleted: z130.boolean().default(false)
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/update.js
-import { z as z132 } from "zod";
-var updateArtifactSchema = z132.object({
-  id: z132.string(),
-  title: z132.string().min(1).max(255).optional(),
-  description: z132.string().max(1e3).optional(),
-  content: z132.string().optional(),
-  visibility: z132.enum(["private", "project", "organization", "public"]).optional(),
-  status: z132.enum(["draft", "review", "published", "archived"]).optional(),
-  tags: z132.array(z132.string().max(50)).max(20).optional(),
-  versionTag: z132.string().max(100).optional(),
-  permissions: z132.object({
-    canRead: z132.array(z132.string()).optional(),
-    canWrite: z132.array(z132.string()).optional(),
-    canDelete: z132.array(z132.string()).optional(),
-    isPublic: z132.boolean().optional(),
-    inheritFromProject: z132.boolean().optional()
+import { z as z131 } from "zod";
+var updateArtifactSchema = z131.object({
+  id: z131.string(),
+  title: z131.string().min(1).max(255).optional(),
+  description: z131.string().max(1e3).optional(),
+  content: z131.string().optional(),
+  visibility: z131.enum(["private", "project", "organization", "public"]).optional(),
+  status: z131.enum(["draft", "review", "published", "archived"]).optional(),
+  tags: z131.array(z131.string().max(50)).max(20).optional(),
+  versionTag: z131.string().max(100).optional(),
+  permissions: z131.object({
+    canRead: z131.array(z131.string()).optional(),
+    canWrite: z131.array(z131.string()).optional(),
+    canDelete: z131.array(z131.string()).optional(),
+    isPublic: z131.boolean().optional(),
+    inheritFromProject: z131.boolean().optional()
   }).optional(),
-  metadata: z132.record(z132.unknown()).optional(),
-  changes: z132.array(z132.string()).optional(),
-  changeDescription: z132.string().max(1e3).optional(),
-  createNewVersion: z132.boolean().optional(),
-  versionMessage: z132.string().max(500).optional()
+  metadata: z131.record(z131.unknown()).optional(),
+  changes: z131.array(z131.string()).optional(),
+  changeDescription: z131.string().max(1e3).optional(),
+  createNewVersion: z131.boolean().optional(),
+  versionMessage: z131.string().max(500).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/delete.js
-import { z as z133 } from "zod";
-var deleteArtifactSchema = z133.object({
-  id: z133.string(),
-  hardDelete: z133.boolean().default(false)
+import { z as z132 } from "zod";
+var deleteArtifactSchema = z132.object({
+  id: z132.string(),
+  hardDelete: z132.boolean().default(false)
   // For future implementation
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/create.js
-import { z as z134 } from "zod";
-var questSchema = z134.object({
-  id: z134.string(),
-  title: z134.string().min(1).max(255),
-  description: z134.string().max(MAX_DESCRIPTION_LENGTH),
-  status: z134.enum(["not_started", "in_progress", "completed", "blocked"]).default("not_started"),
-  order: z134.number().min(0),
-  dependencies: z134.array(z134.string()).default([]),
-  estimatedTime: z134.string().optional()
-});
-var questResourceSchema = z134.object({
-  title: z134.string().min(1).max(255),
-  url: z134.string().url(),
-  type: z134.enum(["documentation", "tutorial", "reference", "example"])
-});
-var createQuestMasterSchema = z134.object({
-  title: z134.string().min(1).max(255),
-  description: z134.string().max(MAX_DESCRIPTION_LENGTH).optional(),
-  goal: z134.string().min(1).max(MAX_GOAL_LENGTH),
-  complexity: z134.enum(["beginner", "intermediate", "advanced", "expert"]),
-  estimatedTotalTime: z134.string().optional(),
-  prerequisites: z134.array(z134.string().max(200)).default([]),
-  quests: z134.array(questSchema).min(1),
-  resources: z134.array(questResourceSchema).default([]),
-  projectId: z134.string().optional(),
-  organizationId: z134.string().optional(),
-  visibility: z134.enum(["private", "project", "organization", "public"]).default("private"),
-  tags: z134.array(z134.string().max(MAX_TAG_LENGTH)).max(20).default([]),
-  permissions: z134.object({
-    canRead: z134.array(z134.string()).default([]),
-    canWrite: z134.array(z134.string()).default([]),
-    canDelete: z134.array(z134.string()).default([]),
-    isPublic: z134.boolean().default(false),
-    inheritFromProject: z134.boolean().default(true)
+import { z as z133 } from "zod";
+var questSchema = z133.object({
+  id: z133.string(),
+  title: z133.string().min(1).max(255),
+  description: z133.string().max(MAX_DESCRIPTION_LENGTH),
+  status: z133.enum(["not_started", "in_progress", "completed", "blocked"]).default("not_started"),
+  order: z133.number().min(0),
+  dependencies: z133.array(z133.string()).default([]),
+  estimatedTime: z133.string().optional()
+});
+var questResourceSchema = z133.object({
+  title: z133.string().min(1).max(255),
+  url: z133.string().url(),
+  type: z133.enum(["documentation", "tutorial", "reference", "example"])
+});
+var createQuestMasterSchema = z133.object({
+  title: z133.string().min(1).max(255),
+  description: z133.string().max(MAX_DESCRIPTION_LENGTH).optional(),
+  goal: z133.string().min(1).max(MAX_GOAL_LENGTH),
+  complexity: z133.enum(["beginner", "intermediate", "advanced", "expert"]),
+  estimatedTotalTime: z133.string().optional(),
+  prerequisites: z133.array(z133.string().max(200)).default([]),
+  quests: z133.array(questSchema).min(1),
+  resources: z133.array(questResourceSchema).default([]),
+  projectId: z133.string().optional(),
+  organizationId: z133.string().optional(),
+  visibility: z133.enum(["private", "project", "organization", "public"]).default("private"),
+  tags: z133.array(z133.string().max(MAX_TAG_LENGTH)).max(20).default([]),
+  permissions: z133.object({
+    canRead: z133.array(z133.string()).default([]),
+    canWrite: z133.array(z133.string()).default([]),
+    canDelete: z133.array(z133.string()).default([]),
+    isPublic: z133.boolean().default(false),
+    inheritFromProject: z133.boolean().default(true)
   }).optional(),
-  sourceQuestId: z134.string().optional(),
-  sessionId: z134.string().optional(),
-  metadata: z134.record(z134.unknown()).default({})
+  sourceQuestId: z133.string().optional(),
+  sessionId: z133.string().optional(),
+  metadata: z133.record(z133.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/updateQuestStatus.js
-import { z as z135 } from "zod";
-var updateQuestStatusSchema = z135.object({
-  artifactId: z135.string(),
-  questId: z135.string(),
-  status: z135.enum(["not_started", "in_progress", "completed", "blocked"]),
-  completionNote: z135.string().max(500).optional()
+import { z as z134 } from "zod";
+var updateQuestStatusSchema = z134.object({
+  artifactId: z134.string(),
+  questId: z134.string(),
+  status: z134.enum(["not_started", "in_progress", "completed", "blocked"]),
+  completionNote: z134.string().max(500).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/dataLakeService/opensearchClient.js
@@ -5448,63 +5251,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 z136 } from "zod";
-var processIngestedEmailOptionsSchema = z136.object({
-  platformDomain: z136.string().optional(),
-  isNewsletter: z136.boolean().optional()
+import { z as z135 } from "zod";
+var processIngestedEmailOptionsSchema = z135.object({
+  platformDomain: z135.string().optional(),
+  isNewsletter: z135.boolean().optional()
 }).optional();
-var emailAttachmentSchema = z136.object({
-  filename: z136.string().optional(),
-  contentType: z136.string().optional(),
-  contentDisposition: z136.string().optional(),
-  size: z136.number().min(0),
-  content: z136.instanceof(Buffer),
-  related: z136.boolean().optional()
-});
-var parsedEmailObjectSchema = z136.object({
-  messageId: z136.string().optional(),
-  inReplyTo: z136.string().optional(),
-  references: z136.union([z136.string(), z136.array(z136.string())]).optional(),
-  from: z136.any().optional(),
+var emailAttachmentSchema = z135.object({
+  filename: z135.string().optional(),
+  contentType: z135.string().optional(),
+  contentDisposition: z135.string().optional(),
+  size: z135.number().min(0),
+  content: z135.instanceof(Buffer),
+  related: z135.boolean().optional()
+});
+var parsedEmailObjectSchema = z135.object({
+  messageId: z135.string().optional(),
+  inReplyTo: z135.string().optional(),
+  references: z135.union([z135.string(), z135.array(z135.string())]).optional(),
+  from: z135.any().optional(),
   // Complex email address object
-  to: z136.any().optional(),
-  cc: z136.any().optional(),
-  bcc: z136.any().optional(),
-  subject: z136.string().optional(),
-  date: z136.date().optional(),
-  text: z136.string().optional(),
-  html: z136.string().optional(),
-  attachments: z136.array(emailAttachmentSchema).optional()
-});
-var processIngestedEmailSchema = z136.object({
+  to: z135.any().optional(),
+  cc: z135.any().optional(),
+  bcc: z135.any().optional(),
+  subject: z135.string().optional(),
+  date: z135.date().optional(),
+  text: z135.string().optional(),
+  html: z135.string().optional(),
+  attachments: z135.array(emailAttachmentSchema).optional()
+});
+var processIngestedEmailSchema = z135.object({
   parsedEmail: parsedEmailObjectSchema,
-  rawEmailS3Key: z136.string().min(1, "rawEmailS3Key cannot be empty"),
+  rawEmailS3Key: z135.string().min(1, "rawEmailS3Key cannot be empty"),
   options: processIngestedEmailOptionsSchema
 });
 
 // ../../b4m-core/packages/services/dist/src/emailAnalysisService/types.js
-import { z as z137 } from "zod";
-var llmAnalysisResponseSchema = z137.object({
-  summary: z137.string().min(1, "Summary cannot be empty"),
-  entities: z137.object({
-    companies: z137.array(z137.string()).default([]),
-    people: z137.array(z137.string()).default([]),
-    products: z137.array(z137.string()).default([]),
-    technologies: z137.array(z137.string()).default([])
+import { z as z136 } from "zod";
+var llmAnalysisResponseSchema = z136.object({
+  summary: z136.string().min(1, "Summary cannot be empty"),
+  entities: z136.object({
+    companies: z136.array(z136.string()).default([]),
+    people: z136.array(z136.string()).default([]),
+    products: z136.array(z136.string()).default([]),
+    technologies: z136.array(z136.string()).default([])
   }),
-  sentiment: z137.enum(["positive", "neutral", "negative", "urgent"]),
-  actionItems: z137.array(z137.object({
-    description: z137.string(),
-    deadline: z137.string().optional()
+  sentiment: z136.enum(["positive", "neutral", "negative", "urgent"]),
+  actionItems: z136.array(z136.object({
+    description: z136.string(),
+    deadline: z136.string().optional()
     // ISO date string from LLM
   })).default([]),
-  privacyRecommendation: z137.enum(["public", "team", "private"]),
-  embargoDetected: z137.boolean().default(false),
-  suggestedTags: z137.array(z137.string()).default([])
+  privacyRecommendation: z136.enum(["public", "team", "private"]),
+  embargoDetected: z136.boolean().default(false),
+  suggestedTags: z136.array(z136.string()).default([])
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletion.js
-import { z as z139 } from "zod";
+import { z as z138 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionInvoke.js
 import { fromZodError } from "zod-validation-error";
@@ -6695,17 +6498,17 @@ var rechartsTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editFile/index.js
-import { z as z138 } from "zod";
+import { z as z137 } from "zod";
 import { diffLines as diffLines2 } from "diff";
-var editFileSchema = z138.object({
-  fileId: z138.string().describe("The ID of the file to edit"),
-  instruction: z138.string().describe("Natural language instruction describing the changes to make"),
-  selection: z138.object({
-    start: z138.number().describe("Starting character position of the selection"),
-    end: z138.number().describe("Ending character position of the selection")
+var editFileSchema = z137.object({
+  fileId: z137.string().describe("The ID of the file to edit"),
+  instruction: z137.string().describe("Natural language instruction describing the changes to make"),
+  selection: z137.object({
+    start: z137.number().describe("Starting character position of the selection"),
+    end: z137.number().describe("Ending character position of the selection")
   }).optional().describe("Optional selection range to edit within the file"),
-  preserveFormatting: z138.boolean().optional().default(true).describe("Whether to preserve the original formatting style"),
-  returnDiff: z138.boolean().optional().default(true).describe("Whether to return a diff of the changes")
+  preserveFormatting: z137.boolean().optional().default(true).describe("Whether to preserve the original formatting style"),
+  returnDiff: z137.boolean().optional().default(true).describe("Whether to return a diff of the changes")
 });
 function generateSimpleDiff(original, modified) {
   const differences = diffLines2(original, modified);
@@ -10022,131 +9825,131 @@ var DISABLE_SERVER_THROTTLING = process.env.DISABLE_SERVER_THROTTLING === "true"
 var questSaveMutex = new Mutex();
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletion.js
-var QuestStartBodySchema = z139.object({
-  userId: z139.string(),
-  sessionId: z139.string(),
-  questId: z139.string(),
-  message: z139.string(),
-  messageFileIds: z139.array(z139.string()),
-  historyCount: z139.number(),
-  fabFileIds: z139.array(z139.string()),
+var QuestStartBodySchema = z138.object({
+  userId: z138.string(),
+  sessionId: z138.string(),
+  questId: z138.string(),
+  message: z138.string(),
+  messageFileIds: z138.array(z138.string()),
+  historyCount: z138.number(),
+  fabFileIds: z138.array(z138.string()),
   params: ChatCompletionCreateInputSchema,
   dashboardParams: DashboardParamsSchema.optional(),
-  enableQuestMaster: z139.boolean().optional(),
-  enableMementos: z139.boolean().optional(),
-  enableArtifacts: z139.boolean().optional(),
-  enableAgents: z139.boolean().optional(),
+  enableQuestMaster: z138.boolean().optional(),
+  enableMementos: z138.boolean().optional(),
+  enableArtifacts: z138.boolean().optional(),
+  enableAgents: z138.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
-  tools: z139.array(z139.union([b4mLLMTools, z139.string()])).optional(),
-  mcpServers: z139.array(z139.string()).optional(),
-  projectId: z139.string().optional(),
-  organizationId: z139.string().nullable().optional(),
+  tools: z138.array(z138.union([b4mLLMTools, z138.string()])).optional(),
+  mcpServers: z138.array(z138.string()).optional(),
+  projectId: z138.string().optional(),
+  organizationId: z138.string().nullable().optional(),
   questMaster: QuestMasterParamsSchema.optional(),
-  toolPromptId: z139.string().optional(),
+  toolPromptId: z138.string().optional(),
   researchMode: ResearchModeParamsSchema.optional(),
-  fallbackModel: z139.string().optional(),
-  embeddingModel: z139.string().optional(),
-  queryComplexity: z139.string(),
+  fallbackModel: z138.string().optional(),
+  embeddingModel: z138.string().optional(),
+  queryComplexity: z138.string(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z139.object({
-    maxDepth: z139.number().optional(),
-    duration: z139.number().optional(),
+  deepResearchConfig: z138.object({
+    maxDepth: z138.number().optional(),
+    duration: z138.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z139.array(z139.any()).optional()
+    searchers: z138.array(z138.any()).optional()
   }).optional(),
-  extraContextMessages: z139.array(z139.object({
-    role: z139.enum(["user", "assistant", "system", "function", "tool"]),
-    content: z139.union([z139.string(), z139.array(z139.any())]),
-    fabFileIds: z139.array(z139.string()).optional()
+  extraContextMessages: z138.array(z138.object({
+    role: z138.enum(["user", "assistant", "system", "function", "tool"]),
+    content: z138.union([z138.string(), z138.array(z138.any())]),
+    fabFileIds: z138.array(z138.string()).optional()
   })).optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z139.string().optional()
+  timezone: z138.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ImageGeneration.js
 import axios8 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer4 } from "file-type";
 import { v4 as uuidv47 } from "uuid";
-import { z as z140 } from "zod";
+import { z as z139 } from "zod";
 import { fromZodError as fromZodError2 } from "zod-validation-error";
 var ImageGenerationBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z140.string(),
-  questId: z140.string(),
-  userId: z140.string(),
-  prompt: z140.string(),
-  safety_tolerance: z140.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z140.boolean().optional().default(false),
-  seed: z140.number().nullable().optional(),
-  output_format: z140.enum(["jpeg", "png"]).nullable().optional().default("png"),
-  width: z140.number().optional(),
-  height: z140.number().optional(),
-  aspect_ratio: z140.string().optional(),
-  fabFileIds: z140.array(z140.string()).optional()
+  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/VideoGeneration.js
 import axios9 from "axios";
 import { v4 as uuidv48 } from "uuid";
-import { z as z141 } from "zod";
+import { z as z140 } from "zod";
 import { fromZodError as fromZodError3 } from "zod-validation-error";
-var VideoGenerationBodySchema = z141.object({
-  sessionId: z141.string(),
-  questId: z141.string(),
-  userId: z141.string(),
-  prompt: z141.string(),
-  model: z141.nativeEnum(VideoModels).default(VideoModels.SORA_2),
-  seconds: z141.union([z141.literal(4), z141.literal(8), z141.literal(12)]).default(4),
-  size: z141.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize)
+var VideoGenerationBodySchema = z140.object({
+  sessionId: z140.string(),
+  questId: z140.string(),
+  userId: z140.string(),
+  prompt: z140.string(),
+  model: z140.nativeEnum(VideoModels).default(VideoModels.SORA_2),
+  seconds: z140.union([z140.literal(4), z140.literal(8), z140.literal(12)]).default(4),
+  size: z140.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize)
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
 import axios10 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
 import { v4 as uuidv49 } from "uuid";
-import { z as z142 } from "zod";
+import { z as z141 } from "zod";
 import { fromZodError as fromZodError4 } from "zod-validation-error";
 var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z142.string(),
-  questId: z142.string(),
-  userId: z142.string(),
-  prompt: z142.string(),
-  safety_tolerance: z142.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z142.boolean().optional().default(false),
-  seed: z142.number().nullable().optional(),
-  output_format: z142.enum(["jpeg", "png"]).optional().default("png"),
-  width: z142.number().optional(),
-  height: z142.number().optional(),
-  aspect_ratio: z142.string().optional(),
-  size: z142.string().optional(),
-  fabFileIds: z142.array(z142.string()).optional(),
-  image: z142.string()
+  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 z143 } from "zod";
-var refineTextLLMSchema = z143.object({
-  text: z143.string(),
-  context: z143.string().optional()
+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 z144 } from "zod";
-var SingleMementoEvalSchema = z144.object({
-  importance: z144.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: z144.string(),
-  tags: z144.array(z144.string()).optional()
+  summary: z143.string(),
+  tags: z143.array(z143.string()).optional()
 });
-var MementoEvalResponseSchema = z144.object({
-  isPersonal: z144.boolean(),
-  mementos: z144.array(SingleMementoEvalSchema).optional()
+var MementoEvalResponseSchema = z143.object({
+  isPersonal: z143.boolean(),
+  mementos: z143.array(SingleMementoEvalSchema).optional()
   // Array of distinct personal information
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/SmallLLMService.js
-import { z as z145 } from "zod";
+import { z as z144 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/auth/AccessTokenGeneratorService.js
 import jwt2 from "jsonwebtoken";
@@ -10681,7 +10484,7 @@ function buildHookContext(params) {
 }
 
 // src/agents/types.ts
-import { z as z146 } from "zod";
+import { z as z145 } from "zod";
 var HookBlockedError = class extends Error {
   constructor(toolName, reason) {
     super(`Hook blocked execution of ${toolName}: ${reason || "No reason provided"}`);
@@ -10693,39 +10496,39 @@ var ALWAYS_DENIED_FOR_AGENTS = [
   "agent_delegate"
   // No agent chaining
 ];
-var CommandHookSchema = z146.object({
-  type: z146.literal("command"),
-  command: z146.string().min(1, "Command is required for command hooks"),
-  timeout: z146.number().optional()
-});
-var PromptHookSchema = z146.object({
-  type: z146.literal("prompt"),
-  prompt: z146.string().min(1, "Prompt is required for prompt hooks"),
-  timeout: z146.number().optional()
-});
-var HookDefinitionSchema = z146.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
-var HookMatcherSchema = z146.object({
-  matcher: z146.string().optional(),
-  hooks: z146.array(HookDefinitionSchema)
-});
-var AgentHooksSchema = z146.object({
-  PreToolUse: z146.array(HookMatcherSchema).optional(),
-  PostToolUse: z146.array(HookMatcherSchema).optional(),
-  PostToolUseFailure: z146.array(HookMatcherSchema).optional(),
-  Stop: z146.array(HookMatcherSchema).optional()
+var CommandHookSchema = z145.object({
+  type: z145.literal("command"),
+  command: z145.string().min(1, "Command is required for command hooks"),
+  timeout: z145.number().optional()
+});
+var PromptHookSchema = z145.object({
+  type: z145.literal("prompt"),
+  prompt: z145.string().min(1, "Prompt is required for prompt hooks"),
+  timeout: z145.number().optional()
+});
+var HookDefinitionSchema = z145.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
+var HookMatcherSchema = z145.object({
+  matcher: z145.string().optional(),
+  hooks: z145.array(HookDefinitionSchema)
+});
+var AgentHooksSchema = z145.object({
+  PreToolUse: z145.array(HookMatcherSchema).optional(),
+  PostToolUse: z145.array(HookMatcherSchema).optional(),
+  PostToolUseFailure: z145.array(HookMatcherSchema).optional(),
+  Stop: z145.array(HookMatcherSchema).optional()
 }).optional();
-var AgentFrontmatterSchema = z146.object({
-  description: z146.string().min(1, "Agent description is required"),
-  model: z146.string().optional(),
-  "allowed-tools": z146.array(z146.string()).optional(),
-  "denied-tools": z146.array(z146.string()).optional(),
-  "max-iterations": z146.object({
-    quick: z146.number().int().positive().optional(),
-    medium: z146.number().int().positive().optional(),
-    very_thorough: z146.number().int().positive().optional()
+var AgentFrontmatterSchema = z145.object({
+  description: z145.string().min(1, "Agent description is required"),
+  model: z145.string().optional(),
+  "allowed-tools": z145.array(z145.string()).optional(),
+  "denied-tools": z145.array(z145.string()).optional(),
+  "max-iterations": z145.object({
+    quick: z145.number().int().positive().optional(),
+    medium: z145.number().int().positive().optional(),
+    very_thorough: z145.number().int().positive().optional()
   }).optional(),
-  "default-thoroughness": z146.enum(["quick", "medium", "very_thorough"]).optional(),
-  variables: z146.record(z146.string()).optional(),
+  "default-thoroughness": z145.enum(["quick", "medium", "very_thorough"]).optional(),
+  variables: z145.record(z145.string()).optional(),
   hooks: AgentHooksSchema
 });
 var DEFAULT_MAX_ITERATIONS = {
@@ -11036,6 +10839,67 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
   return { tools: tools2, agentContext };
 }
 
+// src/config/toolSafety.ts
+import { z as z146 } from "zod";
+var ToolCategorySchema = z146.enum([
+  "auto_approve",
+  // Safe tools that run automatically without permission
+  "prompt_always",
+  // Dangerous tools that ALWAYS require permission (cannot be trusted)
+  "prompt_default"
+  // Tools that prompt by default but can be trusted
+]);
+var ToolSafetyConfigSchema = z146.object({
+  categories: z146.record(z146.string(), ToolCategorySchema),
+  trustedTools: z146.array(z146.string())
+});
+var DEFAULT_TOOL_CATEGORIES = {
+  // ===== AUTO APPROVE (Safe tools) =====
+  // These tools have no side effects and are always safe to execute
+  math_evaluate: "auto_approve",
+  current_datetime: "auto_approve",
+  dice_roll: "auto_approve",
+  prompt_enhancement: "auto_approve",
+  weather_info: "prompt_default",
+  // ===== PROMPT ALWAYS (Dangerous tools) =====
+  // These tools can modify files, execute code, or have other dangerous side effects
+  // They ALWAYS require permission and cannot be trusted automatically
+  edit_file: "prompt_always",
+  edit_local_file: "prompt_always",
+  create_file: "prompt_always",
+  delete_file: "prompt_always",
+  shell_execute: "prompt_always",
+  bash_execute: "prompt_always",
+  git_commit: "prompt_always",
+  git_push: "prompt_always",
+  // ===== PROMPT DEFAULT (Repository read tools) =====
+  // These tools read from the repository but don't modify anything
+  // Users can trust them if they want to avoid prompts
+  web_search: "prompt_default",
+  deep_research: "prompt_default",
+  file_read: "prompt_default",
+  grep_search: "prompt_default",
+  glob_files: "prompt_default",
+  get_file_tree: "prompt_default",
+  git_status: "prompt_default",
+  git_diff: "prompt_default",
+  git_log: "prompt_default",
+  git_branch: "prompt_default"
+};
+function getToolCategory(toolName, customCategories) {
+  if (customCategories && toolName in customCategories) {
+    return customCategories[toolName];
+  }
+  if (toolName in DEFAULT_TOOL_CATEGORIES) {
+    return DEFAULT_TOOL_CATEGORIES[toolName];
+  }
+  return "prompt_default";
+}
+function canTrustTool(toolName, customCategories) {
+  const category = getToolCategory(toolName, customCategories);
+  return category !== "prompt_always";
+}
+
 // src/utils/PermissionManager.ts
 var PermissionManager = class {
   constructor(trustedTools = [], customCategories, deniedTools) {
@@ -12448,7 +12312,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.21-feat-parallel-tool-execution.18205+47a8e106d",
+  version: "0.2.21-feat-cli-skill-frontmatter-spec.18206+7f8510398",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -12492,7 +12356,6 @@ var package_default = {
     "@anthropic-ai/sdk": "^0.71.2",
     "@aws-sdk/client-apigatewaymanagementapi": "3.654.0",
     "@aws-sdk/client-bedrock-runtime": "3.654.0",
-    "@aws-sdk/client-cloudwatch": "3.654.0",
     "@aws-sdk/client-lambda": "3.654.0",
     "@aws-sdk/client-s3": "3.654.0",
     "@aws-sdk/client-sqs": "3.654.0",
@@ -12556,10 +12419,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.45.1-feat-parallel-tool-execution.18205+47a8e106d",
-    "@bike4mind/mcp": "1.25.1-feat-parallel-tool-execution.18205+47a8e106d",
-    "@bike4mind/services": "2.43.1-feat-parallel-tool-execution.18205+47a8e106d",
-    "@bike4mind/utils": "2.3.1-feat-parallel-tool-execution.18205+47a8e106d",
+    "@bike4mind/common": "2.45.1-feat-cli-skill-frontmatter-spec.18206+7f8510398",
+    "@bike4mind/mcp": "1.25.1-feat-cli-skill-frontmatter-spec.18206+7f8510398",
+    "@bike4mind/services": "2.43.1-feat-cli-skill-frontmatter-spec.18206+7f8510398",
+    "@bike4mind/utils": "2.3.1-feat-cli-skill-frontmatter-spec.18206+7f8510398",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -12576,7 +12439,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "47a8e106deffa28587e7200646f96b73b2b5a0a2"
+  gitHead: "7f851039810b3200a4885d4c254f6d600d0a1ab5"
 };
 
 // src/config/constants.ts
@@ -12635,12 +12498,13 @@ var SubagentOrchestrator = class {
    * @returns Agent result with summary
    */
   async delegateToAgent(options) {
-    const { task, agentName, thoroughness, variables, parentSessionId } = options;
+    const { task, agentName, thoroughness, variables, parentSessionId, model, allowedTools } = options;
     const agentDef = this.deps.agentStore.getAgent(agentName);
     if (!agentDef) {
       const available = this.deps.agentStore.getAgentNames().join(", ");
       throw new Error(`Unknown agent: "${agentName}". Available agents: ${available}`);
     }
+    const effectiveModel = model || agentDef.model;
     const effectiveThoroughness = thoroughness || agentDef.defaultThoroughness;
     const maxIterations = agentDef.maxIterations[effectiveThoroughness];
     const effectiveVariables = {
@@ -12648,8 +12512,9 @@ var SubagentOrchestrator = class {
       ...variables
     };
     const systemPrompt = this.substituteVariables(agentDef.systemPrompt, task, effectiveVariables);
+    const effectiveAllowedTools = allowedTools || agentDef.allowedTools;
     const toolFilter = {
-      allowedTools: agentDef.allowedTools,
+      allowedTools: effectiveAllowedTools,
       deniedTools: [...agentDef.deniedTools || [], ...ALWAYS_DENIED_FOR_AGENTS]
     };
     const agentContext = {
@@ -12659,7 +12524,7 @@ var SubagentOrchestrator = class {
     const { tools: allTools, agentContext: updatedContext } = generateCliTools(
       this.deps.userId,
       this.deps.llm,
-      agentDef.model,
+      effectiveModel,
       this.deps.permissionManager,
       this.deps.showPermissionPrompt,
       agentContext,
@@ -12680,7 +12545,7 @@ var SubagentOrchestrator = class {
       userId: this.deps.userId,
       logger: this.deps.logger,
       llm: this.deps.llm,
-      model: agentDef.model,
+      model: effectiveModel,
       tools: hookedTools,
       maxIterations,
       systemPrompt
@@ -12693,9 +12558,7 @@ var SubagentOrchestrator = class {
     let result;
     try {
       result = await agent.run(task, {
-        maxIterations,
-        parallelExecution: this.deps.enableParallelToolExecution === true,
-        isReadOnlyTool
+        maxIterations
       });
     } catch (error) {
       if (error instanceof HookBlockedError) {
@@ -13245,6 +13108,39 @@ function createTodoStore(onUpdate) {
 }
 
 // src/tools/skillTool.ts
+import { exec } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync = promisify2(exec);
+async function executeHook(script, context) {
+  try {
+    const env = {
+      ...process.env,
+      SKILL_NAME: context.skillName,
+      SKILL_ARGS: context.args,
+      SKILL_RESULT: context.result || "",
+      SKILL_ERROR: context.error || ""
+    };
+    const { stdout, stderr } = await execAsync(script, {
+      env,
+      timeout: 3e4,
+      // 30 second timeout for hooks
+      cwd: process.cwd()
+    });
+    return { success: true, output: stdout || stderr };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, output: `Hook failed: ${message}` };
+  }
+}
+function parseAgentConfig(agent) {
+  if (!agent) {
+    return { name: "general-purpose", thoroughness: void 0 };
+  }
+  if (typeof agent === "string") {
+    return { name: agent, thoroughness: void 0 };
+  }
+  return { name: agent.type, thoroughness: agent.thoroughness };
+}
 function parseArguments(argsString) {
   const args = [];
   let current = "";
@@ -13272,7 +13168,8 @@ function parseArguments(argsString) {
   }
   return args;
 }
-function createSkillTool(customCommandStore) {
+function createSkillTool(deps) {
+  const { customCommandStore } = deps;
   return {
     toolFn: async (args) => {
       const params = args;
@@ -13280,27 +13177,94 @@ function createSkillTool(customCommandStore) {
         throw new Error("skill: skill parameter is required");
       }
       const skillName = params.skill.replace(/^\//, "");
+      const argsString = params.args || "";
       const command = customCommandStore.getCommand(skillName);
       if (!command) {
         const available = customCommandStore.getAllCommands().map((c) => c.name).join(", ");
         throw new Error(`skill: "${skillName}" not found. Available skills: ${available || "none"}`);
       }
-      const argsArray = params.args ? parseArguments(params.args) : [];
-      let expandedBody = substituteArguments(command.body, argsArray);
-      const processed = await processFileReferences(expandedBody);
-      expandedBody = processed.content;
-      if (processed.errors.length > 0) {
-        expandedBody += `
+      if (command.hooks?.["pre-invoke"]) {
+        const hookResult = await executeHook(command.hooks["pre-invoke"], {
+          skillName,
+          args: argsString
+        });
+        if (!hookResult.success) {
+          throw new Error(`Pre-invoke hook failed: ${hookResult.output}`);
+        }
+      }
+      try {
+        const argsArray = params.args ? parseArguments(params.args) : [];
+        let expandedBody = substituteArguments(command.body, argsArray);
+        const processed = await processFileReferences(expandedBody);
+        expandedBody = processed.content;
+        if (processed.errors.length > 0) {
+          expandedBody += `
 
 **File reference errors:**
 ${processed.errors.map((e) => `- ${e}`).join("\n")}`;
-      }
-      return `## Skill Loaded: /${skillName}
+        }
+        let result;
+        const needsFork = command.context === "fork" || Boolean(command.allowedTools?.length) || Boolean(command.model);
+        if (needsFork) {
+          const { subagentOrchestrator, sessionId } = deps;
+          if (!subagentOrchestrator || !sessionId) {
+            const missing = !subagentOrchestrator ? "subagentOrchestrator" : "sessionId";
+            throw new Error(`Skill "${skillName}" requires forked context but ${missing} is not available`);
+          }
+          if (command.context !== "fork" && (command.allowedTools?.length || command.model)) {
+            const reasons = [];
+            if (command.allowedTools?.length) reasons.push("allowed-tools");
+            if (command.model) reasons.push("model");
+            console.log(`\u26A1 Skill "/${skillName}" auto-upgraded to fork context (uses: ${reasons.join(", ")})`);
+          }
+          const agentConfig = parseAgentConfig(command.agent);
+          const agentResult = await subagentOrchestrator.delegateToAgent({
+            task: expandedBody,
+            agentName: agentConfig.name,
+            thoroughness: agentConfig.thoroughness || command.thoroughness,
+            variables: command.variables,
+            parentSessionId: sessionId,
+            // Pass skill-level overrides
+            model: command.model,
+            allowedTools: command.allowedTools
+          });
+          const agentName = agentConfig.name;
+          result = `## Skill Executed: /${skillName} (via ${agentName} agent)
+
+${agentResult.summary}`;
+        } else {
+          result = `## Skill Loaded: /${skillName}
 
 ${expandedBody}
 
 ---
 *Follow the instructions above. This skill was invoked programmatically.*`;
+        }
+        if (command.hooks?.["post-invoke"]) {
+          const hookResult = await executeHook(command.hooks["post-invoke"], {
+            skillName,
+            args: argsString,
+            result
+          });
+          if (!hookResult.success) {
+            console.warn(`Post-invoke hook warning: ${hookResult.output}`);
+          }
+        }
+        return result;
+      } catch (error) {
+        if (command.hooks?.["on-error"]) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const hookResult = await executeHook(command.hooks["on-error"], {
+            skillName,
+            args: argsString,
+            error: errorMessage
+          });
+          if (hookResult.output) {
+            console.warn(`On-error hook output: ${hookResult.output}`);
+          }
+        }
+        throw error;
+      }
     },
     toolSchema: {
       name: "skill",
@@ -13345,9 +13309,14 @@ ${expandedBody}
 }
 
 // src/core/skillsPrompt.ts
+function getSkillDisplayName(cmd) {
+  return cmd.displayName || cmd.name;
+}
 function formatSkillEntry(cmd) {
+  const displayName = getSkillDisplayName(cmd);
   const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
-  return `- **${cmd.name}**${argHint}: ${cmd.description}
+  const nameDisplay = cmd.displayName && cmd.displayName !== cmd.name ? `**${displayName}** (\`${cmd.name}\`)` : `**${cmd.name}**`;
+  return `- ${nameDisplay}${argHint}: ${cmd.description}
 `;
 }
 function formatSkillGroup(heading, commands) {
@@ -13358,12 +13327,16 @@ function formatSkillGroup(heading, commands) {
 ### ${heading}
 ${commands.map(formatSkillEntry).join("")}`;
 }
+function filterAIVisibleSkills(commands) {
+  return commands.filter((cmd) => !cmd.disableModelInvocation);
+}
 function buildSkillsPromptSection(commands) {
-  if (commands.length === 0) {
+  const visibleCommands = filterAIVisibleSkills(commands);
+  if (visibleCommands.length === 0) {
     return "";
   }
-  const projectSkills = commands.filter((c) => c.source === "project");
-  const globalSkills = commands.filter((c) => c.source === "global");
+  const projectSkills = visibleCommands.filter((c) => c.source === "project");
+  const globalSkills = visibleCommands.filter((c) => c.source === "global");
   return `
 
 ## Available Skills
@@ -13652,14 +13625,17 @@ function CliApp() {
         showPermissionPrompt: promptFn,
         configStore: state.configStore,
         apiClient,
-        agentStore,
-        enableParallelToolExecution: config.preferences.enableParallelToolExecution === true
+        agentStore
       });
       const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id);
       const todoStore = createTodoStore();
       const writeTodosTool = createWriteTodosTool(todoStore);
       const enableSkillTool = config.preferences.enableSkillTool !== false;
-      const skillTool = enableSkillTool ? createSkillTool(state.customCommandStore) : null;
+      const skillTool = enableSkillTool ? createSkillTool({
+        customCommandStore: state.customCommandStore,
+        subagentOrchestrator: orchestrator,
+        sessionId: newSession.id
+      }) : null;
       const cliTools = [agentDelegateTool, writeTodosTool];
       if (skillTool) {
         cliTools.push(skillTool);
@@ -13847,12 +13823,9 @@ ${contextResult.mergedContent}` : "";
         role: msg.role,
         content: msg.content
       }));
-      const cliConfig = await state.configStore.get();
       const result = await state.agent.run(messageContent, {
         previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
-        signal: abortController.signal,
-        parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
-        isReadOnlyTool
+        signal: abortController.signal
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {
@@ -14022,12 +13995,9 @@ ${contextResult.mergedContent}` : "";
         role: msg.role,
         content: msg.content
       }));
-      const cliConfig = await state.configStore.get();
       const result = await state.agent.run(messageContent, {
         previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
-        signal: abortController.signal,
-        parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
-        isReadOnlyTool
+        signal: abortController.signal
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {
@@ -14230,17 +14200,18 @@ ${output}` : output.trim() || "(no output)",
         }
         const displayMessage = `/${command}${args.length > 0 ? " " + args.join(" ") : ""}`;
         if (customCommand.agent && state.orchestrator && state.agentStore) {
-          if (!state.agentStore.hasAgent(customCommand.agent)) {
+          const agentName = typeof customCommand.agent === "string" ? customCommand.agent : customCommand.agent.type;
+          if (!state.agentStore.hasAgent(agentName)) {
             const available = state.agentStore.getAgentNames().join(", ");
-            console.error(`\u274C Unknown agent "${customCommand.agent}" specified in command.`);
+            console.error(`\u274C Unknown agent "${agentName}" specified in command.`);
             console.error(`   Available agents: ${available}`);
             return;
           }
-          console.log(`\u{1F916} Delegating to ${customCommand.agent} agent...
+          console.log(`\u{1F916} Delegating to ${agentName} agent...
 `);
           const result = await state.orchestrator.delegateToAgent({
             task: substitutedBody,
-            agentName: customCommand.agent,
+            agentName,
             thoroughness: customCommand.thoroughness,
             variables: customCommand.variables,
             parentSessionId: state.session?.id || "unknown"