@bike4mind/cli 0.2.29-cli-minimal-ui.18782 → 0.2.29-cli-minimal-ui.18783

package/dist/index.js

@@ -7,8 +7,9 @@ import {
   getSerperKey
 } from "./chunk-4XFX3V4G.js";
 import {
-  ConfigStore
-} from "./chunk-23T2XGSZ.js";
+  ConfigStore,
+  logger
+} from "./chunk-LBTTUQJM.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
@@ -2612,271 +2613,13 @@ var CommandHistoryStore = class {
 };
 
 // src/storage/CustomCommandStore.ts
-import fs6 from "fs/promises";
-import path6 from "path";
-import os2 from "os";
-
-// src/utils/commandParser.ts
-import matter from "gray-matter";
-import { z } from "zod";
-
-// src/utils/Logger.ts
 import fs5 from "fs/promises";
 import path5 from "path";
 import os from "os";
-var Logger2 = class _Logger {
-  constructor() {
-    this.logFilePath = null;
-    this.sessionId = null;
-    this.fileLoggingEnabled = true;
-    this.consoleVerbose = false;
-  }
-  static {
-    this.instance = null;
-  }
-  static getInstance() {
-    if (!_Logger.instance) {
-      _Logger.instance = new _Logger();
-    }
-    return _Logger.instance;
-  }
-  /**
-   * Initialize the logger with a session ID
-   */
-  async initialize(sessionId) {
-    this.sessionId = sessionId;
-    const debugDir = path5.join(os.homedir(), ".bike4mind", "debug");
-    await fs5.mkdir(debugDir, { recursive: true });
-    this.logFilePath = path5.join(debugDir, `${sessionId}.txt`);
-    await this.writeToFile("INFO", "=== CLI SESSION START ===");
-  }
-  /**
-   * Set whether verbose console logging is enabled
-   */
-  setVerbose(enabled) {
-    this.consoleVerbose = enabled;
-  }
-  /**
-   * Set whether file logging is enabled
-   */
-  setFileLoggingEnabled(enabled) {
-    this.fileLoggingEnabled = enabled;
-  }
-  /**
-   * DEBUG level - verbose-only console, always file
-   */
-  debug(message) {
-    this.writeToFile("DEBUG", message).catch(() => {
-    });
-    if (this.consoleVerbose) {
-      console.log(message);
-    }
-  }
-  /**
-   * INFO level - always shown to user
-   */
-  info(message) {
-    this.writeToFile("INFO", message).catch(() => {
-    });
-    console.log(message);
-  }
-  /**
-   * WARN level - always shown to user
-   */
-  warn(message) {
-    this.writeToFile("WARN", message).catch(() => {
-    });
-    console.warn(message);
-  }
-  /**
-   * ERROR level - always shown to user
-   */
-  error(message, err) {
-    this.writeToFile("ERROR", message).catch(() => {
-    });
-    if (err) {
-      this.logErrorDetailsToFile(err).catch(() => {
-      });
-    }
-    console.error(message);
-  }
-  /**
-   * Write log entry to file
-   */
-  async writeToFile(level, message) {
-    if (!this.fileLoggingEnabled || !this.logFilePath) {
-      return;
-    }
-    try {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
-      const logEntry = `[${timestamp}] [${level}] ${message}
-`;
-      await fs5.appendFile(this.logFilePath, logEntry, "utf-8");
-    } catch (error) {
-      console.error("File logging failed:", error);
-    }
-  }
-  /**
-   * Log error details to file
-   */
-  async logErrorDetailsToFile(err) {
-    if (!this.fileLoggingEnabled || !this.logFilePath) {
-      return;
-    }
-    try {
-      if (err && typeof err === "object" && "response" in err && err.response) {
-        const response = err.response;
-        const config = err && typeof err === "object" && "config" in err ? err.config : void 0;
-        await this.writeToFile("ERROR", `  Status: ${response.status} ${response.statusText || ""}`);
-        await this.writeToFile("ERROR", `  URL: ${config?.url || "unknown"}`);
-        await this.writeToFile("ERROR", `  Headers: ${this.safeStringify(response.headers)}`);
-        if (response.data) {
-          const errorText = this.extractErrorMessage(response.data);
-          if (errorText.trim().startsWith("<!DOCTYPE") || errorText.trim().startsWith("<html")) {
-            await this.writeToFile("ERROR", `  Response Type: HTML Error Page`);
-            const parsedError = this.parseHtmlError(errorText);
-            if (parsedError) {
-              await this.writeToFile("ERROR", `  Error Message: ${parsedError}`);
-            }
-            await this.writeToFile("ERROR", `  Raw HTML: ${this.truncate(errorText, 1e3)}`);
-          } else {
-            const preview = this.truncate(errorText, 500);
-            await this.writeToFile("ERROR", `  Response: ${preview}`);
-          }
-        } else {
-          await this.writeToFile("ERROR", `  Response: (no data)`);
-        }
-      }
-      if (err && typeof err === "object" && "stack" in err && typeof err.stack === "string") {
-        const stackLines = err.stack.split("\n").slice(0, 5).join("\n    ");
-        await this.writeToFile("ERROR", `  Stack: ${stackLines}`);
-      } else if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
-        await this.writeToFile("ERROR", `  Message: ${err.message}`);
-      }
-    } catch (error) {
-    }
-  }
-  /**
-   * Safely stringify object, handling circular references
-   */
-  safeStringify(obj) {
-    try {
-      return JSON.stringify(obj);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("circular")) {
-        try {
-          const seen = /* @__PURE__ */ new WeakSet();
-          return JSON.stringify(obj, (key, value) => {
-            if (typeof value === "object" && value !== null) {
-              if (seen.has(value)) {
-                return "[Circular]";
-              }
-              seen.add(value);
-            }
-            return value;
-          });
-        } catch {
-          return "[Unable to stringify]";
-        }
-      }
-      return "[Stringify error]";
-    }
-  }
-  /**
-   * Extract readable text from error response data
-   */
-  extractErrorMessage(data) {
-    if (Buffer.isBuffer(data)) {
-      return data.toString("utf-8");
-    }
-    if (typeof data === "string") {
-      return data;
-    }
-    if (data && typeof data === "object" && "_readableState" in data && data._readableState && typeof data._readableState === "object" && "buffer" in data._readableState && Array.isArray(data._readableState.buffer) && data._readableState.buffer.length > 0) {
-      const chunks = [];
-      for (const chunk of data._readableState.buffer) {
-        if (chunk && typeof chunk === "object" && "type" in chunk && chunk.type === "Buffer" && "data" in chunk && Array.isArray(chunk.data)) {
-          chunks.push(Buffer.from(chunk.data));
-        } else if (Buffer.isBuffer(chunk)) {
-          chunks.push(chunk);
-        } else if (chunk && typeof chunk === "object" && "data" in chunk) {
-          if (Buffer.isBuffer(chunk.data)) {
-            chunks.push(chunk.data);
-          } else if (Array.isArray(chunk.data)) {
-            chunks.push(Buffer.from(chunk.data));
-          }
-        }
-      }
-      if (chunks.length > 0) {
-        return Buffer.concat(chunks).toString("utf-8");
-      }
-    }
-    return this.safeStringify(data);
-  }
-  /**
-   * Parse HTML error page to extract error message
-   */
-  parseHtmlError(html) {
-    const titleMatch = html.match(/<title>(.*?)<\/title>/i);
-    const h1Match = html.match(/<h1>(.*?)<\/h1>/i);
-    const bodyMatch = html.match(/<body[^>]*>(.*?)<\/body>/is);
-    if (titleMatch && titleMatch[1] !== "Error") {
-      return titleMatch[1].trim();
-    }
-    if (h1Match) {
-      return h1Match[1].trim();
-    }
-    if (bodyMatch) {
-      const text = bodyMatch[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-      return text.substring(0, 200);
-    }
-    return null;
-  }
-  /**
-   * Truncate string to max length with ellipsis
-   */
-  truncate(str, maxLength) {
-    if (str.length <= maxLength) {
-      return str;
-    }
-    return str.substring(0, maxLength) + "... [truncated]";
-  }
-  /**
-   * Format bytes to human-readable size
-   */
-  formatBytes(bytes) {
-    if (bytes === 0) return "0 B";
-    const k = 1024;
-    const sizes = ["B", "KB", "MB", "GB"];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
-  }
-  /**
-   * Clean up old debug logs (older than 30 days)
-   */
-  async cleanupOldLogs() {
-    if (!this.fileLoggingEnabled) return;
-    try {
-      const debugDir = path5.join(os.homedir(), ".bike4mind", "debug");
-      const files = await fs5.readdir(debugDir);
-      const now = Date.now();
-      const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
-      for (const file of files) {
-        const filePath = path5.join(debugDir, file);
-        const stats = await fs5.stat(filePath);
-        if (stats.mtime.getTime() < thirtyDaysAgo) {
-          await fs5.unlink(filePath);
-        }
-      }
-    } catch (error) {
-      console.error("Failed to cleanup old logs:", error);
-    }
-  }
-};
-var logger = Logger2.getInstance();
-logger.setVerbose(process.env.B4M_VERBOSE === "1");
 
 // src/utils/commandParser.ts
