@xagent/one-shot 1.2.0 → 1.2.2

package/dist/index.js

@@ -23,8 +23,8 @@ import * as readline from 'readline';
 import React4, { useState, useRef, useEffect, useMemo, useCallback } from 'react';
 import { render, Box, Text, useApp, useInput } from 'ink';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import chalk2 from 'chalk';
 import { program, Command } from 'commander';
-import chalk from 'chalk';
 import * as dotenv from 'dotenv';
 
 var __create = Object.create;
@@ -726,7 +726,7 @@ var init_client2 = __esm({
             },
             {
               capabilities: {
-                tools: {}
+                // Client capabilities - not tools (tools are for servers)
               }
             }
           );
@@ -7562,10 +7562,10 @@ var init_dependency_analyzer = __esm({
         const circularDeps = [];
         const visited = /* @__PURE__ */ new Set();
         const visiting = /* @__PURE__ */ new Set();
-        const dfs = (filePath, path38) => {
+        const dfs = (filePath, path39) => {
           if (visiting.has(filePath)) {
-            const cycleStart = path38.indexOf(filePath);
-            const cycle = path38.slice(cycleStart).concat([filePath]);
+            const cycleStart = path39.indexOf(filePath);
+            const cycle = path39.slice(cycleStart).concat([filePath]);
             circularDeps.push({
               cycle: cycle.map((fp) => graph.nodes.get(fp)?.filePath || fp),
               severity: cycle.length <= 2 ? "error" : "warning",
@@ -7581,7 +7581,7 @@ var init_dependency_analyzer = __esm({
           if (node) {
             for (const dependency of node.dependencies) {
               if (graph.nodes.has(dependency)) {
-                dfs(dependency, [...path38, filePath]);
+                dfs(dependency, [...path39, filePath]);
               }
             }
           }
@@ -12740,8 +12740,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path38, errorMaps, issueData } = params;
-      const fullPath = [...path38, ...issueData.path || []];
+      const { data, path: path39, errorMaps, issueData } = params;
+      const fullPath = [...path39, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -13049,11 +13049,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path38, key) {
+      constructor(parent, value, path39, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path38;
+        this._path = path39;
         this._key = key;
       }
       get path() {
@@ -18384,6 +18384,10 @@ var init_grok_agent = __esm({
         this.minRequestInterval = 500;
         // ms
         this.lastRequestTime = 0;
+        this.recentToolCalls = /* @__PURE__ */ new Map();
+        // Track recent tool calls to prevent duplicates
+        this.duplicateWindowMs = 2e3;
+        // 2 second window for duplicate detection
         // Plan Mode integration
         this.planModeState = null;
         this.readonlyOverlay = null;
@@ -18445,6 +18449,13 @@ The above project context should inform your responses and decision making.` : "
           role: "system",
           content: `You are Grok One-Shot, an AI-powered CLI assistant that helps with file editing, coding tasks, and system operations.${customInstructionsSection}${contextSection}${verbosityInstructions}
 
+\u{1F6A8} CRITICAL TOOL CALLING RULES:
+- NEVER use multiple tool calls in a single response
+- NEVER concatenate tool calls like "view_fileview_file" or "str_replace_editorstr_replace_editor"
+- ALWAYS use ONE tool call per message with proper XML structure
+- WAIT for tool results before making additional tool calls
+- Each tool call must have valid JSON arguments only
+
 You have access to these tools:
 
 CORE TOOLS:
@@ -18979,6 +18990,24 @@ Current working directory: ${process.cwd()}`
       }
       async executeTool(toolCall) {
         try {
+          const toolName = toolCall.function?.name;
+          const now = Date.now();
+          const callSignature = `${toolName}:${toolCall.function?.arguments || ""}`;
+          const lastCallTime = this.recentToolCalls.get(callSignature);
+          if (lastCallTime && now - lastCallTime < this.duplicateWindowMs) {
+            console.log(`[GrokAgent] Skipping duplicate tool call: ${toolName}`);
+            return {
+              success: true,
+              output: "Skipped duplicate tool call",
+              details: `This tool call was already executed ${Math.round((now - lastCallTime) / 1e3)}s ago`
+            };
+          }
+          this.recentToolCalls.set(callSignature, now);
+          for (const [key, time] of this.recentToolCalls.entries()) {
+            if (now - time > this.duplicateWindowMs) {
+              this.recentToolCalls.delete(key);
+            }
+          }
           const planModeState = this.getPlanModeState();
           if (planModeState?.active) {
             const readonlyOverlay = this.getReadonlyOverlay();
@@ -18986,6 +19015,25 @@ Current working directory: ${process.cwd()}`
               return await readonlyOverlay.interceptToolCall(toolCall);
             }
           }
+          if (!toolCall.function?.arguments) {
+            console.error(`[GrokAgent] Tool call missing function arguments:`, toolCall);
+            return {
+              success: false,
+              error: `Tool call ${toolCall.function?.name || "unknown"} missing required arguments`,
+              details: `This appears to be a malformed tool call. The AI model may have generated invalid XML or concatenated multiple tool calls.`
+            };
+          }
+          if (typeof toolCall.function.arguments === "string" && (toolCall.function.arguments.includes("str_replace_editorstr_replace_editor") || toolCall.function.arguments.includes("view_fileview_file") || toolCall.function.arguments.includes("create_filecreate_file") || toolCall.function.arguments.includes("}{") || toolCall.function.name?.includes("view_file") && toolCall.function.name !== "view_file")) {
+            console.error(`[GrokAgent] Detected malformed XML in tool call - appears to be concatenated:`, {
+              toolName: toolCall.function.name,
+              arguments: toolCall.function.arguments
+            });
+            return {
+              success: false,
+              error: `Malformed tool call detected - appears to be concatenated XML without proper structure`,
+              details: `The AI model generated invalid XML by concatenating multiple tool calls. This is a model generation issue that requires single, properly formatted tool calls.`
+            };
+          }
           let args;
           try {
             args = JSON.parse(toolCall.function.arguments);
@@ -18997,14 +19045,14 @@ Current working directory: ${process.cwd()}`
               toolCall
             });
             try {
-              const cleanedArgs = toolCall.function.arguments.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").trim();
+              const cleanedArgs = toolCall.function.arguments.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").replace(/^\s*{?\s*/, "{").replace(/\s*}?\s*$/, "}").trim();
               args = JSON.parse(cleanedArgs);
               console.log(`[GrokAgent] JSON parsing recovered after cleanup`);
             } catch (retryError) {
               return {
                 success: false,
                 error: `Invalid JSON arguments for ${toolCall.function.name}: ${parseError.message}. Arguments: ${toolCall.function.arguments}`,
-                details: `Tool call failed due to malformed JSON. This is likely a model generation issue.`
+                details: `Tool call failed due to malformed JSON. This is likely a model generation issue. Try using single tool calls with proper XML structure.`
               };
             }
           }
@@ -19050,10 +19098,10 @@ Current working directory: ${process.cwd()}`
                 return await this.textEditor.view(args.path, range);
               } catch (error) {
                 console.warn(`view_file tool failed, falling back to bash: ${error.message}`);
-                const path38 = args.path;
-                let command = `cat "${path38}"`;
+                const path39 = args.path;
+                let command = `cat "${path39}"`;
                 if (args.start_line && args.end_line) {
-                  command = `sed -n '${args.start_line},${args.end_line}p' "${path38}"`;
+                  command = `sed -n '${args.start_line},${args.end_line}p' "${path39}"`;
                 }
                 return await this.bash.execute(command);
               }
@@ -19264,6 +19312,25 @@ EOF`;
       }
       async executeMCPTool(toolCall) {
         try {
+          if (!toolCall.function?.arguments) {
+            console.error(`[GrokAgent] MCP tool call missing function arguments:`, toolCall);
+            return {
+              success: false,
+              error: `MCP tool call ${toolCall.function?.name || "unknown"} missing required arguments`,
+              details: `This appears to be a malformed MCP tool call. The AI model may have generated invalid XML or concatenated multiple tool calls.`
+            };
+          }
+          if (typeof toolCall.function.arguments === "string" && (toolCall.function.arguments.includes("mcp__") && toolCall.function.arguments.match(/mcp__\w+mcp__/) || toolCall.function.name?.startsWith("mcp__") && toolCall.function.name.split("__").length > 3)) {
+            console.error(`[GrokAgent] Detected malformed XML in MCP tool call:`, {
+              toolName: toolCall.function.name,
+              arguments: toolCall.function.arguments
+            });
+            return {
+              success: false,
+              error: `Malformed MCP tool call detected - appears to be concatenated XML`,
+              details: `The AI model generated invalid XML by concatenating multiple MCP tool calls. Use single, properly formatted tool calls only.`
+            };
+          }
           let args;
           try {
             args = JSON.parse(toolCall.function.arguments);
@@ -19275,7 +19342,7 @@ EOF`;
               toolCall
             });
             try {
-              const cleanedArgs = toolCall.function.arguments.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").trim();
+              const cleanedArgs = toolCall.function.arguments.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").replace(/^\s*{?\s*/, "{").replace(/\s*}?\s*$/, "}").trim();
               args = JSON.parse(cleanedArgs);
               console.log(`[GrokAgent] MCP JSON parsing recovered after cleanup`);
             } catch (retryError) {
@@ -19634,6 +19701,10 @@ ${output?.plan?.summary || "Task completed"}`,
             instructions += "- Keep responses CONCISE and to the point. Avoid lengthy explanations.\n";
             instructions += "- Prioritize brevity over detail unless specifically requested.\n";
             instructions += "- Use minimal formatting and avoid verbose tool descriptions.\n";
+            instructions += "- NEVER use separators like ### or --- between tool results and your response.\n";
+            instructions += "- Provide analysis immediately after tools without visual dividers.\n";
+            instructions += "- You may use **bold** and _italic_ for emphasis when helpful.\n";
+            instructions += "- Match Claude Code style: tool outputs followed by clean, well-formatted analysis.\n";
             break;
           case "normal":
             instructions += "- Provide balanced responses with appropriate detail.\n";
@@ -19659,6 +19730,11 @@ ${output?.plan?.summary || "Task completed"}`,
             instructions += "- Provide detailed context for all operations.\n";
             break;
         }
+        instructions += "\n";
+        instructions += "\n\u{1F4A1} VISUAL FORMATTING:\n";
+        instructions += "- Use emojis for status: \u2705 success, \u274C error, \u26A0\uFE0F warning, \u{1F4A1} tips\n";
+        instructions += "- Add checkmarks for completed features or working items\n";
+        instructions += "- Use appropriate emojis to make responses more scannable\n";
         return instructions;
       }
       // Plan Mode integration methods
@@ -19863,150 +19939,21 @@ var init_use_input_history = __esm({
   "src/hooks/use-input-history.ts"() {
   }
 });
-
-// src/services/paste-detection.ts
-function getPasteDetectionService() {
-  if (!globalPasteService) {
-    globalPasteService = new PasteDetectionService();
-  }
-  return globalPasteService;
-}
-var PasteDetectionService, globalPasteService;
-var init_paste_detection = __esm({
-  "src/services/paste-detection.ts"() {
-    PasteDetectionService = class {
-      constructor(thresholds) {
-        this.pasteCounter = 0;
-        this.debug = process.env.GROK_PASTE_DEBUG === "true";
-        this.thresholds = {
-          lineThreshold: thresholds?.lineThreshold ?? this.getDefaultLineThreshold(),
-          charThreshold: thresholds?.charThreshold ?? this.getDefaultCharThreshold()
-        };
-      }
-      /**
-       * Detects if new content represents a paste operation that should be summarized
-       */
-      detectPaste(oldValue, newValue) {
-        const added = this.getAddedContent(oldValue, newValue);
-        if (this.debug) {
-          console.log("\u{1F50D} Paste Detection Debug:", {
-            addedLength: added?.length || 0,
-            lineCount: added ? this.countLines(added) : 0,
-            thresholds: this.thresholds,
-            shouldSummarize: added ? this.shouldSummarize(added) : false
-          });
-        }
-        if (!added || !this.shouldSummarize(added)) {
-          return null;
-        }
-        this.pasteCounter++;
-        return {
-          content: added,
-          lineCount: this.countLines(added),
-          charCount: added.length,
-          pasteNumber: this.pasteCounter,
-          summary: this.createPasteSummary(added, this.pasteCounter)
-        };
-      }
-      /**
-       * Determines if content should be summarized based on thresholds
-       */
-      shouldSummarize(content) {
-        const lineCount = this.countLines(content);
-        return lineCount > this.thresholds.lineThreshold || content.length > this.thresholds.charThreshold;
-      }
-      /**
-       * Creates a paste summary in the format: [Pasted text #N +X lines]
-       */
-      createPasteSummary(content, pasteNumber) {
-        const lineCount = this.countLines(content);
-        const pluralLines = lineCount === 1 ? "line" : "lines";
-        return `[Pasted text #${pasteNumber} +${lineCount} ${pluralLines}]`;
-      }
-      /**
-       * Resets the paste counter (useful for new sessions)
-       */
-      resetCounter() {
-        this.pasteCounter = 0;
-      }
-      /**
-       * Updates thresholds for paste detection
-       */
-      updateThresholds(thresholds) {
-        this.thresholds = {
-          ...this.thresholds,
-          ...thresholds
-        };
-      }
-      /**
-       * Gets current paste counter value
-       */
-      getCurrentCounter() {
-        return this.pasteCounter;
-      }
-      /**
-       * Gets current thresholds
-       */
-      getThresholds() {
-        return { ...this.thresholds };
-      }
-      /**
-       * Extracts the content that was added between old and new values
-       */
-      getAddedContent(oldValue, newValue) {
-        if (newValue.startsWith(oldValue)) {
-          return newValue.slice(oldValue.length);
-        }
-        return "";
-      }
-      /**
-       * Counts the number of lines in content
-       */
-      countLines(content) {
-        if (!content) return 0;
-        const lines = content.split(/\r\n|\r|\n/);
-        return lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
-      }
-      /**
-       * Gets default line threshold from environment or config
-       */
-      getDefaultLineThreshold() {
-        const envValue = process.env.GROK_PASTE_LINE_THRESHOLD;
-        if (envValue) {
-          const parsed = parseInt(envValue, 10);
-          if (!isNaN(parsed) && parsed > 0) {
-            return parsed;
-          }
-        }
-        return 2;
-      }
-      /**
-       * Gets default character threshold from environment or config
-       */
-      getDefaultCharThreshold() {
-        const envValue = process.env.GROK_PASTE_CHAR_THRESHOLD;
-        if (envValue) {
-          const parsed = parseInt(envValue, 10);
-          if (!isNaN(parsed) && parsed > 0) {
-            return parsed;
-          }
-        }
-        return 50;
-      }
-    };
-    globalPasteService = null;
-  }
-});
 function useEnhancedInput({
   onSubmit,
   onEscape,
   onSpecialKey,
-  onPasteDetected,
   disabled = false,
   multiline = false
 } = {}) {
   const [input, setInputState] = useState("");
   const [cursorPosition, setCursorPositionState] = useState(0);
+  const debugSetInputState = useCallback((newInput) => {
+    setInputState(newInput);
+  }, []);
+  const debugSetCursorPositionState = useCallback((newPos) => {
+    setCursorPositionState(newPos);
+  }, []);
   const isMultilineRef = useRef(multiline);
   const {
     addToHistory,
@@ -20016,32 +19963,34 @@ function useEnhancedInput({
     isNavigatingHistory
   } = useInputHistory();
   const setInput = useCallback((text) => {
-    const previousInput = input;
-    setInputState(text);
-    setCursorPositionState(Math.min(text.length, cursorPosition));
+    enhancedLog("\u{1F504} setInput called");
+    enhancedLog("setInput details:", {
+      previousInput: input.slice(0, 100) + (input.length > 100 ? "..." : ""),
+      newText: text.slice(0, 100) + (text.length > 100 ? "..." : ""),
+      previousLength: input.length,
+      newLength: text.length,
+      cursorPosition,
+      isNavigatingHistory: isNavigatingHistory()
+    });
+    debugSetInputState(text);
+    debugSetCursorPositionState(Math.min(text.length, cursorPosition));
     if (!isNavigatingHistory()) {
       setOriginalInput(text);
     }
-    if (onPasteDetected && text !== previousInput) {
-      const pasteService = getPasteDetectionService();
-      const pasteEvent = pasteService.detectPaste(previousInput, text);
-      if (pasteEvent) {
-        onPasteDetected(pasteEvent);
-      }
-    }
-  }, [input, cursorPosition, isNavigatingHistory, setOriginalInput, onPasteDetected]);
+    enhancedLog("\u2705 setInput completed");
+  }, [input, cursorPosition, isNavigatingHistory, setOriginalInput]);
   const setCursorPosition = useCallback((position) => {
-    setCursorPositionState(Math.max(0, Math.min(input.length, position)));
-  }, [input.length]);
+    debugSetCursorPositionState(Math.max(0, Math.min(input.length, position)));
+  }, [input.length, debugSetCursorPositionState]);
   const clearInput = useCallback(() => {
-    setInputState("");
-    setCursorPositionState(0);
+    debugSetInputState("");
+    debugSetCursorPositionState(0);
     setOriginalInput("");
-  }, [setOriginalInput]);
+  }, [setOriginalInput, debugSetInputState, debugSetCursorPositionState]);
   const insertAtCursor = useCallback((text) => {
     const result = insertText(input, cursorPosition, text);
-    setInputState(result.text);
-    setCursorPositionState(result.position);
+    debugSetInputState(result.text);
+    debugSetCursorPositionState(result.position);
     setOriginalInput(result.text);
   }, [input, cursorPosition, setOriginalInput]);
   const handleSubmit = useCallback(() => {
@@ -20052,10 +20001,31 @@ function useEnhancedInput({
     }
   }, [input, addToHistory, onSubmit, clearInput]);
   const handleInput = useCallback((inputChar, key) => {
-    if (disabled) return;
+    enhancedLog("\u2328\uFE0F handleInput called");
+    enhancedLog("Input event:", {
+      inputChar: inputChar === "" ? "(empty)" : inputChar,
+      charCode: inputChar.charCodeAt(0) || "N/A",
+      key: {
+        name: key.name || "undefined",
+        ctrl: !!key.ctrl,
+        meta: !!key.meta,
+        shift: !!key.shift,
+        paste: !!key.paste,
+        return: !!key.return,
+        backspace: !!key.backspace,
+        delete: !!key.delete
+      },
+      currentInput: input.slice(0, 50) + (input.length > 50 ? "..." : ""),
+      currentInputLength: input.length,
+      disabled
+    });
+    if (disabled) {
+      enhancedLog("\u274C Input disabled, returning early");
+      return;
+    }
     if (key.ctrl && inputChar === "c" || inputChar === "") {
-      setInputState("");
-      setCursorPositionState(0);
+      debugSetInputState("");
+      debugSetCursorPositionState(0);
       setOriginalInput("");
       return;
     }
@@ -20069,8 +20039,8 @@ function useEnhancedInput({
     if (key.return) {
       if (multiline && key.shift) {
         const result = insertText(input, cursorPosition, "\n");
-        setInputState(result.text);
-        setCursorPositionState(result.position);
+        debugSetInputState(result.text);
+        debugSetCursorPositionState(result.position);
         setOriginalInput(result.text);
       } else {
         handleSubmit();
@@ -20080,58 +20050,58 @@ function useEnhancedInput({
     if ((key.upArrow || key.name === "up") && !key.ctrl && !key.meta) {
       const historyInput = navigateHistory("up");
       if (historyInput !== null) {
-        setInputState(historyInput);
-        setCursorPositionState(historyInput.length);
+        debugSetInputState(historyInput);
+        debugSetCursorPositionState(historyInput.length);
       }
       return;
     }
     if ((key.downArrow || key.name === "down") && !key.ctrl && !key.meta) {
       const historyInput = navigateHistory("down");
       if (historyInput !== null) {
-        setInputState(historyInput);
-        setCursorPositionState(historyInput.length);
+        debugSetInputState(historyInput);
+        debugSetCursorPositionState(historyInput.length);
       }
       return;
     }
     if ((key.leftArrow || key.name === "left") && key.ctrl && !inputChar.includes("[")) {
       const newPos = moveToPreviousWord(input, cursorPosition);
-      setCursorPositionState(newPos);
+      debugSetCursorPositionState(newPos);
       return;
     }
     if ((key.rightArrow || key.name === "right") && key.ctrl && !inputChar.includes("[")) {
       const newPos = moveToNextWord(input, cursorPosition);
-      setCursorPositionState(newPos);
+      debugSetCursorPositionState(newPos);
       return;
     }
     if (key.leftArrow || key.name === "left") {
       const newPos = Math.max(0, cursorPosition - 1);
-      setCursorPositionState(newPos);
+      debugSetCursorPositionState(newPos);
       return;
     }
     if (key.rightArrow || key.name === "right") {
       const newPos = Math.min(input.length, cursorPosition + 1);
-      setCursorPositionState(newPos);
+      debugSetCursorPositionState(newPos);
       return;
     }
     if (key.ctrl && inputChar === "a" || key.name === "home") {
-      setCursorPositionState(0);
+      debugSetCursorPositionState(0);
       return;
     }
     if (key.ctrl && inputChar === "e" || key.name === "end") {
-      setCursorPositionState(input.length);
+      debugSetCursorPositionState(input.length);
       return;
     }
     const isBackspace = key.backspace || key.name === "backspace" || inputChar === "\b" || inputChar === "\x7F" || key.delete && inputChar === "" && !key.shift;
     if (isBackspace) {
       if (key.ctrl || key.meta) {
         const result = deleteWordBefore(input, cursorPosition);
-        setInputState(result.text);
-        setCursorPositionState(result.position);
+        debugSetInputState(result.text);
+        debugSetCursorPositionState(result.position);
         setOriginalInput(result.text);
       } else {
         const result = deleteCharBefore(input, cursorPosition);
-        setInputState(result.text);
-        setCursorPositionState(result.position);
+        debugSetInputState(result.text);
+        debugSetCursorPositionState(result.position);
         setOriginalInput(result.text);
       }
       return;
@@ -20139,13 +20109,13 @@ function useEnhancedInput({
     if (key.delete && inputChar !== "" || key.ctrl && inputChar === "d") {
       if (key.ctrl || key.meta) {
         const result = deleteWordAfter(input, cursorPosition);
-        setInputState(result.text);
-        setCursorPositionState(result.position);
+        debugSetInputState(result.text);
+        debugSetCursorPositionState(result.position);
         setOriginalInput(result.text);
       } else {
         const result = deleteCharAfter(input, cursorPosition);
-        setInputState(result.text);
-        setCursorPositionState(result.position);
+        debugSetInputState(result.text);
+        debugSetCursorPositionState(result.position);
         setOriginalInput(result.text);
       }
       return;
@@ -20153,36 +20123,57 @@ function useEnhancedInput({
     if (key.ctrl && inputChar === "k") {
       const lineEnd = moveToLineEnd(input, cursorPosition);
       const newText = input.slice(0, cursorPosition) + input.slice(lineEnd);
-      setInputState(newText);
+      debugSetInputState(newText);
       setOriginalInput(newText);
       return;
     }
     if (key.ctrl && inputChar === "u") {
       const lineStart = moveToLineStart(input, cursorPosition);
       const newText = input.slice(0, lineStart) + input.slice(cursorPosition);
-      setInputState(newText);
-      setCursorPositionState(lineStart);
+      debugSetInputState(newText);
+      debugSetCursorPositionState(lineStart);
       setOriginalInput(newText);
       return;
     }
     if (key.ctrl && inputChar === "w") {
       const result = deleteWordBefore(input, cursorPosition);
-      setInputState(result.text);
-      setCursorPositionState(result.position);
+      debugSetInputState(result.text);
+      debugSetCursorPositionState(result.position);
       setOriginalInput(result.text);
       return;
     }
     if (key.ctrl && inputChar === "x") {
-      setInputState("");
-      setCursorPositionState(0);
+      debugSetInputState("");
+      debugSetCursorPositionState(0);
       setOriginalInput("");
       return;
     }
     if (inputChar && !key.ctrl && !key.meta) {
+      enhancedLog("\u{1F4DD} Regular character input detected");
+      enhancedLog("Character details:", {
+        character: inputChar,
+        currentPosition: cursorPosition,
+        currentInputLength: input.length,
+        willInsertAt: cursorPosition
+      });
       const result = insertText(input, cursorPosition, inputChar);
-      setInputState(result.text);
-      setCursorPositionState(result.position);
+      enhancedLog("\u{1F4DD} Text insertion result:", {
+        oldLength: input.length,
+        newLength: result.text.length,
+        newPosition: result.position,
+        insertedChar: inputChar
+      });
+      debugSetInputState(result.text);
+      debugSetCursorPositionState(result.position);
       setOriginalInput(result.text);
+      enhancedLog("\u2705 Regular character input completed");
+    } else {
+      enhancedLog("\u274C Character input skipped:", {
+        hasInputChar: !!inputChar,
+        isCtrl: !!key.ctrl,
+        isMeta: !!key.meta,
+        reason: !inputChar ? "No input char" : key.ctrl ? "Ctrl pressed" : "Meta pressed"
+      });
     }
   }, [disabled, onSpecialKey, input, cursorPosition, multiline, handleSubmit, navigateHistory, setOriginalInput]);
   return {
@@ -20197,11 +20188,13 @@ function useEnhancedInput({
     handleInput
   };
 }
+var enhancedLog;
 var init_use_enhanced_input = __esm({
   "src/hooks/use-enhanced-input.ts"() {
     init_text_utils();
     init_use_input_history();
-    init_paste_detection();
+    enhancedLog = (..._args) => {
+    };
   }
 });
 
@@ -27099,7 +27092,7 @@ var init_package = __esm({
     package_default = {
       type: "module",
       name: "@xagent/one-shot",
-      version: "1.2.0",
+      version: "1.2.2",
       description: "An open-source AI agent that brings advanced AI capabilities directly into your terminal with automatic documentation updates.",
       main: "dist/index.js",
       module: "dist/index.js",
@@ -27518,23 +27511,6 @@ function useInputHandler({
       }
     }
   };
-  const handlePasteDetected = (pasteEvent) => {
-    const userEntry = {
-      type: "user",
-      content: pasteEvent.content,
-      // Full content for AI (when submitted)
-      displayContent: pasteEvent.summary,
-      // Summary for UI display
-      timestamp: /* @__PURE__ */ new Date(),
-      isPasteSummary: true,
-      pasteMetadata: {
-        pasteNumber: pasteEvent.pasteNumber,
-        lineCount: pasteEvent.lineCount,
-        charCount: pasteEvent.charCount
-      }
-    };
-    setChatHistory((prev) => [...prev, userEntry]);
-  };
   const handleInputChange = (newInput) => {
     if (newInput.startsWith("/")) {
       setShowCommandSuggestions(true);
@@ -27550,20 +27526,75 @@ function useInputHandler({
     setInput,
     setCursorPosition,
     clearInput,
+    insertAtCursor,
     resetHistory,
     handleInput
   } = useEnhancedInput({
     onSubmit: handleInputSubmit,
     onSpecialKey: handleSpecialKey,
-    onPasteDetected: handlePasteDetected,
+    // Paste detection handled inline
     disabled: isConfirmationActive,
     multiline: true
     // Enable multiline mode to handle pasted content properly
   });
+  if (typeof globalThis.grokPasteCache === "undefined") {
+    globalThis.grokPasteCache = /* @__PURE__ */ new Map();
+  }
+  if (typeof globalThis.grokPasteCounter === "undefined") {
+    globalThis.grokPasteCounter = 0;
+  }
   useInput((inputChar, key) => {
     if (onGlobalShortcut && onGlobalShortcut(inputChar, key)) {
       return;
     }
+    if (inputChar.length > 1) {
+      const existingInputBeforePaste = input;
+      const cursorPositionBeforePaste = cursorPosition;
+      if (!globalThis.grokStreamingPasteBuffer) {
+        globalThis.grokExistingInputBeforePaste = existingInputBeforePaste;
+        globalThis.grokCursorPositionBeforePaste = cursorPositionBeforePaste;
+      }
+      if (!globalThis.grokStreamingPasteBuffer) {
+        globalThis.grokStreamingPasteBuffer = "";
+      }
+      globalThis.grokStreamingPasteBuffer += inputChar;
+      setTimeout(() => {
+        const pastedContent = globalThis.grokStreamingPasteBuffer;
+        if (pastedContent && (pastedContent.length > 100 || pastedContent.split(/\r\n|\r|\n/).length > 10)) {
+          const lines = pastedContent.split(/\r\n|\r|\n/);
+          globalThis.grokPasteCounter += 1;
+          const summary = `[Pasted text #${globalThis.grokPasteCounter} +${lines.length} lines]`;
+          globalThis.grokPasteCache.set(summary, pastedContent);
+          const existingInput2 = globalThis.grokExistingInputBeforePaste || "";
+          const cursorPos = globalThis.grokCursorPositionBeforePaste || 0;
+          setInput(existingInput2);
+          setCursorPosition(cursorPos);
+          setTimeout(() => {
+            insertAtCursor(summary);
+          }, 10);
+          const pasteConfirmationEntry = {
+            type: "assistant",
+            content: `\u{1F4C4} Large paste detected: ${lines.length} lines, showing summary`,
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          setChatHistory((prev) => [...prev, pasteConfirmationEntry]);
+        } else if (pastedContent) {
+          const existingInput2 = globalThis.grokExistingInputBeforePaste || "";
+          const cursorPos = globalThis.grokCursorPositionBeforePaste || 0;
+          const beforeCursor = existingInput2.slice(0, cursorPos);
+          const afterCursor = existingInput2.slice(cursorPos);
+          const combinedContent = beforeCursor + pastedContent + afterCursor;
+          setInput(combinedContent);
+          setTimeout(() => {
+            setCursorPosition(beforeCursor.length + pastedContent.length);
+          }, 0);
+        }
+        globalThis.grokStreamingPasteBuffer = void 0;
+        globalThis.grokExistingInputBeforePaste = void 0;
+        globalThis.grokCursorPositionBeforePaste = void 0;
+      }, 100);
+      return;
+    }
     handleInput(inputChar, key);
   });
   useEffect(() => {
@@ -28793,12 +28824,12 @@ Auto-compact automatically enables compact mode when conversations exceed thresh
           content: `\u{1F50A} **Current Verbosity Level: ${verbosityLevel.toUpperCase()}**
 
 **Available levels:**
-- \`quiet\` - Minimal output, suppress prefixes and extra formatting
+- \`quiet\` - \u{1F3AF} **Claude Code mode**: Ultra-brief tool output (\`\u23BF Read X lines (ctrl+r to expand)\`)
 - \`normal\` - Current default behavior with full details
 - \`verbose\` - Additional details and debug information
 
 **Usage:** \`/verbosity <level>\`
-**Example:** \`/verbosity quiet\``,
+**Example:** \`/verbosity quiet\` (for Claude Code parity)`,
           timestamp: /* @__PURE__ */ new Date()
         };
         setChatHistory((prev) => [...prev, levelEntry]);
@@ -28813,7 +28844,7 @@ Auto-compact automatically enables compact mode when conversations exceed thresh
           type: "assistant",
           content: `\u2705 **Verbosity level set to: ${newLevel.toUpperCase()}**
 
-Tool outputs will now show ${newLevel === "quiet" ? "minimal output" : newLevel === "normal" ? "full details" : "extra details and debug information"}.`,
+${newLevel === "quiet" ? "\u{1F3AF} **Claude Code mode activated!** Tool outputs will now show ultra-brief format: `\u23BF Read X lines (ctrl+r to expand)`" : newLevel === "normal" ? "Tool outputs will now show full details." : "Tool outputs will now show extra details and debug information."}`,
           timestamp: /* @__PURE__ */ new Date()
         };
         setChatHistory((prev) => [...prev, confirmEntry]);
@@ -29220,24 +29251,27 @@ ${pushResult.error || "Git push failed"}
     }
     return false;
   };
-  const processUserMessage = async (userInput) => {
-    const pasteService = getPasteDetectionService();
-    const shouldSummarize = pasteService.shouldSummarize(userInput);
-    const recentEntry = chatHistory[chatHistory.length - 1];
-    const isAlreadyShowingPasteSummary = recentEntry && recentEntry.isPasteSummary && recentEntry.content === userInput;
-    if (!isAlreadyShowingPasteSummary) {
-      const userEntry = {
-        type: "user",
-        content: userInput,
-        displayContent: shouldSummarize ? pasteService.createPasteSummary(userInput, pasteService.getCurrentCounter() + 1) : userInput,
-        timestamp: /* @__PURE__ */ new Date(),
-        isPasteSummary: shouldSummarize
-      };
-      if (shouldSummarize) {
-        pasteService.detectPaste("", userInput);
-      }
-      setChatHistory((prev) => [...prev, userEntry]);
+  const expandPasteSummaryToFullContent = async (userInput) => {
+    if (!globalThis.grokPasteCache) return userInput;
+    let expandedInput = userInput;
+    const cache = globalThis.grokPasteCache;
+    for (const [summary, fullContent] of cache.entries()) {
+      const cleanContent = fullContent.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim().split("\n").map((line) => line.trim()).join("\n");
+      expandedInput = expandedInput.replace(summary, cleanContent);
     }
+    return expandedInput;
+  };
+  const processUserMessage = async (userInput) => {
+    const expandedInput = await expandPasteSummaryToFullContent(userInput);
+    const userEntry = {
+      type: "user",
+      content: expandedInput,
+      // AI receives expanded content
+      displayContent: userInput,
+      // UI shows what user typed (may be summary)
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    setChatHistory((prev) => [...prev, userEntry]);
     setIsProcessing(true);
     clearInput();
     try {
@@ -29326,7 +29360,7 @@ ${pushResult.error || "Git push failed"}
         }
         lastUpdateTime = now;
       };
-      for await (const chunk of agent.processUserMessageStream(userInput)) {
+      for await (const chunk of agent.processUserMessageStream(expandedInput)) {
         switch (chunk.type) {
           case "content":
             if (chunk.content) {
@@ -29396,7 +29430,6 @@ var init_use_input_handler = __esm({
   "src/hooks/use-input-handler.ts"() {
     init_confirmation_service();
     init_use_enhanced_input();
-    init_paste_detection();
     init_use_plan_mode();
     init_command_suggestions();
     init_model_config();
@@ -30448,18 +30481,179 @@ var init_user_message_entry = __esm({
     };
   }
 });
+function MarkdownRenderer({ content }) {
+  try {
+    return /* @__PURE__ */ jsx(InlineMarkdown, { content });
+  } catch (error) {
+    console.error("Markdown rendering error:", error);
+    return /* @__PURE__ */ jsx(Text, { wrap: "wrap", dimColor: false, children: content });
+  }
+}
+function InlineMarkdown({ content }) {
+  const lines = content.split("\n");
+  return /* @__PURE__ */ jsx(Text, { wrap: "wrap", dimColor: false, children: lines.map((line, lineIndex) => /* @__PURE__ */ jsxs(React4.Fragment, { children: [
+    lineIndex > 0 && "\n",
+    parseInlineMarkdown(line).map((part, partIndex) => {
+      if (part.type === "header") {
+        return /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: part.text }, `${lineIndex}-${partIndex}`);
+      }
+      if (part.type === "bold") {
+        return /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: part.text }, `${lineIndex}-${partIndex}`);
+      }
+      if (part.type === "italic") {
+        return /* @__PURE__ */ jsx(Text, { italic: true, color: "gray", children: part.text }, `${lineIndex}-${partIndex}`);
+      }
+      if (part.type === "code") {
+        return /* @__PURE__ */ jsx(Text, { color: "cyan", children: part.text }, `${lineIndex}-${partIndex}`);
+      }
+      if (part.type === "emoji") {
+        const emoji = part.text;
+        if (emoji === "\u2705" || emoji === "\u2713") {
+          return /* @__PURE__ */ jsx(Text, { color: "green", children: emoji }, `${lineIndex}-${partIndex}`);
+        }
+        if (emoji === "\u274C" || emoji === "\u2717") {
+          return /* @__PURE__ */ jsx(Text, { color: "red", children: emoji }, `${lineIndex}-${partIndex}`);
+        }
+        if (emoji === "\u26A0\uFE0F" || emoji === "\u26A0") {
+          return /* @__PURE__ */ jsx(Text, { color: "yellow", children: emoji }, `${lineIndex}-${partIndex}`);
+        }
+        if (emoji === "\u{1F4A1}" || emoji === "\u2139\uFE0F" || emoji === "\u{1F50D}") {
+          return /* @__PURE__ */ jsx(Text, { color: "blue", children: emoji }, `${lineIndex}-${partIndex}`);
+        }
+        return /* @__PURE__ */ jsx(Text, { color: "white", children: emoji }, `${lineIndex}-${partIndex}`);
+      }
+      if (part.type === "metadata") {
+        return /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: part.text }, `${lineIndex}-${partIndex}`);
+      }
+      return /* @__PURE__ */ jsx(Text, { color: "white", children: part.text }, `${lineIndex}-${partIndex}`);
+    })
+  ] }, lineIndex)) });
+}
+function parseInlineMarkdown(content) {
+  if (content.match(/^#+\s*$/)) {
+    return [];
+  }
+  const headerMatch = content.match(/^(#+)\s+(.*)$/);
+  if (headerMatch) {
+    const [, hashes, headerText] = headerMatch;
+    return [{ type: "header", text: headerText.trim(), level: hashes.length }];
+  }
+  const parts = [];
+  let current = "";
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "`" && i < content.length - 1) {
+      if (current) {
+        parts.push({ type: "text", text: current });
+        current = "";
+      }
+      const closeIndex = content.indexOf("`", i + 1);
+      if (closeIndex !== -1 && closeIndex > i + 1) {
+        const codeText = content.substring(i + 1, closeIndex);
+        parts.push({ type: "code", text: codeText });
+        i = closeIndex + 1;
+        continue;
+      }
+    }
+    if (content.substr(i, 2) === "**") {
+      if (current) {
+        parts.push({ type: "text", text: current });
+        current = "";
+      }
+      const closeIndex = content.indexOf("**", i + 2);
+      if (closeIndex !== -1) {
+        const boldText = content.substring(i + 2, closeIndex);
+        parts.push({ type: "bold", text: boldText });
+        i = closeIndex + 2;
+        continue;
+      }
+    }
+    if (content[i] === "_" && content[i + 1] !== "_") {
+      if (current) {
+        parts.push({ type: "text", text: current });
+        current = "";
+      }
+      const closeIndex = content.indexOf("_", i + 1);
+      if (closeIndex !== -1) {
+        const italicText = content.substring(i + 1, closeIndex);
+        parts.push({ type: "italic", text: italicText });
+        i = closeIndex + 1;
+        continue;
+      }
+    }
+    const char = content[i];
+    if (/[\u{1F600}-\u{1F64F}]|[\u{1F300}-\u{1F5FF}]|[\u{1F680}-\u{1F6FF}]|[\u{1F1E0}-\u{1F1FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]/u.test(char)) {
+      if (current) {
+        parts.push({ type: "text", text: current });
+        current = "";
+      }
+      parts.push({ type: "emoji", text: char });
+      i++;
+      continue;
+    }
+    current += content[i];
+    i++;
+  }
+  if (current) {
+    const codePattern = /(view_file|str_replace_editor|create_file|search|semantic_search|ast_parser|package\.json|README\.md|GROK\.md|install\.sh|docs-getter\.sh|dist\/|src\/|scripts\/|apps\/|node_modules|\.git|\.js|\.ts|\.json|\.sh|\.md|bun\s+install|npm\s+install)/g;
+    const metadataPattern = /(\([^)]*(?:v\d+\.\d+|\d+k?[+]?\s*(?:files?|lines?|items?)|\d+\.\d+[xX]|dependencies?|scripts?|guides?|overview|project\s+docs?|source\s+code|detailed\s+setup|changelog|debugging|session\s+files?|build\s+artifacts)[^)]*\))/g;
+    let lastIndex = 0;
+    let match;
+    let processedText = current;
+    const tempParts = [];
+    lastIndex = 0;
+    while ((match = codePattern.exec(processedText)) !== null) {
+      if (match.index > lastIndex) {
+        tempParts.push({ type: "text", text: processedText.substring(lastIndex, match.index) });
+      }
+      tempParts.push({ type: "code", text: match[0] });
+      lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < processedText.length) {
+      tempParts.push({ type: "text", text: processedText.substring(lastIndex) });
+    }
+    const finalParts = [];
+    for (const part of tempParts) {
+      if (part.type === "text") {
+        lastIndex = 0;
+        metadataPattern.lastIndex = 0;
+        while ((match = metadataPattern.exec(part.text)) !== null) {
+          if (match.index > lastIndex) {
+            finalParts.push({ type: "text", text: part.text.substring(lastIndex, match.index) });
+          }
+          finalParts.push({ type: "metadata", text: match[0] });
+          lastIndex = match.index + match[0].length;
+        }
+        if (lastIndex < part.text.length) {
+          finalParts.push({ type: "text", text: part.text.substring(lastIndex) });
+        }
+        if (finalParts.length === 0 || finalParts[finalParts.length - 1].text !== part.text) {
+          if (finalParts.length === 0) {
+            finalParts.push(part);
+          }
+        }
+      } else {
+        finalParts.push(part);
+      }
+    }
+    if (finalParts.length === 0) {
+      parts.push({ type: "text", text: current });
+    } else {
+      parts.push(...finalParts);
+    }
+  }
+  return parts;
+}
+var init_markdown_renderer = __esm({
+  "src/ui/utils/markdown-renderer.tsx"() {
+  }
+});
 function AssistantMessageEntry({ entry, verbosityLevel: _verbosityLevel }) {
   const { content: processedContent, isTruncated } = handleLongContent(entry.content);
   return /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "row", alignItems: "flex-start", children: [
     /* @__PURE__ */ jsx(Text, { color: inkColors.text, children: "\u23FA " }),
     /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: "100%", children: [
-      entry.toolCalls ? (
-        // If there are tool calls, just show plain text  
-        /* @__PURE__ */ jsx(Text, { color: inkColors.text, wrap: "wrap", dimColor: false, children: processedContent.trim() })
-      ) : (
-        // Use bright white text like Claude Code - explicit hex color to override any defaults
-        /* @__PURE__ */ jsx(Text, { color: inkColors.text, wrap: "wrap", dimColor: false, children: processedContent.trim() })
-      ),
+      /* @__PURE__ */ jsx(MarkdownRenderer, { content: processedContent.trim() }),
       entry.isStreaming && /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u2588" }),
       isTruncated && /* @__PURE__ */ jsx(Text, { color: "yellow", italic: true, children: "[Response truncated for performance - full content in session log]" })
     ] })
@@ -30468,6 +30662,7 @@ function AssistantMessageEntry({ entry, verbosityLevel: _verbosityLevel }) {
 var handleLongContent;
 var init_assistant_message_entry = __esm({
   "src/ui/components/chat-entries/assistant-message-entry.tsx"() {
+    init_markdown_renderer();
     init_colors();
     handleLongContent = (content, maxLength = 5e3) => {
       if (content.length <= maxLength) {
@@ -30719,7 +30914,223 @@ var init_file_content_renderer = __esm({
   "src/ui/components/content-renderers/file-content-renderer.tsx"() {
   }
 });
+
+// src/services/tool-brevity-service.ts
+var ToolBrevityService;
+var init_tool_brevity_service = __esm({
+  "src/services/tool-brevity-service.ts"() {
+    ToolBrevityService = class {
+      /**
+       * Format tool result based on brevity mode
+       */
+      static formatToolResult(toolName, result, mode = "normal") {
+        const normalizedToolName = this.normalizeToolName(toolName);
+        const metadata = this.extractMetadata(normalizedToolName, result);
+        const summary = this.generateSummary(normalizedToolName, result, metadata);
+        return {
+          toolName: normalizedToolName,
+          summary,
+          expansionHint: result.length > 0 ? "(ctrl+r to expand)" : "",
+          hasContent: result.length > 0,
+          originalContent: result,
+          metadata
+        };
+      }
+      /**
+       * Normalize tool names to handle MCP and special cases
+       */
+      static normalizeToolName(toolName) {
+        if (toolName.startsWith("mcp__")) {
+          const parts = toolName.split("__");
+          if (parts.length >= 3) {
+            return parts[2];
+          }
+        }
+        const toolMappings = {
+          "str_replace_editor": "Edit",
+          "bash": "Bash",
+          "file_editor": "Edit",
+          "grep": "Grep",
+          "file_search": "Search",
+          "list_files": "List",
+          "read_file": "Read",
+          "write_file": "Write"
+        };
+        return toolMappings[toolName] || this.capitalizeFirst(toolName);
+      }
+      /**
+       * Extract metadata from tool result content
+       */
+      static extractMetadata(toolName, content) {
+        const metadata = {};
+        switch (toolName.toLowerCase()) {
+          case "read":
+          case "edit":
+          case "write":
+            metadata.lineCount = this.countLines(content);
+            break;
+          case "grep":
+          case "search":
+            const { matchCount, fileCount } = this.parseGrepResults(content);
+            metadata.matchCount = matchCount;
+            metadata.fileCount = fileCount;
+            break;
+          case "list":
+            metadata.fileCount = this.countFileItems(content);
+            break;
+          case "bash":
+            metadata.status = this.determineBashStatus(content);
+            break;
+          default:
+            metadata.lineCount = this.countLines(content);
+        }
+        return metadata;
+      }
+      /**
+       * Generate tool-specific summary text
+       */
+      static generateSummary(toolName, content, metadata) {
+        const tool = toolName.toLowerCase();
+        if (!content || content.trim().length === 0) {
+          return `${this.capitalizeFirst(tool)} (no output)`;
+        }
+        switch (tool) {
+          case "read":
+            return `Read ${metadata.lineCount || 0} lines`;
+          case "edit":
+            return `Updated ${this.getFileName(content)} with ${metadata.lineCount || 0} lines`;
+          case "write":
+            return `Created file (${metadata.lineCount || 0} lines)`;
+          case "grep":
+          case "search":
+            if (metadata.matchCount === 0) {
+              return "No matches found";
+            }
+            return `${metadata.matchCount} matches across ${metadata.fileCount || 1} files`;
+          case "list":
+            return `Found ${metadata.fileCount || 0} items`;
+          case "bash":
+            if (metadata.status === "error") {
+              return "Command failed";
+            }
+            return "Command completed successfully";
+          case "glob":
+            return `Found ${this.countFileItems(content)} files`;
+          case "webfetch":
+            return `Fetched content (${metadata.lineCount || 0} lines)`;
+          case "websearch":
+            return `Search completed (${this.countSearchResults(content)} results)`;
+          default:
+            const lines = metadata.lineCount || 0;
+            return lines > 0 ? `${this.capitalizeFirst(tool)} (${lines} lines)` : this.capitalizeFirst(tool);
+        }
+      }
+      /**
+       * Count lines in content
+       */
+      static countLines(content) {
+        if (!content) return 0;
+        return content.split("\n").length;
+      }
+      /**
+       * Parse grep/search results for match and file counts
+       */
+      static parseGrepResults(content) {
+        if (!content) return { matchCount: 0, fileCount: 0 };
+        const lines = content.split("\n").filter((line) => line.trim().length > 0);
+        const files = /* @__PURE__ */ new Set();
+        let matches = 0;
+        for (const line of lines) {
+          const fileMatch = line.match(/^([^:]+):/);
+          if (fileMatch) {
+            files.add(fileMatch[1]);
+            matches++;
+          } else if (line.includes(":")) {
+            matches++;
+          }
+        }
+        return {
+          matchCount: matches || lines.length,
+          fileCount: files.size || (matches > 0 ? 1 : 0)
+        };
+      }
+      /**
+       * Count file items in directory listing
+       */
+      static countFileItems(content) {
+        if (!content) return 0;
+        const lines = content.split("\n").filter((line) => line.trim().length > 0).filter((line) => !line.startsWith("total ")).filter((line) => !line.match(/^d.*\s+\.\s*$/)).filter((line) => !line.match(/^d.*\s+\.\.\s*$/));
+        return lines.length;
+      }
+      /**
+       * Determine bash command success/failure status
+       */
+      static determineBashStatus(content) {
+        if (!content) return "success";
+        const errorIndicators = [
+          "error:",
+          "Error:",
+          "ERROR:",
+          "failed",
+          "Failed",
+          "FAILED",
+          "permission denied",
+          "command not found",
+          "no such file",
+          "cannot"
+        ];
+        const contentLower = content.toLowerCase();
+        return errorIndicators.some((indicator) => contentLower.includes(indicator.toLowerCase())) ? "error" : "success";
+      }
+      /**
+       * Extract filename from edit/write operation content
+       */
+      static getFileName(content) {
+        const fileMatch = content.match(/(?:updated|edited|created)\s+([^\s]+)/i);
+        if (fileMatch) return fileMatch[1];
+        const pathMatch = content.match(/([^/]+)$/);
+        return pathMatch ? pathMatch[1] : "file";
+      }
+      /**
+       * Count search results in web search content
+       */
+      static countSearchResults(content) {
+        const resultMatches = content.match(/result\s+\d+/gi);
+        return resultMatches ? resultMatches.length : 1;
+      }
+      /**
+       * Capitalize first letter of string
+       */
+      static capitalizeFirst(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+      }
+      /**
+       * Check if content should use compact display
+       */
+      static shouldUseCompactDisplay(mode, contentLength) {
+        if (mode === "brief") return true;
+        if (mode === "verbose") return false;
+        const lineCount = contentLength > 0 ? contentLength.toString().split("\n").length : 0;
+        return lineCount > 5;
+      }
+      /**
+       * Format expansion hint with content preview
+       */
+      static formatExpansionHint(hasContent, metadata) {
+        if (!hasContent) return "";
+        if (metadata.lineCount && metadata.lineCount > 10) {
+          return `(${metadata.lineCount} lines, ctrl+r to expand)`;
+        }
+        if (metadata.matchCount && metadata.matchCount > 5) {
+          return `(${metadata.matchCount} matches, ctrl+r to expand)`;
+        }
+        return "(ctrl+r to expand)";
+      }
+    };
+  }
+});
 function ToolCallEntry({ entry, verbosityLevel, explainLevel }) {
+  const [isExpanded, setIsExpanded] = useState(false);
   const getExplanation = (toolName2, filePath2, _isExecuting) => {
     if (explainLevel === "off") return null;
     const explanations = {
@@ -30748,6 +31159,19 @@ function ToolCallEntry({ entry, verbosityLevel, explainLevel }) {
     if (!explanation2) return null;
     return explainLevel === "detailed" ? explanation2.detailed : explanation2.brief;
   };
+  const truncateToClaudeStyle = (content) => {
+    const lines = content.split("\n");
+    const maxLines = 3;
+    if (lines.length <= maxLines) {
+      return { preview: content, hasMore: false, totalLines: lines.length };
+    }
+    const preview2 = lines.slice(0, maxLines).join("\n");
+    return {
+      preview: preview2,
+      hasMore: true,
+      totalLines: lines.length
+    };
+  };
   const getToolActionName = (toolName2) => {
     if (toolName2.startsWith("mcp__")) {
       const parts = toolName2.split("__");
@@ -30814,7 +31238,15 @@ function ToolCallEntry({ entry, verbosityLevel, explainLevel }) {
   const shouldShowFileContent = (entry.toolCall?.function?.name === "view_file" || entry.toolCall?.function?.name === "create_file") && entry.toolResult?.success && !shouldShowDiff;
   const shouldShowToolContent = verbosityLevel !== "quiet";
   const shouldShowFullContent = verbosityLevel === "normal" || verbosityLevel === "verbose";
+  const brevityMode = verbosityLevel === "quiet" ? "brief" : verbosityLevel === "verbose" ? "verbose" : "normal";
+  const brevitySummary = ToolBrevityService.formatToolResult(
+    toolName,
+    entry.content || "",
+    brevityMode
+  );
   const explanation = getExplanation(toolName, filePath);
+  const { preview, hasMore, totalLines } = truncateToClaudeStyle(entry.content || "");
+  const useClaudeCodeFormat = verbosityLevel === "quiet" && brevitySummary.hasContent;
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
     /* @__PURE__ */ jsxs(Box, { children: [
       /* @__PURE__ */ jsx(Text, { color: "magenta", children: "\u23FA" }),
@@ -30823,24 +31255,55 @@ function ToolCallEntry({ entry, verbosityLevel, explainLevel }) {
         filePath ? `${actionName}(${filePath})` : actionName
       ] })
     ] }),
-    explanation && /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsxs(Text, { color: "blue", italic: true, children: [
+    explanation && !useClaudeCodeFormat && /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsxs(Text, { color: "blue", italic: true, children: [
       "\u{1F4A1} ",
       explanation
     ] }) }),
-    shouldShowToolContent && /* @__PURE__ */ jsx(Box, { marginLeft: 2, flexDirection: "column", children: isExecuting ? /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u23BF Executing..." }) : shouldShowFileContent && shouldShowFullContent ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    useClaudeCodeFormat ? (
+      // Claude Code style: ultra-brief format
+      /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "\u23BF ",
+        brevitySummary.summary,
+        " ",
+        brevitySummary.expansionHint
+      ] }) })
+    ) : shouldShowToolContent && /* @__PURE__ */ jsx(Box, { marginLeft: 2, flexDirection: "column", children: isExecuting ? /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u23BF Executing..." }) : shouldShowFileContent && shouldShowFullContent ? /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: !isExpanded ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "\u23BF ",
+        preview
+      ] }),
+      hasMore && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "\u2026 +",
+        totalLines - 3,
+        " lines (ctrl+r to expand)"
+      ] })
+    ] }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
       /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u23BF File contents:" }),
       /* @__PURE__ */ jsx(Box, { marginLeft: 2, flexDirection: "column", children: /* @__PURE__ */ jsx(FileContentRenderer, { content: entry.content }) })
-    ] }) : shouldShowDiff && shouldShowFullContent ? (
+    ] }) }) : shouldShowDiff && shouldShowFullContent ? (
       // For diff results, show only the summary line, not the raw content
       /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
         "\u23BF ",
         entry.content.split("\n")[0]
       ] })
-    ) : !shouldShowFullContent ? /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u23BF Completed" }) : /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+    ) : !shouldShowFullContent ? /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u23BF Completed" }) : !isExpanded && hasMore ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "\u23BF ",
+        preview
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "\u2026 +",
+        totalLines - 3,
+        " lines (ctrl+r to expand)"
+      ] })
+    ] }) : !isExpanded ? /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      "\u23BF ",
+      preview
+    ] }) : /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
       "\u23BF ",
       formatToolContent(entry.content, toolName)
     ] }) }),
