@bike4mind/cli 0.2.1-feat-cli-file-reference.17024 → 0.2.1-feat-cli-project-scoped-config.16996

package/dist/index.js

@@ -4,9 +4,9 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-GZTILMGE.js";
-import "./chunk-CJRAEEKV.js";
-import "./chunk-5N4PG5EH.js";
+} from "./chunk-QXGU6KYI.js";
+import "./chunk-LZMRYJ3B.js";
+import "./chunk-F3ETXO5N.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -15,7 +15,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-NZADYDFG.js";
+} from "./chunk-U3GPYBTD.js";
 import {
   Logger
 } from "./chunk-AMDXHL6S.js";
@@ -83,8 +83,8 @@ import { render, Box as Box11, Text as Text10, useApp, useInput as useInput2 } f
 import { v4 as uuidv49 } from "uuid";
 
 // src/components/App.tsx
-import React8 from "react";
-import { Box as Box8, Text as Text7, Static } from "ink";
+import React7 from "react";
+import { Box as Box7, Text as Text6, Static } from "ink";
 
 // src/components/StatusBar.tsx
 import React from "react";
@@ -94,8 +94,8 @@ var StatusBar = React.memo(function StatusBar2({ sessionName, model, tokenUsage
 });
 
 // src/components/InputPrompt.tsx
-import React4, { useState, useMemo, useEffect } from "react";
-import { Box as Box4, Text as Text4, useInput } from "ink";
+import React3, { useState, useMemo, useEffect } from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
 import TextInput from "ink-text-input";
 
 // src/components/CommandAutocomplete.tsx
@@ -112,210 +112,8 @@ function CommandAutocomplete({ commands, selectedIndex }) {
   }));
 }
 
-// src/components/FileAutocomplete.tsx
-import React3 from "react";
-import { Box as Box3, Text as Text3 } from "ink";
-
-// 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;
-    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
-            });
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  walk(normalizedBase, 0);
-  return results;
-}
-function formatFileSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-var cachedFiles = null;
-var cacheTimestamp = 0;
-var CACHE_TTL_MS = 3e4;
-function getCachedFiles() {
-  const now = Date.now();
-  if (!cachedFiles || now - cacheTimestamp > CACHE_TTL_MS) {
-    cachedFiles = walkDirectory();
-    cacheTimestamp = now;
-  }
-  return cachedFiles;
-}
-function searchFiles(query) {
-  const files = getCachedFiles();
-  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;
-    });
-    if (searchPool.length === 0) {
-      searchPool = files;
-    }
-  }
-  const fuse2 = 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 results = fuse2.search(query);
-  return results.slice(0, 20).map((result) => result.item);
-}
-function isPathWithinCwd(filePath) {
-  const cwd = path.resolve(process.cwd());
-  const absolutePath = path.resolve(cwd, filePath);
-  let resolvedCwd = cwd;
-  let resolvedPath = absolutePath;
-  try {
-    const realCwd = fs.realpathSync.native(cwd);
-    if (realCwd) {
-      resolvedCwd = realCwd;
-    }
-  } catch {
-  }
-  try {
-    const realPath = fs.realpathSync.native(absolutePath);
-    if (realPath) {
-      resolvedPath = realPath;
-    }
-  } catch {
-    const relativePath2 = path.relative(cwd, absolutePath);
-    resolvedPath = path.resolve(resolvedCwd, relativePath2);
-  }
-  const normalizedCwd = resolvedCwd.toLowerCase();
-  const normalizedPath = resolvedPath.toLowerCase();
-  const isWithin = normalizedPath === normalizedCwd || normalizedPath.startsWith(normalizedCwd + path.sep);
-  if (!isWithin) {
-    return false;
-  }
-  const relativePath = path.relative(resolvedCwd, resolvedPath);
-  return !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
-}
-function isBinaryFile(filePath) {
-  const binaryExtensions = [
-    ".png",
-    ".jpg",
-    ".jpeg",
-    ".gif",
-    ".bmp",
-    ".ico",
-    ".webp",
-    // Note: .svg is NOT included because SVG is XML text format that can be safely read
-    ".pdf",
-    ".doc",
-    ".docx",
-    ".xls",
-    ".xlsx",
-    ".ppt",
-    ".pptx",
-    ".zip",
-    ".tar",
-    ".gz",
-    ".rar",
-    ".7z",
-    ".exe",
-    ".dll",
-    ".so",
-    ".dylib",
-    ".bin",
-    ".dat",
-    ".mp3",
-    ".mp4",
-    ".wav",
-    ".avi",
-    ".mov",
-    ".mkv",
-    ".ttf",
-    ".otf",
-    ".woff",
-    ".woff2",
-    ".eot",
-    ".class",
-    ".pyc",
-    ".o",
-    ".obj"
-  ];
-  const ext = path.extname(filePath).toLowerCase();
-  return binaryExtensions.includes(ext);
-}
-var MAX_FILE_SIZE = 10 * 1024 * 1024;
-
-// src/components/FileAutocomplete.tsx
-function FileAutocomplete({ files, selectedIndex, query }) {
-  if (files.length === 0) {
-    return /* @__PURE__ */ React3.createElement(Box3, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "No matching files", query ? ` for "${query}"` : ""));
-  }
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, { 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;
-    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;
-    return /* @__PURE__ */ React3.createElement(Box3, { key: file.path, marginLeft: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "> " : "  "), /* @__PURE__ */ React3.createElement(Text3, { color: file.isDirectory ? "yellow" : isSelected ? "cyan" : void 0, bold: isSelected }, icon), /* @__PURE__ */ React3.createElement(Text3, { color: isSelected ? "cyan" : void 0, bold: isSelected }, " ", pathDisplay), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, sizeDisplay));
-  }));
-}
-
 // src/utils/fuzzySearch.ts
-import Fuse2 from "fuse.js";
+import Fuse from "fuse.js";
 
 // src/config/commands.ts
 var COMMANDS = [
@@ -383,7 +181,7 @@ var COMMANDS = [
 ];
 
 // src/utils/fuzzySearch.ts
-var fuse = new Fuse2(COMMANDS, {
+var fuse = new Fuse(COMMANDS, {
   keys: [
     { name: "name", weight: 0.7 },
     // Prioritize command name
@@ -404,65 +202,23 @@ function searchCommands(query) {
 }
 
 // src/components/InputPrompt.tsx
-function findAtTrigger(value) {
-  for (let i = value.length - 1; i >= 0; i--) {
-    if (value[i] === "@") {
-      const isValid = i === 0 || value[i - 1] === " ";
-      if (isValid) {
-        const query = value.slice(i + 1);
-        if (query.includes(" ")) {
-          return null;
-        }
-        return { startIndex: i, query };
-      }
-    }
-  }
-  return null;
-}
 function InputPrompt({ onSubmit, disabled = false, history = [] }) {
   const [value, setValue] = useState("");
   const [selectedIndex, setSelectedIndex] = useState(0);
   const [historyIndex, setHistoryIndex] = useState(-1);
   const [tempInput, setTempInput] = useState("");
   const [inputKey, setInputKey] = useState(0);
-  const [fileAutocomplete, setFileAutocomplete] = useState(null);
-  const [fileSelectedIndex, setFileSelectedIndex] = useState(0);
-  const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active;
-  const commandQuery = shouldShowCommandAutocomplete ? value.slice(1) : "";
+  const shouldShowAutocomplete = value.startsWith("/") && !disabled;
+  const query = shouldShowAutocomplete ? value.slice(1) : "";
   const filteredCommands = useMemo(() => {
-    if (!shouldShowCommandAutocomplete) return [];
-    return searchCommands(commandQuery);
-  }, [shouldShowCommandAutocomplete, commandQuery]);
-  const filteredFiles = useMemo(() => {
-    if (!fileAutocomplete?.active) return [];
-    return searchFiles(fileAutocomplete.query);
-  }, [fileAutocomplete?.active, fileAutocomplete?.query]);
+    if (!shouldShowAutocomplete) return [];
+    return searchCommands(query);
+  }, [shouldShowAutocomplete, query]);
   useEffect(() => {
     setSelectedIndex(0);
   }, [filteredCommands]);
-  useEffect(() => {
-    setFileSelectedIndex(0);
-  }, [filteredFiles]);
   useInput((input, key) => {
-    if (fileAutocomplete?.active && filteredFiles.length > 0) {
-      if (key.upArrow) {
-        setFileSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredFiles.length - 1);
-        return;
-      } else if (key.downArrow) {
-        setFileSelectedIndex((prev) => prev < filteredFiles.length - 1 ? prev + 1 : 0);
-        return;
-      } else if (key.tab) {
-        const selectedFile = filteredFiles[fileSelectedIndex];
-        if (selectedFile) {
-          insertSelectedFile(selectedFile);
-        }
-        return;
-      } else if (key.escape) {
-        setFileAutocomplete(null);
-        return;
-      }
-    }
-    if (shouldShowCommandAutocomplete && filteredCommands.length > 0) {
+    if (shouldShowAutocomplete && filteredCommands.length > 0) {
       if (key.upArrow) {
         setSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredCommands.length - 1);
       } else if (key.downArrow) {
@@ -470,7 +226,7 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
       }
       return;
     }
-    if (!shouldShowCommandAutocomplete && !fileAutocomplete?.active && history.length > 0) {
+    if (!shouldShowAutocomplete && history.length > 0) {
       if (key.upArrow) {
         if (historyIndex === -1) {
           setTempInput(value);
@@ -493,35 +249,9 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
       }
     }
   });
-  const insertSelectedFile = (file) => {
-    if (!fileAutocomplete) return;
-    const beforeAt = value.slice(0, fileAutocomplete.startIndex);
-    const afterQuery = value.slice(fileAutocomplete.startIndex + 1 + fileAutocomplete.query.length);
-    const pathToInsert = file.isDirectory ? `@${file.path}/` : `@${file.path}`;
-    const newValue = beforeAt + pathToInsert + afterQuery;
-    setValue(newValue);
-    setInputKey((prev) => prev + 1);
-    if (file.isDirectory) {
-      setFileAutocomplete({
-        active: true,
-        startIndex: fileAutocomplete.startIndex,
-        query: file.path + "/"
-      });
-      setFileSelectedIndex(0);
-    } else {
-      setFileAutocomplete(null);
-    }
-  };
   const handleSubmit = (input) => {
     if (disabled || !input.trim()) return;
-    if (fileAutocomplete?.active && filteredFiles.length > 0) {
-      const selectedFile = filteredFiles[fileSelectedIndex];
-      if (selectedFile) {
-        insertSelectedFile(selectedFile);
-      }
-      return;
-    }
-    if (shouldShowCommandAutocomplete && filteredCommands.length > 0) {
+    if (shouldShowAutocomplete && filteredCommands.length > 0) {
       const selectedCommand = filteredCommands[selectedIndex];
       const commandText = `/${selectedCommand.name}`;
       if (selectedCommand.args) {
@@ -538,7 +268,6 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
     onSubmit(input);
     setValue("");
     setHistoryIndex(-1);
-    setFileAutocomplete(null);
   };
   const handleChange = (newValue) => {
     setValue(newValue);
@@ -546,40 +275,30 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
       setHistoryIndex(-1);
       setTempInput("");
     }
-    const atTrigger = findAtTrigger(newValue);
-    if (atTrigger) {
-      setFileAutocomplete({
-        active: true,
-        startIndex: atTrigger.startIndex,
-        query: atTrigger.query
-      });
-    } else {
-      setFileAutocomplete(null);
-    }
   };
-  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "cyan" }, "> "), /* @__PURE__ */ React4.createElement(
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "cyan" }, "> "), /* @__PURE__ */ React3.createElement(
     TextInput,
     {
       key: inputKey,
       value,
       onChange: handleChange,
       onSubmit: handleSubmit,
-      placeholder: disabled ? "Thinking..." : "Type your message, /help for commands, or @file to reference",
+      placeholder: disabled ? "Thinking..." : "Type your message or /help for commands",
       showCursor: !disabled
     }
-  )), shouldShowCommandAutocomplete && /* @__PURE__ */ React4.createElement(CommandAutocomplete, { commands: filteredCommands, selectedIndex }), fileAutocomplete?.active && /* @__PURE__ */ React4.createElement(FileAutocomplete, { files: filteredFiles, selectedIndex: fileSelectedIndex, query: fileAutocomplete.query }));
+  )), shouldShowAutocomplete && /* @__PURE__ */ React3.createElement(CommandAutocomplete, { commands: filteredCommands, selectedIndex }));
 }
 
 // src/components/AgentThinking.tsx
-import React6 from "react";
-import { Box as Box6 } from "ink";
+import React5 from "react";
+import { Box as Box5 } from "ink";
 
 // src/components/ThoughtStream.tsx
-import React5 from "react";
-import { Box as Box5, Text as Text5 } from "ink";
+import React4 from "react";
+import { Box as Box4, Text as Text4 } from "ink";
 import Spinner from "ink-spinner";
-var ThoughtStream = React5.memo(function ThoughtStream2({ steps }) {
-  return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column", gap: 1 }, steps.map((step, index) => /* @__PURE__ */ React5.createElement(Box5, { key: index, flexDirection: "column" }, step.type === "thought" && /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "magenta" }, "\u{1F914} Thought: "), /* @__PURE__ */ React5.createElement(Text5, null, step.content)), step.type === "action" && /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "yellow" }, "\u26A1 Action: "), /* @__PURE__ */ React5.createElement(Text5, { bold: true }, step.metadata?.toolName || "unknown")), step.metadata?.toolInput && /* @__PURE__ */ React5.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, JSON.stringify(step.metadata.toolInput, null, 2)))), step.type === "observation" && /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "blue" }, "\u{1F4CA} Observation: ")), /* @__PURE__ */ React5.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React5.createElement(Text5, null, step.content))), step.type === "final_answer" && /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "green", bold: true }, "\u2705 Final Answer:", " ")), /* @__PURE__ */ React5.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React5.createElement(Text5, null, step.content)), step.metadata?.tokenUsage && /* @__PURE__ */ React5.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(", step.metadata.tokenUsage.total, " tokens)"))))), !steps.some((s) => s.type === "final_answer") && /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "yellow" }, /* @__PURE__ */ React5.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React5.createElement(Text5, null, " ", steps.length === 0 ? "Thinking..." : "Processing...")));
+var ThoughtStream = React4.memo(function ThoughtStream2({ steps }) {
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, steps.map((step, index) => /* @__PURE__ */ React4.createElement(Box4, { key: index, flexDirection: "column" }, step.type === "thought" && /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "magenta" }, "\u{1F914} Thought: "), /* @__PURE__ */ React4.createElement(Text4, null, step.content)), step.type === "action" && /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "\u26A1 Action: "), /* @__PURE__ */ React4.createElement(Text4, { bold: true }, step.metadata?.toolName || "unknown")), step.metadata?.toolInput && /* @__PURE__ */ React4.createElement(Box4, { paddingLeft: 2 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, JSON.stringify(step.metadata.toolInput, null, 2)))), step.type === "observation" && /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "blue" }, "\u{1F4CA} Observation: ")), /* @__PURE__ */ React4.createElement(Box4, { paddingLeft: 2 }, /* @__PURE__ */ React4.createElement(Text4, null, step.content))), step.type === "final_answer" && /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "green", bold: true }, "\u2705 Final Answer:", " ")), /* @__PURE__ */ React4.createElement(Box4, { paddingLeft: 2 }, /* @__PURE__ */ React4.createElement(Text4, null, step.content)), step.metadata?.tokenUsage && /* @__PURE__ */ React4.createElement(Box4, { paddingLeft: 2 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "(", step.metadata.tokenUsage.total, " tokens)"))))), !steps.some((s) => s.type === "final_answer") && /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, /* @__PURE__ */ React4.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React4.createElement(Text4, null, " ", steps.length === 0 ? "Thinking..." : "Processing...")));
 });
 
 // src/store/index.ts
@@ -605,32 +324,32 @@ var useCliStore = create((set) => ({
 }));
 
 // src/components/AgentThinking.tsx
