@nomad-e/bluma-cli 0.0.107 → 0.0.109

package/dist/main.js

@@ -1,1266 +1,1588 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// src/app/agent/core/llm/tool_call_normalizer.ts
-import { randomUUID } from "crypto";
-var ToolCallNormalizer;
-var init_tool_call_normalizer = __esm({
-  "src/app/agent/core/llm/tool_call_normalizer.ts"() {
-    "use strict";
-    ToolCallNormalizer = class {
-      /**
-       * Normaliza a mensagem do assistant, convertendo diferentes formatos de tool calls
-       */
-      static normalizeAssistantMessage(message) {
-        if (message.tool_calls && this.isOpenAIFormat(message.tool_calls)) {
-          return message;
-        }
-        const toolCalls = this.extractToolCalls(message);
-        if (toolCalls.length > 0) {
-          return {
-            role: message.role || "assistant",
-            content: message.content || null,
-            tool_calls: toolCalls
-          };
-        }
-        return message;
-      }
-      /**
-       * Verifica se já está no formato OpenAI
-       */
-      static isOpenAIFormat(toolCalls) {
-        if (!Array.isArray(toolCalls) || toolCalls.length === 0) return false;
-        const firstCall = toolCalls[0];
-        return typeof firstCall.id === "string" && firstCall.type === "function" && typeof firstCall.function?.name === "string" && typeof firstCall.function?.arguments === "string";
-      }
-      /**
-       * Extrai tool calls de diversos formatos possíveis
-       */
-      static extractToolCalls(message) {
-        const results = [];
-        if (message.tool_calls && Array.isArray(message.tool_calls)) {
-          for (const call of message.tool_calls) {
-            const normalized = this.normalizeToolCall(call);
-            if (normalized) results.push(normalized);
-          }
-        }
-        if (typeof message.content === "string" && message.content.trim()) {
-          const extracted = this.extractFromContent(message.content);
-          results.push(...extracted);
-        }
-        if (message.function_call) {
-          const normalized = this.normalizeToolCall(message.function_call);
-          if (normalized) results.push(normalized);
-        }
-        return results;
-      }
-      /**
-       * Normaliza um único tool call para o formato OpenAI
-       */
-      static normalizeToolCall(call) {
-        try {
-          if (call.id && call.function?.name) {
-            return {
-              id: call.id,
-              type: "function",
-              function: {
-                name: call.function.name,
-                arguments: typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments)
-              }
-            };
-          }
-          if (call.name) {
-            return {
-              id: call.id || randomUUID(),
-              type: "function",
-              function: {
-                name: call.name,
-                arguments: typeof call.arguments === "string" ? call.arguments : JSON.stringify(call.arguments || {})
-              }
-            };
-          }
-          if (call.function && typeof call.function === "object") {
-            return {
-              id: call.id || randomUUID(),
-              type: "function",
-              function: {
-                name: call.function.name,
-                arguments: typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments || {})
-              }
-            };
-          }
-          return null;
-        } catch (error) {
-          console.error("Error normalizing tool call:", error, call);
-          return null;
+// src/app/agent/tools/natives/async_command.ts
+var async_command_exports = {};
+__export(async_command_exports, {
+  commandStatus: () => commandStatus,
+  killCommand: () => killCommand,
+  runCommandAsync: () => runCommandAsync,
+  sendCommandInput: () => sendCommandInput
+});
+import os2 from "os";
+import { spawn } from "child_process";
+import { v4 as uuidv42 } from "uuid";
+function cleanupOldCommands() {
+  if (runningCommands.size <= MAX_STORED_COMMANDS) return;
+  const commands = Array.from(runningCommands.entries()).filter(([_, cmd]) => cmd.status !== "running").sort((a, b) => (a[1].endTime || 0) - (b[1].endTime || 0));
+  const toRemove = commands.slice(0, commands.length - MAX_STORED_COMMANDS + 10);
+  for (const [id] of toRemove) {
+    runningCommands.delete(id);
+  }
+}
+function isDangerousCommand(command) {
+  const trimmed = command.trim();
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return "Command requires elevated privileges (sudo/doas) which cannot be handled in async mode";
+    }
+  }
+  for (const pattern of INTERACTIVE_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return "Interactive commands are not supported in async mode";
+    }
+  }
+  return null;
+}
+async function runCommandAsync(args) {
+  try {
+    const {
+      command,
+      cwd = process.cwd(),
+      timeout = 0
+    } = args;
+    if (!command || typeof command !== "string") {
+      return {
+        success: false,
+        error: "command is required and must be a string"
+      };
+    }
+    const dangerReason = isDangerousCommand(command);
+    if (dangerReason) {
+      return {
+        success: false,
+        error: dangerReason
+      };
+    }
+    const commandId = uuidv42().substring(0, 8);
+    const platform = os2.platform();
+    let shellCmd;
+    let shellArgs;
+    if (platform === "win32") {
+      shellCmd = process.env.COMSPEC || "cmd.exe";
+      shellArgs = ["/c", command];
+    } else {
+      shellCmd = process.env.SHELL || "/bin/bash";
+      shellArgs = ["-c", command];
+    }
+    const entry = {
+      id: commandId,
+      command,
+      status: "running",
+      stdout: "",
+      stderr: "",
+      exitCode: null,
+      startTime: Date.now(),
+      process: null
+    };
+    const child = spawn(shellCmd, shellArgs, {
+      cwd,
+      env: process.env,
+      windowsHide: true
+    });
+    entry.process = child;
+    let stdoutTruncated = false;
+    child.stdout?.on("data", (data) => {
+      if (!stdoutTruncated) {
+        entry.stdout += data.toString();
+        if (entry.stdout.length > MAX_OUTPUT_SIZE) {
+          entry.stdout = entry.stdout.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
+          stdoutTruncated = true;
         }
       }
-      /**
-       * Extrai tool calls do content (pode estar em markdown, JSON, etc)
-       */
-      static extractFromContent(content) {
-        const results = [];
-        const cleanContent = content.replace(/```(?:json)?\s*([\s\S]*?)```/g, "$1");
-        const jsonMatches = this.extractJsonObjects(cleanContent);
-        for (const jsonStr of jsonMatches) {
-          try {
-            const parsed = JSON.parse(jsonStr);
-            if (Array.isArray(parsed)) {
-              for (const call of parsed) {
-                const normalized = this.normalizeToolCall(call);
-                if (normalized) results.push(normalized);
-              }
-            } else if (parsed.name || parsed.function) {
-              const normalized = this.normalizeToolCall(parsed);
-              if (normalized) results.push(normalized);
-            } else if (parsed.tool_calls && Array.isArray(parsed.tool_calls)) {
-              for (const call of parsed.tool_calls) {
-                const normalized = this.normalizeToolCall(call);
-                if (normalized) results.push(normalized);
-              }
-            }
-          } catch (e) {
-          }
+    });
+    let stderrTruncated = false;
+    child.stderr?.on("data", (data) => {
+      if (!stderrTruncated) {
+        entry.stderr += data.toString();
+        if (entry.stderr.length > MAX_OUTPUT_SIZE) {
+          entry.stderr = entry.stderr.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
+          stderrTruncated = true;
         }
-        return results;
       }
-      /**
-       * Extrai objetos JSON de uma string (suporta múltiplos objetos)
-       */
-      static extractJsonObjects(text) {
-        const results = [];
-        let depth = 0;
-        let start = -1;
-        for (let i = 0; i < text.length; i++) {
-          if (text[i] === "{") {
-            if (depth === 0) start = i;
-            depth++;
-          } else if (text[i] === "}") {
-            depth--;
-            if (depth === 0 && start !== -1) {
-              results.push(text.substring(start, i + 1));
-              start = -1;
+    });
+    child.on("close", (code) => {
+      entry.exitCode = code;
+      entry.status = code === 0 ? "completed" : "error";
+      entry.endTime = Date.now();
+      entry.process = null;
+    });
+    child.on("error", (error) => {
+      entry.stderr += `
+Process error: ${error.message}`;
+      entry.status = "error";
+      entry.endTime = Date.now();
+      entry.process = null;
+    });
+    if (timeout > 0) {
+      setTimeout(() => {
+        if (entry.status === "running") {
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (entry.status === "running") {
+              child.kill("SIGKILL");
             }
-          }
+          }, 2e3);
+          entry.status = "timeout";
+          entry.stderr += `
+Command timed out after ${timeout} seconds`;
         }
-        return results;
-      }
-      /**
-       * Valida se um tool call normalizado é válido
-       */
-      static isValidToolCall(call) {
-        return !!(call.id && call.type === "function" && call.function?.name && typeof call.function.arguments === "string");
-      }
+      }, timeout * 1e3);
+    }
+    runningCommands.set(commandId, entry);
+    cleanupOldCommands();
+    return {
+      success: true,
+      command_id: commandId,
+      command,
+      message: `Command started in background. Use command_status with id "${commandId}" to check progress.`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Unexpected error: ${error.message}`
     };
-  }
-});
-
-// src/main.ts
-import React10 from "react";
-import { render } from "ink";
-import { EventEmitter as EventEmitter2 } from "events";
-import { v4 as uuidv43 } from "uuid";
-
-// src/app/ui/App.tsx
-import { useState as useState6, useEffect as useEffect5, useRef as useRef4, useCallback as useCallback2, memo as memo10 } from "react";
-import { Box as Box16, Text as Text15, Static } from "ink";
-
-// src/app/ui/layout.tsx
-import { Box, Text } from "ink";
-import { memo } from "react";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-var HeaderComponent = ({
-  sessionId: sessionId2,
-  workdir
-}) => {
-  const dirName = workdir.split("/").pop() || workdir;
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "magenta", bold: true, children: "bluma \u2014 coding agent" }) }),
-    /* @__PURE__ */ jsxs(Box, { children: [
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "cwd " }),
-      /* @__PURE__ */ jsx(Text, { color: "cyan", children: dirName }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " | " }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "session " }),
-      /* @__PURE__ */ jsx(Text, { color: "gray", children: sessionId2.slice(0, 8) })
-    ] })
-  ] });
-};
-var Header = memo(HeaderComponent);
-var SessionInfoComponent = ({
-  sessionId: sessionId2,
-  workdir,
-  toolsCount,
-  mcpStatus
-}) => /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
-  /* @__PURE__ */ jsx(Text, { dimColor: true, children: "mcp " }),
-  /* @__PURE__ */ jsx(Text, { color: mcpStatus === "connected" ? "green" : "yellow", children: mcpStatus === "connected" ? "+" : "-" }),
-  toolsCount !== null && /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-    " ",
-    toolsCount,
-    " tools"
-  ] }) })
-] });
-var SessionInfo = memo(SessionInfoComponent);
-var TaskStatusBarComponent = ({
-  taskName,
-  mode,
-  status
-}) => {
-  const modeColors = {
-    PLANNING: "blue",
-    EXECUTION: "green",
-    VERIFICATION: "yellow"
-  };
-  return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
-    /* @__PURE__ */ jsxs(Text, { color: modeColors[mode], bold: true, children: [
-      "[",
-      mode.charAt(0),
-      "]"
-    ] }),
-    /* @__PURE__ */ jsxs(Text, { children: [
-      " ",
-      taskName
-    ] }),
-    status && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-      " - ",
-      status
-    ] })
-  ] });
-};
-var TaskStatusBar = memo(TaskStatusBarComponent);
-
-// src/app/ui/components/InputPrompt.tsx
-import { Box as Box2, Text as Text2, useStdout, useInput as useInput2 } from "ink";
-
-// src/app/ui/utils/useSimpleInputBuffer.ts
-import { useReducer, useRef, useCallback, useEffect } from "react";
-import { useInput } from "ink";
-function getLineStart(text, cursorPos) {
-  let pos = cursorPos - 1;
-  while (pos >= 0 && text[pos] !== "\n") {
-    pos--;
-  }
-  return pos + 1;
-}
-function getLineEnd(text, cursorPos) {
-  let pos = cursorPos;
-  while (pos < text.length && text[pos] !== "\n") {
-    pos++;
-  }
-  return pos;
-}
-function moveToAdjacentLine(text, cursorPos, direction) {
-  const currentLineStart = getLineStart(text, cursorPos);
-  const currentLineEnd = getLineEnd(text, cursorPos);
-  const column = cursorPos - currentLineStart;
-  if (direction === "up") {
-    if (currentLineStart === 0) return cursorPos;
-    const prevLineEnd = currentLineStart - 1;
-    const prevLineStart = getLineStart(text, prevLineEnd);
-    const prevLineLength = prevLineEnd - prevLineStart;
-    return prevLineStart + Math.min(column, prevLineLength);
-  } else {
-    if (currentLineEnd === text.length) return cursorPos;
-    const nextLineStart = currentLineEnd + 1;
-    const nextLineEnd = getLineEnd(text, nextLineStart);
-    const nextLineLength = nextLineEnd - nextLineStart;
-    return nextLineStart + Math.min(column, nextLineLength);
   }
 }
-function inputReducer(state, action, viewWidth) {
-  const adjustView = (newCursorPos, currentViewStart) => {
-    if (newCursorPos < currentViewStart) {
-      return newCursorPos;
-    }
-    if (newCursorPos >= currentViewStart + viewWidth) {
-      return newCursorPos - viewWidth + 1;
+async function commandStatus(args) {
+  try {
+    const {
+      command_id,
+      wait_seconds = 0,
+      output_limit = 1e4
+    } = args;
+    if (!command_id) {
+      return {
+        success: false,
+        command_id: "",
+        status: "error",
+        error: "command_id is required"
+      };
     }
-    return currentViewStart;
-  };
-  switch (action.type) {
-    case "INPUT": {
-      const cleanInput = action.payload.replace(/(\r\n|\r)/gm, "\n");
-      const newText = state.text.slice(0, state.cursorPosition) + cleanInput + state.text.slice(state.cursorPosition);
-      const newCursorPosition = state.cursorPosition + cleanInput.length;
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      if (newText === state.text && newCursorPosition === state.cursorPosition) {
-        return state;
-      }
-      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        command_id,
+        status: "not_found",
+        error: `Command with id "${command_id}" not found. It may have expired or never existed.`
+      };
     }
-    case "NEWLINE": {
-      const newText = state.text.slice(0, state.cursorPosition) + "\n" + state.text.slice(state.cursorPosition);
-      const newCursorPosition = state.cursorPosition + 1;
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    if (wait_seconds > 0 && entry.status === "running") {
+      await new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          if (entry.status !== "running") {
+            clearInterval(checkInterval);
+            resolve();
+          }
+        }, 100);
+        setTimeout(() => {
+          clearInterval(checkInterval);
+          resolve();
+        }, wait_seconds * 1e3);
+      });
     }
-    case "MOVE_CURSOR": {
-      let newCursorPosition = state.cursorPosition;
-      if (action.direction === "left" && state.cursorPosition > 0) {
-        newCursorPosition--;
-      } else if (action.direction === "right" && state.cursorPosition < state.text.length) {
-        newCursorPosition++;
-      } else if (action.direction === "up") {
-        newCursorPosition = moveToAdjacentLine(state.text, state.cursorPosition, "up");
-      } else if (action.direction === "down") {
-        newCursorPosition = moveToAdjacentLine(state.text, state.cursorPosition, "down");
-      }
-      if (newCursorPosition === state.cursorPosition) {
-        return state;
-      }
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    let stdout = entry.stdout;
+    let stderr = entry.stderr;
+    let truncated = false;
+    if (stdout.length > output_limit) {
+      stdout = "..." + stdout.substring(stdout.length - output_limit);
+      truncated = true;
     }
-    case "MOVE_LINE_START": {
-      const newCursorPosition = getLineStart(state.text, state.cursorPosition);
-      if (newCursorPosition === state.cursorPosition) {
-        return state;
-      }
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    if (stderr.length > output_limit) {
+      stderr = "..." + stderr.substring(stderr.length - output_limit);
+      truncated = true;
     }
-    case "MOVE_LINE_END": {
-      const newCursorPosition = getLineEnd(state.text, state.cursorPosition);
-      if (newCursorPosition === state.cursorPosition) {
-        return state;
-      }
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    const duration = entry.endTime ? (entry.endTime - entry.startTime) / 1e3 : (Date.now() - entry.startTime) / 1e3;
+    return {
+      success: true,
+      command_id,
+      status: entry.status,
+      stdout: stdout || void 0,
+      stderr: stderr || void 0,
+      exit_code: entry.exitCode,
+      duration_seconds: Math.round(duration * 10) / 10,
+      truncated
+    };
+  } catch (error) {
+    return {
+      success: false,
+      command_id: args.command_id || "",
+      status: "error",
+      error: `Unexpected error: ${error.message}`
+    };
+  }
+}
+async function sendCommandInput(args) {
+  try {
+    const { command_id, input } = args;
+    if (!command_id || input === void 0) {
+      return {
+        success: false,
+        error: "command_id and input are required"
+      };
     }
-    case "BACKSPACE": {
-      if (state.cursorPosition > 0) {
-        const newText = state.text.slice(0, state.cursorPosition - 1) + state.text.slice(state.cursorPosition);
-        const newCursorPosition = state.cursorPosition - 1;
-        const newViewStart = adjustView(newCursorPosition, state.viewStart);
-        return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
-      }
-      return state;
-    }
-    case "DELETE": {
-      if (state.cursorPosition < state.text.length) {
-        const newText = state.text.slice(0, state.cursorPosition) + state.text.slice(state.cursorPosition + 1);
-        const newViewStart = adjustView(state.cursorPosition, state.viewStart);
-        return { text: newText, cursorPosition: state.cursorPosition, viewStart: newViewStart };
-      }
-      return state;
-    }
-    case "SUBMIT": {
-      return { text: "", cursorPosition: 0, viewStart: 0 };
-    }
-    case "SET": {
-      const t = action.payload.text.replace(/(\r\n|\r)/gm, "\n");
-      let newCursorPosition;
-      if (typeof action.payload.cursorPosition === "number") {
-        newCursorPosition = Math.min(action.payload.cursorPosition, t.length);
-      } else if (action.payload.moveCursorToEnd ?? true) {
-        newCursorPosition = t.length;
-      } else {
-        newCursorPosition = Math.min(state.cursorPosition, t.length);
-      }
-      const newText = t;
-      const newViewStart = adjustView(newCursorPosition, 0);
-      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        error: `Command with id "${command_id}" not found`
+      };
     }
-    case "SET_CURSOR": {
-      const newCursorPosition = Math.max(0, Math.min(action.payload, state.text.length));
-      if (newCursorPosition === state.cursorPosition) {
-        return state;
-      }
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    if (entry.status !== "running" || !entry.process) {
+      return {
+        success: false,
+        error: `Command is not running (status: ${entry.status})`
+      };
     }
-    default:
-      return state;
+    entry.process.stdin?.write(input);
+    return {
+      success: true,
+      message: `Sent ${input.length} characters to command ${command_id}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to send input: ${error.message}`
+    };
   }
 }
-var useCustomInput = ({ onSubmit, viewWidth, isReadOnly, onInterrupt }) => {
-  const [state, dispatch] = useReducer(
-    (s, a) => inputReducer(s, a, viewWidth),
-    { text: "", cursorPosition: 0, viewStart: 0 }
-  );
-  const inputBuffer = useRef("");
-  const flushScheduled = useRef(false);
-  const flushInputBuffer = useCallback(() => {
-    if (inputBuffer.current.length > 0) {
-      const buffered = inputBuffer.current;
-      inputBuffer.current = "";
-      dispatch({ type: "INPUT", payload: buffered });
+async function killCommand(args) {
+  try {
+    const { command_id } = args;
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        error: `Command with id "${command_id}" not found`
+      };
     }
-    flushScheduled.current = false;
-  }, []);
-  useEffect(() => {
-    return () => {
-      if (flushScheduled.current) {
-        flushInputBuffer();
-      }
+    if (entry.status !== "running" || !entry.process) {
+      return {
+        success: false,
+        error: `Command is not running (status: ${entry.status})`
+      };
+    }
+    entry.process.kill("SIGTERM");
+    entry.status = "killed";
+    entry.endTime = Date.now();
+    return {
+      success: true,
+      message: `Command ${command_id} killed`
     };
-  }, [flushInputBuffer]);
-  useInput(
-    (input, key) => {
-      const hasBackspaceFlag = key.backspace;
-      const hasDeleteFlag = key.delete;
-      const hasBackspaceChar = input === "\x7F" || input === "\b" || input === "\b" || input.charCodeAt(0) === 127 || input.charCodeAt(0) === 8;
-      if (hasBackspaceFlag || hasBackspaceChar) {
-        if (inputBuffer.current.length > 0) {
-          flushInputBuffer();
-        }
-        dispatch({ type: "BACKSPACE" });
-        return;
-      }
-      if (hasDeleteFlag && (key.ctrl || key.meta)) {
-        if (inputBuffer.current.length > 0) {
-          flushInputBuffer();
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to kill command: ${error.message}`
+    };
+  }
+}
+var runningCommands, MAX_OUTPUT_SIZE, MAX_STORED_COMMANDS, OUTPUT_TRUNCATION_MSG, DANGEROUS_PATTERNS, INTERACTIVE_PATTERNS;
+var init_async_command = __esm({
+  "src/app/agent/tools/natives/async_command.ts"() {
+    "use strict";
+    runningCommands = /* @__PURE__ */ new Map();
+    MAX_OUTPUT_SIZE = 3e4;
+    MAX_STORED_COMMANDS = 50;
+    OUTPUT_TRUNCATION_MSG = "\n[OUTPUT TRUNCATED - 30KB/200 lines max]";
+    DANGEROUS_PATTERNS = [
+      // Elevação de privilégios
+      /^sudo\s+/i,
+      /^doas\s+/i,
+      /^su\s+/i,
+      /^pkexec\s+/i,
+      /\|\s*sudo\s+/i,
+      /;\s*sudo\s+/i,
+      /&&\s*sudo\s+/i,
+      // Comandos destrutivos
+      /\brm\s+(-[rf]+\s+)*[\/~]/i,
+      /\brm\s+-[rf]*\s+\*/i,
+      /\bchmod\s+(777|666)\s+\//i,
+      /\bdd\s+.*of=\/dev\/(sd|hd|nvme)/i,
+      /\bmkfs\./i,
+      // Fork bombs
+      /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
+      // Remote code exec
+      /\bcurl\s+.*\|\s*(ba)?sh/i,
+      /\bwget\s+.*\|\s*(ba)?sh/i
+    ];
+    INTERACTIVE_PATTERNS = [
+      /^(vim|vi|nano|emacs|pico)\s*/i,
+      /^(less|more|most)\s*/i,
+      /^(top|htop|btop|atop|nmon)\s*/i,
+      /^(ssh|telnet|ftp|sftp)\s+/i,
+      /^(mysql|psql|redis-cli|mongo|mongosh)\s*$/i,
+      /^(python|python3|node|ruby|irb|lua)\s*$/i,
+      /^(gdb|lldb)\s*/i
+    ];
+  }
+});
+
+// src/app/agent/core/llm/tool_call_normalizer.ts
+import { randomUUID } from "crypto";
+var ToolCallNormalizer;
+var init_tool_call_normalizer = __esm({
+  "src/app/agent/core/llm/tool_call_normalizer.ts"() {
+    "use strict";
+    ToolCallNormalizer = class {
+      /**
+       * Normaliza a mensagem do assistant, convertendo diferentes formatos de tool calls
+       */
+      static normalizeAssistantMessage(message) {
+        if (message.tool_calls && this.isOpenAIFormat(message.tool_calls)) {
+          return message;
         }
-        dispatch({ type: "DELETE" });
-        return;
-      }
-      if (hasDeleteFlag && !key.ctrl && !key.meta) {
-        if (inputBuffer.current.length > 0) {
-          flushInputBuffer();
+        const toolCalls = this.extractToolCalls(message);
+        if (toolCalls.length > 0) {
+          return {
+            role: message.role || "assistant",
+            content: message.content || null,
+            tool_calls: toolCalls
+          };
         }
-        dispatch({ type: "BACKSPACE" });
-        return;
-      }
-      if (inputBuffer.current.length > 0 && (key.ctrl || key.meta || key.escape || key.return || key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.tab || key.shift)) {
-        flushInputBuffer();
+        return message;
       }
-      if (key.escape) {
-        onInterrupt();
-        return;
+      /**
+       * Verifica se já está no formato OpenAI
+       */
+      static isOpenAIFormat(toolCalls) {
+        if (!Array.isArray(toolCalls) || toolCalls.length === 0) return false;
+        const firstCall = toolCalls[0];
+        return typeof firstCall.id === "string" && firstCall.type === "function" && typeof firstCall.function?.name === "string" && typeof firstCall.function?.arguments === "string";
       }
-      if (isReadOnly) {
-        if (key.return && !key.shift) {
-          if (state.text.trim().length > 0) {
-            onSubmit(state.text);
-            dispatch({ type: "SUBMIT" });
+      /**
+       * Extrai tool calls de diversos formatos possíveis
+       */
+      static extractToolCalls(message) {
+        const results = [];
+        if (message.tool_calls && Array.isArray(message.tool_calls)) {
+          for (const call of message.tool_calls) {
+            const normalized = this.normalizeToolCall(call);
+            if (normalized) results.push(normalized);
           }
-          return;
         }
-        if (key.shift && key.return) {
-          dispatch({ type: "NEWLINE" });
-          return;
+        if (typeof message.content === "string" && message.content.trim()) {
+          const extracted = this.extractFromContent(message.content);
+          results.push(...extracted);
         }
-        if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
-        if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
-        if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
-        if (key.downArrow) return dispatch({ type: "MOVE_CURSOR", direction: "down" });
-        if (key.ctrl || key.meta || key.tab) return;
-        inputBuffer.current += input;
-        if (!flushScheduled.current) {
-          flushScheduled.current = true;
-          queueMicrotask(flushInputBuffer);
+        if (message.function_call) {
+          const normalized = this.normalizeToolCall(message.function_call);
+          if (normalized) results.push(normalized);
         }
-        return;
-      }
-      if (key.return && key.shift) {
-        dispatch({ type: "NEWLINE" });
-        return;
+        return results;
       }
-      if (key.return) {
-        if (globalThis.__BLUMA_AT_OPEN__) return;
-        if (globalThis.__BLUMA_SUPPRESS_SUBMIT__) {
-          globalThis.__BLUMA_SUPPRESS_SUBMIT__ = false;
-          return;
+      /**
+       * Normaliza um único tool call para o formato OpenAI
+       */
+      static normalizeToolCall(call) {
+        try {
+          if (call.id && call.function?.name) {
+            return {
+              id: call.id,
+              type: "function",
+              function: {
+                name: call.function.name,
+                arguments: typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments)
+              }
+            };
+          }
+          if (call.name) {
+            return {
+              id: call.id || randomUUID(),
+              type: "function",
+              function: {
+                name: call.name,
+                arguments: typeof call.arguments === "string" ? call.arguments : JSON.stringify(call.arguments || {})
+              }
+            };
+          }
+          if (call.function && typeof call.function === "object") {
+            return {
+              id: call.id || randomUUID(),
+              type: "function",
+              function: {
+                name: call.function.name,
+                arguments: typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments || {})
+              }
+            };
+          }
+          return null;
+        } catch (error) {
+          console.error("Error normalizing tool call:", error, call);
+          return null;
         }
-        if (state.text.trim().length > 0) {
-          onSubmit(state.text);
-          dispatch({ type: "SUBMIT" });
-        }
-        return;
-      }
-      if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
-      if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
-      if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
-      if (key.downArrow) return dispatch({ type: "MOVE_CURSOR", direction: "down" });
-      if (key.ctrl && input === "a") {
-        return dispatch({ type: "MOVE_LINE_START" });
-      }
-      if (key.ctrl && input === "e") {
-        return dispatch({ type: "MOVE_LINE_END" });
-      }
-      if (key.ctrl || key.meta || key.tab) return;
-      inputBuffer.current += input;
-      if (!flushScheduled.current) {
-        flushScheduled.current = true;
-        queueMicrotask(flushInputBuffer);
       }
-    },
-    { isActive: true }
-  );
-  return {
-    text: state.text,
-    cursorPosition: state.cursorPosition,
-    viewStart: state.viewStart,
-    setText: useCallback((t, pos) => {
-      if (inputBuffer.current.length > 0) {
-        flushInputBuffer();
+      /**
+       * Extrai tool calls do content (pode estar em markdown, JSON, etc)
+       */
+      static extractFromContent(content) {
+        const results = [];
+        const cleanContent = content.replace(/```(?:json)?\s*([\s\S]*?)```/g, "$1");
+        const jsonMatches = this.extractJsonObjects(cleanContent);
+        for (const jsonStr of jsonMatches) {
+          try {
+            const parsed = JSON.parse(jsonStr);
+            if (Array.isArray(parsed)) {
+              for (const call of parsed) {
+                const normalized = this.normalizeToolCall(call);
+                if (normalized) results.push(normalized);
+              }
+            } else if (parsed.name || parsed.function) {
+              const normalized = this.normalizeToolCall(parsed);
+              if (normalized) results.push(normalized);
+            } else if (parsed.tool_calls && Array.isArray(parsed.tool_calls)) {
+              for (const call of parsed.tool_calls) {
+                const normalized = this.normalizeToolCall(call);
+                if (normalized) results.push(normalized);
+              }
+            }
+          } catch (e) {
+          }
+        }
+        return results;
       }
-      if (typeof pos === "number") {
-        dispatch({ type: "SET", payload: { text: t, moveCursorToEnd: false, cursorPosition: pos } });
-      } else {
-        dispatch({ type: "SET", payload: { text: t, moveCursorToEnd: true } });
+      /**
+       * Extrai objetos JSON de uma string (suporta múltiplos objetos)
+       */
+      static extractJsonObjects(text) {
+        const results = [];
+        let depth = 0;
+        let start = -1;
+        for (let i = 0; i < text.length; i++) {
+          if (text[i] === "{") {
+            if (depth === 0) start = i;
+            depth++;
+          } else if (text[i] === "}") {
+            depth--;
+            if (depth === 0 && start !== -1) {
+              results.push(text.substring(start, i + 1));
+              start = -1;
+            }
+          }
+        }
+        return results;
       }
-    }, [flushInputBuffer]),
-    setCursor: useCallback((pos) => {
-      if (inputBuffer.current.length > 0) {
-        flushInputBuffer();
+      /**
+       * Valida se um tool call normalizado é válido
+       */
+      static isValidToolCall(call) {
+        return !!(call.id && call.type === "function" && call.function?.name && typeof call.function.arguments === "string");
       }
-      dispatch({ type: "SET_CURSOR", payload: pos });
-    }, [flushInputBuffer])
+    };
+  }
+});
+
+// src/main.ts
+import React10 from "react";
+import { render } from "ink";
+import { EventEmitter as EventEmitter2 } from "events";
+import { v4 as uuidv43 } from "uuid";
+
+// src/app/ui/App.tsx
+import { useState as useState6, useEffect as useEffect5, useRef as useRef4, useCallback as useCallback2, memo as memo10 } from "react";
+import { Box as Box16, Text as Text15, Static } from "ink";
+
+// src/app/ui/layout.tsx
+import { Box, Text } from "ink";
+import { memo } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var HeaderComponent = ({
+  sessionId: sessionId2,
+  workdir
+}) => {
+  const dirName = workdir.split("/").pop() || workdir;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "magenta", bold: true, children: "bluma \u2014 coding agent" }) }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "cwd " }),
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: dirName }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " | " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "session " }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: sessionId2.slice(0, 8) })
+    ] })
+  ] });
+};
+var Header = memo(HeaderComponent);
+var SessionInfoComponent = ({
+  sessionId: sessionId2,
+  workdir,
+  toolsCount,
+  mcpStatus
+}) => /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+  /* @__PURE__ */ jsx(Text, { dimColor: true, children: "mcp " }),
+  /* @__PURE__ */ jsx(Text, { color: mcpStatus === "connected" ? "green" : "yellow", children: mcpStatus === "connected" ? "+" : "-" }),
+  toolsCount !== null && /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+    " ",
+    toolsCount,
+    " tools"
+  ] }) })
+] });
+var SessionInfo = memo(SessionInfoComponent);
+var TaskStatusBarComponent = ({
+  taskName,
+  mode,
+  status
+}) => {
+  const modeColors = {
+    PLANNING: "blue",
+    EXECUTION: "green",
+    VERIFICATION: "yellow"
   };
+  return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { color: modeColors[mode], bold: true, children: [
+      "[",
+      mode.charAt(0),
+      "]"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      taskName
+    ] }),
+    status && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      " - ",
+      status
+    ] })
+  ] });
 };
