@bike4mind/cli 0.2.29-slack-native-search.18848 → 0.2.29

package/dist/index.js

@@ -5,7 +5,8 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-T33BVGIR.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-WO5GGMEO.js";
-import "./chunk-LM4PJCVX.js";
+import "./chunk-UYN4HMRF.js";
+import "./chunk-YQWFK5O2.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -27,7 +28,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-MDOLASLI.js";
+} from "./chunk-5J4RL57F.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -83,32 +84,37 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-MPSPHOIZ.js";
+} from "./chunk-TNFZP7FG.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
 
 // src/index.tsx
-import React21, { useState as useState9, useEffect as useEffect6, useCallback as useCallback2, useRef as useRef3 } from "react";
+import React21, { useState as useState10, useEffect as useEffect7, useCallback as useCallback2, useRef as useRef3 } from "react";
 import { render, Box as Box20, Text as Text20, useApp, useInput as useInput9 } from "ink";
 import { execSync } from "child_process";
 import { randomBytes as randomBytes5 } from "crypto";
 import { v4 as uuidv411 } from "uuid";
 
 // src/components/App.tsx
-import React15, { useState as useState5, useEffect as useEffect4 } from "react";
+import React15, { useState as useState6, useEffect as useEffect5 } from "react";
 import { Box as Box14, Text as Text14, Static, useInput as useInput6 } from "ink";
 
 // src/components/StatusBar.tsx
 import React from "react";
 import { Box, Text } from "ink";
-var StatusBar = React.memo(function StatusBar2({ sessionName, model, tokenUsage }) {
+var StatusBar = React.memo(function StatusBar2({
+  sessionName,
+  model,
+  tokenUsage,
+  creditsUsage
+}) {
   const autoAcceptEdits = useCliStore((state) => state.autoAcceptEdits);
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, sessionName), /* @__PURE__ */ React.createElement(Box, { gap: 2 }, autoAcceptEdits && /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "AUTO ACCEPT: Edits"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, tokenUsage.toLocaleString(), " tokens"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, model)));
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, sessionName), /* @__PURE__ */ React.createElement(Box, { gap: 2 }, autoAcceptEdits && /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "AUTO ACCEPT: Edits"), tokenUsage > 0 && /* @__PURE__ */ React.createElement(Text, { dimColor: true }, tokenUsage.toLocaleString(), " tokens"), creditsUsage !== void 0 && creditsUsage > 0 && /* @__PURE__ */ React.createElement(Text, { dimColor: true }, creditsUsage.toLocaleString(), " ", creditsUsage === 1 ? "credit" : "credits"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, model)));
 });
 
 // src/components/InputPrompt.tsx
-import React5, { useState as useState2, useMemo, useEffect as useEffect2, useRef as useRef2 } from "react";
+import React5, { useState as useState3, useMemo, useEffect as useEffect3, useRef as useRef2 } from "react";
 import { Box as Box4, Text as Text5, useInput as useInput2 } from "ink";
 
 // src/components/CustomTextInput.tsx
