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

package/dist/index.js

@@ -5,7 +5,8 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-XTJDV3TC.js";
+} from "./chunk-22VR7SKO.js";
+import "./chunk-RUI6HNLO.js";
 import {
   ConfigStore,
   logger
@@ -14,8 +15,8 @@ import {
   selectActiveBackgroundAgents,
   useCliStore
 } from "./chunk-TVW4ZESU.js";
-import "./chunk-TKZJAHDN.js";
-import "./chunk-HZNRFX2D.js";
+import "./chunk-UYN4HMRF.js";
+import "./chunk-YQWFK5O2.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -27,7 +28,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-SA634LPQ.js";
+} from "./chunk-5J4RL57F.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -83,7 +84,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-WKJ6QNRZ.js";
+} from "./chunk-TNFZP7FG.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -3331,8 +3332,7 @@ ${options.context}` : this.getSystemPrompt()
             maxTokens,
             temperature,
             abortSignal: options.signal,
-            tool_choice: this.context.toolChoice,
-            executeTools: false
+            tool_choice: this.context.toolChoice
           },
           async (texts, completionInfo) => {
             for (const text of texts) {
@@ -4073,7 +4073,8 @@ var recalculateUserStorageSchema = z14.object({
 // ../../b4m-core/packages/services/dist/src/userService/listRecentActivities.js
 import { z as z15 } from "zod";
 var listRecentActivitiesSchema = z15.object({
-  coverage: z15.enum(["all", "important"]).default("important")
+  coverage: z15.enum(["all", "important"]).default("important"),
+  userId: z15.string().optional()
 });
 var IMPORTANT_COUNTER_NAMES = [
   SessionEvents.CREATE_SESSION,
@@ -5717,7 +5718,19 @@ import { z as z129 } from "zod";
 var createArtifactSchema = z129.object({
   id: z129.string().optional(),
   // Allow custom ID for AI-generated artifacts
-  type: z129.enum(["mermaid", "recharts", "python", "react", "html", "svg", "code", "quest", "file", "questmaster"]),
+  type: z129.enum([
+    "mermaid",
+    "recharts",
+    "python",
+    "react",
+    "html",
+    "svg",
+    "code",
+    "quest",
+    "file",
+    "questmaster",
+    "lattice"
+  ]),
   title: z129.string().min(1).max(255),
   description: z129.string().max(1e3).optional(),
   content: z129.string().min(1),
@@ -10325,6 +10338,819 @@ BLOCKED OPERATIONS:
   })
 };
 
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/lattice/index.js
+function createModelData(name, modelType, userId, description, sessionId) {
+  const now = /* @__PURE__ */ new Date();
+  return {
+    name,
+    description: description || "",
+    modelType,
+    userId,
+    sessionId,
+    data: { entities: [], relationships: [] },
+    rules: { rules: [], rulesets: [] },
+    views: { views: [] },
+    settings: {
+      currency: "USD",
+      fiscalYearStart: "01-01",
+      periodGrain: "quarter",
+      defaultDecimalPlaces: 2,
+      negativeFormat: "parentheses"
+    },
+    scenarios: [],
+    operations: [],
+    operationIndex: -1,
+    version: 1,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+var latticeCreateModelTool = {
+  name: "lattice_create_model",
+  implementation: (context) => ({
+    toolFn: async (params) => {
+      const { name, description, modelType = "custom", initialData } = params;
+      console.log("[LATTICE DEBUG] \u{1F3D7}\uFE0F lattice_create_model called:", {
+        name,
+        description,
+        modelType,
+        hasInitialData: !!initialData,
+        entityCount: initialData?.entities?.length || 0,
+        ruleCount: initialData?.rules?.length || 0
+      });
+      const modelData = createModelData(name, modelType, context.userId, description);
+      if (initialData?.entities && modelData.data) {
+        const now = /* @__PURE__ */ new Date();
+        for (const entityDef of initialData.entities) {
+          const entityId = entityDef.name.toLowerCase().replace(/\s+/g, "_");
+          const attributes = [];
+          if (entityDef.values) {
+            for (const val of entityDef.values) {
+              attributes.push({
+                key: "period",
+                value: val.period,
+                dataType: "string",
+                isComputed: false
+              });
+              attributes.push({
+                key: "value",
+                value: val.value,
+                dataType: "currency",
+                isComputed: false
+              });
+              attributes.push({
+                key: "category",
+                value: entityDef.name,
+                dataType: "string",
+                isComputed: false
+              });
+              modelData.data.entities.push({
+                id: `${entityId}_${val.period.toLowerCase().replace(/\s+/g, "_")}`,
+                type: entityDef.type || "line_item",
+                name: `${entityDef.name} ${val.period}`,
+                displayName: `${entityDef.name} ${val.period}`,
+                attributes: [
+                  { key: "period", value: val.period, dataType: "string", isComputed: false },
+                  { key: "value", value: val.value, dataType: "currency", isComputed: false },
+                  { key: "category", value: entityDef.name, dataType: "string", isComputed: false }
+                ],
+                metadata: {},
+                createdAt: now,
+                updatedAt: now
+              });
+            }
+          }
+          console.log(`[LATTICE DEBUG] \u2795 Created entity: ${entityDef.name} with ${entityDef.values?.length || 0} period values`);
+        }
+      }
+      if (initialData?.rules && modelData.rules) {
+        const now = /* @__PURE__ */ new Date();
+        for (const ruleDef of initialData.rules) {
+          const ruleId = `rule_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
+          const parsedRule = parseFormula(ruleDef.formula);
+          modelData.rules.rules.push({
+            id: ruleId,
+            name: ruleDef.name,
+            description: ruleDef.formula,
+            type: "formula",
+            definition: {
+              operation: parsedRule.operation,
+              inputs: parsedRule.inputs.map((ref) => ({ type: "entity", ref })),
+              output: {
+                targetEntityId: parsedRule.outputEntity.toLowerCase().replace(/\s+/g, "_"),
+                targetAttribute: "computed",
+                dataType: "number"
+              }
+            },
+            dependencies: parsedRule.inputs.map((i) => i.toLowerCase().replace(/\s+/g, "_")),
+            priority: 0,
+            enabled: true,
+            createdAt: now,
+            updatedAt: now
+          });
+          console.log(`[LATTICE DEBUG] \u{1F4D0} Created rule: ${ruleDef.name} = ${ruleDef.formula}`);
+        }
+      }
+      let model;
+      let persistenceStatus = "unknown";
+      const dbKeys = Object.keys(context.db || {});
+      const hasLatticeModels = !!context.db?.latticeModels;
+      if (context.db.latticeModels) {
+        try {
+          model = await context.db.latticeModels.create(modelData);
+          persistenceStatus = `PERSISTED to MongoDB (id: ${model.id})`;
+          context.logger.info(`[Lattice] Created model ${model.id} in database`);
+        } catch (error) {
+          persistenceStatus = `FAILED: ${error instanceof Error ? error.message : String(error)}`;
+          context.logger.error(`[Lattice] Failed to persist model to database:`, error);
+          model = {
+            ...modelData,
+            id: `lattice_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+          };
+        }
+      } else {
+        persistenceStatus = `IN-MEMORY (no latticeModels adapter). DB keys: [${dbKeys.join(", ")}]`;
+        context.logger.warn("[Lattice] No database adapter available, creating in-memory model");
+        model = {
+          ...modelData,
+          id: `lattice_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+        };
+      }
+      const artifactData = {
+        type: "lattice",
+        id: model.id,
+        title: name,
+        content: JSON.stringify(model),
+        metadata: {
+          modelType,
+          periodGrain: model.settings?.periodGrain || "quarter",
+          currency: model.settings?.currency || "USD",
+          entityCount: model.data?.entities?.length || 0,
+          ruleCount: model.rules?.rules?.length || 0,
+          // DEBUG: Include persistence info in metadata
+          _debug: {
+            persistenceStatus,
+            hasLatticeModels,
+            dbKeys
+          }
+        },
+        createdAt: model.createdAt?.toISOString?.() || (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: model.updatedAt?.toISOString?.() || (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const entityCount = model.data?.entities?.length || 0;
+      const ruleCount = model.rules?.rules?.length || 0;
+      return `Created "${name}" model with ${entityCount} entities and ${ruleCount} rules.
+
+<artifact identifier="${model.id}" type="application/vnd.b4m.lattice" title="${name}">
+${JSON.stringify(artifactData, null, 2)}
+</artifact>
+
+The model is ready for viewing. You can add more data by asking to add line items or create formulas.`;
+    },
+    toolSchema: {
+      name: "lattice_create_model",
+      description: `Create a new Lattice financial model with optional initial data. Use initialData to populate entities and rules in ONE call.
+
+**IMPORTANT**: Always include initialData when the user provides specific values! This creates a fully populated model immediately.
+
+**When to use:** When the user wants to:
+- Create a new financial model, spreadsheet, or pro-forma
+- Start building an income statement, balance sheet, or cash flow
+- Set up a SaaS metrics dashboard
+
+**Example with initialData:**
+User: "Create income statement with $100K revenue and $60K costs for Q1"
+Call: lattice_create_model with:
+- name: "Income Statement"
+- modelType: "income_statement"
+- initialData: {
+    entities: [
+      { name: "Revenue", values: [{ period: "Q1", value: 100000 }] },
+      { name: "Costs", values: [{ period: "Q1", value: 60000 }] }
+    ],
+    rules: [
+      { name: "Gross Profit", formula: "Gross Profit = Revenue - Costs" }
+    ]
+  }`,
+      parameters: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: 'Name of the model (e.g., "2024 Budget", "Q1 Forecast")'
+          },
+          description: {
+            type: "string",
+            description: "Optional description of what this model represents"
+          },
+          modelType: {
+            type: "string",
+            enum: ["income_statement", "balance_sheet", "cashflow", "saas_metrics", "custom"],
+            description: "Type of financial model to create"
+          },
+          initialData: {
+            type: "object",
+            description: "Initial entities and rules to populate the model. ALWAYS use this when user provides data!",
+            properties: {
+              entities: {
+                type: "array",
+                description: "Line items with their period values",
+                items: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string", description: 'Entity name (e.g., "Revenue", "COGS")' },
+                    type: { type: "string", description: "Entity type (default: line_item)" },
+                    values: {
+                      type: "array",
+                      description: "Period-value pairs",
+                      items: {
+                        type: "object",
+                        properties: {
+                          period: { type: "string", description: 'Period name (e.g., "Q1", "Jan", "2024")' },
+                          value: { type: "number", description: "Numeric value" }
+                        },
+                        required: ["period", "value"]
+                      }
+                    }
+                  },
+                  required: ["name"]
+                }
+              },
+              rules: {
+                type: "array",
+                description: "Formulas/calculations to create",
+                items: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string", description: 'Rule name (e.g., "Gross Profit Calculation")' },
+                    formula: {
+                      type: "string",
+                      description: 'Natural language formula (e.g., "Gross Profit = Revenue - Costs")'
+                    }
+                  },
+                  required: ["name", "formula"]
+                }
+              }
+            }
+          }
+        },
+        required: ["name"]
+      }
+    }
+  })
+};
+var latticeAddEntityTool = {
+  name: "lattice_add_entity",
+  implementation: (context) => ({
+    toolFn: async (params) => {
+      const { modelId, name, type, displayName, initialValues = [] } = params;
+      console.log("[LATTICE DEBUG] \u2795 lattice_add_entity called:", { modelId, name, type, initialValues });
+      const entityId = name.toLowerCase().replace(/\s+/g, "_");
+      const entityData = {
+        id: entityId,
+        type,
+        name,
+        displayName: displayName || name,
+        attributes: initialValues.map((v) => ({
+          key: v.key,
+          value: v.value,
+          dataType: v.dataType || (typeof v.value === "number" ? "number" : "string"),
+          isComputed: false
+        })),
+        metadata: {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (context.db.latticeModels && modelId && /^[a-f0-9]{24}$/.test(modelId)) {
+        try {
+          const model = await context.db.latticeModels.findById(modelId);
+          if (model) {
+            const existingIndex = model.data.entities.findIndex((e) => e.id === entityId);
+            if (existingIndex >= 0) {
+              model.data.entities[existingIndex] = entityData;
+            } else {
+              model.data.entities.push(entityData);
+            }
+            await context.db.latticeModels.update({
+              id: modelId,
+              data: model.data,
+              updatedAt: /* @__PURE__ */ new Date()
+            });
+            context.logger.info(`[Lattice] Added entity ${entityId} to model ${modelId}`);
+          } else {
+            context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+          }
+        } catch (error) {
+          context.logger.error(`[Lattice] Failed to persist entity to database:`, error);
+        }
+      }
+      return JSON.stringify({
+        success: true,
+        action: "ADD_ENTITY",
+        modelId,
+        entityId,
+        data: entityData,
+        message: `Added ${type} "${displayName || name}" to model. ${initialValues.length > 0 ? `Set initial values: ${initialValues.map((v) => `${v.key}=${v.value}`).join(", ")}` : "No initial values set."}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_add_entity",
+      description: `Add a line item, account, period, or other entity to a Lattice model.
+
+**When to use:** When the user mentions:
+- Adding a revenue line, expense category, or account
+- Creating periods (Q1, Q2, Jan, Feb, etc.)
+- Adding any measurable item to their model
+
+**Entity types:**
+- line_item: Revenue streams, expense lines, KPIs
+- account: Cash, AR, AP, inventory, etc.
+- period: Q1 2024, Jan, FY2025, etc.
+- category: Groups of line items (Operating Expenses)
+- scenario: Base case, upside, downside
+- custom: Any other structured element
+
+**Examples:**
+- "Add Revenue" \u2192 line_item named "Revenue"
+- "Create a Marketing Expenses category" \u2192 category named "Marketing Expenses"
+- "Add quarters Q1 through Q4" \u2192 4 period entities`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model to add the entity to"
+          },
+          name: {
+            type: "string",
+            description: "Internal name for the entity (used in formulas)"
+          },
+          type: {
+            type: "string",
+            enum: ["line_item", "account", "period", "category", "scenario", "custom"],
+            description: "Type of entity"
+          },
+          displayName: {
+            type: "string",
+            description: "Human-readable display name (defaults to name)"
+          },
+          initialValues: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                key: { type: "string", description: 'Period or attribute key (e.g., "Q1_2024")' },
+                value: { type: "string", description: "The value (number or string)" },
+                dataType: {
+                  type: "string",
+                  enum: ["number", "currency", "percentage", "string"],
+                  description: "Data type for the value"
+                }
+              },
+              required: ["key", "value"]
+            },
+            description: "Optional initial values for this entity"
+          }
+        },
+        required: ["modelId", "name", "type"]
+      }
+    }
+  })
+};
+var latticeSetValueTool = {
+  name: "lattice_set_value",
+  implementation: (context) => ({
+    toolFn: async (params) => {
+      const { modelId, entityName, attributeKey, value: rawValue } = params;
+      console.log("[LATTICE DEBUG] \u{1F4DD} lattice_set_value called:", { modelId, entityName, attributeKey, rawValue });
+      let value = rawValue;
+      const numValue = parseFloat(rawValue);
+      if (!isNaN(numValue)) {
+        value = numValue;
+      } else if (rawValue.toLowerCase() === "true") {
+        value = true;
+      } else if (rawValue.toLowerCase() === "false") {
+        value = false;
+      }
+      const entityId = entityName.toLowerCase().replace(/\s+/g, "_");
+      if (context.db.latticeModels && modelId && /^[a-f0-9]{24}$/.test(modelId)) {
+        try {
+          const model = await context.db.latticeModels.findById(modelId);
+          if (model) {
+            const entity = model.data.entities.find((e) => e.id === entityId || e.name === entityName);
+            if (entity) {
+              const attrIndex = entity.attributes.findIndex((a) => a.key === attributeKey);
+              const dataType = typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string";
+              const attributeData = {
+                key: attributeKey,
+                value,
+                dataType,
+                isComputed: false
+              };
+              if (attrIndex >= 0) {
+                entity.attributes[attrIndex] = attributeData;
+              } else {
+                entity.attributes.push(attributeData);
+              }
+              entity.updatedAt = /* @__PURE__ */ new Date();
+              await context.db.latticeModels.update({
+                id: modelId,
+                data: model.data,
+                updatedAt: /* @__PURE__ */ new Date()
+              });
+              context.logger.info(`[Lattice] Set ${entityId}.${attributeKey} = ${value} in model ${modelId}`);
+            } else {
+              context.logger.warn(`[Lattice] Entity ${entityName} not found in model ${modelId}`);
+            }
+          } else {
+            context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+          }
+        } catch (error) {
+          context.logger.error(`[Lattice] Failed to persist value to database:`, error);
+        }
+      }
+      return JSON.stringify({
+        success: true,
+        action: "SET_VALUE",
+        modelId,
+        data: {
+          entityName,
+          attributeKey,
+          value
+        },
+        message: `Set ${entityName}.${attributeKey} = ${value}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_set_value",
+      description: `Set a specific value in a Lattice model.
+
+**When to use:** When the user provides a specific number:
+- "Revenue in Q1 is 150,000"
+- "Set marketing spend to 50k for January"
+- "COGS is 40% of revenue" (use lattice_create_rule for formulas)
+
+**Important:** This tool is for setting raw input values. For calculated values (formulas), use \`lattice_create_rule\` instead.
+
+**Examples:**
+- "Q1 revenue is $100,000" \u2192 entityName="Revenue", attributeKey="Q1", value=100000
+- "Set headcount to 25" \u2192 entityName="Headcount", attributeKey="current", value=25`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model"
+          },
+          entityName: {
+            type: "string",
+            description: "Name of the entity (line item, account, etc.)"
+          },
+          attributeKey: {
+            type: "string",
+            description: 'Period or attribute key (e.g., "Q1_2024", "current", "budget")'
+          },
+          value: {
+            type: "string",
+            description: "The value to set (will be parsed as number if numeric)"
+          }
+        },
+        required: ["modelId", "entityName", "attributeKey", "value"]
+      }
+    }
+  })
+};
+var latticeCreateRuleTool = {
+  name: "lattice_create_rule",
+  implementation: (context) => ({
+    toolFn: async (params) => {
+      const { modelId, name, description, formula } = params;
+      console.log("[LATTICE DEBUG] \u{1F4D0} lattice_create_rule called:", { modelId, name, formula });
+      const parsedRule = parseFormula(formula);
+      const ruleId = `rule_${Date.now()}`;
+      const ruleData = {
+        id: ruleId,
+        name,
+        description: description || formula,
+        type: "formula",
+        definition: {
+          operation: parsedRule.operation,
+          inputs: parsedRule.inputs.map((ref) => ({
+            type: "entity",
+            ref
+          })),
+          output: {
+            targetEntityId: parsedRule.outputEntity.toLowerCase().replace(/\s+/g, "_"),
+            targetAttribute: "computed",
+            dataType: "number"
+          }
+        },
+        dependencies: parsedRule.inputs.map((i) => i.toLowerCase().replace(/\s+/g, "_")),
+        priority: 0,
+        enabled: true,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const outputEntityId = parsedRule.outputEntity.toLowerCase().replace(/\s+/g, "_");
+      let entityCreatedMessage = "";
+      if (context.db.latticeModels && modelId && /^[a-f0-9]{24}$/.test(modelId)) {
+        try {
+          const model = await context.db.latticeModels.findById(modelId);
+          if (model) {
+            const outputEntityExists = model.data.entities.some((e) => e.id === outputEntityId || e.name.toLowerCase() === parsedRule.outputEntity.toLowerCase());
+            if (!outputEntityExists && parsedRule.outputEntity !== "unknown") {
+              const now = /* @__PURE__ */ new Date();
+              const newEntity = {
+                id: outputEntityId,
+                type: "line_item",
+                name: parsedRule.outputEntity,
+                displayName: parsedRule.outputEntity,
+                attributes: [
+                  {
+                    key: "value",
+                    value: 0,
+                    dataType: "currency",
+                    isComputed: true
+                  },
+                  {
+                    key: "category",
+                    value: "Computed",
+                    dataType: "string",
+                    isComputed: false
+                  }
+                ],
+                metadata: { isComputed: true },
+                createdAt: now,
+                updatedAt: now
+              };
+              model.data.entities.push(newEntity);
+              entityCreatedMessage = ` Created output entity "${parsedRule.outputEntity}".`;
+              context.logger.info(`[Lattice] Auto-created output entity ${outputEntityId} for rule ${ruleId}`);
+            }
+            const existingIndex = model.rules.rules.findIndex((r) => r.id === ruleId || r.name === name);
+            if (existingIndex >= 0) {
+              model.rules.rules[existingIndex] = ruleData;
+            } else {
+              model.rules.rules.push(ruleData);
+            }
+            await context.db.latticeModels.update({
+              id: modelId,
+              data: model.data,
+              rules: model.rules,
+              updatedAt: /* @__PURE__ */ new Date()
+            });
+            context.logger.info(`[Lattice] Created rule ${ruleId} in model ${modelId}`);
+          } else {
+            context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+          }
+        } catch (error) {
+          context.logger.error(`[Lattice] Failed to persist rule to database:`, error);
+        }
+      }
+      return JSON.stringify({
+        success: true,
+        action: "CREATE_RULE",
+        modelId,
+        ruleId,
+        data: {
+          name,
+          description,
+          formula,
+          parsed: parsedRule,
+          outputEntityCreated: entityCreatedMessage !== ""
+        },
+        message: `Created rule "${name}": ${formula}.${entityCreatedMessage}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_create_rule",
+      description: `Create a formula or calculation rule in a Lattice model.
+
+**When to use:** When the user defines a calculation:
+- "Gross profit equals revenue minus COGS"
+- "Net margin is net income divided by revenue times 100"
+- "Total expenses is the sum of all expense line items"
+
+**IMPORTANT: For per-period calculations like "calculate X for each quarter", you MUST call this tool ONCE for EACH period.** For example, if asked to "calculate gross margin for each quarter", call this tool 4 times:
+1. lattice_create_rule with formula "Q1 Gross Margin = Q1 Revenue - Q1 COGS"
+2. lattice_create_rule with formula "Q2 Gross Margin = Q2 Revenue - Q2 COGS"
+3. lattice_create_rule with formula "Q3 Gross Margin = Q3 Revenue - Q3 COGS"
+4. lattice_create_rule with formula "Q4 Gross Margin = Q4 Revenue - Q4 COGS"
+
+**Formula syntax (natural language):**
+- Arithmetic: "X equals Y plus Z", "A minus B", "C times D"
+- Aggregation: "sum of", "average of", "total"
+- Percentage: "X percent of Y", "as a percentage"
+- Comparison: "if X is greater than Y then A else B"
+
+**Examples:**
+- "Gross Profit = Revenue - COGS"
+- "Gross Margin = Gross Profit / Revenue * 100"
+- "Total OpEx = sum of all Operating Expenses"
+- "YoY Growth = (Current Year - Prior Year) / Prior Year * 100"
+- "Q1 Gross Margin = Q1 Revenue - Q1 COGS" (per-period)`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model"
+          },
+          name: {
+            type: "string",
+            description: 'Name for this rule (e.g., "Gross Profit Calculation")'
+          },
+          description: {
+            type: "string",
+            description: "Optional description of what this rule calculates"
+          },
+          formula: {
+            type: "string",
+            description: "The formula in natural language or equation format"
+          }
+        },
+        required: ["modelId", "name", "formula"]
+      }
+    }
+  })
+};
+var latticeQueryTool = {
+  name: "lattice_query",
+  implementation: () => ({
+    toolFn: async (params) => {
+      const { modelId, query } = params;
+      const parsedQuery = parseQuery(query);
+      return JSON.stringify({
+        success: true,
+        action: "QUERY",
+        modelId,
+        data: {
+          query,
+          parsed: parsedQuery
+        },
+        message: `Querying model for: ${query}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_query",
+      description: `Query a Lattice model for specific values or aggregations.
+
+**When to use:** When the user asks about values in the model:
+- "What's Q1 gross margin?"
+- "Show me total revenue for 2024"
+- "What are all the expense categories?"
+- "Compare Q1 vs Q2 performance"
+
+**Query types:**
+- Single value: "What is [entity] for [period]?"
+- Aggregation: "Total [entity] for [range]"
+- Comparison: "Compare [entity] across [periods]"
+- List: "Show all [entity type]"
+
+**Examples:**
+- "What's Q2 revenue?" \u2192 Returns specific value
+- "Total revenue for 2024" \u2192 Sums Q1-Q4
+- "Compare gross margin Q1 vs Q2" \u2192 Side-by-side comparison`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model to query"
+          },
+          query: {
+            type: "string",
+            description: "Natural language query about the model"
+          }
+        },
+        required: ["modelId", "query"]
+      }
+    }
+  })
+};
+var latticeExplainTool = {
+  name: "lattice_explain",
+  implementation: () => ({
+    toolFn: async (params) => {
+      const { modelId, entityName, attributeKey } = params;
+      return JSON.stringify({
+        success: true,
+        action: "EXPLAIN",
+        modelId,
+        data: {
+          entityName,
+          attributeKey
+        },
+        message: `Explaining calculation for ${entityName}.${attributeKey}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_explain",
+      description: `Explain how a value in a Lattice model was calculated.
+
+**When to use:** When the user wants to understand a calculation:
+- "How did you calculate gross profit?"
+- "Explain the Q2 margin number"
+- "Show me the formula for total expenses"
+- "Why is this number so high?"
+
+This tool traces the calculation chain from the target value back through all its inputs and rules, providing a step-by-step explanation.`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model"
+          },
+          entityName: {
+            type: "string",
+            description: "Name of the entity containing the value to explain"
+          },
+          attributeKey: {
+            type: "string",
+            description: "Period or attribute key of the value to explain"
+          }
+        },
+        required: ["modelId", "entityName", "attributeKey"]
+      }
+    }
+  })
+};
+function parseFormula(formula) {
+  const normalized = formula.toLowerCase().trim();
+  const equalsMatch = normalized.match(/^(.+?)\s*(?:=|equals?)\s*(.+)$/i);
+  if (equalsMatch) {
+    const [, output, expression] = equalsMatch;
+    if (expression.includes("+") || expression.includes("plus")) {
+      return {
+        operation: "ADD",
+        outputEntity: output,
+        inputs: expression.split(/[+]|plus/i).map((s) => s.trim())
+      };
+    }
+    if (expression.includes("-") || expression.includes("minus")) {
+      return {
+        operation: "SUBTRACT",
+        outputEntity: output,
+        inputs: expression.split(/[-]|minus/i).map((s) => s.trim())
+      };
+    }
+    if (expression.includes("*") || expression.includes("times") || expression.includes("x")) {
+      return {
+        operation: "MULTIPLY",
+        outputEntity: output,
+        inputs: expression.split(/[*x]|times/i).map((s) => s.trim())
+      };
+    }
+    if (expression.includes("/") || expression.includes("divided")) {
+      return {
+        operation: "DIVIDE",
+        outputEntity: output,
+        inputs: expression.split(/[/]|divided by/i).map((s) => s.trim())
+      };
+    }
+    if (expression.includes("sum")) {
+      return {
+        operation: "SUM",
+        outputEntity: output,
+        inputs: [expression.replace(/sum of/i, "").trim()]
+      };
+    }
+  }
+  return {
+    operation: "REFERENCE",
+    outputEntity: "unknown",
+    inputs: [formula]
+  };
+}
+function parseQuery(query) {
+  const normalized = query.toLowerCase();
+  let type = "single_value";
+  if (normalized.includes("total") || normalized.includes("sum")) {
+    type = "aggregation";
+  } else if (normalized.includes("compare") || normalized.includes("vs")) {
+    type = "comparison";
+  } else if (normalized.includes("list") || normalized.includes("show all")) {
+    type = "list";
+  }
+  const entities = [];
+  const periods = [];
+  const periodPatterns = [/q[1-4]/gi, /\d{4}/g, /jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec/gi];
+  for (const pattern of periodPatterns) {
+    const matches = query.match(pattern);
+    if (matches) {
+      periods.push(...matches);
+    }
+  }
+  const commonEntities = ["revenue", "expenses", "profit", "margin", "income", "cost", "cogs", "ebitda"];
+  for (const entity of commonEntities) {
+    if (normalized.includes(entity)) {
+      entities.push(entity);
+    }
+  }
+  return { type, entities, periods };
+}
+
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editLocalFile/index.js
 import { promises as fs10 } from "fs";
 import { existsSync as existsSync7 } from "fs";
@@ -10796,7 +11622,14 @@ var cliOnlyTools = {
   // Shell execution
   bash_execute: bashExecuteTool,
   // Git operations
-  recent_changes: recentChangesTool
+  recent_changes: recentChangesTool,
+  // Lattice financial modeling tools
+  lattice_create_model: latticeCreateModelTool,
+  lattice_add_entity: latticeAddEntityTool,
+  lattice_set_value: latticeSetValueTool,
+  lattice_create_rule: latticeCreateRuleTool,
+  lattice_query: latticeQueryTool,
+  lattice_explain: latticeExplainTool
 };
 var generateTools = (userId, user, logger2, { db }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model, imageProcessorLambdaName, tools = b4mTools) => {
   const context = {
@@ -10902,194 +11735,6 @@ var generateMcpTools = async (mcpData) => {
   return result;
 };
 
-// ../../b4m-core/packages/services/dist/src/llm/agents/ExploreAgent.js
-var ExploreAgent = (config) => ({
-  name: "explore",
-  description: "Fast research, exploration, and information search",
-  model: config?.model ?? "claude-3-5-haiku-20241022",
-  defaultThoroughness: config?.defaultThoroughness ?? "medium",
-  maxIterations: { quick: 2, medium: 5, very_thorough: 10 },
-  deniedTools: [
-    "image_generation",
-    "edit_image",
-    "deep_research",
-    "delegate_to_agent",
-    ...config?.extraDeniedTools ?? []
-  ],
-  allowedTools: config?.extraAllowedTools,
-  systemPrompt: `You are a research and exploration specialist. Your job is to search and analyze information efficiently.
-
-## Focus Areas
-- Finding relevant information across knowledge bases and the web
-- Understanding context and patterns
-- Providing clear, concise summaries
-
-## Tool Usage
-Use these tools strategically:
-- \`web_search\` - Search the web for information
-- \`web_fetch\` - Fetch and read full webpage content
-- \`search_knowledge_base\` - Search the user's knowledge bases
-- \`current_datetime\` - Get the current date and time
-
-## Search Strategy
-1. Start with targeted searches using specific keywords
-2. Use web_fetch to read full content from promising results
-3. Cross-reference findings from multiple sources
-4. Check knowledge bases for relevant internal information
-
-## Output Format
-Provide a clear summary including:
-1. What you found (key facts, sources, patterns)
-2. Key insights or observations
-3. Relevant source references
-
-Be thorough but concise. Your summary will be used by the main agent.`
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/agents/PlanAgent.js
-var PlanAgent = (config) => ({
-  name: "plan",
-  description: "Task breakdown and implementation planning",
-  model: config?.model ?? "claude-3-5-haiku-20241022",
-  defaultThoroughness: config?.defaultThoroughness ?? "medium",
-  maxIterations: { quick: 3, medium: 7, very_thorough: 12 },
-  deniedTools: [
-    "image_generation",
-    "edit_image",
-    "deep_research",
-    "delegate_to_agent",
-    ...config?.extraDeniedTools ?? []
-  ],
-  allowedTools: config?.extraAllowedTools,
-  systemPrompt: `You are a task planning specialist. Your job is to break down complex tasks into clear, actionable steps.
-
-## Focus Areas
-- Identifying dependencies and blockers
-- Creating logical sequence of steps
-- Researching context before planning
-
-## Process
-1. First, research the topic to understand the current landscape
-2. Identify what already exists vs. what needs to be done
-3. Break down work into discrete, actionable steps
-4. Order steps by dependencies
-
-## Output Format
-Provide a structured plan:
-
-### Prerequisites
-- What must exist before starting
-
-### Steps
-1. Step with clear deliverable
-2. Next step (depends on: Step 1)
-...
-
-### Risks & Considerations
-- Potential issues to watch for
-
-Be specific and actionable. Your plan will be used by the main agent.`
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/agents/ReviewAgent.js
-var ReviewAgent = (config) => ({
-  name: "review",
-  description: "Content quality analysis and review",
-  model: config?.model ?? "claude-sonnet-4-5-20250929",
-  defaultThoroughness: config?.defaultThoroughness ?? "medium",
-  maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
-  deniedTools: ["image_generation", "edit_image", "delegate_to_agent", ...config?.extraDeniedTools ?? []],
-  allowedTools: config?.extraAllowedTools,
-  systemPrompt: `You are a review specialist. Your job is to analyze content quality and identify issues.
-
-## Focus Areas
-- Content quality and accuracy
-- Potential errors and edge cases
-- Completeness and thoroughness
-- Consistency and clarity
-
-## Review Process
-1. Understand the context and purpose of the content
-2. Check for common issues (errors, inconsistencies, gaps)
-3. Verify claims against available sources
-4. Look for areas of improvement
-
-## Output Format
-Provide actionable feedback:
-
-### Critical Issues
-- Description of issue and why it matters
-
-### Suggestions
-- Improvement suggestion with rationale
-
-### Positive Observations
-- What's done well (optional)
-
-Focus on actionable feedback. Your review will be used by the main agent.`
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/agents/ProjectManagerAgent.js
-var ProjectManagerAgent = (config) => ({
-  name: "project_manager",
-  description: "Project management via Jira and Confluence (create issues, search, update status, write docs). ALWAYS delegate Jira/Confluence requests to this agent \u2014 you do not have direct access to these tools",
-  model: config?.model ?? "claude-sonnet-4-5-20250929",
-  defaultThoroughness: config?.defaultThoroughness ?? "medium",
-  maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
-  allowedTools: [...config?.extraAllowedTools ?? []],
-  deniedTools: [...config?.extraDeniedTools ?? []],
-  systemPrompt: `You are a project management specialist with access to Jira and Confluence. Your job is to help manage projects, issues, documentation, and team workflows.
-
-## Capabilities
-
-### Jira
-- Search for issues using JQL
-- Create, update, and transition issues
-- Add comments and manage watchers
-- List projects and issue types
-
-### Confluence
-- Search for documentation
-- Create and update pages
-- Browse spaces and page hierarchies
-
-## Best Practices
-1. When searching Jira, use precise JQL queries (e.g., \`project = PROJ AND status = "In Progress"\`)
-2. When creating issues, always check available issue types first with \`atlassian__jira_list_issue_types\`
-3. When updating issue status, use \`atlassian__jira_update_issue_transition\` with the target status name
-4. When creating Confluence pages, use the user's personal space if no space is specified
-5. Always confirm destructive operations (delete) with the user before proceeding
-
-## Output Format
-Provide a clear summary of actions taken:
-1. What was done (created, updated, searched, etc.)
-2. Links or keys to relevant items (e.g., PROJ-123)
-3. Any issues or warnings encountered
-
-Be precise with issue keys and project names. Your results will be used by the main agent.`
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/agents/ServerAgentStore.js
-var ServerAgentStore = class {
-  constructor() {
-    const builtInAgents = [ExploreAgent(), PlanAgent(), ReviewAgent(), ProjectManagerAgent()];
-    this.agents = new Map(builtInAgents.map((a) => [a.name, a]));
-  }
-  getAgent(name) {
-    return this.agents.get(name);
-  }
-  getAllAgents() {
-    return Array.from(this.agents.values());
-  }
-  getAgentNames() {
-    return Array.from(this.agents.keys());
-  }
-  hasAgent(name) {
-    return this.agents.has(name);
-  }
-};
-var serverAgentStore = new ServerAgentStore();
-
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionProcess.js
 import throttle2 from "lodash/throttle.js";
 
@@ -11110,6 +11755,7 @@ var QuestStartBodySchema = z139.object({
   enableMementos: z139.boolean().optional(),
   enableArtifacts: z139.boolean().optional(),
   enableAgents: z139.boolean().optional(),
+  enableLattice: z139.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
   tools: z139.array(z139.union([b4mLLMTools, z139.string()])).optional(),
   mcpServers: z139.array(z139.string()).optional(),
@@ -11954,7 +12600,7 @@ async function executeCommandHook(hook, context) {
   }
 }
 var MAX_PATTERN_LENGTH = 200;
-function matchesToolPattern2(toolName, pattern) {
+function matchesToolPattern(toolName, pattern) {
   if (pattern.length > MAX_PATTERN_LENGTH) {
     console.warn(`Hook pattern exceeds max length (${MAX_PATTERN_LENGTH}), skipping: ${pattern.slice(0, 50)}...`);
     return false;
@@ -11972,7 +12618,7 @@ async function executeHooks(hooks, context) {
   }
   const matchingHooks = [];
   for (const matcher of hooks) {
-    const shouldMatch = !matcher.matcher || !context.tool_name || matchesToolPattern2(context.tool_name, matcher.matcher);
+    const shouldMatch = !matcher.matcher || !context.tool_name || matchesToolPattern(context.tool_name, matcher.matcher);
     if (shouldMatch) {
       matchingHooks.push(...matcher.hooks);
     }
@@ -13989,7 +14635,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.29-subagent-delegation.18906+045a1d01f",
+  version: "0.2.29",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -14103,10 +14749,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.50.1-subagent-delegation.18906+045a1d01f",
-    "@bike4mind/mcp": "1.29.1-subagent-delegation.18906+045a1d01f",
-    "@bike4mind/services": "2.48.1-subagent-delegation.18906+045a1d01f",
-    "@bike4mind/utils": "2.5.1-subagent-delegation.18906+045a1d01f",
+    "@bike4mind/common": "2.51.0",
+    "@bike4mind/mcp": "1.30.0",
+    "@bike4mind/services": "2.49.0",
+    "@bike4mind/utils": "2.6.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -14124,7 +14770,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "045a1d01f262ab4133a6caaaa9d56debaa965143"
+  gitHead: "dd78e3f7ac6eb31fbbae8df3be1f33310779a9d5"
 };
 
 // src/config/constants.ts
@@ -14133,25 +14779,25 @@ var MODEL_NAME_COLUMN_WIDTH = 18;
 var USAGE_CACHE_TTL = 5 * 60 * 1e3;
 
 // src/agents/toolFilter.ts
-function matchesToolPattern3(toolName, pattern) {
+function matchesToolPattern2(toolName, pattern) {
   const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
   return new RegExp(`^${regexPattern}$`).test(toolName);
 }
-function matchesAnyPattern2(toolName, patterns) {
-  return patterns.some((pattern) => matchesToolPattern3(toolName, pattern));
+function matchesAnyPattern(toolName, patterns) {
+  return patterns.some((pattern) => matchesToolPattern2(toolName, pattern));
 }
-function filterToolsByPatterns2(allTools, allowedPatterns, deniedPatterns) {
+function filterToolsByPatterns(allTools, allowedPatterns, deniedPatterns) {
   return allTools.filter((tool) => {
     const toolName = tool.toolSchema.name;
     if (deniedPatterns && deniedPatterns.length > 0) {
-      if (matchesAnyPattern2(toolName, deniedPatterns)) {
+      if (matchesAnyPattern(toolName, deniedPatterns)) {
         return false;
       }
     }
     if (!allowedPatterns || allowedPatterns.length === 0) {
       return true;
     }
-    return matchesAnyPattern2(toolName, allowedPatterns);
+    return matchesAnyPattern(toolName, allowedPatterns);
   });
 }
 
@@ -14422,7 +15068,7 @@ var SubagentOrchestrator = class {
       this.deps.configStore,
       this.deps.apiClient
     );
-    const filteredTools = filterToolsByPatterns2(allTools, toolFilter.allowedTools, toolFilter.deniedTools);
+    const filteredTools = filterToolsByPatterns(allTools, toolFilter.allowedTools, toolFilter.deniedTools);
     if (this.deps.customCommandStore) {
       const skillTool = createSkillTool({
         customCommandStore: this.deps.customCommandStore,