@bike4mind/cli 0.2.28 → 0.2.29-cache-mcp-tools-schema-and-refactor.18897

package/dist/index.js

@@ -5,16 +5,17 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-VGYTNJXN.js";
+} from "./chunk-BPXPHQXQ.js";
 import {
-  ConfigStore
-} from "./chunk-23T2XGSZ.js";
+  ConfigStore,
+  logger
+} from "./chunk-LBTTUQJM.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
 } from "./chunk-TVW4ZESU.js";
-import "./chunk-JJBDHUGY.js";
-import "./chunk-ZEMWV6IR.js";
+import "./chunk-7DZY5UWH.js";
+import "./chunk-AQMAXCNK.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -26,7 +27,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-UNOJBVD2.js";
+} from "./chunk-BAYMEX5W.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -82,32 +83,37 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-XJRPAAUS.js";
+} from "./chunk-E6AOHC4U.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
@@ -320,65 +326,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`;
@@ -389,42 +383,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());
@@ -508,10 +572,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;
@@ -520,7 +601,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 = [
@@ -551,8 +632,9 @@ var COMMANDS = [
     args: "<name>"
   },
   {
-    name: "sessions",
-    description: "List saved sessions"
+    name: "resume",
+    description: "List and resume saved sessions",
+    aliases: ["sessions"]
   },
   {
     name: "config",
@@ -696,13 +778,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 {
@@ -843,14 +925,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 {
@@ -905,6 +987,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();
@@ -945,20 +1042,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);
@@ -967,14 +1064,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(
@@ -1112,11 +1227,11 @@ function InputPrompt({
     }
   };
   const getPlaceholder = () => {
-    if (disabled) return "Thinking...";
+    if (disabled) return "";
     if (isBashMode) return "Enter shell command to execute...";
     return "Type your message, /help for commands, @file to reference, or ! for bash";
   };
-  return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text5, { bold: true, color: isBashMode ? "yellow" : "cyan" }, isBashMode ? "$ " : "> "), /* @__PURE__ */ React5.createElement(
+  return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text5, { bold: true, color: disabled ? "gray" : isBashMode ? "yellow" : "cyan", dimColor: disabled }, isBashMode ? "$ " : "> "), /* @__PURE__ */ React5.createElement(
     CustomTextInput,
     {
       key: inputKey.current,
@@ -1139,7 +1254,7 @@ import React6 from "react";
 import { Box as Box5, Text as Text6 } from "ink";
 import Spinner from "ink-spinner";
 var ThoughtStream = React6.memo(function ThoughtStream2({ isThinking }) {
-  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", gap: 1 }, isThinking && /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, /* @__PURE__ */ React6.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React6.createElement(Text6, null, " Thinking...")));
+  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, isThinking && /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, /* @__PURE__ */ React6.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React6.createElement(Text6, null, " Thinking...")));
 });
 
 // src/components/AgentThinking.tsx
@@ -1212,13 +1327,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();
@@ -1231,7 +1346,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");
@@ -1264,16 +1379,37 @@ function PermissionPrompt({
     { label: "\u2713 Allow once", value: "allow-once" },
     { 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);
     onResponse(items[selectedIndex].value);
   }, [responded, onResponse, items, selectedIndex]);
+  const handleSelectIndex = useCallback(
+    (index) => {
+      if (responded) return;
+      setResponded(true);
+      onResponse(items[index].value);
+    },
+    [responded, onResponse, items]
+  );
   useInput3(
-    (_input, key) => {
+    (input, key) => {
       if (responded) return;
+      const num = parseInt(input, 10);
+      if (num >= 1 && num <= items.length) {
+        handleSelectIndex(num - 1);
+        return;
+      }
+      if (input.toLowerCase() === "y") {
+        handleSelectIndex(0);
+        return;
+      }
+      if (input.toLowerCase() === "n") {
+        handleSelectIndex(items.length - 1);
+        return;
+      }
       if (key.upArrow) {
         setSelectedIndex((i) => i > 0 ? i - 1 : items.length - 1);
       } else if (key.downArrow) {
@@ -1288,11 +1424,11 @@ function PermissionPrompt({
   const rawArgsString = typeof args === "string" ? args : JSON.stringify(args, null, 2);
   const argsString = rawArgsString.length > MAX_ARGS_LENGTH ? rawArgsString.slice(0, MAX_ARGS_LENGTH) + `
 ... (${rawArgsString.length - MAX_ARGS_LENGTH} more chars)` : rawArgsString;
-  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", borderStyle: "bold", borderColor: "yellow", padding: 1, marginY: 1 }, /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "yellow" }, "\u26A0\uFE0F Permission Required")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Tool: "), /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "cyan" }, toolName)), toolDescription && /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Action: "), /* @__PURE__ */ React10.createElement(Text9, null, toolDescription)), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { bold: true }, "Arguments:"), /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, argsString))), preview && /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { bold: true }, "Preview:"), /* @__PURE__ */ React10.createElement(Box9, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" }, renderDiffPreview(preview))), !canBeTrusted && /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { color: "red", dimColor: true }, "Note: This tool cannot be trusted due to its dangerous nature.")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, flexDirection: "column" }, items.map((item, index) => /* @__PURE__ */ React10.createElement(Box9, { key: item.value }, /* @__PURE__ */ React10.createElement(Text9, { color: index === selectedIndex ? "cyan" : void 0, bold: index === selectedIndex }, index === selectedIndex ? "\u276F " : "  ", item.label)))));
+  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", borderStyle: "bold", borderColor: "yellow", padding: 1, marginY: 1 }, /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "yellow" }, "\u26A0\uFE0F Permission Required")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Tool: "), /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "cyan" }, toolName)), toolDescription && /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Action: "), /* @__PURE__ */ React10.createElement(Text9, null, toolDescription)), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { bold: true }, "Arguments:"), /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, argsString))), preview && /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { bold: true }, "Preview:"), /* @__PURE__ */ React10.createElement(Box9, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" }, renderDiffPreview(preview))), !canBeTrusted && /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { color: "red", dimColor: true }, "Note: This tool cannot be trusted due to its dangerous nature.")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, flexDirection: "column" }, items.map((item, index) => /* @__PURE__ */ React10.createElement(Box9, { key: item.value }, /* @__PURE__ */ React10.createElement(Text9, { color: "cyan" }, index + 1, "."), /* @__PURE__ */ React10.createElement(Text9, { color: index === selectedIndex ? "cyan" : void 0, bold: index === selectedIndex }, index === selectedIndex ? " \u276F " : "   ", item.label)))), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Press 1-", items.length, ", y/n, or \u2191\u2193 + Enter")));
 }
 
 // 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 },
@@ -1437,10 +1573,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;
@@ -1707,38 +1843,26 @@ function truncateValue(value, maxLength) {
   }
   return str.slice(0, maxLength) + "...";
 }
-function getRoleDisplay(role) {
-  switch (role) {
-    case "user":
-      return { color: "cyan", label: "\u{1F464} You" };
-    case "system":
-      return { color: "gray", label: "\u2139\uFE0F  System" };
-    default:
-      return { color: "green", label: "\u{1F916} Assistant" };
-  }
-}
 var MessageItem = React14.memo(function MessageItem2({ message }) {
   const isUser = message.role === "user";
-  const isContinuation = message.metadata?.isContinuation === true;
-  const roleDisplay = getRoleDisplay(message.role);
-  return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", marginBottom: 1 }, !isContinuation && /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { bold: true, color: roleDisplay.color }, roleDisplay.label), isUser && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), isUser && message.content && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2 }, /* @__PURE__ */ React14.createElement(Text13, { backgroundColor: "whiteBright", color: "black" }, " ", message.content, " ")), !isUser && message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " ", "tools used, ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+  return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column" }, isUser && message.content && /* @__PURE__ */ React14.createElement(Box13, { marginBottom: 1 }, /* @__PURE__ */ React14.createElement(Text13, { backgroundColor: "whiteBright", color: "black" }, "\u276F ", message.content, " ")), !isUser && message.metadata?.steps && message.metadata.steps.filter((s) => ["thought", "action"].includes(s.type)).length > 0 && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2, flexDirection: "column", marginBottom: 1 }, message.metadata.steps.map((step, idx) => {
     if (step.type === "thought") {
-      return /* @__PURE__ */ React14.createElement(Box13, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   ${step.content}`));
+      return /* @__PURE__ */ React14.createElement(Box13, { key: idx, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   ${step.content}`));
     }
     if (step.type === "action") {
       const toolName = step.metadata?.toolName || "unknown";
       const toolInput = step.metadata?.toolInput;
       const observationStep = message.metadata?.steps?.[idx + 1];
       const result = observationStep?.type === "observation" ? observationStep.content : null;
-      return /* @__PURE__ */ React14.createElement(Box13, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   Input: ${truncateValue(toolInput, 100)}`), result && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   Result: ${truncateValue(result, 200)}`));
+      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, marginTop: message.metadata?.steps?.length ? 1 : 0 }, 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"];
@@ -1749,7 +1873,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);
@@ -1779,9 +1903,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}"` };
@@ -1872,6 +2000,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);
@@ -1882,7 +2011,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();
@@ -1894,7 +2023,7 @@ function App({
       toggleAutoAcceptEdits();
     }
   });