+var TaskStatusBar = memo(TaskStatusBarComponent);
 
 // src/app/ui/components/InputPrompt.tsx
-import { useEffect as useEffect3, useMemo, useState as useState2, memo as memo2 } from "react";
-import { EventEmitter } from "events";
-
-// src/app/ui/utils/slashRegistry.ts
-var getSlashCommands = () => [
-  { name: "/help", description: "list commands" },
-  { name: "/mcp", description: "list tools connected via MCP" },
-  { name: "/tools", description: "list native tools" },
-  { name: "/init", description: "create a new BluMa.md file with codebase documentation" },
-  { name: "/clear", description: "clear history" }
-];
-var filterSlashCommands = (query) => {
-  const list = getSlashCommands();
-  const q = (query || "").toLowerCase();
-  if (!q) return list;
-  const scored = list.map((c) => {
-    const name = c.name.toLowerCase();
-    const desc = c.description.toLowerCase();
-    const isPrefix = name.startsWith(q);
-    const nameIdx = name.indexOf(q);
-    const descIdx = desc.indexOf(q);
-    let tier = 3;
-    let scorePrimary = 0;
-    let scoreSecondary = Number.MAX_SAFE_INTEGER;
-    let scoreTertiary = name.length;
-    if (isPrefix) {
-      tier = 0;
-      scorePrimary = q.length * -1;
-      scoreSecondary = 0;
-    } else if (nameIdx >= 0) {
-      tier = 1;
-      scorePrimary = 0;
-      scoreSecondary = nameIdx;
-    } else if (descIdx >= 0) {
-      tier = 2;
-      scorePrimary = 0;
-      scoreSecondary = descIdx;
-    }
-    return { cmd: c, tier, scorePrimary, scoreSecondary, scoreTertiary };
-  }).filter((s) => s.tier !== 3).sort((a, b) => {
-    if (a.tier !== b.tier) return a.tier - b.tier;
-    if (a.scorePrimary !== b.scorePrimary) return a.scorePrimary - b.scorePrimary;
-    if (a.scoreSecondary !== b.scoreSecondary) return a.scoreSecondary - b.scoreSecondary;
-    if (a.scoreTertiary !== b.scoreTertiary) return a.scoreTertiary - b.scoreTertiary;
-    return a.cmd.name.localeCompare(b.cmd.name);
-  });
-  return scored.map((s) => s.cmd);
-};
+import { Box as Box2, Text as Text2, useStdout, useInput as useInput2 } from "ink";
 
