@bike4mind/cli 0.2.1-epic-lattice.17016 → 0.2.1-feat-cli-usage-command.17001

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

@@ -230,14 +230,7 @@ var b4mLLMTools = z3.enum([
   "create_file",
   "glob_files",
   "grep_search",
-  "delete_file",
-  // Lattice financial modeling tools
-  "lattice_create_model",
-  "lattice_add_entity",
-  "lattice_set_value",
-  "lattice_create_rule",
-  "lattice_query",
-  "lattice_explain"
+  "delete_file"
 ]);
 var B4MLLMToolsList = b4mLLMTools.options.map((tool) => tool);
 var RechartsChartTypeSchema = z3.enum([
@@ -293,9 +286,7 @@ var ArtifactTypeSchema = z4.enum([
   "code",
   "quest",
   "file",
-  "questmaster",
-  "lattice"
-  // Financial pro-forma models
+  "questmaster"
 ]);
 var ArtifactSchema = z4.object({
   id: z4.string(),
@@ -375,17 +366,6 @@ 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",
@@ -419,8 +399,7 @@ var ClaudeArtifactMimeTypes = {
   MERMAID: "application/vnd.ant.mermaid",
   RECHARTS: "application/vnd.ant.recharts",
   CODE: "application/vnd.ant.code",
-  MARKDOWN: "text/markdown",
-  LATTICE: "application/vnd.b4m.lattice"
+  MARKDOWN: "text/markdown"
 };
 
 // ../../b4m-core/packages/common/dist/src/types/entities/AppFileTypes.js
@@ -2023,7 +2002,6 @@ var SettingKeySchema = z19.enum([
   "EnableArtifacts",
   "EnableAgents",
   "EnableRapidReply",
-  "EnableLattice",
   "RapidReplySettings",
   "EnableResearchEngine",
   "EnableOllama",
@@ -2482,8 +2460,7 @@ var API_SERVICE_GROUPS = {
       { key: "EnableRapidReply", order: 7 },
       { key: "EnableResearchEngine", order: 8 },
       { key: "EnableReactViewer", order: 9 },
-      { key: "EnableDeepResearch", order: 10 },
-      { key: "EnableLattice", order: 11 }
+      { key: "EnableDeepResearch", order: 10 }
     ]
   },
   NOTEBOOK: {
@@ -3385,15 +3362,6 @@ var settingsMap = {
     group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
     order: 9
   }),
-  EnableLattice: makeBooleanSetting({
-    key: "EnableLattice",
-    name: "Enable Lattice",
-    defaultValue: false,
-    description: "Whether to enable the Lattice feature for natural language financial pro-forma modeling. Allows creating and manipulating spreadsheet-like models through conversation.",
-    category: "Experimental",
-    group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
-    order: 11
-  }),
   enableVoiceSession: makeBooleanSetting({
     key: "enableVoiceSession",
     name: "Enable Voice Session",
@@ -4051,445 +4019,6 @@ 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) => {
@@ -4500,130 +4029,128 @@ var getPredefinedTags = () => {
 };
 
 // ../../b4m-core/packages/common/dist/src/llm.js
-import { z as z24 } from "zod";
-var DashboardParamsSchema = z24.object({
-  dashboardDataSources: z24.array(z24.object({
-    sourceName: z24.string(),
-    data: z24.any()
+import { z as z23 } from "zod";
+var DashboardParamsSchema = z23.object({
+  dashboardDataSources: z23.array(z23.object({
+    sourceName: z23.string(),
+    data: z23.any()
   })),
-  promptName: z24.string().optional()
+  promptName: z23.string().optional()
 });
-var QuestMasterParamsSchema = z24.object({
-  questMasterPlanId: z24.string(),
-  questId: z24.string(),
-  subQuestId: z24.string()
+var QuestMasterParamsSchema = z23.object({
+  questMasterPlanId: z23.string(),
+  questId: z23.string(),
+  subQuestId: z23.string()
 });
-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()
+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()
   }),
-  label: z24.string().optional()
+  label: z23.string().optional()
 });
-var ResearchModeParamsSchema = z24.object({
-  enabled: z24.boolean(),
-  configurations: z24.array(ResearchModeConfigurationSchema).max(4)
+var ResearchModeParamsSchema = z23.object({
+  enabled: z23.boolean(),
+  configurations: z23.array(ResearchModeConfigurationSchema).max(4)
 });
 var GenerateImageIvokeParamsSchema = OpenAIImageGenerationInput.extend({
-  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()
+  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()
   }).optional()
 });
 var GenerateImageRequestBodySchema = GenerateImageIvokeParamsSchema.extend({
-  sessionId: z24.string().optional(),
-  sessionName: z24.string().optional(),
-  projectId: z24.string().optional()
+  sessionId: z23.string().optional(),
+  sessionName: z23.string().optional(),
+  projectId: z23.string().optional()
 });
 var GenerateImageToolCallSchema = OpenAIImageGenerationInput.extend({
-  safety_tolerance: z24.number().optional(),
-  prompt_upsampling: z24.boolean().optional(),
-  output_format: z24.enum(["jpeg", "png"]).nullable().optional(),
-  seed: z24.number().nullable().optional()
+  safety_tolerance: z23.number().optional(),
+  prompt_upsampling: z23.boolean().optional(),
+  output_format: z23.enum(["jpeg", "png"]).nullable().optional(),
+  seed: z23.number().nullable().optional()
 }).omit({
   prompt: true
 });
 var EditImageRequestBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z24.string(),
-  questId: z24.string().optional(),
-  aspect_ratio: z24.string().optional(),
-  fabFileIds: z24.array(z24.string()).default([]),
-  image: z24.string()
+  sessionId: z23.string(),
+  questId: z23.string().optional(),
+  aspect_ratio: z23.string().optional(),
+  fabFileIds: z23.array(z23.string()).default([]),
+  image: z23.string()
 });
-var ChatCompletionInvokeParamsSchema = z24.object({
+var ChatCompletionInvokeParamsSchema = z23.object({
   /** Notebook session ID */
-  sessionId: z24.string(),
-  historyCount: z24.number(),
+  sessionId: z23.string(),
+  historyCount: z23.number(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z24.object({
-    maxDepth: z24.number().optional(),
-    duration: z24.number().optional(),
+  deepResearchConfig: z23.object({
+    maxDepth: z23.number().optional(),
+    duration: z23.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z24.array(z24.any()).optional()
+    searchers: z23.array(z23.any()).optional()
   }).optional(),
-  fabFileIds: z24.array(z24.string()),
+  fabFileIds: z23.array(z23.string()),
   /** Prompt message */
-  message: z24.string(),
-  messageFileIds: z24.array(z24.string()).default([]),
-  questId: z24.string().optional(),
+  message: z23.string(),
+  messageFileIds: z23.array(z23.string()).default([]),
+  questId: z23.string().optional(),
   /** Extra context messages to include in the conversation from external sources */
-  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()
+  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()
   })).optional(),
   /** Dashboard related params */
   dashboardParams: DashboardParamsSchema.optional(),
   /** LLM params */
   params: ChatCompletionCreateInputSchema,
   /** Whether Quest Master is enabled */
-  enableQuestMaster: z24.boolean().optional(),
+  enableQuestMaster: z23.boolean().optional(),
   /** Whether Mementos is enabled */
-  enableMementos: z24.boolean().optional(),
+  enableMementos: z23.boolean().optional(),
   /** Whether Artifacts is enabled */
-  enableArtifacts: z24.boolean().optional(),
+  enableArtifacts: z23.boolean().optional(),
   /** Whether Agents is enabled */
-  enableAgents: z24.boolean().optional(),
-  /** Whether Lattice (financial pro-forma modeling) is enabled */
-  enableLattice: z24.boolean().optional(),
+  enableAgents: z23.boolean().optional(),
   /** LLM tools to enable (built-in tools or MCP tool names) */
-  tools: z24.array(z24.union([b4mLLMTools, z24.string()])).optional(),
+  tools: z23.array(z23.union([b4mLLMTools, z23.string()])).optional(),
   /** Enabled MCP servers */
-  mcpServers: z24.array(z24.string()).optional(),
+  mcpServers: z23.array(z23.string()).optional(),
   /** Project ID */
-  projectId: z24.string().optional(),
+  projectId: z23.string().optional(),
   /** Organization ID */
-  organizationId: z24.string().nullable().optional(),
+  organizationId: z23.string().nullable().optional(),
   /** Tool prompt ID to use for the LLM */
-  toolPromptId: z24.string().optional(),
+  toolPromptId: z23.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: z24.string().optional(),
+  fallbackModel: z23.string().optional(),
   /** Embedding model to use */
-  embeddingModel: z24.string().optional()
+  embeddingModel: z23.string().optional()
 });
 var LLMApiRequestBodySchema = ChatCompletionInvokeParamsSchema.extend({
   /** Notebook session ID */
-  sessionId: z24.string().optional(),
+  sessionId: z23.string().optional(),
   /** Notebook session name */
-  sessionName: z24.string().optional()
+  sessionName: z23.string().optional()
 });
 
 // ../../b4m-core/packages/common/dist/src/utils.js
@@ -4697,16 +4224,16 @@ var extractSnippetMeta = (content) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/search.js
-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()
+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()
   }).optional(),
-  orderBy: z25.object({
-    field: z25.string(),
-    direction: z25.enum(["asc", "desc"])
+  orderBy: z24.object({
+    field: z24.string(),
+    direction: z24.enum(["asc", "desc"])
   }).optional()
 });
 
@@ -5928,89 +5455,89 @@ var getMcpProviderMetadata = (providerName) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/artifacts.js
-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(),
+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(),
   type: ArtifactTypeSchema,
-  title: z26.string().min(1).max(255),
-  description: z26.string().max(1e3).optional(),
+  title: z25.string().min(1).max(255),
+  description: z25.string().max(1e3).optional(),
   // Versioning
-  version: z26.number().int().positive().default(1),
-  versionTag: z26.string().max(100).optional(),
-  currentVersionId: z26.string().uuid().optional(),
-  parentVersionId: z26.string().uuid().optional(),
+  version: z25.number().int().positive().default(1),
+  versionTag: z25.string().max(100).optional(),
+  currentVersionId: z25.string().uuid().optional(),
+  parentVersionId: z25.string().uuid().optional(),
   // Timestamps
-  createdAt: z26.date(),
-  updatedAt: z26.date(),
-  publishedAt: z26.date().optional(),
-  deletedAt: z26.date().optional(),
+  createdAt: z25.date(),
+  updatedAt: z25.date(),
+  publishedAt: z25.date().optional(),
+  deletedAt: z25.date().optional(),
   // Ownership & Access
-  userId: z26.string(),
-  projectId: z26.string().optional(),
-  organizationId: z26.string().optional(),
+  userId: z25.string(),
+  projectId: z25.string().optional(),
+  organizationId: z25.string().optional(),
   visibility: VisibilitySchema.default("private"),
   permissions: ArtifactPermissionsSchema,
   // Relationships
-  sourceQuestId: z26.string().optional(),
-  sessionId: z26.string().optional(),
-  parentArtifactId: z26.string().uuid().optional(),
+  sourceQuestId: z25.string().optional(),
+  sessionId: z25.string().optional(),
+  parentArtifactId: z25.string().uuid().optional(),
   // Status
   status: ArtifactStatusSchema.default("draft"),
-  tags: z26.array(z26.string().max(50)).max(20).default([]),
+  tags: z25.array(z25.string().max(50)).max(20).default([]),
   // Content
-  contentHash: z26.string(),
-  contentSize: z26.number().int().nonnegative(),
+  contentHash: z25.string(),
+  contentSize: z25.number().int().nonnegative(),
   // Metadata
-  metadata: z26.record(z26.unknown()).optional()
+  metadata: 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 EnhancedArtifactMetadataSchema = z25.object({
+  language: z25.string().optional(),
+  dependencies: z25.array(z25.string()).optional(),
+  settings: z25.record(z25.unknown()).optional()
 });
 var ReactArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z26.literal("react"),
-  content: z26.string(),
+  type: z25.literal("react"),
+  content: z25.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    dependencies: z26.array(z26.string()),
-    props: z26.record(z26.unknown()).optional(),
-    hasDefaultExport: z26.boolean(),
-    errorBoundary: z26.boolean().default(true)
+    dependencies: z25.array(z25.string()),
+    props: z25.record(z25.unknown()).optional(),
+    hasDefaultExport: z25.boolean(),
+    errorBoundary: z25.boolean().default(true)
   })
 });
 var HtmlArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z26.literal("html"),
-  content: z26.string(),
+  type: z25.literal("html"),
+  content: z25.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    allowedScripts: z26.array(z26.string()).default([]),
-    cspPolicy: z26.string().optional(),
-    sanitized: z26.boolean().default(false)
+    allowedScripts: z25.array(z25.string()).default([]),
+    cspPolicy: z25.string().optional(),
+    sanitized: z25.boolean().default(false)
   })
 });
 var SvgArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z26.literal("svg"),
