@bike4mind/cli 0.2.52-chore-upgrade-dotenv.21139 → 0.2.52-chore-upgrade-dotenv.21189

package/dist/{chunk-HXBLAUDN.js → chunk-2727SUBA.js}

@@ -333,7 +333,9 @@ var b4mLLMTools = z5.enum([
   "quantum_schedule",
   "quantum_formulate",
   // Navigation tool
-  "navigate_view"
+  "navigate_view",
+  // Excel generation
+  "excel_generation"
 ]);
 var B4MLLMToolsList = b4mLLMTools.options.map((tool) => tool);
 var RechartsChartTypeSchema = z5.enum([
@@ -613,6 +615,7 @@ var AppFileReservedTags;
   AppFileReservedTags2["ProfilePhoto"] = "profile-photo";
   AppFileReservedTags2["AdminLogo"] = "admin-logo";
   AppFileReservedTags2["AdminDarkLogo"] = "admin-dark-logo";
+  AppFileReservedTags2["DocxTemplate"] = "docx-template";
 })(AppFileReservedTags || (AppFileReservedTags = {}));
 
 // ../../b4m-core/packages/common/dist/src/types/entities/FabFileTypes.js
@@ -1243,6 +1246,7 @@ var SreTrackingStatus;
   SreTrackingStatus2["FAILED"] = "failed";
   SreTrackingStatus2["WONT_FIX"] = "wont_fix";
   SreTrackingStatus2["DISPATCH_FAILED"] = "dispatch_failed";
