thincoder 0.8.11 → 0.8.13

package/src/tools/file.mjs

@@ -6,7 +6,10 @@ import {
   autoSyntaxCheck,
   resolveInCwd,
   resolveExternal,
+  normalizeEOL,
 } from "./shared.mjs";
+import { specForModel } from "../config.mjs";
+import { createHash } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { stat } from "node:fs/promises";
@@ -27,6 +30,7 @@ export const readTool = {
       offset: { type: "number", description: "1-based line number to start from" },
       limit: { type: "number", description: `Max lines to return (default ${MAX_READ_LINES})` },
       allowExternal: { type: "boolean", description: "Allow reading files outside the working directory. Only set true when the user explicitly provided an external path — never use this to explore beyond cwd on your own." },
+      hashes: { type: "boolean", description: "Include SHA256 line hashes for hash-based editing (default false). Use when you plan to edit the file with hashline_edit." },
     },
     required: ["path"],
   },
@@ -36,12 +40,19 @@ export const readTool = {
     // Large file guard: check size first, reject reading entire file if >10MB (offset/limit only affect the returned slice, not buffering)
     const st = await stat(abs).catch(() => null)
     if (st && st.size > MAX_FILE_READ_BYTES) throw new Error(`File too large (${Math.round(st.size / 1_000_000)}MB > 10MB limit). Use bash with head/tail or grep for targeted extraction.`)
-    const content = await readFile(abs, "utf8")
+    const content = normalizeEOL(await readFile(abs, "utf8"))
     const lines = content.split("\n")
     const offset = Math.max(1, args.offset ?? 1)
     const limit = Math.min(args.limit ?? MAX_READ_LINES, MAX_READ_LINES)
     const slice = lines.slice(offset - 1, offset - 1 + limit)
-    const numbered = slice.map((l, i) => `${offset + i}\t${l}`).join("\n")
+    const numbered = slice.map((l, i) => {
+      const ln = offset + i
+      if (args.hashes) {
+        const h = createHash("sha256").update(l).digest("hex").slice(0, 12)
+        return `${ln}\t[${h}] ${l}`
+      }
+      return `${ln}\t${l}`
+    }).join("\n")
     const suffix = offset - 1 + limit < lines.length ? `\n... (${lines.length} lines total, use offset to continue)` : ""
     return truncate(numbered + suffix)
   },