-  content: z26.string(),
+  type: z25.literal("svg"),
+  content: z25.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    viewBox: z26.string().optional(),
-    width: z26.number().positive().optional(),
-    height: z26.number().positive().optional(),
-    sanitized: z26.boolean().default(false)
+    viewBox: z25.string().optional(),
+    width: z25.number().positive().optional(),
+    height: z25.number().positive().optional(),
+    sanitized: z25.boolean().default(false)
   })
 });
 var MermaidArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z26.literal("mermaid"),
-  content: z26.string(),
+  type: z25.literal("mermaid"),
+  content: z25.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    chartType: z26.enum([
+    chartType: z25.enum([
       "flowchart",
       "sequenceDiagram",
       "classDiagram",
@@ -6020,7 +5547,7 @@ var MermaidArtifactV2Schema = BaseArtifactSchema.extend({
       "pie",
       "mindmap"
     ]).optional(),
-    description: z26.string().optional()
+    description: z25.string().optional()
   })
 });
 var ArtifactStatuses;
@@ -6048,39 +5575,39 @@ var validateMermaidArtifactV2 = (data) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/questmaster.js
-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),
+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),
   status: QuestStatusSchema.default("pending"),
-  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 = 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()
+  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()
 });
-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 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 QuestMasterArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z27.literal("questmaster"),
+  type: z26.literal("questmaster"),
   content: QuestMasterContentSchema
 });
 var validateQuest = (data) => {
@@ -6097,13 +5624,13 @@ var safeParseQuestMasterArtifactV2 = (data) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/curation.js
-import { z as z28 } from "zod";
+import { z as z27 } from "zod";
 var CurationType;
 (function(CurationType2) {
   CurationType2["TRANSCRIPT"] = "transcript";
   CurationType2["EXECUTIVE_SUMMARY"] = "executive_summary";
 })(CurationType || (CurationType = {}));
-var CurationTypeSchema = z28.nativeEnum(CurationType);
+var CurationTypeSchema = z27.nativeEnum(CurationType);
 var CurationArtifactType;
 (function(CurationArtifactType2) {
   CurationArtifactType2["CODE"] = "code";
@@ -6116,7 +5643,7 @@ var CurationArtifactType;
   CurationArtifactType2["DEEP_RESEARCH"] = "deep_research";
   CurationArtifactType2["IMAGE"] = "image";
 })(CurationArtifactType || (CurationArtifactType = {}));
-var CurationArtifactTypeSchema = z28.enum([
+var CurationArtifactTypeSchema = z27.enum([
   "CODE",
   "REACT",
   "HTML",
@@ -6127,28 +5654,28 @@ var CurationArtifactTypeSchema = z28.enum([
   "DEEP_RESEARCH",
   "IMAGE"
 ]);
-var ExportFormatSchema = z28.enum(["markdown", "txt", "html"]);
-var CurationOptionsSchema = z28.object({
+var ExportFormatSchema = z27.enum(["markdown", "txt", "html"]);
+var CurationOptionsSchema = z27.object({
   /** Curation type: transcript (Option 1) or executive_summary (Option 2) */
   curationType: CurationTypeSchema.default(CurationType.TRANSCRIPT),
   /** Include code artifacts in the curated notebook */
-  includeCode: z28.boolean().default(true),
+  includeCode: z27.boolean().default(true),
   /** Include diagrams (Mermaid, SVG) in the curated notebook */
-  includeDiagrams: z28.boolean().default(true),
+  includeDiagrams: z27.boolean().default(true),
   /** Include data visualizations (Recharts) in the curated notebook */
-  includeDataViz: z28.boolean().default(true),
+  includeDataViz: z27.boolean().default(true),
   /** Include QuestMaster plans in the curated notebook */
-  includeQuestMaster: z28.boolean().default(true),
+  includeQuestMaster: z27.boolean().default(true),
   /** Include Deep Research findings in the curated notebook */
-  includeResearch: z28.boolean().default(true),
+  includeResearch: z27.boolean().default(true),
   /** Include images in the curated notebook */
-  includeImages: z28.boolean().default(true),
+  includeImages: z27.boolean().default(true),
   /** Token budget for processing (varies by curation type) */
-  tokenBudget: z28.number().optional(),
+  tokenBudget: z27.number().optional(),
   /** Export format for the curated notebook */
   exportFormat: ExportFormatSchema.default("markdown"),
   /** Custom notebook name (optional, defaults to curated-notebook-{sessionId}) */
-  customNotebookName: z28.string().optional()
+  customNotebookName: z27.string().optional()
 });
 
 // ../../b4m-core/packages/common/dist/src/utils/artifactHelpers.js
@@ -6391,7 +5918,6 @@ export {
   SvgArtifactSchema,
   MermaidArtifactSchema,
   RechartsArtifactSchema,
-  LatticeArtifactSchema,
   MermaidChartMetadataSchema,
   ChatHistoryItemWithArtifactsSchema,
   ArtifactOperationSchema,
@@ -6557,67 +6083,6 @@ 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,