@bike4mind/cli 0.2.29-cli-resume-command.18763 → 0.2.29-feature-b4m-pi.18846

package/dist/index.js

@@ -5,7 +5,8 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-VGYTNJXN.js";
+} from "./chunk-SZRU4SFM.js";
+import "./chunk-NHP3UPYU.js";
 import {
   ConfigStore
 } from "./chunk-23T2XGSZ.js";
@@ -13,8 +14,8 @@ import {
   selectActiveBackgroundAgents,
   useCliStore
 } from "./chunk-TVW4ZESU.js";
-import "./chunk-JJBDHUGY.js";
-import "./chunk-ZEMWV6IR.js";
+import "./chunk-MUWN5G77.js";
+import "./chunk-2UFCM2T4.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -26,7 +27,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-UNOJBVD2.js";
+} from "./chunk-A3HXNIIZ.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -82,7 +83,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-XJRPAAUS.js";
+} from "./chunk-WVQTZODT.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -551,9 +552,8 @@ var COMMANDS = [
     args: "<name>"
   },
   {
-    name: "resume",
-    description: "List and resume saved sessions",
-    aliases: ["sessions"]
+    name: "sessions",
+    description: "List saved sessions"
   },
   {
     name: "config",
@@ -3718,23 +3718,18 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
   async executeToolWithQueueFallback(toolUse) {
     const queuedObs = this.observationQueue.find((obs) => obs.toolId === getToolId(toolUse));
     if (queuedObs) {
-      const result = queuedObs.result;
+      const result2 = queuedObs.result;
       const index = this.observationQueue.indexOf(queuedObs);
       this.observationQueue.splice(index, 1);
-      return typeof result === "string" ? result : JSON.stringify(result);
+      return typeof result2 === "string" ? result2 : JSON.stringify(result2);
     }
     const tool = this.context.tools.find((t) => t.toolSchema.name === toolUse.name);
     if (!tool) {
-      return `Error: Tool ${toolUse.name} not found in agent context`;
-    }
-    try {
-      const params = this.parseToolArguments(toolUse.arguments);
-      const result = await tool.toolFn(params);
-      return typeof result === "string" ? result : JSON.stringify(result);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return `Error: ${message}`;
+      throw new Error(`Tool ${toolUse.name} not found in agent context`);
     }
+    const params = this.parseToolArguments(toolUse.arguments);
+    const result = await tool.toolFn(params);
+    return typeof result === "string" ? result : JSON.stringify(result);
   }
   /**
    * Build and append tool call/result messages for the conversation history
@@ -5756,7 +5751,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),
@@ -10364,6 +10371,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 fs11 } from "fs";
 import { existsSync as existsSync6 } from "fs";
@@ -10835,7 +11655,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 = {
@@ -10961,6 +11788,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(),
@@ -13807,7 +14635,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.29-cli-resume-command.18763+9e3ccc640",
+  version: "0.2.29-feature-b4m-pi.18846+9859d25d9",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -13915,10 +14743,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.50.1-cli-resume-command.18763+9e3ccc640",
-    "@bike4mind/mcp": "1.29.1-cli-resume-command.18763+9e3ccc640",
-    "@bike4mind/services": "2.48.1-cli-resume-command.18763+9e3ccc640",
-    "@bike4mind/utils": "2.5.1-cli-resume-command.18763+9e3ccc640",
+    "@bike4mind/common": "2.50.1-feature-b4m-pi.18846+9859d25d9",
+    "@bike4mind/mcp": "1.29.1-feature-b4m-pi.18846+9859d25d9",
+    "@bike4mind/services": "2.48.1-feature-b4m-pi.18846+9859d25d9",
+    "@bike4mind/utils": "2.5.1-feature-b4m-pi.18846+9859d25d9",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -13935,7 +14763,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "9e3ccc640da244f7528fa1a479d00e8b40b415a4"
+  gitHead: "9859d25d9a50e23c155ed70c318a3edfe9573f2a"
 };
 
 // src/config/constants.ts
@@ -16681,7 +17509,7 @@ Available commands:
   /whoami - Show current authenticated user
   /usage - Show credit usage and balance
   /save <name> - Save current session
-  /resume - List and resume saved sessions
+  /sessions - List saved sessions
   /config - Show configuration
 
 API Configuration:
@@ -16730,7 +17558,6 @@ Custom Commands:
         console.log(`\u2705 Session saved as "${sessionName}"`);
         break;
       }
-      case "resume":
       case "sessions": {
         const sessions = await state.sessionStore.list(20);
         if (sessions.length === 0) {