@bike4mind/cli 0.2.0 → 0.2.1-epic-lattice.16998

package/dist/{chunk-WR6YZRQV.js → chunk-RVGWNNDF.js}

@@ -230,7 +230,14 @@ var b4mLLMTools = z3.enum([
   "create_file",
   "glob_files",
   "grep_search",
-  "delete_file"
+  "delete_file",
+  // Lattice financial modeling tools
+  "lattice_create_model",
+  "lattice_add_entity",
+  "lattice_set_value",
+  "lattice_create_rule",
+  "lattice_query",
+  "lattice_explain"
 ]);
 var B4MLLMToolsList = b4mLLMTools.options.map((tool) => tool);
 var RechartsChartTypeSchema = z3.enum([
@@ -286,7 +293,9 @@ var ArtifactTypeSchema = z4.enum([
   "code",
   "quest",
   "file",
-  "questmaster"
+  "questmaster",
+  "lattice"
+  // Financial pro-forma models
 ]);
 var ArtifactSchema = z4.object({
   id: z4.string(),
@@ -366,6 +375,17 @@ var RechartsArtifactSchema = ArtifactSchema.extend({
     colors: z4.array(z4.string()).optional()
   })
 });
+var LatticeArtifactSchema = ArtifactSchema.extend({
+  type: z4.literal("lattice"),
+  metadata: ArtifactMetadataSchema.extend({
+    modelType: z4.enum(["income_statement", "balance_sheet", "cashflow", "saas_metrics", "custom"]).optional(),
+    periodGrain: z4.enum(["month", "quarter", "year"]).optional(),
+    currency: z4.string().default("USD"),
+    entityCount: z4.number().int().nonnegative().optional(),
+    ruleCount: z4.number().int().nonnegative().optional(),
+    lastComputedAt: z4.date().optional()
+  })
+});
 var MermaidChartMetadataSchema = z4.object({
   chartType: z4.enum([
     "flowchart",
@@ -399,7 +419,8 @@ var ClaudeArtifactMimeTypes = {
   MERMAID: "application/vnd.ant.mermaid",
   RECHARTS: "application/vnd.ant.recharts",
   CODE: "application/vnd.ant.code",
-  MARKDOWN: "text/markdown"
+  MARKDOWN: "text/markdown",
+  LATTICE: "application/vnd.b4m.lattice"
 };
 
 // ../../b4m-core/packages/common/dist/src/types/entities/AppFileTypes.js
@@ -4019,6 +4040,445 @@ var InternalTeamMemberSchema = z22.object({
 });
 var InternalTeamMemberListSchema = z22.array(InternalTeamMemberSchema);
 
+// ../../b4m-core/packages/common/dist/src/schemas/lattice.js
+import { z as z23 } from "zod";
+var LatticeDataTypeSchema = z23.enum([
+  "number",
+  "currency",
+  "percentage",
+  "string",
+  "boolean",
+  "date",
+  "datetime"
+]);
+var LatticeEntityTypeSchema = z23.enum(["line_item", "account", "period", "category", "scenario", "custom"]);
+var LatticeRelationshipTypeSchema = z23.enum(["parent_child", "temporal", "reference", "derived"]);
+var LatticeRuleTypeSchema = z23.enum(["formula", "aggregation", "constraint", "transformation", "conditional"]);
+var LatticeOperationSchema = z23.enum([
+  // Arithmetic
+  "ADD",
+  "SUBTRACT",
+  "MULTIPLY",
+  "DIVIDE",
+  "ABS",
+  "ROUND",
+  "FLOOR",
+  "CEIL",
+  "POWER",
+  "SQRT",
+  // Aggregation
+  "SUM",
+  "AVERAGE",
+  "MIN",
+  "MAX",
+  "COUNT",
+  "MEDIAN",
+  // Logical
+  "IF",
+  "AND",
+  "OR",
+  "NOT",
+  "EQUALS",
+  "GREATER_THAN",
+  "LESS_THAN",
+  "GREATER_THAN_OR_EQUAL",
+  "LESS_THAN_OR_EQUAL",
+  "BETWEEN",
+  // Financial
+  "PERCENT_OF",
+  "GROWTH_RATE",
+  "NPV",
+  "IRR",
+  "PMT",
+  "FV",
+  "PV",
+  // Special
+  "REFERENCE",
+  "LOOKUP"
+]);
+var LatticeConditionOperatorSchema = z23.enum(["==", "!=", ">", "<", ">=", "<=", "contains", "in"]);
+var LatticePeriodGrainSchema = z23.enum(["day", "week", "month", "quarter", "year"]);
+var LatticeNegativeFormatSchema = z23.enum(["parentheses", "minus", "red"]);
+var LatticeViewTypeSchema = z23.enum([
+  "table",
+  "pivot",
+  "time_series",
+  "comparison",
+  "summary_card",
+  "waterfall",
+  "tree"
+]);
+var LatticeModelTypeSchema = z23.enum([
+  "income_statement",
+  "balance_sheet",
+  "cashflow",
+  "saas_metrics",
+  "dcf",
+  "lbo",
+  "custom"
+]);
+var LatticeIntentTypeSchema = z23.enum([
+  "CREATE_ENTITY",
+  "SET_VALUE",
+  "CREATE_RULE",
+  "QUERY_VALUE",
+  "QUERY_AGGREGATE",
+  "CREATE_VIEW",
+  "COMPARE",
+  "FORECAST",
+  "EXPLAIN",
+  "UNDO",
+  "REDO",
+  "LIST",
+  "DELETE",
+  "AMBIGUOUS"
+]);
+var LatticeErrorTypeSchema = z23.enum([
+  "PARSE_ERROR",
+  "AMBIGUOUS_REFERENCE",
+  "ENTITY_NOT_FOUND",
+  "RULE_NOT_FOUND",
+  "CIRCULAR_DEPENDENCY",
+  "TYPE_MISMATCH",
+  "DIVISION_BY_ZERO",
+  "MISSING_DATA",
+  "INVALID_PERIOD",
+  "CONSTRAINT_VIOLATION",
+  "INVALID_OPERATION"
+]);
+var LatticeOperationTypeSchema = z23.enum([
+  "CREATE_ENTITY",
+  "UPDATE_ENTITY",
+  "DELETE_ENTITY",
+  "CREATE_RULE",
+  "UPDATE_RULE",
+  "DELETE_RULE",
+  "SET_VALUE",
+  "CREATE_VIEW",
+  "UPDATE_VIEW",
+  "DELETE_VIEW",
+  "CREATE_SCENARIO",
+  "UPDATE_SCENARIO",
+  "DELETE_SCENARIO",
+  "UPDATE_SETTINGS"
+]);
+var LatticeExportFormatSchema = z23.enum(["csv", "json", "xlsx"]);
+var LatticePrimitiveValueSchema = z23.union([z23.number(), z23.string(), z23.boolean(), z23.date(), z23.null()]);
+var LatticeAttributeSchema = z23.object({
+  key: z23.string().min(1).max(100),
+  value: LatticePrimitiveValueSchema,
+  dataType: LatticeDataTypeSchema,
+  isComputed: z23.boolean().default(false),
+  computedByRuleId: z23.string().optional(),
+  timestamp: z23.number().optional(),
+  metadata: z23.record(z23.unknown()).optional()
+});
+var LatticeEntitySchema = z23.object({
+  id: z23.string().min(1).max(100),
+  type: LatticeEntityTypeSchema,
+  name: z23.string().min(1).max(255),
+  displayName: z23.string().max(255).optional(),
+  attributes: z23.array(LatticeAttributeSchema).default([]),
+  metadata: z23.record(z23.unknown()).default({}),
+  createdAt: z23.date(),
+  updatedAt: z23.date()
+});
+var LatticeRelationshipSchema = z23.object({
+  id: z23.string().min(1).max(100),
+  type: LatticeRelationshipTypeSchema,
+  fromEntityId: z23.string(),
+  toEntityId: z23.string(),
+  metadata: z23.record(z23.unknown()).optional()
+});
+var LatticeDataStoreSchema = z23.object({
+  entities: z23.array(LatticeEntitySchema).default([]),
+  relationships: z23.array(LatticeRelationshipSchema).default([])
+});
+var LatticeInputSchema = z23.object({
+  type: z23.enum(["entity", "attribute", "rule", "literal", "range"]),
+  ref: z23.string(),
+  selector: z23.string().optional()
+});
+var LatticeOutputSchema = z23.object({
+  targetEntityId: z23.string(),
+  targetAttribute: z23.string(),
+  dataType: LatticeDataTypeSchema
+});
+var LatticeConditionSchema = z23.object({
+  left: LatticeInputSchema,
+  operator: LatticeConditionOperatorSchema,
+  right: LatticeInputSchema,
+  logicalJoin: z23.enum(["AND", "OR"]).optional()
+});
+var LatticeRuleDefinitionSchema = z23.object({
+  operation: LatticeOperationSchema,
+  inputs: z23.array(LatticeInputSchema).min(1),
+  output: LatticeOutputSchema,
+  conditions: z23.array(LatticeConditionSchema).optional()
+});
+var LatticeRuleSchema = z23.object({
+  id: z23.string().min(1).max(100),
+  name: z23.string().min(1).max(255),
+  description: z23.string().max(1e3).optional(),
+  type: LatticeRuleTypeSchema,
+  definition: LatticeRuleDefinitionSchema,
+  dependencies: z23.array(z23.string()).default([]),
+  priority: z23.number().int().default(0),
+  enabled: z23.boolean().default(true),
+  createdAt: z23.date(),
+  updatedAt: z23.date()
+});
+var LatticeRulesetSchema = z23.object({
+  id: z23.string().min(1).max(100),
+  name: z23.string().min(1).max(255),
+  ruleIds: z23.array(z23.string()).default([]),
+  description: z23.string().max(1e3).optional()
+});
+var LatticeRulesStoreSchema = z23.object({
+  rules: z23.array(LatticeRuleSchema).default([]),
+  rulesets: z23.array(LatticeRulesetSchema).default([])
+});
+var LatticeRowConfigSchema = z23.object({
+  source: z23.enum(["entity", "rule", "category"]),
+  ref: z23.string(),
+  label: z23.string().optional(),
+  indent: z23.number().int().min(0).max(10).optional(),
+  isSummary: z23.boolean().optional()
+});
+var LatticeColumnConfigSchema = z23.object({
+  source: z23.enum(["period", "scenario", "attribute", "computed"]),
+  ref: z23.string(),
+  label: z23.string().optional(),
+  width: z23.number().positive().optional()
+});
+var LatticeFilterSchema = z23.object({
+  field: z23.string(),
+  operator: LatticeConditionOperatorSchema,
+  value: LatticePrimitiveValueSchema
+});
+var LatticeSortConfigSchema = z23.object({
+  field: z23.string(),
+  direction: z23.enum(["asc", "desc"])
+});
+var LatticeGroupConfigSchema = z23.object({
+  groupBy: z23.array(z23.string()),
+  aggregation: LatticeOperationSchema
+});
+var LatticeFormatConfigSchema = z23.object({
+  numberFormat: z23.string().optional(),
+  currencySymbol: z23.string().max(10).optional(),
+  percentageDecimals: z23.number().int().min(0).max(10).optional(),
+  negativeFormat: LatticeNegativeFormatSchema.optional(),
+  showGridLines: z23.boolean().optional(),
+  zebra: z23.boolean().optional(),
+  compactMode: z23.boolean().optional()
+});
+var LatticeViewConfigSchema = z23.object({
+  rows: z23.array(LatticeRowConfigSchema).optional(),
+  columns: z23.array(LatticeColumnConfigSchema).optional(),
+  filters: z23.array(LatticeFilterSchema).optional(),
+  sorting: z23.array(LatticeSortConfigSchema).optional(),
+  grouping: LatticeGroupConfigSchema.optional(),
+  formatting: LatticeFormatConfigSchema.optional()
+});
+var LatticeViewSchema = z23.object({
+  id: z23.string().min(1).max(100),
+  type: LatticeViewTypeSchema,
+  name: z23.string().min(1).max(255),
+  config: LatticeViewConfigSchema,
+  createdAt: z23.date(),
+  updatedAt: z23.date()
+});
+var LatticeViewStoreSchema = z23.object({
+  views: z23.array(LatticeViewSchema).default([]),
+  activeViewId: z23.string().optional()
+});
+var LatticeModelSettingsSchema = z23.object({
+  currency: z23.string().min(1).max(10).default("USD"),
+  fiscalYearStart: z23.string().regex(/^\d{2}-\d{2}$/).default("01-01"),
+  periodGrain: LatticePeriodGrainSchema.default("quarter"),
+  defaultDecimalPlaces: z23.number().int().min(0).max(10).default(2),
+  negativeFormat: LatticeNegativeFormatSchema.default("parentheses")
+});
+var LatticeHistoryOperationSchema = z23.object({
+  id: z23.string(),
+  type: LatticeOperationTypeSchema,
+  timestamp: z23.date(),
+  data: z23.record(z23.unknown()),
+  inverse: z23.record(z23.unknown()),
+  description: z23.string(),
+  messageId: z23.string().optional()
+});
+var LatticeScenarioOverrideSchema = z23.object({
+  entityId: z23.string(),
+  attributeKey: z23.string(),
+  value: LatticePrimitiveValueSchema
+});
+var LatticeScenarioSchema = z23.object({
+  id: z23.string().min(1).max(100),
+  name: z23.string().min(1).max(255),
+  description: z23.string().max(1e3).optional(),
+  overrides: z23.array(LatticeScenarioOverrideSchema).default([]),
+  createdAt: z23.date(),
+  updatedAt: z23.date()
+});
+var LatticeComputedValueSchema = z23.object({
+  value: LatticePrimitiveValueSchema,
+  computedByRuleId: z23.string(),
+  computedAt: z23.date()
+});
+var LatticeComputedValuesSchema = z23.record(z23.record(LatticeComputedValueSchema));
+var LatticeCalculationStepSchema = z23.object({
+  ruleId: z23.string(),
+  ruleName: z23.string(),
+  operation: LatticeOperationSchema,
+  inputs: z23.array(z23.object({
+    name: z23.string(),
+    value: LatticePrimitiveValueSchema
+  })),
+  output: LatticePrimitiveValueSchema
+});
+var LatticeCalculationChainSchema = z23.object({
+  targetEntity: z23.string(),
+  targetAttribute: z23.string(),
+  finalValue: LatticePrimitiveValueSchema,
+  steps: z23.array(LatticeCalculationStepSchema)
+});
+var LatticeModelSchema = z23.object({
+  // Identity
+  id: z23.string().min(1).max(100),
+  name: z23.string().min(1).max(255),
+  description: z23.string().max(2e3).optional(),
+  modelType: LatticeModelTypeSchema.default("custom"),
+  // Ownership
+  userId: z23.string(),
+  sessionId: z23.string().optional(),
+  projectId: z23.string().optional(),
+  organizationId: z23.string().optional(),
+  // Core Data Layers
+  data: LatticeDataStoreSchema.default({ entities: [], relationships: [] }),
+  rules: LatticeRulesStoreSchema.default({ rules: [], rulesets: [] }),
+  views: LatticeViewStoreSchema.default({ views: [] }),
+  // Settings
+  settings: LatticeModelSettingsSchema.default({}),
+  // Scenarios
+  scenarios: z23.array(LatticeScenarioSchema).default([]),
+  activeScenarioId: z23.string().optional(),
+  // History
+  operations: z23.array(LatticeHistoryOperationSchema).default([]),
+  operationIndex: z23.number().int().min(-1).default(-1),
+  // Versioning
+  version: z23.number().int().positive().default(1),
+  contentHash: z23.string().optional(),
+  // Timestamps
+  createdAt: z23.date(),
+  updatedAt: z23.date(),
+  lastComputedAt: z23.date().optional(),
+  // Soft delete
+  deletedAt: z23.date().optional()
+});
+var LatticeExtractedEntitySchema = z23.object({
+  type: z23.enum([
+    "line_item_name",
+    "period",
+    "amount",
+    "percentage",
+    "operation",
+    "comparison_operator",
+    "entity_reference",
+    "category",
+    "scenario"
+  ]),
+  value: z23.string(),
+  normalizedValue: z23.union([z23.string(), z23.number()]).optional(),
+  position: z23.object({
+    start: z23.number().int().min(0),
+    end: z23.number().int().min(0)
+  }),
+  confidence: z23.number().min(0).max(1)
+});
+var LatticeParsedIntentSchema = z23.object({
+  intent: LatticeIntentTypeSchema,
+  confidence: z23.number().min(0).max(1),
+  entities: z23.array(LatticeExtractedEntitySchema),
+  rawInput: z23.string(),
+  normalizedInput: z23.string(),
+  suggestedOperations: z23.array(LatticeHistoryOperationSchema).optional(),
+  ambiguousRefs: z23.array(z23.object({
+    value: z23.string(),
+    candidates: z23.array(z23.string())
+  })).optional(),
+  clarificationNeeded: z23.string().optional()
+});
+var LatticeErrorSchema = z23.object({
+  type: LatticeErrorTypeSchema,
+  message: z23.string(),
+  suggestions: z23.array(z23.string()).optional(),
+  context: z23.object({
+    input: z23.string().optional(),
+    position: z23.number().optional(),
+    relatedEntities: z23.array(z23.string()).optional(),
+    relatedRules: z23.array(z23.string()).optional()
+  }).optional()
+});
+var CreateLatticeModelRequestSchema = z23.object({
+  name: z23.string().min(1).max(255),
+  description: z23.string().max(2e3).optional(),
+  modelType: LatticeModelTypeSchema.optional(),
+  sessionId: z23.string().optional(),
+  projectId: z23.string().optional(),
+  settings: LatticeModelSettingsSchema.partial().optional()
+});
+var UpdateLatticeModelRequestSchema = z23.object({
+  name: z23.string().min(1).max(255).optional(),
+  description: z23.string().max(2e3).optional(),
+  settings: LatticeModelSettingsSchema.partial().optional(),
+  data: LatticeDataStoreSchema.optional(),
+  rules: LatticeRulesStoreSchema.optional(),
+  views: LatticeViewStoreSchema.optional()
+});
+var ComputeLatticeRequestSchema = z23.object({
+  scenarioId: z23.string().optional()
+});
+var ComputeLatticeResponseSchema = z23.object({
+  computedValues: LatticeComputedValuesSchema,
+  duration: z23.number(),
+  errors: z23.array(LatticeErrorSchema).optional()
+});
+var ExplainLatticeRequestSchema = z23.object({
+  entityId: z23.string(),
+  attributeKey: z23.string()
+});
+var ExplainLatticeResponseSchema = z23.object({
+  chain: LatticeCalculationChainSchema
+});
+var ExportLatticeRequestSchema = z23.object({
+  format: LatticeExportFormatSchema,
+  viewId: z23.string().optional(),
+  scenarioId: z23.string().optional()
+});
+var validateLatticeModel = (data) => {
+  return LatticeModelSchema.parse(data);
+};
+var validateLatticeEntity = (data) => {
+  return LatticeEntitySchema.parse(data);
+};
+var validateLatticeRule = (data) => {
+  return LatticeRuleSchema.parse(data);
+};
+var validateLatticeParsedIntent = (data) => {
+  return LatticeParsedIntentSchema.parse(data);
+};
+var safeParseLatticeModel = (data) => {
+  return LatticeModelSchema.safeParse(data);
+};
+var safeParseLatticeEntity = (data) => {
+  return LatticeEntitySchema.safeParse(data);
+};
+var safeParseLatticeRule = (data) => {
+  return LatticeRuleSchema.safeParse(data);
+};
+
 // ../../b4m-core/packages/common/dist/src/constants/user.js
 var PREDEFINED_USER_TAGS = ["Developer", "Analyst", "Customer"];
 var isPredefinedTag = (tag) => {
@@ -4029,128 +4489,128 @@ var getPredefinedTags = () => {
 };
 
 // ../../b4m-core/packages/common/dist/src/llm.js
-import { z as z23 } from "zod";
-var DashboardParamsSchema = z23.object({
-  dashboardDataSources: z23.array(z23.object({
-    sourceName: z23.string(),
-    data: z23.any()
+import { z as z24 } from "zod";
+var DashboardParamsSchema = z24.object({
+  dashboardDataSources: z24.array(z24.object({
+    sourceName: z24.string(),
+    data: z24.any()
   })),
-  promptName: z23.string().optional()
+  promptName: z24.string().optional()
 });
-var QuestMasterParamsSchema = z23.object({
-  questMasterPlanId: z23.string(),
-  questId: z23.string(),
-  subQuestId: z23.string()
+var QuestMasterParamsSchema = z24.object({
+  questMasterPlanId: z24.string(),
+  questId: z24.string(),
+  subQuestId: z24.string()
 });
-var ResearchModeConfigurationSchema = z23.object({
-  id: z23.string(),
-  enabled: z23.boolean(),
-  model: z23.string(),
-  parameters: z23.object({
-    temperature: z23.number().optional(),
-    maxTokens: z23.number().optional(),
-    topP: z23.number().optional(),
-    presencePenalty: z23.number().optional(),
-    frequencyPenalty: z23.number().optional()
+var ResearchModeConfigurationSchema = z24.object({
+  id: z24.string(),
+  enabled: z24.boolean(),
+  model: z24.string(),
+  parameters: z24.object({
+    temperature: z24.number().optional(),
+    maxTokens: z24.number().optional(),
+    topP: z24.number().optional(),
+    presencePenalty: z24.number().optional(),
+    frequencyPenalty: z24.number().optional()
   }),
-  label: z23.string().optional()
+  label: z24.string().optional()
 });
-var ResearchModeParamsSchema = z23.object({
-  enabled: z23.boolean(),
-  configurations: z23.array(ResearchModeConfigurationSchema).max(4)
+var ResearchModeParamsSchema = z24.object({
+  enabled: z24.boolean(),
+  configurations: z24.array(ResearchModeConfigurationSchema).max(4)
 });
 var GenerateImageIvokeParamsSchema = OpenAIImageGenerationInput.extend({
-  sessionId: z23.string(),
-  questId: z23.string().optional(),
-  width: z23.number().optional(),
-  height: z23.number().optional(),
-  aspect_ratio: z23.string().optional(),
-  fabFileIds: z23.array(z23.string()).default([]),
-  tools: z23.array(z23.union([b4mLLMTools, z23.string()])).optional(),
-  promptEnhancement: z23.object({
-    originalPrompt: z23.string(),
-    enhancedPrompt: z23.string(),
-    promptWasEnhanced: z23.boolean()
+  sessionId: z24.string(),
+  questId: z24.string().optional(),
+  width: z24.number().optional(),
+  height: z24.number().optional(),
+  aspect_ratio: z24.string().optional(),
+  fabFileIds: z24.array(z24.string()).default([]),
+  tools: z24.array(z24.union([b4mLLMTools, z24.string()])).optional(),
+  promptEnhancement: z24.object({
+    originalPrompt: z24.string(),
+    enhancedPrompt: z24.string(),
+    promptWasEnhanced: z24.boolean()
   }).optional()
 });
 var GenerateImageRequestBodySchema = GenerateImageIvokeParamsSchema.extend({
-  sessionId: z23.string().optional(),
-  sessionName: z23.string().optional(),
-  projectId: z23.string().optional()
+  sessionId: z24.string().optional(),
+  sessionName: z24.string().optional(),
+  projectId: z24.string().optional()
 });
 var GenerateImageToolCallSchema = OpenAIImageGenerationInput.extend({
-  safety_tolerance: z23.number().optional(),
-  prompt_upsampling: z23.boolean().optional(),
-  output_format: z23.enum(["jpeg", "png"]).nullable().optional(),
-  seed: z23.number().nullable().optional()
+  safety_tolerance: z24.number().optional(),
+  prompt_upsampling: z24.boolean().optional(),
+  output_format: z24.enum(["jpeg", "png"]).nullable().optional(),
+  seed: z24.number().nullable().optional()
 }).omit({
   prompt: true
 });
 var EditImageRequestBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z23.string(),
-  questId: z23.string().optional(),
-  aspect_ratio: z23.string().optional(),
-  fabFileIds: z23.array(z23.string()).default([]),
-  image: z23.string()
+  sessionId: z24.string(),
+  questId: z24.string().optional(),
+  aspect_ratio: z24.string().optional(),
+  fabFileIds: z24.array(z24.string()).default([]),
+  image: z24.string()
 });
-var ChatCompletionInvokeParamsSchema = z23.object({
+var ChatCompletionInvokeParamsSchema = z24.object({
   /** Notebook session ID */
-  sessionId: z23.string(),
-  historyCount: z23.number(),
+  sessionId: z24.string(),
+  historyCount: z24.number(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z23.object({
-    maxDepth: z23.number().optional(),
-    duration: z23.number().optional(),
+  deepResearchConfig: z24.object({
+    maxDepth: z24.number().optional(),
+    duration: z24.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z23.array(z23.any()).optional()
+    searchers: z24.array(z24.any()).optional()
   }).optional(),
-  fabFileIds: z23.array(z23.string()),
+  fabFileIds: z24.array(z24.string()),
   /** Prompt message */
-  message: z23.string(),
-  messageFileIds: z23.array(z23.string()).default([]),
-  questId: z23.string().optional(),
+  message: z24.string(),
+  messageFileIds: z24.array(z24.string()).default([]),
+  questId: z24.string().optional(),
   /** Extra context messages to include in the conversation from external sources */
-  extraContextMessages: z23.array(z23.object({
-    role: z23.enum(["user", "assistant", "system", "function", "tool"]),
-    content: z23.union([z23.string(), z23.array(z23.any())]),
-    fabFileIds: z23.array(z23.string()).optional()
+  extraContextMessages: z24.array(z24.object({
+    role: z24.enum(["user", "assistant", "system", "function", "tool"]),
+    content: z24.union([z24.string(), z24.array(z24.any())]),
+    fabFileIds: z24.array(z24.string()).optional()
   })).optional(),
   /** Dashboard related params */
   dashboardParams: DashboardParamsSchema.optional(),
   /** LLM params */
   params: ChatCompletionCreateInputSchema,
   /** Whether Quest Master is enabled */
-  enableQuestMaster: z23.boolean().optional(),
+  enableQuestMaster: z24.boolean().optional(),
   /** Whether Mementos is enabled */
-  enableMementos: z23.boolean().optional(),
+  enableMementos: z24.boolean().optional(),
   /** Whether Artifacts is enabled */
-  enableArtifacts: z23.boolean().optional(),
+  enableArtifacts: z24.boolean().optional(),
   /** Whether Agents is enabled */
-  enableAgents: z23.boolean().optional(),
+  enableAgents: z24.boolean().optional(),
   /** LLM tools to enable (built-in tools or MCP tool names) */
-  tools: z23.array(z23.union([b4mLLMTools, z23.string()])).optional(),
+  tools: z24.array(z24.union([b4mLLMTools, z24.string()])).optional(),
   /** Enabled MCP servers */
-  mcpServers: z23.array(z23.string()).optional(),
+  mcpServers: z24.array(z24.string()).optional(),
   /** Project ID */
-  projectId: z23.string().optional(),
+  projectId: z24.string().optional(),
   /** Organization ID */
-  organizationId: z23.string().nullable().optional(),
+  organizationId: z24.string().nullable().optional(),
   /** Tool prompt ID to use for the LLM */
-  toolPromptId: z23.string().optional(),
+  toolPromptId: z24.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: z23.string().optional(),
+  fallbackModel: z24.string().optional(),
   /** Embedding model to use */
-  embeddingModel: z23.string().optional()
+  embeddingModel: z24.string().optional()
 });
 var LLMApiRequestBodySchema = ChatCompletionInvokeParamsSchema.extend({
   /** Notebook session ID */
-  sessionId: z23.string().optional(),
+  sessionId: z24.string().optional(),
   /** Notebook session name */
-  sessionName: z23.string().optional()
+  sessionName: z24.string().optional()
 });
 
 // ../../b4m-core/packages/common/dist/src/utils.js
@@ -4224,16 +4684,16 @@ var extractSnippetMeta = (content) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/search.js
-import { z as z24 } from "zod";
-var searchSchema = z24.object({
-  search: z24.string().optional(),
-  pagination: z24.object({
-    page: z24.coerce.number().int().positive(),
-    limit: z24.coerce.number().int().positive()
+import { z as z25 } from "zod";
+var searchSchema = z25.object({
+  search: z25.string().optional(),
+  pagination: z25.object({
+    page: z25.coerce.number().int().positive(),
+    limit: z25.coerce.number().int().positive()
   }).optional(),
-  orderBy: z24.object({
-    field: z24.string(),
-    direction: z24.enum(["asc", "desc"])
+  orderBy: z25.object({
+    field: z25.string(),
+    direction: z25.enum(["asc", "desc"])
   }).optional()
 });
 
@@ -5455,89 +5915,89 @@ var getMcpProviderMetadata = (providerName) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/artifacts.js
-import { z as z25 } from "zod";
-var ArtifactStatusSchema = z25.enum(["draft", "review", "published", "archived", "deleted"]);
-var VisibilitySchema = z25.enum(["private", "project", "organization", "public"]);
-var ArtifactPermissionsSchema = z25.object({
-  canRead: z25.array(z25.string()),
-  canWrite: z25.array(z25.string()),
-  canDelete: z25.array(z25.string()),
-  isPublic: z25.boolean().default(false),
-  inheritFromProject: z25.boolean().default(true)
-});
-var BaseArtifactSchema = z25.object({
-  id: z25.string().uuid(),
+import { z as z26 } from "zod";
+var ArtifactStatusSchema = z26.enum(["draft", "review", "published", "archived", "deleted"]);
+var VisibilitySchema = z26.enum(["private", "project", "organization", "public"]);
+var ArtifactPermissionsSchema = z26.object({
+  canRead: z26.array(z26.string()),
+  canWrite: z26.array(z26.string()),
+  canDelete: z26.array(z26.string()),
+  isPublic: z26.boolean().default(false),
+  inheritFromProject: z26.boolean().default(true)
+});
+var BaseArtifactSchema = z26.object({
+  id: z26.string().uuid(),
   type: ArtifactTypeSchema,
-  title: z25.string().min(1).max(255),
-  description: z25.string().max(1e3).optional(),
+  title: z26.string().min(1).max(255),
+  description: z26.string().max(1e3).optional(),
   // Versioning
-  version: z25.number().int().positive().default(1),
-  versionTag: z25.string().max(100).optional(),
-  currentVersionId: z25.string().uuid().optional(),
-  parentVersionId: z25.string().uuid().optional(),
+  version: z26.number().int().positive().default(1),
+  versionTag: z26.string().max(100).optional(),
+  currentVersionId: z26.string().uuid().optional(),
+  parentVersionId: z26.string().uuid().optional(),
   // Timestamps
-  createdAt: z25.date(),
-  updatedAt: z25.date(),
-  publishedAt: z25.date().optional(),
-  deletedAt: z25.date().optional(),
+  createdAt: z26.date(),
+  updatedAt: z26.date(),
+  publishedAt: z26.date().optional(),
+  deletedAt: z26.date().optional(),
   // Ownership & Access
-  userId: z25.string(),
-  projectId: z25.string().optional(),
-  organizationId: z25.string().optional(),
+  userId: z26.string(),
+  projectId: z26.string().optional(),
+  organizationId: z26.string().optional(),
   visibility: VisibilitySchema.default("private"),
   permissions: ArtifactPermissionsSchema,
   // Relationships
-  sourceQuestId: z25.string().optional(),
-  sessionId: z25.string().optional(),
-  parentArtifactId: z25.string().uuid().optional(),
+  sourceQuestId: z26.string().optional(),
+  sessionId: z26.string().optional(),
+  parentArtifactId: z26.string().uuid().optional(),
   // Status
   status: ArtifactStatusSchema.default("draft"),
-  tags: z25.array(z25.string().max(50)).max(20).default([]),
+  tags: z26.array(z26.string().max(50)).max(20).default([]),
   // Content
-  contentHash: z25.string(),
-  contentSize: z25.number().int().nonnegative(),
+  contentHash: z26.string(),
+  contentSize: z26.number().int().nonnegative(),
   // Metadata
-  metadata: z25.record(z25.unknown()).optional()
+  metadata: z26.record(z26.unknown()).optional()
 });
-var EnhancedArtifactMetadataSchema = z25.object({
-  language: z25.string().optional(),
-  dependencies: z25.array(z25.string()).optional(),
-  settings: z25.record(z25.unknown()).optional()
+var EnhancedArtifactMetadataSchema = z26.object({
+  language: z26.string().optional(),
+  dependencies: z26.array(z26.string()).optional(),
+  settings: z26.record(z26.unknown()).optional()
 });
 var ReactArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z25.literal("react"),
-  content: z25.string(),
+  type: z26.literal("react"),
+  content: z26.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    dependencies: z25.array(z25.string()),
-    props: z25.record(z25.unknown()).optional(),
-    hasDefaultExport: z25.boolean(),
-    errorBoundary: z25.boolean().default(true)
+    dependencies: z26.array(z26.string()),
+    props: z26.record(z26.unknown()).optional(),
+    hasDefaultExport: z26.boolean(),
+    errorBoundary: z26.boolean().default(true)
   })
 });
 var HtmlArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z25.literal("html"),
-  content: z25.string(),
+  type: z26.literal("html"),
+  content: z26.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    allowedScripts: z25.array(z25.string()).default([]),
-    cspPolicy: z25.string().optional(),
-    sanitized: z25.boolean().default(false)
+    allowedScripts: z26.array(z26.string()).default([]),
+    cspPolicy: z26.string().optional(),
+    sanitized: z26.boolean().default(false)
   })
 });
 var SvgArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z25.literal("svg"),
-  content: z25.string(),
+  type: z26.literal("svg"),
+  content: z26.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    viewBox: z25.string().optional(),
-    width: z25.number().positive().optional(),
-    height: z25.number().positive().optional(),
-    sanitized: z25.boolean().default(false)
+    viewBox: z26.string().optional(),
+    width: z26.number().positive().optional(),
+    height: z26.number().positive().optional(),
+    sanitized: z26.boolean().default(false)
   })
 });
 var MermaidArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z25.literal("mermaid"),
-  content: z25.string(),
+  type: z26.literal("mermaid"),
+  content: z26.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    chartType: z25.enum([
+    chartType: z26.enum([
       "flowchart",
       "sequenceDiagram",
       "classDiagram",
@@ -5547,7 +6007,7 @@ var MermaidArtifactV2Schema = BaseArtifactSchema.extend({
       "pie",
       "mindmap"
     ]).optional(),
-    description: z25.string().optional()
+    description: z26.string().optional()
   })
 });
 var ArtifactStatuses;
@@ -5575,39 +6035,39 @@ var validateMermaidArtifactV2 = (data) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/questmaster.js
-import { z as z26 } from "zod";
-var QuestStatusSchema = z26.enum(["pending", "in-progress", "completed", "skipped"]);
-var QuestSchema = z26.object({
-  id: z26.string().uuid(),
-  title: z26.string().min(1).max(255),
-  description: z26.string().max(1e3),
+import { z as z27 } from "zod";
+var QuestStatusSchema = z27.enum(["pending", "in-progress", "completed", "skipped"]);
+var QuestSchema = z27.object({
+  id: z27.string().uuid(),
+  title: z27.string().min(1).max(255),
+  description: z27.string().max(1e3),
   status: QuestStatusSchema.default("pending"),
-  order: z26.number().int().nonnegative(),
-  dependencies: z26.array(z26.string().uuid()).optional(),
-  estimatedMinutes: z26.number().int().positive().optional(),
-  completedAt: z26.date().optional(),
-  completedBy: z26.string().optional(),
-  metadata: z26.record(z26.unknown()).optional()
+  order: z27.number().int().nonnegative(),
+  dependencies: z27.array(z27.string().uuid()).optional(),
+  estimatedMinutes: z27.number().int().positive().optional(),
+  completedAt: z27.date().optional(),
+  completedBy: z27.string().optional(),
+  metadata: z27.record(z27.unknown()).optional()
 });
-var QuestResourceSchema = z26.object({
-  type: z26.enum(["documentation", "tutorial", "example", "tool"]),
-  title: z26.string().min(1).max(255),
-  url: z26.string().url(),
-  description: z26.string().max(500).optional()
-});
-var QuestMasterContentSchema = z26.object({
-  goal: z26.string().min(1).max(500),
-  quests: z26.array(QuestSchema).min(1),
-  totalSteps: z26.number().int().positive(),
-  estimatedDuration: z26.number().int().positive().optional(),
-  complexity: z26.enum(["low", "medium", "high"]),
-  category: z26.string().max(100).optional(),
-  prerequisites: z26.array(z26.string().max(255)).optional(),
-  completionCriteria: z26.array(z26.string().max(500)).optional(),
-  resources: z26.array(QuestResourceSchema).optional()
+var QuestResourceSchema = z27.object({
+  type: z27.enum(["documentation", "tutorial", "example", "tool"]),
+  title: z27.string().min(1).max(255),
+  url: z27.string().url(),
+  description: z27.string().max(500).optional()
+});
+var QuestMasterContentSchema = z27.object({
+  goal: z27.string().min(1).max(500),
+  quests: z27.array(QuestSchema).min(1),
+  totalSteps: z27.number().int().positive(),
+  estimatedDuration: z27.number().int().positive().optional(),
+  complexity: z27.enum(["low", "medium", "high"]),
+  category: z27.string().max(100).optional(),
+  prerequisites: z27.array(z27.string().max(255)).optional(),
+  completionCriteria: z27.array(z27.string().max(500)).optional(),
+  resources: z27.array(QuestResourceSchema).optional()
 });
 var QuestMasterArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z26.literal("questmaster"),
+  type: z27.literal("questmaster"),
   content: QuestMasterContentSchema
 });
 var validateQuest = (data) => {
@@ -5624,13 +6084,13 @@ var safeParseQuestMasterArtifactV2 = (data) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/curation.js
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var CurationType;
 (function(CurationType2) {
   CurationType2["TRANSCRIPT"] = "transcript";
   CurationType2["EXECUTIVE_SUMMARY"] = "executive_summary";
 })(CurationType || (CurationType = {}));
-var CurationTypeSchema = z27.nativeEnum(CurationType);
+var CurationTypeSchema = z28.nativeEnum(CurationType);
 var CurationArtifactType;
 (function(CurationArtifactType2) {
   CurationArtifactType2["CODE"] = "code";
@@ -5643,7 +6103,7 @@ var CurationArtifactType;
   CurationArtifactType2["DEEP_RESEARCH"] = "deep_research";
   CurationArtifactType2["IMAGE"] = "image";
 })(CurationArtifactType || (CurationArtifactType = {}));
-var CurationArtifactTypeSchema = z27.enum([
+var CurationArtifactTypeSchema = z28.enum([
   "CODE",
   "REACT",
   "HTML",
@@ -5654,28 +6114,28 @@ var CurationArtifactTypeSchema = z27.enum([
   "DEEP_RESEARCH",
   "IMAGE"
 ]);
-var ExportFormatSchema = z27.enum(["markdown", "txt", "html"]);
-var CurationOptionsSchema = z27.object({
+var ExportFormatSchema = z28.enum(["markdown", "txt", "html"]);
+var CurationOptionsSchema = z28.object({
   /** Curation type: transcript (Option 1) or executive_summary (Option 2) */
   curationType: CurationTypeSchema.default(CurationType.TRANSCRIPT),
   /** Include code artifacts in the curated notebook */
-  includeCode: z27.boolean().default(true),
+  includeCode: z28.boolean().default(true),
   /** Include diagrams (Mermaid, SVG) in the curated notebook */
-  includeDiagrams: z27.boolean().default(true),
+  includeDiagrams: z28.boolean().default(true),
   /** Include data visualizations (Recharts) in the curated notebook */
-  includeDataViz: z27.boolean().default(true),
+  includeDataViz: z28.boolean().default(true),
   /** Include QuestMaster plans in the curated notebook */
-  includeQuestMaster: z27.boolean().default(true),
+  includeQuestMaster: z28.boolean().default(true),
   /** Include Deep Research findings in the curated notebook */
-  includeResearch: z27.boolean().default(true),
+  includeResearch: z28.boolean().default(true),
   /** Include images in the curated notebook */
-  includeImages: z27.boolean().default(true),
+  includeImages: z28.boolean().default(true),
   /** Token budget for processing (varies by curation type) */
-  tokenBudget: z27.number().optional(),
+  tokenBudget: z28.number().optional(),
   /** Export format for the curated notebook */
   exportFormat: ExportFormatSchema.default("markdown"),
   /** Custom notebook name (optional, defaults to curated-notebook-{sessionId}) */
-  customNotebookName: z27.string().optional()
+  customNotebookName: z28.string().optional()
 });
 
 // ../../b4m-core/packages/common/dist/src/utils/artifactHelpers.js
@@ -5918,6 +6378,7 @@ export {
   SvgArtifactSchema,
   MermaidArtifactSchema,
   RechartsArtifactSchema,
+  LatticeArtifactSchema,
   MermaidChartMetadataSchema,
   ChatHistoryItemWithArtifactsSchema,
   ArtifactOperationSchema,
@@ -6083,6 +6544,67 @@ export {
   UserApiKeyEvents,
   InternalTeamMemberSchema,
   InternalTeamMemberListSchema,
+  LatticeDataTypeSchema,
+  LatticeEntityTypeSchema,
+  LatticeRelationshipTypeSchema,
+  LatticeRuleTypeSchema,
+  LatticeOperationSchema,
+  LatticeConditionOperatorSchema,
+  LatticePeriodGrainSchema,
+  LatticeNegativeFormatSchema,
+  LatticeViewTypeSchema,
+  LatticeModelTypeSchema,
+  LatticeIntentTypeSchema,
+  LatticeErrorTypeSchema,
+  LatticeOperationTypeSchema,
+  LatticeExportFormatSchema,
+  LatticePrimitiveValueSchema,
+  LatticeAttributeSchema,
+  LatticeEntitySchema,
+  LatticeRelationshipSchema,
+  LatticeDataStoreSchema,
+  LatticeInputSchema,
+  LatticeOutputSchema,
+  LatticeConditionSchema,
+  LatticeRuleDefinitionSchema,
+  LatticeRuleSchema,
+  LatticeRulesetSchema,
+  LatticeRulesStoreSchema,
+  LatticeRowConfigSchema,
+  LatticeColumnConfigSchema,
+  LatticeFilterSchema,
+  LatticeSortConfigSchema,
+  LatticeGroupConfigSchema,
+  LatticeFormatConfigSchema,
+  LatticeViewConfigSchema,
+  LatticeViewSchema,
+  LatticeViewStoreSchema,
+  LatticeModelSettingsSchema,
+  LatticeHistoryOperationSchema,
+  LatticeScenarioOverrideSchema,
+  LatticeScenarioSchema,
+  LatticeComputedValueSchema,
+  LatticeComputedValuesSchema,
+  LatticeCalculationStepSchema,
+  LatticeCalculationChainSchema,
+  LatticeModelSchema,
+  LatticeExtractedEntitySchema,
+  LatticeParsedIntentSchema,
+  LatticeErrorSchema,
+  CreateLatticeModelRequestSchema,
+  UpdateLatticeModelRequestSchema,
+  ComputeLatticeRequestSchema,
+  ComputeLatticeResponseSchema,
+  ExplainLatticeRequestSchema,
+  ExplainLatticeResponseSchema,
+  ExportLatticeRequestSchema,
+  validateLatticeModel,
+  validateLatticeEntity,
+  validateLatticeRule,
+  validateLatticeParsedIntent,
+  safeParseLatticeModel,
+  safeParseLatticeEntity,
+  safeParseLatticeRule,
   PREDEFINED_USER_TAGS,
   isPredefinedTag,
   getPredefinedTags,