@bike4mind/cli 0.2.5-ja-fix-confluence-table-data-5752.17103 → 0.2.7-basic-cli-shortcuts.17131

package/dist/index.js

@@ -4,9 +4,9 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-3TADOGT5.js";
-import "./chunk-ZYMOZ2IB.js";
-import "./chunk-GVI2BQAN.js";
+} from "./chunk-3CCBDIFR.js";
+import "./chunk-LIRY24M5.js";
+import "./chunk-YXHQN7SK.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -15,7 +15,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-WPD676KY.js";
+} from "./chunk-DNSBC3LO.js";
 import {
   Logger
 } from "./chunk-AMDXHL6S.js";
@@ -73,19 +73,19 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-QCULHLGT.js";
+} from "./chunk-H6SHASMZ.js";
 import {
   __require
 } from "./chunk-PDX44BCA.js";
 
 // src/index.tsx
-import React12, { useState as useState4, useEffect as useEffect3, useCallback } from "react";
-import { render, Box as Box12, Text as Text11, useApp, useInput as useInput3 } from "ink";
+import React14, { useState as useState5, useEffect as useEffect3, useCallback, useRef } from "react";
+import { render, Box as Box13, Text as Text13, useApp, useInput as useInput4 } from "ink";
 import { v4 as uuidv49 } from "uuid";
 
 // src/components/App.tsx
-import React9 from "react";
-import { Box as Box9, Text as Text8, Static } from "ink";
+import React10 from "react";
+import { Box as Box9, Text as Text9, Static } from "ink";
 
 // src/components/StatusBar.tsx
 import React from "react";
@@ -95,27 +95,127 @@ 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 TextInput from "ink-text-input";
+import React5, { useState as useState2, useMemo, useEffect } from "react";
+import { Box as Box4, Text as Text5, useInput as useInput2 } from "ink";
+
+// src/components/CustomTextInput.tsx
+import React2, { useState } from "react";
+import { Text as Text2, useInput } from "ink";
+function CustomTextInput({
+  value,
+  onChange,
+  onSubmit,
+  placeholder = "",
+  showCursor = true
+}) {
+  const [cursorOffset, setCursorOffset] = useState(value.length);
+  useInput(
+    (input, key) => {
+      if (key.return && !key.meta && !key.shift) {
+        onSubmit(value);
+        return;
+      }
+      if (key.ctrl) {
+        switch (input) {
+          case "u":
+            {
+              const lines = value.split("\n");
+              let currentLineStart = 0;
+              let currentLineIndex = 0;
+              let charCount = 0;
+              for (let i = 0; i < lines.length; i++) {
+                const lineLength = lines[i].length;
+                if (charCount + lineLength >= cursorOffset) {
+                  currentLineIndex = i;
+                  currentLineStart = charCount;
+                  break;
+                }
+                charCount += lineLength + 1;
+              }
+              lines.splice(currentLineIndex, 1);
+              const newValue = lines.join("\n");
+              onChange(newValue);
+              setCursorOffset(Math.min(currentLineStart, newValue.length));
+            }
+            return;
+          case "k":
+            onChange(value.slice(0, cursorOffset));
+            return;
+          case "w":
+            {
+              const beforeCursor2 = value.slice(0, cursorOffset);
+              const afterCursor2 = value.slice(cursorOffset);
+              const trimmed = beforeCursor2.trimEnd();
+              const lastSpace = trimmed.lastIndexOf(" ");
+              const newBefore = lastSpace === -1 ? "" : trimmed.slice(0, lastSpace + 1);
+              const newValue = newBefore + afterCursor2;
+              onChange(newValue);
+              setCursorOffset(newBefore.length);
+            }
+            return;
+          case "a":
+            setCursorOffset(0);
+            return;
+          case "e":
+            setCursorOffset(value.length);
+            return;
+          case "l":
+            onChange("");
+            return;
+        }
+      }
+      if (key.backspace || key.delete) {
+        if (cursorOffset > 0) {
+          const newValue = value.slice(0, cursorOffset - 1) + value.slice(cursorOffset);
+          onChange(newValue);
+          setCursorOffset(cursorOffset - 1);
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        setCursorOffset(Math.max(0, cursorOffset - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursorOffset(Math.min(value.length, cursorOffset + 1));
+        return;
+      }
+      if (!key.ctrl && !key.meta && input.length === 1) {
+        const sanitizedInput = input === "\r" ? "\n" : input;
+        const newValue = value.slice(0, cursorOffset) + sanitizedInput + value.slice(cursorOffset);
+        onChange(newValue);
+        setCursorOffset(cursorOffset + 1);
+      }
+    },
+    { isActive: true }
+  );
+  const hasValue = value.length > 0;
+  if (!hasValue) {
+    return /* @__PURE__ */ React2.createElement(Text2, null, showCursor ? /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Text2, { inverse: true }, " "), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, placeholder)) : /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, placeholder));
+  }
+  const beforeCursor = value.slice(0, cursorOffset);
+  const cursorChar = value[cursorOffset] || " ";
+  const afterCursor = value.slice(cursorOffset + 1);
+  return /* @__PURE__ */ React2.createElement(Text2, null, beforeCursor, showCursor && /* @__PURE__ */ React2.createElement(Text2, { inverse: true }, cursorChar), !showCursor && cursorChar, afterCursor);
+}
 
 // src/components/CommandAutocomplete.tsx
-import React2 from "react";
-import { Box as Box2, Text as Text2 } from "ink";
+import React3 from "react";
+import { Box as Box2, Text as Text3 } from "ink";
 function CommandAutocomplete({ commands, selectedIndex }) {
   if (commands.length === 0) {
-    return /* @__PURE__ */ React2.createElement(Box2, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "No matching commands"));
+    return /* @__PURE__ */ React3.createElement(Box2, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "No matching commands"));
   }
-  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, commands.length === 1 ? "1 command" : `${commands.length} commands`, " \u2022 Use \u2191\u2193 to navigate, Enter to select")), commands.map((cmd, index) => {
+  return /* @__PURE__ */ React3.createElement(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, commands.length === 1 ? "1 command" : `${commands.length} commands`, " \u2022 Use \u2191\u2193 to navigate, Enter to select")), commands.map((cmd, index) => {
     const args = cmd.args ? ` ${cmd.args}` : "";
     const isSelected = index === selectedIndex;
-    return /* @__PURE__ */ React2.createElement(Box2, { key: cmd.name, marginLeft: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "\u25B8 " : "  ", "/", cmd.name, args, " - ", cmd.description));
+    return /* @__PURE__ */ React3.createElement(Box2, { key: cmd.name, marginLeft: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "\u25B8 " : "  ", "/", cmd.name, args, " - ", cmd.description));
   }));
 }
 
 // src/components/FileAutocomplete.tsx
-import React3 from "react";
-import { Box as Box3, Text as Text3 } from "ink";
+import React4 from "react";
+import { Box as Box3, Text as Text4 } from "ink";
 
 // src/utils/fileSearch.ts
 import * as fs from "fs";
@@ -304,14 +404,14 @@ 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__ */ React4.createElement(Box3, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React4.createElement(Text4, { 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) => {
+  return /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React4.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, files.length === 1 ? "1 match" : `${files.length} matches`, " - Use up/down to navigate, Tab to select")), files.map((file, index) => {
     const isSelected = index === selectedIndex;
     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));
+    return /* @__PURE__ */ React4.createElement(Box3, { key: file.path, marginLeft: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "> " : "  "), /* @__PURE__ */ React4.createElement(Text4, { color: file.isDirectory ? "yellow" : isSelected ? "cyan" : void 0, bold: isSelected }, icon), /* @__PURE__ */ React4.createElement(Text4, { color: isSelected ? "cyan" : void 0, bold: isSelected }, " ", pathDisplay), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, sizeDisplay));
   }));
 }
 
@@ -413,6 +513,202 @@ function searchCommands(query) {
   return results.map((result) => result.item);
 }
 