-// src/app/ui/hooks/useAtCompletion.ts
-import { useEffect as useEffect2, useRef as useRef2, useState } from "react";
-import fs from "fs";
-import path from "path";
-var MAX_RESULTS = 50;
-var DEFAULT_RECURSIVE_DEPTH = 2;
-function listPathSuggestions(baseDir, pattern) {
-  const raw = pattern || "";
-  const patternEndsWithSlash = raw.endsWith("/");
-  const relDir = raw.replace(/^\/+|\/+$/g, "");
-  const filterPrefix = patternEndsWithSlash ? "" : relDir.split("/").slice(-1)[0] || "";
-  const listDir = path.resolve(baseDir, relDir || ".");
-  const results = [];
-  const IGNORED_DIRS = ["node_modules", ".git", ".venv", "dist", "build"];
-  const IGNORED_EXTS = [".pyc", ".class", ".o", ".map", ".log", ".tmp"];
-  function isIgnoredName(name) {
-    if (!name) return false;
-    if (IGNORED_DIRS.includes(name)) return true;
-    if (name.startsWith(".")) return true;
-    return false;
+// src/app/ui/utils/useSimpleInputBuffer.ts
+import { useReducer, useRef, useCallback, useEffect } from "react";
+import { useInput } from "ink";
+function getLineStart(text, cursorPos) {
+  let pos = cursorPos - 1;
+  while (pos >= 0 && text[pos] !== "\n") {
+    pos--;
   }
-  function isIgnoredFile(name) {
-    if (!name) return false;
-    for (const e of IGNORED_EXTS) if (name.endsWith(e)) return true;
-    return false;
+  return pos + 1;
+}
+function getLineEnd(text, cursorPos) {
+  let pos = cursorPos;
+  while (pos < text.length && text[pos] !== "\n") {
+    pos++;
   }
-  function pushEntry(entryPath, label, isDir) {
-    if (results.length >= MAX_RESULTS) return;
-    const clean = label.split(path.sep).join("/").replace(/[]+/g, "");
-    results.push({ label: clean + (isDir ? "/" : ""), fullPath: entryPath, isDir });
+  return pos;
+}
+function moveToAdjacentLine(text, cursorPos, direction) {
+  const currentLineStart = getLineStart(text, cursorPos);
+  const currentLineEnd = getLineEnd(text, cursorPos);
+  const column = cursorPos - currentLineStart;
+  if (direction === "up") {
+    if (currentLineStart === 0) return cursorPos;
+    const prevLineEnd = currentLineStart - 1;
+    const prevLineStart = getLineStart(text, prevLineEnd);
+    const prevLineLength = prevLineEnd - prevLineStart;
+    return prevLineStart + Math.min(column, prevLineLength);
+  } else {
+    if (currentLineEnd === text.length) return cursorPos;
+    const nextLineStart = currentLineEnd + 1;
+    const nextLineEnd = getLineEnd(text, nextLineStart);
+    const nextLineLength = nextLineEnd - nextLineStart;
+    return nextLineStart + Math.min(column, nextLineLength);
   }
-  try {
-    if (raw.length === 0 || patternEndsWithSlash) {
-      const queue = [{ dir: listDir, depth: 0, rel: relDir }];
-      while (queue.length && results.length < MAX_RESULTS) {
-        const node = queue.shift();
-        try {
-          const entries = fs.readdirSync(node.dir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (isIgnoredName(entry.name)) continue;
-            const entryAbs = path.join(node.dir, entry.name);
-            const entryRel = node.rel ? path.posix.join(node.rel, entry.name) : entry.name;
-            if (entryRel.split("/").includes("node_modules")) continue;
-            if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
-            pushEntry(entryAbs, entryRel, entry.isDirectory());
-            if (entry.isDirectory() && node.depth < DEFAULT_RECURSIVE_DEPTH) {
-              queue.push({ dir: entryAbs, depth: node.depth + 1, rel: node.rel ? node.rel + "/" + entry.name : entry.name + "/" });
-            }
-            if (results.length >= MAX_RESULTS) break;
-          }
-        } catch (e) {
-        }
+}
+function inputReducer(state, action, viewWidth) {
+  const adjustView = (newCursorPos, currentViewStart) => {
+    if (newCursorPos < currentViewStart) {
+      return newCursorPos;
+    }
+    if (newCursorPos >= currentViewStart + viewWidth) {
+      return newCursorPos - viewWidth + 1;
+    }
+    return currentViewStart;
+  };
+  switch (action.type) {
+    case "INPUT": {
+      const cleanInput = action.payload.replace(/(\r\n|\r)/gm, "\n");
+      const newText = state.text.slice(0, state.cursorPosition) + cleanInput + state.text.slice(state.cursorPosition);
+      const newCursorPosition = state.cursorPosition + cleanInput.length;
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      if (newText === state.text && newCursorPosition === state.cursorPosition) {
+        return state;
       }
-    } else {
-      const entries = fs.readdirSync(listDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (filterPrefix && !entry.name.startsWith(filterPrefix)) continue;
-        if (isIgnoredName(entry.name)) continue;
-        if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
-        const entryAbs = path.join(listDir, entry.name);
-        const label = relDir ? path.posix.join(relDir, entry.name) : entry.name;
-        pushEntry(entryAbs, label, entry.isDirectory());
-        if (results.length >= MAX_RESULTS) break;
+      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "NEWLINE": {
+      const newText = state.text.slice(0, state.cursorPosition) + "\n" + state.text.slice(state.cursorPosition);
+      const newCursorPosition = state.cursorPosition + 1;
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "MOVE_CURSOR": {
+      let newCursorPosition = state.cursorPosition;
+      if (action.direction === "left" && state.cursorPosition > 0) {
+        newCursorPosition--;
+      } else if (action.direction === "right" && state.cursorPosition < state.text.length) {
+        newCursorPosition++;
+      } else if (action.direction === "up") {
+        newCursorPosition = moveToAdjacentLine(state.text, state.cursorPosition, "up");
+      } else if (action.direction === "down") {
+        newCursorPosition = moveToAdjacentLine(state.text, state.cursorPosition, "down");
       }
+      if (newCursorPosition === state.cursorPosition) {
+        return state;
+      }
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
     }
-  } catch (e) {
-  }
-  return results.slice(0, MAX_RESULTS);
-}
-function useAtCompletion({
-  cwd,
-  text,
-  cursorPosition,
-  setText
-}) {
-  const [open, setOpen] = useState(false);
-  const [selected, setSelected] = useState(0);
-  const [suggestions, setSuggestions] = useState([]);
-  const lastQuery = useRef2("");
-  function scanForAt(text2, pos) {
-    const before = text2.slice(0, pos);
-    const m = before.match(/@([\w\/.\-_]*)$/);
-    if (!m) return { pattern: null, insertStart: -1 };
-    return { pattern: m[1] || "", insertStart: m.index + 1 };
-  }
-  function update(newText, newCursor) {
-    const res = scanForAt(newText, newCursor);
-    if (res.pattern !== null && res.pattern.length >= 0) {
-      setOpen(true);
-      globalThis.__BLUMA_AT_OPEN__ = true;
-      const suggs = listPathSuggestions(cwd, res.pattern);
-      setSuggestions(suggs);
-      setSelected(0);
-      lastQuery.current = res.pattern;
-    } else {
-      setOpen(false);
-      globalThis.__BLUMA_AT_OPEN__ = false;
-      setSuggestions([]);
+    case "MOVE_LINE_START": {
+      const newCursorPosition = getLineStart(state.text, state.cursorPosition);
+      if (newCursorPosition === state.cursorPosition) {
+        return state;
+      }
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
     }
-  }
-  useEffect2(() => {
-    update(text, cursorPosition);
-  }, [text, cursorPosition, cwd]);
-  function insertAtSelection() {
-    if (!open || !suggestions[selected]) return;
-    const res = scanForAt(text, cursorPosition);
-    if (!res || res.insertStart < 0) return;
-    let chosen = suggestions[selected].label;
-    const isDir = suggestions[selected].isDir;
-    chosen = chosen.replace(/\\/g, "/").replace(/\|/g, "");
-    let insertVal = chosen.replace(/\/+$/g, "");
-    const currentPattern = res.pattern || "";
-    if (currentPattern.length > 0) {
-      const normalizedPattern = currentPattern.replace(/\/+$/g, "");
-      if (insertVal.startsWith(normalizedPattern)) {
-        insertVal = insertVal.slice(normalizedPattern.length);
-        insertVal = insertVal.replace(/^\/+/, "");
+    case "MOVE_LINE_END": {
+      const newCursorPosition = getLineEnd(state.text, state.cursorPosition);
+      if (newCursorPosition === state.cursorPosition) {
+        return state;
       }
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
     }
-    insertVal = insertVal.split("\\").join("/");
-    if (isDir && !insertVal.endsWith("/")) insertVal = insertVal + "/";
-    const pattern = res.pattern || "";
-    const lastSlash = pattern.lastIndexOf("/");
-    const segmentOffset = lastSlash >= 0 ? lastSlash + 1 : 0;
-    const segmentStart = res.insertStart + segmentOffset;
-    const before = text.slice(0, segmentStart);
-    const after = text.slice(cursorPosition);
-    const newText = before + insertVal + after;
-    const finalText = newText + " ";
-    setText(finalText, finalText.length);
-    globalThis.__BLUMA_FORCE_CURSOR_END__ = true;
-    update(finalText, finalText.length);
-    if (isDir) {
-      setOpen(false);
-      setSuggestions([]);
-      setTimeout(() => {
-        setOpen(true);
-        update(finalText, finalText.length);
-      }, 0);
-    } else {
-      setOpen(false);
-      setSuggestions([]);
+    case "BACKSPACE": {
+      if (state.cursorPosition > 0) {
+        const newText = state.text.slice(0, state.cursorPosition - 1) + state.text.slice(state.cursorPosition);
+        const newCursorPosition = state.cursorPosition - 1;
+        const newViewStart = adjustView(newCursorPosition, state.viewStart);
+        return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+      }
+      return state;
     }
+    case "DELETE": {
+      if (state.cursorPosition < state.text.length) {
+        const newText = state.text.slice(0, state.cursorPosition) + state.text.slice(state.cursorPosition + 1);
+        const newViewStart = adjustView(state.cursorPosition, state.viewStart);
+        return { text: newText, cursorPosition: state.cursorPosition, viewStart: newViewStart };
+      }
+      return state;
+    }
+    case "SUBMIT": {
+      return { text: "", cursorPosition: 0, viewStart: 0 };
+    }
+    case "SET": {
+      const t = action.payload.text.replace(/(\r\n|\r)/gm, "\n");
+      let newCursorPosition;
+      if (typeof action.payload.cursorPosition === "number") {
+        newCursorPosition = Math.min(action.payload.cursorPosition, t.length);
+      } else if (action.payload.moveCursorToEnd ?? true) {
+        newCursorPosition = t.length;
+      } else {
+        newCursorPosition = Math.min(state.cursorPosition, t.length);
+      }
+      const newText = t;
+      const newViewStart = adjustView(newCursorPosition, 0);
+      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "SET_CURSOR": {
+      const newCursorPosition = Math.max(0, Math.min(action.payload, state.text.length));
+      if (newCursorPosition === state.cursorPosition) {
+        return state;
+      }
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    default:
+      return state;
   }
-  function close() {
-    setOpen(false);
-    setSuggestions([]);
-  }
-  return { open, suggestions, selected, setSelected, insertAtSelection, close, update };
 }
-
-// src/app/ui/components/InputPrompt.tsx
-import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var uiEventBus = global.__bluma_ui_eventbus__ || new EventEmitter();
-global.__bluma_ui_eventbus__ = uiEventBus;
-var TextLine = memo2(({
-  line,
-  lineIndex,
-  cursorLine,
-  cursorCol,
-  showCursor
-}) => {
-  const isCursorLine = lineIndex === cursorLine;
-  if (!isCursorLine || !showCursor) {
-    return /* @__PURE__ */ jsx2(Text2, { children: line });
-  }
-  const before = line.slice(0, cursorCol);
-  const char = line[cursorCol] || " ";
-  const after = line.slice(cursorCol + 1);
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    before,
-    /* @__PURE__ */ jsx2(Text2, { inverse: true, color: "white", children: char }),
-    after
-  ] });
-}, (prev, next) => {
-  if (prev.line !== next.line) return false;
-  if (prev.showCursor !== next.showCursor) return false;
-  const prevIsCursorLine = prev.lineIndex === prev.cursorLine;
-  const nextIsCursorLine = next.lineIndex === next.cursorLine;
-  if (prevIsCursorLine !== nextIsCursorLine) return false;
-  if (nextIsCursorLine && prev.cursorCol !== next.cursorCol) return false;
-  return true;
-});
-TextLine.displayName = "TextLine";
-var PathSuggestions = memo2(({
-  suggestions,
-  selected
-}) => {
-  const VISIBLE = 7;
-  const total = suggestions.length;
-  const sel = Math.max(0, Math.min(selected, total - 1));
-  let start = Math.max(0, sel - Math.floor(VISIBLE / 2));
-  if (start + VISIBLE > total) start = Math.max(0, total - VISIBLE);
-  const windowItems = suggestions.slice(start, start + VISIBLE);
-  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, height: Math.min(VISIBLE, total), children: windowItems.map((s, idx) => {
-    const realIdx = start + idx;
-    const isSelected = realIdx === selected;
-    return /* @__PURE__ */ jsxs2(Box2, { paddingLeft: 1, paddingY: 0, children: [
-      /* @__PURE__ */ jsx2(Text2, { color: isSelected ? "magenta" : "gray", children: isSelected ? "\u276F " : "  " }),
-      /* @__PURE__ */ jsx2(Text2, { color: isSelected ? "magenta" : "white", bold: isSelected, dimColor: !isSelected, children: s.label })
-    ] }, s.fullPath);
-  }) });
-});
-PathSuggestions.displayName = "PathSuggestions";
-var SlashSuggestions = memo2(({
-  suggestions,
-  selectedIndex
-}) => /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: suggestions.map((s, idx) => {
-  const isSelected = idx === selectedIndex;
-  return /* @__PURE__ */ jsxs2(Box2, { paddingLeft: 1, paddingY: 0, children: [
-    /* @__PURE__ */ jsx2(Text2, { color: isSelected ? "magenta" : "gray", children: isSelected ? "\u276F " : "  " }),
-    /* @__PURE__ */ jsxs2(Text2, { color: isSelected ? "magenta" : "white", bold: isSelected, dimColor: !isSelected, children: [
-      s.name,
-      " ",
-      /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
-        "- ",
-        s.description
-      ] })
-    ] })
-  ] }, s.name);
-}) }));
-SlashSuggestions.displayName = "SlashSuggestions";
-var Footer = memo2(({ isReadOnly }) => /* @__PURE__ */ jsx2(Box2, { paddingX: 1, justifyContent: "center", children: /* @__PURE__ */ jsx2(Text2, { color: "gray", dimColor: true, children: isReadOnly ? "ctrl+c to exit | Enter to send message | Shift+Enter for new line | esc interrupt" : "ctrl+c to exit | Enter to submit | Shift+Enter for new line | /help commands | esc interrupt" }) }));
-Footer.displayName = "Footer";
-var TextLinesRenderer = memo2(({
-  lines,
-  cursorLine,
-  cursorCol,
-  showCursor,
-  showPlaceholder,
-  placeholder
-}) => {
-  return /* @__PURE__ */ jsx2(Fragment2, { children: lines.map((line, idx) => {
-    const isFirstLine = idx === 0;
-    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", paddingX: 1, children: [
-      isFirstLine && /* @__PURE__ */ jsxs2(Text2, { color: "white", children: [
-        ">",
-        " "
-      ] }),
-      !isFirstLine && /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
-        "\u2502",
-        " "
-      ] }),
-      showPlaceholder && isFirstLine && line.length === 0 ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: placeholder }) : /* @__PURE__ */ jsx2(
-        TextLine,
-        {
-          line,
-          lineIndex: idx,
-          cursorLine,
-          cursorCol,
-          showCursor
-        }
-      )
-    ] }, idx);
-  }) });
-});
-TextLinesRenderer.displayName = "TextLinesRenderer";
-var InputPrompt = memo2(({
-  onSubmit,
-  isReadOnly,
-  onInterrupt,
-  disableWhileProcessing = false
-}) => {
-  const { stdout } = useStdout();
-  const [viewWidth] = useState2(() => stdout.columns - 6);
-  const [slashOpen, setSlashOpen] = useState2(false);
-  const [slashIndex, setSlashIndex] = useState2(0);
-  const permissiveOnSubmit = (value) => {
-    const trimmed = (value || "").trim();
-    if (isReadOnly) {
-      if (trimmed.length > 0) {
-        uiEventBus.emit("user_overlay", { kind: "message", payload: trimmed, ts: Date.now() });
-      }
-      return;
+var useCustomInput = ({ onSubmit, viewWidth, isReadOnly, onInterrupt }) => {
+  const [state, dispatch] = useReducer(
+    (s, a) => inputReducer(s, a, viewWidth),
+    { text: "", cursorPosition: 0, viewStart: 0 }
+  );
+  const inputBuffer = useRef("");
+  const flushScheduled = useRef(false);
+  const flushInputBuffer = useCallback(() => {
+    if (inputBuffer.current.length > 0) {
+      const buffered = inputBuffer.current;
+      inputBuffer.current = "";
+      dispatch({ type: "INPUT", payload: buffered });
     }
-    onSubmit(value);
-  };
-  const { text, cursorPosition, setText } = useCustomInput({
-    onSubmit: (value) => {
-      if (disableWhileProcessing && isReadOnly) return;
-      if (pathAutocomplete.open) return;
-      permissiveOnSubmit(value);
-    },
-    viewWidth,
-    isReadOnly,
-    onInterrupt
-  });
-  const linesData = useMemo(() => {
-    const lines = text.split("\n");
-    let remainingChars = cursorPosition;
-    let cursorLine = 0;
-    let cursorCol = 0;
-    for (let i = 0; i < lines.length; i++) {
-      const lineLength = lines[i].length;
-      if (remainingChars <= lineLength) {
-        cursorLine = i;
-        cursorCol = remainingChars;
-        break;
+    flushScheduled.current = false;
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (flushScheduled.current) {
+        flushInputBuffer();
       }
-      remainingChars -= lineLength + 1;
-      if (i === lines.length - 1) {
-        cursorLine = i;
-        cursorCol = lineLength;
+    };
+  }, [flushInputBuffer]);
+  useInput(
+    (input, key) => {
+      const hasBackspaceFlag = key.backspace;
+      const hasDeleteFlag = key.delete;
+      const hasBackspaceChar = input === "\x7F" || input === "\b" || input === "\b" || input.charCodeAt(0) === 127 || input.charCodeAt(0) === 8;
+      if (hasBackspaceFlag || hasBackspaceChar) {
+        if (inputBuffer.current.length > 0) {
+          flushInputBuffer();
+        }
+        dispatch({ type: "BACKSPACE" });
+        return;
       }
-    }
-    return { lines, cursorLine, cursorCol, totalLines: lines.length };
-  }, [text, cursorPosition]);
-  const displayData = linesData;
-  const placeholder = isReadOnly ? " Press Esc to cancel | Enter message while agent runs" : "";
-  const showPlaceholder = text.length === 0 && isReadOnly;
-  const slashQuery = useMemo(() => text.startsWith("/") ? text : "", [text]);
-  const slashSuggestions = useMemo(() => {
-    if (!slashQuery) return [];
-    return filterSlashCommands(slashQuery);
-  }, [slashQuery]);
-  useEffect3(() => {
-    if (isReadOnly) {
-      setSlashOpen(false);
-      return;
-    }
-    if (text.startsWith("/")) {
-      setSlashOpen(true);
-      setSlashIndex(0);
-    } else {
-      setSlashOpen(false);
-    }
-  }, [text, isReadOnly]);
-  useInput2((input, key) => {
-    if (!slashOpen) return;
-    if (key.downArrow) {
-      setSlashIndex((i) => Math.min(i + 1, Math.max(0, slashSuggestions.length - 1)));
-    } else if (key.upArrow) {
-      setSlashIndex((i) => Math.max(i - 1, 0));
-    } else if (key.return) {
-      const choice = slashSuggestions[slashIndex];
-      if (choice) {
-        setSlashOpen(false);
-        try {
-          setText(`${choice.name} `);
-        } catch (e) {
-          permissiveOnSubmit(`${choice.name} `);
+      if (hasDeleteFlag && (key.ctrl || key.meta)) {
+        if (inputBuffer.current.length > 0) {
+          flushInputBuffer();
         }
+        dispatch({ type: "DELETE" });
+        return;
       }
-    } else if (key.escape) {
-      setSlashOpen(false);
-    }
-  }, { isActive: slashOpen });
-  useEffect3(() => {
-    if (globalThis.__BLUMA_FORCE_CURSOR_END__) {
-      setText(text, text.length);
-      delete globalThis.__BLUMA_FORCE_CURSOR_END__;
-    }
-  }, [text, setText]);
-  const cwd = process.cwd();
-  const pathAutocomplete = useAtCompletion({ cwd, text, cursorPosition, setText });
-  useInput2((input, key) => {
-    if (key.backspace || key.delete || key.ctrl || key.meta) return;
-    if (pathAutocomplete.open) {
-      if (key.downArrow) {
-        pathAutocomplete.setSelected((i) => Math.min(i + 1, Math.max(0, pathAutocomplete.suggestions.length - 1)));
+      if (hasDeleteFlag && !key.ctrl && !key.meta) {
+        if (inputBuffer.current.length > 0) {
+          flushInputBuffer();
+        }
+        dispatch({ type: "BACKSPACE" });
         return;
-      } else if (key.upArrow) {
-        pathAutocomplete.setSelected((i) => Math.max(i - 1, 0));
+      }
+      if (inputBuffer.current.length > 0 && (key.ctrl || key.meta || key.escape || key.return || key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.tab || key.shift)) {
+        flushInputBuffer();
+      }
+      if (key.escape) {
+        onInterrupt();
         return;
-      } else if (key.return || key.tab) {
-        const selected = pathAutocomplete.suggestions[pathAutocomplete.selected];
-        if (selected) {
-          const before = text.slice(0, cursorPosition);
-          const m = before.match(/@([\w\/.\-_]*)$/);
-          if (m) {
-            globalThis.__BLUMA_SUPPRESS_SUBMIT__ = true;
-            pathAutocomplete.insertAtSelection();
-            return;
+      }
+      if (isReadOnly) {
+        if (key.return && !key.shift) {
+          if (state.text.trim().length > 0) {
+            onSubmit(state.text);
+            dispatch({ type: "SUBMIT" });
           }
+          return;
+        }
+        if (key.shift && key.return) {
+          dispatch({ type: "NEWLINE" });
+          return;
+        }
+        if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
+        if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
+        if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
+        if (key.downArrow) return dispatch({ type: "MOVE_CURSOR", direction: "down" });
+        if (key.ctrl || key.meta || key.tab) return;
+        inputBuffer.current += input;
+        if (!flushScheduled.current) {
+          flushScheduled.current = true;
+          queueMicrotask(flushInputBuffer);
         }
         return;
-      } else if (key.escape) {
-        pathAutocomplete.close();
+      }
+      if (key.return && key.shift) {
+        dispatch({ type: "NEWLINE" });
         return;
       }
-      return;
-    }
-  }, { isActive: true });
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
-    disableWhileProcessing ? /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", paddingX: 1, flexWrap: "nowrap", children: [
-      /* @__PURE__ */ jsxs2(Text2, { color: "white", children: [
-        ">",
-        " "
-      ] }),
-      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "ctrl+c to exit" })
-    ] }) }) : /* @__PURE__ */ jsxs2(Fragment2, { children: [
-      /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsx2(
-        TextLinesRenderer,
-        {
-          lines: displayData.lines,
-          cursorLine: displayData.cursorLine,
-          cursorCol: displayData.cursorCol,
-          showCursor: !isReadOnly,
-          showPlaceholder,
-          placeholder
-        }
-      ) }),
-      pathAutocomplete.open && pathAutocomplete.suggestions.length > 0 && /* @__PURE__ */ jsx2(
-        PathSuggestions,
-        {
-          suggestions: pathAutocomplete.suggestions,
-          selected: pathAutocomplete.selected
+      if (key.return) {
+        if (globalThis.__BLUMA_AT_OPEN__) return;
+        if (globalThis.__BLUMA_SUPPRESS_SUBMIT__) {
+          globalThis.__BLUMA_SUPPRESS_SUBMIT__ = false;
+          return;
         }
-      ),
-      slashOpen && slashSuggestions.length > 0 && /* @__PURE__ */ jsx2(
-        SlashSuggestions,
-        {
-          suggestions: slashSuggestions,
-          selectedIndex: slashIndex
+        if (state.text.trim().length > 0) {
+          onSubmit(state.text);
+          dispatch({ type: "SUBMIT" });
         }
-      )
-    ] }),
-    /* @__PURE__ */ jsx2(Footer, { isReadOnly })
-  ] });
-});
-InputPrompt.displayName = "InputPrompt";
-
-// src/app/ui/ConfirmationPrompt.tsx
-import { memo as memo4 } from "react";
-import { Box as Box6, Text as Text6 } from "ink";
-
-// src/app/ui/InteractiveMenu.tsx
-import { useState as useState3, memo as memo3 } from "react";
-import { Box as Box3, Text as Text3, useInput as useInput3 } from "ink";
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-var InteractiveMenuComponent = ({ onDecision }) => {
-  const options = [
-    { key: "y", label: "yes", value: "accept", color: "green" },
-    { key: "n", label: "no", value: "decline", color: "red" },
-    { key: "a", label: "always", value: "accept_always", color: "yellow" }
-  ];
-  const [selected, setSelected] = useState3(0);
-  useInput3((input, key) => {
-    if (key.upArrow || key.leftArrow) {
-      setSelected((i) => i > 0 ? i - 1 : options.length - 1);
-    }
-    if (key.downArrow || key.rightArrow) {
-      setSelected((i) => i < options.length - 1 ? i + 1 : 0);
-    }
-    if (key.escape) {
-      onDecision("decline");
-    }
-    if (key.return) {
-      onDecision(options[selected].value);
-    }
-    const opt = options.find((o) => o.key === input.toLowerCase());
-    if (opt) {
-      onDecision(opt.value);
-    }
-  });
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [
-    /* @__PURE__ */ jsxs3(Box3, { children: [
-      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "approve? " }),
-      options.map((opt, idx) => {
-        const isSelected = idx === selected;
-        return /* @__PURE__ */ jsx3(Box3, { marginRight: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: isSelected ? opt.color : "gray", bold: isSelected, children: [
-          "[",
-          opt.key,
-          "]",
-          opt.label
-        ] }) }, opt.value);
-      })
-    ] }),
-    /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "arrows to select, enter to confirm, esc to cancel" }) })
-  ] });
-};
-var InteractiveMenu = memo3(InteractiveMenuComponent);
-
-// src/app/ui/components/promptRenderers.tsx
-import { Box as Box5, Text as Text5 } from "ink";
-import path2 from "path";
-
-// src/app/ui/components/SimpleDiff.tsx
-import { Box as Box4, Text as Text4 } from "ink";
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-var SimpleDiff = ({ text, maxHeight }) => {
-  const allLines = (text || "").split("\n").filter((line) => line !== "");
-  const isTruncated = maxHeight > 0 && allLines.length > maxHeight;
-  const linesToRender = isTruncated ? allLines.slice(-maxHeight) : allLines;
-  const hiddenCount = allLines.length - linesToRender.length;
-  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingX: 2, children: [
-    isTruncated && /* @__PURE__ */ jsx4(Box4, { marginBottom: 0, children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
-      "\u22EF ",
-      hiddenCount,
-      " lines hidden"
-    ] }) }),
-    linesToRender.map((line, index) => {
-      if (line.startsWith("---") || line.startsWith("+++")) {
-        return null;
+        return;
       }
-      let color = "white";
-      let prefix = "";
-      if (line.startsWith("+")) {
-        color = "green";
-        prefix = "+ ";
-      } else if (line.startsWith("-")) {
-        color = "red";
-        prefix = "- ";
-      } else if (line.startsWith("@@")) {
-        color = "cyan";
-        prefix = "";
+      if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
+      if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
+      if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
+      if (key.downArrow) return dispatch({ type: "MOVE_CURSOR", direction: "down" });
+      if (key.ctrl && input === "a") {
+        return dispatch({ type: "MOVE_LINE_START" });
+      }
+      if (key.ctrl && input === "e") {
+        return dispatch({ type: "MOVE_LINE_END" });
+      }
+      if (key.ctrl || key.meta || key.tab) return;
+      inputBuffer.current += input;
+      if (!flushScheduled.current) {
+        flushScheduled.current = true;
+        queueMicrotask(flushInputBuffer);
+      }
+    },
+    { isActive: true }
+  );
+  return {
+    text: state.text,
+    cursorPosition: state.cursorPosition,
+    viewStart: state.viewStart,
+    setText: useCallback((t, pos) => {
+      if (inputBuffer.current.length > 0) {
+        flushInputBuffer();
+      }
+      if (typeof pos === "number") {
+        dispatch({ type: "SET", payload: { text: t, moveCursorToEnd: false, cursorPosition: pos } });
       } else {
-        color = "gray";
-        prefix = "  ";
+        dispatch({ type: "SET", payload: { text: t, moveCursorToEnd: true } });
       }
-      return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color, children: [
-        prefix,
-        line.replace(/^[+\-]/, "")
-      ] }) }, index);
-    })
-  ] });
+    }, [flushInputBuffer]),
+    setCursor: useCallback((pos) => {
+      if (inputBuffer.current.length > 0) {
+        flushInputBuffer();
+      }
+      dispatch({ type: "SET_CURSOR", payload: pos });
+    }, [flushInputBuffer])
+  };
 };
 
