@corbat-tech/coco 2.5.3 → 2.6.0

package/dist/cli/index.js

@@ -7141,9 +7141,12 @@ YOU ARE AN EXECUTION AGENT, NOT A CONVERSATIONAL ASSISTANT.
 - EVERY action requires a TOOL CALL. Text responses are ONLY for brief confirmations AFTER tools execute.
 
 **Execution Process:**
-1. **Analyze**: Understand what the user wants (in your head, don't output this)
+1. **Orient**: Output ONE line stating the *goal* of the next step \u2014 not the tool, the intent.
+   - Good: "Confirming the typo is gone\u2026" / "Checking tests still pass\u2026" / "Reading the config to understand current structure\u2026"
+   - Bad: "I'll use grep to search." (restates the tool, not the goal)
+   - Skip this for obvious single-step tasks ("create hello.js" \u2192 just create it).
 2. **Execute**: IMMEDIATELY CALL THE APPROPRIATE TOOLS (this is mandatory, not optional)
-3. **Respond**: Brief confirmation of what was done (AFTER tools executed)
+3. **Respond**: Brief confirmation of what was done (AFTER all tools executed)
 
 **Critical Rules:**
 - User says "create X with Y" \u2192 Immediately call write_file/edit_file tool, no discussion
@@ -7228,19 +7231,43 @@ If a file tool fails with "outside project directory", the system will automatic
 
 **For structured content** (documentation, tutorials, summaries, explanations with multiple sections, or when the user asks for "markdown"):
 
-1. Wrap your entire response in a single markdown code block:
-   \`\`\`markdown
+1. Wrap your entire response in a single tilde markdown block:
+   ~~~markdown
    Your content here...
+   ~~~
+
+2. **CRITICAL: Bare ~~~ closes the outer block** \u2014 Only use bare ~~~ (without a lang tag) as the VERY LAST line to close the outer block. Writing ~~~ anywhere else inside the block will break rendering.
+
+3. **ALL inner fenced blocks use standard backtick syntax:**
+   - Code: \`\`\`javascript / \`\`\`typescript / \`\`\`python / \`\`\`bash / etc.
+   - Shell commands: \`\`\`bash
+   - ASCII diagrams: \`\`\`ascii
+   - Tree structures / file paths: \`\`\`text
+   - Any other fenced content: \`\`\`<lang>
+
+   Example:
+   ~~~markdown
+   ## Section
+
+   Some text here.
+
+   \`\`\`bash
+   echo "hello"
+   ls -la
    \`\`\`
 
-2. **CRITICAL: Never close the markdown block prematurely** - The closing \`\`\` must ONLY appear at the very end.
+   \`\`\`ascii
+   \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+   \u2502 Service \u2502
+   \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+   \`\`\`
 
-3. **For code examples inside markdown**, use TILDES (~~~) instead of backticks:
-   ~~~javascript
-   function example() { return "hello"; }
+   More text after blocks.
    ~~~
 
-4. **Include all content in ONE block**: headers, lists, tables, quotes, code examples.
+   **Inner blocks open with \`\`\`lang and close with \`\`\`. The only ~~~ inside the markdown block is the final bare ~~~ at the very end.**
+
+4. **Include all content in ONE block**: headers, lists, tables, quotes, code, commands, diagrams.
 
 **When to use markdown block:**
 - User asks for documentation, summary, tutorial, guide
@@ -32837,6 +32864,8 @@ var rawMarkdownBuffer = "";
 var inCodeBlock = false;
 var codeBlockLang = "";
 var codeBlockLines = [];
+var inNestedCodeBlock = false;
+var codeBlockFenceChar = "";
 var streamingIndicatorActive = false;
 var streamingIndicatorInterval = null;
 var streamingIndicatorFrame = 0;
@@ -32880,6 +32909,7 @@ function flushLineBuffer() {
       stopStreamingIndicator();
     }
     inCodeBlock = false;
+    codeBlockFenceChar = "";
     codeBlockLang = "";
     codeBlockLines = [];
   }
@@ -32887,6 +32917,8 @@ function flushLineBuffer() {
 function resetLineBuffer() {
   lineBuffer = "";
   inCodeBlock = false;
+  inNestedCodeBlock = false;
+  codeBlockFenceChar = "";
   codeBlockLang = "";
   codeBlockLines = [];
   stopStreamingIndicator();
@@ -32909,28 +32941,100 @@ function renderStreamChunk(chunk) {
   }
 }
 function processAndOutputLine(line) {
-  const codeBlockMatch = line.match(/^```(\w*)$/);
+  line = line.replace(/^[\u200B\uFEFF\u200C\u200D\u2060\u00AD]+/, "");
+  const tildeFenceMatch = line.match(/^~~~(\w*)$/);
+  if (tildeFenceMatch) {
+    const lang = tildeFenceMatch[1] || "";
+    if (!inCodeBlock) {
+      if (lang) {
+        inCodeBlock = true;
+        inNestedCodeBlock = false;
+        codeBlockFenceChar = "~~~";
+        codeBlockLang = lang;
+        codeBlockLines = [];
+        if (codeBlockLang === "markdown" || codeBlockLang === "md") {
+          startStreamingIndicator();
+        }
+      } else {
+        const formatted = formatMarkdownLine(line);
+        const termWidth = getTerminalWidth2();
+        const wrapped = wrapText(formatted, termWidth);
+        for (const wl of wrapped) {
+          console.log(wl);
+        }
+      }
+    } else if (codeBlockFenceChar === "~~~") {
+      if (lang && !inNestedCodeBlock) {
+        inNestedCodeBlock = true;
+        codeBlockLines.push(line);
+      } else if (!lang && inNestedCodeBlock) {
+        inNestedCodeBlock = false;
+        codeBlockLines.push(line);
+      } else if (!lang && !inNestedCodeBlock) {
+        stopStreamingIndicator();
+        renderCodeBlock(codeBlockLang, codeBlockLines);
+        inCodeBlock = false;
+        inNestedCodeBlock = false;
+        codeBlockFenceChar = "";
+        codeBlockLang = "";
+        codeBlockLines = [];
+      } else {
+        codeBlockLines.push(line);
+      }
+    } else {
+      if (lang && !inNestedCodeBlock) {
+        inNestedCodeBlock = true;
+        codeBlockLines.push(line);
+      } else if (!lang && inNestedCodeBlock) {
+        inNestedCodeBlock = false;
+        codeBlockLines.push(line);
+      } else {
+        codeBlockLines.push(line);
+      }
+    }
+    return;
+  }
+  const codeBlockMatch = line.match(/^(`{3,4})(\w*)$/);
   if (codeBlockMatch) {
+    const fenceChars = codeBlockMatch[1];
+    const lang = codeBlockMatch[2] || "";
     if (!inCodeBlock) {
       inCodeBlock = true;
-      codeBlockLang = codeBlockMatch[1] || "";
+      inNestedCodeBlock = false;
+      codeBlockFenceChar = fenceChars;
+      codeBlockLang = lang;
       codeBlockLines = [];
       if (codeBlockLang === "markdown" || codeBlockLang === "md") {
         startStreamingIndicator();
       }
-    } else {
+    } else if (!lang && inNestedCodeBlock && fenceChars === "```") {
+      inNestedCodeBlock = false;
+      codeBlockLines.push(line);
+    } else if (!inNestedCodeBlock && lang && fenceChars === "```") {
+      inNestedCodeBlock = true;
+      codeBlockLines.push(line);
+    } else if (!lang && !inNestedCodeBlock && codeBlockFenceChar === fenceChars) {
       stopStreamingIndicator();
       renderCodeBlock(codeBlockLang, codeBlockLines);
       inCodeBlock = false;
+      inNestedCodeBlock = false;
+      codeBlockFenceChar = "";
       codeBlockLang = "";
       codeBlockLines = [];
+    } else {
+      codeBlockLines.push(line);
     }
     return;
   }
   if (inCodeBlock) {
     codeBlockLines.push(line);
   } else {
-    console.log(formatMarkdownLine(line));
+    const formatted = formatMarkdownLine(line);
+    const termWidth = getTerminalWidth2();
+    const wrapped = wrapText(formatted, termWidth);
+    for (const wl of wrapped) {
+      console.log(wl);
+    }
   }
 }
 function renderCodeBlock(lang, lines) {
@@ -33241,8 +33345,9 @@ function wrapText(text13, maxWidth) {
   }
   const lines = [];
   let remaining = text13;
-  while (stripAnsi2(remaining).length > maxWidth) {
+  while (true) {
     const plain = stripAnsi2(remaining);
+    if (plain.length <= maxWidth) break;
     let breakPoint = maxWidth;
     const lastSpace = plain.lastIndexOf(" ", maxWidth);
     if (lastSpace > maxWidth * 0.5) {
@@ -33271,8 +33376,8 @@ function wrapText(text13, maxWidth) {
       rawPos = ansiPositions[ansiIdx].end;
       ansiIdx++;
     }
-    lines.push(remaining.slice(0, rawPos));
-    remaining = remaining.slice(rawPos).trimStart();
+    lines.push(remaining.slice(0, rawPos) + "\x1B[0m");
+    remaining = "\x1B[0m" + remaining.slice(rawPos).trimStart();
   }
   if (remaining) {
     lines.push(remaining);
@@ -33312,16 +33417,54 @@ function getToolIcon(toolName, input) {
 function renderToolStart(toolName, input, metadata) {
   const icon = getToolIcon(toolName, { ...input, wouldCreate: metadata?.isCreate });
   const summary = formatToolSummary(toolName, input);
-  let label = toolName;
   if (toolName === "write_file") {
-    label = chalk25.yellow.bold("MODIFY") + " " + chalk25.cyan(String(input.path || ""));
+    const label = chalk25.yellow.bold("MODIFY") + " " + chalk25.cyan(String(input.path || ""));
     console.log(`
 ${icon} ${label}`);
+    const preview = renderContentPreview(String(input.content || ""), 3);
+    if (preview) console.log(preview);
+    return;
+  }
+  if (toolName === "edit_file") {
+    console.log(`
+${icon} ${chalk25.yellow.bold("EDIT")} ${chalk25.cyan(String(input.path || ""))}`);
+    const editPreview = renderEditPreview(
+      String(input.old_string || ""),
+      String(input.new_string || "")
+    );
+    if (editPreview) console.log(editPreview);
     return;
   }
   console.log(`
 ${icon} ${chalk25.cyan.bold(toolName)} ${chalk25.dim(summary)}`);
 }
+function renderContentPreview(content, maxLines) {
+  const maxWidth = Math.max(getTerminalWidth2() - 6, 40);
+  const lines = content.split("\n");
+  const preview = [];
+  for (const line of lines) {
+    if (preview.length >= maxLines) break;
+    const trimmed = line.trimEnd();
+    if (trimmed.length === 0 && preview.length === 0) continue;
+    const truncated = trimmed.length > maxWidth ? trimmed.slice(0, maxWidth - 1) + "\u2026" : trimmed;
+    preview.push(`   ${truncated}`);
+  }
+  if (preview.length === 0) return "";
+  const totalNonEmpty = lines.filter((l) => l.trim().length > 0).length;
+  const more = totalNonEmpty > maxLines ? chalk25.dim(` \u2026 +${totalNonEmpty - maxLines} lines`) : "";
+  return chalk25.dim(preview.join("\n")) + more;
+}
+function renderEditPreview(oldStr, newStr) {
+  const maxWidth = Math.max(getTerminalWidth2() - 8, 30);
+  const firstOld = oldStr.split("\n").find((l) => l.trim().length > 0) ?? "";
+  const firstNew = newStr.split("\n").find((l) => l.trim().length > 0) ?? "";
+  if (!firstOld && !firstNew) return "";
+  const truncate2 = (s) => s.length > maxWidth ? s.slice(0, maxWidth - 1) + "\u2026" : s;
+  const lines = [];
+  if (firstOld) lines.push(chalk25.dim("   ") + chalk25.red(`- ${truncate2(firstOld.trim())}`));
+  if (firstNew) lines.push(chalk25.dim("   ") + chalk25.green(`+ ${truncate2(firstNew.trim())}`));
+  return lines.join("\n");
+}
 function renderToolEnd(result) {
   const status = result.result.success ? chalk25.green("\u2713") : chalk25.red("\u2717");
   const duration = chalk25.dim(`${result.duration.toFixed(0)}ms`);
@@ -33330,6 +33473,8 @@ function renderToolEnd(result) {
   if (!result.result.success && result.result.error) {
     console.log(chalk25.red(`  \u2514\u2500 ${result.result.error}`));
   }
+  const details = formatResultDetails(result);
+  if (details) console.log(details);
 }
 function formatToolSummary(toolName, input) {
   switch (toolName) {
@@ -33340,6 +33485,7 @@ function formatToolSummary(toolName, input) {
       return String(input.path || "");
     case "list_directory":
       return String(input.path || ".");
+    case "grep":
     case "search_files": {
       const pattern = String(input.pattern || "");
       const path54 = input.path ? ` in ${input.path}` : "";
@@ -33347,7 +33493,8 @@ function formatToolSummary(toolName, input) {
     }
     case "bash_exec": {
       const cmd = String(input.command || "");
-      return cmd.length > 50 ? cmd.slice(0, 47) + "..." : cmd;
+      const max = Math.max(getTerminalWidth2() - 20, 50);
+      return cmd.length > max ? cmd.slice(0, max - 1) + "\u2026" : cmd;
     }
     default:
       return formatToolInput(input);
@@ -33371,15 +33518,16 @@ function formatResultPreview(result) {
           return chalk25.dim(`(${files} files, ${dirs} dirs)`);
         }
         break;
+      case "grep":
       case "search_files":
         if (Array.isArray(data.matches)) {
-          return chalk25.dim(`(${data.matches.length} matches)`);
+          const n = data.matches.length;
+          return n === 0 ? chalk25.yellow("\xB7 no matches") : chalk25.dim(`\xB7 ${n} match${n === 1 ? "" : "es"}`);
         }
         break;
       case "bash_exec":
-        if (data.exitCode === 0) {
-          const lines = String(data.stdout || "").split("\n").length;
-          return chalk25.dim(`(${lines} lines)`);
+        if (data.exitCode !== void 0 && data.exitCode !== 0) {
+          return chalk25.red(`(exit ${data.exitCode})`);
         }
         break;
       case "write_file":
@@ -33390,6 +33538,47 @@ function formatResultPreview(result) {
   }
   return "";
 }
+function formatResultDetails(result) {
+  if (!result.result.success) return "";
+  const { name, result: toolResult } = result;
+  const maxWidth = Math.max(getTerminalWidth2() - 8, 40);
+  try {
+    const data = JSON.parse(toolResult.output);
+    if ((name === "grep" || name === "search_files") && Array.isArray(data.matches)) {
+      const matches = data.matches;
+      if (matches.length === 0) return "";
+      const MAX_SHOWN = 3;
+      const shown = matches.slice(0, MAX_SHOWN);
+      const lines = shown.map(({ file, line, content }) => {
+        const location = chalk25.cyan(`${file}:${line}`);
+        const snippet = content.trim();
+        const truncated = snippet.length > maxWidth ? snippet.slice(0, maxWidth - 1) + "\u2026" : snippet;
+        return `  ${chalk25.dim("\u2502")} ${location} ${chalk25.dim(truncated)}`;
+      });
+      if (matches.length > MAX_SHOWN) {
+        lines.push(`  ${chalk25.dim(`\u2502 \u2026 +${matches.length - MAX_SHOWN} more`)}`);
+      }
+      return lines.join("\n");
+    }
+    if (name === "bash_exec" && data.exitCode === 0) {
+      const stdout = String(data.stdout || "").trimEnd();
+      if (!stdout) return "";
+      const outputLines = stdout.split("\n").filter((l) => l.trim());
+      if (outputLines.length > 6) return "";
+      const shown = outputLines.slice(0, 4);
+      const lines = shown.map((l) => {
+        const truncated = l.length > maxWidth ? l.slice(0, maxWidth - 1) + "\u2026" : l;
+        return `  ${chalk25.dim("\u2502")} ${chalk25.dim(truncated)}`;
+      });
+      if (outputLines.length > 4) {
+        lines.push(`  ${chalk25.dim(`\u2502 \u2026 +${outputLines.length - 4} more`)}`);
+      }
+      return lines.join("\n");
+    }
+  } catch {
+  }
+  return "";
+}
 function formatToolInput(input) {
   const entries = Object.entries(input);
   if (entries.length === 0) return "";
@@ -38786,7 +38975,7 @@ init_errors();
 init_paths();
 var fs36 = await import('fs/promises');
 var path38 = await import('path');
-var crypto3 = await import('crypto');
+var crypto2 = await import('crypto');
 var GLOBAL_MEMORIES_DIR = path38.join(COCO_HOME, "memories");
 var PROJECT_MEMORIES_DIR = ".coco/memories";
 var DEFAULT_MAX_MEMORIES = 1e3;
@@ -38868,7 +39057,7 @@ Examples:
         { tool: "create_memory" }
       );
     }
-    const id = crypto3.randomUUID();
+    const id = crypto2.randomUUID();
     const memory = {
       id,
       key,
@@ -38983,7 +39172,7 @@ var memoryTools = [createMemoryTool, recallMemoryTool, listMemoriesTool];
 init_registry4();
 init_errors();
 var fs37 = await import('fs/promises');
-var crypto4 = await import('crypto');
+var crypto3 = await import('crypto');
 var CHECKPOINT_FILE = ".coco/checkpoints.json";
 var DEFAULT_MAX_CHECKPOINTS = 50;
 var STASH_PREFIX = "coco-cp";
@@ -39038,7 +39227,7 @@ Examples:
     description: z.string().min(1).max(200).describe("Description of this checkpoint")
   }),
   async execute({ description }) {
-    const id = crypto4.randomUUID().slice(0, 8);
+    const id = crypto3.randomUUID().slice(0, 8);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const stashMessage = `${STASH_PREFIX}-${id}-${description.replace(/\s+/g, "-").slice(0, 50)}`;
     const changedFiles = await getChangedFiles();
@@ -42128,6 +42317,115 @@ function findNextWordBoundary(line, pos) {
   while (i < line.length && line[i] === " ") i++;
   return i;
 }
+function countVisualRows(text13, startCol, termCols) {
+  let rows = 1;
+  let col = startCol;
+  for (const char of text13) {
+    if (char === "\n") {
+      if (col > 0) rows++;
+      col = 0;
+    } else {
+      col++;
+      if (col >= termCols) {
+        rows++;
+        col = 0;
+      }
+    }
+  }
+  return rows;
+}
+function getCursorVisualPos(text13, cursorPos, promptLen, termCols) {
+  let row = 0;
+  let col = promptLen;
+  for (let i = 0; i < cursorPos; i++) {
+    if (text13[i] === "\n") {
+      if (col > 0) row++;
+      col = 0;
+    } else {
+      col++;
+      if (col >= termCols) {
+        row++;
+        col = 0;
+      }
+    }
+  }
+  return { row, col };
+}
+function computeWordWrap(text13, startCol, termCols) {
+  const passthrough = {
+    display: text13,
+    toDisplayPos: (p45) => p45,
+    toOrigPos: (p45) => p45
+  };
+  if (!text13 || termCols <= 1) return passthrough;
+  const origToDisp = new Int32Array(text13.length + 1);
+  const dispToOrig = [];
+  let display = "";
+  let col = startCol;
+  function emitChar(ch, origIdx) {
+    origToDisp[origIdx] = display.length;
+    dispToOrig.push(origIdx);
+    display += ch;
+    col = ch === "\n" ? 0 : col + 1;
+  }
+  function injectNewline() {
+    dispToOrig.push(-1);
+    display += "\n";
+    col = 0;
+  }
+  let i = 0;
+  while (i < text13.length) {
+    const ch = text13[i];
+    if (ch === "\n") {
+      emitChar("\n", i++);
+      continue;
+    }
+    if (ch !== " ") {
+      let wordEnd = i;
+      while (wordEnd < text13.length && text13[wordEnd] !== " " && text13[wordEnd] !== "\n") {
+        wordEnd++;
+      }
+      const wordLen = wordEnd - i;
+      if (col > 0 && col + wordLen > termCols) {
+        injectNewline();
+      }
+      for (let k = i; k < wordEnd; k++) {
+        emitChar(text13[k], k);
+        if (col >= termCols && k + 1 < wordEnd) {
+          injectNewline();
+        }
+      }
+      i = wordEnd;
+    } else {
+      emitChar(" ", i++);
+      if (col >= termCols) {
+        col = 0;
+      } else {
+        let nextWordEnd = i;
+        while (nextWordEnd < text13.length && text13[nextWordEnd] !== " " && text13[nextWordEnd] !== "\n") {
+          nextWordEnd++;
+        }
+        const nextWordLen = nextWordEnd - i;
+        if (nextWordLen > 0 && col + nextWordLen > termCols) {
+          injectNewline();
+        }
+      }
+    }
+  }
+  origToDisp[text13.length] = display.length;
+  return {
+    display,
+    toDisplayPos: (origPos) => origToDisp[Math.min(origPos, text13.length)] ?? display.length,
+    toOrigPos: (displayPos) => {
+      const dp = Math.max(0, Math.min(displayPos, dispToOrig.length - 1));
+      for (let d = dp; d >= 0; d--) {
+        const orig = dispToOrig[d];
+        if (orig !== void 0 && orig >= 0) return orig;
+      }
+      return 0;
+    }
+  };
+}
 function createInputHandler(_session) {
   const savedHistory = loadHistory();
   const sessionHistory = [...savedHistory];
@@ -42142,6 +42440,7 @@ function createInputHandler(_session) {
   let lastCursorRow = 0;
   let lastContentRows = 1;
   let isFirstRender = true;
+  let lastCtrlCTime = 0;
   let isPasting = false;
   let pasteBuffer = "";
   let isReadingClipboard = false;
@@ -42183,7 +42482,9 @@ function createInputHandler(_session) {
     process.stdout.write("\r" + ansiEscapes.eraseDown);
     const separator = chalk25.dim("\u2500".repeat(termCols));
     let output = separator + "\n";
-    output += prompt.str + currentLine;
+    const ww = computeWordWrap(currentLine, prompt.visualLen, termCols);
+    const displayLine = ww.display;
+    output += prompt.str + displayLine;
     completions = findCompletions(currentLine);
     selectedCompletion = Math.min(selectedCompletion, Math.max(0, completions.length - 1));
     if (cursorPos === currentLine.length && completions.length > 0 && completions[selectedCompletion]) {
@@ -42192,9 +42493,23 @@ function createInputHandler(_session) {
         output += chalk25.dim.gray(ghost);
       }
     }
-    const totalContentLen = prompt.visualLen + currentLine.length;
-    const contentRows = totalContentLen === 0 ? 1 : Math.ceil(totalContentLen / termCols);
-    const contentExactFill = totalContentLen > 0 && totalContentLen % termCols === 0;
+    const hasWrapped = displayLine.includes("\n");
+    const contentRows = hasWrapped ? countVisualRows(displayLine, prompt.visualLen, termCols) : (() => {
+      const len = prompt.visualLen + displayLine.length;
+      return len === 0 ? 1 : Math.ceil(len / termCols);
+    })();
+    const contentExactFill = hasWrapped ? (() => {
+      const { col } = getCursorVisualPos(
+        displayLine,
+        displayLine.length,
+        prompt.visualLen,
+        termCols
+      );
+      return col === 0 && displayLine.length > 0;
+    })() : (() => {
+      const len = prompt.visualLen + displayLine.length;
+      return len > 0 && len % termCols === 0;
+    })();
     output += (contentExactFill ? "" : "\n") + separator;
     const showMenu = completions.length > 0 && currentLine.startsWith("/") && currentLine.length >= 1;
     let extraLinesBelow = 0;
@@ -42251,10 +42566,19 @@ function createInputHandler(_session) {
     const totalUp = extraLinesBelow + 1 + contentRows;
     output += ansiEscapes.cursorUp(totalUp);
     output += ansiEscapes.cursorDown(1);
-    const cursorAbsolutePos = prompt.visualLen + cursorPos;
-    const onExactBoundary = cursorAbsolutePos > 0 && cursorAbsolutePos % termCols === 0;
-    const finalLine = onExactBoundary ? cursorAbsolutePos / termCols - 1 : Math.floor(cursorAbsolutePos / termCols);
-    const finalCol = onExactBoundary ? 0 : cursorAbsolutePos % termCols;
+    const displayCursorPos = cursorPos === 0 ? 0 : ww.toDisplayPos(cursorPos);
+    let finalLine;
+    let finalCol;
+    if (hasWrapped) {
+      const pos = getCursorVisualPos(displayLine, displayCursorPos, prompt.visualLen, termCols);
+      finalLine = pos.row;
+      finalCol = pos.col;
+    } else {
+      const cursorAbsolutePos = prompt.visualLen + cursorPos;
+      const onExactBoundary = cursorAbsolutePos > 0 && cursorAbsolutePos % termCols === 0;
+      finalLine = onExactBoundary ? cursorAbsolutePos / termCols - 1 : Math.floor(cursorAbsolutePos / termCols);
+      finalCol = onExactBoundary ? 0 : cursorAbsolutePos % termCols;
+    }
     output += "\r";
     if (finalLine > 0) {
       output += ansiEscapes.cursorDown(finalLine);
@@ -42275,8 +42599,8 @@ function createInputHandler(_session) {
     lastMenuLines = 0;
   }
   function insertTextAtCursor(text13) {
-    const cleaned = text13.replace(/[\r\n]+/g, " ");
-    const printable = cleaned.replace(/[^\x20-\x7E\u00A0-\uFFFF]/g, "");
+    const cleaned = text13.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const printable = cleaned.replace(/[^\n\x20-\x7E\u00A0-\uFFFF]/g, "");
     if (printable.length === 0) return;
     currentLine = currentLine.slice(0, cursorPos) + printable + currentLine.slice(cursorPos);
     cursorPos += printable.length;
@@ -42343,10 +42667,27 @@ function createInputHandler(_session) {
             return;
           }
           if (key === "") {
+            if (currentLine.length > 0) {
+              currentLine = "";
+              cursorPos = 0;
+              selectedCompletion = 0;
+              historyIndex = -1;
+              lastCtrlCTime = 0;
+              render();
+              return;
+            }
+            const now = Date.now();
+            if (now - lastCtrlCTime < 800) {
+              cleanup();
+              console.log("\n\u{1F44B} Goodbye!");
+              saveHistory(sessionHistory);
+              process.exit(0);
+            }
+            lastCtrlCTime = now;
             cleanup();
-            console.log("\n\u{1F44B} Goodbye!");
-            saveHistory(sessionHistory);
-            process.exit(0);
+            console.log(chalk25.dim("(Press Ctrl+C again to exit)"));
+            resolve4("");
+            return;
           }
           if (key === "") {
             if (currentLine.length === 0) {
@@ -42484,7 +42825,10 @@ function createInputHandler(_session) {
                 selectedCompletion = Math.min(targetIndex, completions.length - 1);
               }
               render();
-            } else if (sessionHistory.length > 0 && completions.length === 0) {
+            } else if (cursorPos > 0) {
+              cursorPos = 0;
+              render();
+            } else if (sessionHistory.length > 0) {
               if (historyIndex === -1) {
                 tempLine = currentLine;
                 historyIndex = sessionHistory.length - 1;
@@ -42510,7 +42854,10 @@ function createInputHandler(_session) {
                 selectedCompletion = currentCol;
               }
               render();
-            } else if (historyIndex !== -1 && completions.length === 0) {
+            } else if (cursorPos < currentLine.length) {
+              cursorPos = currentLine.length;
+              render();
+            } else if (historyIndex !== -1) {
               if (historyIndex < sessionHistory.length - 1) {
                 historyIndex++;
                 currentLine = sessionHistory[historyIndex] ?? "";
@@ -42655,7 +43002,9 @@ function createSpinner(message) {
         const elapsed = startTime ? Math.floor((Date.now() - startTime) / 1e3) : 0;
         const elapsedStr = elapsed > 0 ? chalk25.dim(` (${elapsed}s)`) : "";
         const toolCountStr = formatToolCount();
-        spinner19.succeed(`${finalMessage || currentMessage}${toolCountStr}${elapsedStr}`);
+        const rawMsg = finalMessage || currentMessage;
+        const cleanMsg = rawMsg.replace(/\u2026$|\.\.\.$/, "").trimEnd();
+        spinner19.succeed(`${cleanMsg}${toolCountStr}${elapsedStr}`);
         spinner19 = null;
       }
       startTime = null;
@@ -44521,7 +44870,13 @@ function formatGitShort(ctx) {
   return chalk25.dim("\u{1F33F} ") + branch + dirty;
 }
 init_full_access_mode();
-function formatStatusBar(projectPath, config, gitCtx) {
+function formatContextUsage(percent) {
+  const label = `ctx ${percent.toFixed(0)}%`;
+  if (percent >= 90) return chalk25.red(label);
+  if (percent >= 75) return chalk25.yellow(label);
+  return chalk25.dim(label);
+}
+function formatStatusBar(projectPath, config, gitCtx, contextUsagePercent) {
   const parts = [];
   const projectName = path34__default.basename(projectPath);
   parts.push(chalk25.dim("\u{1F4C1}") + chalk25.magenta(projectName));
@@ -44537,10 +44892,13 @@ function formatStatusBar(projectPath, config, gitCtx) {
   if (gitCtx) {
     parts.push(formatGitShort(gitCtx));
   }
+  if (contextUsagePercent !== void 0 && contextUsagePercent > 0) {
+    parts.push(formatContextUsage(contextUsagePercent));
+  }
   return "  " + parts.join(chalk25.dim(" \u2022 "));
 }
-function renderStatusBar(projectPath, config, gitCtx) {
-  const statusLine = formatStatusBar(projectPath, config, gitCtx);
+function renderStatusBar(projectPath, config, gitCtx, contextUsagePercent) {
+  const statusLine = formatStatusBar(projectPath, config, gitCtx, contextUsagePercent);
   console.log();
   console.log(statusLine);
 }
@@ -44723,6 +45081,8 @@ async function startRepl(options = {}) {
     }).finally(() => process.exit(0));
   };
   process.once("SIGTERM", sigtermHandler);
+  let warned75 = false;
+  let warned90 = false;
   while (true) {
     let autoInput = null;
     if (pendingQueuedMessages.length > 0) {
@@ -44998,7 +45358,8 @@ async function startRepl(options = {}) {
         },
         onToolEnd: (result2) => {
           const elapsed = activeSpinner && typeof activeSpinner.getElapsed === "function" ? activeSpinner.getElapsed() : 0;
-          if (elapsed >= 30) {
+          if (elapsed >= 3) {
+            inputEcho.clear();
             activeSpinner?.stop();
             activeSpinner = null;
             turnActiveSpinner = null;
@@ -45050,7 +45411,15 @@ async function startRepl(options = {}) {
         },
         onThinkingEnd: () => {
           clearThinkingInterval();
-          clearSpinner();
+          const thinkingElapsed = activeSpinner?.getElapsed() ?? 0;
+          if (thinkingElapsed >= 2) {
+            inputEcho.clear();
+            activeSpinner?.stop();
+            activeSpinner = null;
+            turnActiveSpinner = null;
+          } else {
+            clearSpinner();
+          }
         },
         onToolPreparing: (toolName) => {
           setSpinner(getToolPreparingDescription(toolName));
@@ -45153,20 +45522,34 @@ async function startRepl(options = {}) {
         if (ctx) gitContext = ctx;
       }).catch(() => {
       });
-      renderStatusBar(session.projectPath, session.config, gitContext);
+      const usageBefore = getContextUsagePercent(session);
+      let usageForDisplay = usageBefore;
       try {
-        const usageBefore = getContextUsagePercent(session);
         const compactionResult = await checkAndCompactContext(session, provider);
         if (compactionResult?.wasCompacted) {
-          const usageAfter = getContextUsagePercent(session);
+          usageForDisplay = getContextUsagePercent(session);
           console.log(
             chalk25.dim(
-              `Context compacted (${usageBefore.toFixed(0)}% -> ${usageAfter.toFixed(0)}%)`
+              `Context compacted (${usageBefore.toFixed(0)}% -> ${usageForDisplay.toFixed(0)}%)`
             )
           );
+          warned75 = false;
+          warned90 = false;
         }
       } catch {
       }
+      renderStatusBar(session.projectPath, session.config, gitContext, usageForDisplay);
+      if (usageForDisplay >= 90 && !warned90) {
+        warned90 = true;
+        console.log(
+          chalk25.red("  \u2717 Context critical (" + usageForDisplay.toFixed(0) + "%) \u2014 use /clear to start fresh")
+        );
+      } else if (usageForDisplay >= 75 && !warned75) {
+        warned75 = true;
+        console.log(
+          chalk25.yellow("  \u26A0  Context at " + usageForDisplay.toFixed(0) + "% \u2014 use /clear to start fresh or /compact to summarize")
+        );
+      }
       console.log();
     } catch (error) {
       clearThinkingInterval();