+// src/utils/imageDetector.ts
+import { readFileSync, existsSync, statSync as statSync2 } from "fs";
+import { extname as extname2 } from "path";
+var ImageInputDetector = class {
+  static {
+    this.MAX_IMAGE_SIZE = 10 * 1024 * 1024;
+  }
+  static {
+    // 10MB
+    this.SUPPORTED_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".webp"];
+  }
+  /**
+   * Check if input contains image data
+   */
+  static containsImageData(input) {
+    if (input.includes("\x1B]1337;File=")) {
+      return true;
+    }
+    if (input.includes("\x1B_G")) {
+      return true;
+    }
+    if (input.includes("\x1BP")) {
+      return true;
+    }
+    if (input.match(/data:image\/(png|jpeg|jpg|gif|webp);base64,/)) {
+      return true;
+    }
+    if (this.looksLikeFilePath(input)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Extract image data from terminal input
+   */
+  static extractImageData(input) {
+    const iterm2 = this.extractITerm2Image(input);
+    if (iterm2) return iterm2;
+    const kitty = this.extractKittyImage(input);
+    if (kitty) return kitty;
+    const sixel = this.extractSixelImage(input);
+    if (sixel) return sixel;
+    const base64 = this.extractBase64Image(input);
+    if (base64) return base64;
+    const fileDrop = this.extractDroppedFile(input);
+    if (fileDrop) return fileDrop;
+    return null;
+  }
+  /**
+   * Extract iTerm2 inline image
+   * Format: ESC]1337;File=[args]:base64data^G
+   */
+  static extractITerm2Image(input) {
+    const match = input.match(/\x1b\]1337;File=([^:]*):([^\x07]+)\x07/);
+    if (!match) return null;
+    try {
+      const args = match[1];
+      const base64Data = match[2];
+      const data = Buffer.from(base64Data, "base64");
+      let format = "png";
+      const nameMatch = args.match(/name=([^;]+)/);
+      if (nameMatch) {
+        const ext = extname2(nameMatch[1]).substring(1).toLowerCase();
+        if (ext && this.SUPPORTED_EXTENSIONS.includes(`.${ext}`)) {
+          format = ext === "jpeg" ? "jpg" : ext;
+        }
+      }
+      return {
+        type: "paste",
+        data,
+        format,
+        protocol: "iterm2"
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Extract Kitty graphics protocol image
+   * Format: ESC_Ga=T,f=100;base64data ESC\
+   */
+  static extractKittyImage(input) {
+    const match = input.match(/\x1b_G([^;]*);([^\x1b]+)\x1b\\/);
+    if (!match) return null;
+    try {
+      const params = match[1];
+      const base64Data = match[2];
+      const data = Buffer.from(base64Data, "base64");
+      let format = "png";
+      const formatMatch = params.match(/f=(\d+)/);
+      if (formatMatch) {
+        const formatCode = parseInt(formatMatch[1], 10);
+        if (formatCode === 100) format = "jpg";
+      }
+      return {
+        type: "paste",
+        data,
+        format,
+        protocol: "kitty"
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Extract Sixel image
+   * Format: ESC P q ... ESC \
+   */
+  static extractSixelImage(input) {
+    const match = input.match(/\x1bP([^q]*q[^\x1b]+)\x1b\\/);
+    if (!match) return null;
+    return null;
+  }
+  /**
+   * Extract base64 data URL
+   * Format: data:image/png;base64,iVBORw0KGgo...
+   */
+  static extractBase64Image(input) {
+    const match = input.match(/data:image\/(png|jpeg|jpg|gif|webp);base64,([A-Za-z0-9+/=]+)/);
+    if (!match) return null;
+    try {
+      const format = match[1] === "jpeg" ? "jpg" : match[1];
+      const base64Data = match[2];
+      const data = Buffer.from(base64Data, "base64");
+      return {
+        type: "paste",
+        data,
+        format,
+        protocol: "base64"
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Extract dropped file path and read image
+   */
+  static extractDroppedFile(input) {
+    if (!this.looksLikeFilePath(input)) return null;
+    let filepath = input.trim();
+    filepath = filepath.replace(/^["']|["']$/g, "");
+    filepath = filepath.replace(/\\\s/g, " ");
+    if (!existsSync(filepath)) return null;
+    const stats = statSync2(filepath);
+    if (!stats.isFile()) return null;
+    const ext = extname2(filepath).toLowerCase();
+    if (!this.SUPPORTED_EXTENSIONS.includes(ext)) return null;
+    if (stats.size > this.MAX_IMAGE_SIZE) return null;
+    try {
+      const data = readFileSync(filepath);
+      const format = ext.substring(1) === "jpeg" ? "jpg" : ext.substring(1);
+      const filename = filepath.split("/").pop() || "image";
+      return {
+        type: "drop",
+        data,
+        format,
+        filename,
+        filepath
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Check if string looks like a file path
+   */
+  static looksLikeFilePath(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith("/") || trimmed.match(/^[a-zA-Z]:\\/)) {
+      return true;
+    }
+    if (trimmed.startsWith("~")) {
+      return true;
+    }
+    if (this.SUPPORTED_EXTENSIONS.some((ext) => trimmed.toLowerCase().endsWith(ext))) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Remove image data from input string, leaving only text
+   */
+  static stripImageData(input) {
+    let cleaned = input;
+    cleaned = cleaned.replace(/\x1b\]1337;File=[^:]*:[^\x07]+\x07/g, "");
+    cleaned = cleaned.replace(/\x1b_G[^;]*;[^\x1b]+\x1b\\/g, "");
+    cleaned = cleaned.replace(/\x1bP[^q]*q[^\x1b]+\x1b\\/g, "");
+    cleaned = cleaned.replace(/data:image\/(png|jpeg|jpg|gif|webp);base64,[A-Za-z0-9+/=]+/g, "");
+    const filepath = this.extractDroppedFile(cleaned);
+    if (filepath) {
+      cleaned = cleaned.replace(filepath.filepath, "");
+    }
+    return cleaned.trim();
+  }
+};
+
 // src/components/InputPrompt.tsx
 function findAtTrigger(value) {
   for (let i = value.length - 1; i >= 0; i--) {
@@ -429,14 +725,13 @@ function findAtTrigger(value) {
   }
   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);
+function InputPrompt({ onSubmit, onImageDetected, disabled = false, history = [] }) {
+  const [value, setValue] = useState2("");
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const [historyIndex, setHistoryIndex] = useState2(-1);
+  const [tempInput, setTempInput] = useState2("");
+  const [fileAutocomplete, setFileAutocomplete] = useState2(null);
+  const [fileSelectedIndex, setFileSelectedIndex] = useState2(0);
   const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active;
   const commandQuery = shouldShowCommandAutocomplete ? value.slice(1) : "";
   const filteredCommands = useMemo(() => {
@@ -453,7 +748,7 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
   useEffect(() => {
     setFileSelectedIndex(0);
   }, [filteredFiles]);
-  useInput((input, key) => {
+  useInput2((_input, key) => {
     if (fileAutocomplete?.active && filteredFiles.length > 0) {
       if (key.upArrow) {
         setFileSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredFiles.length - 1);
@@ -510,7 +805,6 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
     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,
@@ -537,7 +831,6 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
       if (selectedCommand.args) {
         setValue(commandText + " ");
         setHistoryIndex(-1);
-        setInputKey((prev) => prev + 1);
         return;
       }
       setValue("");
@@ -550,7 +843,15 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
     setHistoryIndex(-1);
     setFileAutocomplete(null);
   };
-  const handleChange = (newValue) => {
+  const handleChange = async (newValue) => {
+    if (ImageInputDetector.containsImageData(newValue)) {
+      const imageEvent = ImageInputDetector.extractImageData(newValue);
+      if (imageEvent && onImageDetected) {
+        const placeholder = await onImageDetected(imageEvent.data);
+        setValue(`${placeholder} `);
+        return;
+      }
+    }
     setValue(newValue);
     if (historyIndex !== -1) {
       setHistoryIndex(-1);
@@ -567,29 +868,28 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
       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(
-    TextInput,
+  return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text5, { bold: true, color: "cyan" }, "> "), /* @__PURE__ */ React5.createElement(
+    CustomTextInput,
     {
-      key: inputKey,
       value,
       onChange: handleChange,
       onSubmit: handleSubmit,
       placeholder: disabled ? "Thinking..." : "Type your message, /help for commands, or @file to reference",
       showCursor: !disabled
     }
-  )), shouldShowCommandAutocomplete && /* @__PURE__ */ React4.createElement(CommandAutocomplete, { commands: filteredCommands, selectedIndex }), fileAutocomplete?.active && /* @__PURE__ */ React4.createElement(FileAutocomplete, { files: filteredFiles, selectedIndex: fileSelectedIndex, query: fileAutocomplete.query }));
+  )), shouldShowCommandAutocomplete && /* @__PURE__ */ React5.createElement(CommandAutocomplete, { commands: filteredCommands, selectedIndex }), fileAutocomplete?.active && /* @__PURE__ */ React5.createElement(FileAutocomplete, { files: filteredFiles, selectedIndex: fileSelectedIndex, query: fileAutocomplete.query }));
 }
 
 // src/components/AgentThinking.tsx
-import React6 from "react";
+import React7 from "react";
 import { Box as Box6 } from "ink";
 
 // src/components/ThoughtStream.tsx
-import React5 from "react";
-import { Box as Box5, Text as Text5 } from "ink";
+import React6 from "react";
+import { Box as Box5, Text as Text6 } 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 = React6.memo(function ThoughtStream2({ steps }) {
+  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", gap: 1 }, steps.map((step, index) => /* @__PURE__ */ React6.createElement(Box5, { key: index, flexDirection: "column" }, step.type === "thought" && /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "magenta" }, "\u{1F914} Thought: "), /* @__PURE__ */ React6.createElement(Text6, null, step.content)), step.type === "action" && /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, "\u26A1 Action: "), /* @__PURE__ */ React6.createElement(Text6, { bold: true }, step.metadata?.toolName || "unknown")), step.metadata?.toolInput && /* @__PURE__ */ React6.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, JSON.stringify(step.metadata.toolInput, null, 2)))), step.type === "observation" && /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "blue" }, "\u{1F4CA} Observation: ")), /* @__PURE__ */ React6.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React6.createElement(Text6, null, step.content))), step.type === "final_answer" && /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "green", bold: true }, "\u2705 Final Answer:", " ")), /* @__PURE__ */ React6.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React6.createElement(Text6, null, step.content)), step.metadata?.tokenUsage && /* @__PURE__ */ React6.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "(", step.metadata.tokenUsage.total, " tokens)"))))), !steps.some((s) => s.type === "final_answer") && /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, /* @__PURE__ */ React6.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React6.createElement(Text6, null, " ", steps.length === 0 ? "Thinking..." : "Processing...")));
 });
 
 // src/store/index.ts
@@ -618,32 +918,32 @@ var useCliStore = create((set) => ({
 }));
 
 // src/components/AgentThinking.tsx
-var AgentThinking = React6.memo(function AgentThinking2() {
+var AgentThinking = React7.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__ */ React7.createElement(Box6, { borderStyle: "single", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React7.createElement(ThoughtStream, { steps: agentSteps }));
 });
 
 // src/components/PermissionPrompt.tsx
-import React7 from "react";
-import { Box as Box7, Text as Text6 } from "ink";
+import React8 from "react";
+import { Box as Box7, Text as Text7 } 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__ */ React8.createElement(Text7, { key: index, color: "green" }, line);
     }
     if (line.startsWith("-")) {
-      return /* @__PURE__ */ React7.createElement(Text6, { key: index, color: "red" }, line);
+      return /* @__PURE__ */ React8.createElement(Text7, { key: index, color: "red" }, line);
     }
     if (line.startsWith("@@")) {
-      return /* @__PURE__ */ React7.createElement(Text6, { key: index, color: "cyan" }, line);
+      return /* @__PURE__ */ React8.createElement(Text7, { key: index, color: "cyan" }, line);
     }
-    return /* @__PURE__ */ React7.createElement(Text6, { key: index, dimColor: true }, line);
+    return /* @__PURE__ */ React8.createElement(Text7, { key: index, dimColor: true }, line);
   });
 }
 function PermissionPrompt({
@@ -663,12 +963,12 @@ 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) })));
+  return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column", borderStyle: "bold", borderColor: "yellow", padding: 1, marginY: 1 }, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "yellow" }, "\u26A0\uFE0F Permission Required")), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "Tool: "), /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "cyan" }, toolName)), toolDescription && /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "Action: "), /* @__PURE__ */ React8.createElement(Text7, null, toolDescription)), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { bold: true }, "Arguments:"), /* @__PURE__ */ React8.createElement(Box7, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, argsString))), preview && /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { bold: true }, "Preview:"), /* @__PURE__ */ React8.createElement(Box7, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" }, renderDiffPreview(preview))), !canBeTrusted && /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: "red", dimColor: true }, "Note: This tool cannot be trusted due to its dangerous nature.")), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(SelectInput, { items, onSelect: (item) => onResponse(item.value) })));
 }
 
 // src/components/ConfigEditor.tsx
-import React8, { useState as useState2, useMemo as useMemo2 } from "react";
-import { Box as Box8, Text as Text7, useInput as useInput2 } from "ink";
+import React9, { useState as useState3, useMemo as useMemo2 } from "react";
+import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
 var MAX_ITERATIONS_OPTIONS = [
   { label: "10", value: 10 },
   { label: "20", value: 20 },
@@ -685,103 +985,128 @@ var EXPORT_FORMAT_OPTIONS = [
   { label: "markdown", value: "markdown" },
   { label: "json", value: "json" }
 ];
-var CONFIG_ITEMS = [
-  {
-    key: "maxIterations",
-    label: "Max Iterations",
-    type: "select",
-    options: MAX_ITERATIONS_OPTIONS,
-    getValue: (config) => config.preferences.maxIterations,
-    setValue: (config, value) => ({
-      ...config,
-      preferences: {
-        ...config.preferences,
-        maxIterations: value
-      }
-    })
-  },
-  {
-    key: "maxTokens",
-    label: "Max Tokens",
-    type: "number",
-    min: 256,
-    max: 128e3,
-    step: 256,
-    getValue: (config) => config.preferences.maxTokens,
-    setValue: (config, value) => ({
-      ...config,
-      preferences: {
-        ...config.preferences,
-        maxTokens: value
-      }
-    })
-  },
-  {
-    key: "temperature",
-    label: "Temperature",
-    type: "number",
-    min: 0,
-    max: 2,
-    step: 0.1,
-    getValue: (config) => config.preferences.temperature,
-    setValue: (config, value) => ({
-      ...config,
-      preferences: {
-        ...config.preferences,
-        temperature: value
-      }
-    })
-  },
-  {
-    key: "autoSave",
-    label: "Auto Save",
-    type: "boolean",
-    getValue: (config) => config.preferences.autoSave,
-    setValue: (config, value) => ({
-      ...config,
-      preferences: {
-        ...config.preferences,
-        autoSave: value
-      }
-    })
-  },
-  {
-    key: "theme",
-    label: "Theme",
-    type: "select",
-    options: THEME_OPTIONS,
-    getValue: (config) => config.preferences.theme,
-    setValue: (config, value) => ({
-      ...config,
-      preferences: {
-        ...config.preferences,
-        theme: value
-      }
-    })
-  },
-  {
-    key: "exportFormat",
-    label: "Export Format",
-    type: "select",
-    options: EXPORT_FORMAT_OPTIONS,
-    getValue: (config) => config.preferences.exportFormat,
-    setValue: (config, value) => ({
-      ...config,
-      preferences: {
-        ...config.preferences,
-        exportFormat: value
-      }
-    })
+function buildConfigItems(availableModels) {
+  const modelOptions = availableModels.map((model) => ({
+    label: model.name,
+    value: model.id
+  }));
+  const items = [];
+  if (modelOptions.length > 0) {
+    items.push({
+      key: "model",
+      label: "Model",
+      type: "select",
+      options: modelOptions,
+      getValue: (config) => {
+        const modelExists = modelOptions.some((opt) => opt.value === config.defaultModel);
+        return modelExists ? config.defaultModel : modelOptions[0]?.value ?? config.defaultModel;
+      },
+      setValue: (config, value) => ({
+        ...config,
+        defaultModel: value
+      })
+    });
   }
-];
-function ConfigEditor({ config, onSave, onClose }) {
-  const [selectedIndex, setSelectedIndex] = useState2(0);
-  const [editedConfig, setEditedConfig] = useState2(config);
-  const [saveError, setSaveError] = useState2(null);
-  const [isSaving, setIsSaving] = useState2(false);
+  items.push(
+    {
+      key: "maxIterations",
+      label: "Max Iterations",
+      type: "select",
+      options: MAX_ITERATIONS_OPTIONS,
+      getValue: (config) => config.preferences.maxIterations,
+      setValue: (config, value) => ({
+        ...config,
+        preferences: {
+          ...config.preferences,
+          maxIterations: value
+        }
+      })
+    },
+    {
+      key: "maxTokens",
+      label: "Max Tokens",
+      type: "number",
+      min: 256,
+      max: 128e3,
+      step: 256,
+      getValue: (config) => config.preferences.maxTokens,
+      setValue: (config, value) => ({
+        ...config,
+        preferences: {
+          ...config.preferences,
+          maxTokens: value
+        }
+      })
+    },
+    {
+      key: "temperature",
+      label: "Temperature",
+      type: "number",
+      min: 0,
+      max: 2,
+      step: 0.1,
+      getValue: (config) => config.preferences.temperature,
+      setValue: (config, value) => ({
+        ...config,
+        preferences: {
+          ...config.preferences,
+          temperature: value
+        }
+      })
+    },
+    {
+      key: "autoSave",
+      label: "Auto Save",
+      type: "boolean",
+      getValue: (config) => config.preferences.autoSave,
+      setValue: (config, value) => ({
+        ...config,
+        preferences: {
+          ...config.preferences,
+          autoSave: value
+        }
+      })
+    },
+    {
+      key: "theme",
+      label: "Theme",
+      type: "select",
+      options: THEME_OPTIONS,
+      getValue: (config) => config.preferences.theme,
+      setValue: (config, value) => ({
+        ...config,
+        preferences: {
+          ...config.preferences,
+          theme: value
+        }
+      })
+    },
+    {
+      key: "exportFormat",
+      label: "Export Format",
+      type: "select",
+      options: EXPORT_FORMAT_OPTIONS,
+      getValue: (config) => config.preferences.exportFormat,
+      setValue: (config, value) => ({
+        ...config,
+        preferences: {
+          ...config.preferences,
+          exportFormat: value
+        }
+      })
+    }
+  );
+  return items;
+}
+function ConfigEditor({ config, availableModels, onSave, onClose }) {
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const [editedConfig, setEditedConfig] = useState3(config);
+  const [saveError, setSaveError] = useState3(null);
+  const [isSaving, setIsSaving] = useState3(false);
+  const configItems = useMemo2(() => buildConfigItems(availableModels), [availableModels]);
   const hasChanges = useMemo2(() => {
-    return JSON.stringify(config.preferences) !== JSON.stringify(editedConfig.preferences);
-  }, [config.preferences, editedConfig.preferences]);
+    return JSON.stringify(config.preferences) !== JSON.stringify(editedConfig.preferences) || config.defaultModel !== editedConfig.defaultModel;
+  }, [config.preferences, editedConfig.preferences, config.defaultModel, editedConfig.defaultModel]);
   const handleSaveAndClose = async () => {
     if (hasChanges) {
       try {
@@ -797,14 +1122,14 @@ function ConfigEditor({ config, onSave, onClose }) {
     }
     onClose();
   };
-  useInput2((input, key) => {
-    const currentItem = CONFIG_ITEMS[selectedIndex];
+  useInput3((input, key) => {
+    const currentItem = configItems[selectedIndex];
     if (key.upArrow) {
-      setSelectedIndex((prev) => prev > 0 ? prev - 1 : CONFIG_ITEMS.length - 1);
+      setSelectedIndex((prev) => prev > 0 ? prev - 1 : configItems.length - 1);
       return;
     }
     if (key.downArrow) {
-      setSelectedIndex((prev) => prev < CONFIG_ITEMS.length - 1 ? prev + 1 : 0);
+      setSelectedIndex((prev) => prev < configItems.length - 1 ? prev + 1 : 0);
       return;
     }
     if ((key.escape || input === "q") && !isSaving) {
@@ -862,13 +1187,13 @@ function ConfigEditor({ config, onSave, onClose }) {
     }
     return String(value);
   };
-  return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, marginY: 1 }, /* @__PURE__ */ React8.createElement(Box8, { justifyContent: "space-between", marginBottom: 1 }, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "cyan" }, "Settings"), isSaving ? /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "Saving...") : hasChanges ? /* @__PURE__ */ React8.createElement(Text7, { dimColor: true, color: "yellow" }, "(unsaved changes)") : null), saveError && /* @__PURE__ */ React8.createElement(Box8, { marginBottom: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: "red" }, "Error: ", saveError)), /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", marginBottom: 1 }, CONFIG_ITEMS.map((item, index) => {
+  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, marginY: 1 }, /* @__PURE__ */ React9.createElement(Box8, { justifyContent: "space-between", marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: "cyan" }, "Settings"), isSaving ? /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "Saving...") : hasChanges ? /* @__PURE__ */ React9.createElement(Text8, { dimColor: true, color: "yellow" }, "(unsaved changes)") : null), saveError && /* @__PURE__ */ React9.createElement(Box8, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "red" }, "Error: ", saveError)), /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", marginBottom: 1 }, configItems.map((item, index) => {
     const isSelected = index === selectedIndex;
     const value = item.getValue(editedConfig);
     const displayValue = formatValue(item, value);
     const hasOptions = item.type === "select" || item.type === "boolean" || item.type === "number";
-    return /* @__PURE__ */ React8.createElement(Box8, { key: item.key }, /* @__PURE__ */ React8.createElement(Text7, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  "), /* @__PURE__ */ React8.createElement(Box8, { width: 18 }, /* @__PURE__ */ React8.createElement(Text7, { bold: isSelected, color: isSelected ? "white" : "gray" }, item.label, ":")), /* @__PURE__ */ React8.createElement(Box8, null, hasOptions && isSelected && /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "< "), /* @__PURE__ */ React8.createElement(Text7, { bold: isSelected, color: isSelected ? "green" : void 0 }, displayValue), hasOptions && isSelected && /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, " >")));
-  })), /* @__PURE__ */ React8.createElement(Box8, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "\u2191/\u2193: Navigate | Space/\u2190/\u2192: Change | q/Esc: Save & Exit")));
+    return /* @__PURE__ */ React9.createElement(Box8, { key: item.key }, /* @__PURE__ */ React9.createElement(Text8, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  "), /* @__PURE__ */ React9.createElement(Box8, { width: 18 }, /* @__PURE__ */ React9.createElement(Text8, { bold: isSelected, color: isSelected ? "white" : "gray" }, item.label, ":")), /* @__PURE__ */ React9.createElement(Box8, null, hasOptions && isSelected && /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "< "), /* @__PURE__ */ React9.createElement(Text8, { bold: isSelected, color: isSelected ? "green" : void 0 }, displayValue), hasOptions && isSelected && /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, " >")));
+  })), /* @__PURE__ */ React9.createElement(Box8, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "\u2191/\u2193: Navigate | Space/\u2190/\u2192: Change | q/Esc: Save & Exit")));
 }
 
 // src/utils/processFileReferences.ts