-// src/app/ui/components/promptRenderers.tsx
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
-var getBasePath = (filePath) => {
-  return path2.basename(filePath);
-};
-var renderShellCommand = ({ toolCall }) => {
-  let command = "";
-  try {
-    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
-    command = args.command || "[command not found]";
-  } catch (e) {
-    command = "Error parsing command";
-  }
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " shell" })
-    ] }),
-    /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: command }) })
-  ] });
+// src/app/ui/components/InputPrompt.tsx
+import { useEffect as useEffect3, useMemo, useState as useState2, memo as memo2 } from "react";
+import { EventEmitter } from "events";
+
+// src/app/ui/utils/slashRegistry.ts
+var getSlashCommands = () => [
+  { name: "/help", description: "list commands" },
+  { name: "/mcp", description: "list tools connected via MCP" },
+  { name: "/tools", description: "list native tools" },
+  { name: "/init", description: "create a new BluMa.md file with codebase documentation" },
+  { name: "/clear", description: "clear history" }
+];
+var filterSlashCommands = (query) => {
+  const list = getSlashCommands();
+  const q = (query || "").toLowerCase();
+  if (!q) return list;
+  const scored = list.map((c) => {
+    const name = c.name.toLowerCase();
+    const desc = c.description.toLowerCase();
+    const isPrefix = name.startsWith(q);
+    const nameIdx = name.indexOf(q);
+    const descIdx = desc.indexOf(q);
+    let tier = 3;
+    let scorePrimary = 0;
+    let scoreSecondary = Number.MAX_SAFE_INTEGER;
+    let scoreTertiary = name.length;
+    if (isPrefix) {
+      tier = 0;
+      scorePrimary = q.length * -1;
+      scoreSecondary = 0;
+    } else if (nameIdx >= 0) {
+      tier = 1;
+      scorePrimary = 0;
+      scoreSecondary = nameIdx;
+    } else if (descIdx >= 0) {
+      tier = 2;
+      scorePrimary = 0;
+      scoreSecondary = descIdx;
+    }
+    return { cmd: c, tier, scorePrimary, scoreSecondary, scoreTertiary };
+  }).filter((s) => s.tier !== 3).sort((a, b) => {
+    if (a.tier !== b.tier) return a.tier - b.tier;
+    if (a.scorePrimary !== b.scorePrimary) return a.scorePrimary - b.scorePrimary;
+    if (a.scoreSecondary !== b.scoreSecondary) return a.scoreSecondary - b.scoreSecondary;
+    if (a.scoreTertiary !== b.scoreTertiary) return a.scoreTertiary - b.scoreTertiary;
+    return a.cmd.name.localeCompare(b.cmd.name);
+  });
+  return scored.map((s) => s.cmd);
 };