@@ -65,6 +76,15 @@ export const readImageTool = {
   multimodal: true, // returns JSON { text, images } — agent loop converts to multimodal user message
   /** Returns JSON: { text, images }, for the agent layer to convert into multimodal user messages */
   async execute(args, ctx) {
+    // Vision capability gate: injecting an image into a text-only model's history poisons the whole
+    // conversation (every subsequent request 400s on the image part). Refuse before reading the file.
+    const model = ctx.agent?.provider?.model
+    if (model && !specForModel(model).multimodal) {
+      throw new Error(
+        `Model "${model}" does not support image input — read_image is unavailable with this provider. ` +
+        `Verify visual output programmatically (file size, dimensions, pixel checks via code) or ask the user to switch to a vision-capable provider.`
+      )
+    }
     const abs = resolveInCwd(ctx, args.path)
     const ext = abs.slice(abs.lastIndexOf(".") + 1).toLowerCase()
     const mime = IMAGE_EXTENSIONS[ext]
@@ -134,7 +154,7 @@ export const editTool = {
     if (!args.old_string) {
       throw new Error("old_string must not be empty (empty string matches everywhere and would corrupt the file)")
     }
-    const content = await readFile(abs, "utf8")
+    const content = normalizeEOL(await readFile(abs, "utf8"))
     const occurrences = content.split(args.old_string).length - 1
     if (occurrences === 0) {
       // Give clues to help the model locate: first-line preview + common causes
@@ -176,7 +196,7 @@ export const insertAfterTool = {
   readonly: false,
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
-    const text = await readFile(abs, "utf8")
+    const text = normalizeEOL(await readFile(abs, "utf8"))
     const lines = text.split("\n")
 
     let targetLine
@@ -189,7 +209,12 @@ export const insertAfterTool = {
         throw new Error(`after_line ${targetLine} out of range (file has ${lines.length} lines)`)
       }
     } else if (args.after_regex) {
-      const regex = new RegExp(args.after_regex)
+      let regex
+      try {
+        regex = new RegExp(args.after_regex)
+      } catch (e) {
+        throw new Error(`after_regex /${args.after_regex}/ is not a valid JavaScript regex: ${e.message}`)
+      }
       const matches = []
       for (let i = 0; i < lines.length; i++) {
         if (regex.test(lines[i])) matches.push(i + 1)
@@ -209,3 +234,87 @@ export const insertAfterTool = {
   },
 }
 
+// ---------------------------------------------------------------- hashline_edit
+
+/**
+ * Compute a 12-char hex SHA256 hash for a line (exact content, no trimming).
+ * Used by both read (hashes=true) and hashline_edit for hash-based matching.
+ */
+export function hashLine(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 12)
+}
+
+export const hashlineEditTool = {
+  name: "hashline_edit",
+  description: DESC("hashline_edit"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path" },
+      old_hashes: { type: "array", items: { type: "string" }, description: "SHA256 hashes (12 chars) of the lines to replace. Read the file with hashes=true first to obtain these hashes. Single line: pass 1 hash; multiple lines: pass the exact sequence of hashes." },
+      new_content: { type: "string", description: "Replacement text (can span multiple lines)" },
+    },
+    required: ["path", "old_hashes", "new_content"],
+  },
+  readonly: false,
+  async execute(args, ctx) {
+    const abs = resolveInCwd(ctx, args.path)
+    if (!args.old_hashes?.length) throw new Error("old_hashes must not be empty — read the file with hashes=true to get line hashes")
+    const content = normalizeEOL(await readFile(abs, "utf8"))
+    const lines = content.split("\n")
+    const fileHashes = lines.map((l) => hashLine(l))
+    const target = args.old_hashes
+
+    // Sliding-window match: find all occurrences of the hash sequence.
+    // When multiple matches are found (e.g. empty lines), report positions so the
+    // model can include more context lines (adjacent lines with unique hashes).
+    const matches = []
+    for (let i = 0; i <= fileHashes.length - target.length; i++) {
+      let match = true
+      for (let j = 0; j < target.length; j++) {
+        if (fileHashes[i + j] !== target[j]) { match = false; break }
+      }
+      if (match) matches.push(i)
+    }
+
+    if (matches.length === 0) {
+      // Help the model recover: show the current file hashes for context
+      const maxShow = Math.min(fileHashes.length, 50)
+      const hashDump = fileHashes.slice(0, maxShow).map((h, i) => `${h}  L${i + 1}: ${lines[i].slice(0, 80)}`).join("\n")
+      const preview = target.join(" ")
+      throw new Error(
+        `Hash sequence not found in ${args.path}: ${preview}\n` +
+        `The file may have been modified since you last read it. Current hashes (first ${maxShow} lines):\n${hashDump}`
+      )
+    }
+
+    if (matches.length > 1) {
+      const ctx = 2 // lines of surrounding context
+      const detail = matches.map((m) => {
+        const start = Math.max(0, m - ctx)
+        const end = Math.min(lines.length, m + target.length + ctx)
+        const preview = lines.slice(start, end).map((l, i) => {
+          const ln = start + i + 1
+          const marker = m <= ln - 1 && ln - 1 < m + target.length ? ">" : " "
+          return `${marker} L${ln}: ${l.slice(0, 80)}`
+        }).join("\n")
+        return `  Match at line ${m + 1} (${target.length} line(s)):\n${preview}`
+      }).join("\n\n")
+      throw new Error(
+        `Hash sequence matches ${matches.length} positions in ${args.path} — ambiguous.\n` +
+        `Include more surrounding lines (unique-hash lines before/after the target) to disambiguate.\n\n` +
+        `All matches with surrounding context:\n\n${detail}`
+      )
+    }
+
+    const pos = matches[0]
+    // Replace: remove old lines, insert new lines at the same position
+    const newLines = args.new_content.split("\n")
+    lines.splice(pos, target.length, ...newLines)
+    const updated = lines.join("\n")
+    await writeFile(abs, updated, "utf8")
+    const diff = gitDiffOne(ctx.cwd, abs)
+    return `Edited ${args.path}: replaced ${target.length} line(s) at L${pos + 1} with ${newLines.length} line(s)${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}`
+  },
+}
+

package/src/tools/hashline_edit.md

@@ -0,0 +1,12 @@
+Edit a file using content-hash addressing instead of string matching. More reliable than edit when whitespace or encoding varies — hashes are computed from exact line bytes on disk.
+
+Parameters:
+- path (required): File path
+- old_hashes (required): Array of SHA256 hashes (12-char hex) identifying lines to replace. Read the file with hashes=true first to obtain these hashes. For a single line, pass [hash]; for a contiguous block, pass [hash1, hash2, ...] in order.
+- new_content (required): Replacement text (multi-line ok, \n separated)
+
+Notes:
+- The hash of each line is computed as SHA256(line_content).slice(0, 12) — the same algorithm used by read(hashes=true)
+- Hashes are position-independent: they identify lines by content, not by line number (which changes after edits)
+- If the hash sequence isn't found, the error will include the current file's hashes so you can retry with corrected values
+- Prefer this over edit when: 1) the file may have mixed whitespace/encoding, 2) you want to edit a block of lines with a single call

package/src/tools/index.mjs

@@ -1,24 +1,26 @@
 // tools/index.mjs — backend-compatible re-export
 export { toOpenAISchema } from "./shared.mjs";
 
-import { readTool, writeTool, editTool, insertAfterTool, readImageTool } from "./file.mjs";
+import { readTool, writeTool, editTool, insertAfterTool, readImageTool, hashlineEditTool } from "./file.mjs";
 import { applyPatchTool, syntaxCheckTool, deleteTool } from "./patch.mjs";
 import { bashTool, globTool, grepTool, lsTool } from "./system.mjs";
 import { websearchTool, fetchTool } from "./web.mjs";
 import { gitDiffTool, gitStatusTool, gitLogTool, questionTool, checkpointTool } from "./git.mjs";
 import { checklistTool } from "./checklist.mjs";
+import { linterTool } from "./linter.mjs";
 
 export const builtinTools = [
-  readTool, writeTool, editTool, insertAfterTool, applyPatchTool,
+  readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
   syntaxCheckTool, readImageTool, bashTool, globTool, grepTool,
   websearchTool, lsTool, fetchTool, deleteTool,
   gitDiffTool, gitStatusTool, gitLogTool, questionTool, checkpointTool,
-  checklistTool,
+  checklistTool, linterTool,
 ];
 
 export {
-  readTool, writeTool, editTool, insertAfterTool, applyPatchTool,
+  readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
   syntaxCheckTool, readImageTool, bashTool, globTool, grepTool,
   websearchTool, lsTool, fetchTool, deleteTool,
   gitDiffTool, gitStatusTool, gitLogTool, questionTool, checkpointTool,
+  checklistTool, linterTool,
 };

package/src/tools/linter.md

@@ -0,0 +1,13 @@
+Run the appropriate linter/checker for a file. Auto-detects based on file extension and project config.
+
+Parameters:
+- path (optional): File to check (default: most recently modified file)
+
+Supported languages:
+- .js/.mjs/.cjs/.jsx: eslint (if config present) → node --check (built-in, always available)
+- .ts/.tsx/.mts/.cts: eslint → tsc --noEmit (if tsconfig.json present) → node --check
+- .py: ruff (if installed)
+- .rs: cargo check (if Cargo.toml present)
+- .go: go vet
+
+Does NOT install anything — only uses tools already available in the project.

package/src/tools/linter.mjs

@@ -0,0 +1,146 @@
+import { DESC, resolveInCwd } from "./shared.mjs"
+
+export const linterTool = {
+  name: "linter",
+  description: DESC("linter"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path (default: most recently modified file)" },
+    },
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const { execFileSync } = await import("node:child_process")
+    const { existsSync } = await import("node:fs")
+    const { join, relative } = await import("node:path")
+    const abs = args.path ? resolveInCwd(ctx, args.path) : (ctx.agent?._touchedFiles?.at(-1) || null)
+    if (!abs) return "linter: no file specified and no recently modified file to check"
+
+    const ext = abs.split(".").pop()?.toLowerCase()
+    const checkers = LANG_CHECKERS[ext]
+    if (!checkers) return `linter: no linter configured for .${ext} files. Supported: ${Object.keys(LANG_CHECKERS).map(e => `.${e}`).join(", ")}`
+
+    for (const checker of checkers) {
+      const result = await checker(abs, { cwd: ctx.cwd, existsSync, execFileSync, join, relative })
+      if (result !== null) return result
+    }
+    return `linter: no linter available for ${args.path || abs}. Install one?`
+  },
+}
+
+// ─── Checker definitions ──────────────────────
+
+async function eslintCheck(file, { cwd, existsSync, execFileSync, join, relative }) {
+  // Walk up to find eslint config
+  let dir = file.split(/[\\/]/).slice(0, -1).join("/") || "."
+  while (true) {
+    for (const cfg of [".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json", ".eslintrc.yaml", ".eslintrc.yml", "eslint.config.js", "eslint.config.mjs"]) {
+      if (existsSync(join(cwd, dir, cfg))) {
+        try {
+          const cfgDir = join(cwd, dir)
+          const relPath = relative(cfgDir, file)
+          execFileSync("npx", ["eslint", "--no-color", "--format", "compact", relPath], {
+            cwd: cfgDir, encoding: "utf8", timeout: 30000, stdio: ["ignore", "pipe", "pipe"],
+          })
+          return "✓ eslint: no issues"
+        } catch (e) {
+          const stdout = (e.stdout || "").trim()
+          if (stdout) return stdout
+          return `✗ eslint: ${(e.stderr || e.message).slice(0, 500)}`
+        }
+      }
+    }
+    const parent = dir.split("/").slice(0, -1).join("/")
+    if (!parent || parent === dir) break
+    dir = parent
+  }
+  return null
+}
+
+async function tscCheck(file, { cwd, existsSync, execFileSync, join }) {
+  if (!existsSync(join(cwd, "tsconfig.json"))) return null
+  if (!/\.(ts|tsx|mts|cts)$/.test(file)) return null
+  try {
+    execFileSync("npx", ["tsc", "--noEmit", "--pretty", "false"], {
+      cwd, encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"],
+    })
+    return "✓ tsc: no type errors"
+  } catch (e) {
+    const stdout = (e.stdout || "").trim()
+    if (stdout) return stdout
+    return `✗ tsc: ${(e.stderr || e.message).slice(0, 500)}`
+  }
+}
+
+async function nodeCheck(file, { execFileSync, cwd }) {
+  if (!/\.(m?js|cjs)$/.test(file)) return null
+  try {
+    execFileSync(process.execPath, ["--check", file], {
+      cwd, encoding: "utf8", timeout: 10000, stdio: ["ignore", "pipe", "pipe"],
+    })
+    return "✓ node --check: Syntax OK"
+  } catch (e) {
+    return `✗ node --check: ${(e.stderr || e.message).slice(0, 500)}`
+  }
+}
+
+async function ruffCheck(file, { cwd, execFileSync }) {
+  if (!/\.py$/.test(file)) return null
+  try {
+    execFileSync("ruff", ["check", "--output-format", "concise", file], {
+      cwd, encoding: "utf8", timeout: 30000, stdio: ["ignore", "pipe", "pipe"],
+    })
+    return "✓ ruff: no issues"
+  } catch (e) {
+    if (e.code === "ENOENT") return "linter: ruff not installed. Run: pip install ruff"
+    const stdout = (e.stdout || "").trim()
+    if (stdout) return stdout
+    return `✗ ruff: ${(e.stderr || e.message).slice(0, 500)}`
+  }
+}
+
+async function cargoCheck(file, { cwd, existsSync, execFileSync, join }) {
+  if (!/\.rs$/.test(file)) return null
+  if (!existsSync(join(cwd, "Cargo.toml"))) return null
+  const fname = file.split(/[\\/]/).pop()
+  try {
+    const out = execFileSync("cargo", ["check", "--message-format", "short"], {
+      cwd, encoding: "utf8", timeout: 120000, stdio: ["ignore", "pipe", "pipe"],
+    })
+    const errors = out.split("\n").filter(l => l.includes(fname))
+    return errors.length > 0 ? errors.join("\n") : "✓ cargo check: no errors"
+  } catch (e) {
+    const combined = ((e.stdout || "") + "\n" + (e.stderr || "")).trim()
+    const errors = combined.split("\n").filter(l => l.includes(fname) || l.startsWith("error"))
+    return errors.length > 0 ? errors.join("\n") : `✗ cargo check failed:\n${combined.slice(0, 1000)}`
+  }
+}
+
+async function goVet(file, { cwd, execFileSync }) {
+  if (!/\.go$/.test(file)) return null
+  try {
+    execFileSync("go", ["vet", file], {
+      cwd, encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"],
+    })
+    return "✓ go vet: no issues"
+  } catch (e) {
+    return `✗ go vet: ${(e.stderr || e.message).slice(0, 500)}`
+  }
+}
+
+// ─── Language → checkers (first available wins) ──
+
+const LANG_CHECKERS = {
+  js:  [eslintCheck, nodeCheck],
+  mjs: [eslintCheck, nodeCheck],
+  cjs: [eslintCheck, nodeCheck],
+  jsx: [eslintCheck, nodeCheck],
+  ts:  [eslintCheck, tscCheck],
+  tsx: [eslintCheck, tscCheck],
+  mts: [eslintCheck, tscCheck],
+  cts: [eslintCheck, tscCheck],
+  py:  [ruffCheck],
+  rs:  [cargoCheck],
+  go:  [goVet],
+}