+import matter from "gray-matter";
+import { z } from "zod";
 var flexibleString = z.union([z.string(), z.array(z.string())]).transform((val) => Array.isArray(val) ? val.join(" ") : val).optional();
 var flexibleStringArray = z.union([z.string(), z.array(z.string())]).transform((val) => Array.isArray(val) ? val : [val]).optional();
 function needsQuoting(value) {
@@ -3031,17 +2774,17 @@ function extractCommandName(filename) {
 var CustomCommandStore = class {
   constructor(projectRoot) {
     this.commands = /* @__PURE__ */ new Map();
-    const home = os2.homedir();
+    const home = os.homedir();
     const root = projectRoot || process.cwd();
     this.globalCommandsDirs = [
-      path6.join(home, ".bike4mind", "commands"),
-      path6.join(home, ".claude", "commands"),
-      path6.join(home, ".claude", "skills")
+      path5.join(home, ".bike4mind", "commands"),
+      path5.join(home, ".claude", "commands"),
+      path5.join(home, ".claude", "skills")
     ];
     this.projectCommandsDirs = [
-      path6.join(root, ".bike4mind", "commands"),
-      path6.join(root, ".claude", "commands"),
-      path6.join(root, ".claude", "skills")
+      path5.join(root, ".bike4mind", "commands"),
+      path5.join(root, ".claude", "commands"),
+      path5.join(root, ".claude", "skills")
     ];
   }
   /**
@@ -3066,7 +2809,7 @@ var CustomCommandStore = class {
    */
   async loadCommandsFromDirectory(directory, source) {
     try {
-      const stats = await fs6.stat(directory);
+      const stats = await fs5.stat(directory);
       if (!stats.isDirectory()) {
         return;
       }
@@ -3099,9 +2842,9 @@ var CustomCommandStore = class {
   async findCommandFiles(directory) {
     const files = [];
     try {
-      const entries = await fs6.readdir(directory, { withFileTypes: true });
+      const entries = await fs5.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path6.join(directory, entry.name);
+        const fullPath = path5.join(directory, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.findCommandFiles(fullPath);
           files.push(...subFiles);
@@ -3121,14 +2864,14 @@ var CustomCommandStore = class {
    * @param source - Source identifier ('global' or 'project')
    */
   async loadCommandFile(filePath, source) {
-    const filename = path6.basename(filePath);
+    const filename = path5.basename(filePath);
     const isSkillFile = filename.toLowerCase() === "skill.md";
     const commandName = isSkillFile ? this.extractSkillName(filePath) : extractCommandName(filename);
     if (!commandName) {
       console.warn(`Invalid command filename: ${filename} (must end with .md and have valid name)`);
       return;
     }
-    const fileContent = await fs6.readFile(filePath, "utf-8");
+    const fileContent = await fs5.readFile(filePath, "utf-8");
     const command = parseCommandFile(fileContent, filePath, commandName, source);
     this.commands.set(commandName, command);
   }
@@ -3140,7 +2883,7 @@ var CustomCommandStore = class {
    * @returns Skill name or null if invalid
    */
   extractSkillName(filePath) {
-    const parentDir = path6.basename(path6.dirname(filePath));
+    const parentDir = path5.basename(path5.dirname(filePath));
     return parentDir && parentDir !== "skills" ? parentDir : null;
   }
   /**
@@ -3202,15 +2945,15 @@ var CustomCommandStore = class {
    */
   async createCommandFile(name, isGlobal = false) {
     const targetDir = isGlobal ? this.globalCommandsDirs[0] : this.projectCommandsDirs[0];
-    const filePath = path6.join(targetDir, `${name}.md`);
-    const fileExists = await fs6.access(filePath).then(
+    const filePath = path5.join(targetDir, `${name}.md`);
+    const fileExists = await fs5.access(filePath).then(
       () => true,
       () => false
     );
     if (fileExists) {
       throw new Error(`Command file already exists: ${filePath}`);
     }
-    await fs6.mkdir(targetDir, { recursive: true });
+    await fs5.mkdir(targetDir, { recursive: true });
     const template = `---
 description: ${name} command
 argument-hint: [args]
@@ -3225,7 +2968,7 @@ You can use:
 - $1, $2, etc. for positional arguments
 - @filename for file references
 `;
-    await fs6.writeFile(filePath, template, "utf-8");
+    await fs5.writeFile(filePath, template, "utf-8");
     return filePath;
   }
 };
@@ -4374,7 +4117,7 @@ import { GoogleGenerativeAI } from "@google/generative-ai";
 import OpenAI2 from "openai";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
-import fs7, { unlinkSync } from "fs";
+import fs6, { unlinkSync } from "fs";
 import yauzl from "yauzl";
 import axios3 from "axios";
 
@@ -6053,8 +5796,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path18 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path18;
+    const path17 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path17;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -7380,8 +7123,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path18 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path18;
+  const path17 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path17;
 }
 async function generateFullMask(imageBuffer) {
   const sharp = (await import("sharp")).default;
@@ -9322,15 +9065,15 @@ var planetVisibilityTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
-import { promises as fs8 } from "fs";
+import { promises as fs7 } from "fs";
 import { existsSync as existsSync3, statSync as statSync4 } from "fs";
-import path7 from "path";
+import path6 from "path";
 var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 async function readFileContent(params) {
   const { path: filePath, encoding = "utf-8", offset = 0, limit } = params;
-  const normalizedPath = path7.normalize(filePath);
-  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
-  const cwd = path7.resolve(process.cwd());
+  const normalizedPath = path6.normalize(filePath);
+  const resolvedPath = path6.resolve(process.cwd(), normalizedPath);
+  const cwd = path6.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
@@ -9348,7 +9091,7 @@ async function readFileContent(params) {
   if (isBinary && encoding === "utf-8") {
     throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
   }
-  const content = await fs8.readFile(resolvedPath, encoding);
+  const content = await fs7.readFile(resolvedPath, encoding);
   if (typeof content === "string") {
     const lines = content.split("\n");
     const totalLines = lines.length;
@@ -9386,7 +9129,7 @@ ${content}`;
 }
 async function checkIfBinary(filePath) {
   const buffer = Buffer.alloc(8192);
-  const fd = await fs8.open(filePath, "r");
+  const fd = await fs7.open(filePath, "r");
   try {
     const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
     const chunk = buffer.slice(0, bytesRead);
@@ -9403,7 +9146,7 @@ var fileReadTool = {
       context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
       try {
         const content = await readFileContent(params);
-        const stats = statSync4(path7.resolve(process.cwd(), path7.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,
@@ -9447,25 +9190,25 @@ var fileReadTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
-import { promises as fs9 } from "fs";
+import { promises as fs8 } from "fs";
 import { existsSync as existsSync4 } from "fs";
-import path8 from "path";
+import path7 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
-  const normalizedPath = path8.normalize(filePath);
-  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
-  const cwd = path8.resolve(process.cwd());
+  const normalizedPath = path7.normalize(filePath);
+  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
+  const cwd = path7.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
   const fileExists = existsSync4(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
-    const dir = path8.dirname(resolvedPath);
-    await fs9.mkdir(dir, { recursive: true });
+    const dir = path7.dirname(resolvedPath);
+    await fs8.mkdir(dir, { recursive: true });
   }
-  await fs9.writeFile(resolvedPath, content, "utf-8");
-  const stats = await fs9.stat(resolvedPath);
+  await fs8.writeFile(resolvedPath, content, "utf-8");
+  const stats = await fs8.stat(resolvedPath);
   const lines = content.split("\n").length;
   return `File ${action} successfully: ${filePath}
 Size: ${stats.size} bytes
@@ -9476,7 +9219,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync4(path8.resolve(process.cwd(), path8.normalize(params.path)));
+      const fileExists = existsSync4(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
@@ -9518,7 +9261,7 @@ var createFileTool = {
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
 import { glob } from "glob";
 import { stat } from "fs/promises";
-import path9 from "path";
+import path8 from "path";
 var DEFAULT_IGNORE_PATTERNS2 = [
   "**/node_modules/**",
   "**/.git/**",
@@ -9534,7 +9277,7 @@ var DEFAULT_IGNORE_PATTERNS2 = [
 async function findFiles(params) {
   const { pattern, dir_path, case_sensitive = true, respect_git_ignore = true } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path9.resolve(baseCwd, path9.normalize(dir_path)) : baseCwd;
+  const targetDir = dir_path ? path8.resolve(baseCwd, path8.normalize(dir_path)) : baseCwd;
   if (!targetDir.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot search outside of current working directory`);
   }
@@ -9574,7 +9317,7 @@ async function findFiles(params) {
   const summary = `Found ${filesWithStats.length} file(s)${truncated ? ` (showing first ${MAX_RESULTS})` : ""} matching: ${pattern}`;
   const dirInfo = dir_path ? `
 Directory: ${dir_path}` : "";
-  const filesList = results.map((file) => path9.relative(baseCwd, file.path)).join("\n");
+  const filesList = results.map((file) => path8.relative(baseCwd, file.path)).join("\n");
   return `${summary}${dirInfo}
 
 ${filesList}`;
@@ -9628,7 +9371,7 @@ var globFilesTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
 import { stat as stat2 } from "fs/promises";
-import path10 from "path";
+import path9 from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { createRequire } from "module";
@@ -9637,18 +9380,18 @@ var require2 = createRequire(import.meta.url);
 function getRipgrepPath() {
   try {
     const ripgrepPath = require2.resolve("@vscode/ripgrep");
-    const ripgrepDir = path10.dirname(ripgrepPath);
-    const rgBinary = path10.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    const ripgrepDir = path9.dirname(ripgrepPath);
+    const rgBinary = path9.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
     return rgBinary;
   } catch (error) {
     throw new Error("ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services");
   }
 }
 function isPathWithinWorkspace(targetPath, baseCwd) {
-  const resolvedTarget = path10.resolve(targetPath);
-  const resolvedBase = path10.resolve(baseCwd);
-  const relativePath = path10.relative(resolvedBase, resolvedTarget);
-  return !relativePath.startsWith("..") && !path10.isAbsolute(relativePath);
+  const resolvedTarget = path9.resolve(targetPath);
+  const resolvedBase = path9.resolve(baseCwd);
+  const relativePath = path9.relative(resolvedBase, resolvedTarget);
+  return !relativePath.startsWith("..") && !path9.isAbsolute(relativePath);
 }
 function convertGlobToRipgrepGlobs(globPattern) {
   if (!globPattern || globPattern === "**/*") {
@@ -9664,7 +9407,7 @@ function convertGlobToRipgrepGlobs(globPattern) {
 async function searchFiles2(params) {
   const { pattern, dir_path, include } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path10.resolve(baseCwd, dir_path) : baseCwd;
+  const targetDir = dir_path ? path9.resolve(baseCwd, dir_path) : baseCwd;
   if (!isPathWithinWorkspace(targetDir, baseCwd)) {
     throw new Error(`Path validation failed: "${dir_path}" resolves outside the allowed workspace directory`);
   }
@@ -9726,7 +9469,7 @@ async function searchFiles2(params) {
       if (item.type === "match") {
         const match = item;
         allMatches.push({
-          filePath: path10.relative(targetDir, match.data.path.text) || path10.basename(match.data.path.text),
+          filePath: path9.relative(targetDir, match.data.path.text) || path9.basename(match.data.path.text),
           lineNumber: match.data.line_number,
           line: match.data.lines.text.trimEnd()
           // Remove trailing newline
@@ -9819,14 +9562,14 @@ var grepSearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
-import { promises as fs10 } from "fs";
+import { promises as fs9 } from "fs";
 import { existsSync as existsSync5, statSync as statSync5 } from "fs";
-import path11 from "path";
+import path10 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
-  const normalizedPath = path11.normalize(filePath);
-  const resolvedPath = path11.resolve(process.cwd(), normalizedPath);
-  const cwd = path11.resolve(process.cwd());
+  const normalizedPath = path10.normalize(filePath);
+  const resolvedPath = path10.resolve(process.cwd(), normalizedPath);
+  const cwd = path10.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
@@ -9840,10 +9583,10 @@ async function deleteFile(params) {
     throw new Error(`Path is a directory: ${filePath}. Use recursive=true to delete directories and their contents.`);
   }
   if (isDirectory) {
-    await fs10.rm(resolvedPath, { recursive: true, force: true });
+    await fs9.rm(resolvedPath, { recursive: true, force: true });
     return `Directory deleted successfully: ${filePath}`;
   } else {
-    await fs10.unlink(resolvedPath);
+    await fs9.unlink(resolvedPath);
     return `File deleted successfully: ${filePath}
 Size: ${size} bytes`;
   }
@@ -9853,7 +9596,7 @@ var deleteFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const resolvedPath = path11.resolve(process.cwd(), path11.normalize(params.path));
+      const resolvedPath = path10.resolve(process.cwd(), path10.normalize(params.path));
       const isDirectory = existsSync5(resolvedPath) && statSync5(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
@@ -9979,7 +9722,7 @@ var knowledgeBaseSearchTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
 import { spawn } from "child_process";
-import path12 from "path";
+import path11 from "path";
 var DEFAULT_TIMEOUT_MS = 6e4;
 var MAX_OUTPUT_SIZE = 100 * 1024;
 var DANGEROUS_PATTERNS = [
@@ -10163,7 +9906,7 @@ async function executeBashCommand(params) {
     };
   }
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path12.resolve(baseCwd, relativeCwd) : baseCwd;
+  const targetCwd = relativeCwd ? path11.resolve(baseCwd, relativeCwd) : baseCwd;
   const effectiveTimeout = Math.min(timeout, 5 * 60 * 1e3);
   return new Promise((resolve3) => {
     let stdout = "";
@@ -10353,9 +10096,9 @@ BLOCKED OPERATIONS:
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editLocalFile/index.js
-import { promises as fs11 } from "fs";
+import { promises as fs10 } from "fs";
 import { existsSync as existsSync6 } from "fs";
-import path13 from "path";
+import path12 from "path";
 import { diffLines as diffLines3 } from "diff";
 function generateDiff(original, modified) {
   const differences = diffLines3(original, modified);
@@ -10379,16 +10122,16 @@ function generateDiff(original, modified) {
 }
 async function editLocalFile(params) {
   const { path: filePath, old_string, new_string } = params;
-  const normalizedPath = path13.normalize(filePath);
-  const resolvedPath = path13.resolve(process.cwd(), normalizedPath);
-  const cwd = path13.resolve(process.cwd());
+  const normalizedPath = path12.normalize(filePath);
+  const resolvedPath = path12.resolve(process.cwd(), normalizedPath);
+  const cwd = path12.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot edit files outside of current working directory`);
   }
   if (!existsSync6(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const currentContent = await fs11.readFile(resolvedPath, "utf-8");
+  const currentContent = await fs10.readFile(resolvedPath, "utf-8");
   if (!currentContent.includes(old_string)) {
     const preview = old_string.length > 100 ? old_string.substring(0, 100) + "..." : old_string;
     throw new Error(`String to replace not found in file. Make sure the old_string matches exactly (including whitespace and line endings). Searched for: "${preview}"`);
@@ -10398,7 +10141,7 @@ async function editLocalFile(params) {
     throw new Error(`Found ${occurrences} occurrences of the string to replace. Please provide a more specific old_string that matches exactly one location.`);
   }
   const newContent = currentContent.replace(old_string, new_string);
-  await fs11.writeFile(resolvedPath, newContent, "utf-8");
+  await fs10.writeFile(resolvedPath, newContent, "utf-8");
   const diffResult = generateDiff(old_string, new_string);
   return `File edited successfully: ${filePath}
 Changes: +${diffResult.additions} lines, -${diffResult.deletions} lines
@@ -11618,7 +11361,7 @@ async function generateFileDeletePreview(args) {
     if (!existsSync7(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs14) => fs14.stat(args.path));
+    const stats = await import("fs/promises").then((fs13) => fs13.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -11909,21 +11652,21 @@ var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path18) {
+  async download(path17) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path18) {
+  async delete(path17) {
   }
-  async getSignedUrl(path18) {
-    return `/tmp/${path18}`;
+  async getSignedUrl(path17) {
+    return `/tmp/${path17}`;
   }
-  getPublicUrl(path18) {
-    return `/tmp/${path18}`;
+  getPublicUrl(path17) {
+    return `/tmp/${path17}`;
   }
-  async getPreview(path18) {
-    return `/tmp/${path18}`;
+  async getPreview(path17) {
+    return `/tmp/${path17}`;
   }
-  async getMetadata(path18) {
+  async getMetadata(path17) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -12329,8 +12072,8 @@ function getEnvironmentName(configApiConfig) {
 }
 
 // src/utils/contextLoader.ts
-import * as fs12 from "fs";
-import * as path14 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 import { homedir as homedir3 } from "os";
 var CONTEXT_FILE_SIZE_LIMIT = 100 * 1024;
 var PROJECT_CONTEXT_FILES = [
@@ -12351,9 +12094,9 @@ function formatFileSize2(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 function tryReadContextFile(dir, filename, source) {
-  const filePath = path14.join(dir, filename);
+  const filePath = path13.join(dir, filename);
   try {
-    const stats = fs12.lstatSync(filePath);
+    const stats = fs11.lstatSync(filePath);
     if (stats.isDirectory()) {
       return null;
     }
@@ -12367,7 +12110,7 @@ function tryReadContextFile(dir, filename, source) {
         error: `${source === "global" ? "Global" : "Project"} ${filename} exceeds 100KB limit (${formatFileSize2(stats.size)})`
       };
     }
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs11.readFileSync(filePath, "utf-8");
     return {
       filename,
       content,
@@ -12419,7 +12162,7 @@ ${project.content}`;
 }
 async function loadContextFiles(projectDir) {
   const errors = [];
-  const globalDir = path14.join(homedir3(), ".bike4mind");
+  const globalDir = path13.join(homedir3(), ".bike4mind");
   const projectDirectory = projectDir || process.cwd();
   const [globalResult, projectResult] = await Promise.all([
     Promise.resolve(findContextFile(globalDir, GLOBAL_CONTEXT_FILES, "global")),
@@ -12690,7 +12433,7 @@ function substituteArguments(template, args) {
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path15 from "path";
+import path14 from "path";
 import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
@@ -12728,21 +12471,20 @@ var MCPClient = class {
       if (this.customCommand && this.customCommand.trim() !== "") {
         command = this.customCommand;
         args = this.customArgs ?? [];
-        console.log(`[MCP] Using external command for ${this.serverName}: ${command} ${args.join(" ")}`);
       } else {
         const root = process.env.INIT_CWD || process.cwd();
         const candidatePaths = [
           // When running from SST Lambda with node_modules structure (copyFiles)
-          path15.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+          path14.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda deployed environment (/var/task)
-          path15.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path14.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)
-          path15.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path14.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)
-          path15.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path14.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // Original paths (backward compatibility)
-          path15.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-          path15.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+          path14.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path14.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
         ];
         const serverScriptPath = candidatePaths.find((p) => existsSync8(p));
         if (!serverScriptPath) {
@@ -13557,7 +13299,7 @@ var ServerLlmBackend = class {
         logger.info("\u26A0\uFE0F  Using fallback model list (no CLI-compatible models available)");
         return this.getFallbackModels();
       }
-      logger.info(`\u{1F4CB} Loaded ${filteredModels.length} models from server`);
+      logger.debug(`\u{1F4CB} Loaded ${filteredModels.length} models from server`);
       return filteredModels;
     } catch (error) {
       logger.warn(
@@ -13795,7 +13537,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.29-cli-minimal-ui.18782+8a5b862a2",
+  version: "0.2.29-cli-minimal-ui.18783+9aba9e61e",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -13903,10 +13645,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.50.1-cli-minimal-ui.18782+8a5b862a2",
-    "@bike4mind/mcp": "1.29.1-cli-minimal-ui.18782+8a5b862a2",
-    "@bike4mind/services": "2.48.1-cli-minimal-ui.18782+8a5b862a2",
-    "@bike4mind/utils": "2.5.1-cli-minimal-ui.18782+8a5b862a2",
+    "@bike4mind/common": "2.50.1-cli-minimal-ui.18783+9aba9e61e",
+    "@bike4mind/mcp": "1.29.1-cli-minimal-ui.18783+9aba9e61e",
+    "@bike4mind/services": "2.48.1-cli-minimal-ui.18783+9aba9e61e",
+    "@bike4mind/utils": "2.5.1-cli-minimal-ui.18783+9aba9e61e",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -13923,7 +13665,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "8a5b862a2b827a45357ec4e200de8bb50bfc7fb3"
+  gitHead: "9aba9e61e1fb7e03dfd87a2e777c8e0e4e16fbbd"
 };
 
 // src/config/constants.ts
@@ -14416,9 +14158,9 @@ var SubagentOrchestrator = class {
 };
 
 // src/agents/AgentStore.ts
-import fs13 from "fs/promises";
-import path16 from "path";
-import os3 from "os";
+import fs12 from "fs/promises";
+import path15 from "path";
+import os2 from "os";
 import matter2 from "gray-matter";
 var FULL_MODEL_ID_PREFIXES = [
   "claude-",
@@ -14564,12 +14306,12 @@ var AgentStore = class {
   constructor(builtinDir, projectRoot) {
     this.agents = /* @__PURE__ */ new Map();
     const root = projectRoot || process.cwd();
-    const home = os3.homedir();
+    const home = os2.homedir();
     this.builtinAgentsDir = builtinDir;
-    this.globalB4MAgentsDir = path16.join(home, ".bike4mind", "agents");
-    this.globalClaudeAgentsDir = path16.join(home, ".claude", "agents");
-    this.projectB4MAgentsDir = path16.join(root, ".bike4mind", "agents");
-    this.projectClaudeAgentsDir = path16.join(root, ".claude", "agents");
+    this.globalB4MAgentsDir = path15.join(home, ".bike4mind", "agents");
+    this.globalClaudeAgentsDir = path15.join(home, ".claude", "agents");
+    this.projectB4MAgentsDir = path15.join(root, ".bike4mind", "agents");
+    this.projectClaudeAgentsDir = path15.join(root, ".claude", "agents");
   }
   /**
    * Load all agents from all directories
@@ -14593,7 +14335,7 @@ var AgentStore = class {
    */
   async loadAgentsFromDirectory(directory, source) {
     try {
-      const stats = await fs13.stat(directory);
+      const stats = await fs12.stat(directory);
       if (!stats.isDirectory()) {
         return;
       }
@@ -14621,9 +14363,9 @@ var AgentStore = class {
   async findAgentFiles(directory) {
     const files = [];
     try {
-      const entries = await fs13.readdir(directory, { withFileTypes: true });
+      const entries = await fs12.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path16.join(directory, entry.name);
+        const fullPath = path15.join(directory, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.findAgentFiles(fullPath);
           files.push(...subFiles);
@@ -14640,10 +14382,10 @@ var AgentStore = class {
    * Parse a single agent markdown file
    */
   async parseAgentFile(filePath, source) {
-    const content = await fs13.readFile(filePath, "utf-8");
+    const content = await fs12.readFile(filePath, "utf-8");
     const { data: frontmatter, content: body } = matter2(content);
     const parsed = AgentFrontmatterSchema.parse(frontmatter);
-    const name = path16.basename(filePath, ".md");
+    const name = path15.basename(filePath, ".md");
     const modelInput = parsed.model || DEFAULT_AGENT_MODEL;
     const resolution = resolveModelAlias(modelInput, name, filePath);
     if (!resolution.resolved && resolution.warning) {
@@ -14723,16 +14465,16 @@ var AgentStore = class {
    */
   async createAgentFile(name, isGlobal = false, useClaude = true) {
     const targetDir = isGlobal ? useClaude ? this.globalClaudeAgentsDir : this.globalB4MAgentsDir : useClaude ? this.projectClaudeAgentsDir : this.projectB4MAgentsDir;
-    const filePath = path16.join(targetDir, `${name}.md`);
+    const filePath = path15.join(targetDir, `${name}.md`);
     try {
-      await fs13.access(filePath);
+      await fs12.access(filePath);
       throw new Error(`Agent file already exists: ${filePath}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
     }
-    await fs13.mkdir(targetDir, { recursive: true });
+    await fs12.mkdir(targetDir, { recursive: true });
     const template = `---
 description: ${name} agent description
 model: claude-3-5-haiku-20241022
@@ -14767,7 +14509,7 @@ You are a ${name} specialist. Your job is to [describe primary task].
 ## Output Format
 Describe the expected output format here.
 `;
-    await fs13.writeFile(filePath, template, "utf-8");
+    await fs12.writeFile(filePath, template, "utf-8");
     return filePath;
   }
   /**
@@ -15405,7 +15147,7 @@ function createTodoStore(onUpdate) {
 
 // src/tools/findDefinitionTool.ts
 import { stat as stat3 } from "fs/promises";
-import path17 from "path";
+import path16 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { createRequire as createRequire2 } from "module";
@@ -15426,8 +15168,8 @@ var ALL_KEYWORDS = Object.values(KIND_KEYWORDS).flat();
 function getRipgrepPath2() {
   try {
     const ripgrepPath = require3.resolve("@vscode/ripgrep");
-    const ripgrepDir = path17.dirname(ripgrepPath);
-    return path17.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    const ripgrepDir = path16.dirname(ripgrepPath);
+    return path16.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
   } catch {
     throw new Error(
       "ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services"
@@ -15435,10 +15177,10 @@ function getRipgrepPath2() {
   }
 }
 function isPathWithinWorkspace2(targetPath, baseCwd) {
-  const resolvedTarget = path17.resolve(targetPath);
-  const resolvedBase = path17.resolve(baseCwd);
-  const relativePath = path17.relative(resolvedBase, resolvedTarget);
-  return !relativePath.startsWith("..") && !path17.isAbsolute(relativePath);
+  const resolvedTarget = path16.resolve(targetPath);
+  const resolvedBase = path16.resolve(baseCwd);
+  const relativePath = path16.relative(resolvedBase, resolvedTarget);
+  return !relativePath.startsWith("..") && !path16.isAbsolute(relativePath);
 }
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -15471,7 +15213,7 @@ async function findDefinitions(params) {
     throw new Error("symbol_name is required");
   }
   const baseCwd = process.cwd();
-  const targetDir = search_path ? path17.resolve(baseCwd, search_path) : baseCwd;
+  const targetDir = search_path ? path16.resolve(baseCwd, search_path) : baseCwd;
   if (!isPathWithinWorkspace2(targetDir, baseCwd)) {
     throw new Error(`Path validation failed: "${search_path}" resolves outside the allowed workspace directory`);
   }
@@ -15526,7 +15268,7 @@ async function findDefinitions(params) {
         const lineText = match.data.lines.text.trimEnd();
         if (isLikelyDefinition(lineText)) {
           allMatches.push({
-            filePath: path17.relative(targetDir, match.data.path.text) || path17.basename(match.data.path.text),
+            filePath: path16.relative(targetDir, match.data.path.text) || path16.basename(match.data.path.text),
             lineNumber: match.data.line_number,
             line: lineText
           });
@@ -15719,6 +15461,7 @@ function CliApp() {
   });
   const init = useCallback2(async () => {
     try {
+      const startupLog = [];
       const config = await state.configStore.load();
       const history = await state.commandHistoryStore.load();
       setCommandHistory(history);
@@ -15726,7 +15469,7 @@ function CliApp() {
         await state.customCommandStore.loadCommands();
         const customCommandCount = state.customCommandStore.getCommandCount();
         if (customCommandCount > 0) {
-          console.log(`\u{1F4DD} Loaded ${customCommandCount} custom command${customCommandCount !== 1 ? "s" : ""}`);
+          startupLog.push(`\u{1F4DD} Loaded ${customCommandCount} custom command${customCommandCount !== 1 ? "s" : ""}`);
         }
       } catch (error) {
         console.warn("Failed to load custom commands:", error instanceof Error ? error.message : String(error));
@@ -15747,7 +15490,7 @@ function CliApp() {
         } else {
           isAuthenticated = true;
           const daysUntilExpiry = Math.floor((expiresAt.getTime() - Date.now()) / (1e3 * 60 * 60 * 24));
-          console.log(`\u2705 Authenticated (expires in ${daysUntilExpiry} day${daysUntilExpiry !== 1 ? "s" : ""})`);
+          startupLog.push(`\u2705 Authenticated (expires in ${daysUntilExpiry} day${daysUntilExpiry !== 1 ? "s" : ""})`);
         }
       }
       if (!isAuthenticated) {
@@ -15861,23 +15604,23 @@ function CliApp() {
         state.configStore,
         apiClient
       );
-      console.log(`\u{1F6E0}\uFE0F Loaded ${b4mTools2.length} B4M tool(s)`);
+      startupLog.push(`\u{1F6E0}\uFE0F Loaded ${b4mTools2.length} B4M tool(s)`);
       const mcpManager = new McpManager(config);
       await mcpManager.initialize();
       const mcpTools = mcpManager.getTools();
       if (mcpTools.length > 0) {
         const toolCountByServer = mcpManager.getToolCount();
         const serverSummaries = toolCountByServer.map((s) => `${s.serverName} (${s.count})`).join(", ");
-        console.log(`\u{1F4E1} Loaded ${mcpTools.length} MCP tool(s): ${serverSummaries}`);
+        startupLog.push(`\u{1F4E1} Loaded ${mcpTools.length} MCP tool(s): ${serverSummaries}`);
       } else {
-        console.log(`\u{1F4E1} No MCP tools loaded`);
+        startupLog.push(`\u{1F4E1} No MCP tools loaded`);
       }
       const builtinAgentsDir = new URL("./agents/defaults/", import.meta.url).pathname;
       const agentProjectDir = state.configStore.getProjectConfigDir();
       const agentStore = new AgentStore(builtinAgentsDir, agentProjectDir || process.cwd());
       await agentStore.loadAgents();
       const agentSummary = agentStore.getSummary();
-      console.log(
+      startupLog.push(
         `\u{1F916} Loaded ${agentSummary.total} agent(s): ${agentSummary.builtin} built-in, ${agentSummary.global} global, ${agentSummary.project} project`
       );
       const orchestrator = new SubagentOrchestrator({
@@ -15917,13 +15660,13 @@ function CliApp() {
         cliTools.push(skillTool);
       }
       const allTools = [...b4mTools2, ...mcpTools, ...cliTools];
-      console.log(`\u{1F4C2} Working directory: ${process.cwd()}`);
+      startupLog.push(`\u{1F4C2} Working directory: ${process.cwd()}`);
       const agentNamesList = agentStore.getAgentNames().join(", ");
-      console.log(`\u{1F916} Subagent delegation enabled (${agentNamesList}) + background execution`);
+      startupLog.push(`\u{1F916} Subagent delegation enabled (${agentNamesList}) + background execution`);
       if (skillTool) {
         const skillCount = state.customCommandStore.getCommandCount();
         if (skillCount > 0) {
-          console.log(`\u{1F6E0}\uFE0F  Skill tool enabled (${skillCount} skills available)`);
+          startupLog.push(`\u{1F6E0}\uFE0F  Skill tool enabled (${skillCount} skills available)`);
         }
       }
       logger.debug(
@@ -15932,13 +15675,13 @@ function CliApp() {
       const projectDir = state.configStore.getProjectConfigDir();
       const contextResult = await loadContextFiles(projectDir);
       if (contextResult.globalContext) {
-        console.log(`\u{1F4C4} Global context: ${contextResult.globalContext.filename}`);
+        startupLog.push(`\u{1F4C4} Global context: ${contextResult.globalContext.filename}`);
       }
       if (contextResult.projectContext) {
-        console.log(`\u{1F4C4} Project context: ${contextResult.projectContext.filename}`);
+        startupLog.push(`\u{1F4C4} Project context: ${contextResult.projectContext.filename}`);
       }
       for (const error of contextResult.errors) {
-        console.log(`\u26A0\uFE0F  Context file error: ${error}`);
+        startupLog.push(`\u26A0\uFE0F  Context file error: ${error}`);
       }
       let contextSection = contextResult.mergedContent ? `
 
@@ -16014,8 +15757,36 @@ ${contextResult.mergedContent}` : "";
         // Store for grouped notification turn tracking
       }));
       setStoreSession(newSession);
+      const bannerLines = [
+        { text: "\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D     \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551", ansi: "\x1B[36m\x1B[1m" },
+        { text: "\u255A\u2550\u2550\u2550\u2550\u2550\u255D      \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D", ansi: "\x1B[36m\x1B[1m" },
+        { text: "", ansi: "" },
+        { text: `v${package_default.version} - AI-Powered CLI`, ansi: "\x1B[2m" },
+        { text: "/help for more information", ansi: "\x1B[2m" }
+      ];
+      const bannerWidth = 30;
+      const termWidth = process.stdout.columns || 80;
+      const rightColWidth = termWidth - bannerWidth - 2;
+      const truncate = (str, max) => {
+        if (str.length > max) return str.slice(0, max - 1) + "\u2026";
+        return str;
+      };
+      const totalLines = Math.max(bannerLines.length, startupLog.length);
+      for (let i = 0; i < totalLines; i++) {
+        const banner = bannerLines[i];
+        const leftText = banner?.text || "";
+        const leftAnsi = banner?.ansi || "";
+        const right = startupLog[i] || "";
+        const coloredLeft = leftText ? `${leftAnsi}${leftText}\x1B[0m` : "";
+        const gap = " ".repeat(bannerWidth - leftText.length + 2);
+        console.log(coloredLeft + gap + truncate(right, rightColWidth));
+      }
       setIsInitialized(true);
-      console.log("\n");
+      console.log("");
     } catch (error) {
       console.error("Initialization error:", error);
       setInitError(error instanceof Error ? error.message : "Unknown error");
@@ -17598,17 +17369,6 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     }
   );
 }
-var BANNER = `
-\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557
-\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551
-\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551
-\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551
-\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D     \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u255D      \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D
-`;
-console.log("\x1B[36m\x1B[1m%s\x1B[0m", BANNER);
-console.log(`\x1B[2m  v${package_default.version} - AI-Powered CLI\x1B[0m`);
-console.log("  /help for more information\n");
 var isDevMode = import.meta.url.includes("/src/") || process.env.NODE_ENV === "development";
 if (isDevMode) {
   logger.debug("\u{1F527} Running in development mode (using TypeScript source)\n");