-var renderLsTool = ({ toolCall }) => {
-  let directoryPath = "[path not specified]";
-  try {
-    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
-    directoryPath = args.directory_path || "[path not specified]";
-  } catch (e) {
-    directoryPath = "Error parsing arguments";
+
+// src/app/ui/hooks/useAtCompletion.ts
+import { useEffect as useEffect2, useRef as useRef2, useState } from "react";
+import fs from "fs";
+import path from "path";
+var MAX_RESULTS = 50;
+var DEFAULT_RECURSIVE_DEPTH = 2;
+function listPathSuggestions(baseDir, pattern) {
+  const raw = pattern || "";
+  const patternEndsWithSlash = raw.endsWith("/");
+  const relDir = raw.replace(/^\/+|\/+$/g, "");
+  const filterPrefix = patternEndsWithSlash ? "" : relDir.split("/").slice(-1)[0] || "";
+  const listDir = path.resolve(baseDir, relDir || ".");
+  const results = [];
+  const IGNORED_DIRS = ["node_modules", ".git", ".venv", "dist", "build"];
+  const IGNORED_EXTS = [".pyc", ".class", ".o", ".map", ".log", ".tmp"];
+  function isIgnoredName(name) {
+    if (!name) return false;
+    if (IGNORED_DIRS.includes(name)) return true;
+    if (name.startsWith(".")) return true;
+    return false;
   }
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " ls" })
-    ] }),
-    /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: directoryPath }) })
-  ] });
-};
-var renderCountFilesLinesTool = ({ toolCall }) => {
-  let filepath = "[path not specified]";
-  try {
-    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
-    filepath = args.filepath || "[path not specified]";
-  } catch (e) {
-    filepath = "Error parsing arguments";
+  function isIgnoredFile(name) {
+    if (!name) return false;
+    for (const e of IGNORED_EXTS) if (name.endsWith(e)) return true;
+    return false;
   }
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " count lines" })
-    ] }),
-    /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: filepath }) })
-  ] });
-};
-var renderReadFileLines = ({ toolCall }) => {
-  let filepath = "[path not specified]";
-  let startLine = 0;
-  let endLine = 0;
-  try {
-    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
-    filepath = args.filepath || "[path not specified]";
-    startLine = args.start_line || 0;
-    endLine = args.end_line || 0;
-  } catch (e) {
-    filepath = "Error parsing arguments";
+  function pushEntry(entryPath, label, isDir) {
+    if (results.length >= MAX_RESULTS) return;
+    const clean = label.split(path.sep).join("/").replace(/[]+/g, "");
+    results.push({ label: clean + (isDir ? "/" : ""), fullPath: entryPath, isDir });
   }
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " read" })
-    ] }),
-    /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 2, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: filepath }),
-      /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 2, children: [
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "lines " }),
-        /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: startLine }),
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " to " }),
-        /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: endLine })
-      ] })
-    ] })
-  ] });
-};
-var renderEditTool = ({ toolCall, preview }) => {
-  const diffMaxHeight = 5;
-  let filepath = "[path not specified]";
   try {
-    const args = JSON.parse(toolCall.function.arguments);
-    filepath = args.file_path || "[path not specified]";
+    if (raw.length === 0 || patternEndsWithSlash) {
+      const queue = [{ dir: listDir, depth: 0, rel: relDir }];
+      while (queue.length && results.length < MAX_RESULTS) {
+        const node = queue.shift();
+        try {
+          const entries = fs.readdirSync(node.dir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (isIgnoredName(entry.name)) continue;
+            const entryAbs = path.join(node.dir, entry.name);
+            const entryRel = node.rel ? path.posix.join(node.rel, entry.name) : entry.name;
+            if (entryRel.split("/").includes("node_modules")) continue;
+            if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
+            pushEntry(entryAbs, entryRel, entry.isDirectory());
+            if (entry.isDirectory() && node.depth < DEFAULT_RECURSIVE_DEPTH) {
+              queue.push({ dir: entryAbs, depth: node.depth + 1, rel: node.rel ? node.rel + "/" + entry.name : entry.name + "/" });
+            }
+            if (results.length >= MAX_RESULTS) break;
+          }
+        } catch (e) {
+        }
+      }
+    } else {
+      const entries = fs.readdirSync(listDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (filterPrefix && !entry.name.startsWith(filterPrefix)) continue;
+        if (isIgnoredName(entry.name)) continue;
+        if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
+        const entryAbs = path.join(listDir, entry.name);
+        const label = relDir ? path.posix.join(relDir, entry.name) : entry.name;
+        pushEntry(entryAbs, label, entry.isDirectory());
+        if (results.length >= MAX_RESULTS) break;
+      }
+    }
   } catch (e) {
-    filepath = "Error parsing arguments";
   }
-  const finalFileName = getBasePath(filepath);
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " edit " }),
-      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: finalFileName })
-    ] }),
-    preview ? /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(SimpleDiff, { text: preview, maxHeight: diffMaxHeight }) }) : /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "Generating preview..." }) })
-  ] });
-};
-var renderGeneric = ({ toolCall }) => {
-  const toolName = toolCall.function.name;
-  const rawArguments = toolCall.function.arguments;
-  const MAX_LINES2 = 5;
-  let formattedArgsString;
-  if (!rawArguments) {
-    formattedArgsString = "";
-  } else if (typeof rawArguments === "string") {
-    try {
-      const parsedJson = JSON.parse(rawArguments);
-      formattedArgsString = JSON.stringify(parsedJson, null, 2);
-    } catch (e) {
-      formattedArgsString = rawArguments;
+  return results.slice(0, MAX_RESULTS);
+}
+function useAtCompletion({
+  cwd,
+  text,
+  cursorPosition,
+  setText
+}) {
+  const [open, setOpen] = useState(false);
+  const [selected, setSelected] = useState(0);
+  const [suggestions, setSuggestions] = useState([]);
+  const lastQuery = useRef2("");
+  function scanForAt(text2, pos) {
+    const before = text2.slice(0, pos);
+    const m = before.match(/@([\w\/.\-_]*)$/);
+    if (!m) return { pattern: null, insertStart: -1 };
+    return { pattern: m[1] || "", insertStart: m.index + 1 };
+  }
+  function update(newText, newCursor) {
+    const res = scanForAt(newText, newCursor);
+    if (res.pattern !== null && res.pattern.length >= 0) {
+      setOpen(true);
+      globalThis.__BLUMA_AT_OPEN__ = true;
+      const suggs = listPathSuggestions(cwd, res.pattern);
+      setSuggestions(suggs);
+      setSelected(0);
+      lastQuery.current = res.pattern;
+    } else {
+      setOpen(false);
+      globalThis.__BLUMA_AT_OPEN__ = false;
+      setSuggestions([]);
     }
-  } else {
-    formattedArgsString = JSON.stringify(rawArguments, null, 2);
   }
-  const lines = formattedArgsString.split("\n");
-  const isTruncated = lines.length > MAX_LINES2;
-  const visibleLines = isTruncated ? lines.slice(0, MAX_LINES2) : lines;
-  const remainingCount = lines.length - MAX_LINES2;
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
-      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
-        " ",
-        toolName
-      ] })
-    ] }),
-    formattedArgsString && /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 2, flexDirection: "column", children: [
-      visibleLines.map((line, idx) => /* @__PURE__ */ jsx5(Text5, { color: "gray", children: line }, idx)),
-      isTruncated && /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
-        "\u22EF ",
-        remainingCount,
-        " more lines"
-      ] })
-    ] })
-  ] });
-};
-var renderTodoTool = ({ toolCall }) => {
-  try {
-    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
-    const tasks = args.tasks || [];
-    if (tasks.length === 0) {
-      return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-        /* @__PURE__ */ jsxs5(Box5, { children: [
-          /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
-          /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " todo" })
-        ] }),
-        /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Empty task list" }) })
-      ] });
+  useEffect2(() => {
+    update(text, cursorPosition);
+  }, [text, cursorPosition, cwd]);
+  function insertAtSelection() {
+    if (!open || !suggestions[selected]) return;
+    const res = scanForAt(text, cursorPosition);
+    if (!res || res.insertStart < 0) return;
+    let chosen = suggestions[selected].label;
+    const isDir = suggestions[selected].isDir;
+    chosen = chosen.replace(/\\/g, "/").replace(/\|/g, "");
+    let insertVal = chosen.replace(/\/+$/g, "");
+    const currentPattern = res.pattern || "";
+    if (currentPattern.length > 0) {
+      const normalizedPattern = currentPattern.replace(/\/+$/g, "");
+      if (insertVal.startsWith(normalizedPattern)) {
+        insertVal = insertVal.slice(normalizedPattern.length);
+        insertVal = insertVal.replace(/^\/+/, "");
+      }
     }
-    const completed = tasks.filter((t) => t.isComplete === true).length;
-    const pending = tasks.length - completed;
-    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ jsxs5(Box5, { children: [
-        /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " todo" })
-      ] }),
-      /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 2, flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs5(Text5, { color: "magenta", children: [
-          "\u{1F4CB} ",
-          pending,
-          " pending, ",
-          completed,
-          " completed"
-        ] }),
-        tasks.length > 0 && tasks.length <= 10 && /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, flexDirection: "column", marginTop: 1, children: tasks.map((task, idx) => {
-          const isComplete = task.isComplete === true;
-          const checkbox = isComplete ? "[X]" : "[ ]";
-          const description = task.description || "No description";
-          const displayText = description.length > 60 ? description.substring(0, 57) + "..." : description;
-          const color = isComplete ? "green" : "yellow";
-          return /* @__PURE__ */ jsxs5(
-            Text5,
-            {
-              color,
-              strikethrough: isComplete,
-              dimColor: isComplete,
-              children: [
+    insertVal = insertVal.split("\\").join("/");
+    if (isDir && !insertVal.endsWith("/")) insertVal = insertVal + "/";
+    const pattern = res.pattern || "";
+    const lastSlash = pattern.lastIndexOf("/");
+    const segmentOffset = lastSlash >= 0 ? lastSlash + 1 : 0;
+    const segmentStart = res.insertStart + segmentOffset;
+    const before = text.slice(0, segmentStart);
+    const after = text.slice(cursorPosition);
+    const newText = before + insertVal + after;
+    const finalText = newText + " ";
+    setText(finalText, finalText.length);
+    globalThis.__BLUMA_FORCE_CURSOR_END__ = true;
+    update(finalText, finalText.length);
+    if (isDir) {
+      setOpen(false);
+      setSuggestions([]);
+      setTimeout(() => {
+        setOpen(true);
+        update(finalText, finalText.length);
+      }, 0);
+    } else {
+      setOpen(false);
+      setSuggestions([]);
+    }
+  }
+  function close() {
+    setOpen(false);
+    setSuggestions([]);
+  }
+  return { open, suggestions, selected, setSelected, insertAtSelection, close, update };
+}
+
+// src/app/ui/components/InputPrompt.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var uiEventBus = global.__bluma_ui_eventbus__ || new EventEmitter();
+global.__bluma_ui_eventbus__ = uiEventBus;
+var TextLine = memo2(({
+  line,
+  lineIndex,
+  cursorLine,
+  cursorCol,
+  showCursor
+}) => {
+  const isCursorLine = lineIndex === cursorLine;
+  if (!isCursorLine || !showCursor) {
+    return /* @__PURE__ */ jsx2(Text2, { children: line });
+  }
+  const before = line.slice(0, cursorCol);
+  const char = line[cursorCol] || " ";
+  const after = line.slice(cursorCol + 1);
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    before,
+    /* @__PURE__ */ jsx2(Text2, { inverse: true, color: "white", children: char }),
+    after
+  ] });
+}, (prev, next) => {
+  if (prev.line !== next.line) return false;
+  if (prev.showCursor !== next.showCursor) return false;
+  const prevIsCursorLine = prev.lineIndex === prev.cursorLine;
+  const nextIsCursorLine = next.lineIndex === next.cursorLine;
+  if (prevIsCursorLine !== nextIsCursorLine) return false;
+  if (nextIsCursorLine && prev.cursorCol !== next.cursorCol) return false;
+  return true;
+});
+TextLine.displayName = "TextLine";
+var PathSuggestions = memo2(({
+  suggestions,
+  selected
+}) => {
+  const VISIBLE = 7;
+  const total = suggestions.length;
+  const sel = Math.max(0, Math.min(selected, total - 1));
+  let start = Math.max(0, sel - Math.floor(VISIBLE / 2));
+  if (start + VISIBLE > total) start = Math.max(0, total - VISIBLE);
+  const windowItems = suggestions.slice(start, start + VISIBLE);
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, height: Math.min(VISIBLE, total), children: windowItems.map((s, idx) => {
+    const realIdx = start + idx;
+    const isSelected = realIdx === selected;
+    return /* @__PURE__ */ jsxs2(Box2, { paddingLeft: 1, paddingY: 0, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: isSelected ? "magenta" : "gray", children: isSelected ? "\u276F " : "  " }),
+      /* @__PURE__ */ jsx2(Text2, { color: isSelected ? "magenta" : "white", bold: isSelected, dimColor: !isSelected, children: s.label })
+    ] }, s.fullPath);
+  }) });
+});
+PathSuggestions.displayName = "PathSuggestions";
+var SlashSuggestions = memo2(({
+  suggestions,
+  selectedIndex
+}) => /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: suggestions.map((s, idx) => {
+  const isSelected = idx === selectedIndex;
+  return /* @__PURE__ */ jsxs2(Box2, { paddingLeft: 1, paddingY: 0, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: isSelected ? "magenta" : "gray", children: isSelected ? "\u276F " : "  " }),
+    /* @__PURE__ */ jsxs2(Text2, { color: isSelected ? "magenta" : "white", bold: isSelected, dimColor: !isSelected, children: [
+      s.name,
+      " ",
+      /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+        "- ",
+        s.description
+      ] })
+    ] })
+  ] }, s.name);
+}) }));
+SlashSuggestions.displayName = "SlashSuggestions";
+var Footer = memo2(({ isReadOnly }) => /* @__PURE__ */ jsx2(Box2, { paddingX: 1, justifyContent: "center", children: /* @__PURE__ */ jsx2(Text2, { color: "gray", dimColor: true, children: isReadOnly ? "ctrl+c to exit | Enter to send message | Shift+Enter for new line | esc interrupt" : "ctrl+c to exit | Enter to submit | Shift+Enter for new line | /help commands | esc interrupt" }) }));
+Footer.displayName = "Footer";
+var TextLinesRenderer = memo2(({
+  lines,
+  cursorLine,
+  cursorCol,
+  showCursor,
+  showPlaceholder,
+  placeholder
+}) => {
+  return /* @__PURE__ */ jsx2(Fragment2, { children: lines.map((line, idx) => {
+    const isFirstLine = idx === 0;
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", paddingX: 1, children: [
+      isFirstLine && /* @__PURE__ */ jsxs2(Text2, { color: "white", children: [
+        ">",
+        " "
+      ] }),
+      !isFirstLine && /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+        "\u2502",
+        " "
+      ] }),
+      showPlaceholder && isFirstLine && line.length === 0 ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: placeholder }) : /* @__PURE__ */ jsx2(
+        TextLine,
+        {
+          line,
+          lineIndex: idx,
+          cursorLine,
+          cursorCol,
+          showCursor
+        }
+      )
+    ] }, idx);
+  }) });
+});
+TextLinesRenderer.displayName = "TextLinesRenderer";
+var InputPrompt = memo2(({
+  onSubmit,
+  isReadOnly,
+  onInterrupt,
+  disableWhileProcessing = false
+}) => {
+  const { stdout } = useStdout();
+  const [viewWidth] = useState2(() => stdout.columns - 6);
+  const [slashOpen, setSlashOpen] = useState2(false);
+  const [slashIndex, setSlashIndex] = useState2(0);
+  const permissiveOnSubmit = (value) => {
+    const trimmed = (value || "").trim();
+    if (isReadOnly) {
+      if (trimmed.length > 0) {
+        uiEventBus.emit("user_overlay", { kind: "message", payload: trimmed, ts: Date.now() });
+      }
+      return;
+    }
+    onSubmit(value);
+  };
+  const { text, cursorPosition, setText } = useCustomInput({
+    onSubmit: (value) => {
+      if (disableWhileProcessing && isReadOnly) return;
+      if (pathAutocomplete.open) return;
+      permissiveOnSubmit(value);
+    },
+    viewWidth,
+    isReadOnly,
+    onInterrupt
+  });
+  const linesData = useMemo(() => {
+    const lines = text.split("\n");
+    let remainingChars = cursorPosition;
+    let cursorLine = 0;
+    let cursorCol = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const lineLength = lines[i].length;
+      if (remainingChars <= lineLength) {
+        cursorLine = i;
+        cursorCol = remainingChars;
+        break;
+      }
+      remainingChars -= lineLength + 1;
+      if (i === lines.length - 1) {
+        cursorLine = i;
+        cursorCol = lineLength;
+      }
+    }
+    return { lines, cursorLine, cursorCol, totalLines: lines.length };
+  }, [text, cursorPosition]);
+  const displayData = linesData;
+  const placeholder = isReadOnly ? " Press Esc to cancel | Enter message while agent runs" : "";
+  const showPlaceholder = text.length === 0 && isReadOnly;
+  const slashQuery = useMemo(() => text.startsWith("/") ? text : "", [text]);
+  const slashSuggestions = useMemo(() => {
+    if (!slashQuery) return [];
+    return filterSlashCommands(slashQuery);
+  }, [slashQuery]);
+  useEffect3(() => {
+    if (isReadOnly) {
+      setSlashOpen(false);
+      return;
+    }
+    if (text.startsWith("/")) {
+      setSlashOpen(true);
+      setSlashIndex(0);
+    } else {
+      setSlashOpen(false);
+    }
+  }, [text, isReadOnly]);
+  useInput2((input, key) => {
+    if (!slashOpen) return;
+    if (key.downArrow) {
+      setSlashIndex((i) => Math.min(i + 1, Math.max(0, slashSuggestions.length - 1)));
+    } else if (key.upArrow) {
+      setSlashIndex((i) => Math.max(i - 1, 0));
+    } else if (key.return) {
+      const choice = slashSuggestions[slashIndex];
+      if (choice) {
+        setSlashOpen(false);
+        try {
+          setText(`${choice.name} `);
+        } catch (e) {
+          permissiveOnSubmit(`${choice.name} `);
+        }
+      }
+    } else if (key.escape) {
+      setSlashOpen(false);
+    }
+  }, { isActive: slashOpen });
+  useEffect3(() => {
+    if (globalThis.__BLUMA_FORCE_CURSOR_END__) {
+      setText(text, text.length);
+      delete globalThis.__BLUMA_FORCE_CURSOR_END__;
+    }
+  }, [text, setText]);
+  const cwd = process.cwd();
+  const pathAutocomplete = useAtCompletion({ cwd, text, cursorPosition, setText });
+  useInput2((input, key) => {
+    if (key.backspace || key.delete || key.ctrl || key.meta) return;
+    if (pathAutocomplete.open) {
+      if (key.downArrow) {
+        pathAutocomplete.setSelected((i) => Math.min(i + 1, Math.max(0, pathAutocomplete.suggestions.length - 1)));
+        return;
+      } else if (key.upArrow) {
+        pathAutocomplete.setSelected((i) => Math.max(i - 1, 0));
+        return;
+      } else if (key.return || key.tab) {
+        const selected = pathAutocomplete.suggestions[pathAutocomplete.selected];
+        if (selected) {
+          const before = text.slice(0, cursorPosition);
+          const m = before.match(/@([\w\/.\-_]*)$/);
+          if (m) {
+            globalThis.__BLUMA_SUPPRESS_SUBMIT__ = true;
+            pathAutocomplete.insertAtSelection();
+            return;
+          }
+        }
+        return;
+      } else if (key.escape) {
+        pathAutocomplete.close();
+        return;
+      }
+      return;
+    }
+  }, { isActive: true });
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    disableWhileProcessing ? /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", paddingX: 1, flexWrap: "nowrap", children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "white", children: [
+        ">",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "ctrl+c to exit" })
+    ] }) }) : /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsx2(
+        TextLinesRenderer,
+        {
+          lines: displayData.lines,
+          cursorLine: displayData.cursorLine,
+          cursorCol: displayData.cursorCol,
+          showCursor: !isReadOnly,
+          showPlaceholder,
+          placeholder
+        }
+      ) }),
+      pathAutocomplete.open && pathAutocomplete.suggestions.length > 0 && /* @__PURE__ */ jsx2(
+        PathSuggestions,
+        {
+          suggestions: pathAutocomplete.suggestions,
+          selected: pathAutocomplete.selected
+        }
+      ),
+      slashOpen && slashSuggestions.length > 0 && /* @__PURE__ */ jsx2(
+        SlashSuggestions,
+        {
+          suggestions: slashSuggestions,
+          selectedIndex: slashIndex
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx2(Footer, { isReadOnly })
+  ] });
+});
+InputPrompt.displayName = "InputPrompt";
+
+// src/app/ui/ConfirmationPrompt.tsx
+import { memo as memo4 } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+
+// src/app/ui/InteractiveMenu.tsx
+import { useState as useState3, memo as memo3 } from "react";
+import { Box as Box3, Text as Text3, useInput as useInput3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var InteractiveMenuComponent = ({ onDecision }) => {
+  const options = [
+    { key: "y", label: "yes", value: "accept", color: "green" },
+    { key: "n", label: "no", value: "decline", color: "red" },
+    { key: "a", label: "always", value: "accept_always", color: "yellow" }
+  ];
+  const [selected, setSelected] = useState3(0);
+  useInput3((input, key) => {
+    if (key.upArrow || key.leftArrow) {
+      setSelected((i) => i > 0 ? i - 1 : options.length - 1);
+    }
+    if (key.downArrow || key.rightArrow) {
+      setSelected((i) => i < options.length - 1 ? i + 1 : 0);
+    }
+    if (key.escape) {
+      onDecision("decline");
+    }
+    if (key.return) {
+      onDecision(options[selected].value);
+    }
+    const opt = options.find((o) => o.key === input.toLowerCase());
+    if (opt) {
+      onDecision(opt.value);
+    }
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "approve? " }),
+      options.map((opt, idx) => {
+        const isSelected = idx === selected;
+        return /* @__PURE__ */ jsx3(Box3, { marginRight: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: isSelected ? opt.color : "gray", bold: isSelected, children: [
+          "[",
+          opt.key,
+          "]",
+          opt.label
+        ] }) }, opt.value);
+      })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "arrows to select, enter to confirm, esc to cancel" }) })
+  ] });
+};
+var InteractiveMenu = memo3(InteractiveMenuComponent);
+
+// src/app/ui/components/promptRenderers.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import path2 from "path";
+
+// src/app/ui/components/SimpleDiff.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var SimpleDiff = ({ text, maxHeight }) => {
+  const allLines = (text || "").split("\n").filter((line) => line !== "");
+  const isTruncated = maxHeight > 0 && allLines.length > maxHeight;
+  const linesToRender = isTruncated ? allLines.slice(-maxHeight) : allLines;
+  const hiddenCount = allLines.length - linesToRender.length;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingX: 2, children: [
+    isTruncated && /* @__PURE__ */ jsx4(Box4, { marginBottom: 0, children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "\u22EF ",
+      hiddenCount,
+      " lines hidden"
+    ] }) }),
+    linesToRender.map((line, index) => {
+      if (line.startsWith("---") || line.startsWith("+++")) {
+        return null;
+      }
+      let color = "white";
+      let prefix = "";
+      if (line.startsWith("+")) {
+        color = "green";
+        prefix = "+ ";
+      } else if (line.startsWith("-")) {
+        color = "red";
+        prefix = "- ";
+      } else if (line.startsWith("@@")) {
+        color = "cyan";
+        prefix = "";
+      } else {
+        color = "gray";
+        prefix = "  ";
+      }
+      return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color, children: [
+        prefix,
+        line.replace(/^[+\-]/, "")
+      ] }) }, index);
+    })
+  ] });
+};
+
+// src/app/ui/components/promptRenderers.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var getBasePath = (filePath) => {
+  return path2.basename(filePath);
+};
+var renderShellCommand = ({ toolCall }) => {
+  let command = "";
+  try {
+    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
+    command = args.command || "[command not found]";
+  } catch (e) {
+    command = "Error parsing command";
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " shell" })
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: command }) })
+  ] });
+};
+var renderLsTool = ({ toolCall }) => {
+  let directoryPath = "[path not specified]";
+  try {
+    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
+    directoryPath = args.directory_path || "[path not specified]";
+  } catch (e) {
+    directoryPath = "Error parsing arguments";
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " ls" })
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: directoryPath }) })
+  ] });
+};
+var renderCountFilesLinesTool = ({ toolCall }) => {
+  let filepath = "[path not specified]";
+  try {
+    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
+    filepath = args.filepath || "[path not specified]";
+  } catch (e) {
+    filepath = "Error parsing arguments";
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " count lines" })
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: filepath }) })
+  ] });
+};
+var renderReadFileLines = ({ toolCall }) => {
+  let filepath = "[path not specified]";
+  let startLine = 0;
+  let endLine = 0;
+  try {
+    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
+    filepath = args.filepath || "[path not specified]";
+    startLine = args.start_line || 0;
+    endLine = args.end_line || 0;
+  } catch (e) {
+    filepath = "Error parsing arguments";
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " read" })
+    ] }),
+    /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: filepath }),
+      /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 2, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "lines " }),
+        /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: startLine }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " to " }),
+        /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: endLine })
+      ] })
+    ] })
+  ] });
+};
+var renderEditTool = ({ toolCall, preview }) => {
+  const diffMaxHeight = 5;
+  let filepath = "[path not specified]";
+  try {
+    const args = JSON.parse(toolCall.function.arguments);
+    filepath = args.file_path || "[path not specified]";
+  } catch (e) {
+    filepath = "Error parsing arguments";
+  }
+  const finalFileName = getBasePath(filepath);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " edit " }),
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: finalFileName })
+    ] }),
+    preview ? /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(SimpleDiff, { text: preview, maxHeight: diffMaxHeight }) }) : /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "Generating preview..." }) })
+  ] });
+};
+var renderGeneric = ({ toolCall }) => {
+  const toolName = toolCall.function.name;
+  const rawArguments = toolCall.function.arguments;
+  const MAX_LINES2 = 5;
+  let formattedArgsString;
+  if (!rawArguments) {
+    formattedArgsString = "";
+  } else if (typeof rawArguments === "string") {
+    try {
+      const parsedJson = JSON.parse(rawArguments);
+      formattedArgsString = JSON.stringify(parsedJson, null, 2);
+    } catch (e) {
+      formattedArgsString = rawArguments;
+    }
+  } else {
+    formattedArgsString = JSON.stringify(rawArguments, null, 2);
+  }
+  const lines = formattedArgsString.split("\n");
+  const isTruncated = lines.length > MAX_LINES2;
+  const visibleLines = isTruncated ? lines.slice(0, MAX_LINES2) : lines;
+  const remainingCount = lines.length - MAX_LINES2;
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
+      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        " ",
+        toolName
+      ] })
+    ] }),
+    formattedArgsString && /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 2, flexDirection: "column", children: [
+      visibleLines.map((line, idx) => /* @__PURE__ */ jsx5(Text5, { color: "gray", children: line }, idx)),
+      isTruncated && /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "\u22EF ",
+        remainingCount,
+        " more lines"
+      ] })
+    ] })
+  ] });
+};
+var renderTodoTool = ({ toolCall }) => {
+  try {
+    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
+    const tasks = args.tasks || [];
+    if (tasks.length === 0) {
+      return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs5(Box5, { children: [
+          /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
+          /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " todo" })
+        ] }),
+        /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Empty task list" }) })
+      ] });
+    }
+    const completed = tasks.filter((t) => t.isComplete === true).length;
+    const pending = tasks.length - completed;
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs5(Box5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " todo" })
+      ] }),
+      /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 2, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs5(Text5, { color: "magenta", children: [
+          "\u{1F4CB} ",
+          pending,
+          " pending, ",
+          completed,
+          " completed"
+        ] }),
+        tasks.length > 0 && tasks.length <= 10 && /* @__PURE__ */ jsx5(Box5, { paddingLeft: 2, flexDirection: "column", marginTop: 1, children: tasks.map((task, idx) => {
+          const isComplete = task.isComplete === true;
+          const checkbox = isComplete ? "[X]" : "[ ]";
+          const description = task.description || "No description";
+          const displayText = description.length > 60 ? description.substring(0, 57) + "..." : description;
+          const color = isComplete ? "green" : "yellow";
+          return /* @__PURE__ */ jsxs5(
+            Text5,
+            {
+              color,
+              strikethrough: isComplete,
+              dimColor: isComplete,
+              children: [
                 checkbox,
                 " ",
                 displayText
@@ -1919,1144 +2241,843 @@ function addTasks(tasks) {
     taskStore.push(newTask);
   }
   saveTasksToFile();
-  return createResult(true, `Added ${tasks.length} task(s)`);
-}
-function completeTask(taskId) {
-  loadTasksFromFile();
-  const task = taskStore.find((t) => t.id === taskId);
-  if (!task) {
-    return createResult(false, `Task #${taskId} not found`);
-  }
-  task.status = "completed";
-  task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-  saveTasksToFile();
-  return createResult(true, `Completed: ${task.description}`);
-}
-function updateTask(taskId, description, priority) {
-  loadTasksFromFile();
-  const task = taskStore.find((t) => t.id === taskId);
-  if (!task) {
-    return createResult(false, `Task #${taskId} not found`);
-  }
-  if (description) {
-    const error = validateDescription(description);
-    if (error) {
-      return createResult(false, error);
-    }
-    task.description = description.trim();
-  }
-  if (priority) {
-    task.priority = priority;
-  }
-  saveTasksToFile();
-  return createResult(true, `Updated task #${taskId}`);
-}
-function removeTask(taskId) {
-  loadTasksFromFile();
-  const index = taskStore.findIndex((t) => t.id === taskId);
-  if (index === -1) {
-    return createResult(false, `Task #${taskId} not found`);
-  }
-  const removed = taskStore.splice(index, 1)[0];
-  saveTasksToFile();
-  return createResult(true, `Removed: ${removed.description}`);
-}
-function clearCompleted() {
-  loadTasksFromFile();
-  const before = taskStore.length;
-  taskStore = taskStore.filter((t) => t.status !== "completed");
-  const removed = before - taskStore.length;
-  saveTasksToFile();
-  return createResult(true, `Cleared ${removed} completed task(s)`);
-}
-function generateProgressBar(percent) {
-  const width = 10;
-  const filled = Math.round(percent / 100 * width);
-  const empty = width - filled;
-  return "[" + "=".repeat(filled) + " ".repeat(empty) + "]";
-}
-async function todo(args) {
-  if ("tasks" in args && !("action" in args)) {
-    loadTasksFromFile();
-    taskStore = [];
-    nextId = 1;
-    if (args.tasks && args.tasks.length > 0) {
-      for (const task of args.tasks) {
-        taskStore.push({
-          id: nextId++,
-          description: task.description,
-          status: task.isComplete ? "completed" : "pending",
-          priority: "medium",
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          completedAt: task.isComplete ? (/* @__PURE__ */ new Date()).toISOString() : void 0
-        });
-      }
-    }
-    saveTasksToFile();
-    const stats = calculateStats();
-    const progressBar = generateProgressBar(stats.progress);
-    return createResult(true, `Synced ${taskStore.length} tasks ${progressBar} ${stats.progress}%`);
-  }
-  const fullArgs = args;
-  switch (fullArgs.action) {
-    case "list":
-      return listTasks();
-    case "add":
-      return addTasks(fullArgs.tasks);
-    case "complete":
-      if (!fullArgs.taskId) {
-        return createResult(false, "taskId required for complete action");
-      }
-      return completeTask(fullArgs.taskId);
-    case "update":
-      if (!fullArgs.taskId) {
-        return createResult(false, "taskId required for update action");
-      }
-      return updateTask(fullArgs.taskId, fullArgs.description, fullArgs.priority);
-    case "remove":
-      if (!fullArgs.taskId) {
-        return createResult(false, "taskId required for remove action");
-      }
-      return removeTask(fullArgs.taskId);
-    case "clear":
-      return clearCompleted();
-    case "sync":
-      return addTasks(fullArgs.tasks);
-    default:
-      return createResult(false, `Unknown action: ${fullArgs.action}`);
-  }
-}
-
-// src/app/agent/tools/natives/find_by_name.ts
-import path6 from "path";
-import { promises as fsPromises } from "fs";
-var DEFAULT_IGNORE_PATTERNS = [
-  "node_modules",
-  ".git",
-  ".venv",
-  "venv",
-  "__pycache__",
-  ".cache",
-  "dist",
-  "build",
-  ".next",
-  ".nuxt",
-  "coverage",
-  ".nyc_output",
-  ".pytest_cache",
-  "target",
-  // Rust
-  "vendor"
-  // Go, PHP
-];
-var MAX_RESULTS2 = 100;
-var MAX_DEPTH_DEFAULT = 10;
-function globToRegex(glob) {
-  let regex = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLESTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/{{DOUBLESTAR}}/g, ".*");
-  return new RegExp(`^${regex}$`, "i");
-}
-function shouldIgnore(name, ignorePatterns, includeHidden) {
-  if (!includeHidden && name.startsWith(".")) {
-    return true;
-  }
-  for (const pattern of ignorePatterns) {
-    if (name === pattern || name.match(globToRegex(pattern))) {
-      return true;
-    }
-  }
-  return false;
-}
-function matchesExtensions(filename, extensions) {
-  if (!extensions || extensions.length === 0) return true;
-  const ext = path6.extname(filename).toLowerCase();
-  return extensions.some((e) => {
-    const normalizedExt = e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`;
-    return ext === normalizedExt;
-  });
-}
-async function searchDirectory(dir, pattern, baseDir, options, results) {
-  if (options.currentDepth > options.maxDepth || results.length >= MAX_RESULTS2) {
-    return;
-  }
-  let entries;
-  try {
-    entries = await fsPromises.readdir(dir, { withFileTypes: true });
-  } catch (error) {
-    return;
-  }
-  for (const entry of entries) {
-    if (results.length >= MAX_RESULTS2) break;
-    const name = entry.name;
-    if (shouldIgnore(name, options.ignorePatterns, options.includeHidden)) {
-      continue;
-    }
-    const fullPath = path6.join(dir, name);
-    const relativePath = path6.relative(baseDir, fullPath);
-    if (entry.isDirectory()) {
-      if (pattern.test(name)) {
-        results.push({
-          path: fullPath,
-          relative_path: relativePath,
-          type: "directory"
-        });
-      }
-      await searchDirectory(fullPath, pattern, baseDir, {
-        ...options,
-        currentDepth: options.currentDepth + 1
-      }, results);
-    } else if (entry.isFile()) {
-      if (pattern.test(name) && matchesExtensions(name, options.extensions)) {
-        try {
-          const stats = await fsPromises.stat(fullPath);
-          results.push({
-            path: fullPath,
-            relative_path: relativePath,
-            type: "file",
-            size: stats.size,
-            modified: stats.mtime.toISOString()
-          });
-        } catch {
-          results.push({
-            path: fullPath,
-            relative_path: relativePath,
-            type: "file"
-          });
-        }
-      }
-    }
+  return createResult(true, `Added ${tasks.length} task(s)`);
+}
+function completeTask(taskId) {
+  loadTasksFromFile();
+  const task = taskStore.find((t) => t.id === taskId);
+  if (!task) {
+    return createResult(false, `Task #${taskId} not found`);
   }
+  task.status = "completed";
+  task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveTasksToFile();
+  return createResult(true, `Completed: ${task.description}`);
 }
-async function findByName(args) {
-  try {
-    const {
-      pattern,
-      directory = process.cwd(),
-      extensions,
-      max_depth = MAX_DEPTH_DEFAULT,
-      include_hidden = false,
-      exclude_patterns = []
-    } = args;
-    if (!pattern || typeof pattern !== "string") {
-      return {
-        success: false,
-        pattern: pattern || "",
-        directory,
-        results: [],
-        total_found: 0,
-        truncated: false,
-        error: "Pattern is required and must be a string"
-      };
+function updateTask(taskId, description, priority) {
+  loadTasksFromFile();
+  const task = taskStore.find((t) => t.id === taskId);
+  if (!task) {
+    return createResult(false, `Task #${taskId} not found`);
+  }
+  if (description) {
+    const error = validateDescription(description);
+    if (error) {
+      return createResult(false, error);
     }
-    const resolvedDir = path6.resolve(directory);
-    try {
-      const stats = await fsPromises.stat(resolvedDir);
-      if (!stats.isDirectory()) {
-        return {
-          success: false,
-          pattern,
-          directory: resolvedDir,
-          results: [],
-          total_found: 0,
-          truncated: false,
-          error: `Path is not a directory: ${resolvedDir}`
-        };
+    task.description = description.trim();
+  }
+  if (priority) {
+    task.priority = priority;
+  }
+  saveTasksToFile();
+  return createResult(true, `Updated task #${taskId}`);
+}
+function removeTask(taskId) {
+  loadTasksFromFile();
+  const index = taskStore.findIndex((t) => t.id === taskId);
+  if (index === -1) {
+    return createResult(false, `Task #${taskId} not found`);
+  }
+  const removed = taskStore.splice(index, 1)[0];
+  saveTasksToFile();
+  return createResult(true, `Removed: ${removed.description}`);
+}
+function clearCompleted() {
+  loadTasksFromFile();
+  const before = taskStore.length;
+  taskStore = taskStore.filter((t) => t.status !== "completed");
+  const removed = before - taskStore.length;
+  saveTasksToFile();
+  return createResult(true, `Cleared ${removed} completed task(s)`);
+}
+function generateProgressBar(percent) {
+  const width = 10;
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  return "[" + "=".repeat(filled) + " ".repeat(empty) + "]";
+}
+async function todo(args) {
+  if ("tasks" in args && !("action" in args)) {
+    loadTasksFromFile();
+    taskStore = [];
+    nextId = 1;
+    if (args.tasks && args.tasks.length > 0) {
+      for (const task of args.tasks) {
+        taskStore.push({
+          id: nextId++,
+          description: task.description,
+          status: task.isComplete ? "completed" : "pending",
+          priority: "medium",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          completedAt: task.isComplete ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+        });
       }
-    } catch (error) {
-      return {
-        success: false,
-        pattern,
-        directory: resolvedDir,
-        results: [],
-        total_found: 0,
-        truncated: false,
-        error: `Directory not found: ${resolvedDir}`
-      };
     }
-    const ignorePatterns = [...DEFAULT_IGNORE_PATTERNS, ...exclude_patterns];
-    const patternRegex = globToRegex(pattern);
-    const results = [];
-    await searchDirectory(resolvedDir, patternRegex, resolvedDir, {
-      extensions,
-      maxDepth: max_depth,
-      currentDepth: 0,
-      includeHidden: include_hidden,
-      ignorePatterns
-    }, results);
-    results.sort((a, b) => {
-      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
-      return a.relative_path.localeCompare(b.relative_path);
-    });
-    return {
-      success: true,
-      pattern,
-      directory: resolvedDir,
-      results,
-      total_found: results.length,
-      truncated: results.length >= MAX_RESULTS2
-    };
-  } catch (error) {
-    return {
-      success: false,
-      pattern: args.pattern || "",
-      directory: args.directory || process.cwd(),
-      results: [],
-      total_found: 0,
-      truncated: false,
-      error: `Unexpected error: ${error.message}`
-    };
+    saveTasksToFile();
+    const stats = calculateStats();
+    const progressBar = generateProgressBar(stats.progress);
+    return createResult(true, `Synced ${taskStore.length} tasks ${progressBar} ${stats.progress}%`);
+  }
+  const fullArgs = args;
+  switch (fullArgs.action) {
+    case "list":
+      return listTasks();
+    case "add":
+      return addTasks(fullArgs.tasks);
+    case "complete":
+      if (!fullArgs.taskId) {
+        return createResult(false, "taskId required for complete action");
+      }
+      return completeTask(fullArgs.taskId);
+    case "update":
+      if (!fullArgs.taskId) {
+        return createResult(false, "taskId required for update action");
+      }
+      return updateTask(fullArgs.taskId, fullArgs.description, fullArgs.priority);
+    case "remove":
+      if (!fullArgs.taskId) {
+        return createResult(false, "taskId required for remove action");
+      }
+      return removeTask(fullArgs.taskId);
+    case "clear":
+      return clearCompleted();
+    case "sync":
+      return addTasks(fullArgs.tasks);
+    default:
+      return createResult(false, `Unknown action: ${fullArgs.action}`);
   }
 }
-
-// src/app/agent/tools/natives/grep_search.ts
-import path7 from "path";
-import { promises as fsPromises2 } from "fs";
-var MAX_RESULTS3 = 100;
-var MAX_FILE_SIZE2 = 1024 * 1024;
-var MAX_LINE_LENGTH = 500;
-var DEFAULT_IGNORE2 = [
-  "node_modules",
-  ".git",
-  ".venv",
-  "venv",
-  "__pycache__",
-  ".cache",
-  "dist",
-  "build",
-  ".next",
-  "coverage",
-  "*.min.js",
-  "*.min.css",
-  "*.map",
-  "*.lock",
-  "package-lock.json",
-  "yarn.lock",
-  "pnpm-lock.yaml"
-];
-var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".py",
-  ".pyw",
-  ".java",
-  ".kt",
-  ".scala",
-  ".go",
-  ".rs",
-  ".rb",
-  ".php",
-  ".cs",
-  ".cpp",
-  ".c",
-  ".h",
-  ".hpp",
-  ".swift",
-  ".vue",
-  ".svelte",
-  ".html",
-  ".htm",
-  ".xml",
-  ".svg",
-  ".css",
-  ".scss",
-  ".sass",
-  ".less",
-  ".json",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".md",
-  ".mdx",
-  ".txt",
-  ".rst",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".fish",
-  ".sql",
-  ".graphql",
-  ".gql",
-  ".env",
-  ".env.local",
-  ".env.example",
-  ".gitignore",
-  ".dockerignore",
-  ".eslintrc",
-  ".prettierrc",
-  "Dockerfile",
-  "Makefile",
-  "Rakefile"
-]);
-function isTextFile(filepath) {
-  const ext = path7.extname(filepath).toLowerCase();
-  const basename = path7.basename(filepath);
-  if (TEXT_EXTENSIONS.has(ext)) return true;
-  if (TEXT_EXTENSIONS.has(basename)) return true;
-  if (basename.startsWith(".") && !ext) return true;
-  return false;
-}
-function shouldIgnore2(name) {
-  for (const pattern of DEFAULT_IGNORE2) {
-    if (pattern.includes("*")) {
-      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
-      if (regex.test(name)) return true;
-    } else if (name === pattern) {
+
+// src/app/agent/tools/natives/find_by_name.ts
+import path6 from "path";
+import { promises as fsPromises } from "fs";
+var DEFAULT_IGNORE_PATTERNS = [
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".cache",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".nyc_output",
+  ".pytest_cache",
+  "target",
+  // Rust
+  "vendor"
+  // Go, PHP
+];
+var MAX_RESULTS2 = 100;
+var MAX_DEPTH_DEFAULT = 10;
+function globToRegex(glob) {
+  let regex = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLESTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/{{DOUBLESTAR}}/g, ".*");
+  return new RegExp(`^${regex}$`, "i");
+}
+function shouldIgnore(name, ignorePatterns, includeHidden) {
+  if (!includeHidden && name.startsWith(".")) {
+    return true;
+  }
+  for (const pattern of ignorePatterns) {
+    if (name === pattern || name.match(globToRegex(pattern))) {
       return true;
     }
   }
   return false;
 }
-function createSearchPattern(query, isRegex, caseInsensitive) {
-  try {
-    const flags = caseInsensitive ? "gi" : "g";
-    if (isRegex) {
-      return new RegExp(query, flags);
-    } else {
-      const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      return new RegExp(escaped, flags);
-    }
-  } catch (error) {
-    throw new Error(`Invalid regex pattern: ${error.message}`);
-  }
-}
-function matchesIncludePattern(filename, includePatterns) {
-  if (!includePatterns || includePatterns.length === 0) return true;
-  for (const pattern of includePatterns) {
-    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i");
-    if (regex.test(filename)) return true;
-  }
-  return false;
+function matchesExtensions(filename, extensions) {
+  if (!extensions || extensions.length === 0) return true;
+  const ext = path6.extname(filename).toLowerCase();
+  return extensions.some((e) => {
+    const normalizedExt = e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`;
+    return ext === normalizedExt;
+  });
 }
-async function searchFile(filepath, baseDir, pattern, contextLines, matches, maxResults) {
-  let fileMatches = 0;
-  try {
-    const stats = await fsPromises2.stat(filepath);
-    if (stats.size > MAX_FILE_SIZE2) return 0;
-    const content = await fsPromises2.readFile(filepath, "utf-8");
-    const lines = content.split("\n");
-    const relativePath = path7.relative(baseDir, filepath);
-    for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
-      const line = lines[i];
-      pattern.lastIndex = 0;
-      let match;
-      while ((match = pattern.exec(line)) !== null && matches.length < maxResults) {
-        const lineContent = line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + "..." : line;
-        const searchMatch = {
-          file: filepath,
-          relative_path: relativePath,
-          line_number: i + 1,
-          line_content: lineContent.trim(),
-          match_start: match.index,
-          match_end: match.index + match[0].length
-        };
-        if (contextLines > 0) {
-          searchMatch.context_before = lines.slice(Math.max(0, i - contextLines), i).map((l) => l.length > MAX_LINE_LENGTH ? l.substring(0, MAX_LINE_LENGTH) + "..." : l);
-          searchMatch.context_after = lines.slice(i + 1, i + 1 + contextLines).map((l) => l.length > MAX_LINE_LENGTH ? l.substring(0, MAX_LINE_LENGTH) + "..." : l);
-        }
-        matches.push(searchMatch);
-        fileMatches++;
-        if (!pattern.global) break;
-      }
-    }
-  } catch (error) {
+async function searchDirectory(dir, pattern, baseDir, options, results) {
+  if (options.currentDepth > options.maxDepth || results.length >= MAX_RESULTS2) {
+    return;
   }
-  return fileMatches;
-}
-async function searchDirectory2(dir, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats) {
-  if (matches.length >= maxResults) return;
   let entries;
   try {
-    entries = await fsPromises2.readdir(dir, { withFileTypes: true });
-  } catch {
+    entries = await fsPromises.readdir(dir, { withFileTypes: true });
+  } catch (error) {
     return;
   }
   for (const entry of entries) {
-    if (matches.length >= maxResults) break;
+    if (results.length >= MAX_RESULTS2) break;
     const name = entry.name;
-    if (shouldIgnore2(name)) continue;
-    const fullPath = path7.join(dir, name);
+    if (shouldIgnore(name, options.ignorePatterns, options.includeHidden)) {
+      continue;
+    }
+    const fullPath = path6.join(dir, name);
+    const relativePath = path6.relative(baseDir, fullPath);
     if (entry.isDirectory()) {
-      await searchDirectory2(fullPath, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats);
+      if (pattern.test(name)) {
+        results.push({
+          path: fullPath,
+          relative_path: relativePath,
+          type: "directory"
+        });
+      }
+      await searchDirectory(fullPath, pattern, baseDir, {
+        ...options,
+        currentDepth: options.currentDepth + 1
+      }, results);
     } else if (entry.isFile()) {
-      if (!isTextFile(name)) continue;
-      if (!matchesIncludePattern(name, includePatterns)) continue;
-      stats.filesSearched++;
-      const found = await searchFile(fullPath, baseDir, pattern, contextLines, matches, maxResults);
-      if (found > 0) stats.filesWithMatches++;
+      if (pattern.test(name) && matchesExtensions(name, options.extensions)) {
+        try {
+          const stats = await fsPromises.stat(fullPath);
+          results.push({
+            path: fullPath,
+            relative_path: relativePath,
+            type: "file",
+            size: stats.size,
+            modified: stats.mtime.toISOString()
+          });
+        } catch {
+          results.push({
+            path: fullPath,
+            relative_path: relativePath,
+            type: "file"
+          });
+        }
+      }
     }
   }
 }
-async function grepSearch(args) {
+async function findByName(args) {
   try {
     const {
-      query,
-      path: searchPath,
-      case_insensitive = true,
-      is_regex = false,
-      include_patterns,
-      max_results = MAX_RESULTS3,
-      context_lines = 0
+      pattern,
+      directory = process.cwd(),
+      extensions,
+      max_depth = MAX_DEPTH_DEFAULT,
+      include_hidden = false,
+      exclude_patterns = []
     } = args;
-    if (!query || typeof query !== "string") {
-      return {
-        success: false,
-        query: query || "",
-        search_path: searchPath || "",
-        matches: [],
-        files_searched: 0,
-        files_with_matches: 0,
-        total_matches: 0,
-        truncated: false,
-        error: "Query is required and must be a string"
-      };
-    }
-    if (!searchPath) {
-      return {
-        success: false,
-        query,
-        search_path: "",
-        matches: [],
-        files_searched: 0,
-        files_with_matches: 0,
-        total_matches: 0,
-        truncated: false,
-        error: "Search path is required"
-      };
-    }
-    const resolvedPath = path7.resolve(searchPath);
-    let stats;
-    try {
-      stats = await fsPromises2.stat(resolvedPath);
-    } catch {
+    if (!pattern || typeof pattern !== "string") {
       return {
         success: false,
-        query,
-        search_path: resolvedPath,
-        matches: [],
-        files_searched: 0,
-        files_with_matches: 0,
-        total_matches: 0,
+        pattern: pattern || "",
+        directory,
+        results: [],
+        total_found: 0,
         truncated: false,
-        error: `Path not found: ${resolvedPath}`
+        error: "Pattern is required and must be a string"
       };
     }
-    let pattern;
+    const resolvedDir = path6.resolve(directory);
     try {
-      pattern = createSearchPattern(query, is_regex, case_insensitive);
+      const stats = await fsPromises.stat(resolvedDir);
+      if (!stats.isDirectory()) {
+        return {
+          success: false,
+          pattern,
+          directory: resolvedDir,
+          results: [],
+          total_found: 0,
+          truncated: false,
+          error: `Path is not a directory: ${resolvedDir}`
+        };
+      }
     } catch (error) {
       return {
         success: false,
-        query,
-        search_path: resolvedPath,
-        matches: [],
-        files_searched: 0,
-        files_with_matches: 0,
-        total_matches: 0,
-        truncated: false,
-        error: error.message
-      };
-    }
-    const matches = [];
-    const searchStats = { filesSearched: 0, filesWithMatches: 0 };
-    if (stats.isDirectory()) {
-      await searchDirectory2(
-        resolvedPath,
-        resolvedPath,
         pattern,
-        include_patterns,
-        context_lines,
-        matches,
-        max_results,
-        searchStats
-      );
-    } else if (stats.isFile()) {
-      searchStats.filesSearched = 1;
-      const found = await searchFile(resolvedPath, path7.dirname(resolvedPath), pattern, context_lines, matches, max_results);
-      if (found > 0) searchStats.filesWithMatches = 1;
+        directory: resolvedDir,
+        results: [],
+        total_found: 0,
+        truncated: false,
+        error: `Directory not found: ${resolvedDir}`
+      };
     }
+    const ignorePatterns = [...DEFAULT_IGNORE_PATTERNS, ...exclude_patterns];
+    const patternRegex = globToRegex(pattern);
+    const results = [];
+    await searchDirectory(resolvedDir, patternRegex, resolvedDir, {
+      extensions,
+      maxDepth: max_depth,
+      currentDepth: 0,
+      includeHidden: include_hidden,
+      ignorePatterns
+    }, results);
+    results.sort((a, b) => {
+      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+      return a.relative_path.localeCompare(b.relative_path);
+    });
     return {
       success: true,
-      query,
-      search_path: resolvedPath,
-      matches,
-      files_searched: searchStats.filesSearched,
-      files_with_matches: searchStats.filesWithMatches,
-      total_matches: matches.length,
-      truncated: matches.length >= max_results
+      pattern,
+      directory: resolvedDir,
+      results,
+      total_found: results.length,
+      truncated: results.length >= MAX_RESULTS2
     };
   } catch (error) {
     return {
       success: false,
-      query: args.query || "",
-      search_path: args.path || "",
-      matches: [],
-      files_searched: 0,
-      files_with_matches: 0,
-      total_matches: 0,
+      pattern: args.pattern || "",
+      directory: args.directory || process.cwd(),
+      results: [],
+      total_found: 0,
       truncated: false,
       error: `Unexpected error: ${error.message}`
     };
   }
 }
 
-// src/app/agent/tools/natives/view_file_outline.ts
-import path8 from "path";
-import { promises as fsPromises3 } from "fs";
-var LANGUAGE_MAP = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".java": "java",
-  ".go": "go",
-  ".rs": "rust",
-  ".rb": "ruby",
-  ".php": "php",
-  ".cs": "csharp",
-  ".cpp": "cpp",
-  ".c": "c",
-  ".h": "c",
-  ".hpp": "cpp",
-  ".swift": "swift",
-  ".kt": "kotlin",
-  ".scala": "scala"
-};
-var PATTERNS = {
-  typescript: [
-    // Classes
-    /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w,\s]+)?/,
-    // Interfaces
-    /^(?:export\s+)?interface\s+(\w+)/,
-    // Types
-    /^(?:export\s+)?type\s+(\w+)/,
-    // Functions (standalone)
-    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
-    // Arrow functions assigned to const/let
-    /^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
-    // Methods inside classes (indented)
-    /^\s+(?:public|private|protected|static|async|readonly|\s)*(\w+)\s*\([^)]*\)\s*(?::\s*[\w<>\[\]|&\s]+)?\s*\{/,
-    // Const exports
-    /^(?:export\s+)?const\s+(\w+)\s*[:=]/
-  ],
-  javascript: [
-    /^(?:export\s+)?(?:default\s+)?class\s+(\w+)/,
-    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
-    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
-    /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/,
-    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=/
-  ],
-  python: [
-    /^class\s+(\w+)(?:\([^)]*\))?:/,
-    /^(?:async\s+)?def\s+(\w+)\s*\(/,
-    /^(\w+)\s*=\s*(?:lambda|def)/
-  ],
-  java: [
-    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:abstract)?\s*class\s+(\w+)/,
-    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*interface\s+(\w+)/,
-    /^\s*(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:synchronized)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
-  ],
-  go: [
-    /^type\s+(\w+)\s+struct\s*\{/,
-    /^type\s+(\w+)\s+interface\s*\{/,
-    /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/
-  ],
-  rust: [
-    /^(?:pub\s+)?struct\s+(\w+)/,
-    /^(?:pub\s+)?enum\s+(\w+)/,
-    /^(?:pub\s+)?trait\s+(\w+)/,
-    /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
-    /^impl(?:<[^>]+>)?\s+(?:(\w+)|for\s+(\w+))/
-  ],
-  ruby: [
-    /^class\s+(\w+)/,
-    /^module\s+(\w+)/,
-    /^def\s+(\w+)/
-  ],
-  php: [
-    /^(?:abstract\s+)?class\s+(\w+)/,
-    /^interface\s+(\w+)/,
-    /^(?:public|private|protected)?\s*(?:static)?\s*function\s+(\w+)/
-  ],
-  csharp: [
-    /^(?:public|private|protected|internal)?\s*(?:static)?\s*(?:partial)?\s*class\s+(\w+)/,
-    /^(?:public|private|protected|internal)?\s*interface\s+(\w+)/,
-    /^\s*(?:public|private|protected|internal)?\s*(?:static)?\s*(?:async)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
-  ],
-  swift: [
-    /^(?:public|private|internal|open)?\s*class\s+(\w+)/,
-    /^(?:public|private|internal)?\s*struct\s+(\w+)/,
-    /^(?:public|private|internal)?\s*protocol\s+(\w+)/,
-    /^(?:public|private|internal)?\s*(?:static)?\s*func\s+(\w+)/
-  ],
-  kotlin: [
-    /^(?:open|abstract|sealed)?\s*class\s+(\w+)/,
-    /^interface\s+(\w+)/,
-    /^(?:private|public|internal)?\s*fun\s+(\w+)/
-  ],
-  scala: [
-    /^(?:sealed\s+)?(?:abstract\s+)?class\s+(\w+)/,
-    /^object\s+(\w+)/,
-    /^trait\s+(\w+)/,
-    /^def\s+(\w+)/
-  ],
-  c: [
-    /^(?:static\s+)?(?:inline\s+)?(?:const\s+)?(?:\w+(?:\s*\*)*)\s+(\w+)\s*\([^)]*\)\s*\{/,
-    /^typedef\s+struct\s*\w*\s*\{[^}]*\}\s*(\w+)/,
-    /^struct\s+(\w+)\s*\{/
-  ],
-  cpp: [
-    /^class\s+(\w+)/,
-    /^(?:virtual\s+)?(?:\w+(?:\s*[*&])*)\s+(\w+)\s*\([^)]*\)\s*(?:const)?\s*(?:override)?\s*\{/,
-    /^namespace\s+(\w+)\s*\{/
-  ]
-};
-function detectLanguage(filepath) {
-  const ext = path8.extname(filepath).toLowerCase();
-  return LANGUAGE_MAP[ext] || "unknown";
+// src/app/agent/tools/natives/grep_search.ts
+import path7 from "path";
+import { promises as fsPromises2 } from "fs";
+var MAX_RESULTS3 = 100;
+var MAX_FILE_SIZE2 = 1024 * 1024;
+var MAX_LINE_LENGTH = 500;
+var DEFAULT_IGNORE2 = [
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".cache",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  "*.min.js",
+  "*.min.css",
+  "*.map",
+  "*.lock",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml"
+];
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".pyw",
+  ".java",
+  ".kt",
+  ".scala",
+  ".go",
+  ".rs",
+  ".rb",
+  ".php",
+  ".cs",
+  ".cpp",
+  ".c",
+  ".h",
+  ".hpp",
+  ".swift",
+  ".vue",
+  ".svelte",
+  ".html",
+  ".htm",
+  ".xml",
+  ".svg",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".rst",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".env",
+  ".env.local",
+  ".env.example",
+  ".gitignore",
+  ".dockerignore",
+  ".eslintrc",
+  ".prettierrc",
+  "Dockerfile",
+  "Makefile",
+  "Rakefile"
+]);
+function isTextFile(filepath) {
+  const ext = path7.extname(filepath).toLowerCase();
+  const basename = path7.basename(filepath);
+  if (TEXT_EXTENSIONS.has(ext)) return true;
+  if (TEXT_EXTENSIONS.has(basename)) return true;
+  if (basename.startsWith(".") && !ext) return true;
+  return false;
 }
-function determineItemType(line, language) {
-  const normalizedLine = line.trim().toLowerCase();
-  if (normalizedLine.includes("class ")) return "class";
-  if (normalizedLine.includes("interface ")) return "interface";
-  if (normalizedLine.includes("type ")) return "type";
-  if (normalizedLine.startsWith("import ")) return "import";
-  if (normalizedLine.includes("export ") && !normalizedLine.includes("function") && !normalizedLine.includes("class")) return "export";
-  if (line.startsWith("  ") || line.startsWith("	")) {
-    if (normalizedLine.includes("function") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
-      return "method";
+function shouldIgnore2(name) {
+  for (const pattern of DEFAULT_IGNORE2) {
+    if (pattern.includes("*")) {
+      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+      if (regex.test(name)) return true;
+    } else if (name === pattern) {
+      return true;
     }
-    if (/^\s+\w+\s*\(/.test(line)) return "method";
   }
-  if (normalizedLine.includes("function ") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
-    return "function";
+  return false;
+}
+function createSearchPattern(query, isRegex, caseInsensitive) {
+  try {
+    const flags = caseInsensitive ? "gi" : "g";
+    if (isRegex) {
+      return new RegExp(query, flags);
+    } else {
+      const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(escaped, flags);
+    }
+  } catch (error) {
+    throw new Error(`Invalid regex pattern: ${error.message}`);
   }
-  if (normalizedLine.includes("const ") || normalizedLine.includes("let ") || normalizedLine.includes("var ")) {
-    return normalizedLine.includes("=>") ? "function" : "const";
+}
+function matchesIncludePattern(filename, includePatterns) {
+  if (!includePatterns || includePatterns.length === 0) return true;
+  for (const pattern of includePatterns) {
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i");
+    if (regex.test(filename)) return true;
   }
-  return "function";
+  return false;
 }
-async function extractOutline(filepath, content, language) {
-  const items = [];
-  const lines = content.split("\n");
-  const patterns = PATTERNS[language] || PATTERNS.javascript;
-  let currentClass = null;
-  let braceCount = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const lineNumber = i + 1;
-    const openBraces = (line.match(/\{/g) || []).length;
-    const closeBraces = (line.match(/\}/g) || []).length;
-    braceCount += openBraces - closeBraces;
-    if (braceCount <= 0 && currentClass) {
-      currentClass = null;
-    }
-    for (const pattern of patterns) {
-      const match = line.match(pattern);
-      if (match) {
-        const name = match[1] || match[2];
-        if (!name) continue;
-        const itemType = determineItemType(line, language);
-        if (!itemType) continue;
-        const exported = line.includes("export ");
-        const isInsideClass = currentClass && (line.startsWith("  ") || line.startsWith("	"));
-        const item = {
-          type: itemType,
-          name,
-          line_start: lineNumber,
-          signature: line.trim().substring(0, 120),
-          exported
+async function searchFile(filepath, baseDir, pattern, contextLines, matches, maxResults) {
+  let fileMatches = 0;
+  try {
+    const stats = await fsPromises2.stat(filepath);
+    if (stats.size > MAX_FILE_SIZE2) return 0;
+    const content = await fsPromises2.readFile(filepath, "utf-8");
+    const lines = content.split("\n");
+    const relativePath = path7.relative(baseDir, filepath);
+    for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
+      const line = lines[i];
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(line)) !== null && matches.length < maxResults) {
+        const lineContent = line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + "..." : line;
+        const searchMatch = {
+          file: filepath,
+          relative_path: relativePath,
+          line_number: i + 1,
+          line_content: lineContent.trim(),
+          match_start: match.index,
+          match_end: match.index + match[0].length
         };
-        if (isInsideClass && itemType === "method" && currentClass) {
-          item.parent = currentClass;
-        }
-        if (itemType === "class") {
-          currentClass = name;
+        if (contextLines > 0) {
+          searchMatch.context_before = lines.slice(Math.max(0, i - contextLines), i).map((l) => l.length > MAX_LINE_LENGTH ? l.substring(0, MAX_LINE_LENGTH) + "..." : l);
+          searchMatch.context_after = lines.slice(i + 1, i + 1 + contextLines).map((l) => l.length > MAX_LINE_LENGTH ? l.substring(0, MAX_LINE_LENGTH) + "..." : l);
         }
-        items.push(item);
-        break;
+        matches.push(searchMatch);
+        fileMatches++;
+        if (!pattern.global) break;
       }
     }
+  } catch (error) {
   }
-  return items;
+  return fileMatches;
 }
-function generateSummary(items, totalLines) {
-  const counts = {};
-  for (const item of items) {
-    counts[item.type] = (counts[item.type] || 0) + 1;
+async function searchDirectory2(dir, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats) {
+  if (matches.length >= maxResults) return;
+  let entries;
+  try {
+    entries = await fsPromises2.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (matches.length >= maxResults) break;
+    const name = entry.name;
+    if (shouldIgnore2(name)) continue;
+    const fullPath = path7.join(dir, name);
+    if (entry.isDirectory()) {
+      await searchDirectory2(fullPath, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats);
+    } else if (entry.isFile()) {
+      if (!isTextFile(name)) continue;
+      if (!matchesIncludePattern(name, includePatterns)) continue;
+      stats.filesSearched++;
+      const found = await searchFile(fullPath, baseDir, pattern, contextLines, matches, maxResults);
+      if (found > 0) stats.filesWithMatches++;
+    }
   }
-  const parts = [`${totalLines} lines`];
-  if (counts.class) parts.push(`${counts.class} class${counts.class > 1 ? "es" : ""}`);
-  if (counts.interface) parts.push(`${counts.interface} interface${counts.interface > 1 ? "s" : ""}`);
-  if (counts.function) parts.push(`${counts.function} function${counts.function > 1 ? "s" : ""}`);
-  if (counts.method) parts.push(`${counts.method} method${counts.method > 1 ? "s" : ""}`);
-  if (counts.type) parts.push(`${counts.type} type${counts.type > 1 ? "s" : ""}`);
-  if (counts.const) parts.push(`${counts.const} const${counts.const > 1 ? "s" : ""}`);
-  return parts.join(", ");
 }
-async function viewFileOutline(args) {
+async function grepSearch(args) {
   try {
-    const { file_path } = args;
-    if (!file_path || typeof file_path !== "string") {
+    const {
+      query,
+      path: searchPath,
+      case_insensitive = true,
+      is_regex = false,
+      include_patterns,
+      max_results = MAX_RESULTS3,
+      context_lines = 0
+    } = args;
+    if (!query || typeof query !== "string") {
       return {
         success: false,
-        file_path: file_path || "",
-        language: "unknown",
-        total_lines: 0,
-        items: [],
-        summary: "",
-        error: "file_path is required and must be a string"
+        query: query || "",
+        search_path: searchPath || "",
+        matches: [],
+        files_searched: 0,
+        files_with_matches: 0,
+        total_matches: 0,
+        truncated: false,
+        error: "Query is required and must be a string"
       };
     }
-    const resolvedPath = path8.resolve(file_path);
-    let content;
-    try {
-      content = await fsPromises3.readFile(resolvedPath, "utf-8");
-    } catch (error) {
+    if (!searchPath) {
       return {
         success: false,
-        file_path: resolvedPath,
-        language: "unknown",
-        total_lines: 0,
-        items: [],
-        summary: "",
-        error: error.code === "ENOENT" ? `File not found: ${resolvedPath}` : `Error reading file: ${error.message}`
+        query,
+        search_path: "",
+        matches: [],
+        files_searched: 0,
+        files_with_matches: 0,
+        total_matches: 0,
+        truncated: false,
+        error: "Search path is required"
       };
     }
-    const language = detectLanguage(resolvedPath);
-    const lines = content.split("\n");
-    const totalLines = lines.length;
-    const items = await extractOutline(resolvedPath, content, language);
-    return {
-      success: true,
-      file_path: resolvedPath,
-      language,
-      total_lines: totalLines,
-      items,
-      summary: generateSummary(items, totalLines)
-    };
-  } catch (error) {
-    return {
-      success: false,
-      file_path: args.file_path || "",
-      language: "unknown",
-      total_lines: 0,
-      items: [],
-      summary: "",
-      error: `Unexpected error: ${error.message}`
-    };
-  }
-}
-
-// src/app/agent/tools/natives/async_command.ts
-import os2 from "os";
-import { spawn } from "child_process";
-import { v4 as uuidv42 } from "uuid";
-var runningCommands = /* @__PURE__ */ new Map();
-var MAX_OUTPUT_SIZE = 3e4;
-var MAX_STORED_COMMANDS = 50;
-var OUTPUT_TRUNCATION_MSG = "\n[OUTPUT TRUNCATED - 30KB/200 lines max]";
-var DANGEROUS_PATTERNS = [
-  // Elevação de privilégios
-  /^sudo\s+/i,
-  /^doas\s+/i,
-  /^su\s+/i,
-  /^pkexec\s+/i,
-  /\|\s*sudo\s+/i,
-  /;\s*sudo\s+/i,
-  /&&\s*sudo\s+/i,
-  // Comandos destrutivos
-  /\brm\s+(-[rf]+\s+)*[\/~]/i,
-  /\brm\s+-[rf]*\s+\*/i,
-  /\bchmod\s+(777|666)\s+\//i,
-  /\bdd\s+.*of=\/dev\/(sd|hd|nvme)/i,
-  /\bmkfs\./i,
-  // Fork bombs
-  /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
-  // Remote code exec
-  /\bcurl\s+.*\|\s*(ba)?sh/i,
-  /\bwget\s+.*\|\s*(ba)?sh/i
-];
-var INTERACTIVE_PATTERNS = [
-  /^(vim|vi|nano|emacs|pico)\s*/i,
-  /^(less|more|most)\s*/i,
-  /^(top|htop|btop|atop|nmon)\s*/i,
-  /^(ssh|telnet|ftp|sftp)\s+/i,
-  /^(mysql|psql|redis-cli|mongo|mongosh)\s*$/i,
-  /^(python|python3|node|ruby|irb|lua)\s*$/i,
-  /^(gdb|lldb)\s*/i
-];
-function cleanupOldCommands() {
-  if (runningCommands.size <= MAX_STORED_COMMANDS) return;
-  const commands = Array.from(runningCommands.entries()).filter(([_, cmd]) => cmd.status !== "running").sort((a, b) => (a[1].endTime || 0) - (b[1].endTime || 0));
-  const toRemove = commands.slice(0, commands.length - MAX_STORED_COMMANDS + 10);
-  for (const [id] of toRemove) {
-    runningCommands.delete(id);
-  }
-}
-function isDangerousCommand(command) {
-  const trimmed = command.trim();
-  for (const pattern of DANGEROUS_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return "Command requires elevated privileges (sudo/doas) which cannot be handled in async mode";
-    }
-  }
-  for (const pattern of INTERACTIVE_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return "Interactive commands are not supported in async mode";
-    }
-  }
-  return null;
-}
-async function runCommandAsync(args) {
-  try {
-    const {
-      command,
-      cwd = process.cwd(),
-      timeout = 0
-    } = args;
-    if (!command || typeof command !== "string") {
+    const resolvedPath = path7.resolve(searchPath);
+    let stats;
+    try {
+      stats = await fsPromises2.stat(resolvedPath);
+    } catch {
       return {
         success: false,
-        error: "command is required and must be a string"
+        query,
+        search_path: resolvedPath,
+        matches: [],
+        files_searched: 0,
+        files_with_matches: 0,
+        total_matches: 0,
+        truncated: false,
+        error: `Path not found: ${resolvedPath}`
       };
     }
-    const dangerReason = isDangerousCommand(command);
-    if (dangerReason) {
+    let pattern;
+    try {
+      pattern = createSearchPattern(query, is_regex, case_insensitive);
+    } catch (error) {
       return {
         success: false,
-        error: dangerReason
+        query,
+        search_path: resolvedPath,
+        matches: [],
+        files_searched: 0,
+        files_with_matches: 0,
+        total_matches: 0,
+        truncated: false,
+        error: error.message
       };
     }
-    const commandId = uuidv42().substring(0, 8);
-    const platform = os2.platform();
-    let shellCmd;
-    let shellArgs;
-    if (platform === "win32") {
-      shellCmd = process.env.COMSPEC || "cmd.exe";
-      shellArgs = ["/c", command];
-    } else {
-      shellCmd = process.env.SHELL || "/bin/bash";
-      shellArgs = ["-c", command];
+    const matches = [];
+    const searchStats = { filesSearched: 0, filesWithMatches: 0 };
+    if (stats.isDirectory()) {
+      await searchDirectory2(
+        resolvedPath,
+        resolvedPath,
+        pattern,
+        include_patterns,
+        context_lines,
+        matches,
+        max_results,
+        searchStats
+      );
+    } else if (stats.isFile()) {
+      searchStats.filesSearched = 1;
+      const found = await searchFile(resolvedPath, path7.dirname(resolvedPath), pattern, context_lines, matches, max_results);
+      if (found > 0) searchStats.filesWithMatches = 1;
     }
-    const entry = {
-      id: commandId,
-      command,
-      status: "running",
-      stdout: "",
-      stderr: "",
-      exitCode: null,
-      startTime: Date.now(),
-      process: null
+    return {
+      success: true,
+      query,
+      search_path: resolvedPath,
+      matches,
+      files_searched: searchStats.filesSearched,
+      files_with_matches: searchStats.filesWithMatches,
+      total_matches: matches.length,
+      truncated: matches.length >= max_results
     };
-    const child = spawn(shellCmd, shellArgs, {
-      cwd,
-      env: process.env,
-      windowsHide: true
-    });
-    entry.process = child;
-    let stdoutTruncated = false;
-    child.stdout?.on("data", (data) => {
-      if (!stdoutTruncated) {
-        entry.stdout += data.toString();
-        if (entry.stdout.length > MAX_OUTPUT_SIZE) {
-          entry.stdout = entry.stdout.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
-          stdoutTruncated = true;
-        }
-      }
-    });
-    let stderrTruncated = false;
-    child.stderr?.on("data", (data) => {
-      if (!stderrTruncated) {
-        entry.stderr += data.toString();
-        if (entry.stderr.length > MAX_OUTPUT_SIZE) {
-          entry.stderr = entry.stderr.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
-          stderrTruncated = true;
-        }
-      }
-    });
-    child.on("close", (code) => {
-      entry.exitCode = code;
-      entry.status = code === 0 ? "completed" : "error";
-      entry.endTime = Date.now();
-      entry.process = null;
-    });
-    child.on("error", (error) => {
-      entry.stderr += `
-Process error: ${error.message}`;
-      entry.status = "error";
-      entry.endTime = Date.now();
-      entry.process = null;
-    });
-    if (timeout > 0) {
-      setTimeout(() => {
-        if (entry.status === "running") {
-          child.kill("SIGTERM");
-          setTimeout(() => {
-            if (entry.status === "running") {
-              child.kill("SIGKILL");
-            }
-          }, 2e3);
-          entry.status = "timeout";
-          entry.stderr += `
-Command timed out after ${timeout} seconds`;
-        }
-      }, timeout * 1e3);
+  } catch (error) {
+    return {
+      success: false,
+      query: args.query || "",
+      search_path: args.path || "",
+      matches: [],
+      files_searched: 0,
+      files_with_matches: 0,
+      total_matches: 0,
+      truncated: false,
+      error: `Unexpected error: ${error.message}`
+    };
+  }
+}
+
+// src/app/agent/tools/natives/view_file_outline.ts
+import path8 from "path";
+import { promises as fsPromises3 } from "fs";
+var LANGUAGE_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".java": "java",
+  ".go": "go",
+  ".rs": "rust",
+  ".rb": "ruby",
+  ".php": "php",
+  ".cs": "csharp",
+  ".cpp": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".scala": "scala"
+};
+var PATTERNS = {
+  typescript: [
+    // Classes
+    /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w,\s]+)?/,
+    // Interfaces
+    /^(?:export\s+)?interface\s+(\w+)/,
+    // Types
+    /^(?:export\s+)?type\s+(\w+)/,
+    // Functions (standalone)
+    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
+    // Arrow functions assigned to const/let
+    /^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+    // Methods inside classes (indented)
+    /^\s+(?:public|private|protected|static|async|readonly|\s)*(\w+)\s*\([^)]*\)\s*(?::\s*[\w<>\[\]|&\s]+)?\s*\{/,
+    // Const exports
+    /^(?:export\s+)?const\s+(\w+)\s*[:=]/
+  ],
+  javascript: [
+    /^(?:export\s+)?(?:default\s+)?class\s+(\w+)/,
+    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
+    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+    /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/,
+    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=/
+  ],
+  python: [
+    /^class\s+(\w+)(?:\([^)]*\))?:/,
+    /^(?:async\s+)?def\s+(\w+)\s*\(/,
+    /^(\w+)\s*=\s*(?:lambda|def)/
+  ],
+  java: [
+    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:abstract)?\s*class\s+(\w+)/,
+    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*interface\s+(\w+)/,
+    /^\s*(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:synchronized)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
+  ],
+  go: [
+    /^type\s+(\w+)\s+struct\s*\{/,
+    /^type\s+(\w+)\s+interface\s*\{/,
+    /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/
+  ],
+  rust: [
+    /^(?:pub\s+)?struct\s+(\w+)/,
+    /^(?:pub\s+)?enum\s+(\w+)/,
+    /^(?:pub\s+)?trait\s+(\w+)/,
+    /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
+    /^impl(?:<[^>]+>)?\s+(?:(\w+)|for\s+(\w+))/
+  ],
+  ruby: [
+    /^class\s+(\w+)/,
+    /^module\s+(\w+)/,
+    /^def\s+(\w+)/
+  ],
+  php: [
+    /^(?:abstract\s+)?class\s+(\w+)/,
+    /^interface\s+(\w+)/,
+    /^(?:public|private|protected)?\s*(?:static)?\s*function\s+(\w+)/
+  ],
+  csharp: [
+    /^(?:public|private|protected|internal)?\s*(?:static)?\s*(?:partial)?\s*class\s+(\w+)/,
+    /^(?:public|private|protected|internal)?\s*interface\s+(\w+)/,
+    /^\s*(?:public|private|protected|internal)?\s*(?:static)?\s*(?:async)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
+  ],
+  swift: [
+    /^(?:public|private|internal|open)?\s*class\s+(\w+)/,
+    /^(?:public|private|internal)?\s*struct\s+(\w+)/,
+    /^(?:public|private|internal)?\s*protocol\s+(\w+)/,
+    /^(?:public|private|internal)?\s*(?:static)?\s*func\s+(\w+)/
+  ],
+  kotlin: [
+    /^(?:open|abstract|sealed)?\s*class\s+(\w+)/,
+    /^interface\s+(\w+)/,
+    /^(?:private|public|internal)?\s*fun\s+(\w+)/
+  ],
+  scala: [
+    /^(?:sealed\s+)?(?:abstract\s+)?class\s+(\w+)/,
+    /^object\s+(\w+)/,
+    /^trait\s+(\w+)/,
+    /^def\s+(\w+)/
+  ],
+  c: [
+    /^(?:static\s+)?(?:inline\s+)?(?:const\s+)?(?:\w+(?:\s*\*)*)\s+(\w+)\s*\([^)]*\)\s*\{/,
+    /^typedef\s+struct\s*\w*\s*\{[^}]*\}\s*(\w+)/,
+    /^struct\s+(\w+)\s*\{/
+  ],
+  cpp: [
+    /^class\s+(\w+)/,
+    /^(?:virtual\s+)?(?:\w+(?:\s*[*&])*)\s+(\w+)\s*\([^)]*\)\s*(?:const)?\s*(?:override)?\s*\{/,
+    /^namespace\s+(\w+)\s*\{/
+  ]
+};
+function detectLanguage(filepath) {
+  const ext = path8.extname(filepath).toLowerCase();
+  return LANGUAGE_MAP[ext] || "unknown";
+}
+function determineItemType(line, language) {
+  const normalizedLine = line.trim().toLowerCase();
+  if (normalizedLine.includes("class ")) return "class";
+  if (normalizedLine.includes("interface ")) return "interface";
+  if (normalizedLine.includes("type ")) return "type";
+  if (normalizedLine.startsWith("import ")) return "import";
+  if (normalizedLine.includes("export ") && !normalizedLine.includes("function") && !normalizedLine.includes("class")) return "export";
+  if (line.startsWith("  ") || line.startsWith("	")) {
+    if (normalizedLine.includes("function") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
+      return "method";
     }
-    runningCommands.set(commandId, entry);
-    cleanupOldCommands();
-    return {
-      success: true,
-      command_id: commandId,
-      command,
-      message: `Command started in background. Use command_status with id "${commandId}" to check progress.`
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Unexpected error: ${error.message}`
-    };
+    if (/^\s+\w+\s*\(/.test(line)) return "method";
+  }
+  if (normalizedLine.includes("function ") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
+    return "function";
+  }
+  if (normalizedLine.includes("const ") || normalizedLine.includes("let ") || normalizedLine.includes("var ")) {
+    return normalizedLine.includes("=>") ? "function" : "const";
   }
+  return "function";
 }
-async function commandStatus(args) {
-  try {
-    const {
-      command_id,
-      wait_seconds = 0,
-      output_limit = 1e4
-    } = args;
-    if (!command_id) {
-      return {
-        success: false,
-        command_id: "",
-        status: "error",
-        error: "command_id is required"
-      };
-    }
-    const entry = runningCommands.get(command_id);
-    if (!entry) {
-      return {
-        success: false,
-        command_id,
-        status: "not_found",
-        error: `Command with id "${command_id}" not found. It may have expired or never existed.`
-      };
-    }
-    if (wait_seconds > 0 && entry.status === "running") {
-      await new Promise((resolve) => {
-        const checkInterval = setInterval(() => {
-          if (entry.status !== "running") {
-            clearInterval(checkInterval);
-            resolve();
-          }
-        }, 100);
-        setTimeout(() => {
-          clearInterval(checkInterval);
-          resolve();
-        }, wait_seconds * 1e3);
-      });
-    }
-    let stdout = entry.stdout;
-    let stderr = entry.stderr;
-    let truncated = false;
-    if (stdout.length > output_limit) {
-      stdout = "..." + stdout.substring(stdout.length - output_limit);
-      truncated = true;
+async function extractOutline(filepath, content, language) {
+  const items = [];
+  const lines = content.split("\n");
+  const patterns = PATTERNS[language] || PATTERNS.javascript;
+  let currentClass = null;
+  let braceCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const openBraces = (line.match(/\{/g) || []).length;
+    const closeBraces = (line.match(/\}/g) || []).length;
+    braceCount += openBraces - closeBraces;
+    if (braceCount <= 0 && currentClass) {
+      currentClass = null;
     }
-    if (stderr.length > output_limit) {
-      stderr = "..." + stderr.substring(stderr.length - output_limit);
-      truncated = true;
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const name = match[1] || match[2];
+        if (!name) continue;
+        const itemType = determineItemType(line, language);
+        if (!itemType) continue;
+        const exported = line.includes("export ");
+        const isInsideClass = currentClass && (line.startsWith("  ") || line.startsWith("	"));
+        const item = {
+          type: itemType,
+          name,
+          line_start: lineNumber,
+          signature: line.trim().substring(0, 120),
+          exported
+        };
+        if (isInsideClass && itemType === "method" && currentClass) {
+          item.parent = currentClass;
+        }
+        if (itemType === "class") {
+          currentClass = name;
+        }
+        items.push(item);
+        break;
+      }
     }
-    const duration = entry.endTime ? (entry.endTime - entry.startTime) / 1e3 : (Date.now() - entry.startTime) / 1e3;
-    return {
-      success: true,
-      command_id,
-      status: entry.status,
-      stdout: stdout || void 0,
-      stderr: stderr || void 0,
-      exit_code: entry.exitCode,
-      duration_seconds: Math.round(duration * 10) / 10,
-      truncated
-    };
-  } catch (error) {
-    return {
-      success: false,
-      command_id: args.command_id || "",
-      status: "error",
-      error: `Unexpected error: ${error.message}`
-    };
   }
+  return items;
 }
-async function sendCommandInput(args) {
-  try {
-    const { command_id, input } = args;
-    if (!command_id || input === void 0) {
-      return {
-        success: false,
-        error: "command_id and input are required"
-      };
-    }
-    const entry = runningCommands.get(command_id);
-    if (!entry) {
-      return {
-        success: false,
-        error: `Command with id "${command_id}" not found`
-      };
-    }
-    if (entry.status !== "running" || !entry.process) {
-      return {
-        success: false,
-        error: `Command is not running (status: ${entry.status})`
-      };
-    }
-    entry.process.stdin?.write(input);
-    return {
-      success: true,
-      message: `Sent ${input.length} characters to command ${command_id}`
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to send input: ${error.message}`
-    };
+function generateSummary(items, totalLines) {
+  const counts = {};
+  for (const item of items) {
+    counts[item.type] = (counts[item.type] || 0) + 1;
   }
+  const parts = [`${totalLines} lines`];
+  if (counts.class) parts.push(`${counts.class} class${counts.class > 1 ? "es" : ""}`);
+  if (counts.interface) parts.push(`${counts.interface} interface${counts.interface > 1 ? "s" : ""}`);
+  if (counts.function) parts.push(`${counts.function} function${counts.function > 1 ? "s" : ""}`);
+  if (counts.method) parts.push(`${counts.method} method${counts.method > 1 ? "s" : ""}`);
+  if (counts.type) parts.push(`${counts.type} type${counts.type > 1 ? "s" : ""}`);
+  if (counts.const) parts.push(`${counts.const} const${counts.const > 1 ? "s" : ""}`);
+  return parts.join(", ");
 }
-async function killCommand(args) {
+async function viewFileOutline(args) {
   try {
-    const { command_id } = args;
-    const entry = runningCommands.get(command_id);
-    if (!entry) {
+    const { file_path } = args;
+    if (!file_path || typeof file_path !== "string") {
       return {
         success: false,
-        error: `Command with id "${command_id}" not found`
+        file_path: file_path || "",
+        language: "unknown",
+        total_lines: 0,
+        items: [],
+        summary: "",
+        error: "file_path is required and must be a string"
       };
     }
-    if (entry.status !== "running" || !entry.process) {
+    const resolvedPath = path8.resolve(file_path);
+    let content;
+    try {
+      content = await fsPromises3.readFile(resolvedPath, "utf-8");
+    } catch (error) {
       return {
         success: false,
-        error: `Command is not running (status: ${entry.status})`
+        file_path: resolvedPath,
+        language: "unknown",
+        total_lines: 0,
+        items: [],
+        summary: "",
+        error: error.code === "ENOENT" ? `File not found: ${resolvedPath}` : `Error reading file: ${error.message}`
       };
     }
-    entry.process.kill("SIGTERM");
-    entry.status = "killed";
-    entry.endTime = Date.now();
+    const language = detectLanguage(resolvedPath);
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    const items = await extractOutline(resolvedPath, content, language);
     return {
       success: true,
-      message: `Command ${command_id} killed`
+      file_path: resolvedPath,
+      language,
+      total_lines: totalLines,
+      items,
+      summary: generateSummary(items, totalLines)
     };
   } catch (error) {
     return {
       success: false,
-      error: `Failed to kill command: ${error.message}`
+      file_path: args.file_path || "",
+      language: "unknown",
+      total_lines: 0,
+      items: [],
+      summary: "",
+      error: `Unexpected error: ${error.message}`
     };
   }
 }
 
+// src/app/agent/tool_invoker.ts
+init_async_command();
+
 // src/app/agent/tools/natives/task_boundary.ts
 import path9 from "path";
 import { promises as fs7 } from "fs";
@@ -4107,8 +4128,13 @@ You MUST use \`command_status\` to get the output.
 [Step 1] shell_command({ command: "docker build -t myapp .", timeout: 600 })
 \u2192 { command_id: "cmd_004" }
 
-[Step 2] command_status({ command_id: "cmd_004", wait_seconds: 300 })
-\u2192 { status: "completed", exit_code: 0, truncated: true, stdout: "..." }
+[Step 2] command_status({ command_id: "cmd_004", wait_seconds: 10 })
+\u2192 { status: "running" }
+
+[Step 3] message_notify_user("Building Docker image, please wait...")
+
+[Step 4] command_status({ command_id: "cmd_004", wait_seconds: 10 })
+\u2192 { status: "completed", exit_code: 0, stdout: "Successfully built abc123" }
 \`\`\`
 
 **[WRONG] Never forget command_status:**
@@ -4117,6 +4143,11 @@ shell_command({ command: "npm install" })
 message_notify_user("Installed!") // WRONG: You don't know if it succeeded!
 \`\`\`
 
+**[WRONG] Never use long waits (blocks user):**
+\`\`\`
+command_status({ id: "...", wait_seconds: 300 }) // WRONG: User can't interrupt!
+\`\`\`
+
 **[WRONG] Never use blocked commands:**
 \`\`\`
 shell_command({ command: "sudo apt install ..." }) // BLOCKED
@@ -4126,8 +4157,9 @@ shell_command({ command: "vim file.txt" })         // BLOCKED (interactive)
 
 ### Tips:
 - Always check \`exit_code\` - 0 means success, non-zero is error
-- If \`status: "running"\`, call command_status again with longer wait
-- If \`truncated: true\`, the output was too long - use \`| head\` or \`| tail\`
+- Use wait_seconds: 5-10 for polling (allows user interrupts)
+- If \`status: "running"\`, notify user and poll again
+- If \`truncated: true\`, output was too long - use \`| head\` or \`| tail\`
 - Use \`send_command_input\` for commands that need input (y/n prompts)
 - Use \`kill_command\` to stop a stuck command
 </shell_command>
@@ -6208,6 +6240,61 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
         ]);
         return;
       }
+      if (text.startsWith("!")) {
+        const command = text.slice(1).trim();
+        if (!command) {
+          setIsProcessing(false);
+          return;
+        }
+        setHistory((prev) => [
+          ...prev,
+          {
+            id: prev.length,
+            component: /* @__PURE__ */ jsxs15(Box16, { marginBottom: 1, children: [
+              /* @__PURE__ */ jsx16(Text15, { color: "white", bold: true, children: "$ " }),
+              /* @__PURE__ */ jsx16(Text15, { color: "white", children: command })
+            ] })
+          }
+        ]);
+        Promise.resolve().then(() => (init_async_command(), async_command_exports)).then(async ({ runCommandAsync: runCommandAsync2 }) => {
+          try {
+            const result = await runCommandAsync2({ command, cwd: workdir });
+            if (result.success && result.command_id) {
+              const contextMessage = `[User executed shell command directly]
+Command: ${command}
+Command ID: ${result.command_id}
+
+Please use command_status to check the result and report back to the user.`;
+              agentInstance.current?.processTurn({ content: contextMessage });
+            } else {
+              setHistory((prev) => [
+                ...prev,
+                {
+                  id: prev.length,
+                  component: /* @__PURE__ */ jsxs15(Text15, { color: "red", children: [
+                    "Failed to execute: ",
+                    result.error || result.message
+                  ] })
+                }
+              ]);
+              setIsProcessing(false);
+            }
+          } catch (err) {
+            setHistory((prev) => [
+              ...prev,
+              {
+                id: prev.length,
+                component: /* @__PURE__ */ jsxs15(Text15, { color: "red", children: [
+                  "Error: ",
+                  err.message
+                ] })
+              }
+            ]);
+            setIsProcessing(false);
+          }
+        });
+        return;
+      }
       setIsProcessing(true);
       const displayText = text.length > 1e4 ? text.substring(0, 1e4) + "..." : text;
       setHistory((prev) => [