-    shouldShowDiff && !isExecuting && shouldShowFullContent && /* @__PURE__ */ jsx(Box, { marginLeft: 4, flexDirection: "column", children: /* @__PURE__ */ jsx(
+    shouldShowDiff && !isExecuting && shouldShowFullContent && !useClaudeCodeFormat && /* @__PURE__ */ jsx(Box, { marginLeft: 4, flexDirection: "column", children: /* @__PURE__ */ jsx(
       DiffRenderer,
       {
         diffContent: entry.content,
@@ -30855,6 +31318,7 @@ var init_tool_call_entry = __esm({
   "src/ui/components/chat-entries/tool-call-entry.tsx"() {
     init_diff_renderer();
     init_file_content_renderer();
+    init_tool_brevity_service();
     truncateContent2 = (content, maxLength = 100) => {
       if (process.env.COMPACT !== "1") return content;
       return content.length > maxLength ? content.substring(0, maxLength) + "..." : content;
@@ -31154,31 +31618,64 @@ function ChatInput({
   isProcessing,
   isStreaming
 }) {
-  const beforeCursor = input.slice(0, cursorPosition);
-  const lines = input.split(/\r\n|\r|\n/);
-  const isMultiline = lines.length > 1;
-  const MAX_DISPLAY_LINES = 10;
-  const shouldTruncateDisplay = lines.length > MAX_DISPLAY_LINES;
-  if (shouldTruncateDisplay) {
-    console.log(`\u{1F4C4} Large paste detected: ${lines.length} lines, showing truncated view`);
-  }
-  let currentLineIndex = 0;
-  let currentCharIndex = 0;
-  let totalChars = 0;
-  for (let i = 0; i < lines.length; i++) {
-    if (totalChars + lines[i].length >= cursorPosition) {
-      currentLineIndex = i;
-      currentCharIndex = cursorPosition - totalChars;
-      break;
+  try {
+    let displayInput = input;
+    const beforeCursor = displayInput.slice(0, Math.min(cursorPosition, displayInput.length));
+    const lines = displayInput.split(/\r\n|\r|\n/);
+    const isMultiline = lines.length > 1;
+    const MAX_DISPLAY_LINES = 10;
+    const shouldTruncateDisplay = lines.length > MAX_DISPLAY_LINES;
+    if (shouldTruncateDisplay) {
+      console.log(`\u{1F4C4} Large content: ${lines.length} lines, showing truncated view`);
     }
-    totalChars += lines[i].length + 1;
-  }
-  const showCursor = !isProcessing && !isStreaming;
-  const borderColor = isProcessing || isStreaming ? "yellow" : "blue";
-  const promptColor = "cyan";
-  const placeholderText = "Ask me anything...";
-  const isPlaceholder = !input;
-  if (isMultiline) {
+    let currentLineIndex = 0;
+    let currentCharIndex = 0;
+    let totalChars = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (totalChars + lines[i].length >= cursorPosition) {
+        currentLineIndex = i;
+        currentCharIndex = cursorPosition - totalChars;
+        break;
+      }
+      totalChars += lines[i].length + 1;
+    }
+    const showCursor = !isProcessing && !isStreaming;
+    const borderColor = isProcessing || isStreaming ? "yellow" : "blue";
+    const promptColor = "cyan";
+    const placeholderText = "Ask me anything...";
+    const isPlaceholder = !input;
+    if (isMultiline) {
+      return /* @__PURE__ */ jsx(
+        Box,
+        {
+          borderStyle: "round",
+          borderColor,
+          paddingX: 1,
+          paddingY: 0,
+          marginTop: 1,
+          flexDirection: "column",
+          children: /* @__PURE__ */ jsx(Text, { children: shouldTruncateDisplay ? (
+            // Show Claude Code style paste summary but don't replace input
+            `\u276F [Pasted text #${globalThis.grokPasteCounter || 1} +${lines.length} lines]`
+          ) : (
+            // Normal multiline display for reasonable sizes
+            lines.map((line, index) => {
+              const isCurrentLine = index === currentLineIndex;
+              const promptChar = index === 0 ? "\u276F " : "  ";
+              let lineText = promptChar + line;
+              if (isCurrentLine && showCursor) {
+                const cursorPos = promptChar.length + currentCharIndex;
+                lineText = lineText.slice(0, cursorPos) + "\u2588" + lineText.slice(cursorPos + 1);
+              }
+              return index === lines.length - 1 ? lineText : lineText + "\n";
+            }).join("")
+          ) })
+        }
+      );
+    }
+    const adjustedCursorPos = Math.min(cursorPosition, displayInput.length);
+    const cursorChar = displayInput.slice(adjustedCursorPos, adjustedCursorPos + 1) || " ";
+    const afterCursorText = displayInput.slice(adjustedCursorPos + 1);
     return /* @__PURE__ */ jsx(
       Box,
       {
@@ -31187,57 +31684,36 @@ function ChatInput({
         paddingX: 1,
         paddingY: 0,
         marginTop: 1,
-        flexDirection: "column",
-        children: /* @__PURE__ */ jsx(Text, { children: shouldTruncateDisplay ? (
-          // Show truncated view for very large pastes
-          `\u276F [Large paste: ${lines.length} lines, ${input.length} chars]
-  First few lines:
-  ${lines.slice(0, 3).map((line) => `  ${line}`).join("\n")}
-  ...
-  Last few lines:
-  ${lines.slice(-2).map((line) => `  ${line}`).join("\n")}
-  
-  Press Enter to submit or edit to modify.`
-        ) : (
-          // Normal multiline display for reasonable sizes
-          lines.map((line, index) => {
-            const isCurrentLine = index === currentLineIndex;
-            const promptChar = index === 0 ? "\u276F " : "  ";
-            let lineText = promptChar + line;
-            if (isCurrentLine && showCursor) {
-              const cursorPos = promptChar.length + currentCharIndex;
-              lineText = lineText.slice(0, cursorPos) + "\u2588" + lineText.slice(cursorPos + 1);
-            }
-            return index === lines.length - 1 ? lineText : lineText + "\n";
-          }).join("")
-        ) })
+        children: /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: promptColor, children: "\u276F " }),
+          isPlaceholder ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: placeholderText }),
+            showCursor && /* @__PURE__ */ jsx(Text, { backgroundColor: "white", color: "black", children: " " })
+          ] }) : /* @__PURE__ */ jsxs(Text, { children: [
+            beforeCursor,
+            showCursor && /* @__PURE__ */ jsx(Text, { backgroundColor: "white", color: "black", children: cursorChar }),
+            !showCursor && cursorChar !== " " && cursorChar,
+            afterCursorText
+          ] })
+        ] })
+      }
+    );
+  } catch (error) {
+    console.error("[ERROR] ChatInput component crashed:", error);
+    console.error("[ERROR] Stack:", error instanceof Error ? error.stack : "No stack");
+    console.error("[ERROR] Input data:", { input: input?.slice(0, 100), cursorPosition, isProcessing, isStreaming });
+    return /* @__PURE__ */ jsx(
+      Box,
+      {
+        borderStyle: "round",
+        borderColor: "red",
+        paddingX: 1,
+        paddingY: 0,
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx(Text, { color: "red", children: "\u276F [Input error - check console]" })
       }
     );
   }
-  const cursorChar = input.slice(cursorPosition, cursorPosition + 1) || " ";
-  const afterCursorText = input.slice(cursorPosition + 1);
-  return /* @__PURE__ */ jsx(
-    Box,
-    {
-      borderStyle: "round",
-      borderColor,
-      paddingX: 1,
-      paddingY: 0,
-      marginTop: 1,
-      children: /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Text, { color: promptColor, children: "\u276F " }),
-        isPlaceholder ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: placeholderText }),
-          showCursor && /* @__PURE__ */ jsx(Text, { backgroundColor: "white", color: "black", children: " " })
-        ] }) : /* @__PURE__ */ jsxs(Text, { children: [
-          beforeCursor,
-          showCursor && /* @__PURE__ */ jsx(Text, { backgroundColor: "white", color: "black", children: cursorChar }),
-          !showCursor && cursorChar !== " " && cursorChar,
-          afterCursorText
-        ] })
-      ] })
-    }
-  );
 }
 var init_chat_input = __esm({
   "src/ui/components/chat-input.tsx"() {
@@ -31864,6 +32340,85 @@ var init_chat_interface_renderer = __esm({
     init_confirmation_dialog();
   }
 });
+function getSessionLogger() {
+  if (!sessionLogger) {
+    sessionLogger = new SessionLogger();
+  }
+  return sessionLogger;
+}
+function logTerminalState(state) {
+  getSessionLogger().logTerminalState(state);
+}
+var SessionLogger, sessionLogger;
+var init_session_logger = __esm({
+  "src/utils/session-logger.ts"() {
+    SessionLogger = class {
+      constructor() {
+        this.sessionId = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        this.logPath = path8__default.join(process.cwd(), `session-${this.sessionId}.log`);
+        this.init();
+      }
+      init() {
+        const header = `
+=================================================================
+\u{1F9EA} GROK ONE-SHOT TESTING SESSION
+Session ID: ${this.sessionId}
+Started: ${(/* @__PURE__ */ new Date()).toISOString()}
+=================================================================
+
+`;
+        fs7__default.writeFileSync(this.logPath, header);
+      }
+      logTerminalState(state) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const entry = `
+[${timestamp}] \u{1F4FA} TERMINAL STATE - ${state.action}
+=====================================
+INPUT FIELD: "${state.input}"
+CURSOR POS: ${state.cursorPosition}
+PROCESSING: ${state.isProcessing}
+STREAMING: ${state.isStreaming}
+CHAT ENTRIES: ${state.chatHistory.length}
+LAST ENTRY: ${state.chatHistory.length > 0 ? JSON.stringify(state.chatHistory[state.chatHistory.length - 1], null, 2) : "None"}
+=====================================
+
+`;
+        fs7__default.appendFileSync(this.logPath, entry);
+      }
+      logUserAction(action, details = {}) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const entry = `[${timestamp}] \u{1F464} USER ACTION: ${action}
+Details: ${JSON.stringify(details, null, 2)}
+
+`;
+        fs7__default.appendFileSync(this.logPath, entry);
+      }
+      logPasteEvent(event) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const entry = `[${timestamp}] \u{1F4CB} PASTE EVENT: ${event.phase}
+Data: ${JSON.stringify(event.data, null, 2)}
+
+`;
+        fs7__default.appendFileSync(this.logPath, entry);
+      }
+      logTestResult(testName, result, details) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const entry = `
+[${timestamp}] \u2705 TEST RESULT: ${testName}
+Result: ${result}
+Details: ${details}
+=================================================================
+
+`;
+        fs7__default.appendFileSync(this.logPath, entry);
+      }
+      getLogPath() {
+        return this.logPath;
+      }
+    };
+    sessionLogger = null;
+  }
+});
 
 // src/ui/components/chat-interface.tsx
 var chat_interface_exports = {};
