thincoder 0.8.12 → 0.8.13

package/README.md

@@ -205,6 +205,22 @@ Code conventions: pure `.mjs`, no semicolons, no npm dependencies allowed (inclu
 
 ## Changelog
 
+### 0.8.13 (2026-07)
+- **TUI: incremental rendering** — panel-level cache (`panelCache`) with sync-update bracketing (`DECSET 2026`). Only redraws changed panels, eliminating flicker. `saveCursor`/`restoreCursor` for efficient cursor positioning. Panel order reorganized: `header → conversation → subagent → output → todo → picker → permission → queue → input → status`.
+- **Ctrl+I inject resume** — Ctrl+I (or Tab during processing) now properly interrupts, injects the message, and *resumes* the agent loop. Controller is recreated after abort. Added active signal check in SSE read loop for faster abort on Windows.
+- **Processing hints** — Input box shows "Ctrl+U clear" hint during processing. Tab during processing treated as Ctrl+I. Slash commands re-render the frame.
+- **Compression visibility** — `compressIfNeeded` now forwards `onToken`/`onReasoning` callbacks, making compression activity visible in the TUI.
+- **Session: data-preserving fallback** — when atomic rename fails during session save, fall back to direct write instead of losing data.
+- **Distill: balanced-bracket JSON extraction** — handles nested arrays in LLM output (e.g. `"tags": ["a", "b"]`), replacing the broken non-greedy regex approach.
+- **File tools: EOL normalization** — `normalizeEOL` (`\r\n` → `\n`) applied on all reads (`read`, `edit`, `hashline_edit`, `insert_after`, `grep`, `repomap`), making hash computation and string matching platform-consistent.
+- **hashline_edit: multiple-match detection** — when a hash sequence matches multiple positions, reports all with surrounding context instead of silently picking one.
+- **delete: symlink-safe** — uses `lstat` instead of `stat` to correctly identify symlinks (not directories even if pointing to one).
+- **repomap: large file guard** — skip files >10MB in dependency outline builds to prevent OOM.
+- **Improved error messages** — `grep` and `insert_after` now catch invalid regex patterns at validation time with clear error messages.
+- **Advisor session persistence** — advisor config saved/restored across sessions.
+- **Timeout hardening** — auto-think uses `AbortSignal.timeout(5s)`, embedding requests add 60s timeout, MCP HTTP connect uses `INIT_TIMEOUT_MS`, fetch timeout extended to 10 minutes.
+- **ClearScreen on exit** — terminal restored with `clearScreen` ANSI on TUI cleanup.
+
 ### 0.8.12 (2026-07)
 - **Indexing: git-repo-only** — `codeSync` and `docSync` now only index inside git worktrees (via `git ls-files`), respecting `.gitignore`. Non-git directories get empty indexes. Prevents 2.9GB memory.db from accidentally indexing entire user profiles (AppData, browser extensions, Office add-ins, Program Files)
 - **Indexing: file-size caps** — code files >1MB and doc files >512KB are skipped during bulk indexing (minified bundles, test fixtures, generated code)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.8.12",
+  "version": "0.8.13",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",

package/src/agent/setup.mjs

@@ -1,12 +1,9 @@
 /**
  * agent/setup.mjs — runAgent pre-flight setup: context injection, system prompt construction, tool injection
  */
-import { compressIfNeeded, compressFallback, COMPRESS_FAILURE_LIMIT } from "../context.mjs"
 import { search as memorySearch, docSearch } from "../memory.mjs"
 import { toOpenAISchema } from "../tools/index.mjs"
 import { loadSkills, formatSkillListing } from "../skills.mjs"
-import { specForModel } from "../config.mjs"
-import { join } from "node:path"
 import {
   escapeXml, repairHistory, listWorkDir, readonlyToolNames,
   collectGitContext, loadProjectInstructions, OUTLINE_INJECT_PREFIX,

package/src/agent.mjs

@@ -92,7 +92,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     const lastRole = agent.history.at(-1)?.role
     if (lastRole === "user" || lastRole === "tool") {
       try {
-        if (await compressIfNeeded(agent, threshold)) {
+        if (await compressIfNeeded(agent, threshold, callbacks)) {
           agent._compressFailures = 0
           recentCallSigs.length = 0 // After compression history is rebuilt, reset stall detection counter
           callbacks.onCompress?.()
@@ -118,7 +118,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     // Runs only on turn 0 of user input; failure is silent — falls back to current setting.
     if (agent.config?.agent?.autoThink && turn === 0) {
       const { classifyAndApply } = await import("./auto-think.mjs")
-      classifyAndApply(agent, turn).catch(() => {})
+      await classifyAndApply(agent, turn).catch(() => {})
     }
 
     try {
@@ -132,14 +132,12 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       })
     } catch (e) {
       // User interrupt (Ctrl+I): controller.abort({ interrupt: true, message: "…" }).
-      // The abort may fire before the SSE stream starts (during rate gate or HTTP request).
-      // Inject the user's message into history and retry from the same context.
+      // Inject the message into history and let the outer loop recreate the controller.
       if (e.name === "AbortError" && signal?.reason?.interrupt) {
         agent.history.push({
           role: "user",
           content: `[User interrupt: ${signal.reason.message}]`,
         })
-        continue
       }
       throw e
     }
@@ -170,7 +168,8 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     }
 
     // User interrupted mid-generation (Ctrl+I): the SSE stream was aborted while content
-    // was partially generated. Commit partial output + inject user message, then retry.
+    // was partially generated. Commit partial output + inject user message, then signal
+    // the outer loop to recreate the controller and resume.
     if (response.interrupted) {
       if (response.content) {
         agent.history.push({ role: "assistant", content: response.content })
@@ -179,7 +178,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
         role: "user",
         content: `[User interrupt: ${response.interruptMessage}]`,
       })
-      continue
+      throw Object.assign(new Error("User interrupted"), { name: "AbortError" })
     }
 
     if (response.usage) {

package/src/auto-think.mjs

@@ -62,7 +62,7 @@ export async function classifyAndApply(agent, turn) {
         { role: "user", content: prompt.slice(0, 2000) },
       ],
       tools: [],
-      signal: new AbortController().signal,
+      signal: AbortSignal.timeout(5_000),
     })
     const word = (response.content ?? "").trim().toLowerCase()
     if (word.startsWith("low")) level = "low"

package/src/context.mjs

@@ -143,7 +143,7 @@ function applyCompression(agent, headEnd, tailStart, note) {
  * Only called at safe points in the loop (history ends with user or tool message — a complete exchange boundary).
  * Automatically re-injects task list state after compaction.
  */
-export async function compressIfNeeded(agent, threshold) {
+export async function compressIfNeeded(agent, threshold, callbacks) {
   const history = agent.history
   // Prefer the real baseline: the last response's prompt_tokens is the measured value for the full context (system+tools+history).
   // Subsequent appended messages use estimation as increment; when no measured value exists (first turn / after restore / right after compaction), fall back to pure estimation
@@ -174,6 +174,8 @@ export async function compressIfNeeded(agent, threshold) {
   // The summary is a plain-text task, no reasoning needed — passing thinking to the compaction provider wastes tokens
   const summary = await chat({ ...agent.provider, thinking: null, reasoningEffort: null }, {
     messages: [{ role: "user", content: SUMMARIZE_PROMPT + serialized }],
+    onToken: callbacks?.onToken,
+    onReasoning: callbacks?.onReasoning,
   })
 
   applyCompression(agent, split.headEnd, split.tailStart, COMPACTION_PREFIX + summary.content)

package/src/distill.mjs

@@ -47,11 +47,26 @@ export async function extractCandidates(provider, transcript) {
   const res = await chat(provider, {
     messages: [{ role: "user", content: DISTILL_PROMPT + transcript }],
   })
-  // Non-greedy match first JSON array (greedy [\s\S]* would eat across multiple arrays including interstitial text)
-  const match = res.content.match(/\[[\s\S]*?\]/)
-  if (!match) return []
+  // Balanced-bracket extraction: find the first '[' and track depth through nested
+  // brackets (tags arrays, nested objects, etc.) until the matching ']'.
+  // Non-greedy regex (/\[[\s\S]*?\]/) stops at the FIRST ']', which is wrong when
+  // LLM output contains nested arrays like `"tags": ["a", "b"]`.
+  const start = res.content.indexOf("[")
+  if (start === -1) return []
+  let depth = 0
+  let end = -1
+  for (let i = start; i < res.content.length; i++) {
+    const ch = res.content[i]
+    if (ch === "[" && (i === start || res.content[i - 1] !== "\\")) depth++
+    else if (ch === "]" && res.content[i - 1] !== "\\") {
+      depth--
+      if (depth === 0) { end = i + 1; break }
+    }
+  }
+  if (end === -1) return []
+  const jsonText = res.content.slice(start, end)
   try {
-    const parsed = JSON.parse(match[0])
+    const parsed = JSON.parse(jsonText)
     if (!Array.isArray(parsed)) return []
     return parsed.filter((c) => c?.type && c?.title && c?.content)
   } catch {

package/src/embedding.mjs

@@ -84,7 +84,9 @@ async function requestWithRetry(embedder, input, signal) {
           Authorization: `Bearer ${embedder.apiKey}`,
         },
         body: JSON.stringify({ model: embedder.model, input }),
-        signal,
+        signal: signal
+          ? AbortSignal.any([signal, AbortSignal.timeout(60_000)])
+          : AbortSignal.timeout(60_000),
       })
     } catch (error) {
       if (error.name === "AbortError") throw error

package/src/mcp/transport-http.mjs

@@ -1,7 +1,7 @@
 /**
  * mcp/transport-http.mjs — MCP HTTP + SSE transport (Streamable HTTP)
  */
-import { rpcId, CALL_TIMEOUT_MS, ENDPOINT_WAIT_MS, withTimeout } from "./helpers.mjs"
+import { rpcId, CALL_TIMEOUT_MS, ENDPOINT_WAIT_MS, INIT_TIMEOUT_MS, withTimeout } from "./helpers.mjs"
 
 /** Create an MCP HTTP+SSE transport for Streamable HTTP servers */
 export function httpTransport(baseURL, extraHeaders = {}) {
@@ -56,10 +56,11 @@ export function httpTransport(baseURL, extraHeaders = {}) {
     if (closed) return
     abortController?.abort()
     abortController = new AbortController()
+    const signal = AbortSignal.any([abortController.signal, AbortSignal.timeout(INIT_TIMEOUT_MS)])
     const resp = await fetch(url, {
       method: "GET",
       headers: { Accept: "text/event-stream", ...extraHeaders },
-      signal: abortController.signal,
+      signal,
     })
     if (!resp.ok) throw new Error(`SSE connect failed: HTTP ${resp.status}`)
     eventSource = parseSSE(resp)

package/src/memory/docs.mjs

@@ -7,12 +7,11 @@ import { join } from "node:path"
 import { embed, cosine, toBlob, fromBlob } from "../embedding.mjs"
 import { commitAndPush } from "../git/gitmem.mjs"
 import { DOC_EXTS, SKIP_DIRS, MAX_DOC_FILE_BYTES } from "./schema.mjs"
-import { buildFtsQuery, put, search, putMarkdown } from "./core.mjs"
+import { buildFtsQuery, put, search, putMarkdown, EMBED_TEXT_MAX_LEN } from "./core.mjs"
 import { _upsertDocFile, yieldTick } from "./code-index.mjs"
 import { markIndexedCommit, listProjectFiles } from "./code-sync.mjs"
 
 const DOC_EMBED_BATCH = 64
-const EMBED_TEXT_MAX_LEN = 2000
 
 /**
  * Sync doc index: scan all .md/.mdc/.txt/.rst/.adoc under dir → chunk → upsert into doc_chunks.

package/src/provider/core.mjs

@@ -10,7 +10,7 @@ import {
   estimateRequestTokens, rateGate, recordRate,
 } from "./rate.mjs"
 
-const FETCH_TIMEOUT_MS = 120000
+const FETCH_TIMEOUT_MS = 600_000
 
 /** Create a validated provider config object from raw config */
 export function createProvider(config) {
@@ -315,6 +315,13 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal })
   if (!response.body) throw new Error("No stream response body")
   try {
     for await (const chunk of response.body) {
+      // Active signal check: Ctrl+I abort should halt stream immediately, not wait for
+      // the underlying fetch stream to propagate the abort (delayed on Windows).
+      if (signal?.aborted) {
+        const e = new DOMException("The operation was aborted", "AbortError")
+        e.reason = signal.reason
+        throw e
+      }
       buffer += decoder.decode(chunk, { stream: true })
       const lines = buffer.split("\n")
       buffer = lines.pop()

package/src/session.mjs

@@ -40,7 +40,9 @@ function writeSessionFile(p, data) {
       // rename succeeded: clean up temp file
       try { unlinkSync(tmp) } catch {}
     } catch {
-      // rename still failed: keep tmp as fallback data (next read prefers main file; if missing, tmp is at least there)
+      // rename still failed — fall back to direct write (non-atomic but data-preserving)
+      // p was deleted above; avoid losing both old and new data
+      writeFileSync(p, readFileSync(tmp, "utf8"), "utf8")
     }
   }
 }
@@ -161,6 +163,7 @@ export function saveSession(agent, display) {
     planMode: agent.planMode ?? false,
     autoApprove: agent.autoApprove ?? false,
     goal: agent.goal ?? null,
+    advisor: agent.config?.advisor ?? null,
     pendingReminders: agent._pendingReminders ?? [],
     sessionStart: agent._sessionStart ?? null,
   }
@@ -214,6 +217,9 @@ export function applySession(agent, data) {
   agent.goal = data.goal ?? null
   agent._pendingReminders = data.pendingReminders ?? []
   agent._sessionStart = data.sessionStart ?? null
+  if (data.advisor) {
+    agent.config.advisor = { ...data.advisor }
+  }
   // Reset stall/compaction state on session switch
   agent._compressFailures = 0
   agent._verifyRetries = 0
@@ -234,7 +240,7 @@ export function clearSession(cwd) {
   try {
     archiveCurrent(cwd)
     const p = sessionPath(cwd)
-    writeSessionFile(p, { version: 2, cwd, history: [], tasks: [], display: [], goal: null, autoApprove: false, pendingReminders: [], sessionStart: null })
+    writeSessionFile(p, { version: 2, cwd, history: [], tasks: [], display: [], goal: null, autoApprove: false, advisor: null, pendingReminders: [], sessionStart: null })
   } catch {
     // Can't clear, oh well — next save will overwrite
   }

package/src/tools/file.mjs

@@ -6,6 +6,7 @@ import {
   autoSyntaxCheck,
   resolveInCwd,
   resolveExternal,
+  normalizeEOL,
 } from "./shared.mjs";
 import { specForModel } from "../config.mjs";
 import { createHash } from "node:crypto";
@@ -39,7 +40,7 @@ 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)
@@ -153,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
@@ -195,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
@@ -208,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)
@@ -254,22 +260,24 @@ export const hashlineEditTool = {
   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 = await readFile(abs, "utf8")
+    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 the exact sequence of hashes
-    let pos = -1
+    // 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) { pos = i; break }
+      if (match) matches.push(i)
     }
 
-    if (pos === -1) {
+    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")
@@ -280,6 +288,26 @@ export const hashlineEditTool = {
       )
     }
 
+    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)

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/repomap.mjs

@@ -1,11 +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 { existsSync } from "node:fs"
-import { readFile } from "node:fs/promises"
+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) {
@@ -125,8 +126,11 @@ async function _buildDepGraph(db, cwd) {
     const rel = allFiles[i]
     const abs = join(cwd, ...rel.split("/"))
     if (!existsSync(abs)) continue
+    // 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 = await readFile(abs, "utf8") } catch { continue }
+    try { text = normalizeEOL(await readFile(abs, "utf8")) } catch { continue }
     const lines = text.split("\n")
     const ext = rel.slice(rel.lastIndexOf(".")).toLowerCase()
 

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

@@ -218,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`,

package/src/tui/cmd-advisor.mjs

@@ -56,11 +56,11 @@ async function openAdvisorModelPicker(ctx) {
           // Same as main — clear override (use main pool)
           delete cfg.provider
           delete cfg.model
-          pushLine(`Advisor: 使用主模型 (${agent.activeProvider}/${agent.provider.model})`)
+          pushLine(`Advisor: 使用主模型 (${agent.activeProvider}/${agent.provider.model})`, C.dim)
         } else {
           cfg.provider = e.provider
           cfg.model = e.model
-          pushLine(`Advisor: ${e.provider}/${e.model}`)
+          pushLine(`Advisor: ${e.provider}/${e.model}`, C.dim)
         }
       }
     },