@bike4mind/cli 0.2.29-subagent-delegation.18906 → 0.2.29

package/dist/{chunk-WKJ6QNRZ.js → chunk-TNFZP7FG.js}

@@ -310,9 +310,7 @@ var b4mLLMTools = z5.enum([
   "iss_tracker",
   "planet_visibility",
   // Knowledge base search
-  "search_knowledge_base",
-  // Agent delegation
-  "delegate_to_agent"
+  "search_knowledge_base"
 ]);
 var B4MLLMToolsList = b4mLLMTools.options.map((tool) => tool);
 var RechartsChartTypeSchema = z5.enum([
@@ -368,7 +366,9 @@ var ArtifactTypeSchema = z6.enum([
   "code",
   "quest",
   "file",
-  "questmaster"
+  "questmaster",
+  "lattice"
+  // Financial pro-forma models
 ]);
 var ArtifactSchema = z6.object({
   id: z6.string(),
@@ -448,6 +448,17 @@ var RechartsArtifactSchema = ArtifactSchema.extend({
     colors: z6.array(z6.string()).optional()
   })
 });
+var LatticeArtifactSchema = ArtifactSchema.extend({
+  type: z6.literal("lattice"),
+  metadata: ArtifactMetadataSchema.extend({
+    modelType: z6.enum(["income_statement", "balance_sheet", "cashflow", "saas_metrics", "custom"]).optional(),
+    periodGrain: z6.enum(["month", "quarter", "year"]).optional(),
+    currency: z6.string().default("USD"),
+    entityCount: z6.number().int().nonnegative().optional(),
+    ruleCount: z6.number().int().nonnegative().optional(),
+    lastComputedAt: z6.date().optional()
+  })
+});
 var MermaidChartMetadataSchema = z6.object({
   chartType: z6.enum([
     "flowchart",
@@ -481,7 +492,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
@@ -897,6 +909,129 @@ var RapidReplyResponseStylesCommon = ["auto", "casual", "professional", "code"];
 var RapidReplyTransitionModes = ["replace", "append", "enhance"];
 var RapidReplyFallbackBehaviors = ["disable", "continue", "notify"];
 
+// ../../b4m-core/packages/common/dist/src/types/entities/EmailTypes.js
+var EmailJobStatus;
+(function(EmailJobStatus2) {
+  EmailJobStatus2["DRAFT"] = "draft";
+  EmailJobStatus2["SCHEDULED"] = "scheduled";
+  EmailJobStatus2["QUEUED"] = "queued";
+  EmailJobStatus2["PROCESSING"] = "processing";
+  EmailJobStatus2["COMPLETED"] = "completed";
+  EmailJobStatus2["FAILED"] = "failed";
+  EmailJobStatus2["CANCELLED"] = "cancelled";
+})(EmailJobStatus || (EmailJobStatus = {}));
+var EmailSendStatus;
+(function(EmailSendStatus2) {
+  EmailSendStatus2["PENDING"] = "pending";
+  EmailSendStatus2["PROCESSING"] = "processing";
+  EmailSendStatus2["SENT"] = "sent";
+  EmailSendStatus2["DELIVERED"] = "delivered";
+  EmailSendStatus2["OPENED"] = "opened";
+  EmailSendStatus2["CLICKED"] = "clicked";
+  EmailSendStatus2["BOUNCED"] = "bounced";
+  EmailSendStatus2["COMPLAINED"] = "complained";
+  EmailSendStatus2["FAILED"] = "failed";
+  EmailSendStatus2["CANCELLED"] = "cancelled";
+})(EmailSendStatus || (EmailSendStatus = {}));
+var EmailJobOverallStatus;
+(function(EmailJobOverallStatus2) {
+  EmailJobOverallStatus2["DRAFT"] = "draft";
+  EmailJobOverallStatus2["SENDING"] = "sending";
+  EmailJobOverallStatus2["COMPLETE"] = "complete";
+  EmailJobOverallStatus2["PARTIAL"] = "partial";
+  EmailJobOverallStatus2["FAILED"] = "failed";
+})(EmailJobOverallStatus || (EmailJobOverallStatus = {}));
+var EmailCategory;
+(function(EmailCategory2) {
+  EmailCategory2["MARKETING"] = "marketing";
+  EmailCategory2["PRODUCT_UPDATE"] = "product_update";
+  EmailCategory2["NEWSLETTER"] = "newsletter";
+  EmailCategory2["ANNOUNCEMENT"] = "announcement";
+  EmailCategory2["TRANSACTIONAL"] = "transactional";
+})(EmailCategory || (EmailCategory = {}));
+
+// ../../b4m-core/packages/common/dist/src/types/entities/SoftwareSchedulerTypes.js
+function calculateTaskValue(task, estimate) {
+  const reach = task.reach ?? estimate?.inferredStackRanking?.reach ?? 5;
+  const retention = task.retention ?? estimate?.inferredStackRanking?.retention ?? 5;
+  const revenue = task.revenue ?? estimate?.inferredStackRanking?.revenue ?? 5;
+  const romance = task.romance ?? estimate?.inferredStackRanking?.romance ?? 5;
+  const confidence = task.confidence ?? estimate?.inferredStackRanking?.confidence ?? 5;
+  const foundation = task.foundation ?? estimate?.inferredStackRanking?.foundation ?? 5;
+  const visibility = task.visibility ?? estimate?.inferredStackRanking?.visibility ?? 5;
+  const coreScore = reach * 2 + retention * 3 + revenue * 5;
+  const extendedScore = romance * 1.5 + confidence * 1.5 + foundation * 2 + visibility * 1.5;
+  return coreScore + extendedScore;
+}
+function calculateResourceAllocations(projects, resources, startPeriod, endPeriod) {
+  const allocations = /* @__PURE__ */ new Map();
+  for (const resource of resources) {
+    for (let period = startPeriod; period <= endPeriod; period++) {
+      const key = `${resource.id}-${period}`;
+      allocations.set(key, {
+        resourceId: resource.id,
+        period: period.toString(),
+        allocations: [],
+        totalPercentage: 0
+      });
+    }
+  }
+  for (const project of projects) {
+    if (project.status !== "active" && project.status !== "planned")
+      continue;
+    const projectDuration = project.endPeriod - project.startPeriod + 1;
+    for (const phase of project.phases) {
+      const phaseStartOffset = project.phases.slice(0, project.phases.indexOf(phase)).reduce((sum, p) => sum + p.pct, 0) / 100;
+      const phaseEndOffset = phaseStartOffset + phase.pct / 100;
+      const phaseStartPeriod = Math.floor(project.startPeriod + phaseStartOffset * projectDuration);
+      const phaseEndPeriod = Math.min(Math.floor(project.startPeriod + phaseEndOffset * projectDuration), project.endPeriod);
+      for (const [resourceId, percentage] of Object.entries(phase.teamWeights)) {
+        if (percentage <= 0)
+          continue;
+        for (let period = phaseStartPeriod; period <= phaseEndPeriod; period++) {
+          if (period < startPeriod || period > endPeriod)
+            continue;
+          const key = `${resourceId}-${period}`;
+          const allocation = allocations.get(key);
+          if (allocation) {
+            allocation.allocations.push({
+              projectId: project.id,
+              projectName: project.name,
+              phaseId: phase.id,
+              phaseName: phase.name,
+              percentage
+            });
+            allocation.totalPercentage += percentage;
+          }
+        }
+      }
+    }
+  }
+  return Array.from(allocations.values());
+}
+function detectResourceConflicts(allocations, resources) {
+  const resourceMap = new Map(resources.map((r) => [r.id, r]));
+  const conflicts = [];
+  for (const allocation of allocations) {
+    if (allocation.totalPercentage > 100) {
+      const resource = resourceMap.get(allocation.resourceId);
+      conflicts.push({
+        resourceId: allocation.resourceId,
+        resourceName: resource?.name || allocation.resourceId,
+        period: allocation.period,
+        allocations: allocation.allocations.map((a) => ({
+          projectId: a.projectId,
+          projectName: a.projectName,
+          percentage: a.percentage
+        })),
+        totalPercentage: allocation.totalPercentage,
+        severity: allocation.totalPercentage > 120 ? "critical" : "warning"
+      });
+    }
+  }
+  return conflicts;
+}
+
 // ../../b4m-core/packages/common/dist/src/types/entities/SystemSecretsTypes.js
 var SST_PLACEHOLDER_VALUE = "my-secret-placeholder-value";
 var NOT_CONFIGURED_PLACEHOLDER = "not-configured";
@@ -1139,6 +1274,43 @@ var SpiderErrorAction = z10.object({
   dryRun: z10.boolean().optional(),
   clientId: z10.string().optional()
 });
+var PiHistoryProgressAction = z10.object({
+  action: z10.literal("pi_history_progress"),
+  analysisJobId: z10.string(),
+  repoFullName: z10.string(),
+  phase: z10.enum([
+    "fetching_issues",
+    "fetching_prs",
+    "calculating_stats",
+    "building_profiles",
+    "extracting_keywords",
+    "saving"
+  ]),
+  percentage: z10.number(),
+  message: z10.string(),
+  itemsProcessed: z10.number().optional(),
+  totalItems: z10.number().optional(),
+  clientId: z10.string().optional()
+});
+var PiHistoryCompleteAction = z10.object({
+  action: z10.literal("pi_history_complete"),
+  analysisJobId: z10.string(),
+  repoFullName: z10.string(),
+  stats: z10.object({
+    closedIssues: z10.number(),
+    mergedPRs: z10.number(),
+    contributors: z10.number()
+  }),
+  clientId: z10.string().optional()
+});
+var PiHistoryErrorAction = z10.object({
+  action: z10.literal("pi_history_error"),
+  analysisJobId: z10.string(),
+  repoFullName: z10.string(),
+  error: z10.string(),
+  phase: z10.string(),
+  clientId: z10.string().optional()
+});
 var StreamedChatCompletionAction = z10.object({
   action: z10.literal("streamed_chat_completion"),
   clientId: z10.string().optional(),
@@ -1260,6 +1432,11 @@ var ResearchModeStreamAction = z10.object({
     completionInfo: z10.any().optional()
   }).optional()
 });
+var VoiceCreditsExhaustedAction = z10.object({
+  action: z10.literal("voice_credits_exhausted"),
+  creditsUsed: z10.number(),
+  clientId: z10.string().optional()
+});
 var SessionCreatedAction = shareableDocumentSchema.extend({
   action: z10.literal("session.created"),
   id: z10.string(),
@@ -1316,7 +1493,11 @@ var MessageDataToClient = z10.discriminatedUnion("action", [
   SpiderProgressUpdateAction,
   SpiderCompleteAction,
   SpiderErrorAction,
-  SessionCreatedAction
+  PiHistoryProgressAction,
+  PiHistoryCompleteAction,
+  PiHistoryErrorAction,
+  SessionCreatedAction,
+  VoiceCreditsExhaustedAction
 ]);
 
 // ../../b4m-core/packages/common/dist/src/schemas/cliCompletions.js
@@ -2154,6 +2335,7 @@ var SettingKeySchema = z21.enum([
   "EnableArtifacts",
   "EnableAgents",
   "EnableRapidReply",
+  "EnableLattice",
   "RapidReplySettings",
   "EnableResearchEngine",
   "EnableOllama",
@@ -2679,13 +2861,14 @@ var API_SERVICE_GROUPS = {
       { key: "EnableResearchEngine", order: 8 },
       { key: "EnableReactViewer", order: 9 },
       { key: "EnableDeepResearch", order: 10 },
-      { key: "EnableKnowledgeBaseSearch", order: 11 },
-      { key: "EnableStreamIdleTimeout", order: 12 },
-      { key: "StreamIdleTimeoutSeconds", order: 13 },
-      { key: "EnableMcpToolFiltering", order: 14 },
-      { key: "McpToolFilteringMaxTools", order: 15 },
-      { key: "EnableParallelToolExecution", order: 16 },
-      { key: "EnableHelpChat", order: 17 }
+      { key: "EnableLattice", order: 11 },
+      { key: "EnableKnowledgeBaseSearch", order: 12 },
+      { key: "EnableStreamIdleTimeout", order: 13 },
+      { key: "StreamIdleTimeoutSeconds", order: 14 },
+      { key: "EnableMcpToolFiltering", order: 15 },
+      { key: "McpToolFilteringMaxTools", order: 16 },
+      { key: "EnableParallelToolExecution", order: 17 },
+      { key: "EnableHelpChat", order: 18 }
     ]
   },
   NOTEBOOK: {
@@ -3587,6 +3770,15 @@ 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
+  }),
   EnableKnowledgeBaseSearch: makeBooleanSetting({
     key: "EnableKnowledgeBaseSearch",
     name: "Enable Knowledge Base Search",
@@ -3594,7 +3786,7 @@ var settingsMap = {
     description: "Allow AI to search user uploaded documents. When enabled, users can toggle the Knowledge Base Search tool in AI Settings.",
     category: "Experimental",
     group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
-    order: 11
+    order: 12
   }),
   enableVoiceSession: makeBooleanSetting({
     key: "enableVoiceSession",
@@ -4400,6 +4592,445 @@ var InternalTeamMemberSchema = z24.object({
 });
 var InternalTeamMemberListSchema = z24.array(InternalTeamMemberSchema);
 
+// ../../b4m-core/packages/common/dist/src/schemas/lattice.js
+import { z as z25 } from "zod";
+var LatticeDataTypeSchema = z25.enum([
+  "number",
+  "currency",
+  "percentage",
+  "string",
+  "boolean",
+  "date",
+  "datetime"
+]);
+var LatticeEntityTypeSchema = z25.enum(["line_item", "account", "period", "category", "scenario", "custom"]);
+var LatticeRelationshipTypeSchema = z25.enum(["parent_child", "temporal", "reference", "derived"]);
+var LatticeRuleTypeSchema = z25.enum(["formula", "aggregation", "constraint", "transformation", "conditional"]);
+var LatticeOperationSchema = z25.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 = z25.enum(["==", "!=", ">", "<", ">=", "<=", "contains", "in"]);
+var LatticePeriodGrainSchema = z25.enum(["day", "week", "month", "quarter", "year"]);
+var LatticeNegativeFormatSchema = z25.enum(["parentheses", "minus", "red"]);
+var LatticeViewTypeSchema = z25.enum([
+  "table",
+  "pivot",
+  "time_series",
+  "comparison",
+  "summary_card",
+  "waterfall",
+  "tree"
+]);
+var LatticeModelTypeSchema = z25.enum([
+  "income_statement",
+  "balance_sheet",
+  "cashflow",
+  "saas_metrics",
+  "dcf",
+  "lbo",
+  "custom"
+]);
+var LatticeIntentTypeSchema = z25.enum([
+  "CREATE_ENTITY",
+  "SET_VALUE",
+  "CREATE_RULE",
+  "QUERY_VALUE",
+  "QUERY_AGGREGATE",
+  "CREATE_VIEW",
+  "COMPARE",
+  "FORECAST",
+  "EXPLAIN",
+  "UNDO",
+  "REDO",
+  "LIST",
+  "DELETE",
+  "AMBIGUOUS"
+]);
+var LatticeErrorTypeSchema = z25.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 = z25.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 = z25.enum(["csv", "json", "xlsx"]);
+var LatticePrimitiveValueSchema = z25.union([z25.number(), z25.string(), z25.boolean(), z25.date(), z25.null()]);
+var LatticeAttributeSchema = z25.object({
+  key: z25.string().min(1).max(100),
+  value: LatticePrimitiveValueSchema,
+  dataType: LatticeDataTypeSchema,
+  isComputed: z25.boolean().default(false),
+  computedByRuleId: z25.string().optional(),
+  timestamp: z25.number().optional(),
+  metadata: z25.record(z25.unknown()).optional()
+});
+var LatticeEntitySchema = z25.object({
+  id: z25.string().min(1).max(100),
+  type: LatticeEntityTypeSchema,
+  name: z25.string().min(1).max(255),
+  displayName: z25.string().max(255).optional(),
+  attributes: z25.array(LatticeAttributeSchema).default([]),
+  metadata: z25.record(z25.unknown()).default({}),
+  createdAt: z25.date(),
+  updatedAt: z25.date()
+});
+var LatticeRelationshipSchema = z25.object({
+  id: z25.string().min(1).max(100),
+  type: LatticeRelationshipTypeSchema,
+  fromEntityId: z25.string(),
+  toEntityId: z25.string(),
+  metadata: z25.record(z25.unknown()).optional()
+});
+var LatticeDataStoreSchema = z25.object({
+  entities: z25.array(LatticeEntitySchema).default([]),
+  relationships: z25.array(LatticeRelationshipSchema).default([])
+});
+var LatticeInputSchema = z25.object({
+  type: z25.enum(["entity", "attribute", "rule", "literal", "range"]),
+  ref: z25.string(),
+  selector: z25.string().optional()
+});
+var LatticeOutputSchema = z25.object({
+  targetEntityId: z25.string(),
+  targetAttribute: z25.string(),
+  dataType: LatticeDataTypeSchema
+});
+var LatticeConditionSchema = z25.object({
+  left: LatticeInputSchema,
+  operator: LatticeConditionOperatorSchema,
+  right: LatticeInputSchema,
+  logicalJoin: z25.enum(["AND", "OR"]).optional()
+});
+var LatticeRuleDefinitionSchema = z25.object({
+  operation: LatticeOperationSchema,
+  inputs: z25.array(LatticeInputSchema).min(1),
+  output: LatticeOutputSchema,
+  conditions: z25.array(LatticeConditionSchema).optional()
+});
+var LatticeRuleSchema = z25.object({
+  id: z25.string().min(1).max(100),
+  name: z25.string().min(1).max(255),
+  description: z25.string().max(1e3).optional(),
+  type: LatticeRuleTypeSchema,
+  definition: LatticeRuleDefinitionSchema,
+  dependencies: z25.array(z25.string()).default([]),
+  priority: z25.number().int().default(0),
+  enabled: z25.boolean().default(true),
+  createdAt: z25.date(),
+  updatedAt: z25.date()
+});
+var LatticeRulesetSchema = z25.object({
+  id: z25.string().min(1).max(100),
+  name: z25.string().min(1).max(255),
+  ruleIds: z25.array(z25.string()).default([]),
+  description: z25.string().max(1e3).optional()
+});
+var LatticeRulesStoreSchema = z25.object({
+  rules: z25.array(LatticeRuleSchema).default([]),
+  rulesets: z25.array(LatticeRulesetSchema).default([])
+});
+var LatticeRowConfigSchema = z25.object({
+  source: z25.enum(["entity", "rule", "category"]),
+  ref: z25.string(),
+  label: z25.string().optional(),
+  indent: z25.number().int().min(0).max(10).optional(),
+  isSummary: z25.boolean().optional()
+});
+var LatticeColumnConfigSchema = z25.object({
+  source: z25.enum(["period", "scenario", "attribute", "computed"]),
+  ref: z25.string(),
+  label: z25.string().optional(),
+  width: z25.number().positive().optional()
+});
+var LatticeFilterSchema = z25.object({
+  field: z25.string(),
+  operator: LatticeConditionOperatorSchema,
+  value: LatticePrimitiveValueSchema
+});
+var LatticeSortConfigSchema = z25.object({
+  field: z25.string(),
+  direction: z25.enum(["asc", "desc"])
+});
+var LatticeGroupConfigSchema = z25.object({
+  groupBy: z25.array(z25.string()),
+  aggregation: LatticeOperationSchema
+});
+var LatticeFormatConfigSchema = z25.object({
+  numberFormat: z25.string().optional(),
+  currencySymbol: z25.string().max(10).optional(),
+  percentageDecimals: z25.number().int().min(0).max(10).optional(),
+  negativeFormat: LatticeNegativeFormatSchema.optional(),
+  showGridLines: z25.boolean().optional(),
+  zebra: z25.boolean().optional(),
+  compactMode: z25.boolean().optional()
+});
+var LatticeViewConfigSchema = z25.object({
+  rows: z25.array(LatticeRowConfigSchema).optional(),
+  columns: z25.array(LatticeColumnConfigSchema).optional(),
+  filters: z25.array(LatticeFilterSchema).optional(),
+  sorting: z25.array(LatticeSortConfigSchema).optional(),
+  grouping: LatticeGroupConfigSchema.optional(),
+  formatting: LatticeFormatConfigSchema.optional()
+});
+var LatticeViewSchema = z25.object({
+  id: z25.string().min(1).max(100),
+  type: LatticeViewTypeSchema,
+  name: z25.string().min(1).max(255),
+  config: LatticeViewConfigSchema,
+  createdAt: z25.date(),
+  updatedAt: z25.date()
+});
+var LatticeViewStoreSchema = z25.object({
+  views: z25.array(LatticeViewSchema).default([]),
+  activeViewId: z25.string().optional()
+});
+var LatticeModelSettingsSchema = z25.object({
+  currency: z25.string().min(1).max(10).default("USD"),
+  fiscalYearStart: z25.string().regex(/^\d{2}-\d{2}$/).default("01-01"),
+  periodGrain: LatticePeriodGrainSchema.default("quarter"),
+  defaultDecimalPlaces: z25.number().int().min(0).max(10).default(2),
+  negativeFormat: LatticeNegativeFormatSchema.default("parentheses")
+});
+var LatticeHistoryOperationSchema = z25.object({
+  id: z25.string(),
+  type: LatticeOperationTypeSchema,
+  timestamp: z25.date(),
+  data: z25.record(z25.unknown()),
+  inverse: z25.record(z25.unknown()),
+  description: z25.string(),
+  messageId: z25.string().optional()
+});
+var LatticeScenarioOverrideSchema = z25.object({
+  entityId: z25.string(),
+  attributeKey: z25.string(),
+  value: LatticePrimitiveValueSchema
+});
+var LatticeScenarioSchema = z25.object({
+  id: z25.string().min(1).max(100),
+  name: z25.string().min(1).max(255),
+  description: z25.string().max(1e3).optional(),
+  overrides: z25.array(LatticeScenarioOverrideSchema).default([]),
+  createdAt: z25.date(),
+  updatedAt: z25.date()
+});
+var LatticeComputedValueSchema = z25.object({
+  value: LatticePrimitiveValueSchema,
+  computedByRuleId: z25.string(),
+  computedAt: z25.date()
+});
+var LatticeComputedValuesSchema = z25.record(z25.record(LatticeComputedValueSchema));
+var LatticeCalculationStepSchema = z25.object({
+  ruleId: z25.string(),
+  ruleName: z25.string(),
+  operation: LatticeOperationSchema,
+  inputs: z25.array(z25.object({
+    name: z25.string(),
+    value: LatticePrimitiveValueSchema
+  })),
+  output: LatticePrimitiveValueSchema
+});
+var LatticeCalculationChainSchema = z25.object({
+  targetEntity: z25.string(),
+  targetAttribute: z25.string(),
+  finalValue: LatticePrimitiveValueSchema,
+  steps: z25.array(LatticeCalculationStepSchema)
+});
+var LatticeModelSchema = z25.object({
+  // Identity
+  id: z25.string().min(1).max(100),
+  name: z25.string().min(1).max(255),
+  description: z25.string().max(2e3).optional(),
+  modelType: LatticeModelTypeSchema.default("custom"),
+  // Ownership
+  userId: z25.string(),
+  sessionId: z25.string().optional(),
+  projectId: z25.string().optional(),
+  organizationId: z25.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: z25.array(LatticeScenarioSchema).default([]),
+  activeScenarioId: z25.string().optional(),
+  // History
+  operations: z25.array(LatticeHistoryOperationSchema).default([]),
+  operationIndex: z25.number().int().min(-1).default(-1),
+  // Versioning
+  version: z25.number().int().positive().default(1),
+  contentHash: z25.string().optional(),
+  // Timestamps
+  createdAt: z25.date(),
+  updatedAt: z25.date(),
+  lastComputedAt: z25.date().optional(),
+  // Soft delete
+  deletedAt: z25.date().optional()
+});
+var LatticeExtractedEntitySchema = z25.object({
+  type: z25.enum([
+    "line_item_name",
+    "period",
+    "amount",
+    "percentage",
+    "operation",
+    "comparison_operator",
+    "entity_reference",
+    "category",
+    "scenario"
+  ]),
+  value: z25.string(),
+  normalizedValue: z25.union([z25.string(), z25.number()]).optional(),
+  position: z25.object({
+    start: z25.number().int().min(0),
+    end: z25.number().int().min(0)
+  }),
+  confidence: z25.number().min(0).max(1)
+});
+var LatticeParsedIntentSchema = z25.object({
+  intent: LatticeIntentTypeSchema,
+  confidence: z25.number().min(0).max(1),
+  entities: z25.array(LatticeExtractedEntitySchema),
+  rawInput: z25.string(),
+  normalizedInput: z25.string(),
+  suggestedOperations: z25.array(LatticeHistoryOperationSchema).optional(),
+  ambiguousRefs: z25.array(z25.object({
+    value: z25.string(),
+    candidates: z25.array(z25.string())
+  })).optional(),
+  clarificationNeeded: z25.string().optional()
+});
+var LatticeErrorSchema = z25.object({
+  type: LatticeErrorTypeSchema,
+  message: z25.string(),
+  suggestions: z25.array(z25.string()).optional(),
+  context: z25.object({
+    input: z25.string().optional(),
+    position: z25.number().optional(),
+    relatedEntities: z25.array(z25.string()).optional(),
+    relatedRules: z25.array(z25.string()).optional()
+  }).optional()
+});
+var CreateLatticeModelRequestSchema = z25.object({
+  name: z25.string().min(1).max(255),
+  description: z25.string().max(2e3).optional(),
+  modelType: LatticeModelTypeSchema.optional(),
+  sessionId: z25.string().optional(),
+  projectId: z25.string().optional(),
+  settings: LatticeModelSettingsSchema.partial().optional()
+});
+var UpdateLatticeModelRequestSchema = z25.object({
+  name: z25.string().min(1).max(255).optional(),
+  description: z25.string().max(2e3).optional(),
+  settings: LatticeModelSettingsSchema.partial().optional(),
+  data: LatticeDataStoreSchema.optional(),
+  rules: LatticeRulesStoreSchema.optional(),
+  views: LatticeViewStoreSchema.optional()
+});
+var ComputeLatticeRequestSchema = z25.object({
+  scenarioId: z25.string().optional()
+});
+var ComputeLatticeResponseSchema = z25.object({
+  computedValues: LatticeComputedValuesSchema,
+  duration: z25.number(),
+  errors: z25.array(LatticeErrorSchema).optional()
+});
+var ExplainLatticeRequestSchema = z25.object({
+  entityId: z25.string(),
+  attributeKey: z25.string()
+});
+var ExplainLatticeResponseSchema = z25.object({
+  chain: LatticeCalculationChainSchema
+});
+var ExportLatticeRequestSchema = z25.object({
+  format: LatticeExportFormatSchema,
+  viewId: z25.string().optional(),
+  scenarioId: z25.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) => {
@@ -4410,134 +5041,136 @@ var getPredefinedTags = () => {
 };
 
 // ../../b4m-core/packages/common/dist/src/llm.js
-import { z as z25 } from "zod";
-var DashboardParamsSchema = z25.object({
-  dashboardDataSources: z25.array(z25.object({
-    sourceName: z25.string(),
-    data: z25.any()
+import { z as z26 } from "zod";
+var DashboardParamsSchema = z26.object({
+  dashboardDataSources: z26.array(z26.object({
+    sourceName: z26.string(),
+    data: z26.any()
   })),
-  promptName: z25.string().optional()
+  promptName: z26.string().optional()
 });
-var QuestMasterParamsSchema = z25.object({
-  questMasterPlanId: z25.string(),
-  questId: z25.string(),
-  subQuestId: z25.string()
+var QuestMasterParamsSchema = z26.object({
+  questMasterPlanId: z26.string(),
+  questId: z26.string(),
+  subQuestId: z26.string()
 });
-var ResearchModeConfigurationSchema = z25.object({
-  id: z25.string(),
-  enabled: z25.boolean(),
-  model: z25.string(),
-  parameters: z25.object({
-    temperature: z25.number().optional(),
-    maxTokens: z25.number().optional(),
-    topP: z25.number().optional(),
-    presencePenalty: z25.number().optional(),
-    frequencyPenalty: z25.number().optional()
+var ResearchModeConfigurationSchema = z26.object({
+  id: z26.string(),
+  enabled: z26.boolean(),
+  model: z26.string(),
+  parameters: z26.object({
+    temperature: z26.number().optional(),
+    maxTokens: z26.number().optional(),
+    topP: z26.number().optional(),
+    presencePenalty: z26.number().optional(),
+    frequencyPenalty: z26.number().optional()
   }),
-  label: z25.string().optional()
+  label: z26.string().optional()
 });
-var ResearchModeParamsSchema = z25.object({
-  enabled: z25.boolean(),
-  configurations: z25.array(ResearchModeConfigurationSchema).max(4)
+var ResearchModeParamsSchema = z26.object({
+  enabled: z26.boolean(),
+  configurations: z26.array(ResearchModeConfigurationSchema).max(4)
 });
 var GenerateImageIvokeParamsSchema = OpenAIImageGenerationInput.extend({
-  sessionId: z25.string(),
-  questId: z25.string().optional(),
-  organizationId: z25.string().nullable().optional(),
-  width: z25.number().optional(),
-  height: z25.number().optional(),
-  aspect_ratio: z25.string().optional(),
-  fabFileIds: z25.array(z25.string()).default([]),
-  tools: z25.array(z25.union([b4mLLMTools, z25.string()])).optional(),
-  promptEnhancement: z25.object({
-    originalPrompt: z25.string(),
-    enhancedPrompt: z25.string(),
-    promptWasEnhanced: z25.boolean()
+  sessionId: z26.string(),
+  questId: z26.string().optional(),
+  organizationId: z26.string().nullable().optional(),
+  width: z26.number().optional(),
+  height: z26.number().optional(),
+  aspect_ratio: z26.string().optional(),
+  fabFileIds: z26.array(z26.string()).default([]),
+  tools: z26.array(z26.union([b4mLLMTools, z26.string()])).optional(),
+  promptEnhancement: z26.object({
+    originalPrompt: z26.string(),
+    enhancedPrompt: z26.string(),
+    promptWasEnhanced: z26.boolean()
   }).optional()
 });
 var GenerateImageRequestBodySchema = GenerateImageIvokeParamsSchema.extend({
-  sessionId: z25.string().optional(),
-  sessionName: z25.string().optional(),
-  projectId: z25.string().optional()
+  sessionId: z26.string().optional(),
+  sessionName: z26.string().optional(),
+  projectId: z26.string().optional()
 });
 var GenerateImageToolCallSchema = OpenAIImageGenerationInput.extend({
-  safety_tolerance: z25.number().optional(),
-  prompt_upsampling: z25.boolean().optional(),
-  output_format: z25.enum(["jpeg", "png"]).nullable().optional(),
-  seed: z25.number().nullable().optional(),
-  editModel: z25.string().optional()
+  safety_tolerance: z26.number().optional(),
+  prompt_upsampling: z26.boolean().optional(),
+  output_format: z26.enum(["jpeg", "png"]).nullable().optional(),
+  seed: z26.number().nullable().optional(),
+  editModel: z26.string().optional()
   // Model to use for image editing operations (separate from generation model)
 }).omit({
   prompt: true
 });
 var EditImageRequestBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z25.string(),
-  questId: z25.string().optional(),
-  organizationId: z25.string().nullable().optional(),
-  aspect_ratio: z25.string().optional(),
-  fabFileIds: z25.array(z25.string()).default([]),
-  image: z25.string()
-});
-var ChatCompletionInvokeParamsSchema = z25.object({
+  sessionId: z26.string(),
+  questId: z26.string().optional(),
+  organizationId: z26.string().nullable().optional(),
+  aspect_ratio: z26.string().optional(),
+  fabFileIds: z26.array(z26.string()).default([]),
+  image: z26.string()
+});
+var ChatCompletionInvokeParamsSchema = z26.object({
   /** Notebook session ID */
-  sessionId: z25.string(),
-  historyCount: z25.number(),
+  sessionId: z26.string(),
+  historyCount: z26.number(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z25.object({
-    maxDepth: z25.number().optional(),
-    duration: z25.number().optional(),
+  deepResearchConfig: z26.object({
+    maxDepth: z26.number().optional(),
+    duration: z26.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z25.array(z25.any()).optional()
+    searchers: z26.array(z26.any()).optional()
   }).optional(),
-  fabFileIds: z25.array(z25.string()),
+  fabFileIds: z26.array(z26.string()),
   /** Prompt message */
-  message: z25.string(),
-  messageFileIds: z25.array(z25.string()).default([]),
-  questId: z25.string().optional(),
+  message: z26.string(),
+  messageFileIds: z26.array(z26.string()).default([]),
+  questId: z26.string().optional(),
   /** Extra context messages to include in the conversation from external sources */
-  extraContextMessages: z25.array(z25.object({
-    role: z25.enum(["user", "assistant", "system", "function", "tool"]),
-    content: z25.union([z25.string(), z25.array(z25.any())]),
-    fabFileIds: z25.array(z25.string()).optional()
+  extraContextMessages: z26.array(z26.object({
+    role: z26.enum(["user", "assistant", "system", "function", "tool"]),
+    content: z26.union([z26.string(), z26.array(z26.any())]),
+    fabFileIds: z26.array(z26.string()).optional()
   })).optional(),
   /** Dashboard related params */
   dashboardParams: DashboardParamsSchema.optional(),
   /** LLM params */
   params: ChatCompletionCreateInputSchema,
   /** Whether Quest Master is enabled */
-  enableQuestMaster: z25.boolean().optional(),
+  enableQuestMaster: z26.boolean().optional(),
   /** Whether Mementos is enabled */
-  enableMementos: z25.boolean().optional(),
+  enableMementos: z26.boolean().optional(),
   /** Whether Artifacts is enabled */
-  enableArtifacts: z25.boolean().optional(),
+  enableArtifacts: z26.boolean().optional(),
   /** Whether Agents is enabled */
-  enableAgents: z25.boolean().optional(),
+  enableAgents: z26.boolean().optional(),
+  /** Whether Lattice (financial pro-forma modeling) is enabled */
+  enableLattice: z26.boolean().optional(),
   /** LLM tools to enable (built-in tools or MCP tool names) */
-  tools: z25.array(z25.union([b4mLLMTools, z25.string()])).optional(),
+  tools: z26.array(z26.union([b4mLLMTools, z26.string()])).optional(),
   /** Enabled MCP servers */
-  mcpServers: z25.array(z25.string()).optional(),
+  mcpServers: z26.array(z26.string()).optional(),
   /** Project ID */
-  projectId: z25.string().optional(),
+  projectId: z26.string().optional(),
   /** Organization ID */
-  organizationId: z25.string().nullable().optional(),
+  organizationId: z26.string().nullable().optional(),
   /** Tool prompt ID to use for the LLM */
-  toolPromptId: z25.string().optional(),
+  toolPromptId: z26.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: z25.string().optional(),
+  fallbackModel: z26.string().optional(),
   /** Embedding model to use */
-  embeddingModel: z25.string().optional(),
+  embeddingModel: z26.string().optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z25.string().optional()
+  timezone: z26.string().optional()
 });
 var LLMApiRequestBodySchema = ChatCompletionInvokeParamsSchema.extend({
   /** Notebook session ID */
-  sessionId: z25.string().optional(),
+  sessionId: z26.string().optional(),
   /** Notebook session name */
-  sessionName: z25.string().optional()
+  sessionName: z26.string().optional()
 });
 
 // ../../b4m-core/packages/common/dist/src/utils.js
@@ -4686,16 +5319,16 @@ var extractSnippetMeta = (content) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/search.js
-import { z as z26 } from "zod";
-var searchSchema = z26.object({
-  search: z26.string().optional(),
-  pagination: z26.object({
-    page: z26.coerce.number().int().positive(),
-    limit: z26.coerce.number().int().positive()
+import { z as z27 } from "zod";
+var searchSchema = z27.object({
+  search: z27.string().optional(),
+  pagination: z27.object({
+    page: z27.coerce.number().int().positive(),
+    limit: z27.coerce.number().int().positive()
   }).optional(),
-  orderBy: z26.object({
-    field: z26.string(),
-    direction: z26.enum(["asc", "desc"])
+  orderBy: z27.object({
+    field: z27.string(),
+    direction: z27.enum(["asc", "desc"])
   }).optional()
 });
 
@@ -4833,6 +5466,80 @@ var LinkedInApi = class {
   };
 };
 
+// ../../b4m-core/packages/common/dist/src/rateLimitHeaders.js
+function getHeader(headers, name) {
+  if (!headers || typeof headers !== "object")
+    return null;
+  if (typeof headers.get === "function") {
+    const val = headers.get(name);
+    return typeof val === "string" ? val : null;
+  }
+  const value = headers[name] ?? headers[name.toLowerCase()];
+  return typeof value === "string" ? value : null;
+}
+function parseNumber(value) {
+  if (value === null || value === void 0)
+    return null;
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+}
+function parseRateLimitHeaders(headers) {
+  const limitStr = getHeader(headers, "X-RateLimit-Limit") ?? getHeader(headers, "x-ratelimit-limit");
+  const remainingStr = getHeader(headers, "X-RateLimit-Remaining") ?? getHeader(headers, "x-ratelimit-remaining");
+  const resetStr = getHeader(headers, "X-RateLimit-Reset") ?? getHeader(headers, "x-ratelimit-reset");
+  const retryAfterStr = getHeader(headers, "Retry-After") ?? getHeader(headers, "retry-after");
+  const limit = parseNumber(limitStr);
+  const remaining = parseNumber(remainingStr);
+  let resetAt = null;
+  if (resetStr !== null) {
+    const resetNum = Number(resetStr);
+    if (Number.isFinite(resetNum)) {
+      resetAt = new Date(resetNum * 1e3);
+    } else {
+      const parsed = new Date(resetStr);
+      if (!isNaN(parsed.getTime())) {
+        resetAt = parsed;
+      }
+    }
+  }
+  let retryAfterMs = null;
+  if (retryAfterStr !== null) {
+    const retryNum = Number(retryAfterStr);
+    if (Number.isFinite(retryNum)) {
+      retryAfterMs = retryNum * 1e3;
+    } else {
+      const parsed = new Date(retryAfterStr);
+      if (!isNaN(parsed.getTime())) {
+        retryAfterMs = Math.max(0, parsed.getTime() - Date.now());
+      }
+    }
+  }
+  let usagePercent = null;
+  if (limit !== null && limit > 0 && remaining !== null) {
+    usagePercent = Math.round((limit - remaining) / limit * 100);
+  }
+  return { limit, remaining, resetAt, retryAfterMs, usagePercent };
+}
+function isNearLimit(info, thresholdPercent = 80) {
+  if (info.usagePercent === null)
+    return false;
+  return info.usagePercent >= thresholdPercent;
+}
+function buildRateLimitLogEntry(integration, endpoint, info, wasThrottled = false) {
+  return {
+    type: wasThrottled ? "RATE_LIMIT_ERROR" : "RATE_LIMIT",
+    integration,
+    endpoint,
+    limit: info.limit,
+    remaining: info.remaining,
+    resetAt: info.resetAt?.toISOString() ?? null,
+    retryAfterMs: info.retryAfterMs,
+    usagePercent: info.usagePercent,
+    wasThrottled,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
 // ../../b4m-core/packages/common/dist/src/confluence/format.js
 function stripHtmlAndNormalizeWhitespace(html) {
   if (!html)
@@ -5087,6 +5794,26 @@ var ConfluenceApi = class {
       headers,
       body: options.body ? JSON.stringify(options.body) : void 0
     });
+    const rateLimitInfo = parseRateLimitHeaders(response.headers);
+    if (rateLimitInfo.remaining !== null) {
+      const logEntry = buildRateLimitLogEntry("confluence", path, rateLimitInfo);
+      console.error(JSON.stringify(logEntry));
+    }
+    if (isNearLimit(rateLimitInfo)) {
+      console.error(`[Confluence] Rate limit warning: ${rateLimitInfo.usagePercent}% used (${rateLimitInfo.remaining}/${rateLimitInfo.limit} remaining)`);
+    }
+    if (response.status === 429 && (options._retryCount ?? 0) < 1) {
+      const retryAfterMs = rateLimitInfo.retryAfterMs ?? 5e3;
+      const delayMs = Math.min(retryAfterMs, 1e4);
+      const logEntry = buildRateLimitLogEntry("confluence", path, rateLimitInfo, true);
+      console.error(JSON.stringify(logEntry));
+      console.error(`[Confluence] Rate limited on ${path}, retrying after ${delayMs}ms`);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      return this.request(method, path, {
+        ...options,
+        _retryCount: (options._retryCount ?? 0) + 1
+      });
+    }
     if (!response.ok) {
       const rawBody = await response.text();
       let errorDetail = response.statusText;
@@ -6626,6 +7353,26 @@ var JiraApi = class {
       headers,
       body: options.body ? JSON.stringify(options.body) : void 0
     });
+    const rateLimitInfo = parseRateLimitHeaders(response.headers);
+    if (rateLimitInfo.remaining !== null) {
+      const logEntry = buildRateLimitLogEntry("jira", path, rateLimitInfo);
+      console.error(JSON.stringify(logEntry));
+    }
+    if (isNearLimit(rateLimitInfo)) {
+      console.error(`[Jira] Rate limit warning: ${rateLimitInfo.usagePercent}% used (${rateLimitInfo.remaining}/${rateLimitInfo.limit} remaining)`);
+    }
+    if (response.status === 429 && (options._retryCount ?? 0) < 1) {
+      const retryAfterMs = rateLimitInfo.retryAfterMs ?? 5e3;
+      const delayMs = Math.min(retryAfterMs, 1e4);
+      const logEntry = buildRateLimitLogEntry("jira", path, rateLimitInfo, true);
+      console.error(JSON.stringify(logEntry));
+      console.error(`[Jira] Rate limited on ${path}, retrying after ${delayMs}ms`);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      return this.request(method, path, {
+        ...options,
+        _retryCount: (options._retryCount ?? 0) + 1
+      });
+    }
     if (!response.ok) {
       const errorBody = await response.text();
       throw new Error(`Jira API error (${response.status}): ${errorBody}`);
@@ -7380,89 +8127,89 @@ var getMcpProviderMetadata = (providerName) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/artifacts.js
-import { z as z27 } from "zod";
-var ArtifactStatusSchema = z27.enum(["draft", "review", "published", "archived", "deleted"]);
-var VisibilitySchema = z27.enum(["private", "project", "organization", "public"]);
-var ArtifactPermissionsSchema = z27.object({
-  canRead: z27.array(z27.string()),
-  canWrite: z27.array(z27.string()),
-  canDelete: z27.array(z27.string()),
-  isPublic: z27.boolean().default(false),
-  inheritFromProject: z27.boolean().default(true)
-});
-var BaseArtifactSchema = z27.object({
-  id: z27.string().uuid(),
+import { z as z28 } from "zod";
+var ArtifactStatusSchema = z28.enum(["draft", "review", "published", "archived", "deleted"]);
+var VisibilitySchema = z28.enum(["private", "project", "organization", "public"]);
+var ArtifactPermissionsSchema = z28.object({
+  canRead: z28.array(z28.string()),
+  canWrite: z28.array(z28.string()),
+  canDelete: z28.array(z28.string()),
+  isPublic: z28.boolean().default(false),
+  inheritFromProject: z28.boolean().default(true)
+});
+var BaseArtifactSchema = z28.object({
+  id: z28.string().uuid(),
   type: ArtifactTypeSchema,
-  title: z27.string().min(1).max(255),
-  description: z27.string().max(1e3).optional(),
+  title: z28.string().min(1).max(255),
+  description: z28.string().max(1e3).optional(),
   // Versioning
-  version: z27.number().int().positive().default(1),
-  versionTag: z27.string().max(100).optional(),
-  currentVersionId: z27.string().uuid().optional(),
-  parentVersionId: z27.string().uuid().optional(),
+  version: z28.number().int().positive().default(1),
+  versionTag: z28.string().max(100).optional(),
+  currentVersionId: z28.string().uuid().optional(),
+  parentVersionId: z28.string().uuid().optional(),
   // Timestamps
-  createdAt: z27.date(),
-  updatedAt: z27.date(),
-  publishedAt: z27.date().optional(),
-  deletedAt: z27.date().optional(),
+  createdAt: z28.date(),
+  updatedAt: z28.date(),
+  publishedAt: z28.date().optional(),
+  deletedAt: z28.date().optional(),
   // Ownership & Access
-  userId: z27.string(),
-  projectId: z27.string().optional(),
-  organizationId: z27.string().optional(),
+  userId: z28.string(),
+  projectId: z28.string().optional(),
+  organizationId: z28.string().optional(),
   visibility: VisibilitySchema.default("private"),
   permissions: ArtifactPermissionsSchema,
   // Relationships
-  sourceQuestId: z27.string().optional(),
-  sessionId: z27.string().optional(),
-  parentArtifactId: z27.string().uuid().optional(),
+  sourceQuestId: z28.string().optional(),
+  sessionId: z28.string().optional(),
+  parentArtifactId: z28.string().uuid().optional(),
   // Status
   status: ArtifactStatusSchema.default("draft"),
-  tags: z27.array(z27.string().max(50)).max(20).default([]),
+  tags: z28.array(z28.string().max(50)).max(20).default([]),
   // Content
-  contentHash: z27.string(),
-  contentSize: z27.number().int().nonnegative(),
+  contentHash: z28.string(),
+  contentSize: z28.number().int().nonnegative(),
   // Metadata
-  metadata: z27.record(z27.unknown()).optional()
+  metadata: z28.record(z28.unknown()).optional()
 });
-var EnhancedArtifactMetadataSchema = z27.object({
-  language: z27.string().optional(),
-  dependencies: z27.array(z27.string()).optional(),
-  settings: z27.record(z27.unknown()).optional()
+var EnhancedArtifactMetadataSchema = z28.object({
+  language: z28.string().optional(),
+  dependencies: z28.array(z28.string()).optional(),
+  settings: z28.record(z28.unknown()).optional()
 });
 var ReactArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z27.literal("react"),
-  content: z27.string(),
+  type: z28.literal("react"),
+  content: z28.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    dependencies: z27.array(z27.string()),
-    props: z27.record(z27.unknown()).optional(),
-    hasDefaultExport: z27.boolean(),
-    errorBoundary: z27.boolean().default(true)
+    dependencies: z28.array(z28.string()),
+    props: z28.record(z28.unknown()).optional(),
+    hasDefaultExport: z28.boolean(),
+    errorBoundary: z28.boolean().default(true)
   })
 });
 var HtmlArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z27.literal("html"),
-  content: z27.string(),
+  type: z28.literal("html"),
+  content: z28.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    allowedScripts: z27.array(z27.string()).default([]),
-    cspPolicy: z27.string().optional(),
-    sanitized: z27.boolean().default(false)
+    allowedScripts: z28.array(z28.string()).default([]),
+    cspPolicy: z28.string().optional(),
+    sanitized: z28.boolean().default(false)
   })
 });
 var SvgArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z27.literal("svg"),
-  content: z27.string(),
+  type: z28.literal("svg"),
+  content: z28.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    viewBox: z27.string().optional(),
-    width: z27.number().positive().optional(),
-    height: z27.number().positive().optional(),
-    sanitized: z27.boolean().default(false)
+    viewBox: z28.string().optional(),
+    width: z28.number().positive().optional(),
+    height: z28.number().positive().optional(),
+    sanitized: z28.boolean().default(false)
   })
 });
 var MermaidArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z27.literal("mermaid"),
-  content: z27.string(),
+  type: z28.literal("mermaid"),
+  content: z28.string(),
   metadata: EnhancedArtifactMetadataSchema.extend({
-    chartType: z27.enum([
+    chartType: z28.enum([
       "flowchart",
       "sequenceDiagram",
       "classDiagram",
@@ -7472,7 +8219,7 @@ var MermaidArtifactV2Schema = BaseArtifactSchema.extend({
       "pie",
       "mindmap"
     ]).optional(),
-    description: z27.string().optional()
+    description: z28.string().optional()
   })
 });
 var ArtifactStatuses;
@@ -7500,39 +8247,39 @@ var validateMermaidArtifactV2 = (data) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/questmaster.js
-import { z as z28 } from "zod";
-var QuestStatusSchema = z28.enum(["pending", "in-progress", "completed", "skipped"]);
-var QuestSchema = z28.object({
-  id: z28.string().uuid(),
-  title: z28.string().min(1).max(255),
-  description: z28.string().max(1e3),
+import { z as z29 } from "zod";
+var QuestStatusSchema = z29.enum(["pending", "in-progress", "completed", "skipped"]);
+var QuestSchema = z29.object({
+  id: z29.string().uuid(),
+  title: z29.string().min(1).max(255),
+  description: z29.string().max(1e3),
   status: QuestStatusSchema.default("pending"),
-  order: z28.number().int().nonnegative(),
-  dependencies: z28.array(z28.string().uuid()).optional(),
-  estimatedMinutes: z28.number().int().positive().optional(),
-  completedAt: z28.date().optional(),
-  completedBy: z28.string().optional(),
-  metadata: z28.record(z28.unknown()).optional()
+  order: z29.number().int().nonnegative(),
+  dependencies: z29.array(z29.string().uuid()).optional(),
+  estimatedMinutes: z29.number().int().positive().optional(),
+  completedAt: z29.date().optional(),
+  completedBy: z29.string().optional(),
+  metadata: z29.record(z29.unknown()).optional()
 });
-var QuestResourceSchema = z28.object({
-  type: z28.enum(["documentation", "tutorial", "example", "tool"]),
-  title: z28.string().min(1).max(255),
-  url: z28.string().url(),
-  description: z28.string().max(500).optional()
-});
-var QuestMasterContentSchema = z28.object({
-  goal: z28.string().min(1).max(500),
-  quests: z28.array(QuestSchema).min(1),
-  totalSteps: z28.number().int().positive(),
-  estimatedDuration: z28.number().int().positive().optional(),
-  complexity: z28.enum(["low", "medium", "high"]),
-  category: z28.string().max(100).optional(),
-  prerequisites: z28.array(z28.string().max(255)).optional(),
-  completionCriteria: z28.array(z28.string().max(500)).optional(),
-  resources: z28.array(QuestResourceSchema).optional()
+var QuestResourceSchema = z29.object({
+  type: z29.enum(["documentation", "tutorial", "example", "tool"]),
+  title: z29.string().min(1).max(255),
+  url: z29.string().url(),
+  description: z29.string().max(500).optional()
+});
+var QuestMasterContentSchema = z29.object({
+  goal: z29.string().min(1).max(500),
+  quests: z29.array(QuestSchema).min(1),
+  totalSteps: z29.number().int().positive(),
+  estimatedDuration: z29.number().int().positive().optional(),
+  complexity: z29.enum(["low", "medium", "high"]),
+  category: z29.string().max(100).optional(),
+  prerequisites: z29.array(z29.string().max(255)).optional(),
+  completionCriteria: z29.array(z29.string().max(500)).optional(),
+  resources: z29.array(QuestResourceSchema).optional()
 });
 var QuestMasterArtifactV2Schema = BaseArtifactSchema.extend({
-  type: z28.literal("questmaster"),
+  type: z29.literal("questmaster"),
   content: QuestMasterContentSchema
 });
 var validateQuest = (data) => {
@@ -7549,13 +8296,13 @@ var safeParseQuestMasterArtifactV2 = (data) => {
 };
 
 // ../../b4m-core/packages/common/dist/src/schemas/curation.js
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var CurationType;
 (function(CurationType2) {
   CurationType2["TRANSCRIPT"] = "transcript";
   CurationType2["EXECUTIVE_SUMMARY"] = "executive_summary";
 })(CurationType || (CurationType = {}));
-var CurationTypeSchema = z29.nativeEnum(CurationType);
+var CurationTypeSchema = z30.nativeEnum(CurationType);
 var CurationArtifactType;
 (function(CurationArtifactType2) {
   CurationArtifactType2["CODE"] = "code";
@@ -7568,7 +8315,7 @@ var CurationArtifactType;
   CurationArtifactType2["DEEP_RESEARCH"] = "deep_research";
   CurationArtifactType2["IMAGE"] = "image";
 })(CurationArtifactType || (CurationArtifactType = {}));
-var CurationArtifactTypeSchema = z29.enum([
+var CurationArtifactTypeSchema = z30.enum([
   "CODE",
   "REACT",
   "HTML",
@@ -7579,28 +8326,28 @@ var CurationArtifactTypeSchema = z29.enum([
   "DEEP_RESEARCH",
   "IMAGE"
 ]);
-var ExportFormatSchema = z29.enum(["markdown", "txt", "html"]);
-var CurationOptionsSchema = z29.object({
+var ExportFormatSchema = z30.enum(["markdown", "txt", "html"]);
+var CurationOptionsSchema = z30.object({
   /** Curation type: transcript (Option 1) or executive_summary (Option 2) */
   curationType: CurationTypeSchema.default(CurationType.TRANSCRIPT),
   /** Include code artifacts in the curated notebook */
-  includeCode: z29.boolean().default(true),
+  includeCode: z30.boolean().default(true),
   /** Include diagrams (Mermaid, SVG) in the curated notebook */
-  includeDiagrams: z29.boolean().default(true),
+  includeDiagrams: z30.boolean().default(true),
   /** Include data visualizations (Recharts) in the curated notebook */
-  includeDataViz: z29.boolean().default(true),
+  includeDataViz: z30.boolean().default(true),
   /** Include QuestMaster plans in the curated notebook */
-  includeQuestMaster: z29.boolean().default(true),
+  includeQuestMaster: z30.boolean().default(true),
   /** Include Deep Research findings in the curated notebook */
-  includeResearch: z29.boolean().default(true),
+  includeResearch: z30.boolean().default(true),
   /** Include images in the curated notebook */
-  includeImages: z29.boolean().default(true),
+  includeImages: z30.boolean().default(true),
   /** Token budget for processing (varies by curation type) */
-  tokenBudget: z29.number().optional(),
+  tokenBudget: z30.number().optional(),
   /** Export format for the curated notebook */
   exportFormat: ExportFormatSchema.default("markdown"),
   /** Custom notebook name (optional, defaults to curated-notebook-{sessionId}) */
-  customNotebookName: z29.string().optional()
+  customNotebookName: z30.string().optional()
 });
 
 // ../../b4m-core/packages/common/dist/src/utils/artifactHelpers.js
@@ -7865,6 +8612,7 @@ export {
   SvgArtifactSchema,
   MermaidArtifactSchema,
   RechartsArtifactSchema,
+  LatticeArtifactSchema,
   MermaidChartMetadataSchema,
   ChatHistoryItemWithArtifactsSchema,
   ArtifactOperationSchema,
@@ -7923,6 +8671,13 @@ export {
   RapidReplyResponseStylesCommon,
   RapidReplyTransitionModes,
   RapidReplyFallbackBehaviors,
+  EmailJobStatus,
+  EmailSendStatus,
+  EmailJobOverallStatus,
+  EmailCategory,
+  calculateTaskValue,
+  calculateResourceAllocations,
+  detectResourceConflicts,
   SST_PLACEHOLDER_VALUE,
   NOT_CONFIGURED_PLACEHOLDER,
   isPlaceholderValue,
@@ -7946,6 +8701,9 @@ export {
   SpiderProgressUpdateAction,
   SpiderCompleteAction,
   SpiderErrorAction,
+  PiHistoryProgressAction,
+  PiHistoryCompleteAction,
+  PiHistoryErrorAction,
   StreamedChatCompletionAction,
   StreamedRapidReplyAction,
   HeartbeatPongAction,
@@ -7954,6 +8712,7 @@ export {
   UpdateResearchTaskStatusAction,
   ImportHistoryJobProgressUpdateAction,
   ResearchModeStreamAction,
+  VoiceCreditsExhaustedAction,
   SessionCreatedAction,
   MessageDataToServer,
   MessageDataToClient,
@@ -8044,6 +8803,67 @@ export {
   SlackEvents,
   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,
@@ -8070,6 +8890,9 @@ export {
   extractSnippetMeta,
   searchSchema,
   LinkedInApi,
+  parseRateLimitHeaders,
+  isNearLimit,
+  buildRateLimitLogEntry,
   RESTRICTION_OPERATIONS,
   RESTRICTION_SUBJECT_TYPES,
   CONFLUENCE_MAX_ATTACHMENT_SIZE,