-  const [isBashMode, setIsBashMode] = useState5(false);
+  const [isBashMode, setIsBashMode] = useState6(false);
   const handleSubmit = React15.useCallback(
     async (input) => {
       const trimmed = input.trim();
@@ -1957,7 +2086,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
@@ -2033,12 +2170,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") {
@@ -2102,12 +2239,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") {
@@ -2163,7 +2300,7 @@ function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
       {
         items,
         onSelect: handleSelectionSelect,
-        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React19.createElement(Box18, null, /* @__PURE__ */ React19.createElement(Text18, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React19.createElement(Box18, null, /* @__PURE__ */ React19.createElement(Text18, { color: isSelected ? "cyan" : void 0 }, label))
       }
     ), /* @__PURE__ */ React19.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
   }
@@ -2176,13 +2313,13 @@ function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
     {
       items: confirmationItems,
       onSelect: handleConfirmationSelect,
-      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React19.createElement(Box18, null, /* @__PURE__ */ React19.createElement(Text18, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React19.createElement(Box18, null, /* @__PURE__ */ React19.createElement(Text18, { color: isSelected ? "cyan" : void 0 }, label))
     }
   ), /* @__PURE__ */ React19.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
 }
 
 // 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";
@@ -2299,11 +2436,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 {
@@ -2338,7 +2475,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);
@@ -2359,12 +2496,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
@@ -2385,7 +2522,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) {
@@ -2397,7 +2534,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);
@@ -2435,7 +2572,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) => {
@@ -2470,7 +2607,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;
@@ -2509,19 +2646,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) {
@@ -2623,271 +2760,13 @@ var CommandHistoryStore = class {
 };
 
 // src/storage/CustomCommandStore.ts
-import fs6 from "fs/promises";
+import fs5 from "fs/promises";
 import path6 from "path";
-import os2 from "os";
+import os from "os";
 
 // src/utils/commandParser.ts
 import matter from "gray-matter";
 import { z } from "zod";
-
-// src/utils/Logger.ts
-import fs5 from "fs/promises";
-import path5 from "path";
-import os from "os";
-var Logger2 = class _Logger {
-  constructor() {
-    this.logFilePath = null;
-    this.sessionId = null;
-    this.fileLoggingEnabled = true;
-    this.consoleVerbose = false;
-  }
-  static {
-    this.instance = null;
-  }
-  static getInstance() {
-    if (!_Logger.instance) {
-      _Logger.instance = new _Logger();
-    }
-    return _Logger.instance;
-  }
-  /**
-   * Initialize the logger with a session ID
-   */
-  async initialize(sessionId) {
-    this.sessionId = sessionId;
-    const debugDir = path5.join(os.homedir(), ".bike4mind", "debug");
-    await fs5.mkdir(debugDir, { recursive: true });
-    this.logFilePath = path5.join(debugDir, `${sessionId}.txt`);
-    await this.writeToFile("INFO", "=== CLI SESSION START ===");
-  }
-  /**
-   * Set whether verbose console logging is enabled
-   */
-  setVerbose(enabled) {
-    this.consoleVerbose = enabled;
-  }
-  /**
-   * Set whether file logging is enabled
-   */
-  setFileLoggingEnabled(enabled) {
-    this.fileLoggingEnabled = enabled;
-  }
-  /**
-   * DEBUG level - verbose-only console, always file
-   */
-  debug(message) {
-    this.writeToFile("DEBUG", message).catch(() => {
-    });
-    if (this.consoleVerbose) {
-      console.log(message);
-    }
-  }
-  /**
-   * INFO level - always shown to user
-   */
-  info(message) {
-    this.writeToFile("INFO", message).catch(() => {
-    });
-    console.log(message);
-  }
-  /**
-   * WARN level - always shown to user
-   */
-  warn(message) {
-    this.writeToFile("WARN", message).catch(() => {
-    });
-    console.warn(message);
-  }
-  /**
-   * ERROR level - always shown to user
-   */
-  error(message, err) {
-    this.writeToFile("ERROR", message).catch(() => {
-    });
-    if (err) {
-      this.logErrorDetailsToFile(err).catch(() => {
-      });
-    }
-    console.error(message);
-  }
-  /**
-   * Write log entry to file
-   */
-  async writeToFile(level, message) {
-    if (!this.fileLoggingEnabled || !this.logFilePath) {
-      return;
-    }
-    try {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
-      const logEntry = `[${timestamp}] [${level}] ${message}
-`;
-      await fs5.appendFile(this.logFilePath, logEntry, "utf-8");
-    } catch (error) {
-      console.error("File logging failed:", error);
-    }
-  }
-  /**
-   * Log error details to file
-   */
-  async logErrorDetailsToFile(err) {
-    if (!this.fileLoggingEnabled || !this.logFilePath) {
-      return;
-    }
-    try {
-      if (err && typeof err === "object" && "response" in err && err.response) {
-        const response = err.response;
-        const config = err && typeof err === "object" && "config" in err ? err.config : void 0;
-        await this.writeToFile("ERROR", `  Status: ${response.status} ${response.statusText || ""}`);
-        await this.writeToFile("ERROR", `  URL: ${config?.url || "unknown"}`);
-        await this.writeToFile("ERROR", `  Headers: ${this.safeStringify(response.headers)}`);
-        if (response.data) {
-          const errorText = this.extractErrorMessage(response.data);
-          if (errorText.trim().startsWith("<!DOCTYPE") || errorText.trim().startsWith("<html")) {
-            await this.writeToFile("ERROR", `  Response Type: HTML Error Page`);
-            const parsedError = this.parseHtmlError(errorText);
-            if (parsedError) {
-              await this.writeToFile("ERROR", `  Error Message: ${parsedError}`);
-            }
-            await this.writeToFile("ERROR", `  Raw HTML: ${this.truncate(errorText, 1e3)}`);
-          } else {
-            const preview = this.truncate(errorText, 500);
-            await this.writeToFile("ERROR", `  Response: ${preview}`);
-          }
-        } else {
-          await this.writeToFile("ERROR", `  Response: (no data)`);
-        }
-      }
-      if (err && typeof err === "object" && "stack" in err && typeof err.stack === "string") {
-        const stackLines = err.stack.split("\n").slice(0, 5).join("\n    ");
-        await this.writeToFile("ERROR", `  Stack: ${stackLines}`);
-      } else if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
-        await this.writeToFile("ERROR", `  Message: ${err.message}`);
-      }
-    } catch (error) {
-    }
-  }
-  /**
-   * Safely stringify object, handling circular references
-   */
-  safeStringify(obj) {
-    try {
-      return JSON.stringify(obj);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("circular")) {
-        try {
-          const seen = /* @__PURE__ */ new WeakSet();
-          return JSON.stringify(obj, (key, value) => {
-            if (typeof value === "object" && value !== null) {
-              if (seen.has(value)) {
-                return "[Circular]";
-              }
-              seen.add(value);
-            }
-            return value;
-          });
-        } catch {
-          return "[Unable to stringify]";
-        }
-      }
-      return "[Stringify error]";
-    }
-  }
-  /**
-   * Extract readable text from error response data
-   */
-  extractErrorMessage(data) {
-    if (Buffer.isBuffer(data)) {
-      return data.toString("utf-8");
-    }
-    if (typeof data === "string") {
-      return data;
-    }
-    if (data && typeof data === "object" && "_readableState" in data && data._readableState && typeof data._readableState === "object" && "buffer" in data._readableState && Array.isArray(data._readableState.buffer) && data._readableState.buffer.length > 0) {
-      const chunks = [];
-      for (const chunk of data._readableState.buffer) {
-        if (chunk && typeof chunk === "object" && "type" in chunk && chunk.type === "Buffer" && "data" in chunk && Array.isArray(chunk.data)) {
-          chunks.push(Buffer.from(chunk.data));
-        } else if (Buffer.isBuffer(chunk)) {
-          chunks.push(chunk);
-        } else if (chunk && typeof chunk === "object" && "data" in chunk) {
-          if (Buffer.isBuffer(chunk.data)) {
-            chunks.push(chunk.data);
-          } else if (Array.isArray(chunk.data)) {
-            chunks.push(Buffer.from(chunk.data));
-          }
-        }
-      }
-      if (chunks.length > 0) {
-        return Buffer.concat(chunks).toString("utf-8");
-      }
-    }
-    return this.safeStringify(data);
-  }
-  /**
-   * Parse HTML error page to extract error message
-   */
-  parseHtmlError(html) {
-    const titleMatch = html.match(/<title>(.*?)<\/title>/i);
-    const h1Match = html.match(/<h1>(.*?)<\/h1>/i);
-    const bodyMatch = html.match(/<body[^>]*>(.*?)<\/body>/is);
-    if (titleMatch && titleMatch[1] !== "Error") {
-      return titleMatch[1].trim();
-    }
-    if (h1Match) {
-      return h1Match[1].trim();
-    }
-    if (bodyMatch) {
-      const text = bodyMatch[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-      return text.substring(0, 200);
-    }
-    return null;
-  }
-  /**
-   * Truncate string to max length with ellipsis
-   */
-  truncate(str, maxLength) {
-    if (str.length <= maxLength) {
-      return str;
-    }
-    return str.substring(0, maxLength) + "... [truncated]";
-  }
-  /**
-   * Format bytes to human-readable size
-   */
-  formatBytes(bytes) {
-    if (bytes === 0) return "0 B";
-    const k = 1024;
-    const sizes = ["B", "KB", "MB", "GB"];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
-  }
-  /**
-   * Clean up old debug logs (older than 30 days)
-   */
-  async cleanupOldLogs() {
-    if (!this.fileLoggingEnabled) return;
-    try {
-      const debugDir = path5.join(os.homedir(), ".bike4mind", "debug");
-      const files = await fs5.readdir(debugDir);
-      const now = Date.now();
-      const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
-      for (const file of files) {
-        const filePath = path5.join(debugDir, file);
-        const stats = await fs5.stat(filePath);
-        if (stats.mtime.getTime() < thirtyDaysAgo) {
-          await fs5.unlink(filePath);
-        }
-      }
-    } catch (error) {
-      console.error("Failed to cleanup old logs:", error);
-    }
-  }
-};
-var logger = Logger2.getInstance();
-logger.setVerbose(process.env.B4M_VERBOSE === "1");
-
-// src/utils/commandParser.ts
 var flexibleString = z.union([z.string(), z.array(z.string())]).transform((val) => Array.isArray(val) ? val.join(" ") : val).optional();
 var flexibleStringArray = z.union([z.string(), z.array(z.string())]).transform((val) => Array.isArray(val) ? val : [val]).optional();
 function needsQuoting(value) {
@@ -3042,7 +2921,7 @@ function extractCommandName(filename) {
 var CustomCommandStore = class {
   constructor(projectRoot) {
     this.commands = /* @__PURE__ */ new Map();
-    const home = os2.homedir();
+    const home = os.homedir();
     const root = projectRoot || process.cwd();
     this.globalCommandsDirs = [
       path6.join(home, ".bike4mind", "commands"),
@@ -3077,7 +2956,7 @@ var CustomCommandStore = class {
    */
   async loadCommandsFromDirectory(directory, source) {
     try {
-      const stats = await fs6.stat(directory);
+      const stats = await fs5.stat(directory);
       if (!stats.isDirectory()) {
         return;
       }
@@ -3110,7 +2989,7 @@ var CustomCommandStore = class {
   async findCommandFiles(directory) {
     const files = [];
     try {
-      const entries = await fs6.readdir(directory, { withFileTypes: true });
+      const entries = await fs5.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path6.join(directory, entry.name);
         if (entry.isDirectory()) {
@@ -3139,7 +3018,7 @@ var CustomCommandStore = class {
       console.warn(`Invalid command filename: ${filename} (must end with .md and have valid name)`);
       return;
     }
-    const fileContent = await fs6.readFile(filePath, "utf-8");
+    const fileContent = await fs5.readFile(filePath, "utf-8");
     const command = parseCommandFile(fileContent, filePath, commandName, source);
     this.commands.set(commandName, command);
   }
@@ -3214,14 +3093,14 @@ var CustomCommandStore = class {
   async createCommandFile(name, isGlobal = false) {
     const targetDir = isGlobal ? this.globalCommandsDirs[0] : this.projectCommandsDirs[0];
     const filePath = path6.join(targetDir, `${name}.md`);
-    const fileExists = await fs6.access(filePath).then(
+    const fileExists = await fs5.access(filePath).then(
       () => true,
       () => false
     );
     if (fileExists) {
       throw new Error(`Command file already exists: ${filePath}`);
     }
-    await fs6.mkdir(targetDir, { recursive: true });
+    await fs5.mkdir(targetDir, { recursive: true });
     const template = `---
 description: ${name} command
 argument-hint: [args]
@@ -3236,7 +3115,7 @@ You can use:
 - $1, $2, etc. for positional arguments
 - @filename for file references
 `;
-    await fs6.writeFile(filePath, template, "utf-8");
+    await fs5.writeFile(filePath, template, "utf-8");
     return filePath;
   }
 };
@@ -3369,6 +3248,7 @@ var ReActAgent = class extends EventEmitter {
     super();
     this.steps = [];
     this.totalTokens = 0;
+    this.totalCredits = 0;
     this.toolCallCount = 0;
     this.observationQueue = [];
     this.context = {
@@ -3388,6 +3268,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;
@@ -3424,6 +3305,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
@@ -3459,6 +3341,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",
@@ -3572,6 +3457,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
@@ -3589,6 +3475,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
@@ -3717,18 +3604,23 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
   async executeToolWithQueueFallback(toolUse) {
     const queuedObs = this.observationQueue.find((obs) => obs.toolId === getToolId(toolUse));
     if (queuedObs) {
-      const result2 = queuedObs.result;
+      const result = queuedObs.result;
       const index = this.observationQueue.indexOf(queuedObs);
       this.observationQueue.splice(index, 1);
-      return typeof result2 === "string" ? result2 : JSON.stringify(result2);
+      return typeof result === "string" ? result : JSON.stringify(result);
     }
     const tool = this.context.tools.find((t) => t.toolSchema.name === toolUse.name);
     if (!tool) {
-      throw new Error(`Tool ${toolUse.name} not found in agent context`);
+      return `Error: Tool ${toolUse.name} not found in agent context`;
+    }
+    try {
+      const params = this.parseToolArguments(toolUse.arguments);
+      const result = await tool.toolFn(params);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return `Error: ${message}`;
     }
-    const params = this.parseToolArguments(toolUse.arguments);
-    const result = await tool.toolFn(params);
-    return typeof result === "string" ? result : JSON.stringify(result);
   }
   /**
    * Build and append tool call/result messages for the conversation history
@@ -3806,6 +3698,7 @@ var DEFAULT_TOOL_CATEGORIES = {
   grep_search: "prompt_default",
   glob_files: "prompt_default",
   get_file_tree: "prompt_default",
+  get_file_structure: "prompt_default",
   git_status: "prompt_default",
   git_diff: "prompt_default",
   git_log: "prompt_default",
@@ -3828,6 +3721,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";
@@ -3838,7 +3775,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:
@@ -3868,12 +3836,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:
@@ -3930,7 +3894,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
@@ -4380,7 +4344,7 @@ import { GoogleGenerativeAI } from "@google/generative-ai";
 import OpenAI2 from "openai";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
-import fs7, { unlinkSync } from "fs";
+import fs6, { unlinkSync } from "fs";
 import yauzl from "yauzl";
 import axios3 from "axios";
 
@@ -6059,8 +6023,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) {
@@ -7386,8 +7350,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;
@@ -9328,8 +9292,8 @@ var planetVisibilityTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
-import { promises as fs8 } from "fs";
-import { existsSync as existsSync3, statSync as statSync4 } from "fs";
+import { promises as fs7 } from "fs";
+import { existsSync as existsSync4, statSync as statSync4 } from "fs";
 import path7 from "path";
 var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 async function readFileContent(params) {
@@ -9340,7 +9304,7 @@ async function readFileContent(params) {
   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);
@@ -9354,7 +9318,7 @@ async function readFileContent(params) {
   if (isBinary && encoding === "utf-8") {
     throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
   }
-  const content = await fs8.readFile(resolvedPath, encoding);
+  const content = await fs7.readFile(resolvedPath, encoding);
   if (typeof content === "string") {
     const lines = content.split("\n");
     const totalLines = lines.length;
@@ -9392,7 +9356,7 @@ ${content}`;
 }
 async function checkIfBinary(filePath) {
   const buffer = Buffer.alloc(8192);
-  const fd = await fs8.open(filePath, "r");
+  const fd = await fs7.open(filePath, "r");
   try {
     const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
     const chunk = buffer.slice(0, bytesRead);
@@ -9453,8 +9417,8 @@ var fileReadTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
-import { promises as fs9 } from "fs";
-import { existsSync as existsSync4 } from "fs";
+import { promises as fs8 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import path8 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
@@ -9464,14 +9428,14 @@ async function createFile(params) {
   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 = path8.dirname(resolvedPath);
-    await fs9.mkdir(dir, { recursive: true });
+    await fs8.mkdir(dir, { recursive: true });
   }
-  await fs9.writeFile(resolvedPath, content, "utf-8");
-  const stats = await fs9.stat(resolvedPath);
+  await fs8.writeFile(resolvedPath, content, "utf-8");
+  const stats = await fs8.stat(resolvedPath);
   const lines = content.split("\n").length;
   return `File ${action} successfully: ${filePath}
 Size: ${stats.size} bytes
@@ -9482,7 +9446,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync4(path8.resolve(process.cwd(), path8.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
@@ -9525,7 +9489,7 @@ var createFileTool = {
 import { glob } from "glob";
 import { stat } from "fs/promises";
 import path9 from "path";
-var DEFAULT_IGNORE_PATTERNS2 = [
+var DEFAULT_IGNORE_PATTERNS = [
   "**/node_modules/**",
   "**/.git/**",
   "**/dist/**",
@@ -9544,7 +9508,7 @@ async function findFiles(params) {
   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,
@@ -9825,8 +9789,8 @@ var grepSearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
-import { promises as fs10 } from "fs";
-import { existsSync as existsSync5, statSync as statSync5 } from "fs";
+import { promises as fs9 } from "fs";
+import { existsSync as existsSync6, statSync as statSync5 } from "fs";
 import path11 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
@@ -9836,7 +9800,7 @@ async function deleteFile(params) {
   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);
@@ -9846,10 +9810,10 @@ async function deleteFile(params) {
     throw new Error(`Path is a directory: ${filePath}. Use recursive=true to delete directories and their contents.`);
   }
   if (isDirectory) {
-    await fs10.rm(resolvedPath, { recursive: true, force: true });
+    await fs9.rm(resolvedPath, { recursive: true, force: true });
     return `Directory deleted successfully: ${filePath}`;
   } else {
-    await fs10.unlink(resolvedPath);
+    await fs9.unlink(resolvedPath);
     return `File deleted successfully: ${filePath}
 Size: ${size} bytes`;
   }
@@ -9860,7 +9824,7 @@ var deleteFileTool = {
     toolFn: async (value) => {
       const params = value;
       const resolvedPath = path11.resolve(process.cwd(), path11.normalize(params.path));
-      const isDirectory = existsSync5(resolvedPath) && statSync5(resolvedPath).isDirectory();
+      const isDirectory = existsSync6(resolvedPath) && statSync5(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -10359,8 +10323,8 @@ BLOCKED OPERATIONS:
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editLocalFile/index.js
-import { promises as fs11 } from "fs";
-import { existsSync as existsSync6 } from "fs";
+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) {
@@ -10391,10 +10355,10 @@ async function editLocalFile(params) {
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot edit files outside of current working directory`);
   }
-  if (!existsSync6(resolvedPath)) {
+  if (!existsSync7(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const currentContent = await fs11.readFile(resolvedPath, "utf-8");
+  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}"`);
@@ -10404,7 +10368,7 @@ async function editLocalFile(params) {
     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 fs11.writeFile(resolvedPath, newContent, "utf-8");
+  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
@@ -10979,7 +10943,9 @@ var QuestStartBodySchema = z139.object({
     fabFileIds: z139.array(z139.string()).optional()
   })).optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z139.string().optional()
+  timezone: z139.string().optional(),
+  /** Pre-fetched API key table from invoke phase — avoids redundant DB call in process (#6616 P1-a) */
+  apiKeyTable: z139.record(z139.string(), z139.string().nullable()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/StatusManager.js
@@ -11580,10 +11546,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;
@@ -11621,7 +11587,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));
@@ -11915,21 +11881,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" };
   }
 };
@@ -12335,7 +12301,7 @@ function getEnvironmentName(configApiConfig) {
 }
 
 // src/utils/contextLoader.ts
-import * as fs12 from "fs";
+import * as fs11 from "fs";
 import * as path14 from "path";
 import { homedir as homedir3 } from "os";
 var CONTEXT_FILE_SIZE_LIMIT = 100 * 1024;
@@ -12359,7 +12325,7 @@ function formatFileSize2(bytes) {
 function tryReadContextFile(dir, filename, source) {
   const filePath = path14.join(dir, filename);
   try {
-    const stats = fs12.lstatSync(filePath);
+    const stats = fs11.lstatSync(filePath);
     if (stats.isDirectory()) {
       return null;
     }
@@ -12373,7 +12339,7 @@ function tryReadContextFile(dir, filename, source) {
         error: `${source === "global" ? "Global" : "Project"} ${filename} exceeds 100KB limit (${formatFileSize2(stats.size)})`
       };
     }
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs11.readFileSync(filePath, "utf-8");
     return {
       filename,
       content,
@@ -12697,7 +12663,7 @@ function substituteArguments(template, args) {
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
 import path15 from "path";
-import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
@@ -12734,7 +12700,6 @@ var MCPClient = class {
       if (this.customCommand && this.customCommand.trim() !== "") {
         command = this.customCommand;
         args = this.customArgs ?? [];
-        console.log(`[MCP] Using external command for ${this.serverName}: ${command} ${args.join(" ")}`);
       } else {
         const root = process.env.INIT_CWD || process.cwd();
         const candidatePaths = [
@@ -12750,7 +12715,7 @@ var MCPClient = class {
           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);
@@ -13310,6 +13275,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";
@@ -13461,11 +13434,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") {
@@ -13492,11 +13462,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) {
@@ -13563,7 +13530,7 @@ var ServerLlmBackend = class {
         logger.info("\u26A0\uFE0F  Using fallback model list (no CLI-compatible models available)");
         return this.getFallbackModels();
       }
-      logger.info(`\u{1F4CB} Loaded ${filteredModels.length} models from server`);
+      logger.debug(`\u{1F4CB} Loaded ${filteredModels.length} models from server`);
       return filteredModels;
     } catch (error) {
       logger.warn(
@@ -13801,7 +13768,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.28",
+  version: "0.2.29-cache-mcp-tools-schema-and-refactor.18897+4545eccff",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -13872,10 +13839,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",
@@ -13891,15 +13861,18 @@ 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",
     speakeasy: "^2.0.0",
     tiktoken: "^1.0.16",
+    "tree-sitter-wasms": "^0.1.13",
     turndown: "^7.2.0",
     unpdf: "^0.10.0",
     uuid: "^9.0.1",
     voyageai: "^0.0.4",
+    "web-tree-sitter": "0.25.10",
     xlsx: "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
     yargs: "^17.7.2",
     yauzl: "^3.1.3",
@@ -13909,14 +13882,15 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.50.0",
-    "@bike4mind/mcp": "1.29.0",
-    "@bike4mind/services": "2.48.0",
-    "@bike4mind/utils": "2.5.0",
+    "@bike4mind/common": "2.50.1-cache-mcp-tools-schema-and-refactor.18897+4545eccff",
+    "@bike4mind/mcp": "1.29.1-cache-mcp-tools-schema-and-refactor.18897+4545eccff",
+    "@bike4mind/services": "2.48.1-cache-mcp-tools-schema-and-refactor.18897+4545eccff",
+    "@bike4mind/utils": "2.5.1-cache-mcp-tools-schema-and-refactor.18897+4545eccff",
     "@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",
@@ -13929,7 +13903,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "28d4afd2bd097efcd751a14cbda1eee68cae2ad2"
+  gitHead: "4545eccff3e4227edc2e97613d9d12607cac9530"
 };
 
 // src/config/constants.ts
@@ -14166,50 +14140,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) {
@@ -14422,9 +14352,9 @@ var SubagentOrchestrator = class {
 };
 
 // src/agents/AgentStore.ts
-import fs13 from "fs/promises";
+import fs12 from "fs/promises";
 import path16 from "path";
-import os3 from "os";
+import os2 from "os";
 import matter2 from "gray-matter";
 var FULL_MODEL_ID_PREFIXES = [
   "claude-",
@@ -14570,7 +14500,7 @@ var AgentStore = class {
   constructor(builtinDir, projectRoot) {
     this.agents = /* @__PURE__ */ new Map();
     const root = projectRoot || process.cwd();
-    const home = os3.homedir();
+    const home = os2.homedir();
     this.builtinAgentsDir = builtinDir;
     this.globalB4MAgentsDir = path16.join(home, ".bike4mind", "agents");
     this.globalClaudeAgentsDir = path16.join(home, ".claude", "agents");
@@ -14599,7 +14529,7 @@ var AgentStore = class {
    */
   async loadAgentsFromDirectory(directory, source) {
     try {
-      const stats = await fs13.stat(directory);
+      const stats = await fs12.stat(directory);
       if (!stats.isDirectory()) {
         return;
       }
@@ -14627,7 +14557,7 @@ var AgentStore = class {
   async findAgentFiles(directory) {
     const files = [];
     try {
-      const entries = await fs13.readdir(directory, { withFileTypes: true });
+      const entries = await fs12.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path16.join(directory, entry.name);
         if (entry.isDirectory()) {
@@ -14646,7 +14576,7 @@ var AgentStore = class {
    * Parse a single agent markdown file
    */
   async parseAgentFile(filePath, source) {
-    const content = await fs13.readFile(filePath, "utf-8");
+    const content = await fs12.readFile(filePath, "utf-8");
     const { data: frontmatter, content: body } = matter2(content);
     const parsed = AgentFrontmatterSchema.parse(frontmatter);
     const name = path16.basename(filePath, ".md");
@@ -14731,14 +14661,14 @@ var AgentStore = class {
     const targetDir = isGlobal ? useClaude ? this.globalClaudeAgentsDir : this.globalB4MAgentsDir : useClaude ? this.projectClaudeAgentsDir : this.projectB4MAgentsDir;
     const filePath = path16.join(targetDir, `${name}.md`);
     try {
-      await fs13.access(filePath);
+      await fs12.access(filePath);
       throw new Error(`Agent file already exists: ${filePath}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
     }
-    await fs13.mkdir(targetDir, { recursive: true });
+    await fs12.mkdir(targetDir, { recursive: true });
     const template = `---
 description: ${name} agent description
 model: claude-3-5-haiku-20241022
@@ -14773,7 +14703,7 @@ You are a ${name} specialist. Your job is to [describe primary task].
 ## Output Format
 Describe the expected output format here.
 `;
-    await fs13.writeFile(filePath, template, "utf-8");
+    await fs12.writeFile(filePath, template, "utf-8");
     return filePath;
   }
   /**
@@ -14790,6 +14720,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
@@ -15609,6 +15554,99 @@ function createFindDefinitionTool() {
   };
 }
 
+// src/tools/getFileStructure/index.ts
+import { existsSync as existsSync10, promises as fs13, statSync as statSync6 } from "fs";
+import path18 from "path";
+
+// src/tools/getFileStructure/formatter.ts
+var SECTIONS = [
+  { title: "IMPORTS", kind: "import", exportable: false },
+  { title: "EXPORTS", kind: "export", exportable: false },
+  { title: "FUNCTIONS", kind: "function", exportable: true },
+  { title: "CLASSES", kind: "class", exportable: true },
+  { title: "INTERFACES", kind: "interface", exportable: true },
+  { title: "TYPES", kind: "type", exportable: true },
+  { title: "ENUMS", kind: "enum", exportable: true }
+];
+function formatStructureOutput(filePath, items, fileSize, lineCount) {
+  const sizeStr = fileSize < 1024 ? `${fileSize} B` : `${(fileSize / 1024).toFixed(1)} KB`;
+  const lines = [`File: ${filePath} (${sizeStr}, ${lineCount} lines)`, ""];
+  for (const section of SECTIONS) {
+    const sectionItems = items.filter((i) => i.kind === section.kind);
+    formatSection(lines, section.title, sectionItems, (item) => {
+      const prefix = section.exportable && item.exported ? "export " : "";
+      return `L${item.line}: ${prefix}${item.name}`;
+    });
+  }
+  return lines.join("\n").trimEnd();
+}
+function formatSection(lines, title, items, format) {
+  lines.push(`${title} (${items.length}):`);
+  if (items.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const item of items) {
+      lines.push(`  ${format(item)}`);
+    }
+  }
+  lines.push("");
+}
+
+// src/tools/getFileStructure/index.ts
+var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
+function createGetFileStructureTool() {
+  return {
+    toolFn: async (value) => {
+      const params = value;
+      try {
+        const cwd = process.cwd();
+        const resolvedPath = path18.resolve(cwd, params.path);
+        if (!resolvedPath.startsWith(cwd)) {
+          return "Error: Access denied - cannot read files outside of current working directory";
+        }
+        if (!existsSync10(resolvedPath)) {
+          return `Error: File not found: ${params.path}`;
+        }
+        const stats = statSync6(resolvedPath);
+        if (stats.isDirectory()) {
+          return `Error: Path is a directory, not a file: ${params.path}`;
+        }
+        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 = path18.extname(resolvedPath).toLowerCase();
+        const { getLanguageForExtension, parseFileStructure, getSupportedLanguages } = await import("./treeSitterEngine-4SGFQDY3.js");
+        const languageId = getLanguageForExtension(ext);
+        if (!languageId) {
+          const supported = getSupportedLanguages();
+          return `Error: Unsupported file type "${ext}". Supported languages: ${supported.join(", ")}`;
+        }
+        const sourceCode = await fs13.readFile(resolvedPath, "utf-8");
+        const lineCount = sourceCode.split("\n").length;
+        const items = await parseFileStructure(sourceCode, languageId);
+        return formatStructureOutput(params.path, items, stats.size, lineCount);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return `Error analyzing file structure: ${errorMessage}`;
+      }
+    },
+    toolSchema: {
+      name: "get_file_structure",
+      description: "Extract the high-level structure of a source file (imports, exports, functions, classes, interfaces, types) using AST parsing. Returns a concise outline with line numbers. Much more efficient than file_read when you only need to understand what a file contains or exports. Use this before file_read to decide which parts of a large file to read.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the source file (relative to cwd or absolute within cwd). Supported: .ts, .tsx, .js, .jsx, .mjs, .cjs, .py"
+          }
+        },
+        required: ["path"]
+      }
+    }
+  };
+}
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -15623,7 +15661,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(),
@@ -15646,9 +15684,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);
@@ -15725,6 +15763,7 @@ function CliApp() {
   });
   const init = useCallback2(async () => {
     try {
+      const startupLog = [];
       const config = await state.configStore.load();
       const history = await state.commandHistoryStore.load();
       setCommandHistory(history);
@@ -15732,7 +15771,7 @@ function CliApp() {
         await state.customCommandStore.loadCommands();
         const customCommandCount = state.customCommandStore.getCommandCount();
         if (customCommandCount > 0) {
-          console.log(`\u{1F4DD} Loaded ${customCommandCount} custom command${customCommandCount !== 1 ? "s" : ""}`);
+          startupLog.push(`\u{1F4DD} Loaded ${customCommandCount} custom command${customCommandCount !== 1 ? "s" : ""}`);
         }
       } catch (error) {
         console.warn("Failed to load custom commands:", error instanceof Error ? error.message : String(error));
@@ -15753,7 +15792,7 @@ function CliApp() {
         } else {
           isAuthenticated = true;
           const daysUntilExpiry = Math.floor((expiresAt.getTime() - Date.now()) / (1e3 * 60 * 60 * 24));
-          console.log(`\u2705 Authenticated (expires in ${daysUntilExpiry} day${daysUntilExpiry !== 1 ? "s" : ""})`);
+          startupLog.push(`\u2705 Authenticated (expires in ${daysUntilExpiry} day${daysUntilExpiry !== 1 ? "s" : ""})`);
         }
       }
       if (!isAuthenticated) {
@@ -15867,22 +15906,23 @@ function CliApp() {
         state.configStore,
         apiClient
       );
-      console.log(`\u{1F6E0}\uFE0F Loaded ${b4mTools2.length} B4M tool(s)`);
+      startupLog.push(`\u{1F6E0}\uFE0F Loaded ${b4mTools2.length} B4M tool(s)`);
       const mcpManager = new McpManager(config);
       await mcpManager.initialize();
       const mcpTools = mcpManager.getTools();
       if (mcpTools.length > 0) {
-        const toolNames = mcpTools.map((t) => t.toolSchema.name).join(", ");
-        console.log(`\u{1F4E1} Loaded ${mcpTools.length} MCP tool(s): ${toolNames}`);
+        const toolCountByServer = mcpManager.getToolCount();
+        const serverSummaries = toolCountByServer.map((s) => `${s.serverName} (${s.count})`).join(", ");
+        startupLog.push(`\u{1F4E1} Loaded ${mcpTools.length} MCP tool(s): ${serverSummaries}`);
       } else {
-        console.log(`\u{1F4E1} No MCP tools loaded`);
+        startupLog.push(`\u{1F4E1} No MCP tools loaded`);
       }
       const builtinAgentsDir = new URL("./agents/defaults/", import.meta.url).pathname;
       const agentProjectDir = state.configStore.getProjectConfigDir();
       const agentStore = new AgentStore(builtinAgentsDir, agentProjectDir || process.cwd());
       await agentStore.loadAgents();
       const agentSummary = agentStore.getSummary();
-      console.log(
+      startupLog.push(
         `\u{1F916} Loaded ${agentSummary.total} agent(s): ${agentSummary.builtin} built-in, ${agentSummary.global} global, ${agentSummary.project} project`
       );
       const orchestrator = new SubagentOrchestrator({
@@ -15917,18 +15957,25 @@ function CliApp() {
         sessionId: newSession.id
       }) : null;
       const findDefinitionTool = createFindDefinitionTool();
-      const cliTools = [agentDelegateTool, ...backgroundTools, writeTodosTool, findDefinitionTool];
+      const getFileStructureTool = createGetFileStructureTool();
+      const cliTools = [
+        agentDelegateTool,
+        ...backgroundTools,
+        writeTodosTool,
+        findDefinitionTool,
+        getFileStructureTool
+      ];
       if (skillTool) {
         cliTools.push(skillTool);
       }
       const allTools = [...b4mTools2, ...mcpTools, ...cliTools];
-      console.log(`\u{1F4C2} Working directory: ${process.cwd()}`);
+      startupLog.push(`\u{1F4C2} Working directory: ${process.cwd()}`);
       const agentNamesList = agentStore.getAgentNames().join(", ");
-      console.log(`\u{1F916} Subagent delegation enabled (${agentNamesList}) + background execution`);
+      startupLog.push(`\u{1F916} Subagent delegation enabled (${agentNamesList}) + background execution`);
       if (skillTool) {
         const skillCount = state.customCommandStore.getCommandCount();
         if (skillCount > 0) {
-          console.log(`\u{1F6E0}\uFE0F  Skill tool enabled (${skillCount} skills available)`);
+          startupLog.push(`\u{1F6E0}\uFE0F  Skill tool enabled (${skillCount} skills available)`);
         }
       }
       logger.debug(
@@ -15937,26 +15984,20 @@ function CliApp() {
       const projectDir = state.configStore.getProjectConfigDir();
       const contextResult = await loadContextFiles(projectDir);
       if (contextResult.globalContext) {
-        console.log(`\u{1F4C4} Global context: ${contextResult.globalContext.filename}`);
+        startupLog.push(`\u{1F4C4} Global context: ${contextResult.globalContext.filename}`);
       }
       if (contextResult.projectContext) {
-        console.log(`\u{1F4C4} Project context: ${contextResult.projectContext.filename}`);
+        startupLog.push(`\u{1F4C4} Project context: ${contextResult.projectContext.filename}`);
       }
       for (const error of contextResult.errors) {
-        console.log(`\u26A0\uFE0F  Context file error: ${error}`);
+        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,
@@ -16019,8 +16060,36 @@ ${contextResult.mergedContent}` : "";
         // Store for grouped notification turn tracking
       }));
       setStoreSession(newSession);
+      const bannerLines = [
+        { text: "\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D     \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u255A\u2550\u2550\u2550\u2550\u2550\u255D      \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D", ansi: "\x1B[36m\x1B[1m" },
+        { text: "", ansi: "" },
+        { text: `v${package_default.version} - AI-Powered CLI`, ansi: "\x1B[2m" },
+        { text: "/help for more information", ansi: "\x1B[2m" }
+      ];
+      const bannerWidth = 30;
+      const termWidth = process.stdout.columns || 80;
+      const rightColWidth = termWidth - bannerWidth - 2;
+      const truncate = (str, max) => {
+        if (str.length > max) return str.slice(0, max - 1) + "\u2026";
+        return str;
+      };
+      const totalLines = Math.max(bannerLines.length, startupLog.length);
+      for (let i = 0; i < totalLines; i++) {
+        const banner = bannerLines[i];
+        const leftText = banner?.text || "";
+        const leftAnsi = banner?.ansi || "";
+        const right = startupLog[i] || "";
+        const coloredLeft = leftText ? `${leftAnsi}${leftText}\x1B[0m` : "";
+        const gap = " ".repeat(bannerWidth - leftText.length + 2);
+        console.log(coloredLeft + gap + truncate(right, rightColWidth));
+      }
       setIsInitialized(true);
-      console.log("\n");
+      console.log("");
     } catch (error) {
       console.error("Initialization error:", error);
       setInitError(error instanceof Error ? error.message : "Unknown error");
@@ -16034,7 +16103,7 @@ ${contextResult.mergedContent}` : "";
     setStoreSession,
     setState
   ]);
-  useEffect6(() => {
+  useEffect7(() => {
     init();
   }, [init]);
   const handleCustomCommandMessage = async (fullTemplate, displayMessage) => {
@@ -16145,6 +16214,7 @@ ${contextResult.mergedContent}` : "";
             completion: 0,
             total: result.completionInfo.totalTokens
           },
+          creditsUsed: result.completionInfo.totalCredits,
           model: state.session.model,
           permissionDenied
         }
@@ -16156,6 +16226,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
         }
       };
@@ -16258,7 +16329,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");
@@ -16353,6 +16429,7 @@ ${contextResult.mergedContent}` : "";
             completion: 0,
             total: result.completionInfo.totalTokens
           },
+          creditsUsed: result.completionInfo.totalCredits,
           steps: result.steps.map(formatStep),
           // Complete history: thoughts, actions, observations
           permissionDenied
@@ -16366,6 +16443,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
         }
       };
@@ -16464,7 +16542,8 @@ ${contextResult.mergedContent}` : "";
             prompt: 0,
             completion: 0,
             total: result.completionInfo.totalTokens
-          }
+          },
+          creditsUsed: result.completionInfo.totalCredits
         }
       };
       const updatedSession = {
@@ -16474,6 +16553,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
         }
       };
@@ -16675,7 +16755,7 @@ Available commands:
   /whoami - Show current authenticated user
   /usage - Show credit usage and balance
   /save <name> - Save current session
-  /sessions - List saved sessions
+  /resume - List and resume saved sessions
   /config - Show configuration
 
 API Configuration:
@@ -16694,7 +16774,24 @@ Project Configuration:
 Custom Commands:
   /commands - List all custom commands
   /commands:new <name> - Create a new custom command
-  /commands:reload - Reload custom commands from disk${hasCustomCommands ? "\n\n\u{1F4DD} Custom Commands Available:" : ""}${hasCustomCommands ? customCommands.map((cmd) => {
+  /commands:reload - Reload custom commands from disk
+
+Keyboard Shortcuts:
+  Ctrl+C          - Press twice to exit
+  Esc             - Abort current operation
+  Shift+Tab       - Toggle auto-accept edits
+  Ctrl+U          - Clear current line
+  Ctrl+K          - Clear from cursor to end of line
+  Ctrl+W          - Delete word before cursor
+  Ctrl+A          - Move cursor to beginning
+  Ctrl+E          - Move cursor to end
+  Ctrl+B / \u2190      - Move cursor left
+  Ctrl+F / \u2192      - Move cursor right
+  Ctrl+D          - Delete character at cursor
+  Ctrl+L          - Clear input
+  \u2191 / \u2193           - Navigate history / autocomplete
+  Tab             - Accept autocomplete suggestion
+  Shift+Cmd+Click - Open links in browser${hasCustomCommands ? "\n\n\u{1F4DD} Custom Commands Available:" : ""}${hasCustomCommands ? customCommands.map((cmd) => {
           const source = cmd.source === "global" ? "\u{1F3E0}" : "\u{1F4C1}";
           const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
           return `
@@ -16724,6 +16821,7 @@ Custom Commands:
         console.log(`\u2705 Session saved as "${sessionName}"`);
         break;
       }
+      case "resume":
       case "sessions": {
         const sessions = await state.sessionStore.list(20);
         if (sessions.length === 0) {
@@ -16734,7 +16832,6 @@ Custom Commands:
         const handleSessionSelect = async (selectedSession) => {
           setState((prev) => ({ ...prev, sessionSelector: null }));
           if (!selectedSession) {
-            console.log("\u274C Session selection cancelled");
             return;
           }
           const loadedSession = await state.sessionStore.load(selectedSession.id);
@@ -17159,15 +17256,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;
@@ -17186,6 +17289,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)`);
@@ -17586,21 +17693,11 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     }
   );
 }
-var BANNER = `
-\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557
-\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551
-\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551
-\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551
-\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D     \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u255D      \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D
-`;
-console.log("\x1B[36m\x1B[1m%s\x1B[0m", BANNER);
-console.log(`\x1B[2m  v${package_default.version} - AI-Powered CLI\x1B[0m`);
-console.log("  /help for more information\n");
 var isDevMode = import.meta.url.includes("/src/") || process.env.NODE_ENV === "development";
 if (isDevMode) {
   logger.debug("\u{1F527} Running in development mode (using TypeScript source)\n");
 }
+warmFileCache();
 render(/* @__PURE__ */ React21.createElement(CliApp, null), {
   exitOnCtrlC: false
 });