@@ -321,65 +327,53 @@ function CommandAutocomplete({ commands, selectedIndex }) {
 // src/components/FileAutocomplete.tsx
 import React4 from "react";
 import { Box as Box3, Text as Text4 } from "ink";
+import * as path2 from "path";
 
 // src/utils/fileSearch.ts
 import * as fs from "fs";
 import * as path from "path";
-import Fuse from "fuse.js";
-var DEFAULT_IGNORE_PATTERNS = [
-  "node_modules",
-  ".git",
-  ".next",
-  ".turbo",
-  "dist",
-  "build",
-  ".cache",
-  "coverage",
-  ".DS_Store",
-  ".env",
-  ".env.local",
-  ".env.secrets"
-];
-function walkDirectory(basePath = process.cwd(), maxDepth = 5, ignorePatterns = DEFAULT_IGNORE_PATTERNS) {
-  const results = [];
-  const normalizedBase = path.resolve(basePath);
-  function walk(currentPath, depth) {
-    if (depth > maxDepth) return;
+import { AsyncFzf } from "fzf";
+import { fdir } from "fdir";
+import ignore from "ignore";
+function loadIgnoreRules(projectRoot) {
+  const ig = ignore();
+  ig.add(".git/");
+  const gitignorePath = path.join(projectRoot, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
     try {
-      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (ignorePatterns.some((pattern) => entry.name === pattern || entry.name.startsWith(pattern))) {
-          continue;
-        }
-        const fullPath = path.join(currentPath, entry.name);
-        const relativePath = path.relative(normalizedBase, fullPath);
-        if (entry.isDirectory()) {
-          results.push({
-            path: relativePath,
-            isDirectory: true
-          });
-          walk(fullPath, depth + 1);
-        } else if (entry.isFile()) {
-          try {
-            const stats = fs.statSync(fullPath);
-            results.push({
-              path: relativePath,
-              isDirectory: false,
-              size: stats.size
-            });
-          } catch {
-            results.push({
-              path: relativePath,
-              isDirectory: false
-            });
-          }
-        }
-      }
+      const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+      ig.add(gitignoreContent);
     } catch {
     }
   }
-  walk(normalizedBase, 0);
-  return results;
+  return ig;
+}
+function crawlDirectory(projectRoot, maxDepth = 10, maxFiles = 2e4, ig) {
+  let fileCount = 0;
+  const crawler = new fdir().withRelativePaths().withDirs().withPathSeparator("/").exclude((dirPath) => {
+    const relativePath = path.posix.relative(projectRoot, dirPath);
+    if (!relativePath || relativePath === ".") {
+      return false;
+    }
+    const pathWithSlash = `${relativePath}/`;
+    return ig.ignores(pathWithSlash);
+  }).filter(() => {
+    if (fileCount >= maxFiles) {
+      return false;
+    }
+    fileCount++;
+    return true;
+  });
+  if (maxDepth !== void 0) {
+    crawler.withMaxDepth(maxDepth);
+  }
+  const paths = crawler.crawl(projectRoot).sync();
+  return paths.filter((p) => {
+    if (!p || p === ".") {
+      return true;
+    }
+    return !ig.ignores(p);
+  });
 }
 function formatFileSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -390,42 +384,112 @@ function formatFileSize(bytes) {
 var cachedFiles = null;
 var cacheTimestamp = 0;
 var CACHE_TTL_MS = 3e4;
-function getCachedFiles() {
+function getCachedFiles(projectRoot = process.cwd()) {
   const now = Date.now();
   if (!cachedFiles || now - cacheTimestamp > CACHE_TTL_MS) {
-    cachedFiles = walkDirectory();
+    const normalizedBase = path.resolve(projectRoot);
+    const ig = loadIgnoreRules(normalizedBase);
+    cachedFiles = crawlDirectory(normalizedBase, 10, 2e4, ig);
     cacheTimestamp = now;
   }
   return cachedFiles;
 }
-function searchFiles(query) {
-  const files = getCachedFiles();
+function warmFileCache() {
+  if (!cachedFiles || Date.now() - cacheTimestamp > CACHE_TTL_MS) {
+    setImmediate(() => {
+      getCachedFiles();
+    });
+  }
+}
+function listAbsoluteDirectory(absolutePath, filterQuery) {
+  try {
+    const normalizedPath = path.normalize(absolutePath);
+    if (!fs.existsSync(normalizedPath)) {
+      return [];
+    }
+    const stats = fs.statSync(normalizedPath);
+    if (!stats.isDirectory()) {
+      return [];
+    }
+    const entries = fs.readdirSync(normalizedPath, { withFileTypes: true });
+    let filteredEntries = entries;
+    if (filterQuery && filterQuery.length > 0) {
+      const lowerQuery = filterQuery.toLowerCase();
+      filteredEntries = entries.filter((entry) => entry.name.toLowerCase().includes(lowerQuery));
+    }
+    return filteredEntries.slice(0, 15).map((entry) => {
+      const fullPath = path.join(normalizedPath, entry.name);
+      const result = {
+        path: fullPath,
+        isDirectory: entry.isDirectory()
+      };
+      if (entry.isFile()) {
+        try {
+          const fileStats = fs.statSync(fullPath);
+          result.size = fileStats.size;
+        } catch {
+        }
+      }
+      return result;
+    });
+  } catch {
+    return [];
+  }
+}
+async function searchFiles(query, maxResults = 20) {
+  const projectRoot = process.cwd();
+  if (path.isAbsolute(query)) {
+    try {
+      const stats = fs.statSync(query);
+      if (stats.isDirectory()) {
+        return listAbsoluteDirectory(query);
+      }
+    } catch {
+    }
+    let dirToList;
+    let filterQuery;
+    if (query.endsWith("/") || query.endsWith(path.sep)) {
+      dirToList = query;
+      filterQuery = void 0;
+    } else {
+      dirToList = path.dirname(query);
+      filterQuery = path.basename(query);
+    }
+    return listAbsoluteDirectory(dirToList, filterQuery);
+  }
+  const files = getCachedFiles(projectRoot);
   if (!query || query.trim() === "") {
-    return files.filter((f) => !f.path.includes(path.sep)).slice(0, 20);
-  }
-  const queryDir = path.dirname(query);
-  let searchPool = files;
-  if (queryDir && queryDir !== ".") {
-    const normalizedDir = queryDir.replace(/\\/g, "/");
-    searchPool = files.filter((f) => {
-      const normalizedPath = f.path.replace(/\\/g, "/");
-      return normalizedPath.startsWith(normalizedDir + "/") || normalizedPath === normalizedDir;
+    const rootFiles = files.filter((f) => !f.includes("/")).slice(0, maxResults);
+    return rootFiles.map((p) => {
+      const fullPath = path.join(projectRoot, p);
+      try {
+        const stats = fs.statSync(fullPath);
+        return {
+          path: p,
+          isDirectory: stats.isDirectory(),
+          size: stats.isFile() ? stats.size : void 0
+        };
+      } catch {
+        return { path: p, isDirectory: false };
+      }
     });
-    if (searchPool.length === 0) {
-      searchPool = files;
-    }
-  }
-  const fuse = new Fuse(searchPool, {
-    keys: [{ name: "path", weight: 1 }],
-    threshold: 0.4,
-    // Allow some fuzzy matching
-    includeScore: true,
-    minMatchCharLength: 1,
-    // Use extended search for better path matching
-    useExtendedSearch: false
+  }
+  const fzf = new AsyncFzf(files);
+  const results = await fzf.find(query);
+  return results.slice(0, maxResults).map((result) => {
+    const p = result.item;
+    const fullPath = path.join(projectRoot, p);
+    try {
+      const stats = fs.statSync(fullPath);
+      return {
+        path: p,
+        isDirectory: stats.isDirectory(),
+        size: stats.isFile() ? stats.size : void 0
+      };
+    } catch {
+      return { path: p, isDirectory: false };
+    }
   });
-  const results = fuse.search(query);
-  return results.slice(0, 20).map((result) => result.item);
 }
 function isPathWithinCwd(filePath) {
   const cwd = path.resolve(process.cwd());
@@ -509,10 +573,27 @@ var MAX_FILE_SIZE = 10 * 1024 * 1024;
 // src/components/FileAutocomplete.tsx
 function FileAutocomplete({ files, selectedIndex, query }) {
   if (files.length === 0) {
-    return /* @__PURE__ */ React4.createElement(Box3, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "No matching files", query ? ` for "${query}"` : ""));
-  }
-  return /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React4.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, files.length === 1 ? "1 match" : `${files.length} matches`, " - Use up/down to navigate, Tab to select")), files.map((file, index) => {
-    const isSelected = index === selectedIndex;
+    if (path2.isAbsolute(query)) {
+      return /* @__PURE__ */ React4.createElement(Box3, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "No items in "), /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, query), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " (or path does not exist)"));
+    }
+    return /* @__PURE__ */ React4.createElement(Box3, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "No matching files", query ? ` for "${query}"` : " in root directory"));
+  }
+  const VIEWPORT_SIZE = 6;
+  const totalFiles = files.length;
+  let startIndex = 0;
+  let endIndex = Math.min(VIEWPORT_SIZE, totalFiles);
+  if (totalFiles > VIEWPORT_SIZE) {
+    const halfViewport = Math.floor(VIEWPORT_SIZE / 2);
+    startIndex = Math.max(0, selectedIndex - halfViewport);
+    endIndex = Math.min(totalFiles, startIndex + VIEWPORT_SIZE);
+    if (endIndex === totalFiles) {
+      startIndex = Math.max(0, totalFiles - VIEWPORT_SIZE);
+    }
+  }
+  const visibleFiles = files.slice(startIndex, endIndex);
+  return /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React4.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, totalFiles === 1 ? "1 match" : `${totalFiles} matches`, totalFiles > VIEWPORT_SIZE && ` (${selectedIndex + 1}/${totalFiles})`, " - Use up/down to navigate, Tab to select")), visibleFiles.map((file, viewportIndex) => {
+    const actualIndex = startIndex + viewportIndex;
+    const isSelected = actualIndex === selectedIndex;
     const icon = file.isDirectory ? "[folder]" : "[file]  ";
     const sizeDisplay = file.isDirectory ? "" : file.size !== void 0 ? ` (${formatFileSize(file.size)})` : "";
     const pathDisplay = file.isDirectory ? `${file.path}/` : file.path;
@@ -521,7 +602,7 @@ function FileAutocomplete({ files, selectedIndex, query }) {
 }
 
 // src/utils/fuzzySearch.ts
-import Fuse2 from "fuse.js";
+import Fuse from "fuse.js";
 
 // src/config/commands.ts
 var COMMANDS = [
@@ -698,13 +779,13 @@ function searchCommands(query, commands = COMMANDS) {
   if (!query || query.trim() === "") {
     return commands;
   }
-  const fuse = new Fuse2(commands, fuseOptions);
+  const fuse = new Fuse(commands, fuseOptions);
   const results = fuse.search(query);
   return results.map((result) => result.item);
 }
 
 // src/utils/imageDetector.ts
-import { readFileSync, existsSync, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2, statSync as statSync2 } from "fs";
 import { extname as extname2 } from "path";
 var ImageInputDetector = class {
   static {
@@ -845,14 +926,14 @@ var ImageInputDetector = class {
     let filepath = input.trim();
     filepath = filepath.replace(/^["']|["']$/g, "");
     filepath = filepath.replace(/\\(.)/g, "$1");
-    if (!existsSync(filepath)) return null;
+    if (!existsSync2(filepath)) return null;
     const stats = statSync2(filepath);
     if (!stats.isFile()) return null;
     const ext = extname2(filepath).toLowerCase();
     if (!this.SUPPORTED_EXTENSIONS.includes(ext)) return null;
     if (stats.size > this.MAX_IMAGE_SIZE) return null;
     try {
-      const data = readFileSync(filepath);
+      const data = readFileSync2(filepath);
       const format = ext.substring(1) === "jpeg" ? "jpg" : ext.substring(1);
       const filename = filepath.split("/").pop() || "image";
       return {
@@ -907,6 +988,21 @@ var ImageInputDetector = class {
   }
 };
 
+// src/hooks/useDebounce.ts
+import { useEffect as useEffect2, useState as useState2 } from "react";
+function useDebounce(value, delay = 300) {
+  const [debouncedValue, setDebouncedValue] = useState2(value);
+  useEffect2(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+
 // src/components/InputPrompt.tsx
 function looksLikeFilePath(input) {
   const trimmed = input.trim();
@@ -947,20 +1043,20 @@ function InputPrompt({
   const value = useCliStore((state) => state.inputValue);
   const setInputValue = useCliStore((state) => state.setInputValue);
   const setValue = setInputValue;
-  const [selectedIndex, setSelectedIndex] = useState2(0);
-  const [historyIndex, setHistoryIndex] = useState2(-1);
-  const [tempInput, setTempInput] = useState2("");
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const [historyIndex, setHistoryIndex] = useState3(-1);
+  const [tempInput, setTempInput] = useState3("");
   const inputKey = useRef2(0);
-  useEffect2(() => {
+  useEffect3(() => {
     if (prefillInput) {
       setValue(prefillInput);
       onPrefillConsumed?.();
     }
   }, [prefillInput, onPrefillConsumed]);
-  const [fileAutocomplete, setFileAutocomplete] = useState2(null);
-  const [fileSelectedIndex, setFileSelectedIndex] = useState2(0);
+  const [fileAutocomplete, setFileAutocomplete] = useState3(null);
+  const [fileSelectedIndex, setFileSelectedIndex] = useState3(0);
   const isBashMode = value.startsWith("!");
-  useEffect2(() => {
+  useEffect3(() => {
     onBashModeChange?.(isBashMode);
   }, [isBashMode, onBashModeChange]);
   const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active && !looksLikeFilePath(value);
@@ -969,14 +1065,32 @@ function InputPrompt({
     if (!shouldShowCommandAutocomplete) return [];
     return searchCommands(commandQuery, commands);
   }, [shouldShowCommandAutocomplete, commandQuery, commands]);
-  const filteredFiles = useMemo(() => {
-    if (!fileAutocomplete?.active) return [];
-    return searchFiles(fileAutocomplete.query);
-  }, [fileAutocomplete?.active, fileAutocomplete?.query]);
-  useEffect2(() => {
+  const debouncedFileQuery = useDebounce(fileAutocomplete?.query ?? "", 200);
+  const [filteredFiles, setFilteredFiles] = useState3([]);
+  useEffect3(() => {
+    if (!fileAutocomplete?.active) {
+      setFilteredFiles([]);
+      return;
+    }
+    let cancelled = false;
+    searchFiles(debouncedFileQuery).then((results) => {
+      if (!cancelled) {
+        setFilteredFiles(results);
+      }
+    }).catch((error) => {
+      if (!cancelled) {
+        console.error("File search error:", error);
+        setFilteredFiles([]);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [fileAutocomplete?.active, debouncedFileQuery]);
+  useEffect3(() => {
     setSelectedIndex(0);
   }, [filteredCommands]);
-  useEffect2(() => {
+  useEffect3(() => {
     setFileSelectedIndex(0);
   }, [filteredFiles]);
   useInput2(
@@ -1214,13 +1328,13 @@ function BackgroundAgentStatus() {
 }
 
 // src/components/CompletedGroupNotification.tsx
-import React9, { useEffect as useEffect3 } from "react";
+import React9, { useEffect as useEffect4 } from "react";
 import { Box as Box8, Text as Text8 } from "ink";
 var NOTIFICATION_DISPLAY_DURATION_MS = 3e3;
 function CompletedGroupNotification() {
   const notifications = useCliStore((state) => state.completedGroupNotifications);
   const clearNotifications = useCliStore((state) => state.clearCompletedGroupNotifications);
-  useEffect3(() => {
+  useEffect4(() => {
     if (notifications.length > 0) {
       const timer = setTimeout(() => {
         clearNotifications();
@@ -1233,7 +1347,7 @@ function CompletedGroupNotification() {
 }
 
 // src/components/PermissionPrompt.tsx
-import React10, { useState as useState3, useCallback } from "react";
+import React10, { useState as useState4, useCallback } from "react";
 import { Box as Box9, Text as Text9, useInput as useInput3 } from "ink";
 function renderDiffPreview(preview) {
   const lines = preview.split("\n");
@@ -1260,14 +1374,16 @@ function PermissionPrompt({
 }) {
   const items = canBeTrusted ? [
     { label: "\u2713 Allow once", value: "allow-once" },
+    { label: "\u2713 Allow for this session", value: "allow-session" },
     { label: "\u2713 Always allow (trust this tool)", value: "allow-always" },
     { label: "\u2717 Deny", value: "deny" }
   ] : [
     { label: "\u2713 Allow once", value: "allow-once" },
+    { label: "\u2713 Allow for this session", value: "allow-session" },
     { label: "\u2717 Deny", value: "deny" }
   ];
-  const [selectedIndex, setSelectedIndex] = useState3(0);
-  const [responded, setResponded] = useState3(false);
+  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const [responded, setResponded] = useState4(false);
   const handleSelect = useCallback(() => {
     if (responded) return;
     setResponded(true);
@@ -1315,7 +1431,7 @@ function PermissionPrompt({
 }
 
 // src/components/ConfigEditor.tsx
-import React11, { useState as useState4, useMemo as useMemo3 } from "react";
+import React11, { useState as useState5, useMemo as useMemo3 } from "react";
 import { Box as Box10, Text as Text10, useInput as useInput4 } from "ink";
 var MAX_ITERATIONS_OPTIONS = [
   { label: "10", value: 10 },
@@ -1460,10 +1576,10 @@ function buildConfigItems(availableModels) {
   return items;
 }
 function ConfigEditor({ config, availableModels, onSave, onClose }) {
-  const [selectedIndex, setSelectedIndex] = useState4(0);
-  const [editedConfig, setEditedConfig] = useState4(config);
-  const [saveError, setSaveError] = useState4(null);
-  const [isSaving, setIsSaving] = useState4(false);
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const [editedConfig, setEditedConfig] = useState5(config);
+  const [saveError, setSaveError] = useState5(null);
+  const [isSaving, setIsSaving] = useState5(false);
   const configItems = useMemo3(() => buildConfigItems(availableModels), [availableModels]);
   const hasChanges = useMemo3(() => {
     return JSON.stringify(config.preferences) !== JSON.stringify(editedConfig.preferences) || config.defaultModel !== editedConfig.defaultModel;
@@ -1744,12 +1860,12 @@ var MessageItem = React14.memo(function MessageItem2({ message }) {
       return /* @__PURE__ */ React14.createElement(Box13, { key: idx, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "\u{1F527} ", toolName), toolInput && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   Input: ${truncateValue(toolInput, 100)}`), result && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   Result: ${truncateValue(result, 200)}`));
     }
     return null;
-  }).filter(Boolean)), !isUser && message.content !== "..." && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2, marginBottom: 1 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React14.createElement(MarkdownRenderer, { content: message.content })), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2 }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
+  }).filter(Boolean)), !isUser && message.content !== "..." && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2, marginBottom: 1 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React14.createElement(MarkdownRenderer, { content: message.content })), !isUser && message.content !== "..." && message.metadata && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2, marginBottom: 1 }, (message.metadata.tokenUsage?.total || message.metadata.creditsUsed) && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "(", message.metadata.tokenUsage?.total ? `${message.metadata.tokenUsage.total.toLocaleString()} tokens` : "", message.metadata.creditsUsed && message.metadata.creditsUsed > 0 ? (message.metadata.tokenUsage?.total ? " \u2022 " : "") + `used ${message.metadata.creditsUsed.toLocaleString()} ${message.metadata.creditsUsed === 1 ? "credit" : "credits"}` : "", ")")));
 });
 
 // src/utils/processFileReferences.ts
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 
 // src/utils/constants.ts
 var NAME_SUFFIXES = ["jr", "sr", "ii", "iii", "iv", "v", "phd", "md", "esq"];
@@ -1760,7 +1876,7 @@ function isNameSuffix(value) {
 // src/utils/processFileReferences.ts
 var FILE_REFERENCE_REGEX = /(?:^|\s)@([^\s@]+)/g;
 function looksLikeFilePath2(ref) {
-  if (ref.includes("/") || ref.includes(path2.sep)) {
+  if (ref.includes("/") || ref.includes(path3.sep)) {
     return true;
   }
   const extensionMatch = /\.(\w+)$/.exec(ref);
@@ -1790,9 +1906,13 @@ function extractFileReferences(message) {
 }
 function readFileContents(filePath) {
   const cwd = process.cwd();
-  const absolutePath = path2.resolve(cwd, filePath);
-  if (!isPathWithinCwd(filePath)) {
-    return { error: `Security: Path "${filePath}" is outside the current working directory` };
+  const isAbsolutePath = path3.isAbsolute(filePath);
+  if (filePath.includes("..")) {
+    return { error: `Security: Path traversal detected in "${filePath}"` };
+  }
+  const absolutePath = isAbsolutePath ? path3.normalize(filePath) : path3.resolve(cwd, filePath);
+  if (!isAbsolutePath && !isPathWithinCwd(filePath)) {
+    return { error: `Security: Relative path "${filePath}" escapes the current working directory` };
   }
   if (!fs2.existsSync(absolutePath)) {
     return { error: `File not found: "${filePath}"` };
@@ -1883,6 +2003,7 @@ function App({
   const sessionName = useCliStore((state) => state.session?.name || "New Session");
   const currentModel = useCliStore((state) => state.session?.model || "claude-sonnet-4-5-20250929");
   const totalTokens = useCliStore((state) => state.session?.metadata.totalTokens || 0);
+  const totalCredits = useCliStore((state) => state.session?.metadata.totalCredits);
   const isThinking = useCliStore((state) => state.isThinking);
   const permissionPrompt = useCliStore((state) => state.permissionPrompt);
   const showConfigEditor = useCliStore((state) => state.showConfigEditor);
@@ -1893,7 +2014,7 @@ function App({
   const setIsThinking = useCliStore((state) => state.setIsThinking);
   const pendingBackgroundTrigger = useCliStore((state) => state.pendingBackgroundTrigger);
   const setPendingBackgroundTrigger = useCliStore((state) => state.setPendingBackgroundTrigger);
-  useEffect4(() => {
+  useEffect5(() => {
     if (pendingBackgroundTrigger && !isThinking && onBackgroundCompletion) {
       setPendingBackgroundTrigger(false);
       onBackgroundCompletion();
@@ -1905,7 +2026,7 @@ function App({
       toggleAutoAcceptEdits();
     }
   });
-  const [isBashMode, setIsBashMode] = useState5(false);
+  const [isBashMode, setIsBashMode] = useState6(false);
   const handleSubmit = React15.useCallback(
     async (input) => {
       const trimmed = input.trim();
@@ -1968,7 +2089,15 @@ ${errorBlock}`;
       onPrefillConsumed,
       onBashModeChange: setIsBashMode
     }
-  )), /* @__PURE__ */ React15.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens })));
+  )), /* @__PURE__ */ React15.createElement(
+    StatusBar,
+    {
+      sessionName,
+      model: currentModel,
+      tokenUsage: totalTokens,
+      creditsUsage: totalCredits
+    }
+  )));
 }
 
 // src/components/MessageList.tsx
@@ -2044,12 +2173,12 @@ function TrustLocationSelector({ inProject, onSelect, onCancel }) {
 }
 
 // src/components/RewindSelector.tsx
-import React18, { useState as useState6 } from "react";
+import React18, { useState as useState7 } from "react";
 import { Box as Box17, Text as Text17, useInput as useInput7 } from "ink";
 import SelectInput2 from "ink-select-input";
 function RewindSelector({ messages, onSelect, onCancel }) {
-  const [step, setStep] = useState6("selection");
-  const [selectedMessageIndex, setSelectedMessageIndex] = useState6(null);
+  const [step, setStep] = useState7("selection");
+  const [selectedMessageIndex, setSelectedMessageIndex] = useState7(null);
   useInput7((input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
@@ -2113,12 +2242,12 @@ function RewindSelector({ messages, onSelect, onCancel }) {
 }
 
 // src/components/SessionSelector.tsx
-import React19, { useState as useState7 } from "react";
+import React19, { useState as useState8 } from "react";
 import { Box as Box18, Text as Text18, useInput as useInput8 } from "ink";
 import SelectInput3 from "ink-select-input";
 function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
-  const [step, setStep] = useState7("selection");
-  const [selectedSession, setSelectedSession] = useState7(null);
+  const [step, setStep] = useState8("selection");
+  const [selectedSession, setSelectedSession] = useState8(null);
   useInput8((_input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
@@ -2193,7 +2322,7 @@ function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
 }
 
 // src/components/LoginFlow.tsx
-import React20, { useState as useState8, useEffect as useEffect5 } from "react";
+import React20, { useState as useState9, useEffect as useEffect6 } from "react";
 import { Box as Box19, Text as Text19 } from "ink";
 import Spinner3 from "ink-spinner";
 import jwt from "jsonwebtoken";
@@ -2310,11 +2439,11 @@ var OAuthClient = class {
 
 // src/components/LoginFlow.tsx
 function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, onError }) {
-  const [status, setStatus] = useState8("initiating");
-  const [deviceFlow, setDeviceFlow] = useState8(null);
-  const [statusMessage, setStatusMessage] = useState8("Initiating device authorization...");
-  const [error, setError] = useState8(null);
-  useEffect5(() => {
+  const [status, setStatus] = useState9("initiating");
+  const [deviceFlow, setDeviceFlow] = useState9(null);
+  const [statusMessage, setStatusMessage] = useState9("Initiating device authorization...");
+  const [error, setError] = useState9(null);
+  useEffect6(() => {
     const runLoginFlow = async () => {
       const oauth = new OAuthClient(apiUrl);
       try {
@@ -2349,7 +2478,7 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
     };
     runLoginFlow();
   }, [apiUrl, configStore, onSuccess, onError]);
-  useEffect5(() => {
+  useEffect6(() => {
     if (deviceFlow && status === "waiting") {
       open(deviceFlow.verification_uri_complete).catch((err) => {
         console.error("Failed to auto-open browser:", err);
@@ -2370,12 +2499,12 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
 
 // src/storage/SessionStore.ts
 import { promises as fs3 } from "fs";
-import path3 from "path";
+import path4 from "path";
 import { homedir } from "os";
 import { v4 as uuidv4 } from "uuid";
 var SessionStore = class {
   constructor(basePath) {
-    this.basePath = basePath || path3.join(homedir(), ".bike4mind", "sessions");
+    this.basePath = basePath || path4.join(homedir(), ".bike4mind", "sessions");
   }
   /**
    * Initialize storage directory
@@ -2396,7 +2525,7 @@ var SessionStore = class {
       throw new Error("Cannot save session with no messages");
     }
     await this.init();
-    const filePath = path3.join(this.basePath, `${session.id}.json`);
+    const filePath = path4.join(this.basePath, `${session.id}.json`);
     try {
       await fs3.writeFile(filePath, JSON.stringify(session, null, 2), "utf-8");
     } catch (error) {
@@ -2408,7 +2537,7 @@ var SessionStore = class {
    * Load a session from disk by ID
    */
   async load(id) {
-    const filePath = path3.join(this.basePath, `${id}.json`);
+    const filePath = path4.join(this.basePath, `${id}.json`);
     try {
       const data = await fs3.readFile(filePath, "utf-8");
       const session = JSON.parse(data);
@@ -2446,7 +2575,7 @@ var SessionStore = class {
       const jsonFiles = files.filter((f) => f.endsWith(".json"));
       const sessionsWithFiles = await Promise.all(
         jsonFiles.map(async (file) => {
-          const filePath = path3.join(this.basePath, file);
+          const filePath = path4.join(this.basePath, file);
           const data = await fs3.readFile(filePath, "utf-8");
           const session = JSON.parse(data);
           session.messages = session.messages.map((msg) => {
@@ -2481,7 +2610,7 @@ var SessionStore = class {
    * Delete a session
    */
   async delete(id) {
-    const filePath = path3.join(this.basePath, `${id}.json`);
+    const filePath = path4.join(this.basePath, `${id}.json`);
     try {
       await fs3.unlink(filePath);
       return true;
@@ -2520,19 +2649,19 @@ var SessionStore = class {
 
 // src/storage/CommandHistoryStore.ts
 import { promises as fs4 } from "fs";
-import path4 from "path";
+import path5 from "path";
 import { homedir as homedir2 } from "os";
 var MAX_HISTORY_ENTRIES = 1e3;
 var CommandHistoryStore = class {
   constructor(historyPath) {
     this.history = null;
-    this.historyPath = historyPath || path4.join(homedir2(), ".bike4mind", "history.jsonl");
+    this.historyPath = historyPath || path5.join(homedir2(), ".bike4mind", "history.jsonl");
   }
   /**
    * Initialize history directory
    */
   async init() {
-    const dir = path4.dirname(this.historyPath);
+    const dir = path5.dirname(this.historyPath);
     try {
       await fs4.mkdir(dir, { recursive: true });
     } catch (error) {
@@ -2635,7 +2764,7 @@ var CommandHistoryStore = class {
 
 // src/storage/CustomCommandStore.ts
 import fs5 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import os from "os";
 
 // src/utils/commandParser.ts
@@ -2798,14 +2927,14 @@ var CustomCommandStore = class {
     const home = os.homedir();
     const root = projectRoot || process.cwd();
     this.globalCommandsDirs = [
-      path5.join(home, ".bike4mind", "commands"),
-      path5.join(home, ".claude", "commands"),
-      path5.join(home, ".claude", "skills")
+      path6.join(home, ".bike4mind", "commands"),
+      path6.join(home, ".claude", "commands"),
+      path6.join(home, ".claude", "skills")
     ];
     this.projectCommandsDirs = [
-      path5.join(root, ".bike4mind", "commands"),
-      path5.join(root, ".claude", "commands"),
-      path5.join(root, ".claude", "skills")
+      path6.join(root, ".bike4mind", "commands"),
+      path6.join(root, ".claude", "commands"),
+      path6.join(root, ".claude", "skills")
     ];
   }
   /**
@@ -2865,7 +2994,7 @@ var CustomCommandStore = class {
     try {
       const entries = await fs5.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path5.join(directory, entry.name);
+        const fullPath = path6.join(directory, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.findCommandFiles(fullPath);
           files.push(...subFiles);
@@ -2885,7 +3014,7 @@ var CustomCommandStore = class {
    * @param source - Source identifier ('global' or 'project')
    */
   async loadCommandFile(filePath, source) {
-    const filename = path5.basename(filePath);
+    const filename = path6.basename(filePath);
     const isSkillFile = filename.toLowerCase() === "skill.md";
     const commandName = isSkillFile ? this.extractSkillName(filePath) : extractCommandName(filename);
     if (!commandName) {
@@ -2904,7 +3033,7 @@ var CustomCommandStore = class {
    * @returns Skill name or null if invalid
    */
   extractSkillName(filePath) {
-    const parentDir = path5.basename(path5.dirname(filePath));
+    const parentDir = path6.basename(path6.dirname(filePath));
     return parentDir && parentDir !== "skills" ? parentDir : null;
   }
   /**
@@ -2966,7 +3095,7 @@ var CustomCommandStore = class {
    */
   async createCommandFile(name, isGlobal = false) {
     const targetDir = isGlobal ? this.globalCommandsDirs[0] : this.projectCommandsDirs[0];
-    const filePath = path5.join(targetDir, `${name}.md`);
+    const filePath = path6.join(targetDir, `${name}.md`);
     const fileExists = await fs5.access(filePath).then(
       () => true,
       () => false
@@ -3122,6 +3251,7 @@ var ReActAgent = class extends EventEmitter {
     super();
     this.steps = [];
     this.totalTokens = 0;
+    this.totalCredits = 0;
     this.toolCallCount = 0;
     this.observationQueue = [];
     this.context = {
@@ -3141,6 +3271,7 @@ var ReActAgent = class extends EventEmitter {
   async run(query, options = {}) {
     this.steps = [];
     this.totalTokens = 0;
+    this.totalCredits = 0;
     this.toolCallCount = 0;
     const maxIterations = options.maxIterations ?? this.context.maxIterations ?? 5;
     const temperature = options.temperature ?? this.context.temperature ?? 0.7;
@@ -3177,6 +3308,7 @@ ${options.context}` : this.getSystemPrompt()
             steps: this.steps,
             completionInfo: {
               totalTokens: this.totalTokens,
+              totalCredits: this.totalCredits > 0 ? this.totalCredits : void 0,
               iterations,
               toolCalls: this.toolCallCount,
               reachedMaxIterations: false
@@ -3212,6 +3344,9 @@ ${options.context}` : this.getSystemPrompt()
               const inputTokens = completionInfo.inputTokens || 0;
               const outputTokens = completionInfo.outputTokens || 0;
               this.totalTokens += inputTokens + outputTokens;
+              if (completionInfo.creditsUsed) {
+                this.totalCredits += completionInfo.creditsUsed;
+              }
               if (currentText.trim() && completionInfo.toolsUsed?.length) {
                 const thoughtStep = {
                   type: "thought",
@@ -3325,6 +3460,7 @@ ${options.context}` : this.getSystemPrompt()
         steps: this.steps,
         completionInfo: {
           totalTokens: this.totalTokens,
+          totalCredits: this.totalCredits > 0 ? this.totalCredits : void 0,
           iterations,
           toolCalls: this.toolCallCount,
           reachedMaxIterations
@@ -3342,6 +3478,7 @@ ${options.context}` : this.getSystemPrompt()
           steps: this.steps,
           completionInfo: {
             totalTokens: this.totalTokens,
+            totalCredits: this.totalCredits > 0 ? this.totalCredits : void 0,
             iterations,
             toolCalls: this.toolCallCount,
             reachedMaxIterations: false
@@ -3587,6 +3724,50 @@ function isReadOnlyTool(toolName, customCategories) {
   return getToolCategory(toolName, customCategories) !== "prompt_always";
 }
 
+// src/core/skillsPrompt.ts
+function getSkillDisplayName(cmd) {
+  return cmd.displayName || cmd.name;
+}
+function formatSkillEntry(cmd) {
+  const displayName = getSkillDisplayName(cmd);
+  const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
+  const nameDisplay = cmd.displayName && cmd.displayName !== cmd.name ? `**${displayName}** (\`${cmd.name}\`)` : `**${cmd.name}**`;
+  return `- ${nameDisplay}${argHint}: ${cmd.description}
+`;
+}
+function formatSkillGroup(heading, commands) {
+  if (commands.length === 0) {
+    return "";
+  }
+  return `
+### ${heading}
+${commands.map(formatSkillEntry).join("")}`;
+}
+function filterAIVisibleSkills(commands) {
+  return commands.filter((cmd) => !cmd.disableModelInvocation);
+}
+function filterSkillsByAllowedList(commands, allowedSkills) {
+  if (!allowedSkills || allowedSkills.length === 0) {
+    return commands;
+  }
+  return commands.filter((cmd) => allowedSkills.includes(cmd.name));
+}
+function buildSkillsPromptSection(commands, allowedSkills) {
+  const filteredByAllowed = filterSkillsByAllowedList(commands, allowedSkills);
+  const visibleCommands = filterAIVisibleSkills(filteredByAllowed);
+  if (visibleCommands.length === 0) {
+    return "";
+  }
+  const projectSkills = visibleCommands.filter((c) => c.source === "project");
+  const globalSkills = visibleCommands.filter((c) => c.source === "global");
+  return `
+
+## Available Skills
+
+Use the \`skill\` tool to invoke these. Example: skill({ skill: "commit" })
+` + formatSkillGroup("Project Skills", projectSkills) + formatSkillGroup("Global Skills", globalSkills);
+}
+
 // src/core/prompts.ts
 var TOOL_GREP_SEARCH = "grep_search";
 var TOOL_GLOB_FILES = "glob_files";
@@ -3597,7 +3778,38 @@ var TOOL_BASH_EXECUTE = "bash_execute";
 var TOOL_SUBAGENT_DELEGATE = "subagent_delegate";
 var TOOL_WRITE_TODOS = "write_todos";
 var EXPLORE_SUBAGENT_TYPE = "explore";
-function buildCoreSystemPrompt(contextSection = "") {
+function buildCoreSystemPrompt(contextSection, config) {
+  let projectContextSection = "";
+  let agentDirectoryContext = "";
+  let skillsSection = "";
+  if (typeof contextSection === "string") {
+    projectContextSection = contextSection;
+    if (config) {
+      if (config.enableSkillTool !== false && config.customCommands && config.customCommands.length > 0) {
+        skillsSection = buildSkillsPromptSection(config.customCommands);
+      }
+      if (config.agentStore) {
+        agentDirectoryContext = config.agentStore.getDirectoryContext();
+      }
+    }
+  } else if (contextSection && typeof contextSection === "object") {
+    config = contextSection;
+    if (config.contextContent) {
+      projectContextSection = `
+
+## Project Context
+
+Follow these project-specific instructions:
+
+${config.contextContent}`;
+    }
+    if (config.enableSkillTool !== false && config.customCommands && config.customCommands.length > 0) {
+      skillsSection = buildSkillsPromptSection(config.customCommands);
+    }
+    if (config.agentStore) {
+      agentDirectoryContext = config.agentStore.getDirectoryContext();
+    }
+  }
   return `You are an autonomous AI assistant with access to tools. Your job is to help users by taking action and solving problems proactively.
 
 CORE BEHAVIOR:
@@ -3627,12 +3839,8 @@ When requested to perform tasks like fixing bugs, adding features, refactoring,
 
 SUBAGENT DELEGATION:
 - You have access to specialized subagents via the ${TOOL_SUBAGENT_DELEGATE} tool
-- Use subagents for focused exploration, planning, or review tasks:
-  * explore: Fast read-only codebase search (e.g., "find all auth files", "locate API endpoints")
-  * plan: Break down complex tasks into actionable steps
-  * review: Analyze code quality and identify issues
+- ${agentDirectoryContext ? `${agentDirectoryContext}` : ""}
 - Subagents keep the main conversation clean and run faster with optimized models
-- Delegate when you need to search extensively or analyze code structure
 
 CODE SEARCH BEST PRACTICES:
 When searching code, follow this hierarchy for speed and efficiency:
@@ -3689,7 +3897,7 @@ EXAMPLES:
 - "what packages installed?" \u2192 ${TOOL_GLOB_FILES} "**/package.json" \u2192 ${TOOL_FILE_READ}
 - "find all components using React hooks" \u2192 ${TOOL_SUBAGENT_DELEGATE}(task="find all components using React hooks", type="explore")
 
-Remember: Use context from previous messages to understand follow-up questions.${contextSection}`;
+Remember: Use context from previous messages to understand follow-up questions.${projectContextSection}${skillsSection}`;
 }
 
 // ../../b4m-core/packages/services/dist/src/referService/generateCodes.js
@@ -3865,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,
@@ -5509,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),
@@ -5818,8 +6039,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path18 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path18;
+    const path19 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path19;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -7145,8 +7366,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path18 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path18;
+  const path19 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path19;
 }
 async function generateFullMask(imageBuffer) {
   const sharp = (await import("sharp")).default;
@@ -9088,18 +9309,18 @@ var planetVisibilityTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
 import { promises as fs7 } from "fs";
-import { existsSync as existsSync3, statSync as statSync4 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync4, statSync as statSync4 } from "fs";
+import path7 from "path";
 var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 async function readFileContent(params) {
   const { path: filePath, encoding = "utf-8", offset = 0, limit } = params;
-  const normalizedPath = path6.normalize(filePath);
-  const resolvedPath = path6.resolve(process.cwd(), normalizedPath);
-  const cwd = path6.resolve(process.cwd());
+  const normalizedPath = path7.normalize(filePath);
+  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
+  const cwd = path7.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
-  if (!existsSync3(resolvedPath)) {
+  if (!existsSync4(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   const stats = statSync4(resolvedPath);
@@ -9168,7 +9389,7 @@ var fileReadTool = {
       context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
       try {
         const content = await readFileContent(params);
-        const stats = statSync4(path6.resolve(process.cwd(), path6.normalize(params.path)));
+        const stats = statSync4(path7.resolve(process.cwd(), path7.normalize(params.path)));
         context.logger.info("\u2705 FileRead: Success", {
           path: params.path,
           size: stats.size,
@@ -9213,20 +9434,20 @@ var fileReadTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
 import { promises as fs8 } from "fs";
-import { existsSync as existsSync4 } from "fs";
-import path7 from "path";
+import { existsSync as existsSync5 } from "fs";
+import path8 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
-  const normalizedPath = path7.normalize(filePath);
-  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
-  const cwd = path7.resolve(process.cwd());
+  const normalizedPath = path8.normalize(filePath);
+  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
+  const cwd = path8.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
-  const fileExists = existsSync4(resolvedPath);
+  const fileExists = existsSync5(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
-    const dir = path7.dirname(resolvedPath);
+    const dir = path8.dirname(resolvedPath);
     await fs8.mkdir(dir, { recursive: true });
   }
   await fs8.writeFile(resolvedPath, content, "utf-8");
@@ -9241,7 +9462,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync4(path7.resolve(process.cwd(), path7.normalize(params.path)));
+      const fileExists = existsSync5(path8.resolve(process.cwd(), path8.normalize(params.path)));
       context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
         path: params.path,
         size: params.content.length
@@ -9283,8 +9504,8 @@ var createFileTool = {
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
 import { glob } from "glob";
 import { stat } from "fs/promises";
-import path8 from "path";
-var DEFAULT_IGNORE_PATTERNS2 = [
+import path9 from "path";
+var DEFAULT_IGNORE_PATTERNS = [
   "**/node_modules/**",
   "**/.git/**",
   "**/dist/**",
@@ -9299,11 +9520,11 @@ var DEFAULT_IGNORE_PATTERNS2 = [
 async function findFiles(params) {
   const { pattern, dir_path, case_sensitive = true, respect_git_ignore = true } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path8.resolve(baseCwd, path8.normalize(dir_path)) : baseCwd;
+  const targetDir = dir_path ? path9.resolve(baseCwd, path9.normalize(dir_path)) : baseCwd;
   if (!targetDir.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot search outside of current working directory`);
   }
-  const ignorePatterns = respect_git_ignore ? DEFAULT_IGNORE_PATTERNS2 : [];
+  const ignorePatterns = respect_git_ignore ? DEFAULT_IGNORE_PATTERNS : [];
   const matches = await glob(pattern, {
     cwd: targetDir,
     dot: false,
@@ -9339,7 +9560,7 @@ async function findFiles(params) {
   const summary = `Found ${filesWithStats.length} file(s)${truncated ? ` (showing first ${MAX_RESULTS})` : ""} matching: ${pattern}`;
   const dirInfo = dir_path ? `
 Directory: ${dir_path}` : "";
-  const filesList = results.map((file) => path8.relative(baseCwd, file.path)).join("\n");
+  const filesList = results.map((file) => path9.relative(baseCwd, file.path)).join("\n");
   return `${summary}${dirInfo}
 
 ${filesList}`;
@@ -9393,7 +9614,7 @@ var globFilesTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
 import { stat as stat2 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { createRequire } from "module";
@@ -9402,18 +9623,18 @@ var require2 = createRequire(import.meta.url);
 function getRipgrepPath() {
   try {
     const ripgrepPath = require2.resolve("@vscode/ripgrep");
-    const ripgrepDir = path9.dirname(ripgrepPath);
-    const rgBinary = path9.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    const ripgrepDir = path10.dirname(ripgrepPath);
+    const rgBinary = path10.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
     return rgBinary;
   } catch (error) {
     throw new Error("ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services");
   }
 }
 function isPathWithinWorkspace(targetPath, baseCwd) {
-  const resolvedTarget = path9.resolve(targetPath);
-  const resolvedBase = path9.resolve(baseCwd);
-  const relativePath = path9.relative(resolvedBase, resolvedTarget);
-  return !relativePath.startsWith("..") && !path9.isAbsolute(relativePath);
+  const resolvedTarget = path10.resolve(targetPath);
+  const resolvedBase = path10.resolve(baseCwd);
+  const relativePath = path10.relative(resolvedBase, resolvedTarget);
+  return !relativePath.startsWith("..") && !path10.isAbsolute(relativePath);
 }
 function convertGlobToRipgrepGlobs(globPattern) {
   if (!globPattern || globPattern === "**/*") {
@@ -9429,7 +9650,7 @@ function convertGlobToRipgrepGlobs(globPattern) {
 async function searchFiles2(params) {
   const { pattern, dir_path, include } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path9.resolve(baseCwd, dir_path) : baseCwd;
+  const targetDir = dir_path ? path10.resolve(baseCwd, dir_path) : baseCwd;
   if (!isPathWithinWorkspace(targetDir, baseCwd)) {
     throw new Error(`Path validation failed: "${dir_path}" resolves outside the allowed workspace directory`);
   }
@@ -9491,7 +9712,7 @@ async function searchFiles2(params) {
       if (item.type === "match") {
         const match = item;
         allMatches.push({
-          filePath: path9.relative(targetDir, match.data.path.text) || path9.basename(match.data.path.text),
+          filePath: path10.relative(targetDir, match.data.path.text) || path10.basename(match.data.path.text),
           lineNumber: match.data.line_number,
           line: match.data.lines.text.trimEnd()
           // Remove trailing newline
@@ -9585,17 +9806,17 @@ var grepSearchTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
 import { promises as fs9 } from "fs";
-import { existsSync as existsSync5, statSync as statSync5 } from "fs";
-import path10 from "path";
+import { existsSync as existsSync6, statSync as statSync5 } from "fs";
+import path11 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
-  const normalizedPath = path10.normalize(filePath);
-  const resolvedPath = path10.resolve(process.cwd(), normalizedPath);
-  const cwd = path10.resolve(process.cwd());
+  const normalizedPath = path11.normalize(filePath);
+  const resolvedPath = path11.resolve(process.cwd(), normalizedPath);
+  const cwd = path11.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
-  if (!existsSync5(resolvedPath)) {
+  if (!existsSync6(resolvedPath)) {
     throw new Error(`File or directory not found: ${filePath}`);
   }
   const stats = statSync5(resolvedPath);
@@ -9618,8 +9839,8 @@ var deleteFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const resolvedPath = path10.resolve(process.cwd(), path10.normalize(params.path));
-      const isDirectory = existsSync5(resolvedPath) && statSync5(resolvedPath).isDirectory();
+      const resolvedPath = path11.resolve(process.cwd(), path11.normalize(params.path));
+      const isDirectory = existsSync6(resolvedPath) && statSync5(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -9744,7 +9965,7 @@ var knowledgeBaseSearchTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
 import { spawn } from "child_process";
-import path11 from "path";
+import path12 from "path";
 var DEFAULT_TIMEOUT_MS = 6e4;
 var MAX_OUTPUT_SIZE = 100 * 1024;
 var DANGEROUS_PATTERNS = [
@@ -9928,7 +10149,7 @@ async function executeBashCommand(params) {
     };
   }
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path11.resolve(baseCwd, relativeCwd) : baseCwd;
+  const targetCwd = relativeCwd ? path12.resolve(baseCwd, relativeCwd) : baseCwd;
   const effectiveTimeout = Math.min(timeout, 5 * 60 * 1e3);
   return new Promise((resolve3) => {
     let stdout = "";
@@ -10117,69 +10338,882 @@ BLOCKED OPERATIONS:
   })
 };
 
-// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editLocalFile/index.js
-import { promises as fs10 } from "fs";
-import { existsSync as existsSync6 } from "fs";
-import path12 from "path";
-import { diffLines as diffLines3 } from "diff";
-function generateDiff(original, modified) {
-  const differences = diffLines3(original, modified);
-  let diffString = "";
-  let additions = 0;
-  let deletions = 0;
-  differences.forEach((part) => {
-    if (part.added) {
-      additions += part.count || 0;
-      diffString += part.value.split("\n").filter((line) => line).map((line) => `+ ${line}`).join("\n");
-      if (diffString && !diffString.endsWith("\n"))
-        diffString += "\n";
-    } else if (part.removed) {
-      deletions += part.count || 0;
-      diffString += part.value.split("\n").filter((line) => line).map((line) => `- ${line}`).join("\n");
-      if (diffString && !diffString.endsWith("\n"))
-        diffString += "\n";
-    }
-  });
-  return { additions, deletions, diff: diffString.trim() };
-}
-async function editLocalFile(params) {
-  const { path: filePath, old_string, new_string } = params;
-  const normalizedPath = path12.normalize(filePath);
-  const resolvedPath = path12.resolve(process.cwd(), normalizedPath);
-  const cwd = path12.resolve(process.cwd());
-  if (!resolvedPath.startsWith(cwd)) {
-    throw new Error(`Access denied: Cannot edit files outside of current working directory`);
-  }
-  if (!existsSync6(resolvedPath)) {
-    throw new Error(`File not found: ${filePath}`);
-  }
-  const currentContent = await fs10.readFile(resolvedPath, "utf-8");
-  if (!currentContent.includes(old_string)) {
-    const preview = old_string.length > 100 ? old_string.substring(0, 100) + "..." : old_string;
-    throw new Error(`String to replace not found in file. Make sure the old_string matches exactly (including whitespace and line endings). Searched for: "${preview}"`);
-  }
-  const occurrences = currentContent.split(old_string).length - 1;
-  if (occurrences > 1) {
-    throw new Error(`Found ${occurrences} occurrences of the string to replace. Please provide a more specific old_string that matches exactly one location.`);
-  }
-  const newContent = currentContent.replace(old_string, new_string);
-  await fs10.writeFile(resolvedPath, newContent, "utf-8");
-  const diffResult = generateDiff(old_string, new_string);
-  return `File edited successfully: ${filePath}
-Changes: +${diffResult.additions} lines, -${diffResult.deletions} lines
-
-Diff:
-${diffResult.diff}`;
+// ../../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 editLocalFileTool = {
-  name: "edit_local_file",
+var latticeCreateModelTool = {
+  name: "lattice_create_model",
   implementation: (context) => ({
-    toolFn: async (value) => {
-      const params = value;
-      context.logger.info(`\u{1F4DD} EditLocalFile: Editing file`, {
-        path: params.path,
-        oldStringLength: params.old_string.length,
-        newStringLength: params.new_string.length
+    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";
+import path13 from "path";
+import { diffLines as diffLines3 } from "diff";
+function generateDiff(original, modified) {
+  const differences = diffLines3(original, modified);
+  let diffString = "";
+  let additions = 0;
+  let deletions = 0;
+  differences.forEach((part) => {
+    if (part.added) {
+      additions += part.count || 0;
+      diffString += part.value.split("\n").filter((line) => line).map((line) => `+ ${line}`).join("\n");
+      if (diffString && !diffString.endsWith("\n"))
+        diffString += "\n";
+    } else if (part.removed) {
+      deletions += part.count || 0;
+      diffString += part.value.split("\n").filter((line) => line).map((line) => `- ${line}`).join("\n");
+      if (diffString && !diffString.endsWith("\n"))
+        diffString += "\n";
+    }
+  });
+  return { additions, deletions, diff: diffString.trim() };
+}
+async function editLocalFile(params) {
+  const { path: filePath, old_string, new_string } = params;
+  const normalizedPath = path13.normalize(filePath);
+  const resolvedPath = path13.resolve(process.cwd(), normalizedPath);
+  const cwd = path13.resolve(process.cwd());
+  if (!resolvedPath.startsWith(cwd)) {
+    throw new Error(`Access denied: Cannot edit files outside of current working directory`);
+  }
+  if (!existsSync7(resolvedPath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const currentContent = await fs10.readFile(resolvedPath, "utf-8");
+  if (!currentContent.includes(old_string)) {
+    const preview = old_string.length > 100 ? old_string.substring(0, 100) + "..." : old_string;
+    throw new Error(`String to replace not found in file. Make sure the old_string matches exactly (including whitespace and line endings). Searched for: "${preview}"`);
+  }
+  const occurrences = currentContent.split(old_string).length - 1;
+  if (occurrences > 1) {
+    throw new Error(`Found ${occurrences} occurrences of the string to replace. Please provide a more specific old_string that matches exactly one location.`);
+  }
+  const newContent = currentContent.replace(old_string, new_string);
+  await fs10.writeFile(resolvedPath, newContent, "utf-8");
+  const diffResult = generateDiff(old_string, new_string);
+  return `File edited successfully: ${filePath}
+Changes: +${diffResult.additions} lines, -${diffResult.deletions} lines
+
+Diff:
+${diffResult.diff}`;
+}
+var editLocalFileTool = {
+  name: "edit_local_file",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      context.logger.info(`\u{1F4DD} EditLocalFile: Editing file`, {
+        path: params.path,
+        oldStringLength: params.old_string.length,
+        newStringLength: params.new_string.length
       });
       try {
         const result = await editLocalFile(params);
@@ -10588,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 = {
@@ -10714,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(),
@@ -11341,10 +12383,10 @@ var ToolErrorType;
 // src/utils/diffPreview.ts
 import * as Diff from "diff";
 import { readFile } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 async function generateFileDiffPreview(args) {
   try {
-    if (!existsSync7(args.path)) {
+    if (!existsSync8(args.path)) {
       const lines2 = args.content.split("\n");
       const preview = lines2.slice(0, 20).join("\n");
       const hasMore = lines2.length > 20;
@@ -11382,7 +12424,7 @@ ${diffLines4.join("\n")}`;
 }
 async function generateFileDeletePreview(args) {
   try {
-    if (!existsSync7(args.path)) {
+    if (!existsSync8(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
     const stats = await import("fs/promises").then((fs14) => fs14.stat(args.path));
@@ -11676,21 +12718,21 @@ var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path18) {
+  async download(path19) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path18) {
+  async delete(path19) {
   }
-  async getSignedUrl(path18) {
-    return `/tmp/${path18}`;
+  async getSignedUrl(path19) {
+    return `/tmp/${path19}`;
   }
-  getPublicUrl(path18) {
-    return `/tmp/${path18}`;
+  getPublicUrl(path19) {
+    return `/tmp/${path19}`;
   }
-  async getPreview(path18) {
-    return `/tmp/${path18}`;
+  async getPreview(path19) {
+    return `/tmp/${path19}`;
   }
-  async getMetadata(path18) {
+  async getMetadata(path19) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -11764,6 +12806,9 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
       if (response.action === "deny") {
         throw new PermissionDeniedError(toolName, args);
       }
+      if (response.action === "allow-session") {
+        permissionManager.trustToolForSession(toolName);
+      }
       if (response.action === "allow-always") {
         const canTrust = permissionManager.trustTool(toolName);
         if (canTrust) {
@@ -11968,6 +13013,7 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
 var PermissionManager = class {
   constructor(trustedTools = [], customCategories, deniedTools) {
     this.trustedTools = /* @__PURE__ */ new Set();
+    this.sessionTrustedTools = /* @__PURE__ */ new Set();
     this.deniedTools = /* @__PURE__ */ new Set();
     this.trustedTools = new Set(trustedTools);
     this.customCategories = new Map(Object.entries(customCategories || {}));
@@ -11993,6 +13039,9 @@ var PermissionManager = class {
     if (category === "auto_approve") {
       return false;
     }
+    if (this.sessionTrustedTools.has(toolName)) {
+      return false;
+    }
     if (category === "prompt_always") {
       return true;
     }
@@ -12060,6 +13109,29 @@ var PermissionManager = class {
   getDeniedTools() {
     return Array.from(this.deniedTools).sort();
   }
+  /**
+   * Trust a tool for the current session only (in-memory, no persistence)
+   * Works for all tool categories including prompt_always, but NOT project-denied tools
+   */
+  trustToolForSession(toolName) {
+    if (this.deniedTools.has(toolName)) {
+      return false;
+    }
+    this.sessionTrustedTools.add(toolName);
+    return true;
+  }
+  /**
+   * Check if a tool is trusted for the current session
+   */
+  isSessionTrusted(toolName) {
+    return this.sessionTrustedTools.has(toolName);
+  }
+  /**
+   * Clear all session-scoped trust (called on exit or session reset)
+   */
+  clearSessionTrust() {
+    this.sessionTrustedTools.clear();
+  }
   /**
    * Clear all trusted tools
    */
@@ -12097,7 +13169,7 @@ function getEnvironmentName(configApiConfig) {
 
 // src/utils/contextLoader.ts
 import * as fs11 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 import { homedir as homedir3 } from "os";
 var CONTEXT_FILE_SIZE_LIMIT = 100 * 1024;
 var PROJECT_CONTEXT_FILES = [
@@ -12118,7 +13190,7 @@ function formatFileSize2(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 function tryReadContextFile(dir, filename, source) {
-  const filePath = path13.join(dir, filename);
+  const filePath = path14.join(dir, filename);
   try {
     const stats = fs11.lstatSync(filePath);
     if (stats.isDirectory()) {
@@ -12186,7 +13258,7 @@ ${project.content}`;
 }
 async function loadContextFiles(projectDir) {
   const errors = [];
-  const globalDir = path13.join(homedir3(), ".bike4mind");
+  const globalDir = path14.join(homedir3(), ".bike4mind");
   const projectDirectory = projectDir || process.cwd();
   const [globalResult, projectResult] = await Promise.all([
     Promise.resolve(findContextFile(globalDir, GLOBAL_CONTEXT_FILES, "global")),
@@ -12457,8 +13529,8 @@ function substituteArguments(template, args) {
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path14 from "path";
-import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
+import path15 from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
@@ -12499,18 +13571,18 @@ var MCPClient = class {
         const root = process.env.INIT_CWD || process.cwd();
         const candidatePaths = [
           // When running from SST Lambda with node_modules structure (copyFiles)
-          path14.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda deployed environment (/var/task)
-          path14.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda (.sst/artifacts/mcpHandler-dev), navigate to monorepo root (3 levels up)
-          path14.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from packages/client (Next.js app), navigate to monorepo root (2 levels up)
-          path14.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // Original paths (backward compatibility)
-          path14.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-          path14.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+          path15.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path15.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
         ];
-        const serverScriptPath = candidatePaths.find((p) => existsSync8(p));
+        const serverScriptPath = candidatePaths.find((p) => existsSync9(p));
         if (!serverScriptPath) {
           const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
           console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
@@ -13070,6 +14142,14 @@ ${totalText}`);
 function stripThinkingBlocks(text) {
   return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
+function extractUsageInfo(parsed) {
+  return {
+    inputTokens: parsed.usage?.inputTokens,
+    outputTokens: parsed.usage?.outputTokens,
+    creditsUsed: parsed.credits?.used,
+    usdCost: parsed.credits?.usdCost
+  };
+}
 var ServerLlmBackend = class {
   constructor(options) {
     this.completionsEndpoint = "/api/ai/v1/completions";
@@ -13221,11 +14301,8 @@ var ServerLlmBackend = class {
             if (parsed.type === "content") {
               const textChunk = parsed.text || "";
               accumulatedText += textChunk;
-              if (parsed.usage) {
-                lastUsageInfo = {
-                  inputTokens: parsed.usage.inputTokens,
-                  outputTokens: parsed.usage.outputTokens
-                };
+              if (parsed.usage || parsed.credits) {
+                lastUsageInfo = extractUsageInfo(parsed);
               }
               streamLogger.onContent(eventCount, textChunk, accumulatedText);
             } else if (parsed.type === "tool_use") {
@@ -13252,11 +14329,8 @@ var ServerLlmBackend = class {
                 thinkingBlocks = parsed.thinking;
                 streamLogger.onCriticalEvent(eventCount, "THINKING", `${thinkingBlocks.length} thinking blocks`);
               }
-              if (parsed.usage) {
-                lastUsageInfo = {
-                  inputTokens: parsed.usage.inputTokens,
-                  outputTokens: parsed.usage.outputTokens
-                };
+              if (parsed.usage || parsed.credits) {
+                lastUsageInfo = extractUsageInfo(parsed);
               }
             }
           } catch (parseError) {
@@ -13561,7 +14635,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.29-slack-native-search.18848+70518c650",
+  version: "0.2.29",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -13632,10 +14706,13 @@ var package_default = {
     diff: "^8.0.2",
     dotenv: "^16.3.1",
     "eventsource-parser": "^3.0.6",
+    fdir: "^6.5.0",
     "file-type": "^18.7.0",
     "fuse.js": "^7.1.0",
+    fzf: "^0.5.2",
     glob: "^13.0.0",
     "gray-matter": "^4.0.3",
+    ignore: "^7.0.5",
     ink: "^6.5.1",
     "ink-select-input": "^6.2.0",
     "ink-spinner": "^5.0.0",
@@ -13651,6 +14728,7 @@ var package_default = {
     open: "^11.0.0",
     openai: "^6.18.0",
     "p-limit": "^6.2.0",
+    picomatch: "^4.0.3",
     qrcode: "^1.5.4",
     react: "^19.2.3",
     sharp: "^0.34.5",
@@ -13671,14 +14749,15 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.50.1-slack-native-search.18848+70518c650",
-    "@bike4mind/mcp": "1.29.1-slack-native-search.18848+70518c650",
-    "@bike4mind/services": "2.48.1-slack-native-search.18848+70518c650",
-    "@bike4mind/utils": "2.5.1-slack-native-search.18848+70518c650",
+    "@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",
     "@types/node": "^22.9.0",
+    "@types/picomatch": "^4.0.2",
     "@types/react": "^19.2.7",
     "@types/uuid": "^9.0.7",
     "@types/yargs": "^17.0.32",
@@ -13691,7 +14770,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "70518c65045da6771d97bdadf52992a08b855d1d"
+  gitHead: "dd78e3f7ac6eb31fbbae8df3be1f33310779a9d5"
 };
 
 // src/config/constants.ts
@@ -13928,50 +15007,6 @@ ${expandedBody}
   };
 }
 
-// src/core/skillsPrompt.ts
-function getSkillDisplayName(cmd) {
-  return cmd.displayName || cmd.name;
-}
-function formatSkillEntry(cmd) {
-  const displayName = getSkillDisplayName(cmd);
-  const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
-  const nameDisplay = cmd.displayName && cmd.displayName !== cmd.name ? `**${displayName}** (\`${cmd.name}\`)` : `**${cmd.name}**`;
-  return `- ${nameDisplay}${argHint}: ${cmd.description}
-`;
-}
-function formatSkillGroup(heading, commands) {
-  if (commands.length === 0) {
-    return "";
-  }
-  return `
-### ${heading}
-${commands.map(formatSkillEntry).join("")}`;
-}
-function filterAIVisibleSkills(commands) {
-  return commands.filter((cmd) => !cmd.disableModelInvocation);
-}
-function filterSkillsByAllowedList(commands, allowedSkills) {
-  if (!allowedSkills || allowedSkills.length === 0) {
-    return commands;
-  }
-  return commands.filter((cmd) => allowedSkills.includes(cmd.name));
-}
-function buildSkillsPromptSection(commands, allowedSkills) {
-  const filteredByAllowed = filterSkillsByAllowedList(commands, allowedSkills);
-  const visibleCommands = filterAIVisibleSkills(filteredByAllowed);
-  if (visibleCommands.length === 0) {
-    return "";
-  }
-  const projectSkills = visibleCommands.filter((c) => c.source === "project");
-  const globalSkills = visibleCommands.filter((c) => c.source === "global");
-  return `
-
-## Available Skills
-
-Use the \`skill\` tool to invoke these. Example: skill({ skill: "commit" })
-` + formatSkillGroup("Project Skills", projectSkills) + formatSkillGroup("Global Skills", globalSkills);
-}
-
 // src/agents/SubagentOrchestrator.ts
 var SubagentOrchestrator = class {
   constructor(deps) {
@@ -14185,7 +15220,7 @@ var SubagentOrchestrator = class {
 
 // src/agents/AgentStore.ts
 import fs12 from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 import os2 from "os";
 import matter2 from "gray-matter";
 var FULL_MODEL_ID_PREFIXES = [
@@ -14334,10 +15369,10 @@ var AgentStore = class {
     const root = projectRoot || process.cwd();
     const home = os2.homedir();
     this.builtinAgentsDir = builtinDir;
-    this.globalB4MAgentsDir = path15.join(home, ".bike4mind", "agents");
-    this.globalClaudeAgentsDir = path15.join(home, ".claude", "agents");
-    this.projectB4MAgentsDir = path15.join(root, ".bike4mind", "agents");
-    this.projectClaudeAgentsDir = path15.join(root, ".claude", "agents");
+    this.globalB4MAgentsDir = path16.join(home, ".bike4mind", "agents");
+    this.globalClaudeAgentsDir = path16.join(home, ".claude", "agents");
+    this.projectB4MAgentsDir = path16.join(root, ".bike4mind", "agents");
+    this.projectClaudeAgentsDir = path16.join(root, ".claude", "agents");
   }
   /**
    * Load all agents from all directories
@@ -14391,7 +15426,7 @@ var AgentStore = class {
     try {
       const entries = await fs12.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path15.join(directory, entry.name);
+        const fullPath = path16.join(directory, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.findAgentFiles(fullPath);
           files.push(...subFiles);
@@ -14411,7 +15446,7 @@ var AgentStore = class {
     const content = await fs12.readFile(filePath, "utf-8");
     const { data: frontmatter, content: body } = matter2(content);
     const parsed = AgentFrontmatterSchema.parse(frontmatter);
-    const name = path15.basename(filePath, ".md");
+    const name = path16.basename(filePath, ".md");
     const modelInput = parsed.model || DEFAULT_AGENT_MODEL;
     const resolution = resolveModelAlias(modelInput, name, filePath);
     if (!resolution.resolved && resolution.warning) {
@@ -14491,7 +15526,7 @@ var AgentStore = class {
    */
   async createAgentFile(name, isGlobal = false, useClaude = true) {
     const targetDir = isGlobal ? useClaude ? this.globalClaudeAgentsDir : this.globalB4MAgentsDir : useClaude ? this.projectClaudeAgentsDir : this.projectB4MAgentsDir;
-    const filePath = path15.join(targetDir, `${name}.md`);
+    const filePath = path16.join(targetDir, `${name}.md`);
     try {
       await fs12.access(filePath);
       throw new Error(`Agent file already exists: ${filePath}`);
@@ -14552,6 +15587,21 @@ Describe the expected output format here.
     }
     return { builtin, global, project, total: this.agents.size };
   }
+  /**
+   * Generates a markdown "Phone Book" of available agents and their schemas.
+   * This MUST be injected into the System Prompt of the parent agent.
+   */
+  getDirectoryContext() {
+    if (this.agents.size === 0) {
+      return "No sub-agents are currently available.";
+    }
+    let context = "Use `subagent_delegate` for complex tasks requiring specialized analysis.\n";
+    for (const [name, def] of this.agents) {
+      context += ` - **${name}**: ${def.description}
+`;
+    }
+    return context;
+  }
 };
 
 // src/agents/delegateTool.ts
@@ -15173,7 +16223,7 @@ function createTodoStore(onUpdate) {
 
 // src/tools/findDefinitionTool.ts
 import { stat as stat3 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { createRequire as createRequire2 } from "module";
@@ -15194,8 +16244,8 @@ var ALL_KEYWORDS = Object.values(KIND_KEYWORDS).flat();
 function getRipgrepPath2() {
   try {
     const ripgrepPath = require3.resolve("@vscode/ripgrep");
-    const ripgrepDir = path16.dirname(ripgrepPath);
-    return path16.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    const ripgrepDir = path17.dirname(ripgrepPath);
+    return path17.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
   } catch {
     throw new Error(
       "ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services"
@@ -15203,10 +16253,10 @@ function getRipgrepPath2() {
   }
 }
 function isPathWithinWorkspace2(targetPath, baseCwd) {
-  const resolvedTarget = path16.resolve(targetPath);
-  const resolvedBase = path16.resolve(baseCwd);
-  const relativePath = path16.relative(resolvedBase, resolvedTarget);
-  return !relativePath.startsWith("..") && !path16.isAbsolute(relativePath);
+  const resolvedTarget = path17.resolve(targetPath);
+  const resolvedBase = path17.resolve(baseCwd);
+  const relativePath = path17.relative(resolvedBase, resolvedTarget);
+  return !relativePath.startsWith("..") && !path17.isAbsolute(relativePath);
 }
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -15239,7 +16289,7 @@ async function findDefinitions(params) {
     throw new Error("symbol_name is required");
   }
   const baseCwd = process.cwd();
-  const targetDir = search_path ? path16.resolve(baseCwd, search_path) : baseCwd;
+  const targetDir = search_path ? path17.resolve(baseCwd, search_path) : baseCwd;
   if (!isPathWithinWorkspace2(targetDir, baseCwd)) {
     throw new Error(`Path validation failed: "${search_path}" resolves outside the allowed workspace directory`);
   }
@@ -15294,7 +16344,7 @@ async function findDefinitions(params) {
         const lineText = match.data.lines.text.trimEnd();
         if (isLikelyDefinition(lineText)) {
           allMatches.push({
-            filePath: path16.relative(targetDir, match.data.path.text) || path16.basename(match.data.path.text),
+            filePath: path17.relative(targetDir, match.data.path.text) || path17.basename(match.data.path.text),
             lineNumber: match.data.line_number,
             line: lineText
           });
@@ -15372,8 +16422,8 @@ function createFindDefinitionTool() {
 }
 
 // src/tools/getFileStructure/index.ts
-import { existsSync as existsSync9, promises as fs13, statSync as statSync6 } from "fs";
-import path17 from "path";
+import { existsSync as existsSync10, promises as fs13, statSync as statSync6 } from "fs";
+import path18 from "path";
 
 // src/tools/getFileStructure/formatter.ts
 var SECTIONS = [
@@ -15417,11 +16467,11 @@ function createGetFileStructureTool() {
       const params = value;
       try {
         const cwd = process.cwd();
-        const resolvedPath = path17.resolve(cwd, params.path);
+        const resolvedPath = path18.resolve(cwd, params.path);
         if (!resolvedPath.startsWith(cwd)) {
           return "Error: Access denied - cannot read files outside of current working directory";
         }
-        if (!existsSync9(resolvedPath)) {
+        if (!existsSync10(resolvedPath)) {
           return `Error: File not found: ${params.path}`;
         }
         const stats = statSync6(resolvedPath);
@@ -15431,7 +16481,7 @@ function createGetFileStructureTool() {
         if (stats.size > MAX_FILE_SIZE3) {
           return `Error: File too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Max: ${MAX_FILE_SIZE3 / 1024 / 1024}MB`;
         }
-        const ext = path17.extname(resolvedPath).toLowerCase();
+        const ext = path18.extname(resolvedPath).toLowerCase();
         const { getLanguageForExtension, parseFileStructure, getSupportedLanguages } = await import("./treeSitterEngine-4SGFQDY3.js");
         const languageId = getLanguageForExtension(ext);
         if (!languageId) {
@@ -15478,7 +16528,7 @@ var usageCache = null;
 function CliApp() {
   const { exit } = useApp();
   const imageRenderer = new ImageRenderer();
-  const [state, setState] = useState9({
+  const [state, setState] = useState10({
     session: null,
     sessionStore: new SessionStore(),
     configStore: new ConfigStore(),
@@ -15501,9 +16551,9 @@ function CliApp() {
     contextContent: "",
     backgroundManager: null
   });
-  const [isInitialized, setIsInitialized] = useState9(false);
-  const [initError, setInitError] = useState9(null);
-  const [commandHistory, setCommandHistory] = useState9([]);
+  const [isInitialized, setIsInitialized] = useState10(false);
+  const [initError, setInitError] = useState10(null);
+  const [commandHistory, setCommandHistory] = useState10([]);
   const imageStoreInitPromise = useRef3(null);
   const setStoreSession = useCliStore((state2) => state2.setSession);
   const enqueuePermissionPrompt = useCliStore((state2) => state2.enqueuePermissionPrompt);
@@ -15809,18 +16859,12 @@ function CliApp() {
       for (const error of contextResult.errors) {
         startupLog.push(`\u26A0\uFE0F  Context file error: ${error}`);
       }
-      let contextSection = contextResult.mergedContent ? `
-
-## Project Context
-
-Follow these project-specific instructions:
-
-${contextResult.mergedContent}` : "";
-      if (enableSkillTool) {
-        const commands = state.customCommandStore.getAllCommands();
-        contextSection += buildSkillsPromptSection(commands);
-      }
-      const cliSystemPrompt = buildCoreSystemPrompt(contextSection);
+      const cliSystemPrompt = buildCoreSystemPrompt({
+        contextContent: contextResult.mergedContent,
+        agentStore,
+        customCommands: state.customCommandStore.getAllCommands(),
+        enableSkillTool
+      });
       const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
       const agent = new ReActAgent({
         userId: config.userId,
@@ -15926,7 +16970,7 @@ ${contextResult.mergedContent}` : "";
     setStoreSession,
     setState
   ]);
-  useEffect6(() => {
+  useEffect7(() => {
     init();
   }, [init]);
   const handleCustomCommandMessage = async (fullTemplate, displayMessage) => {
@@ -16037,6 +17081,7 @@ ${contextResult.mergedContent}` : "";
             completion: 0,
             total: result.completionInfo.totalTokens
           },
+          creditsUsed: result.completionInfo.totalCredits,
           model: state.session.model,
           permissionDenied
         }
@@ -16048,6 +17093,7 @@ ${contextResult.mergedContent}` : "";
         metadata: {
           ...currentSession.metadata,
           totalTokens: currentSession.metadata.totalTokens + result.completionInfo.totalTokens,
+          totalCredits: (currentSession.metadata.totalCredits || 0) + (result.completionInfo.totalCredits || 0),
           toolCallCount: currentSession.metadata.toolCallCount + successfulToolCalls
         }
       };
@@ -16150,7 +17196,12 @@ ${contextResult.mergedContent}` : "";
       const tokenCounter2 = getTokenCounter();
       const contextWindow = tokenCounter2.getContextWindow(activeSession.model, state.availableModels);
       const threshold = contextWindow * 0.8;
-      const systemPrompt = buildCoreSystemPrompt(state.contextContent || "");
+      const systemPrompt = buildCoreSystemPrompt({
+        contextContent: state.contextContent,
+        agentStore: state.agentStore || void 0,
+        customCommands: state.customCommandStore.getAllCommands(),
+        enableSkillTool: config?.preferences.enableSkillTool !== false
+      });
       const contextUsage = tokenCounter2.countSessionTokens(activeSession, systemPrompt);
       if (contextUsage.totalTokens >= threshold) {
         console.log("\n\u26A0\uFE0F  Context window 80% full. Auto-compacting...\n");
@@ -16245,6 +17296,7 @@ ${contextResult.mergedContent}` : "";
             completion: 0,
             total: result.completionInfo.totalTokens
           },
+          creditsUsed: result.completionInfo.totalCredits,
           steps: result.steps.map(formatStep),
           // Complete history: thoughts, actions, observations
           permissionDenied
@@ -16258,6 +17310,7 @@ ${contextResult.mergedContent}` : "";
         metadata: {
           ...currentSession.metadata,
           totalTokens: currentSession.metadata.totalTokens + result.completionInfo.totalTokens,
+          totalCredits: (currentSession.metadata.totalCredits || 0) + (result.completionInfo.totalCredits || 0),
           toolCallCount: currentSession.metadata.toolCallCount + successfulToolCalls
         }
       };
@@ -16356,7 +17409,8 @@ ${contextResult.mergedContent}` : "";
             prompt: 0,
             completion: 0,
             total: result.completionInfo.totalTokens
-          }
+          },
+          creditsUsed: result.completionInfo.totalCredits
         }
       };
       const updatedSession = {
@@ -16366,6 +17420,7 @@ ${contextResult.mergedContent}` : "";
         metadata: {
           ...currentSession.metadata,
           totalTokens: currentSession.metadata.totalTokens + result.completionInfo.totalTokens,
+          totalCredits: (currentSession.metadata.totalCredits || 0) + (result.completionInfo.totalCredits || 0),
           toolCallCount: currentSession.metadata.toolCallCount + successfulToolCalls
         }
       };
@@ -17068,15 +18123,21 @@ No usage data available for the last ${USAGE_DAYS} days.`);
         }
         const tokenCounter2 = getTokenCounter();
         const contextWindow = tokenCounter2.getContextWindow(state.session.model, state.availableModels);
-        const corePromptTokens = tokenCounter2.countTokens(buildCoreSystemPrompt(""));
+        const corePromptTokens = tokenCounter2.countTokens(buildCoreSystemPrompt());
         const projectContextTokens = state.contextContent ? tokenCounter2.countTokens(state.contextContent) : 0;
         const commands = state.customCommandStore.getAllCommands();
         const skillsSection = buildSkillsPromptSection(commands);
         const skillsTokens = skillsSection ? tokenCounter2.countTokens(skillsSection) : 0;
+        const agentDirectoryTokens = state.agentStore ? tokenCounter2.countTokens(state.agentStore.getDirectoryContext()) : 0;
         const mcpTools = state.mcpManager?.getTools() || [];
         const mcpToolsTokens = tokenCounter2.countToolSchemaTokens(mcpTools);
         const mcpToolCount = state.mcpManager?.getToolCount() || [];
-        const systemPrompt = buildCoreSystemPrompt(state.contextContent || "");
+        const systemPrompt = buildCoreSystemPrompt({
+          contextContent: state.contextContent,
+          agentStore: state.agentStore || void 0,
+          customCommands: commands,
+          enableSkillTool: state.config?.preferences.enableSkillTool !== false
+        });
         const usage = tokenCounter2.countSessionTokens(state.session, systemPrompt);
         const totalWithTools = usage.totalTokens + mcpToolsTokens;
         const usagePercent = totalWithTools / contextWindow * 100;
@@ -17095,6 +18156,10 @@ No usage data available for the last ${USAGE_DAYS} days.`);
         if (commands.length > 0) {
           console.log(`  Skills Section:    ${skillsTokens.toLocaleString()} tokens (${commands.length} skills)`);
         }
+        if (agentDirectoryTokens > 0) {
+          const agentCount = state.agentStore?.getAgentCount() || 0;
+          console.log(`  Agent Directory:   ${agentDirectoryTokens.toLocaleString()} tokens (${agentCount} agents)`);
+        }
         if (mcpTools.length > 0) {
           console.log("\nMCP Tools:");
           console.log(`  Total:             ${mcpToolsTokens.toLocaleString()} tokens (${mcpTools.length} tools)`);
@@ -17499,6 +18564,7 @@ var isDevMode = import.meta.url.includes("/src/") || process.env.NODE_ENV === "d
 if (isDevMode) {
   logger.debug("\u{1F527} Running in development mode (using TypeScript source)\n");
 }
+warmFileCache();
 render(/* @__PURE__ */ React21.createElement(CliApp, null), {
   exitOnCtrlC: false
 });