-var AgentThinking = React6.memo(function AgentThinking2() {
+var AgentThinking = React5.memo(function AgentThinking2() {
   const isThinking = useCliStore((state) => state.isThinking);
   const agentSteps = useCliStore((state) => state.agentSteps);
   if (!isThinking) {
     return null;
   }
-  return /* @__PURE__ */ React6.createElement(Box6, { borderStyle: "single", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React6.createElement(ThoughtStream, { steps: agentSteps }));
+  return /* @__PURE__ */ React5.createElement(Box5, { borderStyle: "single", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React5.createElement(ThoughtStream, { steps: agentSteps }));
 });
 
 // src/components/PermissionPrompt.tsx
-import React7 from "react";
-import { Box as Box7, Text as Text6 } from "ink";
+import React6 from "react";
+import { Box as Box6, Text as Text5 } from "ink";
 import SelectInput from "ink-select-input";
 function renderDiffPreview(preview) {
   const lines = preview.split("\n");
   return lines.map((line, index) => {
     if (line.startsWith("+")) {
-      return /* @__PURE__ */ React7.createElement(Text6, { key: index, color: "green" }, line);
+      return /* @__PURE__ */ React6.createElement(Text5, { key: index, color: "green" }, line);
     }
     if (line.startsWith("-")) {
-      return /* @__PURE__ */ React7.createElement(Text6, { key: index, color: "red" }, line);
+      return /* @__PURE__ */ React6.createElement(Text5, { key: index, color: "red" }, line);
     }
     if (line.startsWith("@@")) {
-      return /* @__PURE__ */ React7.createElement(Text6, { key: index, color: "cyan" }, line);
+      return /* @__PURE__ */ React6.createElement(Text5, { key: index, color: "cyan" }, line);
     }
-    return /* @__PURE__ */ React7.createElement(Text6, { key: index, dimColor: true }, line);
+    return /* @__PURE__ */ React6.createElement(Text5, { key: index, dimColor: true }, line);
   });
 }
 function PermissionPrompt({
@@ -650,121 +369,7 @@ function PermissionPrompt({
     { label: "\u2717 Deny", value: "deny" }
   ];
   const argsString = typeof args === "string" ? args : JSON.stringify(args, null, 2);
-  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", borderStyle: "bold", borderColor: "yellow", padding: 1, marginY: 1 }, /* @__PURE__ */ React7.createElement(Box7, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true, color: "yellow" }, "\u26A0\uFE0F Permission Required")), /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Tool: "), /* @__PURE__ */ React7.createElement(Text6, { bold: true, color: "cyan" }, toolName)), toolDescription && /* @__PURE__ */ React7.createElement(Box7, null, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Action: "), /* @__PURE__ */ React7.createElement(Text6, null, toolDescription)), /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Arguments:"), /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, argsString))), preview && /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Preview:"), /* @__PURE__ */ React7.createElement(Box7, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" }, renderDiffPreview(preview))), !canBeTrusted && /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: "red", dimColor: true }, "Note: This tool cannot be trusted due to its dangerous nature.")), /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(SelectInput, { items, onSelect: (item) => onResponse(item.value) })));
-}
-
-// src/utils/processFileReferences.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-
-// src/utils/constants.ts
-var NAME_SUFFIXES = ["jr", "sr", "ii", "iii", "iv", "v", "phd", "md", "esq"];
-function isNameSuffix(value) {
-  return NAME_SUFFIXES.includes(value);
-}
-
-// src/utils/processFileReferences.ts
-var FILE_REFERENCE_REGEX = /(?:^|\s)@([^\s@]+)/g;
-function looksLikeFilePath(ref) {
-  if (ref.includes("/") || ref.includes(path2.sep)) {
-    return true;
-  }
-  const extensionMatch = /\.(\w+)$/.exec(ref);
-  if (extensionMatch) {
-    const ext = extensionMatch[1].toLowerCase();
-    if (isNameSuffix(ext)) {
-      return false;
-    }
-    if (ext.length > 10) {
-      return false;
-    }
-    return true;
-  }
-  return false;
-}
-function extractFileReferences(message) {
-  const references = [];
-  const regex = /(?:^|\s)@([^\s@]+)/g;
-  let match;
-  while ((match = regex.exec(message)) !== null) {
-    const ref = match[1];
-    if (looksLikeFilePath(ref)) {
-      references.push(ref);
-    }
-  }
-  return references;
-}
-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` };
-  }
-  if (!fs2.existsSync(absolutePath)) {
-    return { error: `File not found: "${filePath}"` };
-  }
-  const stats = fs2.statSync(absolutePath);
-  if (stats.isDirectory()) {
-    try {
-      const entries = fs2.readdirSync(absolutePath);
-      const fileCount = entries.length;
-      return {
-        content: `(Directory with ${fileCount} items. Use file tools to explore if needed.)`,
-        size: 0
-      };
-    } catch (err) {
-      return { error: `Cannot read directory "${filePath}": ${err instanceof Error ? err.message : "Unknown error"}` };
-    }
-  }
-  if (stats.size > MAX_FILE_SIZE) {
-    return {
-      error: `File too large: "${filePath}" is ${formatFileSize(stats.size)} (max ${formatFileSize(MAX_FILE_SIZE)})`
-    };
-  }
-  if (isBinaryFile(filePath)) {
-    return { error: `Binary file: "${filePath}" cannot be included as text content` };
-  }
-  try {
-    const content = fs2.readFileSync(absolutePath, "utf-8");
-    return { content, size: stats.size };
-  } catch (err) {
-    return { error: `Cannot read file "${filePath}": ${err instanceof Error ? err.message : "Unknown error"}` };
-  }
-}
-function formatFileBlock(filePath, content, size, isDirectory) {
-  if (isDirectory) {
-    return `
---- Directory Reference: ${filePath} ---
-${content}
---- End of ${filePath} ---`;
-  }
-  return `
---- Referenced File: ${filePath} (${formatFileSize(size)}) ---
-${content}
---- End of ${filePath} ---`;
-}
-async function processFileReferences(message) {
-  const references = extractFileReferences(message);
-  const errors = [];
-  const fileBlocks = [];
-  for (const ref of references) {
-    const result = readFileContents(ref);
-    if ("error" in result) {
-      errors.push(result.error);
-      continue;
-    }
-    const isDirectory = result.size === 0 && result.content.startsWith("(Directory");
-    fileBlocks.push(formatFileBlock(ref, result.content, result.size, isDirectory));
-  }
-  if (fileBlocks.length === 0) {
-    return { content: message, errors };
-  }
-  const processedContent = message + "\n" + fileBlocks.join("\n");
-  return { content: processedContent, errors };
-}
-function hasFileReferences(message) {
-  FILE_REFERENCE_REGEX.lastIndex = 0;
-  return FILE_REFERENCE_REGEX.test(message);
+  return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", borderStyle: "bold", borderColor: "yellow", padding: 1, marginY: 1 }, /* @__PURE__ */ React6.createElement(Box6, null, /* @__PURE__ */ React6.createElement(Text5, { bold: true, color: "yellow" }, "\u26A0\uFE0F Permission Required")), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Tool: "), /* @__PURE__ */ React6.createElement(Text5, { bold: true, color: "cyan" }, toolName)), toolDescription && /* @__PURE__ */ React6.createElement(Box6, null, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Action: "), /* @__PURE__ */ React6.createElement(Text5, null, toolDescription)), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text5, { bold: true }, "Arguments:"), /* @__PURE__ */ React6.createElement(Box6, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, argsString))), preview && /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text5, { bold: true }, "Preview:"), /* @__PURE__ */ React6.createElement(Box6, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" }, renderDiffPreview(preview))), !canBeTrusted && /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: "red", dimColor: true }, "Note: This tool cannot be trusted due to its dangerous nature.")), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(SelectInput, { items, onSelect: (item) => onResponse(item.value) })));
 }
 
 // src/components/App.tsx
@@ -777,7 +382,7 @@ function App({ onMessage, onCommand, onPermissionResponse, commandHistory = [] }
   const permissionPrompt = useCliStore((state) => state.permissionPrompt);
   const exitRequested = useCliStore((state) => state.exitRequested);
   const setIsThinking = useCliStore((state) => state.setIsThinking);
-  const handleSubmit = React8.useCallback(
+  const handleSubmit = React7.useCallback(
     async (input) => {
       const trimmed = input.trim();
       if (!trimmed) return;
@@ -788,25 +393,14 @@ function App({ onMessage, onCommand, onPermissionResponse, commandHistory = [] }
       }
       setIsThinking(true);
       try {
-        let messageToSend = trimmed;
-        if (hasFileReferences(trimmed)) {
-          const processed = await processFileReferences(trimmed);
-          messageToSend = processed.content;
-          if (processed.errors.length > 0) {
-            const errorBlock = processed.errors.map((e) => `[Warning: ${e}]`).join("\n");
-            messageToSend = `${messageToSend}
-
-${errorBlock}`;
-          }
-        }
-        await onMessage(messageToSend);
+        await onMessage(trimmed);
       } finally {
         setIsThinking(false);
       }
     },
     [onMessage, onCommand, setIsThinking]
   );
-  return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column" }, /* @__PURE__ */ React8.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens }), permissionPrompt ? /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React8.createElement(
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens }), permissionPrompt ? /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React7.createElement(
     PermissionPrompt,
     {
       toolName: permissionPrompt.toolName,
@@ -815,39 +409,39 @@ ${errorBlock}`;
       canBeTrusted: permissionPrompt.canBeTrusted,
       onResponse: onPermissionResponse
     }