+  SreTrackingStatus2["DRY_RUN"] = "dry_run";
 })(SreTrackingStatus || (SreTrackingStatus = {}));
 var SRE_GATE_DEFAULTS = {
   enabled: true,
@@ -1736,6 +1740,17 @@ var UpdateFabFileChunkVectorStatusAction = z11.object({
   vectorizeStatus: z11.enum(["ongoing", "complete", "failed"]).optional(),
   failedMessage: z11.string().optional()
 });
+var DataLakeBatchProgressAction = z11.object({
+  action: z11.literal("data_lake_batch_progress"),
+  clientId: z11.string().optional(),
+  batchId: z11.string(),
+  uploadedFiles: z11.number().optional(),
+  chunkedFiles: z11.number().optional(),
+  vectorizedFiles: z11.number().optional(),
+  failedFiles: z11.number().optional(),
+  totalFiles: z11.number().optional(),
+  status: z11.enum(["preparing", "uploading", "processing", "completed", "completed_with_errors", "failed", "cancelled"]).optional()
+});
 var UpdateResearchTaskStatusAction = z11.object({
   action: z11.literal("update_research_task_status"),
   clientId: z11.string().optional(),
@@ -1990,7 +2005,8 @@ var MessageDataToClient = z11.discriminatedUnion("action", [
   KeepCommandAction,
   KeepCommandResultAction,
   TavernSceneBroadcastAction,
-  TavernHeartbeatLogAction
+  TavernHeartbeatLogAction,
+  DataLakeBatchProgressAction
 ]);
 
 // ../../b4m-core/packages/common/dist/src/schemas/cliCompletions.js
@@ -2512,7 +2528,15 @@ var FileGeneratePresignedUrlRequestInput = z14.object({
   mimeType: z14.string(),
   fileSize: z14.number(),
   /** The path to the file */
-  path: z14.string().optional()
+  path: z14.string().optional(),
+  /** SHA-256 content hash for deduplication */
+  contentHash: z14.string().optional(),
+  /** Batch ID for data lake uploads */
+  batchId: z14.string().optional(),
+  /** Original relative path from folder upload */
+  relativePath: z14.string().optional(),
+  /** Tags to apply to the file on creation */
+  tags: z14.array(z14.object({ name: z14.string(), strength: z14.number() })).optional()
 });
 var CreateFabFileRequestInput = z14.object({
   // file: z.any(),
@@ -6064,6 +6088,90 @@ var safeParseLatticeRule = (data) => {
   return LatticeRuleSchema.safeParse(data);
 };
 
+// ../../b4m-core/packages/common/dist/src/schemas/dataLake.js
+import z28 from "zod";
+var slugRegex = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+var sha256Regex = /^[a-f0-9]{64}$/;
+var CreateDataLakeRequestInput = z28.object({
+  name: z28.string().min(1).max(200),
+  slug: z28.string().min(2).max(60).regex(slugRegex, 'Slug must be lowercase alphanumeric with hyphens (e.g. "my-data-lake")'),
+  description: z28.string().max(2e3).optional(),
+  fileTagPrefix: z28.string().min(2).max(30).refine((s) => s.endsWith(":"), 'Tag prefix must end with ":" (e.g. "acme:")'),
+  requiredUserTag: z28.string().max(100).optional(),
+  organizationId: z28.string().optional()
+});
+var UpdateDataLakeRequestInput = z28.object({
+  name: z28.string().min(1).max(200).optional(),
+  description: z28.string().max(2e3).optional(),
+  requiredUserTag: z28.string().min(1).max(100).optional(),
+  status: z28.enum(["active", "archived"]).optional()
+});
+var DataLakeListRequestInput = z28.object({
+  organizationId: z28.string().optional(),
+  status: z28.enum(["active", "archived"]).optional()
+});
+var BatchPresignedUrlFileItem = z28.object({
+  fileName: z28.string().min(1),
+  mimeType: z28.string().min(1),
+  fileSize: z28.number().positive(),
+  contentHash: z28.string().regex(sha256Regex).optional(),
+  tags: z28.array(z28.object({
+    name: z28.string().min(1),
+    strength: z28.number().min(0).max(1)
+  })).optional(),
+  relativePath: z28.string().optional()
+});
+var BatchPresignedUrlRequestInput = z28.object({
+  files: z28.array(BatchPresignedUrlFileItem).min(1).max(100),
+  dataLakeSlug: z28.string().optional()
+});
+var InferTaxonomyFolderEntry = z28.object({
+  relativePath: z28.string(),
+  fileName: z28.string(),
+  fileSize: z28.number(),
+  mimeType: z28.string().optional(),
+  /** First ~500 chars of file content for AI analysis */
+  contentSample: z28.string().max(1e3).optional()
+});
+var InferTaxonomyRequestInput = z28.object({
+  folderTree: z28.array(InferTaxonomyFolderEntry).min(1).max(500),
+  /** If re-running for an existing data lake, pass its prefix */
+  existingPrefix: z28.string().optional(),
+  /** User description of the data (helps the AI) */
+  context: z28.string().max(2e3).optional()
+});
+var CheckDuplicatesRequestInput = z28.object({
+  hashes: z28.array(z28.string().regex(sha256Regex)).min(1).max(500)
+});
+var SyncDeltaFileEntry = z28.object({
+  relativePath: z28.string(),
+  fileName: z28.string(),
+  contentHash: z28.string().regex(sha256Regex),
+  fileSize: z28.number()
+});
+var ComputeSyncDeltaRequestInput = z28.object({
+  dataLakeSlug: z28.string(),
+  currentFiles: z28.array(SyncDeltaFileEntry).min(1).max(1e4)
+});
+var ApplySyncRequestInput = z28.object({
+  dataLakeSlug: z28.string(),
+  actions: z28.object({
+    upload: z28.array(z28.object({
+      relativePath: z28.string(),
+      fileName: z28.string(),
+      contentHash: z28.string().regex(sha256Regex)
+    })),
+    update: z28.array(z28.object({
+      existingFileId: z28.string(),
+      relativePath: z28.string(),
+      fileName: z28.string(),
+      contentHash: z28.string().regex(sha256Regex)
+    })),
+    remove: z28.array(z28.string()),
+    skip: z28.array(z28.string())
+  })
+});
+
 // ../../b4m-core/packages/common/dist/src/constants/user.js
 var PREDEFINED_USER_TAGS = ["Developer", "Analyst", "Customer", "Opti"];
 var isPredefinedTag = (tag) => {
@@ -6090,147 +6198,155 @@ var DATA_LAKES = [
     datalakeTag: "datalake:opti-knowledge"
   }
 ];
-function getAccessibleDataLakes(userTags) {
+function getAccessibleDataLakes(userTags, dynamicDataLakes) {
   const normalizedUserTags = userTags.map((tag) => tag.toLowerCase());
-  return DATA_LAKES.filter((dl) => normalizedUserTags.includes(dl.requiredUserTag.toLowerCase()));
+  let allLakes;
+  if (dynamicDataLakes && dynamicDataLakes.length > 0) {
+    const dynamicIds = new Set(dynamicDataLakes.map((d) => d.id));
+    const fallbacks = DATA_LAKES.filter((dl) => !dynamicIds.has(dl.id));
+    allLakes = [...dynamicDataLakes, ...fallbacks];
+  } else {
+    allLakes = DATA_LAKES;
+  }
+  return allLakes.filter((dl) => normalizedUserTags.includes(dl.requiredUserTag.toLowerCase()));
 }
-function getDataLakeTags(userTags) {
-  return getAccessibleDataLakes(userTags).map((dl) => dl.datalakeTag);
+function getDataLakeTags(userTags, dynamicDataLakes) {
+  return getAccessibleDataLakes(userTags, dynamicDataLakes).map((dl) => dl.datalakeTag);
 }
 
 // ../../b4m-core/packages/common/dist/src/llm.js
-import { z as z28 } from "zod";
-var DashboardParamsSchema = z28.object({
-  dashboardDataSources: z28.array(z28.object({
-    sourceName: z28.string(),
-    data: z28.any()
+import { z as z29 } from "zod";
+var DashboardParamsSchema = z29.object({
+  dashboardDataSources: z29.array(z29.object({
+    sourceName: z29.string(),
+    data: z29.any()
   })),
-  promptName: z28.string().optional()
-});
-var QuestMasterParamsSchema = z28.object({
-  questMasterPlanId: z28.string(),
-  questId: z28.string(),
-  subQuestId: z28.string()
-});
-var ResearchModeConfigurationSchema = z28.object({
-  id: z28.string(),
-  enabled: z28.boolean(),
-  model: z28.string(),
-  parameters: z28.object({
-    temperature: z28.number().optional(),
-    maxTokens: z28.number().optional(),
-    topP: z28.number().optional(),
-    presencePenalty: z28.number().optional(),
-    frequencyPenalty: z28.number().optional()
-  }),
-  label: z28.string().optional()
-});
-var ResearchModeParamsSchema = z28.object({
-  enabled: z28.boolean(),
-  configurations: z28.array(ResearchModeConfigurationSchema).max(4)
+  promptName: z29.string().optional()
+});
+var QuestMasterParamsSchema = z29.object({
+  questMasterPlanId: z29.string(),
+  questId: z29.string(),
+  subQuestId: z29.string()
+});
+var ResearchModeConfigurationSchema = z29.object({
+  id: z29.string(),
+  enabled: z29.boolean(),
+  model: z29.string(),
+  parameters: z29.object({
+    temperature: z29.number().optional(),
+    maxTokens: z29.number().optional(),
+    topP: z29.number().optional(),
+    presencePenalty: z29.number().optional(),
+    frequencyPenalty: z29.number().optional()
+  }),
+  label: z29.string().optional()
+});
+var ResearchModeParamsSchema = z29.object({
+  enabled: z29.boolean(),
+  configurations: z29.array(ResearchModeConfigurationSchema).max(4)
 });
 var GenerateImageIvokeParamsSchema = OpenAIImageGenerationInput.extend({
-  sessionId: z28.string(),
-  questId: z28.string().optional(),
-  organizationId: z28.string().nullable().optional(),
-  width: z28.number().optional(),
-  height: z28.number().optional(),
-  aspect_ratio: z28.string().optional(),
-  fabFileIds: z28.array(z28.string()).prefault([]),
-  tools: z28.array(z28.union([b4mLLMTools, z28.string()])).optional(),
-  promptEnhancement: z28.object({
-    originalPrompt: z28.string(),
-    enhancedPrompt: z28.string(),
-    promptWasEnhanced: z28.boolean()
+  sessionId: z29.string(),
+  questId: z29.string().optional(),
+  organizationId: z29.string().nullable().optional(),
+  width: z29.number().optional(),
+  height: z29.number().optional(),
+  aspect_ratio: z29.string().optional(),
+  fabFileIds: z29.array(z29.string()).prefault([]),
+  tools: z29.array(z29.union([b4mLLMTools, z29.string()])).optional(),
+  promptEnhancement: z29.object({
+    originalPrompt: z29.string(),
+    enhancedPrompt: z29.string(),
+    promptWasEnhanced: z29.boolean()
   }).optional()
 });
 var GenerateImageRequestBodySchema = GenerateImageIvokeParamsSchema.extend({
-  sessionId: z28.string().optional(),
-  sessionName: z28.string().optional(),
-  projectId: z28.string().optional()
+  sessionId: z29.string().optional(),
+  sessionName: z29.string().optional(),
+  projectId: z29.string().optional()
 });
 var GenerateImageToolCallSchema = OpenAIImageGenerationInput.extend({
-  safety_tolerance: z28.number().optional(),
-  prompt_upsampling: z28.boolean().optional(),
-  output_format: z28.enum(["jpeg", "png"]).nullable().optional(),
-  seed: z28.number().nullable().optional(),
-  editModel: z28.string().optional()
+  safety_tolerance: z29.number().optional(),
+  prompt_upsampling: z29.boolean().optional(),
+  output_format: z29.enum(["jpeg", "png"]).nullable().optional(),
+  seed: z29.number().nullable().optional(),
+  editModel: z29.string().optional()
   // Model to use for image editing operations (separate from generation model)
 }).omit({
   prompt: true
 });
 var EditImageRequestBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z28.string(),
-  questId: z28.string().optional(),
-  organizationId: z28.string().nullable().optional(),
-  aspect_ratio: z28.string().optional(),
-  fabFileIds: z28.array(z28.string()).prefault([]),
-  image: z28.string()
-});
-var ChatCompletionInvokeParamsSchema = z28.object({
+  sessionId: z29.string(),
+  questId: z29.string().optional(),
+  organizationId: z29.string().nullable().optional(),
+  aspect_ratio: z29.string().optional(),
+  fabFileIds: z29.array(z29.string()).prefault([]),
+  image: z29.string()
+});
+var ChatCompletionInvokeParamsSchema = z29.object({
   /** Notebook session ID */
-  sessionId: z28.string(),
-  historyCount: z28.number(),
+  sessionId: z29.string(),
+  historyCount: z29.number(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z28.object({
-    maxDepth: z28.number().optional(),
-    duration: z28.number().optional(),
+  deepResearchConfig: z29.object({
+    maxDepth: z29.number().optional(),
+    duration: z29.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z28.array(z28.any()).optional()
+    searchers: z29.array(z29.any()).optional()
   }).optional(),
-  fabFileIds: z28.array(z28.string()),
+  fabFileIds: z29.array(z29.string()),
   /** Prompt message */
-  message: z28.string(),
-  messageFileIds: z28.array(z28.string()).prefault([]),
-  questId: z28.string().optional(),
+  message: z29.string(),
+  messageFileIds: z29.array(z29.string()).prefault([]),
+  questId: z29.string().optional(),
   /** Extra context messages to include in the conversation from external sources */
-  extraContextMessages: z28.array(z28.object({
-    role: z28.enum(["user", "assistant", "system", "function", "tool"]),
-    content: z28.union([z28.string(), z28.array(z28.any())]),
-    fabFileIds: z28.array(z28.string()).optional()
+  extraContextMessages: z29.array(z29.object({
+    role: z29.enum(["user", "assistant", "system", "function", "tool"]),
+    content: z29.union([z29.string(), z29.array(z29.any())]),
+    fabFileIds: z29.array(z29.string()).optional()
   })).optional(),
   /** Dashboard related params */
   dashboardParams: DashboardParamsSchema.optional(),
   /** LLM params */
   params: ChatCompletionCreateInputSchema,
   /** Whether Quest Master is enabled */
-  enableQuestMaster: z28.boolean().optional(),
+  enableQuestMaster: z29.boolean().optional(),
   /** Whether Mementos is enabled */
-  enableMementos: z28.boolean().optional(),
+  enableMementos: z29.boolean().optional(),
   /** Whether Artifacts is enabled */
-  enableArtifacts: z28.boolean().optional(),
+  enableArtifacts: z29.boolean().optional(),
   /** Whether Agents is enabled */
-  enableAgents: z28.boolean().optional(),
+  enableAgents: z29.boolean().optional(),
   /** Whether Lattice (financial pro-forma modeling) is enabled */
-  enableLattice: z28.boolean().optional(),
+  enableLattice: z29.boolean().optional(),
   /** LLM tools to enable (built-in tools or MCP tool names) */
-  tools: z28.array(z28.union([b4mLLMTools, z28.string()])).optional(),
+  tools: z29.array(z29.union([b4mLLMTools, z29.string()])).optional(),
   /** Enabled MCP servers */
-  mcpServers: z28.array(z28.string()).optional(),
+  mcpServers: z29.array(z29.string()).optional(),
   /** Project ID */
-  projectId: z28.string().optional(),
+  projectId: z29.string().optional(),
   /** Organization ID */
-  organizationId: z28.string().nullable().optional(),
+  organizationId: z29.string().nullable().optional(),
   /** Tool prompt ID to use for the LLM */
-  toolPromptId: z28.string().optional(),
+  toolPromptId: z29.string().optional(),
   /** Quest Master related params */
   questMaster: QuestMasterParamsSchema.optional(),
   /** Research Mode related params */
   researchMode: ResearchModeParamsSchema.optional(),
   /** Fallback model ID to try if primary model fails */
-  fallbackModel: z28.string().optional(),
+  fallbackModel: z29.string().optional(),
   /** Embedding model to use */
-  embeddingModel: z28.string().optional(),
+  embeddingModel: z29.string().optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z28.string().optional(),
+  timezone: z29.string().optional(),
   /** Persona-based sub-agent filter — only these agent names are available for delegation */
-  allowedAgents: z28.array(z28.string()).optional()
+  allowedAgents: z29.array(z29.string()).optional()
 });
 var LLMApiRequestBodySchema = ChatCompletionInvokeParamsSchema.extend({
   /** Notebook session ID */
-  sessionId: z28.string().optional(),
+  sessionId: z29.string().optional(),
   /** Notebook session name */
-  sessionName: z28.string().optional()
+  sessionName: z29.string().optional()
 });
 
 // ../../b4m-core/packages/common/dist/src/utils.js
@@ -6379,16 +6495,16 @@ var extractSnippetMeta = (content) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/search.js
-import { z as z29 } from "zod";
-var searchSchema = z29.object({
-  search: z29.string().optional(),
-  pagination: z29.object({
-    page: z29.coerce.number().int().positive(),
-    limit: z29.coerce.number().int().positive()
+import { z as z30 } from "zod";
+var searchSchema = z30.object({
+  search: z30.string().optional(),
+  pagination: z30.object({
+    page: z30.coerce.number().int().positive(),
+    limit: z30.coerce.number().int().positive()
   }).optional(),
-  orderBy: z29.object({
-    field: z29.string(),
-    direction: z29.enum(["asc", "desc"])
+  orderBy: z30.object({
+    field: z30.string(),
+    direction: z30.enum(["asc", "desc"])
   }).optional()
 });
 
@@ -10019,89 +10135,89 @@ var getMcpProviderMetadata = (providerName) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/artifacts.js
-import { z as z30 } from "zod";
-var ArtifactStatusSchema = z30.enum(["draft", "review", "published", "archived", "deleted"]);
-var VisibilitySchema = z30.enum(["private", "project", "organization", "public"]);
-var ArtifactPermissionsSchema = z30.object({
-  canRead: z30.array(z30.string()),
-  canWrite: z30.array(z30.string()),
-  canDelete: z30.array(z30.string()),
-  isPublic: z30.boolean().prefault(false),
-  inheritFromProject: z30.boolean().prefault(true)
-});
-var BaseArtifactSchema = z30.object({
-  id: z30.uuid(),
+import { z as z31 } from "zod";
+var ArtifactStatusSchema = z31.enum(["draft", "review", "published", "archived", "deleted"]);
+var VisibilitySchema = z31.enum(["private", "project", "organization", "public"]);
+var ArtifactPermissionsSchema = z31.object({
+  canRead: z31.array(z31.string()),
+  canWrite: z31.array(z31.string()),
+  canDelete: z31.array(z31.string()),
+  isPublic: z31.boolean().prefault(false),
+  inheritFromProject: z31.boolean().prefault(true)
+});
+var BaseArtifactSchema = z31.object({
+  id: z31.uuid(),
   type: ArtifactTypeSchema,
-  title: z30.string().min(1).max(255),
-  description: z30.string().max(1e3).optional(),
+  title: z31.string().min(1).max(255),
+  description: z31.string().max(1e3).optional(),
   // Versioning
-  version: z30.int().positive().prefault(1),
-  versionTag: z30.string().max(100).optional(),
-  currentVersionId: z30.uuid().optional(),
-  parentVersionId: z30.uuid().optional(),
+  version: z31.int().positive().prefault(1),
+  versionTag: z31.string().max(100).optional(),
+  currentVersionId: z31.uuid().optional(),
+  parentVersionId: z31.uuid().optional(),
   // Timestamps
-  createdAt: z30.date(),
-  updatedAt: z30.date(),
-  publishedAt: z30.date().optional(),
-  deletedAt: z30.date().optional(),
+  createdAt: z31.date(),
+  updatedAt: z31.date(),
+  publishedAt: z31.date().optional(),
+  deletedAt: z31.date().optional(),
   // Ownership & Access
-  userId: z30.string(),
-  projectId: z30.string().optional(),
-  organizationId: z30.string().optional(),
+  userId: z31.string(),
+  projectId: z31.string().optional(),
+  organizationId: z31.string().optional(),
   visibility: VisibilitySchema.prefault("private"),
   permissions: ArtifactPermissionsSchema,
   // Relationships
-  sourceQuestId: z30.string().optional(),
-  sessionId: z30.string().optional(),
-  parentArtifactId: z30.uuid().optional(),
+  sourceQuestId: z31.string().optional(),
+  sessionId: z31.string().optional(),
+  parentArtifactId: z31.uuid().optional(),
   // Status
   status: ArtifactStatusSchema.prefault("draft"),
-  tags: z30.array(z30.string().max(50)).max(20).prefault([]),
+  tags: z31.array(z31.string().max(50)).max(20).prefault([]),
   // Content
-  contentHash: z30.string(),
-  contentSize: z30.int().nonnegative(),
+  contentHash: z31.string(),
+  contentSize: z31.int().nonnegative(),
   // Metadata
-  metadata: z30.record(z30.string(), z30.unknown()).optional()
+  metadata: z31.record(z31.string(), z31.unknown()).optional()
 });
-var EnhancedArtifactMetadataSchema = z30.object({
-  language: z30.string().optional(),
-  dependencies: z30.array(z30.string()).optional(),
-  settings: z30.record(z30.string(), z30.unknown()).optional()
+var EnhancedArtifactMetadataSchema = z31.object({
+  language: z31.string().optional(),
+  dependencies: z31.array(z31.string()).optional(),
+  settings: z31.record(z31.string(), z31.unknown()).optional()
 });
 var ReactArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z30.literal("react"),
-  content: z30.string(),
+  type: z31.literal("react"),
+  content: z31.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    dependencies: z30.array(z30.string()),
-    props: z30.record(z30.string(), z30.unknown()).optional(),
-    hasDefaultExport: z30.boolean(),
-    errorBoundary: z30.boolean().prefault(true)
+    dependencies: z31.array(z31.string()),
+    props: z31.record(z31.string(), z31.unknown()).optional(),
+    hasDefaultExport: z31.boolean(),
+    errorBoundary: z31.boolean().prefault(true)
   })
 });
 var HtmlArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z30.literal("html"),
-  content: z30.string(),
+  type: z31.literal("html"),
+  content: z31.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    allowedScripts: z30.array(z30.string()).prefault([]),
-    cspPolicy: z30.string().optional(),
-    sanitized: z30.boolean().prefault(false)
+    allowedScripts: z31.array(z31.string()).prefault([]),
+    cspPolicy: z31.string().optional(),
+    sanitized: z31.boolean().prefault(false)
   })
 });
 var SvgArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z30.literal("svg"),
-  content: z30.string(),
+  type: z31.literal("svg"),
+  content: z31.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    viewBox: z30.string().optional(),
-    width: z30.number().positive().optional(),
-    height: z30.number().positive().optional(),
-    sanitized: z30.boolean().prefault(false)
+    viewBox: z31.string().optional(),
+    width: z31.number().positive().optional(),
+    height: z31.number().positive().optional(),
+    sanitized: z31.boolean().prefault(false)
   })
 });
 var MermaidArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z30.literal("mermaid"),
-  content: z30.string(),
+  type: z31.literal("mermaid"),
+  content: z31.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    chartType: z30.enum([
+    chartType: z31.enum([
       "flowchart",
       "sequenceDiagram",
       "classDiagram",
@@ -10111,17 +10227,17 @@ var MermaidArtifactV2Schema = BaseArtifactSchema.extend({
       "pie",
       "mindmap"
     ]).optional(),
-    description: z30.string().optional()
+    description: z31.string().optional()
   })
 });
 var PythonArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z30.literal("python"),
-  content: z30.string(),
+  type: z31.literal("python"),
+  content: z31.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    packages: z30.array(z30.string()).default([]),
-    hasOutput: z30.boolean().default(false),
-    executionState: z30.enum(["idle", "running", "completed", "error"]).optional(),
-    lastExecutionTime: z30.number().optional()
+    packages: z31.array(z31.string()).default([]),
+    hasOutput: z31.boolean().default(false),
+    executionState: z31.enum(["idle", "running", "completed", "error"]).optional(),
+    lastExecutionTime: z31.number().optional()
   })
 });
 var ArtifactStatuses;
@@ -10152,39 +10268,39 @@ var validatePythonArtifactV2 = (data) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/questmaster.js
-import { z as z31 } from "zod";
-var QuestStatusSchema = z31.enum(["pending", "in-progress", "completed", "skipped"]);
-var QuestSchema = z31.object({
-  id: z31.uuid(),
-  title: z31.string().min(1).max(255),
-  description: z31.string().max(1e3),
+import { z as z32 } from "zod";
+var QuestStatusSchema = z32.enum(["pending", "in-progress", "completed", "skipped"]);
+var QuestSchema = z32.object({
+  id: z32.uuid(),
+  title: z32.string().min(1).max(255),
+  description: z32.string().max(1e3),
   status: QuestStatusSchema.prefault("pending"),
-  order: z31.int().nonnegative(),
-  dependencies: z31.array(z31.uuid()).optional(),
-  estimatedMinutes: z31.int().positive().optional(),
-  completedAt: z31.date().optional(),
-  completedBy: z31.string().optional(),
-  metadata: z31.record(z31.string(), z31.unknown()).optional()
-});
-var QuestResourceSchema = z31.object({
-  type: z31.enum(["documentation", "tutorial", "example", "tool"]),
-  title: z31.string().min(1).max(255),
-  url: z31.url(),
-  description: z31.string().max(500).optional()
-});
-var QuestMasterContentSchema = z31.object({
-  goal: z31.string().min(1).max(500),
-  quests: z31.array(QuestSchema).min(1),
-  totalSteps: z31.int().positive(),
-  estimatedDuration: z31.int().positive().optional(),
-  complexity: z31.enum(["low", "medium", "high"]),
-  category: z31.string().max(100).optional(),
-  prerequisites: z31.array(z31.string().max(255)).optional(),
-  completionCriteria: z31.array(z31.string().max(500)).optional(),
-  resources: z31.array(QuestResourceSchema).optional()
+  order: z32.int().nonnegative(),
+  dependencies: z32.array(z32.uuid()).optional(),
+  estimatedMinutes: z32.int().positive().optional(),
+  completedAt: z32.date().optional(),
+  completedBy: z32.string().optional(),
+  metadata: z32.record(z32.string(), z32.unknown()).optional()
+});
+var QuestResourceSchema = z32.object({
+  type: z32.enum(["documentation", "tutorial", "example", "tool"]),
+  title: z32.string().min(1).max(255),
+  url: z32.url(),
+  description: z32.string().max(500).optional()
+});
+var QuestMasterContentSchema = z32.object({
+  goal: z32.string().min(1).max(500),
+  quests: z32.array(QuestSchema).min(1),
+  totalSteps: z32.int().positive(),
+  estimatedDuration: z32.int().positive().optional(),
+  complexity: z32.enum(["low", "medium", "high"]),
+  category: z32.string().max(100).optional(),
+  prerequisites: z32.array(z32.string().max(255)).optional(),
+  completionCriteria: z32.array(z32.string().max(500)).optional(),
+  resources: z32.array(QuestResourceSchema).optional()
 });
 var QuestMasterArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z31.literal("questmaster"),
+  type: z32.literal("questmaster"),
   content: QuestMasterContentSchema
 });
 var validateQuest = (data) => {
@@ -10201,13 +10317,13 @@ var safeParseQuestMasterArtifactV2 = (data) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/curation.js
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var CurationType;
 (function(CurationType2) {
   CurationType2["TRANSCRIPT"] = "transcript";
   CurationType2["EXECUTIVE_SUMMARY"] = "executive_summary";
 })(CurationType || (CurationType = {}));
-var CurationTypeSchema = z32.enum(CurationType);
+var CurationTypeSchema = z33.enum(CurationType);
 var CurationArtifactType;
 (function(CurationArtifactType2) {
   CurationArtifactType2["CODE"] = "code";
@@ -10220,7 +10336,7 @@ var CurationArtifactType;
   CurationArtifactType2["DEEP_RESEARCH"] = "deep_research";
   CurationArtifactType2["IMAGE"] = "image";
 })(CurationArtifactType || (CurationArtifactType = {}));
-var CurationArtifactTypeSchema = z32.enum([
+var CurationArtifactTypeSchema = z33.enum([
   "CODE",
   "REACT",
   "HTML",
@@ -10231,28 +10347,28 @@ var CurationArtifactTypeSchema = z32.enum([
   "DEEP_RESEARCH",
   "IMAGE"
 ]);
-var ExportFormatSchema = z32.enum(["markdown", "txt", "html"]);
-var CurationOptionsSchema = z32.object({
+var ExportFormatSchema = z33.enum(["markdown", "txt", "html"]);
+var CurationOptionsSchema = z33.object({
   /** Curation type: transcript (Option 1) or executive_summary (Option 2) */
   curationType: CurationTypeSchema.prefault(CurationType.TRANSCRIPT),
   /** Include code artifacts in the curated notebook */
-  includeCode: z32.boolean().prefault(true),
+  includeCode: z33.boolean().prefault(true),
   /** Include diagrams (Mermaid, SVG) in the curated notebook */
-  includeDiagrams: z32.boolean().prefault(true),
+  includeDiagrams: z33.boolean().prefault(true),
   /** Include data visualizations (Recharts) in the curated notebook */
-  includeDataViz: z32.boolean().prefault(true),
+  includeDataViz: z33.boolean().prefault(true),
   /** Include QuestMaster plans in the curated notebook */
-  includeQuestMaster: z32.boolean().prefault(true),
+  includeQuestMaster: z33.boolean().prefault(true),
   /** Include Deep Research findings in the curated notebook */
-  includeResearch: z32.boolean().prefault(true),
+  includeResearch: z33.boolean().prefault(true),
   /** Include images in the curated notebook */
-  includeImages: z32.boolean().prefault(true),
+  includeImages: z33.boolean().prefault(true),
   /** Token budget for processing (varies by curation type) */
-  tokenBudget: z32.number().optional(),
+  tokenBudget: z33.number().optional(),
   /** Export format for the curated notebook */
   exportFormat: ExportFormatSchema.prefault("markdown"),
   /** Custom notebook name (optional, defaults to curated-notebook-{sessionId}) */
-  customNotebookName: z32.string().optional()
+  customNotebookName: z33.string().optional()
 });
 
 // ../../b4m-core/packages/common/dist/src/utils/artifactHelpers.js
@@ -11717,6 +11833,7 @@ export {
   HeartbeatPongAction,
   InvalidateQueryAction,
   UpdateFabFileChunkVectorStatusAction,
+  DataLakeBatchProgressAction,
   UpdateResearchTaskStatusAction,
   ImportHistoryJobProgressUpdateAction,
   ResearchModeStreamAction,
@@ -11917,6 +12034,17 @@ export {
   safeParseLatticeModel,
   safeParseLatticeEntity,
   safeParseLatticeRule,
+  CreateDataLakeRequestInput,
+  UpdateDataLakeRequestInput,
+  DataLakeListRequestInput,
+  BatchPresignedUrlFileItem,
+  BatchPresignedUrlRequestInput,
+  InferTaxonomyFolderEntry,
+  InferTaxonomyRequestInput,
+  CheckDuplicatesRequestInput,
+  SyncDeltaFileEntry,
+  ComputeSyncDeltaRequestInput,
+  ApplySyncRequestInput,
   PREDEFINED_USER_TAGS,
   isPredefinedTag,
   getPredefinedTags,