@@ -31928,6 +32483,16 @@ function ChatInterfaceWithAgent({
     explainLevel,
     planMode
   } = useInputHandler(inputHandlerProps);
+  useEffect(() => {
+    logTerminalState({
+      input,
+      cursorPosition,
+      chatHistory,
+      isProcessing,
+      isStreaming,
+      action: "STATE_CHANGE"
+    });
+  }, [input, cursorPosition, chatHistory.length, isProcessing, isStreaming]);
   useStreaming(agent, initialMessage, setChatHistory, {
     setIsProcessing,
     setIsStreaming,
@@ -32014,6 +32579,29 @@ var init_chat_interface = __esm({
     init_use_session_logging();
     init_use_processing_timer();
     init_chat_interface_renderer();
+    init_session_logger();
+  }
+});
+
+// src/utils/console-markdown.ts
+var console_markdown_exports = {};
+__export(console_markdown_exports, {
+  renderMarkdownToConsole: () => renderMarkdownToConsole
+});
+function renderMarkdownToConsole(content) {
+  let result = content;
+  result = result.replace(/^#+\s+(.*)$/gm, (_, text) => chalk2.bold.white(text));
+  result = result.replace(/\*\*(.*?)\*\*/g, (_, text) => chalk2.bold.white(text));
+  result = result.replace(/_(.*?)_/g, (_, text) => chalk2.italic.gray(text));
+  result = result.replace(/`([^`]+)`/g, (_, text) => chalk2.cyan(text));
+  result = result.replace(/(✅|✓)/g, (match) => chalk2.green(match));
+  result = result.replace(/(❌|✗)/g, (match) => chalk2.red(match));
+  result = result.replace(/(⚠️|⚠)/g, (match) => chalk2.yellow(match));
+  result = result.replace(/(ℹ️|💡|🔍)/g, (match) => chalk2.blue(match));
+  return result;
+}
+var init_console_markdown = __esm({
+  "src/utils/console-markdown.ts"() {
   }
 });
 
@@ -32030,27 +32618,27 @@ function createMCPCommand() {
       if (PREDEFINED_SERVERS[name]) {
         const config3 = PREDEFINED_SERVERS[name];
         addMCPServer(config3);
-        console.log(chalk.green(`\u2713 Added predefined MCP server: ${name}`));
+        console.log(chalk2.green(`\u2713 Added predefined MCP server: ${name}`));
         const manager2 = getMCPManager();
         await manager2.addServer(config3);
-        console.log(chalk.green(`\u2713 Connected to MCP server: ${name}`));
+        console.log(chalk2.green(`\u2713 Connected to MCP server: ${name}`));
         const tools2 = manager2.getTools().filter((t) => t.serverName === name);
-        console.log(chalk.blue(`  Available tools: ${tools2.length}`));
+        console.log(chalk2.blue(`  Available tools: ${tools2.length}`));
         return;
       }
       const transportType = options.transport.toLowerCase();
       if (transportType === "stdio") {
         if (!options.command) {
-          console.error(chalk.red("Error: --command is required for stdio transport"));
+          console.error(chalk2.red("Error: --command is required for stdio transport"));
           process.exit(1);
         }
       } else if (transportType === "http" || transportType === "sse" || transportType === "streamable_http") {
         if (!options.url) {
-          console.error(chalk.red(`Error: --url is required for ${transportType} transport`));
+          console.error(chalk2.red(`Error: --url is required for ${transportType} transport`));
           process.exit(1);
         }
       } else {
-        console.error(chalk.red("Error: Transport type must be stdio, http, sse, or streamable_http"));
+        console.error(chalk2.red("Error: Transport type must be stdio, http, sse, or streamable_http"));
         process.exit(1);
       }
       const env = {};
@@ -32079,14 +32667,14 @@ function createMCPCommand() {
         }
       };
       addMCPServer(config2);
-      console.log(chalk.green(`\u2713 Added MCP server: ${name}`));
+      console.log(chalk2.green(`\u2713 Added MCP server: ${name}`));
       const manager = getMCPManager();
       await manager.addServer(config2);
-      console.log(chalk.green(`\u2713 Connected to MCP server: ${name}`));
+      console.log(chalk2.green(`\u2713 Connected to MCP server: ${name}`));
       const tools = manager.getTools().filter((t) => t.serverName === name);
-      console.log(chalk.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk2.blue(`  Available tools: ${tools.length}`));
     } catch (error) {
-      console.error(chalk.red(`Error adding MCP server: ${error.message}`));
+      console.error(chalk2.red(`Error adding MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -32096,7 +32684,7 @@ function createMCPCommand() {
       try {
         config2 = JSON.parse(jsonConfig);
       } catch {
-        console.error(chalk.red("Error: Invalid JSON configuration"));
+        console.error(chalk2.red("Error: Invalid JSON configuration"));
         process.exit(1);
       }
       const serverConfig = {
@@ -32119,14 +32707,14 @@ function createMCPCommand() {
         }
       }
       addMCPServer(serverConfig);
-      console.log(chalk.green(`\u2713 Added MCP server: ${name}`));
+      console.log(chalk2.green(`\u2713 Added MCP server: ${name}`));
       const manager = getMCPManager();
       await manager.addServer(serverConfig);
-      console.log(chalk.green(`\u2713 Connected to MCP server: ${name}`));
+      console.log(chalk2.green(`\u2713 Connected to MCP server: ${name}`));
       const tools = manager.getTools().filter((t) => t.serverName === name);
-      console.log(chalk.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk2.blue(`  Available tools: ${tools.length}`));
     } catch (error) {
-      console.error(chalk.red(`Error adding MCP server: ${error.message}`));
+      console.error(chalk2.red(`Error adding MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -32135,9 +32723,9 @@ function createMCPCommand() {
       const manager = getMCPManager();
       await manager.removeServer(name);
       removeMCPServer(name);
-      console.log(chalk.green(`\u2713 Removed MCP server: ${name}`));
+      console.log(chalk2.green(`\u2713 Removed MCP server: ${name}`));
     } catch (error) {
-      console.error(chalk.red(`Error removing MCP server: ${error.message}`));
+      console.error(chalk2.red(`Error removing MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -32145,15 +32733,15 @@ function createMCPCommand() {
     const config2 = loadMCPConfig();
     const manager = getMCPManager();
     if (config2.servers.length === 0) {
-      console.log(chalk.yellow("No MCP servers configured"));
+      console.log(chalk2.yellow("No MCP servers configured"));
       return;
     }
-    console.log(chalk.bold("Configured MCP servers:"));
+    console.log(chalk2.bold("Configured MCP servers:"));
     console.log();
     for (const server of config2.servers) {
       const isConnected = manager.getServers().includes(server.name);
-      const status = isConnected ? chalk.green("\u2713 Connected") : chalk.red("\u2717 Disconnected");
-      console.log(`${chalk.bold(server.name)}: ${status}`);
+      const status = isConnected ? chalk2.green("\u2713 Connected") : chalk2.red("\u2717 Disconnected");
+      console.log(`${chalk2.bold(server.name)}: ${status}`);
       if (server.transport) {
         console.log(`  Transport: ${server.transport.type}`);
         if (server.transport.type === "stdio") {
@@ -32186,15 +32774,15 @@ function createMCPCommand() {
       const config2 = loadMCPConfig();
       const serverConfig = config2.servers.find((s) => s.name === name);
       if (!serverConfig) {
-        console.error(chalk.red(`Server ${name} not found`));
+        console.error(chalk2.red(`Server ${name} not found`));
         process.exit(1);
       }
-      console.log(chalk.blue(`Testing connection to ${name}...`));
+      console.log(chalk2.blue(`Testing connection to ${name}...`));
       const manager = getMCPManager();
       await manager.addServer(serverConfig);
       const tools = manager.getTools().filter((t) => t.serverName === name);
-      console.log(chalk.green(`\u2713 Successfully connected to ${name}`));
-      console.log(chalk.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk2.green(`\u2713 Successfully connected to ${name}`));
+      console.log(chalk2.blue(`  Available tools: ${tools.length}`));
       if (tools.length > 0) {
         console.log("  Tools:");
         tools.forEach((tool) => {
@@ -32203,7 +32791,7 @@ function createMCPCommand() {
         });
       }
     } catch (error) {
-      console.error(chalk.red(`\u2717 Failed to connect to ${name}: ${error.message}`));
+      console.error(chalk2.red(`\u2717 Failed to connect to ${name}: ${error.message}`));
       process.exit(1);
     }
   });
@@ -32227,9 +32815,9 @@ function createSetNameCommand() {
     try {
       const settingsManager = getSettingsManager();
       settingsManager.updateUserSetting("assistantName", name);
-      console.log(chalk.green(`\u2705 Assistant name set to: ${name}`));
+      console.log(chalk2.green(`\u2705 Assistant name set to: ${name}`));
     } catch (error) {
-      console.error(chalk.red(`\u274C Failed to set assistant name: ${error.message}`));
+      console.error(chalk2.red(`\u274C Failed to set assistant name: ${error.message}`));
       process.exit(1);
     }
   });
@@ -32254,10 +32842,10 @@ function createToggleConfirmationsCommand() {
       const currentValue = settingsManager.getUserSetting("requireConfirmation") ?? true;
       const newValue = !currentValue;
       settingsManager.updateUserSetting("requireConfirmation", newValue);
-      console.log(chalk.green(`\u2705 Confirmation requirement ${newValue ? "enabled" : "disabled"}`));
+      console.log(chalk2.green(`\u2705 Confirmation requirement ${newValue ? "enabled" : "disabled"}`));
       console.log(`File operations and bash commands will ${newValue ? "now" : "no longer"} require confirmation.`);
     } catch (error) {
-      console.error(chalk.red(`\u274C Failed to toggle confirmations: ${error.message}`));
+      console.error(chalk2.red(`\u274C Failed to toggle confirmations: ${error.message}`));
       process.exit(1);
     }
   });
@@ -32275,7 +32863,7 @@ var require_package = __commonJS({
     module.exports = {
       type: "module",
       name: "@xagent/one-shot",
-      version: "1.2.0",
+      version: "1.2.2",
       description: "An open-source AI agent that brings advanced AI capabilities directly into your terminal with automatic documentation updates.",
       main: "dist/index.js",
       module: "dist/index.js",
@@ -32460,6 +33048,7 @@ try {
   const { printWelcomeBanner: printWelcomeBanner2 } = await Promise.resolve().then(() => (init_use_console_setup(), use_console_setup_exports));
   const { getSettingsManager: getSettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
   const { ConfirmationService: ConfirmationService2 } = await Promise.resolve().then(() => (init_confirmation_service(), confirmation_service_exports));
+  const { renderMarkdownToConsole: renderMarkdownToConsole2 } = await Promise.resolve().then(() => (init_console_markdown(), console_markdown_exports));
   const { createMCPCommand: createMCPCommand2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
   const { createSetNameCommand: createSetNameCommand2 } = await Promise.resolve().then(() => (init_set_name(), set_name_exports));
   const { createToggleConfirmationsCommand: createToggleConfirmationsCommand2 } = await Promise.resolve().then(() => (init_toggle_confirmations(), toggle_confirmations_exports));
@@ -32535,7 +33124,7 @@ try {
           const chatEntries = await agent.processUserMessage(options.prompt);
           for (const entry of chatEntries) {
             if (entry.type === "assistant" && entry.content) {
-              console.log(entry.content);
+              console.log(renderMarkdownToConsole2(entry.content));
             }
           }
         } catch (error) {