-  )) : /* @__PURE__ */ React8.createElement(React8.Fragment, null, /* @__PURE__ */ React8.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React8.createElement(Box8, { key: index, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React8.createElement(MessageItem, { message }))), /* @__PURE__ */ React8.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React8.createElement(Box8, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: "yellow", bold: true }, "\u26A0\uFE0F Press Ctrl+C again to exit")), /* @__PURE__ */ React8.createElement(Box8, { borderStyle: "single", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React8.createElement(InputPrompt, { onSubmit: handleSubmit, disabled: isThinking, history: commandHistory }))));
+  )) : /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React7.createElement(Box7, { key: index, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React7.createElement(MessageItem, { message }))), /* @__PURE__ */ React7.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React7.createElement(Box7, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: "yellow", bold: true }, "\u26A0\uFE0F Press Ctrl+C again to exit")), /* @__PURE__ */ React7.createElement(Box7, { borderStyle: "single", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React7.createElement(InputPrompt, { onSubmit: handleSubmit, disabled: isThinking, history: commandHistory }))));
 }
 function MessageItem({ message }) {
-  return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React8.createElement(Box8, null, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React8.createElement(Box8, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React8.createElement(Text7, null, message.content)), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React8.createElement(Box8, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { 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__ */ React8.createElement(Text7, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Box7, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React7.createElement(Text6, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React7.createElement(Text6, null, message.content)), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { 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__ */ React7.createElement(Text6, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
     if (step.type === "thought") {
-      return /* @__PURE__ */ React8.createElement(Box8, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `   ${step.content.slice(0, 200)}${step.content.length > 200 ? "..." : ""}`));
+      return /* @__PURE__ */ React7.createElement(Box7, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, `   ${step.content.slice(0, 200)}${step.content.length > 200 ? "..." : ""}`));
     }
     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__ */ React8.createElement(Box8, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
+      return /* @__PURE__ */ React7.createElement(Box7, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
     }
     return null;
-  }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React8.createElement(Box8, { paddingLeft: 2 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
+  }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
 }
 
 // src/components/MessageList.tsx
-import React9 from "react";
-import { Box as Box9, Text as Text8 } from "ink";
+import React8 from "react";
+import { Box as Box8, Text as Text7 } from "ink";
 function stripThinkingTags(content) {
   return content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
-var MessageList = React9.memo(
+var MessageList = React8.memo(
   function MessageList2({ messages }) {
     if (messages.length === 0) {
-      return /* @__PURE__ */ React9.createElement(Box9, { paddingY: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "No messages yet. Type a message to start!"));
+      return /* @__PURE__ */ React8.createElement(Box8, { paddingY: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "No messages yet. Type a message to start!"));
     }
-    return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React9.createElement(Box9, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Box9, null, /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React9.createElement(Box9, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React9.createElement(Text8, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React9.createElement(Box9, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Text8, { 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__ */ React9.createElement(Text8, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+    return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React8.createElement(Box8, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React8.createElement(Box8, null, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React8.createElement(Box8, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React8.createElement(Text7, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React8.createElement(Box8, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { 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__ */ React8.createElement(Text7, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
       if (step.type === "thought") {
-        return /* @__PURE__ */ React9.createElement(Box9, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Text8, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React9.createElement(
-          Text8,
+        return /* @__PURE__ */ React8.createElement(Box8, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React8.createElement(
+          Text7,
           {
             dimColor: true
           },
@@ -859,10 +453,10 @@ var MessageList = React9.memo(
         const toolInput = step.metadata?.toolInput;
         const observationStep = message.metadata.steps[idx + 1];
         const result = observationStep?.type === "observation" ? observationStep.content : null;
-        return /* @__PURE__ */ React9.createElement(Box9, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
+        return /* @__PURE__ */ React8.createElement(Box8, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
       }
       return null;
-    }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React9.createElement(Box9, { paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
+    }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React8.createElement(Box8, { paddingLeft: 2 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
   },
   (prevProps, nextProps) => {
     if (prevProps.messages.length !== nextProps.messages.length) {
@@ -872,6 +466,39 @@ var MessageList = React9.memo(
   }
 );
 
+// src/components/TrustLocationSelector.tsx
+import React9 from "react";
+import { Box as Box9, Text as Text8 } from "ink";
+import SelectInput2 from "ink-select-input";
+function TrustLocationSelector({ inProject, onSelect, onCancel }) {
+  const items = [];
+  if (inProject) {
+    items.push({
+      label: "Project settings (local) - Saved in .bike4mind/local.json (not committed)",
+      value: "local"
+    });
+    items.push({
+      label: "Project settings (team-wide) - Checked in at .bike4mind/config.json",
+      value: "project"
+    });
+  }
+  items.push({
+    label: "User settings - Saved at ~/.bike4mind/config.json",
+    value: "global"
+  });
+  const handleSelect = (item) => {
+    onSelect(item.value);
+  };
+  return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "Where should this rule be saved?")), /* @__PURE__ */ React9.createElement(
+    SelectInput2,
+    {
+      items,
+      onSelect: handleSelect,
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React9.createElement(Box9, null, /* @__PURE__ */ React9.createElement(Text8, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+    }
+  ), /* @__PURE__ */ React9.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Ctrl+C to cancel")));
+}
+
 // src/components/LoginFlow.tsx
 import React10, { useState as useState2, useEffect as useEffect2 } from "react";
 import { Box as Box10, Text as Text9 } from "ink";
@@ -984,7 +611,7 @@ var OAuthClient = class {
    * Sleep for specified milliseconds
    */
   sleep(ms) {
-    return new Promise((resolve3) => setTimeout(resolve3, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 };
 
@@ -1049,19 +676,19 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
 }
 
 // src/storage/SessionStore.ts
-import { promises as fs3 } from "fs";
-import path3 from "path";
+import { promises as fs } from "fs";
+import path from "path";
 import { homedir } from "os";
 var SessionStore = class {
   constructor(basePath) {
-    this.basePath = basePath || path3.join(homedir(), ".bike4mind", "sessions");
+    this.basePath = basePath || path.join(homedir(), ".bike4mind", "sessions");
   }
   /**
    * Initialize storage directory
    */
   async init() {
     try {
-      await fs3.mkdir(this.basePath, { recursive: true });
+      await fs.mkdir(this.basePath, { recursive: true });
     } catch (error) {
       console.error("Failed to initialize session storage:", error);
       throw error;
@@ -1072,9 +699,9 @@ var SessionStore = class {
    */
   async save(session) {
     await this.init();
-    const filePath = path3.join(this.basePath, `${session.id}.json`);
+    const filePath = path.join(this.basePath, `${session.id}.json`);
     try {
-      await fs3.writeFile(filePath, JSON.stringify(session, null, 2), "utf-8");
+      await fs.writeFile(filePath, JSON.stringify(session, null, 2), "utf-8");
     } catch (error) {
       console.error("Failed to save session:", error);
       throw error;
@@ -1084,9 +711,9 @@ var SessionStore = class {
    * Load a session from disk by ID
    */
   async load(id) {
-    const filePath = path3.join(this.basePath, `${id}.json`);
+    const filePath = path.join(this.basePath, `${id}.json`);
     try {
-      const data = await fs3.readFile(filePath, "utf-8");
+      const data = await fs.readFile(filePath, "utf-8");
       return JSON.parse(data);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -1110,12 +737,12 @@ var SessionStore = class {
   async list() {
     await this.init();
     try {
-      const files = await fs3.readdir(this.basePath);
+      const files = await fs.readdir(this.basePath);
       const jsonFiles = files.filter((f) => f.endsWith(".json"));
       const sessions = await Promise.all(
         jsonFiles.map(async (file) => {
-          const filePath = path3.join(this.basePath, file);
-          const data = await fs3.readFile(filePath, "utf-8");
+          const filePath = path.join(this.basePath, file);
+          const data = await fs.readFile(filePath, "utf-8");
           return JSON.parse(data);
         })
       );
@@ -1129,9 +756,9 @@ var SessionStore = class {
    * Delete a session
    */
   async delete(id) {
-    const filePath = path3.join(this.basePath, `${id}.json`);
+    const filePath = path.join(this.basePath, `${id}.json`);
     try {
-      await fs3.unlink(filePath);
+      await fs.unlink(filePath);
       return true;
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -1167,8 +794,8 @@ var SessionStore = class {
 };
 
 // src/storage/ConfigStore.ts
-import { promises as fs4 } from "fs";
-import path4 from "path";
+import { promises as fs2, existsSync } from "fs";
+import path2 from "path";
 import { homedir as homedir2 } from "os";
 import { v4 as uuidv4 } from "uuid";
 import { z } from "zod";
@@ -1214,6 +841,53 @@ var CliConfigSchema = z.object({
   }),
   trustedTools: z.array(z.string()).optional().default([])
 });
+var ProjectConfigSchema = z.object({
+  tools: z.object({
+    enabled: z.array(z.string()).optional(),
+    denied: z.array(z.string()).optional(),
+    config: z.record(z.any()).optional()
+  }).optional(),
+  defaultModel: z.string().optional(),
+  mcpServers: z.array(
+    z.object({
+      name: z.string(),
+      command: z.string(),
+      args: z.array(z.string()),
+      env: z.record(z.string()),
+      enabled: z.boolean()
+    })
+  ).optional(),
+  preferences: z.object({
+    maxTokens: z.number().optional(),
+    temperature: z.number().optional(),
+    autoSave: z.boolean().optional(),
+    theme: z.enum(["light", "dark"]).optional(),
+    exportFormat: z.enum(["markdown", "json"]).optional()
+  }).optional()
+});
+var ProjectLocalConfigSchema = z.object({
+  trustedTools: z.array(z.string()).optional(),
+  toolApiKeys: z.object({
+    openweather: z.string().optional(),
+    serper: z.string().optional()
+  }).optional(),
+  preferences: z.object({
+    maxTokens: z.number().optional(),
+    temperature: z.number().optional(),
+    autoSave: z.boolean().optional(),
+    theme: z.enum(["light", "dark"]).optional(),
+    exportFormat: z.enum(["markdown", "json"]).optional()
+  }).optional(),
+  mcpServers: z.array(
+    z.object({
+      name: z.string(),
+      command: z.string(),
+      args: z.array(z.string()),
+      env: z.record(z.string()),
+      enabled: z.boolean()
+    })
+  ).optional()
+});
 var DEFAULT_CONFIG = {
   version: "0.1.0",
   userId: uuidv4(),
@@ -1239,18 +913,132 @@ var DEFAULT_CONFIG = {
   trustedTools: []
   // No tools trusted by default
 };
+function findProjectConfigDir(startDir = process.cwd()) {
+  let currentDir = startDir;
+  const { root } = path2.parse(currentDir);
+  while (currentDir !== root) {
+    const projectConfigPath = path2.join(currentDir, ".bike4mind", "config.json");
+    try {
+      if (existsSync(projectConfigPath)) {
+        return currentDir;
+      }
+    } catch {
+    }
+    currentDir = path2.dirname(currentDir);
+  }
+  return null;
+}
+async function loadProjectConfig(projectDir) {
+  const configPath = path2.join(projectDir, ".bike4mind", "config.json");
+  try {
+    const data = await fs2.readFile(configPath, "utf-8");
+    const rawConfig = JSON.parse(data);
+    const validated = ProjectConfigSchema.parse(rawConfig);
+    return validated;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    if (error instanceof z.ZodError) {
+      console.error("Project config validation error:", error.errors);
+      return null;
+    }
+    console.error("Failed to load project config:", error);
+    return null;
+  }
+}
+async function loadProjectLocalConfig(projectDir) {
+  const configPath = path2.join(projectDir, ".bike4mind", "local.json");
+  try {
+    const data = await fs2.readFile(configPath, "utf-8");
+    const rawConfig = JSON.parse(data);
+    const validated = ProjectLocalConfigSchema.parse(rawConfig);
+    return validated;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    if (error instanceof z.ZodError) {
+      console.error("Project local config validation error:", error.errors);
+      return null;
+    }
+    console.error("Failed to load project local config:", error);
+    return null;
+  }
+}
+function mergeMcpServers(...serverArrays) {
+  const serverMap = /* @__PURE__ */ new Map();
+  for (const servers of serverArrays) {
+    if (servers) {
+      for (const server of servers) {
+        serverMap.set(server.name, server);
+      }
+    }
+  }
+  return Array.from(serverMap.values());
+}
+function mergeConfigs(global, project, local) {
+  const merged = { ...global };
+  if (project) {
+    if (project.defaultModel) {
+      merged.defaultModel = project.defaultModel;
+    }
+    if (project.preferences) {
+      merged.preferences = {
+        ...merged.preferences,
+        ...project.preferences
+      };
+    }
+    if (project.tools) {
+      merged.tools = {
+        ...merged.tools,
+        enabled: project.tools.enabled || merged.tools.enabled,
+        disabled: [...merged.tools.disabled, ...project.tools.denied || []],
+        config: {
+          ...merged.tools.config,
+          ...project.tools.config
+        }
+      };
+    }
+    if (project.mcpServers) {
+      merged.mcpServers = mergeMcpServers(merged.mcpServers, project.mcpServers);
+    }
+  }
+  if (local) {
+    if (local.trustedTools) {
+      merged.trustedTools = [...merged.trustedTools || [], ...local.trustedTools];
+    }
+    if (local.toolApiKeys) {
+      merged.toolApiKeys = {
+        ...merged.toolApiKeys,
+        ...local.toolApiKeys
+      };
+    }
+    if (local.preferences) {
+      merged.preferences = {
+        ...merged.preferences,
+        ...local.preferences
+      };
+    }
+    if (local.mcpServers) {
+      merged.mcpServers = mergeMcpServers(merged.mcpServers, local.mcpServers);
+    }
+  }
+  return merged;
+}
 var ConfigStore = class {
   constructor(configPath) {
     this.config = null;
-    this.configPath = configPath || path4.join(homedir2(), ".bike4mind", "config.json");
+    this.projectConfigDir = null;
+    this.configPath = configPath || path2.join(homedir2(), ".bike4mind", "config.json");
   }
   /**
    * Initialize config directory
    */
   async init() {
-    const dir = path4.dirname(this.configPath);
+    const dir = path2.dirname(this.configPath);
     try {
-      await fs4.mkdir(dir, { recursive: true });
+      await fs2.mkdir(dir, { recursive: true });
     } catch (error) {
       console.error("Failed to initialize config directory:", error);
       throw error;
@@ -1258,51 +1046,76 @@ var ConfigStore = class {
   }
   /**
    * Load configuration from disk with Zod validation
+   * Merges global → project → local configs
    */
   async load() {
     if (this.config) {
       return this.config;
     }
     try {
+      let globalConfig;
       try {
-        const stats = await fs4.stat(this.configPath);
-        const mode = stats.mode & 511;
-        if (mode !== 384) {
-          console.warn(`\u26A0\uFE0F  Config file has insecure permissions (${mode.toString(8)}). Setting to 0600...`);
-          await fs4.chmod(this.configPath, 384);
+        try {
+          const stats = await fs2.stat(this.configPath);
+          const mode = stats.mode & 511;
+          if (mode !== 384) {
+            console.warn(`\u26A0\uFE0F  Config file has insecure permissions (${mode.toString(8)}). Setting to 0600...`);
+            await fs2.chmod(this.configPath, 384);
+          }
+        } catch (statError) {
+        }
+        const data = await fs2.readFile(this.configPath, "utf-8");
+        const rawConfig = JSON.parse(data);
+        if (rawConfig.apiConfig && "environment" in rawConfig.apiConfig) {
+          const oldApiConfig = rawConfig.apiConfig;
+          if (oldApiConfig.environment === "custom" && oldApiConfig.customUrl) {
+            rawConfig.apiConfig = { customUrl: oldApiConfig.customUrl };
+          } else {
+            rawConfig.apiConfig = {};
+          }
         }
-      } catch (statError) {
-      }
-      const data = await fs4.readFile(this.configPath, "utf-8");
-      const rawConfig = JSON.parse(data);
-      if (rawConfig.apiConfig && "environment" in rawConfig.apiConfig) {
-        const oldApiConfig = rawConfig.apiConfig;
-        if (oldApiConfig.environment === "custom" && oldApiConfig.customUrl) {
-          rawConfig.apiConfig = { customUrl: oldApiConfig.customUrl };
+        const validated = CliConfigSchema.parse(rawConfig);
+        globalConfig = {
+          ...DEFAULT_CONFIG,
+          ...validated,
+          auth: validated.auth,
+          // Explicitly preserve auth field
+          preferences: {
+            ...DEFAULT_CONFIG.preferences,
+            ...validated.preferences
+          },
+          tools: {
+            ...DEFAULT_CONFIG.tools,
+            ...validated.tools
+          },
+          toolApiKeys: {
+            ...DEFAULT_CONFIG.toolApiKeys,
+            ...validated.toolApiKeys || {}
+          },
+          trustedTools: validated.trustedTools || []
+        };
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          globalConfig = { ...DEFAULT_CONFIG };
+        } else if (error instanceof z.ZodError) {
+          console.error("Global config validation error:", error.errors);
+          console.error("Using default configuration");
+          globalConfig = { ...DEFAULT_CONFIG };
         } else {
-          rawConfig.apiConfig = {};
+          throw error;
         }
       }
-      const validated = CliConfigSchema.parse(rawConfig);
-      this.config = {
-        ...DEFAULT_CONFIG,
-        ...validated,
-        auth: validated.auth,
-        // Explicitly preserve auth field
-        preferences: {
-          ...DEFAULT_CONFIG.preferences,
-          ...validated.preferences
-        },
-        tools: {
-          ...DEFAULT_CONFIG.tools,
-          ...validated.tools
-        },
-        toolApiKeys: {
-          ...DEFAULT_CONFIG.toolApiKeys,
-          ...validated.toolApiKeys || {}
-        },
-        trustedTools: validated.trustedTools || []
-      };
+      this.projectConfigDir = findProjectConfigDir();
+      let projectConfig = null;
+      let projectLocalConfig = null;
+      if (this.projectConfigDir) {
+        projectConfig = await loadProjectConfig(this.projectConfigDir);
+        projectLocalConfig = await loadProjectLocalConfig(this.projectConfigDir);
+        if (projectConfig) {
+          console.log(`\u{1F4C1} Project config loaded from: ${this.projectConfigDir}/.bike4mind/`);
+        }
+      }
+      this.config = mergeConfigs(globalConfig, projectConfig, projectLocalConfig);
       return this.config;
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -1346,8 +1159,8 @@ var ConfigStore = class {
       throw new Error("No configuration to save");
     }
     try {
-      await fs4.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
-      await fs4.chmod(this.configPath, 384);
+      await fs2.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
+      await fs2.chmod(this.configPath, 384);
     } catch (error) {
       console.error("Failed to save config:", error);
       throw error;
@@ -1489,27 +1302,126 @@ var ConfigStore = class {
     } else {
       config.apiConfig = { customUrl: url };
     }
-    await this.save(config);
+    await this.save(config);
+  }
+  /**
+   * Get project config directory (if any)
+   */
+  getProjectConfigDir() {
+    return this.projectConfigDir;
+  }
+  /**
+   * Initialize project config in current directory
+   * Creates .bike4mind/config.json with default project config
+   * Also ensures .bike4mind/local.json is in .gitignore
+   */
+  async initProjectConfig(projectDir = process.cwd()) {
+    const configDir = path2.join(projectDir, ".bike4mind");
+    const configPath = path2.join(configDir, "config.json");
+    await fs2.mkdir(configDir, { recursive: true });
+    try {
+      await fs2.access(configPath);
+      console.log(`Project config already exists at: ${configPath}`);
+    } catch {
+      const defaultProjectConfig = {
+        tools: {
+          enabled: [],
+          denied: [],
+          config: {}
+        },
+        mcpServers: [],
+        preferences: {}
+      };
+      await fs2.writeFile(configPath, JSON.stringify(defaultProjectConfig, null, 2), "utf-8");
+      console.log(`\u2705 Created project config at: ${configPath}`);
+    }
+    await this.ensureGitignore(projectDir);
+  }
+  /**
+   * Ensure .gitignore includes .bike4mind/local.json
+   */
+  async ensureGitignore(projectDir) {
+    const gitignorePath = path2.join(projectDir, ".gitignore");
+    const entryToAdd = ".bike4mind/local.json";
+    try {
+      let gitignoreContent = "";
+      try {
+        gitignoreContent = await fs2.readFile(gitignorePath, "utf-8");
+      } catch {
+      }
+      if (gitignoreContent.includes(entryToAdd)) {
+        return;
+      }
+      const newContent = gitignoreContent.trim() + (gitignoreContent ? "\n" : "") + `
+# Bike4Mind local config (developer-specific)
+${entryToAdd}
+`;
+      await fs2.writeFile(gitignorePath, newContent, "utf-8");
+      console.log(`\u2705 Added ${entryToAdd} to .gitignore`);
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F  Failed to update .gitignore:`, error);
+    }
+  }
+  /**
+   * Save project config to .bike4mind/config.json
+   */
+  async saveProjectConfig(config, projectDir) {
+    const targetDir = projectDir || this.projectConfigDir || process.cwd();
+    const configPath = path2.join(targetDir, ".bike4mind", "config.json");
+    await fs2.mkdir(path2.dirname(configPath), { recursive: true });
+    const validated = ProjectConfigSchema.parse(config);
+    await fs2.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
+    console.log(`\u2705 Saved project config to: ${configPath}`);
+  }
+  /**
+   * Save project-local config to .bike4mind/local.json
+   */
+  async saveProjectLocalConfig(config, projectDir) {
+    const targetDir = projectDir || this.projectConfigDir || process.cwd();
+    const configPath = path2.join(targetDir, ".bike4mind", "local.json");
+    await fs2.mkdir(path2.dirname(configPath), { recursive: true });
+    const validated = ProjectLocalConfigSchema.parse(config);
+    await fs2.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
+    await fs2.chmod(configPath, 384);
+    console.log(`\u2705 Saved project-local config to: ${configPath}`);
+  }
+  /**
+   * Load raw project config (without merging)
+   */
+  async loadRawProjectConfig() {
+    if (!this.projectConfigDir) {
+      return null;
+    }
+    return loadProjectConfig(this.projectConfigDir);
+  }
+  /**
+   * Load raw project-local config (without merging)
+   */
+  async loadRawProjectLocalConfig() {
+    if (!this.projectConfigDir) {
+      return null;
+    }
+    return loadProjectLocalConfig(this.projectConfigDir);
   }
 };
 
 // src/storage/CommandHistoryStore.ts
-import { promises as fs5 } from "fs";
-import path5 from "path";
+import { promises as fs3 } from "fs";
+import path3 from "path";
 import { homedir as homedir3 } from "os";
 var MAX_HISTORY_ENTRIES = 1e3;
 var CommandHistoryStore = class {
   constructor(historyPath) {
     this.history = null;
-    this.historyPath = historyPath || path5.join(homedir3(), ".bike4mind", "history.jsonl");
+    this.historyPath = historyPath || path3.join(homedir3(), ".bike4mind", "history.jsonl");
   }
   /**
    * Initialize history directory
    */
   async init() {
-    const dir = path5.dirname(this.historyPath);
+    const dir = path3.dirname(this.historyPath);
     try {
-      await fs5.mkdir(dir, { recursive: true });
+      await fs3.mkdir(dir, { recursive: true });
     } catch (error) {
       console.error("Failed to initialize history directory:", error);
       throw error;
@@ -1524,7 +1436,7 @@ var CommandHistoryStore = class {
       return this.history;
     }
     try {
-      const data = await fs5.readFile(this.historyPath, "utf-8");
+      const data = await fs3.readFile(this.historyPath, "utf-8");
       const lines = data.trim().split("\n").filter((line) => line.length > 0);
       const entries = lines.map((line) => {
         try {
@@ -1561,7 +1473,7 @@ var CommandHistoryStore = class {
     };
     await this.init();
     const line = JSON.stringify(entry) + "\n";
-    await fs5.appendFile(this.historyPath, line, "utf-8");
+    await fs3.appendFile(this.historyPath, line, "utf-8");
     this.history = [command, ...this.history || []];
     if (this.history.length > MAX_HISTORY_ENTRIES) {
       await this.trim();
@@ -1584,7 +1496,7 @@ var CommandHistoryStore = class {
       };
       return JSON.stringify(entry);
     }).join("\n");
-    await fs5.writeFile(this.historyPath, lines + "\n", "utf-8");
+    await fs3.writeFile(this.historyPath, lines + "\n", "utf-8");
     this.history = trimmedCommands;
   }
   /**
@@ -1592,7 +1504,7 @@ var CommandHistoryStore = class {
    */
   async clear() {
     try {
-      await fs5.unlink(this.historyPath);
+      await fs3.unlink(this.historyPath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -2366,7 +2278,7 @@ import { GoogleGenerativeAI } from "@google/generative-ai";
 import OpenAI2 from "openai";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
-import fs6, { unlinkSync } from "fs";
+import fs4, { unlinkSync } from "fs";
 import yauzl from "yauzl";
 import axios3 from "axios";
 
@@ -2973,196 +2885,190 @@ var listFabFilesBySessionSchema = z90.object({
   sessionId: z90.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/fabFileService/listByQuest.js
-import { z as z91 } from "zod";
-var listFabFilesByQuestSchema = z91.object({
-  questId: z91.string()
-});
-
 // ../../b4m-core/packages/services/dist/src/fabFileService/createByUrl.js
-import { z as z92 } from "zod";
-var createFabFileByUrlSchema = z92.object({
-  url: z92.string().regex(/^(?!https?:\/\/(drive|docs)\.google\.com\/(?:file\/d\/|open\?id=|uc\?id=|document\/d\/|spreadsheets\/d\/|presentation\/d\/|forms\/d\/|drive\/folders\/)([a-zA-Z0-9_-]{10,})).+/)
+import { z as z91 } from "zod";
+var createFabFileByUrlSchema = z91.object({
+  url: z91.string().regex(/^(?!https?:\/\/(drive|docs)\.google\.com\/(?:file\/d\/|open\?id=|uc\?id=|document\/d\/|spreadsheets\/d\/|presentation\/d\/|forms\/d\/|drive\/folders\/)([a-zA-Z0-9_-]{10,})).+/)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/search.js
-import { z as z93 } from "zod";
-var searchFabFilesSchema = z93.object({
-  search: z93.string().optional(),
-  filters: z93.object({
-    tags: z93.array(z93.string()).optional(),
-    type: z93.enum(["text", "pdf", "url", "image", "excel", "word", "json", "csv", "markdown", "code"]).optional(),
-    shared: z93.coerce.boolean().optional(),
+import { z as z92 } from "zod";
+var searchFabFilesSchema = z92.object({
+  search: z92.string().optional(),
+  filters: z92.object({
+    tags: z92.array(z92.string()).optional(),
+    type: z92.enum(["text", "pdf", "url", "image", "excel", "word", "json", "csv", "markdown", "code"]).optional(),
+    shared: z92.coerce.boolean().optional(),
     // Indicates if the user is searching for shared files
-    curated: z93.coerce.boolean().optional(),
+    curated: z92.coerce.boolean().optional(),
     // Indicates if the user is searching for curated notebook files
-    projectId: z93.string().optional(),
-    ids: z93.array(z93.string()).optional()
+    projectId: z92.string().optional(),
+    ids: z92.array(z92.string()).optional()
     // Add support for filtering by IDs
   }).optional(),
-  pagination: z93.object({
-    page: z93.coerce.number(),
-    limit: z93.coerce.number()
+  pagination: z92.object({
+    page: z92.coerce.number(),
+    limit: z92.coerce.number()
   }).optional(),
-  order: z93.object({
-    by: z93.enum(["createdAt", "fileName", "fileSize"]),
-    direction: z93.enum(["asc", "desc"])
+  order: z92.object({
+    by: z92.enum(["createdAt", "fileName", "fileSize"]),
+    direction: z92.enum(["asc", "desc"])
   }).optional(),
-  options: z93.object({
-    includeShared: z93.coerce.boolean().optional()
+  options: z92.object({
+    includeShared: z92.coerce.boolean().optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/addFavorite.js
-import { z as z94 } from "zod";
-var addFavoriteParametersSchema3 = z94.object({
-  fileId: z94.string()
+import { z as z93 } from "zod";
+var addFavoriteParametersSchema3 = z93.object({
+  fileId: z93.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/deleteFavorite.js
-import { z as z95 } from "zod";
-var deleteFavoriteParametersSchema4 = z95.object({
-  fileId: z95.string()
+import { z as z94 } from "zod";
+var deleteFavoriteParametersSchema4 = z94.object({
+  fileId: z94.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/toggleTags.js
-import { z as z96 } from "zod";
-var fabFileToggleTagsSchema = z96.object({
-  ids: z96.array(z96.string()),
-  tags: z96.array(z96.string())
+import { z as z95 } from "zod";
+var fabFileToggleTagsSchema = z95.object({
+  ids: z95.array(z95.string()),
+  tags: z95.array(z95.string())
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/edit.js
-import { z as z97 } from "zod";
+import { z as z96 } from "zod";
 import { diffLines } from "diff";
-var editFabFileSchema = z97.object({
-  id: z97.string(),
-  instruction: z97.string(),
-  selection: z97.object({
-    start: z97.number(),
-    end: z97.number()
+var editFabFileSchema = z96.object({
+  id: z96.string(),
+  instruction: z96.string(),
+  selection: z96.object({
+    start: z96.number(),
+    end: z96.number()
   }).optional(),
-  preserveFormatting: z97.boolean().optional().default(true),
-  applyImmediately: z97.boolean().optional().default(false)
+  preserveFormatting: z96.boolean().optional().default(true),
+  applyImmediately: z96.boolean().optional().default(false)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/applyEdit.js
 import mime2 from "mime-types";
 import { v4 as uuidv43 } from "uuid";
-import { z as z98 } from "zod";
-var applyEditSchema = z98.object({
-  id: z98.string(),
-  modifiedContent: z98.string(),
-  createBackup: z98.boolean().optional().default(true)
+import { z as z97 } from "zod";
+var applyEditSchema = z97.object({
+  id: z97.string(),
+  modifiedContent: z97.string(),
+  createBackup: z97.boolean().optional().default(true)
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/respondToFriendRequest.js
-import { z as z99 } from "zod";
-var respondToFriendRequestSchema = z99.object({
-  id: z99.string(),
+import { z as z98 } from "zod";
+var respondToFriendRequestSchema = z98.object({
+  id: z98.string(),
   /** The user ID of the recipient of the friend request */
-  userId: z99.string(),
-  accept: z99.boolean()
+  userId: z98.string(),
+  accept: z98.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/unfriend.js
-import { z as z100 } from "zod";
-var unfriendSchema = z100.object({
-  friendshipId: z100.string(),
+import { z as z99 } from "zod";
+var unfriendSchema = z99.object({
+  friendshipId: z99.string(),
   /** The user ID of the user who wants to unfriend the other user */
-  userId: z100.string()
+  userId: z99.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/list.js
-import { z as z101 } from "zod";
-var listFriendsSchema = z101.object({
-  userId: z101.string()
+import { z as z100 } from "zod";
+var listFriendsSchema = z100.object({
+  userId: z100.string()
 });
-var listPendingFriendRequestsSchema = z101.object({
-  userId: z101.string()
+var listPendingFriendRequestsSchema = z100.object({
+  userId: z100.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/adminService/loginAs.js
-import { z as z102 } from "zod";
-var loginAsSchema = z102.object({
-  targetUserId: z102.string()
+import { z as z101 } from "zod";
+var loginAsSchema = z101.object({
+  targetUserId: z101.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/get.js
-import { z as z103 } from "zod";
-var getParamsSchema = z103.object({
-  key: z103.string()
+import { z as z102 } from "zod";
+var getParamsSchema = z102.object({
+  key: z102.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/set.js
-import { z as z104 } from "zod";
-var setParamsSchema = z104.object({
-  key: z104.string(),
-  value: z104.any(),
+import { z as z103 } from "zod";
+var setParamsSchema = z103.object({
+  key: z103.string(),
+  value: z103.any(),
   /**
    * Time to live in milliseconds
    */
-  ttl: z104.number(),
-  recache: z104.boolean().optional()
+  ttl: z103.number(),
+  recache: z103.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/ttl.js
-import { z as z105 } from "zod";
-var ttlParamsSchema = z105.object({
-  key: z105.string()
+import { z as z104 } from "zod";
+var ttlParamsSchema = z104.object({
+  key: z104.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/weeklyReports.js
-import { z as z106 } from "zod";
+import { z as z105 } from "zod";
 import dayjs3 from "dayjs";
-var weeklyReportSchema = z106.object({
-  startDate: z106.string(),
-  endDate: z106.string(),
-  report: z106.string(),
-  aiInsights: z106.string().nullable()
+var weeklyReportSchema = z105.object({
+  startDate: z105.string(),
+  endDate: z105.string(),
+  report: z105.string(),
+  aiInsights: z105.string().nullable()
 });
 
 // ../../b4m-core/packages/services/dist/src/embeddingCacheService/generateCacheKey.js
 import crypto2 from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/researchAgentService/create.js
+import { z as z106 } from "zod";
+var researchAgentCreateSchema = z106.object({
+  name: z106.string().min(1),
+  description: z106.string().min(1)
+});
+
+// ../../b4m-core/packages/services/dist/src/researchAgentService/update.js
 import { z as z107 } from "zod";
-var researchAgentCreateSchema = z107.object({
+var researchAgentUpdateSchema = z107.object({
+  id: z107.string(),
   name: z107.string().min(1),
   description: z107.string().min(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/update.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
 import { z as z108 } from "zod";
-var researchAgentUpdateSchema = z108.object({
-  id: z108.string(),
-  name: z108.string().min(1),
-  description: z108.string().min(1)
+var researchAgentRemoveSchema = z108.object({
+  id: z108.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
 import { z as z109 } from "zod";
-var researchAgentRemoveSchema = z109.object({
+var researchAgentGetSchema = z109.object({
   id: z109.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
-import { z as z110 } from "zod";
-var researchAgentGetSchema = z110.object({
-  id: z110.string()
-});
-
 // ../../b4m-core/packages/services/dist/src/researchAgentService/listFiles.js
-import { z as z111 } from "zod";
-var researchAgentListFilesSchema = z111.object({
+import { z as z110 } from "zod";
+var researchAgentListFilesSchema = z110.object({
   /**
    * The ID of the research agent
    */
-  id: z111.string()
+  id: z110.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-import { z as z112 } from "zod";
+import { z as z111 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/lib/turndown.js
 import turndown from "turndown";
@@ -3553,316 +3459,316 @@ var deepResearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-var ResearchTaskProcessSchema = z112.object({
-  id: z112.string()
+var ResearchTaskProcessSchema = z111.object({
+  id: z111.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/create.js
-import { z as z113 } from "zod";
-var researchTaskCreateSchema = z113.object({
-  researchAgentId: z113.string(),
-  title: z113.string().max(100),
-  description: z113.string().max(500),
-  prompt: z113.string().max(500).optional(),
-  type: z113.nativeEnum(ResearchTaskType),
-  executionType: z113.nativeEnum(ResearchTaskExecutionType).default(ResearchTaskExecutionType.ON_DEMAND),
-  fileTagId: z113.string().optional(),
-  autoGeneratedTag: z113.object({
-    name: z113.string(),
-    icon: z113.string(),
-    color: z113.string()
+import { z as z112 } from "zod";
+var researchTaskCreateSchema = z112.object({
+  researchAgentId: z112.string(),
+  title: z112.string().max(100),
+  description: z112.string().max(500),
+  prompt: z112.string().max(500).optional(),
+  type: z112.nativeEnum(ResearchTaskType),
+  executionType: z112.nativeEnum(ResearchTaskExecutionType).default(ResearchTaskExecutionType.ON_DEMAND),
+  fileTagId: z112.string().optional(),
+  autoGeneratedTag: z112.object({
+    name: z112.string(),
+    icon: z112.string(),
+    color: z112.string()
   }).optional()
 });
 var researchTaskScrapeCreateSchema = researchTaskCreateSchema.extend({
-  urls: z113.array(z113.string().url()).min(1),
-  canDiscoverLinks: z113.boolean()
+  urls: z112.array(z112.string().url()).min(1),
+  canDiscoverLinks: z112.boolean()
 });
 var researchTaskPeriodicCreateSchema = researchTaskCreateSchema.extend({
-  executionPeriodicStartAt: z113.coerce.date(),
-  executionPeriodicEndAt: z113.coerce.date(),
-  executionPeriodicFrequency: z113.nativeEnum(ResearchTaskPeriodicFrequencyType)
+  executionPeriodicStartAt: z112.coerce.date(),
+  executionPeriodicEndAt: z112.coerce.date(),
+  executionPeriodicFrequency: z112.nativeEnum(ResearchTaskPeriodicFrequencyType)
 });
 var researchTaskScheduledCreateSchema = researchTaskCreateSchema.extend({
-  executionScheduledAt: z113.coerce.date()
+  executionScheduledAt: z112.coerce.date()
 });
 var researchTaskDeepResearchCreateSchema = researchTaskCreateSchema.extend({
-  maxDepth: z113.number().min(1).max(10).optional()
+  maxDepth: z112.number().min(1).max(10).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/search.js
-import { z as z114 } from "zod";
-var searchResearchTasksSchema = z114.object({
-  search: z114.string().optional(),
+import { z as z113 } from "zod";
+var searchResearchTasksSchema = z113.object({
+  search: z113.string().optional(),
   // ADD FILTERS SCHEMA HERE
   // filters: z
   //   .object({
   //     userId: z.string().optional(),
   //   })
   //   .optional(),
-  pagination: z114.object({
-    page: z114.coerce.number().optional(),
-    limit: z114.coerce.number().optional()
+  pagination: z113.object({
+    page: z113.coerce.number().optional(),
+    limit: z113.coerce.number().optional()
   }).optional(),
-  orderBy: z114.object({
-    by: z114.enum(["createdAt", "updatedAt"]).optional(),
-    direction: z114.enum(["asc", "desc"]).optional()
+  orderBy: z113.object({
+    by: z113.enum(["createdAt", "updatedAt"]).optional(),
+    direction: z113.enum(["asc", "desc"]).optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/get.js
-import { z as z115 } from "zod";
-var getResearchTaskSchema = z115.object({
-  id: z115.string().min(1)
+import { z as z114 } from "zod";
+var getResearchTaskSchema = z114.object({
+  id: z114.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/update.js
-import { z as z116 } from "zod";
-var updateResearchTaskSchema = z116.object({
-  id: z116.string(),
-  title: z116.string(),
-  description: z116.string(),
-  type: z116.nativeEnum(ResearchTaskType)
+import { z as z115 } from "zod";
+var updateResearchTaskSchema = z115.object({
+  id: z115.string(),
+  title: z115.string(),
+  description: z115.string(),
+  type: z115.nativeEnum(ResearchTaskType)
 });
 var researchTaskScrapeUpdateSchema = updateResearchTaskSchema.extend({
-  urls: z116.array(z116.string().url()).min(1),
-  canDiscoverLinks: z116.boolean()
+  urls: z115.array(z115.string().url()).min(1),
+  canDiscoverLinks: z115.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/listByAgentId.js
-import { z as z117 } from "zod";
-var listByAgentIdSchema = z117.object({
-  researchAgentId: z117.string()
+import { z as z116 } from "zod";
+var listByAgentIdSchema = z116.object({
+  researchAgentId: z116.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/remove.js
-import { z as z118 } from "zod";
-var researchTaskRemoveSchema = z118.object({
-  id: z118.string().min(1)
+import { z as z117 } from "zod";
+var researchTaskRemoveSchema = z117.object({
+  id: z117.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/retry.js
-import { z as z119 } from "zod";
-var researchTaskRetrySchema = z119.object({
-  id: z119.string(),
-  userId: z119.string()
+import { z as z118 } from "zod";
+var researchTaskRetrySchema = z118.object({
+  id: z118.string(),
+  userId: z118.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/processDiscoveredLinks.js
 import axios4 from "axios";
-import { z as z120 } from "zod";
+import { z as z119 } from "zod";
 import plimit from "p-limit";
 import pLimit2 from "p-limit";
-var researchTaskProcessDiscoveredLinksSchema = z120.object({
-  id: z120.string()
+var researchTaskProcessDiscoveredLinksSchema = z119.object({
+  id: z119.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/downloadRelevantLinks.js
-import { z as z121 } from "zod";
+import { z as z120 } from "zod";
 import plimit2 from "p-limit";
 import axios5 from "axios";
 import { fileTypeFromBuffer } from "file-type";
-var researchTaskDownloadRelevantLinksSchema = z121.object({
-  id: z121.string()
+var researchTaskDownloadRelevantLinksSchema = z120.object({
+  id: z120.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchData/remove.js
-import { z as z122 } from "zod";
-var researchDataRemoveSchema = z122.object({
-  id: z122.string(),
-  researchAgentId: z122.string()
+import { z as z121 } from "zod";
+var researchDataRemoveSchema = z121.object({
+  id: z121.string(),
+  researchAgentId: z121.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/taskSchedulerService/create.js
-import { z as z123 } from "zod";
-var researchTaskPayload = z123.object({
-  id: z123.string(),
-  userId: z123.string()
+import { z as z122 } from "zod";
+var researchTaskPayload = z122.object({
+  id: z122.string(),
+  userId: z122.string()
 });
-var customTaskPayload = z123.object({
-  test: z123.string()
+var customTaskPayload = z122.object({
+  test: z122.string()
 });
-var taskSchedulerCreate = z123.discriminatedUnion("handler", [
-  z123.object({
-    handler: z123.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
+var taskSchedulerCreate = z122.discriminatedUnion("handler", [
+  z122.object({
+    handler: z122.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
     payload: researchTaskPayload,
-    processDate: z123.date()
+    processDate: z122.date()
   }),
-  z123.object({
-    handler: z123.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
+  z122.object({
+    handler: z122.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
     payload: customTaskPayload,
-    processDate: z123.date()
+    processDate: z122.date()
   })
 ]);
 
 // ../../b4m-core/packages/services/dist/src/tagService/createFileTag.js
+import { z as z123 } from "zod";
+var tagCreateFileTagSchema = z123.object({
+  name: z123.string(),
+  icon: z123.string().optional(),
+  color: z123.string().optional(),
+  description: z123.string().optional()
+});
+
+// ../../b4m-core/packages/services/dist/src/tagService/create.js
 import { z as z124 } from "zod";
-var tagCreateFileTagSchema = z124.object({
+var tagCreateSchema = z124.object({
   name: z124.string(),
   icon: z124.string().optional(),
+  description: z124.string().optional(),
   color: z124.string().optional(),
-  description: z124.string().optional()
+  type: z124.nativeEnum(TagType)
 });
 
-// ../../b4m-core/packages/services/dist/src/tagService/create.js
+// ../../b4m-core/packages/services/dist/src/tagService/update.js
 import { z as z125 } from "zod";
-var tagCreateSchema = z125.object({
-  name: z125.string(),
+var tagUpdateSchema = z125.object({
+  id: z125.string(),
+  name: z125.string().optional(),
   icon: z125.string().optional(),
   description: z125.string().optional(),
-  color: z125.string().optional(),
-  type: z125.nativeEnum(TagType)
-});
-
-// ../../b4m-core/packages/services/dist/src/tagService/update.js
-import { z as z126 } from "zod";
-var tagUpdateSchema = z126.object({
-  id: z126.string(),
-  name: z126.string().optional(),
-  icon: z126.string().optional(),
-  description: z126.string().optional(),
-  color: z126.string().optional()
+  color: z125.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/tagService/remove.js
-import { z as z127 } from "zod";
-var tagRemoveSchema = z127.object({
-  id: z127.string()
+import { z as z126 } from "zod";
+var tagRemoveSchema = z126.object({
+  id: z126.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/create.js
-import { z as z128 } from "zod";
-var createArtifactSchema = z128.object({
-  id: z128.string().optional(),
+import { z as z127 } from "zod";
+var createArtifactSchema = z127.object({
+  id: z127.string().optional(),
   // Allow custom ID for AI-generated artifacts
-  type: z128.enum(["mermaid", "recharts", "python", "react", "html", "svg", "code", "quest", "file", "questmaster"]),
-  title: z128.string().min(1).max(255),
-  description: z128.string().max(1e3).optional(),
-  content: z128.string().min(1),
-  projectId: z128.string().optional(),
-  organizationId: z128.string().optional(),
-  visibility: z128.enum(["private", "project", "organization", "public"]).default("private"),
-  tags: z128.array(z128.string().max(50)).max(20).default([]),
-  versionTag: z128.string().max(100).optional(),
-  sourceQuestId: z128.string().optional(),
-  sessionId: z128.string().optional(),
-  parentArtifactId: z128.string().optional(),
-  permissions: z128.object({
-    canRead: z128.array(z128.string()).default([]),
-    canWrite: z128.array(z128.string()).default([]),
-    canDelete: z128.array(z128.string()).default([]),
-    isPublic: z128.boolean().default(false),
-    inheritFromProject: z128.boolean().default(true)
+  type: z127.enum(["mermaid", "recharts", "python", "react", "html", "svg", "code", "quest", "file", "questmaster"]),
+  title: z127.string().min(1).max(255),
+  description: z127.string().max(1e3).optional(),
+  content: z127.string().min(1),
+  projectId: z127.string().optional(),
+  organizationId: z127.string().optional(),
+  visibility: z127.enum(["private", "project", "organization", "public"]).default("private"),
+  tags: z127.array(z127.string().max(50)).max(20).default([]),
+  versionTag: z127.string().max(100).optional(),
+  sourceQuestId: z127.string().optional(),
+  sessionId: z127.string().optional(),
+  parentArtifactId: z127.string().optional(),
+  permissions: z127.object({
+    canRead: z127.array(z127.string()).default([]),
+    canWrite: z127.array(z127.string()).default([]),
+    canDelete: z127.array(z127.string()).default([]),
+    isPublic: z127.boolean().default(false),
+    inheritFromProject: z127.boolean().default(true)
   }).optional(),
-  metadata: z128.record(z128.unknown()).default({})
+  metadata: z127.record(z127.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/get.js
-import { z as z129 } from "zod";
-var getArtifactSchema = z129.object({
-  id: z129.string(),
-  includeContent: z129.boolean().default(false),
-  includeVersions: z129.boolean().default(false),
-  version: z129.number().optional()
+import { z as z128 } from "zod";
+var getArtifactSchema = z128.object({
+  id: z128.string(),
+  includeContent: z128.boolean().default(false),
+  includeVersions: z128.boolean().default(false),
+  version: z128.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/list.js
-import { z as z130 } from "zod";
-var listArtifactsSchema = z130.object({
-  type: z130.string().optional(),
-  status: z130.enum(["draft", "review", "published", "archived"]).optional(),
-  visibility: z130.enum(["private", "project", "organization", "public"]).optional(),
-  projectId: z130.string().optional(),
-  sessionId: z130.string().optional(),
-  tags: z130.array(z130.string()).optional(),
-  search: z130.string().optional(),
-  limit: z130.number().min(1).max(100).default(20),
-  offset: z130.number().min(0).default(0),
-  sortBy: z130.enum(["createdAt", "updatedAt", "title", "type"]).default("updatedAt"),
-  sortOrder: z130.enum(["asc", "desc"]).default("desc"),
-  includeDeleted: z130.boolean().default(false)
+import { z as z129 } from "zod";
+var listArtifactsSchema = z129.object({
+  type: z129.string().optional(),
+  status: z129.enum(["draft", "review", "published", "archived"]).optional(),
+  visibility: z129.enum(["private", "project", "organization", "public"]).optional(),
+  projectId: z129.string().optional(),
+  sessionId: z129.string().optional(),
+  tags: z129.array(z129.string()).optional(),
+  search: z129.string().optional(),
+  limit: z129.number().min(1).max(100).default(20),
+  offset: z129.number().min(0).default(0),
+  sortBy: z129.enum(["createdAt", "updatedAt", "title", "type"]).default("updatedAt"),
+  sortOrder: z129.enum(["asc", "desc"]).default("desc"),
+  includeDeleted: z129.boolean().default(false)
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/update.js
-import { z as z131 } from "zod";
-var updateArtifactSchema = z131.object({
-  id: z131.string(),
-  title: z131.string().min(1).max(255).optional(),
-  description: z131.string().max(1e3).optional(),
-  content: z131.string().optional(),
-  visibility: z131.enum(["private", "project", "organization", "public"]).optional(),
-  status: z131.enum(["draft", "review", "published", "archived"]).optional(),
-  tags: z131.array(z131.string().max(50)).max(20).optional(),
-  versionTag: z131.string().max(100).optional(),
-  permissions: z131.object({
-    canRead: z131.array(z131.string()).optional(),
-    canWrite: z131.array(z131.string()).optional(),
-    canDelete: z131.array(z131.string()).optional(),
-    isPublic: z131.boolean().optional(),
-    inheritFromProject: z131.boolean().optional()
+import { z as z130 } from "zod";
+var updateArtifactSchema = z130.object({
+  id: z130.string(),
+  title: z130.string().min(1).max(255).optional(),
+  description: z130.string().max(1e3).optional(),
+  content: z130.string().optional(),
+  visibility: z130.enum(["private", "project", "organization", "public"]).optional(),
+  status: z130.enum(["draft", "review", "published", "archived"]).optional(),
+  tags: z130.array(z130.string().max(50)).max(20).optional(),
+  versionTag: z130.string().max(100).optional(),
+  permissions: z130.object({
+    canRead: z130.array(z130.string()).optional(),
+    canWrite: z130.array(z130.string()).optional(),
+    canDelete: z130.array(z130.string()).optional(),
+    isPublic: z130.boolean().optional(),
+    inheritFromProject: z130.boolean().optional()
   }).optional(),
-  metadata: z131.record(z131.unknown()).optional(),
-  changes: z131.array(z131.string()).optional(),
-  changeDescription: z131.string().max(1e3).optional(),
-  createNewVersion: z131.boolean().optional(),
-  versionMessage: z131.string().max(500).optional()
+  metadata: z130.record(z130.unknown()).optional(),
+  changes: z130.array(z130.string()).optional(),
+  changeDescription: z130.string().max(1e3).optional(),
+  createNewVersion: z130.boolean().optional(),
+  versionMessage: z130.string().max(500).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/delete.js
-import { z as z132 } from "zod";
-var deleteArtifactSchema = z132.object({
-  id: z132.string(),
-  hardDelete: z132.boolean().default(false)
+import { z as z131 } from "zod";
+var deleteArtifactSchema = z131.object({
+  id: z131.string(),
+  hardDelete: z131.boolean().default(false)
   // For future implementation
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/create.js
-import { z as z133 } from "zod";
-var questSchema = z133.object({
-  id: z133.string(),
-  title: z133.string().min(1).max(255),
-  description: z133.string().max(1e3),
-  status: z133.enum(["not_started", "in_progress", "completed", "blocked"]).default("not_started"),
-  order: z133.number().min(0),
-  dependencies: z133.array(z133.string()).default([]),
-  estimatedTime: z133.string().optional()
-});
-var questResourceSchema = z133.object({
-  title: z133.string().min(1).max(255),
-  url: z133.string().url(),
-  type: z133.enum(["documentation", "tutorial", "reference", "example"])
-});
-var createQuestMasterSchema = z133.object({
-  title: z133.string().min(1).max(255),
-  description: z133.string().max(1e3).optional(),
-  goal: z133.string().min(1).max(1e3),
-  complexity: z133.enum(["beginner", "intermediate", "advanced", "expert"]),
-  estimatedTotalTime: z133.string().optional(),
-  prerequisites: z133.array(z133.string().max(200)).default([]),
-  quests: z133.array(questSchema).min(1),
-  resources: z133.array(questResourceSchema).default([]),
-  projectId: z133.string().optional(),
-  organizationId: z133.string().optional(),
-  visibility: z133.enum(["private", "project", "organization", "public"]).default("private"),
-  tags: z133.array(z133.string().max(50)).max(20).default([]),
-  permissions: z133.object({
-    canRead: z133.array(z133.string()).default([]),
-    canWrite: z133.array(z133.string()).default([]),
-    canDelete: z133.array(z133.string()).default([]),
-    isPublic: z133.boolean().default(false),
-    inheritFromProject: z133.boolean().default(true)
+import { z as z132 } from "zod";
+var questSchema = z132.object({
+  id: z132.string(),
+  title: z132.string().min(1).max(255),
+  description: z132.string().max(1e3),
+  status: z132.enum(["not_started", "in_progress", "completed", "blocked"]).default("not_started"),
+  order: z132.number().min(0),
+  dependencies: z132.array(z132.string()).default([]),
+  estimatedTime: z132.string().optional()
+});
+var questResourceSchema = z132.object({
+  title: z132.string().min(1).max(255),
+  url: z132.string().url(),
+  type: z132.enum(["documentation", "tutorial", "reference", "example"])
+});
+var createQuestMasterSchema = z132.object({
+  title: z132.string().min(1).max(255),
+  description: z132.string().max(1e3).optional(),
+  goal: z132.string().min(1).max(1e3),
+  complexity: z132.enum(["beginner", "intermediate", "advanced", "expert"]),
+  estimatedTotalTime: z132.string().optional(),
+  prerequisites: z132.array(z132.string().max(200)).default([]),
+  quests: z132.array(questSchema).min(1),
+  resources: z132.array(questResourceSchema).default([]),
+  projectId: z132.string().optional(),
+  organizationId: z132.string().optional(),
+  visibility: z132.enum(["private", "project", "organization", "public"]).default("private"),
+  tags: z132.array(z132.string().max(50)).max(20).default([]),
+  permissions: z132.object({
+    canRead: z132.array(z132.string()).default([]),
+    canWrite: z132.array(z132.string()).default([]),
+    canDelete: z132.array(z132.string()).default([]),
+    isPublic: z132.boolean().default(false),
+    inheritFromProject: z132.boolean().default(true)
   }).optional(),
-  sourceQuestId: z133.string().optional(),
-  sessionId: z133.string().optional(),
-  metadata: z133.record(z133.unknown()).default({})
+  sourceQuestId: z132.string().optional(),
+  sessionId: z132.string().optional(),
+  metadata: z132.record(z132.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/updateQuestStatus.js
-import { z as z134 } from "zod";
-var updateQuestStatusSchema = z134.object({
-  artifactId: z134.string(),
-  questId: z134.string(),
-  status: z134.enum(["not_started", "in_progress", "completed", "blocked"]),
-  completionNote: z134.string().max(500).optional()
+import { z as z133 } from "zod";
+var updateQuestStatusSchema = z133.object({
+  artifactId: z133.string(),
+  questId: z133.string(),
+  status: z133.enum(["not_started", "in_progress", "completed", "blocked"]),
+  completionNote: z133.string().max(500).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/dataLakeService/opensearchClient.js
@@ -3882,63 +3788,63 @@ import { v4 as uuidv44 } from "uuid";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/emailIngestionService/types.js
-import { z as z135 } from "zod";
-var processIngestedEmailOptionsSchema = z135.object({
-  platformDomain: z135.string().optional(),
-  isNewsletter: z135.boolean().optional()
+import { z as z134 } from "zod";
+var processIngestedEmailOptionsSchema = z134.object({
+  platformDomain: z134.string().optional(),
+  isNewsletter: z134.boolean().optional()
 }).optional();
-var emailAttachmentSchema = z135.object({
-  filename: z135.string().optional(),
-  contentType: z135.string().optional(),
-  contentDisposition: z135.string().optional(),
-  size: z135.number().min(0),
-  content: z135.instanceof(Buffer),
-  related: z135.boolean().optional()
-});
-var parsedEmailObjectSchema = z135.object({
-  messageId: z135.string().optional(),
-  inReplyTo: z135.string().optional(),
-  references: z135.union([z135.string(), z135.array(z135.string())]).optional(),
-  from: z135.any().optional(),
+var emailAttachmentSchema = z134.object({
+  filename: z134.string().optional(),
+  contentType: z134.string().optional(),
+  contentDisposition: z134.string().optional(),
+  size: z134.number().min(0),
+  content: z134.instanceof(Buffer),
+  related: z134.boolean().optional()
+});
+var parsedEmailObjectSchema = z134.object({
+  messageId: z134.string().optional(),
+  inReplyTo: z134.string().optional(),
+  references: z134.union([z134.string(), z134.array(z134.string())]).optional(),
+  from: z134.any().optional(),
   // Complex email address object
-  to: z135.any().optional(),
-  cc: z135.any().optional(),
-  bcc: z135.any().optional(),
-  subject: z135.string().optional(),
-  date: z135.date().optional(),
-  text: z135.string().optional(),
-  html: z135.string().optional(),
-  attachments: z135.array(emailAttachmentSchema).optional()
-});
-var processIngestedEmailSchema = z135.object({
+  to: z134.any().optional(),
+  cc: z134.any().optional(),
+  bcc: z134.any().optional(),
+  subject: z134.string().optional(),
+  date: z134.date().optional(),
+  text: z134.string().optional(),
+  html: z134.string().optional(),
+  attachments: z134.array(emailAttachmentSchema).optional()
+});
+var processIngestedEmailSchema = z134.object({
   parsedEmail: parsedEmailObjectSchema,
-  rawEmailS3Key: z135.string().min(1, "rawEmailS3Key cannot be empty"),
+  rawEmailS3Key: z134.string().min(1, "rawEmailS3Key cannot be empty"),
   options: processIngestedEmailOptionsSchema
 });
 
 // ../../b4m-core/packages/services/dist/src/emailAnalysisService/types.js
-import { z as z136 } from "zod";
-var llmAnalysisResponseSchema = z136.object({
-  summary: z136.string().min(1, "Summary cannot be empty"),
-  entities: z136.object({
-    companies: z136.array(z136.string()).default([]),
-    people: z136.array(z136.string()).default([]),
-    products: z136.array(z136.string()).default([]),
-    technologies: z136.array(z136.string()).default([])
+import { z as z135 } from "zod";
+var llmAnalysisResponseSchema = z135.object({
+  summary: z135.string().min(1, "Summary cannot be empty"),
+  entities: z135.object({
+    companies: z135.array(z135.string()).default([]),
+    people: z135.array(z135.string()).default([]),
+    products: z135.array(z135.string()).default([]),
+    technologies: z135.array(z135.string()).default([])
   }),
-  sentiment: z136.enum(["positive", "neutral", "negative", "urgent"]),
-  actionItems: z136.array(z136.object({
-    description: z136.string(),
-    deadline: z136.string().optional()
+  sentiment: z135.enum(["positive", "neutral", "negative", "urgent"]),
+  actionItems: z135.array(z135.object({
+    description: z135.string(),
+    deadline: z135.string().optional()
     // ISO date string from LLM
   })).default([]),
-  privacyRecommendation: z136.enum(["public", "team", "private"]),
-  embargoDetected: z136.boolean().default(false),
-  suggestedTags: z136.array(z136.string()).default([])
+  privacyRecommendation: z135.enum(["public", "team", "private"]),
+  embargoDetected: z135.boolean().default(false),
+  suggestedTags: z135.array(z135.string()).default([])
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletion.js
-import { z as z138 } from "zod";
+import { z as z137 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionInvoke.js
 import { fromZodError } from "zod-validation-error";
@@ -4052,8 +3958,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path13 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path13;
+    const path11 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path11;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -4998,17 +4904,17 @@ var rechartsTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editFile/index.js
-import { z as z137 } from "zod";
+import { z as z136 } from "zod";
 import { diffLines as diffLines2 } from "diff";
-var editFileSchema = z137.object({
-  fileId: z137.string().describe("The ID of the file to edit"),
-  instruction: z137.string().describe("Natural language instruction describing the changes to make"),
-  selection: z137.object({
-    start: z137.number().describe("Starting character position of the selection"),
-    end: z137.number().describe("Ending character position of the selection")
+var editFileSchema = z136.object({
+  fileId: z136.string().describe("The ID of the file to edit"),
+  instruction: z136.string().describe("Natural language instruction describing the changes to make"),
+  selection: z136.object({
+    start: z136.number().describe("Starting character position of the selection"),
+    end: z136.number().describe("Ending character position of the selection")
   }).optional().describe("Optional selection range to edit within the file"),
-  preserveFormatting: z137.boolean().optional().default(true).describe("Whether to preserve the original formatting style"),
-  returnDiff: z137.boolean().optional().default(true).describe("Whether to return a diff of the changes")
+  preserveFormatting: z136.boolean().optional().default(true).describe("Whether to preserve the original formatting style"),
+  returnDiff: z136.boolean().optional().default(true).describe("Whether to return a diff of the changes")
 });
 function generateSimpleDiff(original, modified) {
   const differences = diffLines2(original, modified);
@@ -5237,8 +5143,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path13 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path13;
+  const path11 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path11;
 }
 async function updateQuestAndReturnMarkdown2(storedImagePath, context) {
   await context.onFinish?.("edit_image", storedImagePath);
@@ -6767,8 +6673,8 @@ var getHeliocentricCoords = (planet, T) => {
   const sinNode = Math.sin(longNode);
   const x = r * (cosNode * cosOmega - sinNode * sinOmega * cosI);
   const y = r * (sinNode * cosOmega + cosNode * sinOmega * cosI);
-  const z144 = r * sinOmega * sinI;
-  return { x, y, z: z144, r };
+  const z143 = r * sinOmega * sinI;
+  return { x, y, z: z143, r };
 };
 var getGeocentricEcliptic = (planet, earth) => {
   const dx = planet.x - earth.x;
@@ -7075,33 +6981,33 @@ var planetVisibilityTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
-import { promises as fs7 } from "fs";
-import { existsSync as existsSync2, statSync as statSync3 } from "fs";
-import path6 from "path";
-var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
+import { promises as fs5 } from "fs";
+import { existsSync as existsSync2, statSync } from "fs";
+import path4 from "path";
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
 async function readFileContent(params) {
   const { path: filePath, encoding = "utf-8", maxLines } = params;
-  const normalizedPath = path6.normalize(filePath);
-  const resolvedPath = path6.resolve(process.cwd(), normalizedPath);
-  const cwd = path6.resolve(process.cwd());
+  const normalizedPath = path4.normalize(filePath);
+  const resolvedPath = path4.resolve(process.cwd(), normalizedPath);
+  const cwd = path4.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
   if (!existsSync2(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const stats = statSync3(resolvedPath);
+  const stats = statSync(resolvedPath);
   if (stats.isDirectory()) {
     throw new Error(`Path is a directory, not a file: ${filePath}`);
   }
-  if (stats.size > MAX_FILE_SIZE2) {
-    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE2 / 1024 / 1024}MB)`);
+  if (stats.size > MAX_FILE_SIZE) {
+    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE / 1024 / 1024}MB)`);
   }
   const isBinary = await checkIfBinary(resolvedPath);
   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 fs7.readFile(resolvedPath, encoding);
+  const content = await fs5.readFile(resolvedPath, encoding);
   if (maxLines && typeof content === "string") {
     const lines = content.split("\n");
     if (lines.length > maxLines) {
@@ -7116,7 +7022,7 @@ ${content}`;
 }
 async function checkIfBinary(filePath) {
   const buffer = Buffer.alloc(8192);
-  const fd = await fs7.open(filePath, "r");
+  const fd = await fs5.open(filePath, "r");
   try {
     const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
     const chunk = buffer.slice(0, bytesRead);
@@ -7133,7 +7039,7 @@ var fileReadTool = {
       context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
       try {
         const content = await readFileContent(params);
-        const stats = statSync3(path6.resolve(process.cwd(), path6.normalize(params.path)));
+        const stats = statSync(path4.resolve(process.cwd(), path4.normalize(params.path)));
         context.logger.info("\u2705 FileRead: Success", {
           path: params.path,
           size: stats.size,
@@ -7172,25 +7078,25 @@ var fileReadTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
-import { promises as fs8 } from "fs";
+import { promises as fs6 } from "fs";
 import { existsSync as existsSync3 } from "fs";
-import path7 from "path";
+import path5 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
-  const normalizedPath = path7.normalize(filePath);
-  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
-  const cwd = path7.resolve(process.cwd());
+  const normalizedPath = path5.normalize(filePath);
+  const resolvedPath = path5.resolve(process.cwd(), normalizedPath);
+  const cwd = path5.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
   const fileExists = existsSync3(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
-    const dir = path7.dirname(resolvedPath);
-    await fs8.mkdir(dir, { recursive: true });
+    const dir = path5.dirname(resolvedPath);
+    await fs6.mkdir(dir, { recursive: true });
   }
-  await fs8.writeFile(resolvedPath, content, "utf-8");
-  const stats = await fs8.stat(resolvedPath);
+  await fs6.writeFile(resolvedPath, content, "utf-8");
+  const stats = await fs6.stat(resolvedPath);
   const lines = content.split("\n").length;
   return `File ${action} successfully: ${filePath}
 Size: ${stats.size} bytes
@@ -7201,7 +7107,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync3(path7.resolve(process.cwd(), path7.normalize(params.path)));
+      const fileExists = existsSync3(path5.resolve(process.cwd(), path5.normalize(params.path)));
       context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
         path: params.path,
         size: params.content.length
@@ -7242,8 +7148,8 @@ var createFileTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
 import { readdir } from "fs/promises";
-import { statSync as statSync4 } from "fs";
-import path8 from "path";
+import { statSync as statSync2 } from "fs";
+import path6 from "path";
 function matchGlob(filePath, pattern) {
   let regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
   regexPattern = regexPattern.replace(/\{\{GLOBSTAR\}\}\//g, "(.*/)?").replace(/\/\{\{GLOBSTAR\}\}/g, "(/.*)?").replace(/\{\{GLOBSTAR\}\}/g, ".*");
@@ -7261,8 +7167,8 @@ async function walkDir(dir, pattern, includeHidden, maxResults, basePath = "") {
       if (!includeHidden && entry.name.startsWith(".")) {
         continue;
       }
-      const relativePath = basePath ? path8.join(basePath, entry.name) : entry.name;
-      const fullPath = path8.join(dir, entry.name);
+      const relativePath = basePath ? path6.join(basePath, entry.name) : entry.name;
+      const fullPath = path6.join(dir, entry.name);
       if (matchGlob(relativePath, pattern)) {
         matches.push(relativePath);
       }
@@ -7278,7 +7184,7 @@ async function walkDir(dir, pattern, includeHidden, maxResults, basePath = "") {
 async function listFiles(params) {
   const { pattern, cwd: relativeCwd, includeHidden = false, maxResults = 1e3 } = params;
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path8.resolve(baseCwd, path8.normalize(relativeCwd)) : baseCwd;
+  const targetCwd = relativeCwd ? path6.resolve(baseCwd, path6.normalize(relativeCwd)) : baseCwd;
   if (!targetCwd.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot list files outside of current working directory`);
   }
@@ -7289,8 +7195,8 @@ async function listFiles(params) {
   const filesInfo = [];
   for (const match of matches) {
     try {
-      const fullPath = path8.join(targetCwd, match);
-      const stats = statSync4(fullPath);
+      const fullPath = path6.join(targetCwd, match);
+      const stats = statSync2(fullPath);
       filesInfo.push({
         path: match,
         size: stats.size,
@@ -7371,9 +7277,9 @@ var globFilesTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
 import { readdir as readdir2 } from "fs/promises";
-import { readFileSync as readFileSync2, statSync as statSync5 } from "fs";
-import path9 from "path";
-var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
+import { readFileSync, statSync as statSync3 } from "fs";
+import path7 from "path";
+var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 function matchGlob2(filePath, pattern) {
   const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
   const regex = new RegExp(`^${regexPattern}$`);
@@ -7390,8 +7296,8 @@ async function walkDir2(dir, pattern, maxResults, basePath = "") {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const relativePath = basePath ? path9.join(basePath, entry.name) : entry.name;
-      const fullPath = path9.join(dir, entry.name);
+      const relativePath = basePath ? path7.join(basePath, entry.name) : entry.name;
+      const fullPath = path7.join(dir, entry.name);
       if (matchGlob2(relativePath, pattern)) {
         matches.push(relativePath);
       }
@@ -7404,10 +7310,10 @@ async function walkDir2(dir, pattern, maxResults, basePath = "") {
   }
   return matches;
 }
-async function searchFiles2(params) {
+async function searchFiles(params) {
   const { pattern, filePattern = "**/*", cwd: relativeCwd, caseSensitive = false, maxResults = 100, contextLines = 0 } = params;
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path9.resolve(baseCwd, path9.normalize(relativeCwd)) : baseCwd;
+  const targetCwd = relativeCwd ? path7.resolve(baseCwd, path7.normalize(relativeCwd)) : baseCwd;
   if (!targetCwd.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot search files outside of current working directory`);
   }
@@ -7421,13 +7327,13 @@ async function searchFiles2(params) {
   const filesToSearch = await walkDir2(targetCwd, filePattern, 1e4);
   const filteredFiles = [];
   for (const match of filesToSearch) {
-    const fullPath = path9.join(targetCwd, match);
+    const fullPath = path7.join(targetCwd, match);
     try {
-      const stats = statSync5(fullPath);
-      if (stats.isDirectory() || stats.size > MAX_FILE_SIZE3) {
+      const stats = statSync3(fullPath);
+      if (stats.isDirectory() || stats.size > MAX_FILE_SIZE2) {
         continue;
       }
-      if (isBinaryFile2(fullPath)) {
+      if (isBinaryFile(fullPath)) {
         continue;
       }
       filteredFiles.push(match);
@@ -7445,9 +7351,9 @@ async function searchFiles2(params) {
       break;
     }
     filesSearched++;
-    const fullPath = path9.join(targetCwd, file);
+    const fullPath = path7.join(targetCwd, file);
     try {
-      const content = readFileSync2(fullPath, "utf-8");
+      const content = readFileSync(fullPath, "utf-8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (matches.length >= maxResults) {
@@ -7511,7 +7417,7 @@ ${match.context.after.map((l) => `     ${l}`).join("\n")}`;
   }).join("\n");
   return `${summary}${patternInfo}${cwdInfo}${matchesList}`;
 }
-function isBinaryFile2(filePath) {
+function isBinaryFile(filePath) {
   try {
     const buffer = Buffer.alloc(8192);
     const fd = __require("fs").openSync(filePath, "r");
@@ -7534,7 +7440,7 @@ var grepSearchTool = {
         cwd: params.cwd || "."
       });
       try {
-        const result = await searchFiles2(params);
+        const result = await searchFiles(params);
         context.logger.info("\u2705 GrepSearch: Success");
         return result;
       } catch (error) {
@@ -7580,31 +7486,31 @@ var grepSearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
-import { promises as fs9 } from "fs";
-import { existsSync as existsSync4, statSync as statSync6 } from "fs";
-import path10 from "path";
+import { promises as fs7 } from "fs";
+import { existsSync as existsSync4, statSync as statSync4 } from "fs";
+import path8 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
-  const normalizedPath = path10.normalize(filePath);
-  const resolvedPath = path10.resolve(process.cwd(), normalizedPath);
-  const cwd = path10.resolve(process.cwd());
+  const normalizedPath = path8.normalize(filePath);
+  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
+  const cwd = path8.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
   if (!existsSync4(resolvedPath)) {
     throw new Error(`File or directory not found: ${filePath}`);
   }
-  const stats = statSync6(resolvedPath);
+  const stats = statSync4(resolvedPath);
   const isDirectory = stats.isDirectory();
   const size = stats.size;
   if (isDirectory && !recursive) {
     throw new Error(`Path is a directory: ${filePath}. Use recursive=true to delete directories and their contents.`);
   }
   if (isDirectory) {
-    await fs9.rm(resolvedPath, { recursive: true, force: true });
+    await fs7.rm(resolvedPath, { recursive: true, force: true });
     return `Directory deleted successfully: ${filePath}`;
   } else {
-    await fs9.unlink(resolvedPath);
+    await fs7.unlink(resolvedPath);
     return `File deleted successfully: ${filePath}
 Size: ${size} bytes`;
   }
@@ -7614,8 +7520,8 @@ var deleteFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const resolvedPath = path10.resolve(process.cwd(), path10.normalize(params.path));
-      const isDirectory = existsSync4(resolvedPath) && statSync6(resolvedPath).isDirectory();
+      const resolvedPath = path8.resolve(process.cwd(), path8.normalize(params.path));
+      const isDirectory = existsSync4(resolvedPath) && statSync4(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -7793,42 +7699,42 @@ var DISABLE_SERVER_THROTTLING = process.env.DISABLE_SERVER_THROTTLING === "true"
 var questSaveMutex = new Mutex();
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletion.js
-var QuestStartBodySchema = z138.object({
-  userId: z138.string(),
-  sessionId: z138.string(),
-  questId: z138.string(),
-  message: z138.string(),
-  messageFileIds: z138.array(z138.string()),
-  historyCount: z138.number(),
-  fabFileIds: z138.array(z138.string()),
+var QuestStartBodySchema = z137.object({
+  userId: z137.string(),
+  sessionId: z137.string(),
+  questId: z137.string(),
+  message: z137.string(),
+  messageFileIds: z137.array(z137.string()),
+  historyCount: z137.number(),
+  fabFileIds: z137.array(z137.string()),
   params: ChatCompletionCreateInputSchema,
   dashboardParams: DashboardParamsSchema.optional(),
-  enableQuestMaster: z138.boolean().optional(),
-  enableMementos: z138.boolean().optional(),
-  enableArtifacts: z138.boolean().optional(),
-  enableAgents: z138.boolean().optional(),
+  enableQuestMaster: z137.boolean().optional(),
+  enableMementos: z137.boolean().optional(),
+  enableArtifacts: z137.boolean().optional(),
+  enableAgents: z137.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
-  tools: z138.array(z138.union([b4mLLMTools, z138.string()])).optional(),
-  mcpServers: z138.array(z138.string()).optional(),
-  projectId: z138.string().optional(),
-  organizationId: z138.string().nullable().optional(),
+  tools: z137.array(z137.union([b4mLLMTools, z137.string()])).optional(),
+  mcpServers: z137.array(z137.string()).optional(),
+  projectId: z137.string().optional(),
+  organizationId: z137.string().nullable().optional(),
   questMaster: QuestMasterParamsSchema.optional(),
-  toolPromptId: z138.string().optional(),
+  toolPromptId: z137.string().optional(),
   researchMode: ResearchModeParamsSchema.optional(),
-  fallbackModel: z138.string().optional(),
-  embeddingModel: z138.string().optional(),
-  queryComplexity: z138.string(),
+  fallbackModel: z137.string().optional(),
+  embeddingModel: z137.string().optional(),
+  queryComplexity: z137.string(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z138.object({
-    maxDepth: z138.number().optional(),
-    duration: z138.number().optional(),
+  deepResearchConfig: z137.object({
+    maxDepth: z137.number().optional(),
+    duration: z137.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z138.array(z138.any()).optional()
+    searchers: z137.array(z137.any()).optional()
   }).optional(),
-  extraContextMessages: z138.array(z138.object({
-    role: z138.enum(["user", "assistant", "system", "function", "tool"]),
-    content: z138.union([z138.string(), z138.array(z138.any())]),
-    fabFileIds: z138.array(z138.string()).optional()
+  extraContextMessages: z137.array(z137.object({
+    role: z137.enum(["user", "assistant", "system", "function", "tool"]),
+    content: z137.union([z137.string(), z137.array(z137.any())]),
+    fabFileIds: z137.array(z137.string()).optional()
   })).optional()
 });
 
@@ -7836,9 +7742,30 @@ var QuestStartBodySchema = z138.object({
 import axios8 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer4 } from "file-type";
 import { v4 as uuidv47 } from "uuid";
-import { z as z139 } from "zod";
+import { z as z138 } from "zod";
 import { fromZodError as fromZodError2 } from "zod-validation-error";
 var ImageGenerationBodySchema = OpenAIImageGenerationInput.extend({
+  sessionId: z138.string(),
+  questId: z138.string(),
+  userId: z138.string(),
+  prompt: z138.string(),
+  safety_tolerance: z138.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z138.boolean().optional().default(false),
+  seed: z138.number().nullable().optional(),
+  output_format: z138.enum(["jpeg", "png"]).nullable().optional().default("png"),
+  width: z138.number().optional(),
+  height: z138.number().optional(),
+  aspect_ratio: z138.string().optional(),
+  fabFileIds: z138.array(z138.string()).optional()
+});
+
+// ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
+import axios9 from "axios";
+import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
+import { v4 as uuidv48 } from "uuid";
+import { z as z139 } from "zod";
+import { fromZodError as fromZodError3 } from "zod-validation-error";
+var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
   sessionId: z139.string(),
   questId: z139.string(),
   userId: z139.string(),
@@ -7846,56 +7773,35 @@ var ImageGenerationBodySchema = OpenAIImageGenerationInput.extend({
   safety_tolerance: z139.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
   prompt_upsampling: z139.boolean().optional().default(false),
   seed: z139.number().nullable().optional(),
-  output_format: z139.enum(["jpeg", "png"]).nullable().optional().default("png"),
+  output_format: z139.enum(["jpeg", "png"]).optional().default("png"),
   width: z139.number().optional(),
   height: z139.number().optional(),
   aspect_ratio: z139.string().optional(),
-  fabFileIds: z139.array(z139.string()).optional()
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
-import axios9 from "axios";
-import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
-import { v4 as uuidv48 } from "uuid";
-import { z as z140 } from "zod";
-import { fromZodError as fromZodError3 } from "zod-validation-error";
-var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z140.string(),
-  questId: z140.string(),
-  userId: z140.string(),
-  prompt: z140.string(),
-  safety_tolerance: z140.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z140.boolean().optional().default(false),
-  seed: z140.number().nullable().optional(),
-  output_format: z140.enum(["jpeg", "png"]).optional().default("png"),
-  width: z140.number().optional(),
-  height: z140.number().optional(),
-  aspect_ratio: z140.string().optional(),
-  size: z140.string().optional(),
-  fabFileIds: z140.array(z140.string()).optional(),
-  image: z140.string()
+  size: z139.string().optional(),
+  fabFileIds: z139.array(z139.string()).optional(),
+  image: z139.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/refineText.js
-import { z as z141 } from "zod";
-var refineTextLLMSchema = z141.object({
-  text: z141.string(),
-  context: z141.string().optional()
+import { z as z140 } from "zod";
+var refineTextLLMSchema = z140.object({
+  text: z140.string(),
+  context: z140.string().optional()
   // tone: z.enum(['formal', 'informal', 'neutral']).optional(),
   // style: z.enum(['technical', 'creative', 'academic', 'business', 'narrative']).optional(),
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/MementoEvaluationService.js
-import { z as z142 } from "zod";
-var SingleMementoEvalSchema = z142.object({
-  importance: z142.number().min(1).max(10),
+import { z as z141 } from "zod";
+var SingleMementoEvalSchema = z141.object({
+  importance: z141.number().min(1).max(10),
   // 1-10 scale for personal info importance
-  summary: z142.string(),
-  tags: z142.array(z142.string()).optional()
+  summary: z141.string(),
+  tags: z141.array(z141.string()).optional()
 });
-var MementoEvalResponseSchema = z142.object({
-  isPersonal: z142.boolean(),
-  mementos: z142.array(SingleMementoEvalSchema).optional()
+var MementoEvalResponseSchema = z141.object({
+  isPersonal: z141.boolean(),
+  mementos: z141.array(SingleMementoEvalSchema).optional()
   // Array of distinct personal information
 });
 
@@ -7941,7 +7847,7 @@ async function generateFileDeletePreview(args) {
     if (!existsSync5(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs11) => fs11.stat(args.path));
+    const stats = await import("fs/promises").then((fs9) => fs9.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -7957,21 +7863,21 @@ var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path13) {
+  async download(path11) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path13) {
+  async delete(path11) {
   }
-  async getSignedUrl(path13) {
-    return `/tmp/${path13}`;
+  async getSignedUrl(path11) {
+    return `/tmp/${path11}`;
   }
-  getPublicUrl(path13) {
-    return `/tmp/${path13}`;
+  getPublicUrl(path11) {
+    return `/tmp/${path11}`;
   }
-  async getPreview(path13) {
-    return `/tmp/${path13}`;
+  async getPreview(path11) {
+    return `/tmp/${path11}`;
   }
-  async getMetadata(path13) {
+  async getMetadata(path11) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -7991,7 +7897,7 @@ var CliLogger = class extends Logger {
   log(...args) {
   }
 };
-function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext) {
+function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore) {
   const originalFn = tool.toolFn;
   const toolName = tool.toolSchema.name;
   return {
@@ -8035,7 +7941,25 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
         throw new PermissionDeniedError(toolName, args);
       }
       if (response.action === "allow-always") {
-        permissionManager.trustTool(toolName);
+        const canTrust = permissionManager.trustTool(toolName);
+        if (canTrust) {
+          const projectDir = configStore.getProjectConfigDir();
+          if (projectDir) {
+            try {
+              await configStore.initProjectConfig();
+              const existingLocal = await configStore.loadRawProjectLocalConfig() || {};
+              const updatedLocal = {
+                ...existingLocal,
+                trustedTools: [...existingLocal.trustedTools || [], toolName]
+              };
+              await configStore.saveProjectLocalConfig(updatedLocal);
+            } catch (error) {
+              await configStore.trustTool(toolName);
+            }
+          } else {
+            await configStore.trustTool(toolName);
+          }
+        }
       }
       const result = await originalFn(args);
       agentContext.observationQueue.push({ toolName, result });
@@ -8043,7 +7967,7 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
     }
   };
 }
-function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, toolApiKeys) {
+function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, toolApiKeys) {
   const logger2 = new CliLogger();
   const storage = new NoOpStorage();
   const user = {
@@ -8127,13 +8051,15 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     toolConfig,
     model
   );
-  const tools2 = Object.entries(toolsMap).filter(([key]) => toolConfig[key] !== void 0).map(([_, tool]) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext));
+  const tools2 = Object.entries(toolsMap).filter(([key]) => toolConfig[key] !== void 0).map(
+    ([_, tool]) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore)
+  );
   return { tools: tools2, agentContext };
 }
 
 // src/config/toolSafety.ts
-import { z as z143 } from "zod";
-var ToolCategorySchema = z143.enum([
+import { z as z142 } from "zod";
+var ToolCategorySchema = z142.enum([
   "auto_approve",
   // Safe tools that run automatically without permission
   "prompt_always",
@@ -8141,9 +8067,9 @@ var ToolCategorySchema = z143.enum([
   "prompt_default"
   // Tools that prompt by default but can be trusted
 ]);
-var ToolSafetyConfigSchema = z143.object({
-  categories: z143.record(z143.string(), ToolCategorySchema),
-  trustedTools: z143.array(z143.string())
+var ToolSafetyConfigSchema = z142.object({
+  categories: z142.record(z142.string(), ToolCategorySchema),
+  trustedTools: z142.array(z142.string())
 });
 var DEFAULT_TOOL_CATEGORIES = {
   // ===== AUTO APPROVE (Safe tools) =====
@@ -8192,23 +8118,30 @@ function canTrustTool(toolName, customCategories) {
 
 // src/utils/PermissionManager.ts
 var PermissionManager = class {
-  constructor(trustedTools = [], customCategories) {
+  constructor(trustedTools = [], customCategories, deniedTools) {
     this.trustedTools = /* @__PURE__ */ new Set();
+    this.deniedTools = /* @__PURE__ */ new Set();
     this.trustedTools = new Set(trustedTools);
     this.customCategories = new Map(Object.entries(customCategories || {}));
+    this.deniedTools = new Set(deniedTools || []);
   }
   /**
    * Check if a tool needs permission before execution
    *
    * A tool needs permission if:
-   * 1. It's not in the auto_approve category, AND
-   * 2. It's not in the trusted tools set
+   * 1. It's in the denied tools list (from project config), OR
+   * 2. It's not in the auto_approve category, AND
+   * 3. It's not in the trusted tools set
    *
    * Note: prompt_always tools CANNOT be trusted, so they always need permission
+   * Note: denied tools from project config ALWAYS need permission (cannot be overridden locally)
    */
   needsPermission(toolName) {
     const categoryMap = Object.fromEntries(this.customCategories);
     const category = getToolCategory(toolName, categoryMap);
+    if (this.deniedTools.has(toolName)) {
+      return true;
+    }
     if (category === "auto_approve") {
       return false;
     }
@@ -8219,10 +8152,13 @@ var PermissionManager = class {
   }
   /**
    * Add a tool to the trusted list
-   * Returns false if the tool cannot be trusted (prompt_always category)
+   * Returns false if the tool cannot be trusted (prompt_always category or denied by project)
    */
   trustTool(toolName) {
     const categoryMap = Object.fromEntries(this.customCategories);
+    if (this.deniedTools.has(toolName)) {
+      return false;
+    }
     if (!canTrustTool(toolName, categoryMap)) {
       return false;
     }
@@ -8255,12 +8191,27 @@ var PermissionManager = class {
     return getToolCategory(toolName, categoryMap);
   }
   /**
-   * Check if a tool can be trusted (not in prompt_always category)
+   * Check if a tool can be trusted (not in prompt_always category or denied by project)
    */
   canBeTrusted(toolName) {
     const categoryMap = Object.fromEntries(this.customCategories);
+    if (this.deniedTools.has(toolName)) {
+      return false;
+    }
     return canTrustTool(toolName, categoryMap);
   }
+  /**
+   * Check if a tool is denied by project config
+   */
+  isDenied(toolName) {
+    return this.deniedTools.has(toolName);
+  }
+  /**
+   * Get list of denied tools
+   */
+  getDeniedTools() {
+    return Array.from(this.deniedTools).sort();
+  }
   /**
    * Clear all trusted tools
    */
@@ -8297,8 +8248,8 @@ function getEnvironmentName(configApiConfig) {
 }
 
 // src/utils/Logger.ts
-import fs10 from "fs/promises";
-import path11 from "path";
+import fs8 from "fs/promises";
+import path9 from "path";
 import os from "os";
 var Logger2 = class _Logger {
   constructor() {
@@ -8321,9 +8272,9 @@ var Logger2 = class _Logger {
    */
   async initialize(sessionId) {
     this.sessionId = sessionId;
-    const debugDir = path11.join(os.homedir(), ".bike4mind", "debug");
-    await fs10.mkdir(debugDir, { recursive: true });
-    this.logFilePath = path11.join(debugDir, `${sessionId}.txt`);
+    const debugDir = path9.join(os.homedir(), ".bike4mind", "debug");
+    await fs8.mkdir(debugDir, { recursive: true });
+    this.logFilePath = path9.join(debugDir, `${sessionId}.txt`);
     await this.writeToFile("INFO", "=== CLI SESSION START ===");
   }
   /**
@@ -8387,7 +8338,7 @@ var Logger2 = class _Logger {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
       const logEntry = `[${timestamp}] [${level}] ${message}
 `;
-      await fs10.appendFile(this.logFilePath, logEntry, "utf-8");
+      await fs8.appendFile(this.logFilePath, logEntry, "utf-8");
     } catch (error) {
       console.error("File logging failed:", error);
     }
@@ -8533,15 +8484,15 @@ var Logger2 = class _Logger {
   async cleanupOldLogs() {
     if (!this.fileLoggingEnabled) return;
     try {
-      const debugDir = path11.join(os.homedir(), ".bike4mind", "debug");
-      const files = await fs10.readdir(debugDir);
+      const debugDir = path9.join(os.homedir(), ".bike4mind", "debug");
+      const files = await fs8.readdir(debugDir);
       const now = Date.now();
       const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
       for (const file of files) {
-        const filePath = path11.join(debugDir, file);
-        const stats = await fs10.stat(filePath);
+        const filePath = path9.join(debugDir, file);
+        const stats = await fs8.stat(filePath);
         if (stats.mtime.getTime() < thirtyDaysAgo) {
-          await fs10.unlink(filePath);
+          await fs8.unlink(filePath);
         }
       }
     } catch (error) {
@@ -8554,8 +8505,8 @@ var logger = Logger2.getInstance();
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path12 from "path";
-import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
+import path10 from "path";
+import { existsSync as existsSync6, readdirSync } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
@@ -8580,20 +8531,20 @@ var MCPClient = class {
       const root = process.env.INIT_CWD || process.cwd();
       const candidatePaths = [
         // When running from SST Lambda with node_modules structure (copyFiles)
-        path12.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
         // When running from SST Lambda deployed environment (/var/task)
-        path12.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
         // When running from SST Lambda (.sst/artifacts/mcpHandler-dev), navigate to monorepo root (3 levels up)
-        path12.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
         // When running from packages/client (Next.js app), navigate to monorepo root (2 levels up)
-        path12.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
         // Original paths (backward compatibility)
-        path12.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-        path12.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+        path10.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
       ];
       const serverScriptPath = candidatePaths.find((p) => existsSync6(p));
       if (!serverScriptPath) {
-        const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+        const getDirectories = (source) => readdirSync(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
         console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
         console.error(`[MCP] Available directories in ${root}:`, getDirectories(root));
         throw new Error(`MCP Server script path not found for ${this.serverName}. Root: ${root}, Available dirs: ${getDirectories(root).join(", ")}`);
@@ -8622,7 +8573,7 @@ var MCPClient = class {
         }
       };
       await this.mcp.connect(this.transport);
-      await new Promise((resolve3) => setTimeout(resolve3, 100));
+      await new Promise((resolve) => setTimeout(resolve, 100));
       const toolsResult = await this.mcp.listTools();
       this.tools = toolsResult.tools.map((tool) => {
         return {
@@ -8805,7 +8756,7 @@ var ServerLlmBackend = class {
    */
   async complete(model, messages, options, callback) {
     logger.debug(`[ServerLlmBackend] Starting complete() with model: ${model}`);
-    return new Promise(async (resolve3, reject) => {
+    return new Promise(async (resolve, reject) => {
       try {
         logger.debug("[ServerLlmBackend] Making streaming request...");
         const response = await this.makeStreamingRequest(model, messages, options);
@@ -8835,15 +8786,15 @@ var ServerLlmBackend = class {
                   reject(err);
                 }).then(() => {
                   logger.debug("[ServerLlmBackend] Callback completed, resolving");
-                  resolve3();
+                  resolve();
                 });
               } else if (cleanedText) {
                 callback([cleanedText], lastUsageInfo).catch((err) => {
                   logger.error("[ServerLlmBackend] Callback error:", err);
                   reject(err);
-                }).then(() => resolve3());
+                }).then(() => resolve());
               } else {
-                resolve3();
+                resolve();
               }
               return;
             }
@@ -8903,7 +8854,7 @@ var ServerLlmBackend = class {
         response.data.on("end", () => {
           if (!receivedDone) {
             logger.debug("[ServerLlmBackend] Stream ended without [DONE], resolving anyway");
-            resolve3();
+            resolve();
           } else {
             logger.debug("[ServerLlmBackend] Stream ended, [DONE] handler will resolve");
           }
@@ -9170,7 +9121,7 @@ var ApiClient = class {
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.1-feat-cli-file-reference.17024+3bc00b63c",
+  version: "0.2.1-feat-cli-project-scoped-config.16996+16c515189",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -9181,9 +9132,6 @@ var package_default = {
   },
   homepage: "https://github.com/bike4mind/lumina5#readme",
   bugs: "https://github.com/bike4mind/lumina5/issues",
-  publishConfig: {
-    access: "public"
-  },
   keywords: [
     "cli",
     "ai",
@@ -9204,8 +9152,6 @@ var package_default = {
     dev: "tsx src/index.tsx",
     build: "tsup",
     typecheck: "tsc --noEmit",
-    test: "vitest run",
-    "test:watch": "vitest",
     start: "node dist/index.js",
     prepublishOnly: "pnpm build"
   },
@@ -9272,10 +9218,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.36.1-feat-cli-file-reference.17024+3bc00b63c",
-    "@bike4mind/mcp": "1.19.4-feat-cli-file-reference.17024+3bc00b63c",
-    "@bike4mind/services": "2.29.1-feat-cli-file-reference.17024+3bc00b63c",
-    "@bike4mind/utils": "2.0.3-feat-cli-file-reference.17024+3bc00b63c",
+    "@bike4mind/common": "2.36.1-feat-cli-project-scoped-config.16996+16c515189",
+    "@bike4mind/mcp": "1.19.4-feat-cli-project-scoped-config.16996+16c515189",
+    "@bike4mind/services": "2.29.1-feat-cli-project-scoped-config.16996+16c515189",
+    "@bike4mind/utils": "2.0.3-feat-cli-project-scoped-config.16996+16c515189",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -9284,10 +9230,9 @@ var package_default = {
     "@types/yargs": "^17.0.32",
     tsup: "^8.5.1",
     tsx: "^4.21.0",
-    typescript: "^5.9.3",
-    vitest: "^3.2.4"
+    typescript: "^5.9.3"
   },
-  gitHead: "3bc00b63c23e8153e62c6f7f28671702dfc0deba"
+  gitHead: "16c515189f0b9a7e3ccea2c9874866dd2e8fe084"
 };
 
 // src/index.tsx
@@ -9310,7 +9255,8 @@ function CliApp() {
     agent: null,
     mcpManager: null,
     permissionManager: null,
-    permissionPrompt: null
+    permissionPrompt: null,
+    trustLocationSelector: null
   });
   const [isInitialized, setIsInitialized] = useState3(false);
   const [initError, setInitError] = useState3(null);
@@ -9339,7 +9285,7 @@ function CliApp() {
     }
     await Promise.race([
       Promise.all(cleanupTasks),
-      new Promise((resolve3) => setTimeout(resolve3, 500))
+      new Promise((resolve) => setTimeout(resolve, 500))
       // 500ms timeout
     ]);
     setTimeout(() => {
@@ -9471,11 +9417,17 @@ function CliApp() {
         debug: () => {
         }
       };
-      const permissionManager = new PermissionManager(config.trustedTools || []);
+      const permissionManager = new PermissionManager(
+        config.trustedTools || [],
+        void 0,
+        // customCategories (not used yet)
+        config.tools.disabled || []
+        // denied tools from project config
+      );
       const promptFn = (toolName, args, preview) => {
-        return new Promise((resolve3) => {
+        return new Promise((resolve) => {
           const canBeTrusted = permissionManager.canBeTrusted(toolName);
-          const prompt = { toolName, args, preview, canBeTrusted, resolve: resolve3 };
+          const prompt = { toolName, args, preview, canBeTrusted, resolve };
           setState((prev) => ({
             ...prev,
             permissionManager,
@@ -9499,6 +9451,7 @@ function CliApp() {
         permissionManager,
         promptFn,
         agentContext,
+        state.configStore,
         config.toolApiKeys
       );
       console.log(`\u{1F6E0}\uFE0F  Loaded ${b4mTools.length} B4M tool(s)`);
@@ -9549,7 +9502,7 @@ Remember: Use context from previous messages to understand follow-up questions.`
         llm,
         model: modelInfo.id,
         tools: allTools,
-        maxIterations: 10,
+        maxIterations: 3,
         maxTokens: config.preferences.maxTokens,
         temperature: config.preferences.temperature,
         systemPrompt: cliSystemPrompt
@@ -9677,6 +9630,9 @@ Tool Permissions:
   /trust <tool-name> - Trust a tool (won't ask permission again)
   /untrust <tool-name> - Remove tool from trusted list
   /trusted - List all trusted tools
+
+Project Configuration:
+  /project-config - Show merged project configuration
         `);
         break;
       case "exit":
@@ -9768,7 +9724,7 @@ Tool Permissions:
         console.log("");
         break;
       }
-      case "trust":
+      case "trust": {
         if (!state.permissionManager) {
           console.log("Permission manager not initialized");
           return;
@@ -9776,16 +9732,85 @@ Tool Permissions:
         const toolToTrust = args[0];
         if (!toolToTrust) {
           console.log("Usage: /trust <tool-name>");
+          console.log("");
+          console.log("Example:");
+          console.log("  /trust file_read  - Opens interactive location selector");
+          console.log("");
           return;
         }
-        const trusted = state.permissionManager.trustTool(toolToTrust);
-        if (trusted) {
-          await state.configStore.trustTool(toolToTrust);
-          console.log(`\u2705 Tool '${toolToTrust}' is now trusted and won't require permission`);
-        } else {
-          console.log(`\u274C Tool '${toolToTrust}' cannot be trusted (it's in the 'prompt_always' category)`);
+        const canTrust = state.permissionManager.trustTool(toolToTrust);
+        if (!canTrust) {
+          if (state.permissionManager.isDenied(toolToTrust)) {
+            console.log(`\u274C Tool '${toolToTrust}' is denied by project configuration and cannot be trusted`);
+          } else {
+            console.log(`\u274C Tool '${toolToTrust}' cannot be trusted (it's in the 'prompt_always' category)`);
+          }
+          return;
         }
+        state.permissionManager.untrustTool(toolToTrust);
+        const handleLocationSelect = async (location) => {
+          setState((prev) => ({ ...prev, trustLocationSelector: null }));
+          if (!location) {
+            console.log("\u274C Trust operation cancelled");
+            return;
+          }
+          const projectDir = state.configStore.getProjectConfigDir();
+          switch (location) {
+            case "local": {
+              if (!projectDir) {
+                console.log('\u274C No project found. Use "global" to save to ~/.bike4mind/config.json');
+                return;
+              }
+              await state.configStore.initProjectConfig();
+              const existingLocal = await state.configStore.loadRawProjectLocalConfig() || {};
+              const updatedLocal = {
+                ...existingLocal,
+                trustedTools: [...existingLocal.trustedTools || [], toolToTrust]
+              };
+              await state.configStore.saveProjectLocalConfig(updatedLocal);
+              state.permissionManager?.trustTool(toolToTrust);
+              console.log(`\u2705 Tool '${toolToTrust}' trusted for this project only`);
+              console.log(`   Saved in: ${projectDir}/.bike4mind/local.json`);
+              break;
+            }
+            case "project": {
+              if (!projectDir) {
+                console.log('\u274C No project found. Use "global" to save to ~/.bike4mind/config.json');
+                return;
+              }
+              const existingProject = await state.configStore.loadRawProjectConfig() || {};
+              const updatedProject = {
+                ...existingProject,
+                tools: {
+                  ...existingProject.tools,
+                  enabled: [...existingProject.tools?.enabled || [], toolToTrust]
+                }
+              };
+              await state.configStore.saveProjectConfig(updatedProject);
+              state.permissionManager?.trustTool(toolToTrust);
+              console.log(`\u2705 Tool '${toolToTrust}' trusted for entire team`);
+              console.log(`   Saved in: ${projectDir}/.bike4mind/config.json`);
+              console.log("   \u26A0\uFE0F  Remember to commit this file to share with your team!");
+              break;
+            }
+            case "global": {
+              await state.configStore.trustTool(toolToTrust);
+              state.permissionManager?.trustTool(toolToTrust);
+              console.log(`\u2705 Tool '${toolToTrust}' trusted globally (all projects)`);
+              console.log("   Saved in: ~/.bike4mind/config.json");
+              break;
+            }
+          }
+        };
+        setState((prev) => ({
+          ...prev,
+          trustLocationSelector: {
+            toolName: toolToTrust,
+            resolve: handleLocationSelect
+          }
+        }));
         break;
+      }
       case "untrust":
         if (!state.permissionManager) {
           console.log("Permission manager not initialized");
@@ -9834,6 +9859,50 @@ Tool Permissions:
         console.log(`Expires: ${new Date(authTokens.expiresAt).toLocaleString()}`);
         console.log("");
         break;
+      case "project-config": {
+        const projectDir = state.configStore.getProjectConfigDir();
+        const config = await state.configStore.get();
+        console.log("\n\u{1F4C1} Project Configuration:\n");
+        if (projectDir) {
+          console.log(`Project Directory: ${projectDir}/.bike4mind/`);
+          console.log("");
+          const projectConfig = await state.configStore.loadRawProjectConfig();
+          const localConfig = await state.configStore.loadRawProjectLocalConfig();
+          if (projectConfig) {
+            console.log("Team Config (.bike4mind/config.json):");
+            if (projectConfig.defaultModel) {
+              console.log(`  Default Model: ${projectConfig.defaultModel}`);
+            }
+            if (projectConfig.tools?.denied && projectConfig.tools.denied.length > 0) {
+              console.log(`  Denied Tools: ${projectConfig.tools.denied.join(", ")}`);
+            }
+            if (projectConfig.mcpServers && projectConfig.mcpServers.length > 0) {
+              console.log(`  MCP Servers: ${projectConfig.mcpServers.map((s) => s.name).join(", ")}`);
+            }
+            console.log("");
+          }
+          if (localConfig) {
+            console.log("Local Config (.bike4mind/local.json):");
+            if (localConfig.trustedTools && localConfig.trustedTools.length > 0) {
+              console.log(`  Trusted Tools: ${localConfig.trustedTools.join(", ")}`);
+            }
+            if (localConfig.mcpServers && localConfig.mcpServers.length > 0) {
+              console.log(`  MCP Servers: ${localConfig.mcpServers.map((s) => s.name).join(", ")}`);
+            }
+            console.log("");
+          }
+          console.log("Merged Configuration (what you're using):");
+          console.log(`  Default Model: ${config.defaultModel}`);
+          console.log(`  Trusted Tools: ${config.trustedTools?.length || 0} tools`);
+          console.log(`  Denied Tools: ${config.tools.disabled.length} tools`);
+          console.log(`  MCP Servers: ${config.mcpServers.length} servers`);
+        } else {
+          console.log("No project configuration found.");
+          console.log("Tip: Create .bike4mind/config.json in your project root for team-wide settings.");
+        }
+        console.log("");
+        break;
+      }
       default:
         console.log(`Unknown command: /${command}`);
         console.log("Type /help for available commands");
@@ -9842,6 +9911,26 @@ Tool Permissions:
   if (initError) {
     return /* @__PURE__ */ React11.createElement(Box11, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React11.createElement(Text10, null, initError), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
   }
+  if (state.trustLocationSelector) {
+    const projectDir = state.configStore.getProjectConfigDir();
+    const inProject = projectDir !== null;
+    return /* @__PURE__ */ React11.createElement(
+      TrustLocationSelector,
+      {
+        inProject,
+        onSelect: (location) => {
+          if (state.trustLocationSelector) {
+            state.trustLocationSelector.resolve(location);
+          }
+        },
+        onCancel: () => {
+          if (state.trustLocationSelector) {
+            state.trustLocationSelector.resolve(null);
+          }
+        }
+      }
+    );
+  }
   if (state.showLoginFlow) {
     const loginApiUrl = getApiUrl(state.config?.apiConfig);
     return /* @__PURE__ */ React11.createElement(