@@ -990,8 +1315,10 @@ function App({
   onMessage,
   onCommand,
   onPermissionResponse,
+  onImageDetected,
   commandHistory = [],
   config,
+  availableModels = [],
   onSaveConfig
 }) {
   const messages = useCliStore((state) => state.session?.messages || []);
@@ -1004,11 +1331,11 @@ function App({
   const setShowConfigEditor = useCliStore((state) => state.setShowConfigEditor);
   const exitRequested = useCliStore((state) => state.exitRequested);
   const setIsThinking = useCliStore((state) => state.setIsThinking);
-  const handleSubmit = React9.useCallback(
+  const handleSubmit = React10.useCallback(
     async (input) => {
       const trimmed = input.trim();
       if (!trimmed) return;
-      if (trimmed.startsWith("/")) {
+      if (trimmed.startsWith("/") && !trimmed.match(/^\/[A-Z]/)) {
         const [command, ...args] = trimmed.slice(1).split(" ");
         await onCommand(command, args);
         return;
@@ -1033,7 +1360,15 @@ ${errorBlock}`;
     },
     [onMessage, onCommand, setIsThinking]
   );
-  return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column" }, /* @__PURE__ */ React9.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens }), showConfigEditor && config && onSaveConfig ? /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React9.createElement(ConfigEditor, { config, onSave: onSaveConfig, onClose: () => setShowConfigEditor(false) })) : permissionPrompt ? /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React9.createElement(
+  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column" }, /* @__PURE__ */ React10.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens }), showConfigEditor && config && onSaveConfig ? /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React10.createElement(
+    ConfigEditor,
+    {
+      config,
+      availableModels,
+      onSave: onSaveConfig,
+      onClose: () => setShowConfigEditor(false)
+    }
+  )) : permissionPrompt ? /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React10.createElement(
     PermissionPrompt,
     {
       toolName: permissionPrompt.toolName,
@@ -1042,39 +1377,47 @@ ${errorBlock}`;
       canBeTrusted: permissionPrompt.canBeTrusted,
       onResponse: onPermissionResponse
     }
-  )) : /* @__PURE__ */ React9.createElement(React9.Fragment, null, /* @__PURE__ */ React9.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React9.createElement(Box9, { key: index, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React9.createElement(MessageItem, { message }))), /* @__PURE__ */ React9.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React9.createElement(Box9, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), /* @__PURE__ */ React9.createElement(Box9, { borderStyle: "single", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React9.createElement(InputPrompt, { onSubmit: handleSubmit, disabled: isThinking, history: commandHistory }))));
+  )) : /* @__PURE__ */ React10.createElement(React10.Fragment, null, /* @__PURE__ */ React10.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React10.createElement(Box9, { key: index, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React10.createElement(MessageItem, { message }))), /* @__PURE__ */ React10.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React10.createElement(Box9, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React10.createElement(Text9, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), /* @__PURE__ */ React10.createElement(Box9, { borderStyle: "single", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React10.createElement(
+    InputPrompt,
+    {
+      onSubmit: handleSubmit,
+      onImageDetected,
+      disabled: isThinking,
+      history: commandHistory
+    }
+  ))));
 }
 function MessageItem({ message }) {
-  return /* @__PURE__ */ React9.createElement(Box9, { 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 ", message.content) : /* @__PURE__ */ React9.createElement(Text8, null, 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__ */ React10.createElement(Box9, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React10.createElement(Text9, null, message.content)), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { 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__ */ React10.createElement(Text9, { 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, { dimColor: true }, `   ${step.content.slice(0, 200)}${step.content.length > 200 ? "..." : ""}`));
+      return /* @__PURE__ */ React10.createElement(Box9, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React10.createElement(Text9, { 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__ */ 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__ */ React10.createElement(Box9, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React10.createElement(Text9, { 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__ */ React10.createElement(Box9, { paddingLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
 }
 
 // src/components/MessageList.tsx
-import React10 from "react";
-import { Box as Box10, Text as Text9 } from "ink";
+import React11 from "react";
+import { Box as Box10, Text as Text10 } from "ink";
 function stripThinkingTags(content) {
   return content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
-var MessageList = React10.memo(
+var MessageList = React11.memo(
   function MessageList2({ messages }) {
     if (messages.length === 0) {
-      return /* @__PURE__ */ React10.createElement(Box10, { paddingY: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "No messages yet. Type a message to start!"));
+      return /* @__PURE__ */ React11.createElement(Box10, { paddingY: 1 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "No messages yet. Type a message to start!"));
     }
-    return /* @__PURE__ */ React10.createElement(Box10, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React10.createElement(Box10, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React10.createElement(Box10, null, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React10.createElement(Box10, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React10.createElement(Text9, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React10.createElement(Box10, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { 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__ */ React10.createElement(Text9, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+    return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React11.createElement(Box10, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React11.createElement(Box10, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React11.createElement(Text10, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React11.createElement(Text10, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React11.createElement(Box10, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React11.createElement(Text10, { 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__ */ React11.createElement(Text10, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
       if (step.type === "thought") {
-        return /* @__PURE__ */ React10.createElement(Box10, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React10.createElement(
-          Text9,
+        return /* @__PURE__ */ React11.createElement(Box10, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React11.createElement(Text10, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React11.createElement(
+          Text10,
           {
             dimColor: true
           },
@@ -1086,10 +1429,10 @@ var MessageList = React10.memo(
         const toolInput = step.metadata?.toolInput;
         const observationStep = message.metadata.steps[idx + 1];
         const result = observationStep?.type === "observation" ? observationStep.content : null;
-        return /* @__PURE__ */ React10.createElement(Box10, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React10.createElement(Text9, { 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__ */ React11.createElement(Box10, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React11.createElement(Text10, { 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__ */ React10.createElement(Box10, { paddingLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
+    }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React11.createElement(Box10, { paddingLeft: 2 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
   },
   (prevProps, nextProps) => {
     if (prevProps.messages.length !== nextProps.messages.length) {
@@ -1099,9 +1442,42 @@ var MessageList = React10.memo(
   }
 );
 
+// src/components/TrustLocationSelector.tsx
+import React12 from "react";
+import { Box as Box11, Text as Text11 } 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__ */ React12.createElement(Box11, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React12.createElement(Box11, { marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "Where should this rule be saved?")), /* @__PURE__ */ React12.createElement(
+    SelectInput2,
+    {
+      items,
+      onSelect: handleSelect,
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+    }
+  ), /* @__PURE__ */ React12.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Ctrl+C to cancel")));
+}
+
 // src/components/LoginFlow.tsx
-import React11, { useState as useState3, useEffect as useEffect2 } from "react";
-import { Box as Box11, Text as Text10 } from "ink";
+import React13, { useState as useState4, useEffect as useEffect2 } from "react";
+import { Box as Box12, Text as Text12 } from "ink";
 import Spinner2 from "ink-spinner";
 import jwt from "jsonwebtoken";
 import open from "open";
@@ -1217,10 +1593,10 @@ var OAuthClient = class {
 
 // src/components/LoginFlow.tsx
 function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, onError }) {
-  const [status, setStatus] = useState3("initiating");
-  const [deviceFlow, setDeviceFlow] = useState3(null);
-  const [statusMessage, setStatusMessage] = useState3("Initiating device authorization...");
-  const [error, setError] = useState3(null);
+  const [status, setStatus] = useState4("initiating");
+  const [deviceFlow, setDeviceFlow] = useState4(null);
+  const [statusMessage, setStatusMessage] = useState4("Initiating device authorization...");
+  const [error, setError] = useState4(null);
   useEffect2(() => {
     const runLoginFlow = async () => {
       const oauth = new OAuthClient(apiUrl);
@@ -1264,15 +1640,15 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
     }
   }, [deviceFlow, status]);
   if (status === "initiating") {
-    return /* @__PURE__ */ React11.createElement(Box11, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React11.createElement(Box11, null, /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, /* @__PURE__ */ React11.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
+    return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { color: "cyan" }, /* @__PURE__ */ React13.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
   }
   if (status === "error") {
-    return /* @__PURE__ */ React11.createElement(Box11, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React11.createElement(Box11, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React11.createElement(Box11, null, /* @__PURE__ */ React11.createElement(Text10, { color: "red" }, error)));
+    return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React13.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { color: "red" }, error)));
   }
   if (status === "success") {
-    return /* @__PURE__ */ React11.createElement(Box11, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React11.createElement(Box11, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React11.createElement(Box11, null, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "You can now use B4M CLI with your account.")));
+    return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React13.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "You can now use B4M CLI with your account.")));
   }
-  return /* @__PURE__ */ React11.createElement(Box11, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React11.createElement(Box11, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React11.createElement(Box11, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React11.createElement(Box11, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React11.createElement(Text10, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React11.createElement(Box11, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, null, "And enter this code when prompted:")), /* @__PURE__ */ React11.createElement(Box11, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React11.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, /* @__PURE__ */ React11.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React11.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
+  return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React13.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React13.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React13.createElement(Box12, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React13.createElement(Text12, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React13.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, null, "And enter this code when prompted:")), /* @__PURE__ */ React13.createElement(Box12, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React13.createElement(Text12, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React13.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "cyan" }, /* @__PURE__ */ React13.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React13.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
 }
 
 // src/storage/SessionStore.ts
@@ -1394,7 +1770,7 @@ var SessionStore = class {
 };
 
 // src/storage/ConfigStore.ts
-import { promises as fs4 } from "fs";
+import { promises as fs4, existsSync as existsSync3 } from "fs";
 import path4 from "path";
 import { homedir as homedir2 } from "os";
 import { v4 as uuidv4 } from "uuid";
@@ -1421,8 +1797,8 @@ var CliConfigSchema = z.object({
   mcpServers: z.array(
     z.object({
       name: z.string(),
-      command: z.string(),
-      args: z.array(z.string()),
+      command: z.string().optional(),
+      args: z.array(z.string()).optional(),
       env: z.record(z.string()),
       enabled: z.boolean()
     })
@@ -1442,6 +1818,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().optional(),
+      args: z.array(z.string()).optional(),
+      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().optional(),
+      args: z.array(z.string()).optional(),
+      env: z.record(z.string()),
+      enabled: z.boolean()
+    })
+  ).optional()
+});
 var DEFAULT_CONFIG = {
   version: "0.1.0",
   userId: uuidv4(),
@@ -1468,9 +1891,124 @@ var DEFAULT_CONFIG = {
   trustedTools: []
   // No tools trusted by default
 };
+function findProjectConfigDir(startDir = process.cwd()) {
+  let currentDir = startDir;
+  const { root } = path4.parse(currentDir);
+  while (currentDir !== root) {
+    const gitPath = path4.join(currentDir, ".git");
+    try {
+      if (existsSync3(gitPath)) {
+        return currentDir;
+      }
+    } catch {
+    }
+    currentDir = path4.dirname(currentDir);
+  }
+  return process.cwd();
+}
+async function loadProjectConfig(projectDir) {
+  const configPath = path4.join(projectDir, ".bike4mind", "config.json");
+  try {
+    const data = await fs4.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 = path4.join(projectDir, ".bike4mind", "local.json");
+  try {
+    const data = await fs4.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: [...merged.tools.enabled || [], ...project.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) {
+      const trustedSet = /* @__PURE__ */ new Set([...merged.trustedTools || [], ...local.trustedTools]);
+      merged.trustedTools = Array.from(trustedSet);
+    }
+    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.projectConfigDir = null;
     this.configPath = configPath || path4.join(homedir2(), ".bike4mind", "config.json");
   }
   /**
@@ -1487,51 +2025,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 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);
+          }
+        } 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 };
+          } 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") {
@@ -1720,6 +2283,92 @@ var ConfigStore = class {
     }
     await this.save(config);
   }
+  /**
+   * Get project config directory (if any)
+   */
+  getProjectConfigDir() {
+    return this.projectConfigDir;
+  }
+  /**
+   * Initialize project config directory
+   * Creates .bike4mind/ directory and ensures local.json is gitignored
+   * Does NOT auto-create config.json (user creates that manually)
+   */
+  async initProjectConfig() {
+    const projectDir = this.projectConfigDir || findProjectConfigDir();
+    if (!projectDir) {
+      return;
+    }
+    const configDir = path4.join(projectDir, ".bike4mind");
+    await fs4.mkdir(configDir, { recursive: true });
+    await this.ensureGitignore(projectDir);
+  }
+  /**
+   * Ensure .gitignore includes .bike4mind/local.json
+   */
+  async ensureGitignore(projectDir) {
+    const gitignorePath = path4.join(projectDir, ".gitignore");
+    const entryToAdd = ".bike4mind/local.json";
+    try {
+      let gitignoreContent = "";
+      try {
+        gitignoreContent = await fs4.readFile(gitignorePath, "utf-8");
+      } catch {
+      }
+      if (gitignoreContent.includes(entryToAdd)) {
+        return;
+      }
+      const newContent = gitignoreContent.trim() + (gitignoreContent ? "\n" : "") + `
+# Bike4Mind local config (developer-specific)
+${entryToAdd}
+`;
+      await fs4.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 = path4.join(targetDir, ".bike4mind", "config.json");
+    await fs4.mkdir(path4.dirname(configPath), { recursive: true });
+    const validated = ProjectConfigSchema.parse(config);
+    await fs4.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 = path4.join(targetDir, ".bike4mind", "local.json");
+    await fs4.mkdir(path4.dirname(configPath), { recursive: true });
+    const validated = ProjectLocalConfigSchema.parse(config);
+    await fs4.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
+    await fs4.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
@@ -1856,7 +2505,7 @@ var ReActAgent = class extends EventEmitter {
   /**
    * Run the agent to completion
    *
-   * @param query - The user's question or task
+   * @param query - The user's question or task (can be text or multimodal content with images)
    * @param options - Optional overrides for this run
    * @returns Agent result with final answer and all steps
    */
@@ -4471,13 +5120,30 @@ async function performWebSearch(adapters, params) {
       link: result.link,
       snippet: result.snippet
     })) || [];
+    const citables = results.map((result, index) => ({
+      id: result.link,
+      // Use URL as unique identifier
+      type: "web_url",
+      title: result.title,
+      url: result.link,
+      description: result.snippet,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "complete",
+      metadata: {
+        sourceSystem: "web_search",
+        relevanceScore: 1 - index * 0.1,
+        // Higher relevance for earlier results
+        fullContext: result.snippet
+      }
+    }));
     const formattedResults = results.map((result, index) => `${index + 1}. **${result.title}**
 ${result.snippet}
 Source: [${new URL(result.link).hostname}](${result.link})
 `).join("\n");
-    return formattedResults ? `Here's what I found from searching the web:
+    const formattedOutput = formattedResults ? `Here's what I found from searching the web:
 
 ${formattedResults}` : "No results found from web search.";
+    return { formattedResults: formattedOutput, citables };
   } catch (error) {
     console.error("\u274C WebSearch Tool: Error during search:", error);
     throw error;
@@ -4488,7 +5154,18 @@ var webSearchTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      return performWebSearch({ db: context.db }, params);
+      const { formattedResults, citables } = await performWebSearch({ db: context.db }, params);
+      if (citables.length > 0) {
+        await context.statusUpdate({
+          // Store citables in promptMeta - statusUpdate will Object.assign this
+          // The receiving code needs to handle merging promptMeta.citables
+          promptMeta: {
+            citables
+          }
+        }, "Web search complete");
+        console.log(`\u{1F4DA} WebSearch Tool: Stored ${citables.length} citables`);
+      }
+      return formattedResults;
     },
     toolSchema: {
       name: "web_search",
@@ -7305,7 +7982,7 @@ 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 { existsSync as existsSync4, statSync as statSync4 } from "fs";
 import path6 from "path";
 var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 async function readFileContent(params) {
@@ -7316,10 +7993,10 @@ async function readFileContent(params) {
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
-  if (!existsSync2(resolvedPath)) {
+  if (!existsSync4(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const stats = statSync3(resolvedPath);
+  const stats = statSync4(resolvedPath);
   if (stats.isDirectory()) {
     throw new Error(`Path is a directory, not a file: ${filePath}`);
   }
@@ -7362,7 +8039,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 = statSync4(path6.resolve(process.cwd(), path6.normalize(params.path)));
         context.logger.info("\u2705 FileRead: Success", {
           path: params.path,
           size: stats.size,
@@ -7402,7 +8079,7 @@ var fileReadTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
 import { promises as fs8 } from "fs";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import path7 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
@@ -7412,7 +8089,7 @@ async function createFile(params) {
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
-  const fileExists = existsSync3(resolvedPath);
+  const fileExists = existsSync5(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
     const dir = path7.dirname(resolvedPath);
@@ -7430,7 +8107,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync3(path7.resolve(process.cwd(), path7.normalize(params.path)));
+      const fileExists = existsSync5(path7.resolve(process.cwd(), path7.normalize(params.path)));
       context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
         path: params.path,
         size: params.content.length
@@ -7471,7 +8148,7 @@ 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 { statSync as statSync5 } from "fs";
 import path8 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]");
@@ -7519,7 +8196,7 @@ async function listFiles(params) {
   for (const match of matches) {
     try {
       const fullPath = path8.join(targetCwd, match);
-      const stats = statSync4(fullPath);
+      const stats = statSync5(fullPath);
       filesInfo.push({
         path: match,
         size: stats.size,
@@ -7600,7 +8277,7 @@ 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 { readFileSync as readFileSync3, statSync as statSync6 } from "fs";
 import path9 from "path";
 var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
 function matchGlob2(filePath, pattern) {
@@ -7652,7 +8329,7 @@ async function searchFiles2(params) {
   for (const match of filesToSearch) {
     const fullPath = path9.join(targetCwd, match);
     try {
-      const stats = statSync5(fullPath);
+      const stats = statSync6(fullPath);
       if (stats.isDirectory() || stats.size > MAX_FILE_SIZE3) {
         continue;
       }
@@ -7676,7 +8353,7 @@ async function searchFiles2(params) {
     filesSearched++;
     const fullPath = path9.join(targetCwd, file);
     try {
-      const content = readFileSync2(fullPath, "utf-8");
+      const content = readFileSync3(fullPath, "utf-8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (matches.length >= maxResults) {
@@ -7810,7 +8487,7 @@ 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 { existsSync as existsSync6, statSync as statSync7 } from "fs";
 import path10 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
@@ -7820,10 +8497,10 @@ async function deleteFile(params) {
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
-  if (!existsSync4(resolvedPath)) {
+  if (!existsSync6(resolvedPath)) {
     throw new Error(`File or directory not found: ${filePath}`);
   }
-  const stats = statSync6(resolvedPath);
+  const stats = statSync7(resolvedPath);
   const isDirectory = stats.isDirectory();
   const size = stats.size;
   if (isDirectory && !recursive) {
@@ -7844,7 +8521,7 @@ var deleteFileTool = {
     toolFn: async (value) => {
       const params = value;
       const resolvedPath = path10.resolve(process.cwd(), path10.normalize(params.path));
-      const isDirectory = existsSync4(resolvedPath) && statSync6(resolvedPath).isDirectory();
+      const isDirectory = existsSync6(resolvedPath) && statSync7(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -8134,10 +8811,10 @@ import jwt2 from "jsonwebtoken";
 // src/utils/diffPreview.ts
 import * as Diff from "diff";
 import { readFile } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 async function generateFileDiffPreview(args) {
   try {
-    if (!existsSync5(args.path)) {
+    if (!existsSync7(args.path)) {
       const lines2 = args.content.split("\n");
       const preview = lines2.slice(0, 20).join("\n");
       const hasMore = lines2.length > 20;
@@ -8167,7 +8844,7 @@ ${preview}${hasMore ? `
 }
 async function generateFileDeletePreview(args) {
   try {
-    if (!existsSync5(args.path)) {
+    if (!existsSync7(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
     const stats = await import("fs/promises").then((fs11) => fs11.stat(args.path));
@@ -8220,7 +8897,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 {
@@ -8264,7 +8941,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 });
@@ -8272,7 +8967,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 = {
@@ -8356,7 +9051,9 @@ 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 };
 }
 
@@ -8421,23 +9118,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;
     }
@@ -8448,10 +9152,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;
     }
@@ -8484,12 +9191,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
    */
@@ -8784,18 +9506,22 @@ var logger = Logger2.getInstance();
 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 { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
   transport = null;
   envVariables;
+  customCommand;
+  customArgs;
   tools = [];
   serverName;
-  constructor({ envVariables, name, selectedRepositories }) {
+  constructor({ envVariables, name, selectedRepositories, command, args }) {
     this.mcp = new Client2({ name: "mcp-client-cli", version: "1.0.0" });
     this.envVariables = [...envVariables];
     this.serverName = name;
+    this.customCommand = command;
+    this.customArgs = args;
     if (name === "github" && selectedRepositories) {
       const reposJson = JSON.stringify(selectedRepositories);
       this.envVariables.push({
@@ -8806,37 +9532,48 @@ var MCPClient = class {
   }
   async connectToServer() {
     try {
-      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`),
-        // When running from SST Lambda deployed environment (/var/task)
-        path12.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`),
-        // 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`),
-        // 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")
-      ];
-      const serverScriptPath = candidatePaths.find((p) => existsSync6(p));
-      if (!serverScriptPath) {
-        const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
-        console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
-        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(", ")}`);
-      }
-      console.log(`[MCP] Using server: ${this.serverName} at ${serverScriptPath}`);
+      const envVarsObject = this.envVariables.reduce((acc, env) => ({
+        ...acc,
+        [env.key]: env.value
+      }), {});
+      let command;
+      let args;
+      if (this.customCommand && this.customCommand.trim() !== "") {
+        command = this.customCommand;
+        args = this.customArgs ?? [];
+        console.log(`[MCP] Using external command for ${this.serverName}: ${command} ${args.join(" ")}`);
+      } else {
+        const root = process.env.INIT_CWD || process.cwd();
+        const candidatePaths = [
+          // When running from SST Lambda with node_modules structure (copyFiles)
+          path12.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`),
+          // 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`),
+          // 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`),
+          // 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")
+        ];
+        const serverScriptPath = candidatePaths.find((p) => existsSync8(p));
+        if (!serverScriptPath) {
+          const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+          console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
+          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(", ")}`);
+        }
+        command = process.execPath;
+        args = [serverScriptPath];
+        console.log(`[MCP] Using server: ${this.serverName} at ${serverScriptPath}`);
+      }
       this.transport = new StdioClientTransport({
-        command: process.execPath,
-        args: [serverScriptPath],
+        command,
+        args,
         env: {
-          ...process.env,
-          ...this.envVariables.reduce((acc, env) => ({
-            ...acc,
-            [env.key]: env.value
-          }), {})
+          ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0)),
+          ...envVarsObject
         }
       });
       this.transport.onerror = (error) => {
@@ -8944,7 +9681,9 @@ var McpManager = class {
       }));
       const client = new MCPClient({
         envVariables,
-        name: serverConfig.name
+        name: serverConfig.name,
+        command: serverConfig.command,
+        args: serverConfig.args
       });
       await client.connectToServer();
       const mcpData = {
@@ -9016,6 +9755,190 @@ var McpManager = class {
   }
 };
 
+// src/utils/imageRenderer.ts
+var ImageRenderer = class {
+  constructor() {
+    this.imageCounter = 0;
+    this.placeholderMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Generate placeholder for a new image
+   */
+  createPlaceholder(hash) {
+    const existing = this.placeholderMap.get(hash);
+    if (existing) {
+      return existing.placeholder;
+    }
+    this.imageCounter++;
+    const placeholder = `[Image ${this.imageCounter}]`;
+    this.placeholderMap.set(hash, {
+      hash,
+      number: this.imageCounter,
+      placeholder
+    });
+    return placeholder;
+  }
+  /**
+   * Get all image hashes from a message containing placeholders
+   */
+  extractImageHashes(message) {
+    const hashes = [];
+    const placeholderRegex = /\[Image \d+\]/g;
+    const matches = message.match(placeholderRegex);
+    if (!matches) return hashes;
+    for (const [hash, data] of this.placeholderMap.entries()) {
+      if (matches.includes(data.placeholder)) {
+        hashes.push(hash);
+      }
+    }
+    return hashes;
+  }
+  /**
+   * Get hash by placeholder text
+   */
+  getHashFromPlaceholder(placeholder) {
+    for (const [hash, data] of this.placeholderMap.entries()) {
+      if (data.placeholder === placeholder) {
+        return hash;
+      }
+    }
+    return null;
+  }
+};
+
+// src/utils/messageBuilder.ts
+var MessageBuilder = class {
+  constructor(imageStore, imageRenderer) {
+    this.imageStore = imageStore;
+    this.imageRenderer = imageRenderer;
+  }
+  /**
+   * Build a multimodal message from user input
+   * Extracts image placeholders and creates proper message structure with base64-encoded images
+   */
+  async buildMessage(userInput, role = "user") {
+    const imageHashes = this.imageRenderer.extractImageHashes(userInput);
+    if (imageHashes.length === 0) {
+      return {
+        message: {
+          role,
+          content: userInput
+        },
+        uploadedImages: []
+      };
+    }
+    const content = [];
+    const parts = this.splitMessageByPlaceholders(userInput);
+    for (const part of parts) {
+      if (part.type === "text" && part.content.trim()) {
+        content.push({
+          type: "text",
+          text: part.content
+        });
+      } else if (part.type === "image") {
+        const hash = this.imageRenderer.getHashFromPlaceholder(part.content);
+        if (hash) {
+          const imageData = this.imageStore.readImage(hash);
+          const metadata = this.imageStore.getMetadata(hash);
+          if (imageData && metadata) {
+            const base64Data = imageData.toString("base64");
+            const mediaType = this.getMediaType(metadata.format);
+            content.push({
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: mediaType,
+                data: base64Data
+              }
+            });
+          }
+        }
+      }
+    }
+    return {
+      message: {
+        role,
+        content
+      },
+      uploadedImages: []
+    };
+  }
+  /**
+   * Get MIME type for image format
+   */
+  getMediaType(format) {
+    switch (format.toLowerCase()) {
+      case "png":
+        return "image/png";
+      case "jpg":
+      case "jpeg":
+        return "image/jpeg";
+      case "gif":
+        return "image/gif";
+      case "webp":
+        return "image/webp";
+      default:
+        return "image/png";
+    }
+  }
+  /**
+   * Split message text by image placeholders
+   * Returns array of text and image parts in order
+   */
+  splitMessageByPlaceholders(message) {
+    const parts = [];
+    const placeholderRegex = /(\[Image \d+\])/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = placeholderRegex.exec(message)) !== null) {
+      if (match.index > lastIndex) {
+        const text = message.substring(lastIndex, match.index);
+        if (text) {
+          parts.push({ type: "text", content: text });
+        }
+      }
+      parts.push({ type: "image", content: match[0] });
+      lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < message.length) {
+      const text = message.substring(lastIndex);
+      if (text) {
+        parts.push({ type: "text", content: text });
+      }
+    }
+    if (parts.length === 0) {
+      parts.push({ type: "text", content: message });
+    }
+    return parts;
+  }
+  /**
+   * Check if a message contains images
+   */
+  hasImages(message) {
+    return this.imageRenderer.extractImageHashes(message).length > 0;
+  }
+  /**
+   * Convert multimodal message back to simple string (for display/logging)
+   */
+  messageToString(message) {
+    if (typeof message.content === "string") {
+      return message.content;
+    }
+    return message.content.map((item) => {
+      if (item.type === "text") {
+        return item.text;
+      } else if (item.type === "image") {
+        if (item.source.type === "url") {
+          return `[Image: ${item.source.url}]`;
+        } else {
+          return `[Image: base64 ${item.source.media_type}]`;
+        }
+      }
+      return "";
+    }).join("");
+  }
+};
+
 // src/llm/ServerLlmBackend.ts
 import { createParser } from "eventsource-parser";
 import { isAxiosError } from "axios";
@@ -9215,9 +10138,40 @@ var ServerLlmBackend = class {
   }
   /**
    * Get available models from server
-   * For now, returns hardcoded list of supported models
+   * Fetches from /api/models and filters for CLI-compatible models
+   * Falls back to hardcoded list if API fails
    */
   async getModelInfo() {
+    try {
+      logger.debug("[ServerLlmBackend] Fetching models from /api/models");
+      const response = await this.apiClient.get("/api/models");
+      if (!response || typeof response !== "object" || !Array.isArray(response.models)) {
+        logger.warn("[ServerLlmBackend] Invalid API response format, using fallback models");
+        logger.info("\u26A0\uFE0F  Using fallback model list (API returned invalid format)");
+        return this.getFallbackModels();
+      }
+      const filteredModels = response.models.filter((model) => model.type === "text" && model.supportsTools === true);
+      logger.debug(`[ServerLlmBackend] Fetched ${filteredModels.length} CLI-compatible models`);
+      if (filteredModels.length === 0) {
+        logger.warn("[ServerLlmBackend] No CLI-compatible models found from API, using fallback");
+        logger.info("\u26A0\uFE0F  Using fallback model list (no CLI-compatible models available)");
+        return this.getFallbackModels();
+      }
+      logger.info(`\u{1F4CB} Loaded ${filteredModels.length} models from server`);
+      return filteredModels;
+    } catch (error) {
+      logger.warn(
+        `[ServerLlmBackend] Failed to fetch models from API, using fallback: ${error instanceof Error ? error.message : String(error)}`
+      );
+      logger.info("\u26A0\uFE0F  Using fallback model list (API unavailable)");
+      return this.getFallbackModels();
+    }
+  }
+  /**
+   * Fallback models when API is unavailable
+   * Returns hardcoded list of commonly supported models
+   */
+  getFallbackModels() {
     return [
       {
         id: "claude-sonnet-4-5-20250929",
@@ -9402,7 +10356,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.5-ja-fix-confluence-table-data-5752.17103+6a00a3402",
+  version: "0.2.7-basic-cli-shortcuts.17131+b79f34724",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -9463,6 +10417,7 @@ var package_default = {
     "async-mutex": "^0.5.0",
     axios: "^1.13.2",
     bcryptjs: "^2.4.3",
+    "better-sqlite3": "^12.5.0",
     cheerio: "1.0.0-rc.12",
     "csv-parse": "^5.5.6",
     dayjs: "^1.11.13",
@@ -9488,7 +10443,7 @@ var package_default = {
     "p-limit": "^6.2.0",
     qrcode: "^1.5.4",
     react: "^19.2.3",
-    sharp: "^0.32.6",
+    sharp: "^0.34.5",
     speakeasy: "^2.0.0",
     tiktoken: "^1.0.16",
     turndown: "^7.2.0",
@@ -9504,10 +10459,11 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.37.1-ja-fix-confluence-table-data-5752.17103+6a00a3402",
-    "@bike4mind/mcp": "1.19.6-ja-fix-confluence-table-data-5752.17103+6a00a3402",
-    "@bike4mind/services": "2.32.2-ja-fix-confluence-table-data-5752.17103+6a00a3402",
-    "@bike4mind/utils": "2.1.1-ja-fix-confluence-table-data-5752.17103+6a00a3402",
+    "@bike4mind/common": "2.38.1-basic-cli-shortcuts.17131+b79f34724",
+    "@bike4mind/mcp": "1.20.1-basic-cli-shortcuts.17131+b79f34724",
+    "@bike4mind/services": "2.33.1-basic-cli-shortcuts.17131+b79f34724",
+    "@bike4mind/utils": "2.1.2-basic-cli-shortcuts.17131+b79f34724",
+    "@types/better-sqlite3": "^7.6.12",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -9519,7 +10475,7 @@ var package_default = {
     typescript: "^5.9.3",
     vitest: "^3.2.4"
   },
-  gitHead: "6a00a340293a16b1c79330247461aae6bcbf3dfa"
+  gitHead: "b79f34724ba9a60aae19010065d78ac75c2f8396"
 };
 
 // src/config/constants.ts
@@ -9540,19 +10496,26 @@ var EXIT_TIMEOUT_MS = 2e3;
 var usageCache = null;
 function CliApp() {
   const { exit } = useApp();
-  const [state, setState] = useState4({
+  const imageRenderer = new ImageRenderer();
+  const [state, setState] = useState5({
     session: null,
     sessionStore: new SessionStore(),
     configStore: new ConfigStore(),
     commandHistoryStore: new CommandHistoryStore(),
+    imageStore: null,
+    // Lazy-loaded on first use
+    imageRenderer,
+    messageBuilder: null,
     agent: null,
     mcpManager: null,
     permissionManager: null,
-    permissionPrompt: null
+    permissionPrompt: null,
+    trustLocationSelector: null
   });
-  const [isInitialized, setIsInitialized] = useState4(false);
-  const [initError, setInitError] = useState4(null);
-  const [commandHistory, setCommandHistory] = useState4([]);
+  const [isInitialized, setIsInitialized] = useState5(false);
+  const [initError, setInitError] = useState5(null);
+  const [commandHistory, setCommandHistory] = useState5([]);
+  const imageStoreInitPromise = useRef(null);
   const setStoreSession = useCliStore((state2) => state2.setSession);
   const setPermissionPrompt = useCliStore((state2) => state2.setPermissionPrompt);
   const setShowConfigEditor = useCliStore((state2) => state2.setShowConfigEditor);
@@ -9576,6 +10539,13 @@ function CliApp() {
     if (state.agent) {
       state.agent.removeAllListeners();
     }
+    if (state.imageStore) {
+      try {
+        state.imageStore.close();
+      } catch (err) {
+        logger.debug(`[CLEANUP] Image store close error: ${err}`);
+      }
+    }
     await Promise.race([
       Promise.all(cleanupTasks),
       new Promise((resolve3) => setTimeout(resolve3, 500))
@@ -9584,8 +10554,8 @@ function CliApp() {
     setTimeout(() => {
       process.exit(0);
     }, 100);
-  }, [state.session, state.sessionStore, state.mcpManager, state.agent]);
-  useInput3((input, key) => {
+  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
+  useInput4((input, key) => {
     if (key.ctrl && input === "c") {
       const now = Date.now();
       if (exitTimestamp && now - exitTimestamp < EXIT_TIMEOUT_MS) {
@@ -9710,7 +10680,13 @@ 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) => {
           const canBeTrusted = permissionManager.canBeTrusted(toolName);
@@ -9738,6 +10714,7 @@ function CliApp() {
         permissionManager,
         promptFn,
         agentContext,
+        state.configStore,
         config.toolApiKeys
       );
       console.log(`\u{1F6E0}\uFE0F  Loaded ${b4mTools.length} B4M tool(s)`);
@@ -9802,8 +10779,10 @@ Remember: Use context from previous messages to understand follow-up questions.`
         agent,
         mcpManager,
         permissionManager,
-        config
+        config,
         // Store config for synchronous access
+        availableModels: models
+        // Store models for ConfigEditor
       }));
       setStoreSession(newSession);
       setIsInitialized(true);
@@ -9835,9 +10814,16 @@ Remember: Use context from previous messages to understand follow-up questions.`
       return;
     }
     try {
+      let messageContent = message;
+      let userMessageContent = message;
+      if (state.messageBuilder && state.messageBuilder.hasImages(message)) {
+        const { message: multimodalMessage } = await state.messageBuilder.buildMessage(message);
+        messageContent = multimodalMessage.content;
+        userMessageContent = message;
+      }
       const userMessage = {
         role: "user",
-        content: message,
+        content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const recentMessages = state.session.messages.slice(-20);
@@ -9845,7 +10831,7 @@ Remember: Use context from previous messages to understand follow-up questions.`
         role: msg.role,
         content: msg.content
       }));
-      const result = await state.agent.run(message, {
+      const result = await state.agent.run(messageContent, {
         previousMessages: previousMessages.length > 0 ? previousMessages : void 0
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
@@ -9894,6 +10880,35 @@ Remember: Use context from previous messages to understand follow-up questions.`
       console.error("Error processing message:", error);
     }
   };
+  const handleImageDetected = async (imageData) => {
+    try {
+      let imageStore = state.imageStore;
+      if (!imageStore) {
+        if (!imageStoreInitPromise.current) {
+          imageStoreInitPromise.current = (async () => {
+            const { ImageStore: ImageStoreClass } = await import("./ImageStore-RQZ7OF7P.js");
+            const newImageStore = new ImageStoreClass();
+            setState((prev) => ({
+              ...prev,
+              imageStore: newImageStore,
+              messageBuilder: new MessageBuilder(newImageStore, prev.imageRenderer)
+            }));
+            return newImageStore;
+          })();
+        }
+        imageStore = await imageStoreInitPromise.current;
+      }
+      const imageRef = await imageStore.store(imageData);
+      const imagePlaceholder = state.imageRenderer.createPlaceholder(imageRef.hash);
+      console.log(`
+\u2713 Image detected and stored: ${imagePlaceholder}
+`);
+      return imagePlaceholder;
+    } catch (error) {
+      console.error("Error storing image:", error);
+      throw error;
+    }
+  };
   const handleCommand = async (command, args) => {
     switch (command) {
       case "help":
@@ -9919,6 +10934,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":
@@ -9997,7 +11015,7 @@ Tool Permissions:
         console.log("");
         break;
       }
-      case "trust":
+      case "trust": {
         if (!state.permissionManager) {
           console.log("Permission manager not initialized");
           return;
@@ -10005,16 +11023,97 @@ 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;
+              }
+              try {
+                await state.configStore.initProjectConfig();
+                const existingLocal = await state.configStore.loadRawProjectLocalConfig() || {};
+                const updatedLocal = {
+                  ...existingLocal,
+                  trustedTools: [.../* @__PURE__ */ new Set([...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`);
+              } catch (error) {
+                console.error(`\u274C Failed to save project-local config:`, error);
+              }
+              break;
+            }
+            case "project": {
+              if (!projectDir) {
+                console.log('\u274C No project found. Use "global" to save to ~/.bike4mind/config.json');
+                return;
+              }
+              try {
+                const existingProject = await state.configStore.loadRawProjectConfig() || {};
+                const updatedProject = {
+                  ...existingProject,
+                  tools: {
+                    ...existingProject.tools,
+                    enabled: [.../* @__PURE__ */ new Set([...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!");
+              } catch (error) {
+                console.error(`\u274C Failed to save project config:`, error);
+              }
+              break;
+            }
+            case "global": {
+              try {
+                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");
+              } catch (error) {
+                console.error(`\u274C Failed to save global config:`, error);
+              }
+              break;
+            }
+          }
+        };
+        setState((prev) => ({
+          ...prev,
+          trustLocationSelector: {
+            toolName: toolToTrust,
+            resolve: handleLocationSelect
+          }
+        }));
         break;
+      }
       case "untrust":
         if (!state.permissionManager) {
           console.log("Permission manager not initialized");
@@ -10190,6 +11289,49 @@ Usage by Model (Last ${USAGE_DAYS} days):`);
           console.log(`
 No usage data available for the last ${USAGE_DAYS} days.`);
         }
+        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;
       }
@@ -10203,11 +11345,31 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     setState((prev) => ({ ...prev, config: updatedConfig }));
   };
   if (initError) {
-    return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React12.createElement(Text11, null, initError), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
+    return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React14.createElement(Text13, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React14.createElement(Text13, null, initError), /* @__PURE__ */ React14.createElement(Text13, { 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__ */ React14.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__ */ React12.createElement(
+    return /* @__PURE__ */ React14.createElement(
       LoginFlow,
       {
         apiUrl: loginApiUrl,
@@ -10230,15 +11392,17 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     );
   }
   if (!isInitialized) {
-    return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React12.createElement(Text11, null, "\u{1F680} Initializing..."));
+    return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React14.createElement(Text13, null, "\u{1F680} Initializing..."));
   }
-  return /* @__PURE__ */ React12.createElement(
+  return /* @__PURE__ */ React14.createElement(
     App,
     {
       onMessage: handleMessage,
       onCommand: handleCommand,
+      onImageDetected: handleImageDetected,
       commandHistory,
       config: state.config,
+      availableModels: state.availableModels,
       onSaveConfig: handleSaveConfig,
       onPermissionResponse: (response) => {
         if (state.permissionPrompt) {
@@ -10265,6 +11429,6 @@ var isDevMode = import.meta.url.includes("/src/") || process.env.NODE_ENV === "d
 if (isDevMode) {
   console.log("\u{1F527} Running in development mode (using TypeScript source)\n");
 }
-render(/* @__PURE__ */ React12.createElement(CliApp, null), {
+render(/* @__PURE__ */ React14.createElement(CliApp, null), {
   exitOnCtrlC: false
 });