package/src/tools/patch.mjs

@@ -6,7 +6,7 @@ import {
 import { execFileSync } from "node:child_process";
 import { mkdir } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
-import { stat } from "node:fs/promises";
+import { stat, lstat } from "node:fs/promises";
 import { writeFile } from "node:fs/promises";
 import { unlink } from "node:fs/promises";
 import { existsSync } from "node:fs";
@@ -206,8 +206,12 @@ export const deleteTool = {
   readonly: false,
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
-    if (!existsSync(abs)) throw new Error(`File not found: ${args.path}`)
-    const s = await stat(abs)
+    let s
+    try {
+      s = await lstat(abs)
+    } catch {
+      throw new Error(`File not found: ${args.path}`)
+    }
     if (s.isDirectory()) throw new Error(`"${args.path}" is a directory — use bash to remove directories`)
     // git-tracked files: refuse direct deletion (safety net); untracked: allow
     // Use resolved relative path (normalized forward slashes) to prevent backslash/unusual paths from bypassing ls-files matching

package/src/tools/read.md

@@ -1,10 +1,11 @@
 Read a text file. Returns numbered lines. Use offset/limit to page large files.
-
 Parameters:
-- path (required): File path, relative to cwd or absolute
+- path (required): File path, relative to cwd or absolute (alias: filePath)
 - offset: 1-based line number to start reading from
 - limit: Max lines to return (default 2000)
+- hashes: Include SHA256 content hashes per line (for hashline_edit). Set true before using hashline_edit.
 
 Notes:
 - Always prefer this over `cat` or shell-based reading — it caps output and avoids large dumps
 - Use offset for pagination when the file is large
+- When you plan to edit the file, set hashes=true to get line hashes for hashline_edit — hash-based editing avoids whitespace/encoding matching failures

package/src/tools/repomap.mjs

@@ -1,10 +1,12 @@
 /**
- * repomap.mjs — repo dependency outline (zero dependencies, pure regex)
+ * repomap.mjs — repo dependency outline
  * Real-time import/export parsing, generates compact text for LLMs to understand code structure.
  * No index stored — reads and parses files on each call, ~50ms.
  */
-import { readFileSync, existsSync } from "node:fs"
+import { existsSync } from "node:fs"
+import { readFile, stat } from "node:fs/promises"
 import { join } from "node:path"
+import { normalizeEOL } from "./shared.mjs"
 
 /** Extract JS/TS file import paths (normalize by stripping .ts/.js/.mjs suffixes) */
 function parseImports(lines, ext) {
@@ -113,17 +115,22 @@ function normalizeExt(p) {
  * Internal: scan all files, build forward dependency graph + reverse reference graph.
  * Returns { deps, importers, fileCount } shared by buildOutline / buildSummary.
  */
-function _buildDepGraph(db, cwd) {
+async function _buildDepGraph(db, cwd) {
   const allFiles = db.prepare(`SELECT DISTINCT path FROM code_chunks ORDER BY path`).all().map((r) => r.path)
   if (allFiles.length === 0) return null
 
   const deps = new Map()      // path → { imports: Set, exports: Set, size: number, dir: string }
   const importers = new Map() // importee → Set<importer>
 
-  for (const rel of allFiles) {
+  for (let i = 0; i < allFiles.length; i++) {
+    const rel = allFiles[i]
     const abs = join(cwd, ...rel.split("/"))
     if (!existsSync(abs)) continue
-    const text = readFileSync(abs, "utf8")
+    // Large file guard: skip files over 10MB to prevent OOM
+    const fst = await stat(abs).catch(() => null)
+    if (fst && fst.size > 10_000_000) continue
+    let text
+    try { text = normalizeEOL(await readFile(abs, "utf8")) } catch { continue }
     const lines = text.split("\n")
     const ext = rel.slice(rel.lastIndexOf(".")).toLowerCase()
 
@@ -160,6 +167,8 @@ function _buildDepGraph(db, cwd) {
       if (!importers.has(r)) importers.set(r, new Set())
       importers.get(r).add(rel)
     }
+    // Yield the event loop every 20 files to prevent TUI freeze
+    if (i % 20 === 19) await new Promise(r => setImmediate(r))
   }
 
   return { deps, importers, fileCount: allFiles.length }
@@ -173,8 +182,8 @@ function _buildDepGraph(db, cwd) {
  *  3. Entry points (files with no importers — startup/top-level entry points)
  * Output is naturally bounded (~1000-2000 chars), no more OUTLINE_INJECT_MAX hard truncation.
  */
-export function buildSummary(db, cwd) {
-  const graph = _buildDepGraph(db, cwd)
+export async function buildSummary(db, cwd) {
+  const graph = await _buildDepGraph(db, cwd)
   if (!graph) return "(no indexed source files; run codeSync or /reindex first)"
   const { deps, importers, fileCount } = graph
 
@@ -248,8 +257,8 @@ export function buildSummary(db, cwd) {
 }
 
 /** Get known file list from code_chunks (reuse index), parse by path to generate outline text */
-export function buildOutline(db, cwd, focusPath) {
-  const graph = _buildDepGraph(db, cwd)
+export async function buildOutline(db, cwd, focusPath) {
+  const graph = await _buildDepGraph(db, cwd)
   if (!graph) return "(no indexed source files; run codeSync or /reindex first)"
   const { deps, importers } = graph
 
@@ -298,7 +307,7 @@ export function repoOutlineTool(db, cwd) {
     },
     readonly: true,
     async execute(args) {
-      const outline = buildOutline(db, cwd, args.path ?? null)
+      const outline = await buildOutline(db, cwd, args.path ?? null)
       return outline
     },
   }

package/src/tools/shared.mjs

@@ -20,6 +20,13 @@ export const BASH_TIMEOUT_MS = 120_000
 export const MAX_RESPONSE_BODY_BYTES = 5_000_000
 export const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "build", ".turbo", "coverage"])
 
+/** Normalize Windows line endings to Unix: \r\n → \n.
+ *  Applied on every text-file read so that edit/hash matching
+ *  and hash computation are platform-consistent. */
+export function normalizeEOL(text) {
+  return text.replace(/\r\n/g, "\n")
+}
+
 /** Convert to OpenAI tools parameter format */
 export function toOpenAISchema(tool) {
   return {

package/src/tools/system.mjs

@@ -11,7 +11,8 @@ import {
   isDestructiveCommand,
   hasFileRedirection,
   insideGitRepo,
-  globToRegex
+  globToRegex,
+  normalizeEOL,
 } from "./shared.mjs";
 import { spawn, execFileSync } from "node:child_process";
 import { readFile, readdir, stat, lstat } from "node:fs/promises";
@@ -222,6 +223,8 @@ async function* walkFiles(dir, rel = "") {
     return
   }
   for (const e of entries) {
+    // Skip ignored dirs AND symbolic links (symlinks to directories would cause infinite loops)
+    if (e.isSymbolicLink()) continue
     if (e.isDirectory() && IGNORED_DIRS.has(e.name)) continue
     const relPath = rel ? `${rel}/${e.name}` : e.name
     if (e.isDirectory()) {
@@ -253,7 +256,12 @@ export const grepTool = {
   readonly: true,
   async execute(args, ctx) {
     const base = resolveInCwd(ctx, args.path ?? ".")
-    const regex = new RegExp(args.pattern)
+    let regex
+    try {
+      regex = new RegExp(args.pattern)
+    } catch (e) {
+      throw new Error(`grep pattern /${args.pattern}/ is not a valid regex: ${e.message}`)
+    }
     const fileFilter = args.glob ? globToRegex(args.glob) : null
     const before = Math.max(0, Math.floor(args.before ?? 0))
     const after = Math.max(0, Math.floor(args.after ?? 0))
@@ -267,7 +275,7 @@ export const grepTool = {
         // Large file guard: skip files over 10MB to prevent OOM
         const fst = await stat(file)
         if (fst.size > 10_000_000) return
-        content = await readFile(file, "utf8")
+        content = normalizeEOL(await readFile(file, "utf8"))
       } catch {
         return // Skip unreadable files; binary files will be read as UTF-8 and searched (may produce garbled matches)
       }
@@ -346,7 +354,13 @@ export const lsTool = {
   readonly: true,
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path ?? ".")
-    const entries = await readdir(abs, { withFileTypes: true })
+    let entries
+    try {
+      entries = await readdir(abs, { withFileTypes: true })
+    } catch (e) {
+      if (e.code === "ENOENT" || e.code === "ENOTDIR") throw new Error(`ls: ${args.path ?? "."} — ${e.code === "ENOTDIR" ? "not a directory" : "not found"}`)
+      throw e
+    }
     const rows = await Promise.all(
       entries.slice(0, 500).map(async (e) => {
         const s = await stat(join(abs, e.name)).catch(() => null)

package/src/tui/agent-turn.mjs

@@ -30,6 +30,7 @@ export async function runAgentTurn(ctx, text) {
   state.currentTool = null
   state.processingStarted = Date.now()
   state.controller = new AbortController()
+  state.interruptPrompt = null
   // Refresh status bar every second during processing (elapsed timer)
   const ticker = setInterval(() => {
     if (state.processing) render()
@@ -179,10 +180,13 @@ export async function runAgentTurn(ctx, text) {
       state.tokens.completion += usage.completion_tokens ?? 0
       state.tokens.cacheHit += usage.prompt_cache_hit_tokens ?? 0
       state.tokens.cacheMiss += usage.prompt_cache_miss_tokens ?? 0
+      state.tokens.reasoningTokens += usage.completion_tokens_details?.reasoning_tokens ?? 0
     },
     // Throttle wait (active gate / 429 backoff): show in status bar so user knows it's not frozen
     onWait: ({ phase, seconds }) => {
-      state.status = phase === "gate" ? `TPM throttle wait ~${seconds}s` : `Rate-limited 429, retry in ${seconds}s`
+      if (phase === "gate") state.status = `TPM throttle wait ~${seconds}s`
+      else if (phase === "overloaded") state.status = `Server overloaded, retrying in ${seconds}s`
+      else state.status = `Rate-limited 429, retry in ${seconds}s`
       render()
     },
     onTaskUpdate: (items) => {
@@ -193,12 +197,15 @@ export async function runAgentTurn(ctx, text) {
       pushLine(`  [task] ${done}/${items.length}${current ? ` ▶ ${current.title}` : ""}`, C.dim)
       render()
     },
+    onAdvisor: (note) => {
+      pushLine(`  [advisor] ${note.replace(/\n/g, "\n  ")}`, C.advisor)
+    },
     // Incremental save: flush to disk every 5 tool turns — mid-crash loss window shrinks from an entire round to a few turns
     onTurnEnd: (() => {
       let n = 0
       return () => {
         if (++n % 5 !== 0) return
-        try { saveSession(agent, state.lines) } catch {}
+        try { saveSession(agent, state.lines) } catch (e) { console.error(`[session] incremental save failed: ${e.message}`) }
       }
     })(),
   }
@@ -211,6 +218,14 @@ export async function runAgentTurn(ctx, text) {
     } catch (error) {
       flushStream()
       if (error.name === "AbortError" || state.controller?.signal.aborted) {
+        // Ctrl+I inject: the signal was aborted with an interrupt message — the agent loop
+        // may have already injected it into history, but the aborted signal prevents retry.
+        // Recreate the controller and resume from the same context.
+        if (state.controller?.signal?.reason?.interrupt) {
+          state.controller = new AbortController()
+          resume = true
+          continue
+        }
         pushLine("[stopped]", C.warn)
         break
       }

package/src/tui/ansi.mjs

@@ -17,6 +17,10 @@ export const ansi = {
   clearLine: `${ESC}[K`,
   clearToEnd: `${ESC}[J`,
   clearScreen: `${ESC}[2J`,
+  saveCursor: `${ESC}7`,      // DECSC — save cursor position
+  restoreCursor: `${ESC}8`,   // DECRC — restore cursor position
+  syncUpdateStart: `${ESC}[?2026h`, // DECSET 2026 — buffer output until syncUpdateEnd
+  syncUpdateEnd: `${ESC}[?2026l`,   // DECRST 2026 — flush buffered output atomically
   reset: `${ESC}[0m`,
   dim: `${ESC}[2m`,
   bold: `${ESC}[1m`,
@@ -33,4 +37,5 @@ export const C = {
   error: ansi.fg(1),
   dim: ansi.gray,
   warn: ansi.fg(3),
+  advisor: `${ESC}[92m`,  // bright green — visible on dark backgrounds
 }