@bike4mind/cli 0.2.11 → 0.2.12-cli-todo-list.17408

package/dist/index.js

@@ -4,9 +4,9 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-ZHCX7BLB.js";
-import "./chunk-ID4NS6KF.js";
-import "./chunk-RJFNIMVH.js";
+} from "./chunk-XM52K32A.js";
+import "./chunk-JXROCVSM.js";
+import "./chunk-7N7AZPLK.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -15,10 +15,10 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-BU5TP3BH.js";
+} from "./chunk-INYINU6X.js";
 import {
   Logger
-} from "./chunk-AMDXHL6S.js";
+} from "./chunk-OCYRD7D6.js";
 import "./chunk-BPFEGDC7.js";
 import {
   AiEvents,
@@ -74,9 +74,6 @@ import {
   b4mLLMTools,
   getMcpProviderMetadata
 } from "./chunk-OHR7UCTC.js";
-import {
-  __require
-} from "./chunk-PDX44BCA.js";
 
 // src/index.tsx
 import React17, { useState as useState8, useEffect as useEffect3, useCallback, useRef as useRef2 } from "react";
@@ -182,11 +179,11 @@ function CustomTextInput({
         setCursorOffset(Math.min(value.length, cursorOffset + 1));
         return;
       }
-      if (!key.ctrl && !key.meta && input.length === 1) {
+      if (!key.ctrl && !key.meta && input.length > 0) {
         const sanitizedInput = input === "\r" ? "\n" : input;
         const newValue = value.slice(0, cursorOffset) + sanitizedInput + value.slice(cursorOffset);
         onChange(newValue);
-        setCursorOffset(cursorOffset + 1);
+        setCursorOffset(cursorOffset + sanitizedInput.length);
       }
     },
     { isActive: !disabled }
@@ -713,7 +710,7 @@ var ImageInputDetector = class {
     if (!this.looksLikeFilePath(input)) return null;
     let filepath = input.trim();
     filepath = filepath.replace(/^["']|["']$/g, "");
-    filepath = filepath.replace(/\\\s/g, " ");
+    filepath = filepath.replace(/\\(.)/g, "$1");
     if (!existsSync(filepath)) return null;
     const stats = statSync2(filepath);
     if (!stats.isFile()) return null;
@@ -740,7 +737,15 @@ var ImageInputDetector = class {
    */
   static looksLikeFilePath(input) {
     const trimmed = input.trim();
-    if (trimmed.startsWith("/") || trimmed.match(/^[a-zA-Z]:\\/)) {
+    if (trimmed.startsWith("/")) {
+      const hasMultipleSegments = trimmed.indexOf("/", 1) !== -1;
+      const hasImageExtension = this.SUPPORTED_EXTENSIONS.some((ext) => trimmed.toLowerCase().endsWith(ext));
+      if (hasMultipleSegments || hasImageExtension) {
+        return true;
+      }
+      return false;
+    }
+    if (trimmed.match(/^[a-zA-Z]:\\/)) {
       return true;
     }
     if (trimmed.startsWith("~")) {
@@ -769,6 +774,16 @@ var ImageInputDetector = class {
 };
 
 // src/components/InputPrompt.tsx
+function looksLikeFilePath(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("/")) {
+    const hasMultipleSegments = trimmed.indexOf("/", 1) !== -1;
+    if (hasMultipleSegments) return true;
+  }
+  if (trimmed.startsWith("~")) return true;
+  if (trimmed.match(/^[a-zA-Z]:\\/)) return true;
+  return false;
+}
 function findAtTrigger(value) {
   for (let i = value.length - 1; i >= 0; i--) {
     if (value[i] === "@") {
@@ -812,7 +827,7 @@ function InputPrompt({
   useEffect(() => {
     onBashModeChange?.(isBashMode);
   }, [isBashMode, onBashModeChange]);
-  const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active;
+  const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active && !looksLikeFilePath(value);
   const commandQuery = shouldShowCommandAutocomplete ? value.slice(1) : "";
   const filteredCommands = useMemo(() => {
     if (!shouldShowCommandAutocomplete) return [];
@@ -1358,7 +1373,7 @@ function isNameSuffix(value) {
 
 // src/utils/processFileReferences.ts
 var FILE_REFERENCE_REGEX = /(?:^|\s)@([^\s@]+)/g;
-function looksLikeFilePath(ref) {
+function looksLikeFilePath2(ref) {
   if (ref.includes("/") || ref.includes(path2.sep)) {
     return true;
   }
@@ -1381,7 +1396,7 @@ function extractFileReferences(message) {
   let match;
   while ((match = FILE_REFERENCE_REGEX.exec(message)) !== null) {
     const ref = match[1];
-    if (looksLikeFilePath(ref)) {
+    if (looksLikeFilePath2(ref)) {
       references.push(ref);
     }
   }
@@ -3093,6 +3108,21 @@ ${options.context}` : this.getSystemPrompt()
       let finalAnswer = "";
       let reachedMaxIterations = false;
       while (iterations < maxIterations) {
+        if (options.signal?.aborted) {
+          this.context.logger.info("[ReActAgent] Operation aborted by user");
+          const result2 = {
+            finalAnswer: "Interrupted",
+            steps: this.steps,
+            completionInfo: {
+              totalTokens: this.totalTokens,
+              iterations,
+              toolCalls: this.toolCallCount,
+              reachedMaxIterations: false
+            }
+          };
+          this.emit("complete", result2);
+          return result2;
+        }
         iterations++;
         this.context.logger.debug(`[ReActAgent] Starting iteration ${iterations}/${maxIterations}`);
         let iterationComplete = false;
@@ -3106,7 +3136,8 @@ ${options.context}` : this.getSystemPrompt()
             stream: false,
             tools: this.context.tools,
             maxTokens,
-            temperature
+            temperature,
+            abortSignal: options.signal
           },
           async (texts, completionInfo) => {
             for (const text of texts) {
@@ -3249,6 +3280,9 @@ ${options.context}` : this.getSystemPrompt()
           this.emit("final_answer", finalStep);
         }
       }
+      if (options.signal?.aborted && !finalAnswer) {
+        finalAnswer = "Interrupted";
+      }
       const result = {
         finalAnswer,
         steps: this.steps,
@@ -3356,6 +3390,70 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
   }
 };
 
+// src/core/prompts.ts
+var TOOL_GREP_SEARCH = "grep_search";
+var TOOL_GLOB_FILES = "glob_files";
+var TOOL_FILE_READ = "file_read";
+var TOOL_EDIT_LOCAL_FILE = "edit_local_file";
+var TOOL_CREATE_FILE = "create_file";
+var TOOL_BASH_EXECUTE = "bash_execute";
+var TOOL_SUBAGENT_DELEGATE = "subagent_delegate";
+var TOOL_WRITE_TODOS = "write_todos";
+var EXPLORE_SUBAGENT_TYPE = "explore";
+function buildCoreSystemPrompt(contextSection = "") {
+  return `You are an autonomous AI assistant with access to tools. Your job is to help users by taking action and solving problems proactively.
+
+CORE BEHAVIOR:
+- Be proactive: Take action instead of asking for permission or clarification
+- Make smart assumptions: If unclear, choose the most reasonable interpretation
+- Use conversation history: Reference previous exchanges to understand context
+- Complete tasks fully: Don't just show what to do - actually do it
+
+FOR SOFTWARE ENGINEERING TASKS:
+When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this sequence:
+1. **Understand:** Think about the user's request and the relevant codebase context. Use '${TOOL_GREP_SEARCH}' and '${TOOL_GLOB_FILES}' search tools extensively (in parallel if independent) to understand file structures, existing code patterns, and conventions. Use '${TOOL_FILE_READ}' to understand context and validate any assumptions you may have. If you need to read multiple files, you should make multiple parallel calls to '${TOOL_FILE_READ}'.
+                   When the task involves **complex refactoring, codebase exploration or system-wide analysis**, your **first and primary action** must be to delegate to the '${EXPLORE_SUBAGENT_TYPE}' agent using the '${TOOL_SUBAGENT_DELEGATE}' tool. Use it to build a comprehensive understanding of the code, its structure, and dependencies. For **simple, targeted searches** (like finding a specific function name, file path, or variable declaration), you should use '${TOOL_GREP_SEARCH}' or '${TOOL_GLOB_FILES}' directly.
+2. **Plan:** Build a coherent and grounded (based on the understanding in step 1) plan for how you intend to resolve the user's task. Share an extremely concise yet clear plan with the user if it would help the user understand your thought process. As part of the plan, you should use an iterative development process that includes writing unit tests to verify your changes. Use output logs or debug statements as part of this process to arrive at a solution.
+  If '${EXPLORE_SUBAGENT_TYPE}' subagent was used, do not ignore the output of the agent, you must use it as the foundation of your plan. For complex tasks, break them down into smaller, manageable subtasks and use the \`${TOOL_WRITE_TODOS}\` tool to track your progress. Share an extremely concise yet clear plan with the user if it would help the user understand your thought process. As part of the plan, you should use an iterative development process that includes writing unit tests to verify your changes. Use output logs or debug statements as part of this process to arrive at a solution.
+3. **Implement:** Use the available tools (e.g., '${TOOL_EDIT_LOCAL_FILE}', '${TOOL_CREATE_FILE}', '${TOOL_BASH_EXECUTE}' ...) to act on the plan, strictly adhering to the project's established conventions.
+4. **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining 'README' files, build/package configuration (e.g., 'package.json'), or existing test execution patterns. NEVER assume standard test commands. When executing test commands, prefer "run once" or "CI" modes to ensure the command terminates after completion.
+5. **Verify (Standards):** VERY IMPORTANT: After making code changes, execute the project-specific build, linting and type-checking commands (e.g., 'tsc', 'npm run lint', 'ruff check .') that you have identified for this project (or obtained from the user). This ensures code quality and adherence to standards.
+6. **Finalize:** After all verification passes, consider the task complete. Do not remove or revert any changes or created files (like tests). Await the user's next instruction.
+
+SUBAGENT DELEGATION:
+- You have access to specialized subagents via the ${TOOL_SUBAGENT_DELEGATE} tool
+- Use subagents for focused exploration, planning, or review tasks:
+  * explore: Fast read-only codebase search (e.g., "find all auth files", "locate API endpoints")
+  * plan: Break down complex tasks into actionable steps
+  * review: Analyze code quality and identify issues
+- Subagents keep the main conversation clean and run faster with optimized models
+- Delegate when you need to search extensively or analyze code structure
+
+FOR GENERAL TASKS:
+- Use available tools to get information (weather, web search, calculations, etc.)
+- When user asks follow-up questions, use conversation context to understand what they're referring to
+- If user asks "how about X?" after a previous question, apply the same question type to X
+
+## Shell tool output token efficiency:
+IT IS CRITICAL TO FOLLOW THESE GUIDELINES TO AVOID EXCESSIVE TOKEN CONSUMPTION.
+
+- Always prefer command flags that reduce output verbosity when using '${TOOL_BASH_EXECUTE}'.
+- Aim to minimize tool output tokens while still capturing necessary information.
+- If a command is expected to produce a lot of output, use quiet or silent flags where available and appropriate.
+- Always consider the trade-off between output verbosity and the need for information. If a command's full output is essential for understanding the result, avoid overly aggressive quieting that might obscure important details.
+- If a command does not have quiet/silent flags or for commands with potentially long output that may not be useful, redirect stdout and stderr to temp files in the project's temporary directory. For example: 'command > <temp_dir>/out.log 2> <temp_dir>/err.log'.
+- After the command runs, inspect the temp files (e.g. '<temp_dir>/out.log' and '<temp_dir>/err.log') using commands like 'grep', 'tail', 'head', ... (or platform equivalents). Remove the temp files when done.
+
+EXAMPLES:
+- "what should I wear in Texas?" \u2192 use weather tool for Texas
+- "how about Japan?" \u2192 use weather tool for Japan (applying same question from context)
+- "enhance README" \u2192 ${TOOL_FILE_READ} \u2192 generate \u2192 ${TOOL_EDIT_LOCAL_FILE}
+- "what packages installed?" \u2192 ${TOOL_GLOB_FILES} "**/package.json" \u2192 ${TOOL_FILE_READ}
+- "find all components using React hooks" \u2192 ${TOOL_SUBAGENT_DELEGATE}(task="find all components using React hooks", type="explore")
+
+Remember: Use context from previous messages to understand follow-up questions.${contextSection}`;
+}
+
 // ../../b4m-core/packages/services/dist/src/referService/generateCodes.js
 import { randomBytes } from "crypto";
 import range from "lodash/range.js";
@@ -8707,98 +8805,80 @@ var createFileTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
-import { readdir } from "fs/promises";
-import { statSync as statSync5 } from "fs";
+import { glob } from "glob";
+import { stat } from "fs/promises";
 import path9 from "path";
-function matchGlob(filePath, pattern) {
-  let regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
-  regexPattern = regexPattern.replace(/\{\{GLOBSTAR\}\}\//g, "(.*/)?").replace(/\/\{\{GLOBSTAR\}\}/g, "(/.*)?").replace(/\{\{GLOBSTAR\}\}/g, ".*");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(filePath);
-}
-async function walkDir(dir, pattern, includeHidden, maxResults, basePath = "") {
-  const matches = [];
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (matches.length >= maxResults) {
-        break;
-      }
-      if (!includeHidden && entry.name.startsWith(".")) {
-        continue;
-      }
-      const relativePath = basePath ? path9.join(basePath, entry.name) : entry.name;
-      const fullPath = path9.join(dir, entry.name);
-      if (matchGlob(relativePath, pattern)) {
-        matches.push(relativePath);
-      }
-      if (entry.isDirectory() && (pattern.includes("**") || pattern.includes("/"))) {
-        const subMatches = await walkDir(fullPath, pattern, includeHidden, maxResults - matches.length, relativePath);
-        matches.push(...subMatches);
-      }
-    }
-  } catch (error) {
-  }
-  return matches;
-}
-async function listFiles(params) {
-  const { pattern, cwd: relativeCwd, includeHidden = false, maxResults = 1e3 } = params;
+var DEFAULT_IGNORE_PATTERNS2 = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/.turbo/**",
+  "**/.sst/**",
+  "**/*.min.js",
+  "**/*.min.css"
+];
+async function findFiles(params) {
+  const { pattern, dir_path, case_sensitive = true, respect_git_ignore = true } = params;
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path9.resolve(baseCwd, path9.normalize(relativeCwd)) : baseCwd;
-  if (!targetCwd.startsWith(baseCwd)) {
-    throw new Error(`Access denied: Cannot list files outside of current working directory`);
-  }
-  const matches = await walkDir(targetCwd, pattern, includeHidden, maxResults);
+  const targetDir = dir_path ? path9.resolve(baseCwd, path9.normalize(dir_path)) : baseCwd;
+  if (!targetDir.startsWith(baseCwd)) {
+    throw new Error(`Access denied: Cannot search outside of current working directory`);
+  }
+  const ignorePatterns = respect_git_ignore ? DEFAULT_IGNORE_PATTERNS2 : [];
+  const matches = await glob(pattern, {
+    cwd: targetDir,
+    dot: false,
+    // Don't match hidden files by default
+    ignore: ignorePatterns,
+    absolute: true,
+    nodir: true,
+    // Only return files, not directories
+    nocase: !case_sensitive,
+    // Case-insensitive if requested
+    maxDepth: 20
+    // Reasonable depth limit
+  });
   if (matches.length === 0) {
-    return `No files found matching pattern: ${pattern}`;
+    return `No files found matching pattern: ${pattern}${dir_path ? ` in ${dir_path}` : ""}`;
   }
-  const filesInfo = [];
-  for (const match of matches) {
+  const filesWithStats = [];
+  for (const filePath of matches) {
     try {
-      const fullPath = path9.join(targetCwd, match);
-      const stats = statSync5(fullPath);
-      filesInfo.push({
-        path: match,
-        size: stats.size,
-        isDirectory: stats.isDirectory(),
-        modified: stats.mtime.toISOString()
+      const stats = await stat(filePath);
+      filesWithStats.push({
+        path: filePath,
+        mtime: stats.mtimeMs
       });
-    } catch (error) {
+    } catch {
       continue;
     }
   }
-  const truncated = matches.length >= maxResults;
-  const summary = `Found ${filesInfo.length} file(s)${truncated ? ` (truncated to ${maxResults})` : ""} matching: ${pattern}
-`;
-  const cwdInfo = relativeCwd ? `Directory: ${relativeCwd}
-` : "";
-  const filesList = filesInfo.map((file) => {
-    const typeIcon = file.isDirectory ? "\u{1F4C1}" : "\u{1F4C4}";
-    const sizeStr = file.isDirectory ? "" : ` (${formatBytes(file.size)})`;
-    return `${typeIcon} ${file.path}${sizeStr}`;
-  }).join("\n");
-  return `${summary}${cwdInfo}
+  filesWithStats.sort((a, b) => b.mtime - a.mtime);
+  const MAX_RESULTS = 500;
+  const truncated = filesWithStats.length > MAX_RESULTS;
+  const results = truncated ? filesWithStats.slice(0, MAX_RESULTS) : filesWithStats;
+  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");
+  return `${summary}${dirInfo}
+
 ${filesList}`;
 }
-function 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 `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
-}
 var globFilesTool = {
   name: "glob_files",
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      context.logger.info("\u{1F50D} GlobFiles: Listing files", {
+      context.logger.info("\u{1F50D} GlobFiles: Finding files", {
         pattern: params.pattern,
-        cwd: params.cwd || "."
+        dir_path: params.dir_path || "."
       });
       try {
-        const result = await listFiles(params);
+        const result = await findFiles(params);
         context.logger.info("\u2705 GlobFiles: Success");
         return result;
       } catch (error) {
@@ -8808,25 +8888,25 @@ var globFilesTool = {
     },
     toolSchema: {
       name: "glob_files",
-      description: "List files and directories matching a glob pattern. Supports wildcards like *, **, ?, and character ranges. Restricted to current working directory for security.",
+      description: "Efficiently finds files matching specific glob patterns (e.g., `src/**/*.ts`, `**/*.md`), returning absolute paths sorted by modification time (newest first). Use this to locate files by name or extension when you need to discover or explore files in a project.",
       parameters: {
         type: "object",
         properties: {
           pattern: {
             type: "string",
-            description: 'Glob pattern to match files (e.g., "*.ts", "src/**/*.tsx", "test/*.{js,ts}"). Use ** for recursive directory search.'
+            description: 'The glob pattern to match against file paths. Supports wildcards (*, **), character ranges ([abc]), and brace expansion ({ts,tsx}). Examples: "*.ts" for TypeScript files in current dir, "src/**/*.tsx" for all TSX files in src tree, "**/*.{js,ts}" for all JS/TS files.'
           },
-          cwd: {
+          dir_path: {
             type: "string",
-            description: "Directory to search in, relative to current working directory (optional). Defaults to current directory."
+            description: "Optional: The absolute path to the directory to search in. If not specified, uses the current working directory. Must be within the current working directory."
           },
-          includeHidden: {
+          case_sensitive: {
             type: "boolean",
-            description: "Include hidden files and directories (starting with .). Defaults to false."
+            description: "Optional: Whether the pattern matching should be case-sensitive. Defaults to true. Set to false for case-insensitive matching on case-sensitive file systems."
           },
-          maxResults: {
-            type: "number",
-            description: "Maximum number of results to return (default: 1000). Prevents overwhelming output."
+          respect_git_ignore: {
+            type: "boolean",
+            description: "Optional: Whether to respect common ignore patterns (node_modules, .git, dist, build, etc.). Defaults to true. Set to false to include all files."
           }
         },
         required: ["pattern"]
@@ -8836,158 +8916,144 @@ var globFilesTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
-import { readdir as readdir2 } from "fs/promises";
-import { readFileSync as readFileSync3, statSync as statSync6 } from "fs";
+import { globStream } from "glob";
+import { readFile, stat as stat2 } from "fs/promises";
 import path10 from "path";
 var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
-function matchGlob2(filePath, pattern) {
-  const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(filePath);
-}
-async function walkDir2(dir, pattern, maxResults, basePath = "") {
-  const matches = [];
+var DEFAULT_IGNORE_PATTERNS3 = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/*.min.js",
+  "**/*.min.css",
+  "**/package-lock.json",
+  "**/pnpm-lock.yaml",
+  "**/yarn.lock"
+];
+async function isBinaryFile2(filePath) {
   try {
-    const entries = await readdir2(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (matches.length >= maxResults) {
-        break;
-      }
-      if (entry.name.startsWith(".")) {
-        continue;
-      }
-      const relativePath = basePath ? path10.join(basePath, entry.name) : entry.name;
-      const fullPath = path10.join(dir, entry.name);
-      if (matchGlob2(relativePath, pattern)) {
-        matches.push(relativePath);
-      }
-      if (entry.isDirectory() && (pattern.includes("**") || pattern.includes("/"))) {
-        const subMatches = await walkDir2(fullPath, pattern, maxResults - matches.length, relativePath);
-        matches.push(...subMatches);
-      }
-    }
-  } catch (error) {
+    const { openSync, readSync, closeSync } = await import("fs");
+    const buffer = Buffer.alloc(8192);
+    const fd = openSync(filePath, "r");
+    const bytesRead = readSync(fd, buffer, 0, 8192, 0);
+    closeSync(fd);
+    const chunk = buffer.slice(0, bytesRead);
+    return chunk.includes(0);
+  } catch {
+    return true;
   }
-  return matches;
+}
+function isPathWithinWorkspace(targetPath, baseCwd) {
+  const resolvedTarget = path10.resolve(targetPath);
+  const resolvedBase = path10.resolve(baseCwd);
+  return resolvedTarget.startsWith(resolvedBase);
 }
 async function searchFiles2(params) {
-  const { pattern, filePattern = "**/*", cwd: relativeCwd, caseSensitive = false, maxResults = 100, contextLines = 0 } = params;
+  const { pattern, dir_path, include } = params;
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path10.resolve(baseCwd, path10.normalize(relativeCwd)) : baseCwd;
-  if (!targetCwd.startsWith(baseCwd)) {
-    throw new Error(`Access denied: Cannot search files outside of current working directory`);
+  const targetDir = dir_path ? path10.resolve(baseCwd, dir_path) : baseCwd;
+  if (!isPathWithinWorkspace(targetDir, baseCwd)) {
+    throw new Error(`Path validation failed: "${dir_path}" resolves outside the allowed workspace directory`);
+  }
+  try {
+    const stats = await stat2(targetDir);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${dir_path}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Path does not exist: ${dir_path}`);
+    }
+    throw error;
   }
   let searchRegex;
   try {
-    const flags = caseSensitive ? "g" : "gi";
-    searchRegex = new RegExp(pattern, flags);
+    searchRegex = new RegExp(pattern, "i");
   } catch (error) {
     throw new Error(`Invalid regex pattern: ${pattern}`);
   }
-  const filesToSearch = await walkDir2(targetCwd, filePattern, 1e4);
-  const filteredFiles = [];
-  for (const match of filesToSearch) {
-    const fullPath = path10.join(targetCwd, match);
+  const globPattern = include || "**/*";
+  const filesStream = globStream(globPattern, {
+    cwd: targetDir,
+    dot: false,
+    // Skip hidden files
+    ignore: DEFAULT_IGNORE_PATTERNS3,
+    absolute: true,
+    nodir: true
+    // Only match files, not directories
+  });
+  const allMatches = [];
+  let filesSearched = 0;
+  const maxMatches = 500;
+  for await (const filePath of filesStream) {
+    if (allMatches.length >= maxMatches) {
+      break;
+    }
+    const fileAbsPath = filePath;
     try {
-      const stats = statSync6(fullPath);
-      if (stats.isDirectory() || stats.size > MAX_FILE_SIZE3) {
+      const stats = await stat2(fileAbsPath);
+      if (stats.size > MAX_FILE_SIZE3) {
         continue;
       }
-      if (isBinaryFile2(fullPath)) {
+      if (await isBinaryFile2(fileAbsPath)) {
         continue;
       }
-      filteredFiles.push(match);
-    } catch {
-      continue;
-    }
-  }
-  if (filteredFiles.length === 0) {
-    return `No files found matching pattern: ${filePattern}`;
-  }
-  const matches = [];
-  let filesSearched = 0;
-  for (const file of filteredFiles) {
-    if (matches.length >= maxResults) {
-      break;
-    }
-    filesSearched++;
-    const fullPath = path10.join(targetCwd, file);
-    try {
-      const content = readFileSync3(fullPath, "utf-8");
-      const lines = content.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        if (matches.length >= maxResults) {
-          break;
-        }
-        const line = lines[i];
-        if (searchRegex.test(line)) {
-          const match = {
-            file,
-            line: i + 1,
-            // 1-indexed line numbers
-            content: line.trim()
-          };
-          if (contextLines > 0) {
-            const before = [];
-            const after = [];
-            for (let j = Math.max(0, i - contextLines); j < i; j++) {
-              before.push(lines[j]);
-            }
-            for (let j = i + 1; j <= Math.min(lines.length - 1, i + contextLines); j++) {
-              after.push(lines[j]);
-            }
-            match.context = { before, after };
-          }
-          matches.push(match);
+      filesSearched++;
+      const content = await readFile(fileAbsPath, "utf8");
+      const lines = content.split(/\r?\n/);
+      lines.forEach((line, index) => {
+        if (allMatches.length < maxMatches && searchRegex.test(line)) {
+          allMatches.push({
+            filePath: path10.relative(targetDir, fileAbsPath) || path10.basename(fileAbsPath),
+            lineNumber: index + 1,
+            line
+          });
         }
-        searchRegex.lastIndex = 0;
+      });
+    } catch (readError) {
+      const errCode = readError.code;
+      if (errCode !== "ENOENT" && errCode !== "EACCES") {
+        console.debug(`Could not read ${fileAbsPath}: ${readError.message}`);
       }
-    } catch {
-      continue;
     }
   }
-  if (matches.length === 0) {
-    return `No matches found for pattern: ${pattern}
-Searched ${filesSearched} file(s)`;
+  const searchDirDisplay = dir_path || ".";
+  const filterInfo = include ? ` (filter: "${include}")` : "";
+  if (allMatches.length === 0) {
+    return `No matches found for pattern "${pattern}" in "${searchDirDisplay}"${filterInfo}.
+Searched ${filesSearched} file(s).`;
   }
-  const truncated = matches.length >= maxResults;
-  const summary = `Found ${matches.length} match(es)${truncated ? ` (truncated to ${maxResults})` : ""} in ${filesSearched} file(s)
+  const matchesByFile = allMatches.reduce((acc, match) => {
+    if (!acc[match.filePath]) {
+      acc[match.filePath] = [];
+    }
+    acc[match.filePath].push(match);
+    acc[match.filePath].sort((a, b) => a.lineNumber - b.lineNumber);
+    return acc;
+  }, {});
+  const matchCount = allMatches.length;
+  const matchTerm = matchCount === 1 ? "match" : "matches";
+  const truncated = matchCount >= maxMatches;
+  let result = `Found ${matchCount} ${matchTerm}${truncated ? " (truncated)" : ""} for pattern "${pattern}" in "${searchDirDisplay}"${filterInfo}:
 `;
-  const patternInfo = `Pattern: ${pattern}${caseSensitive ? "" : " (case-insensitive)"}
+  result += `Searched ${filesSearched} file(s)
+---
 `;
-  const cwdInfo = relativeCwd ? `Directory: ${relativeCwd}
-` : "";
-  const matchesList = matches.map((match) => {
-    let result = `
-\u{1F4C4} ${match.file}:${match.line}
-   ${match.content}`;
-    if (match.context) {
-      if (match.context.before.length > 0) {
-        result = `${result}
-   Context before:
-${match.context.before.map((l) => `     ${l}`).join("\n")}`;
-      }
-      if (match.context.after.length > 0) {
-        result = `${result}
-   Context after:
-${match.context.after.map((l) => `     ${l}`).join("\n")}`;
-      }
-    }
-    return result;
-  }).join("\n");
-  return `${summary}${patternInfo}${cwdInfo}${matchesList}`;
-}
-function isBinaryFile2(filePath) {
-  try {
-    const buffer = Buffer.alloc(8192);
-    const fd = __require("fs").openSync(filePath, "r");
-    const bytesRead = __require("fs").readSync(fd, buffer, 0, 8192, 0);
-    __require("fs").closeSync(fd);
-    const chunk = buffer.slice(0, bytesRead);
-    return chunk.includes(0);
-  } catch {
-    return true;
+  for (const filePath in matchesByFile) {
+    result += `File: ${filePath}
+`;
+    matchesByFile[filePath].forEach((match) => {
+      const trimmedLine = match.line.trim();
+      const displayLine = trimmedLine.length > 200 ? trimmedLine.slice(0, 200) + "..." : trimmedLine;
+      result += `L${match.lineNumber}: ${displayLine}
+`;
+    });
+    result += "---\n";
   }
+  return result.trim();
 }
 var grepSearchTool = {
   name: "grep_search",
@@ -8996,8 +9062,8 @@ var grepSearchTool = {
       const params = value;
       context.logger.info("\u{1F50D} GrepSearch: Searching files", {
         pattern: params.pattern,
-        filePattern: params.filePattern || "**/*",
-        cwd: params.cwd || "."
+        dir_path: params.dir_path || ".",
+        include: params.include || "**/*"
       });
       try {
         const result = await searchFiles2(params);
@@ -9010,33 +9076,21 @@ var grepSearchTool = {
     },
     toolSchema: {
       name: "grep_search",
-      description: "Search for a regex pattern in file contents. Similar to grep command. Searches text files only, excluding binary files. Restricted to current working directory for security.",
+      description: "Searches for a regular expression pattern within the content of files in a specified directory (or current working directory). Can filter files by a glob pattern. Returns the lines containing matches, along with their file paths and line numbers.",
       parameters: {
         type: "object",
         properties: {
           pattern: {
             type: "string",
-            description: "Regular expression pattern to search for in file contents"
+            description: "The regular expression (regex) pattern to search for within file contents (e.g., 'function\\s+myFunction', 'import\\s+\\{.*\\}\\s+from\\s+.*')."
           },
-          filePattern: {
+          dir_path: {
             type: "string",
-            description: 'Glob pattern to filter which files to search (optional, default: "**/*"). Example: "src/**/*.ts" to search only TypeScript files in src directory.'
+            description: "Optional: The absolute path to the directory to search within. If omitted, searches the current working directory."
           },
-          cwd: {
+          include: {
             type: "string",
-            description: "Directory to search in, relative to current working directory (optional). Defaults to current directory."
-          },
-          caseSensitive: {
-            type: "boolean",
-            description: "Whether the search should be case-sensitive (default: false)"
-          },
-          maxResults: {
-            type: "number",
-            description: "Maximum number of matches to return (default: 100). Prevents overwhelming output."
-          },
-          contextLines: {
-            type: "number",
-            description: "Number of context lines to show before and after each match (default: 0). Similar to grep -C option."
+            description: "Optional: A glob pattern to filter which files are searched (e.g., '*.js', '*.{ts,tsx}', 'src/**'). If omitted, searches all files (respecting potential global ignores)."
           }
         },
         required: ["pattern"]
@@ -9047,7 +9101,7 @@ var grepSearchTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
 import { promises as fs10 } from "fs";
-import { existsSync as existsSync6, statSync as statSync7 } from "fs";
+import { existsSync as existsSync6, statSync as statSync5 } from "fs";
 import path11 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
@@ -9060,7 +9114,7 @@ async function deleteFile(params) {
   if (!existsSync6(resolvedPath)) {
     throw new Error(`File or directory not found: ${filePath}`);
   }
-  const stats = statSync7(resolvedPath);
+  const stats = statSync5(resolvedPath);
   const isDirectory = stats.isDirectory();
   const size = stats.size;
   if (isDirectory && !recursive) {
@@ -9081,7 +9135,7 @@ var deleteFileTool = {
     toolFn: async (value) => {
       const params = value;
       const resolvedPath = path11.resolve(process.cwd(), path11.normalize(params.path));
-      const isDirectory = existsSync6(resolvedPath) && statSync7(resolvedPath).isDirectory();
+      const isDirectory = existsSync6(resolvedPath) && statSync5(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -9857,7 +9911,7 @@ var ToolErrorType;
 
 // src/utils/diffPreview.ts
 import * as Diff from "diff";
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 async function generateFileDiffPreview(args) {
   try {
@@ -9872,7 +9926,7 @@ ${preview}${hasMore ? `
 
 ... (${lines2.length - 20} more lines)` : ""}`;
     }
-    const currentContent = await readFile(args.path, "utf-8");
+    const currentContent = await readFile2(args.path, "utf-8");
     const patch = Diff.createPatch(
       args.path,
       currentContent,
@@ -11248,6 +11302,10 @@ var ServerLlmBackend = class {
    */
   async complete(model, messages, options, callback) {
     logger.debug(`[ServerLlmBackend] Starting complete() with model: ${model}`);
+    if (options.abortSignal?.aborted) {
+      logger.debug("[ServerLlmBackend] Request aborted before start");
+      return;
+    }
     return new Promise(async (resolve3, reject) => {
       try {
         logger.debug("[ServerLlmBackend] Making streaming request...");
@@ -11348,7 +11406,25 @@ var ServerLlmBackend = class {
             }
           }
         });
+        if (options.abortSignal) {
+          const abortHandler = () => {
+            logger.debug("[ServerLlmBackend] Abort signal received, destroying stream");
+            response.data.destroy();
+            resolve3();
+          };
+          if (options.abortSignal.aborted) {
+            abortHandler();
+            return;
+          }
+          options.abortSignal.addEventListener("abort", abortHandler, { once: true });
+          response.data.on("close", () => {
+            options.abortSignal?.removeEventListener("abort", abortHandler);
+          });
+        }
         response.data.on("data", (chunk) => {
+          if (options.abortSignal?.aborted) {
+            return;
+          }
           parser.feed(chunk.toString());
         });
         response.data.on("end", () => {
@@ -11360,9 +11436,23 @@ var ServerLlmBackend = class {
           }
         });
         response.data.on("error", (error) => {
+          if (options.abortSignal?.aborted) {
+            resolve3();
+            return;
+          }
           reject(error);
         });
       } catch (error) {
+        if (options.abortSignal?.aborted) {
+          logger.debug("[ServerLlmBackend] Request was aborted, resolving gracefully");
+          resolve3();
+          return;
+        }
+        if (isAxiosError(error) && error.code === "ERR_CANCELED") {
+          logger.debug("[ServerLlmBackend] Request was canceled, resolving gracefully");
+          resolve3();
+          return;
+        }
         logger.error("LLM completion failed", error);
         if (isAxiosError(error)) {
           logger.debug(
@@ -11513,8 +11603,10 @@ var ServerLlmBackend = class {
     logger.debug(`  Body: ${logger.formatBytes(bodySize)}`);
     logger.debug(`  Preview: ${bodyStr.substring(0, 200)}`);
     const response = await axiosInstance.post(this.completionsEndpoint, requestBody, {
-      responseType: "stream"
+      responseType: "stream",
       // Auth header is automatically injected by ApiClient interceptor
+      // Pass abort signal to cancel request if user presses ESC
+      signal: options.abortSignal
     });
     logger.debug(`\u2190 ${response.status} ${response.statusText}`);
     return response;
@@ -11658,7 +11750,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.11",
+  version: "0.2.12-cli-todo-list.17408+244ee96b6",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -11695,7 +11787,8 @@ var package_default = {
     test: "vitest run",
     "test:watch": "vitest",
     start: "node dist/index.js",
-    prepublishOnly: "pnpm build"
+    prepublishOnly: "pnpm build",
+    postinstall: `node -e "try { require('better-sqlite3') } catch(e) { if(e.message.includes('bindings')) { console.log('\\n\u26A0\uFE0F  Rebuilding better-sqlite3 native bindings...'); require('child_process').execSync('pnpm rebuild better-sqlite3', {stdio:'inherit'}) } }"`
   },
   dependencies: {
     "@anthropic-ai/sdk": "^0.22.0",
@@ -11728,6 +11821,7 @@ var package_default = {
     "eventsource-parser": "^3.0.6",
     "file-type": "^18.7.0",
     "fuse.js": "^7.1.0",
+    glob: "^13.0.0",
     "gray-matter": "^4.0.3",
     ink: "^6.5.1",
     "ink-select-input": "^6.2.0",
@@ -11761,11 +11855,11 @@ var package_default = {
     zustand: "^4.5.4"
   },
   devDependencies: {
-    "@bike4mind/agents": "workspace:*",
-    "@bike4mind/common": "workspace:*",
-    "@bike4mind/mcp": "workspace:*",
-    "@bike4mind/services": "workspace:*",
-    "@bike4mind/utils": "workspace:*",
+    "@bike4mind/agents": "0.1.0",
+    "@bike4mind/common": "2.41.1-cli-todo-list.17408+244ee96b6",
+    "@bike4mind/mcp": "1.21.1-cli-todo-list.17408+244ee96b6",
+    "@bike4mind/services": "2.36.1-cli-todo-list.17408+244ee96b6",
+    "@bike4mind/utils": "2.1.6-cli-todo-list.17408+244ee96b6",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -11777,7 +11871,8 @@ var package_default = {
     tsx: "^4.21.0",
     typescript: "^5.9.3",
     vitest: "^3.2.4"
-  }
+  },
+  gitHead: "244ee96b6f743aeff0513fc84f573050b624d4e7"
 };
 
 // src/config/constants.ts
@@ -12133,6 +12228,131 @@ function createSubagentDelegateTool(orchestrator, parentSessionId) {
   };
 }
 
+// src/tools/writeTodosTool.ts
+var VALID_STATUSES = ["pending", "in_progress", "completed", "cancelled"];
+function validateTodos(todos) {
+  if (!Array.isArray(todos)) {
+    throw new Error("write_todos: todos must be an array");
+  }
+  if (todos.length === 0) {
+    throw new Error("write_todos: todos array cannot be empty");
+  }
+  let inProgressCount = 0;
+  const validatedTodos = todos.map((item, index) => {
+    if (!item || typeof item !== "object") {
+      throw new Error(`write_todos: item at index ${index} must be an object`);
+    }
+    const { description, status } = item;
+    if (typeof description !== "string" || description.trim() === "") {
+      throw new Error(`write_todos: item at index ${index} must have a non-empty description`);
+    }
+    if (typeof status !== "string" || !VALID_STATUSES.includes(status)) {
+      throw new Error(
+        `write_todos: item at index ${index} has invalid status "${status}". Must be one of: ${VALID_STATUSES.join(", ")}`
+      );
+    }
+    if (status === "in_progress") {
+      inProgressCount++;
+    }
+    return {
+      description: description.trim(),
+      status
+    };
+  });
+  if (inProgressCount > 1) {
+    throw new Error(`write_todos: only one task can be 'in_progress' at a time, but found ${inProgressCount}`);
+  }
+  return validatedTodos;
+}
+function formatTodosOutput(todos) {
+  const statusEmoji = {
+    pending: "\u2B1C",
+    in_progress: "\u{1F504}",
+    completed: "\u2705",
+    cancelled: "\u274C"
+  };
+  const lines = todos.map((todo, index) => {
+    const emoji = statusEmoji[todo.status];
+    return `${index + 1}. ${emoji} [${todo.status}] ${todo.description}`;
+  });
+  return lines.join("\n");
+}
+function createWriteTodosTool(todoStore) {
+  return {
+    toolFn: async (args) => {
+      const params = args;
+      const validatedTodos = validateTodos(params.todos);
+      todoStore.todos = validatedTodos;
+      if (todoStore.onUpdate) {
+        todoStore.onUpdate(validatedTodos);
+      }
+      const output = formatTodosOutput(validatedTodos);
+      return `Todo list updated successfully:
+
+${output}`;
+    },
+    toolSchema: {
+      name: "write_todos",
+      description: `Create or update a list of subtasks for complex multi-step requests.
+
+**When to use this tool:**
+- When handling complex requests that require multiple steps
+- To break down a large task into smaller, manageable subtasks
+- To track progress through a multi-step workflow
+
+**Important guidelines:**
+- Call this tool early when receiving complex requests
+- Update the list immediately when starting, completing, or cancelling tasks
+- Only ONE task should be 'in_progress' at a time
+- Never batch updates - update as soon as state changes
+
+**Status values:**
+- pending: Task not yet started
+- in_progress: Currently working on this task (only ONE allowed)
+- completed: Task finished successfully
+- cancelled: Task will not be completed
+
+**Example:**
+If asked to "create a new React component with tests", break it down:
+1. Create component file \u2192 in_progress
+2. Add component logic \u2192 pending
+3. Create test file \u2192 pending
+4. Write unit tests \u2192 pending`,
+      parameters: {
+        type: "object",
+        properties: {
+          todos: {
+            type: "array",
+            description: "Complete list of todo items. This replaces any existing list. Each item needs a description and status.",
+            items: {
+              type: "object",
+              properties: {
+                description: {
+                  type: "string",
+                  description: "Clear, concise description of the task"
+                },
+                status: {
+                  type: "string",
+                  enum: ["pending", "in_progress", "completed", "cancelled"],
+                  description: "Current status of the task. Only ONE task can be 'in_progress' at a time."
+                }
+              },
+              required: ["description", "status"]
+            }
+          }
+        },
+        required: ["todos"]
+      }
+    }
+  };
+}
+function createTodoStore(onUpdate) {
+  return {
+    todos: [],
+    onUpdate
+  };
+}
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -12164,7 +12384,8 @@ function CliApp() {
     trustLocationSelector: null,
     rewindSelector: null,
     sessionSelector: null,
-    orchestrator: null
+    orchestrator: null,
+    abortController: null
   });
   const [isInitialized, setIsInitialized] = useState8(false);
   const [initError, setInitError] = useState8(null);
@@ -12210,6 +12431,15 @@ function CliApp() {
     }, 100);
   }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
   useInput6((input, key) => {
+    if (key.escape) {
+      if (state.abortController) {
+        logger.debug("[ABORT] ESC pressed - aborting current operation...");
+        state.abortController.abort();
+        setState((prev) => ({ ...prev, abortController: null }));
+        useCliStore.getState().setIsThinking(false);
+      }
+      return;
+    }
     if (key.ctrl && input === "c") {
       const now = Date.now();
       if (exitTimestamp && now - exitTimestamp < EXIT_TIMEOUT_MS) {
@@ -12407,7 +12637,9 @@ function CliApp() {
         subagentConfigs
       });
       const subagentDelegateTool = createSubagentDelegateTool(orchestrator, newSession.id);
-      const allTools = [...b4mTools, ...mcpTools, subagentDelegateTool];
+      const todoStore = createTodoStore();
+      const writeTodosTool = createWriteTodosTool(todoStore);
+      const allTools = [...b4mTools, ...mcpTools, subagentDelegateTool, writeTodosTool];
       console.log(`\u{1F916} Subagent delegation enabled (explore, plan, review)`);
       const projectDir = state.configStore.getProjectConfigDir();
       const contextResult = await loadContextFiles(projectDir);
@@ -12427,46 +12659,7 @@ function CliApp() {
 Follow these project-specific instructions:
 
 ${contextResult.mergedContent}` : "";
-      const cliSystemPrompt = `You are an autonomous AI assistant with access to tools. Your job is to help users by taking action and solving problems proactively.
-
-CORE BEHAVIOR:
-- Be proactive: Take action instead of asking for permission or clarification
-- Make smart assumptions: If unclear, choose the most reasonable interpretation
-- Use conversation history: Reference previous exchanges to understand context
-- Complete tasks fully: Don't just show what to do - actually do it
-
-FOR CODING TASKS:
-- You have file system access (file_read, create_file, glob_files, grep_search, delete_file)
-- When user says "enhance", "update", "fix", "improve" a file:
-  * Use file_read to get current content
-  * Generate the improved version
-  * Use create_file to write it back
-  * Don't just show suggestions - make the changes
-- When searching for code: Use grep_search or glob_files to find relevant files
-- Permission system will ask for approval before any file writes
-
-SUBAGENT DELEGATION:
-- You have access to specialized subagents via the subagent_delegate tool
-- Use subagents for focused exploration, planning, or review tasks:
-  * explore: Fast read-only codebase search (e.g., "find all auth files", "locate API endpoints")
-  * plan: Break down complex tasks into actionable steps
-  * review: Analyze code quality and identify issues
-- Subagents keep the main conversation clean and run faster with optimized models
-- Delegate when you need to search extensively or analyze code structure
-
-FOR GENERAL TASKS:
-- Use available tools to get information (weather, web search, calculations, etc.)
-- When user asks follow-up questions, use conversation context to understand what they're referring to
-- If user asks "how about X?" after a previous question, apply the same question type to X
-
-EXAMPLES:
-- "what should I wear in Texas?" \u2192 use weather tool for Texas
-- "how about Japan?" \u2192 use weather tool for Japan (applying same question from context)
-- "enhance README" \u2192 file_read \u2192 generate \u2192 create_file
-- "what packages installed?" \u2192 glob_files "**/package.json" \u2192 file_read
-- "find all components using React hooks" \u2192 subagent_delegate(task="find all components using React hooks", type="explore")
-
-Remember: Use context from previous messages to understand follow-up questions.${contextSection}`;
+      const cliSystemPrompt = buildCoreSystemPrompt(contextSection);
       const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
       const agent = new ReActAgent({
         userId: config.userId,
@@ -12511,13 +12704,16 @@ Remember: Use context from previous messages to understand follow-up questions.$
         }
       };
       agent.on("thought", stepHandler);
+      agent.on("observation", stepHandler);
       agent.on("action", stepHandler);
       orchestrator.setBeforeRunCallback((subagent, _subagentType) => {
         subagent.on("thought", stepHandler);
+        subagent.on("observation", stepHandler);
         subagent.on("action", stepHandler);
       });
       orchestrator.setAfterRunCallback((subagent, _subagentType) => {
         subagent.off("thought", stepHandler);
+        subagent.off("observation", stepHandler);
         subagent.off("action", stepHandler);
       });
       setState((prev) => ({
@@ -12564,6 +12760,8 @@ Remember: Use context from previous messages to understand follow-up questions.$
       return;
     }
     useCliStore.getState().setIsThinking(true);
+    const abortController = new AbortController();
+    setState((prev) => ({ ...prev, abortController }));
     const currentSteps = [];
     const stepHandler = (step) => {
       currentSteps.push(step);
@@ -12623,7 +12821,8 @@ Remember: Use context from previous messages to understand follow-up questions.$
         content: msg.content
       }));
       const result = await state.agent.run(messageContent, {
-        previousMessages: previousMessages.length > 0 ? previousMessages : void 0
+        previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
+        signal: abortController.signal
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {
@@ -12668,6 +12867,33 @@ Remember: Use context from previous messages to understand follow-up questions.$
       useCliStore.getState().setIsThinking(false);
     } catch (error) {
       useCliStore.getState().setIsThinking(false);
+      if (error instanceof Error && error.name === "AbortError") {
+        logger.debug("[ABORT] Custom command aborted by user");
+        const currentSession2 = useCliStore.getState().session;
+        if (currentSession2) {
+          const messages2 = [...currentSession2.messages];
+          const lastMessage2 = messages2[messages2.length - 1];
+          if (lastMessage2 && lastMessage2.role === "assistant") {
+            messages2[messages2.length - 1] = {
+              ...lastMessage2,
+              content: "\u26A0\uFE0F Operation cancelled by user",
+              metadata: {
+                ...lastMessage2.metadata,
+                cancelled: true
+              }
+            };
+          }
+          const sessionWithCancel = {
+            ...currentSession2,
+            messages: messages2,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          setState((prev) => ({ ...prev, session: sessionWithCancel }));
+          setStoreSession(sessionWithCancel);
+          await state.sessionStore.save(sessionWithCancel);
+        }
+        return;
+      }
       if (error?.message?.includes("Permission denied")) {
         console.log("\n\u26A0\uFE0F  Action blocked by permission settings");
         const currentSession2 = useCliStore.getState().session;
@@ -12708,6 +12934,7 @@ Remember: Use context from previous messages to understand follow-up questions.$
       setState((prev) => ({ ...prev, session: sessionWithError }));
       setStoreSession(sessionWithError);
     } finally {
+      setState((prev) => ({ ...prev, abortController: null }));
       state.agent.off("thought", stepHandler);
       state.agent.off("action", stepHandler);
     }
@@ -12727,6 +12954,8 @@ Remember: Use context from previous messages to understand follow-up questions.$
       return;
     }
     useCliStore.getState().setIsThinking(true);
+    const abortController = new AbortController();
+    setState((prev) => ({ ...prev, abortController }));
     try {
       let messageContent = message;
       let userMessageContent = message;
@@ -12764,7 +12993,8 @@ Remember: Use context from previous messages to understand follow-up questions.$
         content: msg.content
       }));
       const result = await state.agent.run(messageContent, {
-        previousMessages: previousMessages.length > 0 ? previousMessages : void 0
+        previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
+        signal: abortController.signal
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {
@@ -12804,6 +13034,30 @@ Remember: Use context from previous messages to understand follow-up questions.$
       await state.sessionStore.save(updatedSession);
     } catch (error) {
       useCliStore.getState().clearPendingMessages();
+      if (error instanceof Error && error.name === "AbortError") {
+        logger.debug("[ABORT] Operation aborted by user");
+        const currentSession = useCliStore.getState().session;
+        if (currentSession) {
+          const cancelMessage = {
+            id: uuidv410(),
+            role: "assistant",
+            content: "\u26A0\uFE0F Operation cancelled by user",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            metadata: {
+              cancelled: true
+            }
+          };
+          const sessionWithCancel = {
+            ...currentSession,
+            messages: [...currentSession.messages, cancelMessage],
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          setState((prev) => ({ ...prev, session: sessionWithCancel }));
+          setStoreSession(sessionWithCancel);
+          await state.sessionStore.save(sessionWithCancel);
+        }
+        return;
+      }
       if (error instanceof Error) {
         if (error.message.includes("Authentication failed") || error.message.includes("Authentication expired")) {
           console.log("\n\u274C Authentication failed");
@@ -12812,6 +13066,9 @@ Remember: Use context from previous messages to understand follow-up questions.$
         }
       }
       console.error("Error processing message:", error);
+    } finally {
+      setState((prev) => ({ ...prev, abortController: null }));
+      useCliStore.getState().setIsThinking(false);
     }
   };
   const handleBashCommand = useCallback(
@@ -12862,7 +13119,7 @@ ${output}` : output.trim() || "(no output)",
       if (!imageStore) {
         if (!imageStoreInitPromise.current) {
           imageStoreInitPromise.current = (async () => {
-            const { ImageStore: ImageStoreClass } = await import("./ImageStore-RQZ7OF7P.js");
+            const { ImageStore: ImageStoreClass } = await import("./ImageStore-MMUOUPI2.js");
             const newImageStore = new ImageStoreClass();
             setState((prev) => ({
               ...prev,