thincoder 0.8.11 → 0.8.12

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/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

@@ -3,7 +3,8 @@
  * 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 } from "node:fs/promises"
 import { join } from "node:path"
 
 /** Extract JS/TS file import paths (normalize by stripping .ts/.js/.mjs suffixes) */
@@ -113,17 +114,19 @@ 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")
+    let text
+    try { text = await readFile(abs, "utf8") } catch { continue }
     const lines = text.split("\n")
     const ext = rel.slice(rel.lastIndexOf(".")).toLowerCase()
 
@@ -160,6 +163,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 +178,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 +253,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 +303,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/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}`) }
       }
     })(),
   }

package/src/tui/ansi.mjs

@@ -33,4 +33,5 @@ export const C = {
   error: ansi.fg(1),
   dim: ansi.gray,
   warn: ansi.fg(3),
+  advisor: `${ESC}[92m`,  // bright green — visible on dark backgrounds
 }

package/src/tui/cmd-advisor.mjs

@@ -0,0 +1,68 @@
+/** /advisor command: toggle advisor on/off, select model.
+ *  ctx: { agent, openPicker, pushLine } */
+import { C } from "./ansi.mjs"
+
+export async function handleAdvisorCommand(ctx) {
+  const { agent, openPicker, pushLine } = ctx
+  const cfg = agent.config.advisor ??= {}
+  const enabled = cfg.enabled === true
+  const curProvider = cfg.provider || agent.activeProvider
+  const curModel = cfg.model || agent.provider.model
+
+  const entries = [
+    { type: "item", text: `Advisor: ${enabled ? "ON" : "OFF"}`, action: "toggle" },
+    { type: "item", text: `Model: ${curProvider}/${curModel}`, action: "model" },
+  ]
+
+  openPicker({
+    title: "Advisor",
+    entries,
+    onSelect: async (e) => {
+      if (e.action === "toggle") {
+        cfg.enabled = !cfg.enabled
+        agent._pendingReminders = agent._pendingReminders ?? []
+        if (cfg.enabled) {
+          agent._pendingReminders.push("[系统提醒: Advisor 审查已开启。每轮操作后，你的输出将被审查，观察结果可能作为系统提醒注入。请批判性参考——这是观察，不是命令。]")
+        } else {
+          agent._pendingReminders.push("[系统提醒: Advisor 审查已关闭。后续轮次不再自动审查。]")
+        }
+      } else if (e.action === "model") {
+        await openAdvisorModelPicker(ctx).catch(err => pushLine(`[error] ${err.message}`, C.error))
+      }
+    },
+  })
+}
+
+async function openAdvisorModelPicker(ctx) {
+  const { agent, openPicker, pushLine } = ctx
+  const providers = agent.providers || []
+
+  // Build flat list: each provider's name + a "use current model" entry
+  const entries = []
+  let idx = 0
+  for (const p of providers) {
+    const mark = p.name === agent.activeProvider ? "* " : "  "
+    entries.push({ type: "item", text: `${mark}${p.name} — ${p.baseURL}`, action: "set_provider", provider: p.name, model: p.model })
+    idx++
+  }
+
+  openPicker({
+    title: "Advisor Model",
+    entries,
+    onSelect: async (e) => {
+      if (e.action === "set_provider") {
+        const cfg = agent.config.advisor ??= {}
+        if (e.provider === agent.activeProvider && e.model === agent.provider.model) {
+          // Same as main — clear override (use main pool)
+          delete cfg.provider
+          delete cfg.model
+          pushLine(`Advisor: 使用主模型 (${agent.activeProvider}/${agent.provider.model})`)
+        } else {
+          cfg.provider = e.provider
+          cfg.model = e.model
+          pushLine(`Advisor: ${e.provider}/${e.model}`)
+        }
+      }
+    },
+  })
+}

package/src/tui/cmd-think.mjs

@@ -4,20 +4,26 @@
 export async function handleThinkCommand(ctx) {
   const { agent, openPicker, syncProviderField } = ctx
   const cur = agent.provider
-  const thinkingEnabled = cur.thinking?.type === "enabled" || cur.thinking?.type === undefined
   const { specForModel } = await import("../config.mjs")
   const spec = specForModel(cur.model)
   const isEffortOnly = spec.thinkApi === "effort"
+  const thinkOnValue = spec.thinkOnValue ?? "enabled"
+  const isCustomThink = thinkOnValue !== "enabled"
+  // "enabled" when thinking.type matches the model's enabled value, or when thinking is absent and the model is NOT a custom-think model (defaults to on for standard models)
+  const thinkingEnabled = cur.thinking?.type === thinkOnValue || (cur.thinking?.type === undefined && !isCustomThink)
   const entries = []
+  // Auto-think: classify difficulty per-prompt and auto-set reasoning effort
+  const autoThinkEnabled = agent.config?.agent?.autoThink === true
+  entries.push({ type: "item", text: `Auto: ${autoThinkEnabled ? "ON" : "OFF"}`, action: "auto" })
   if (!isEffortOnly) {
-    entries.push({ type: "item", text: `Thinking: ${thinkingEnabled ? "ON" : "OFF"}`, action: thinkingEnabled ? "off" : "on" })
+    if (!autoThinkEnabled) entries.push({ type: "item", text: `Thinking: ${thinkingEnabled ? "ON" : "OFF"}`, action: thinkingEnabled ? "off" : "on" })
   }
-  if (spec.reasoningEffortEnum) {
+  if (spec.reasoningEffortEnum && !autoThinkEnabled) {
     for (const level of spec.reasoningEffortEnum) {
       const mark = cur.reasoningEffort === level ? "▸ " : "  "
       entries.push({ type: "item", text: `${mark}effort: ${level}`, action: "effort", level })
     }
-  } else {
+  } else if (!autoThinkEnabled) {
     entries.push({ type: "item", text: "effort: high", action: "effort", level: "high" })
     entries.push({ type: "item", text: "effort: max", action: "effort", level: "max" })
   }
@@ -25,7 +31,19 @@ export async function handleThinkCommand(ctx) {
     title: "Think",
     entries,
     onSelect: async (e) => {
-      if (e.action === "effort") {
+      if (e.action === "auto") {
+        const cfg = agent.config.agent ??= {}
+        cfg.autoThink = !cfg.autoThink
+        agent._pendingReminders = agent._pendingReminders ?? []
+        if (cfg.autoThink) {
+          // Turn off manual effort — auto will set it per-turn
+          delete cur.reasoningEffort
+          await syncProviderField("reasoningEffort", undefined)
+          agent._pendingReminders.push("[System reminder: Auto-think is now ON. Reasoning effort will be automatically set per-task based on difficulty classification.]")
+        } else {
+          agent._pendingReminders.push("[System reminder: Auto-think is now OFF. Reasoning effort will remain at its current manual setting.]")
+        }
+      } else if (e.action === "effort") {
         cur.reasoningEffort = e.level
         await syncProviderField("reasoningEffort", e.level)
       } else {
@@ -36,12 +54,20 @@ export async function handleThinkCommand(ctx) {
           if (!enable) await syncProviderField("reasoningEffort", undefined)
           else await syncProviderField("reasoningEffort", cur.reasoningEffort)
         } else {
-          cur.thinking = enable ? { type: "enabled" } : { type: "disabled" }
-          if (!enable) delete cur.reasoningEffort
-          else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+          if (enable) {
+            cur.thinking = { type: thinkOnValue }
+            if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+          } else {
+            // Custom-think models (MiniMax "adaptive") don't support "disabled" — remove the field instead
+            cur.thinking = isCustomThink ? undefined : { type: "disabled" }
+            delete cur.reasoningEffort
+          }
           await syncProviderField("thinking", cur.thinking)
-          if (!enable) await syncProviderField("reasoningEffort", undefined)
-          else await syncProviderField("reasoningEffort", cur.reasoningEffort)
+          if (enable) {
+            await syncProviderField("reasoningEffort", cur.reasoningEffort)
+          } else {
+            await syncProviderField("reasoningEffort", undefined)
+          }
         }
       }
     },

package/src/tui/index.mjs

@@ -63,7 +63,7 @@ export async function startTUI(agent, opts = {}) {
     picker: null, // model picker { entries, lines, index, scroll, selectedLine }
     wizard: null, // first-launch config wizard { step, index, scroll, selectedLine, fields, error, lines }
     tasks: agent.tasks ?? [], // task list from task tool (progress shown in status bar); carried over on session restore, auto-collapsed when all done
-    tokens: { prompt: 0, completion: 0, cacheHit: 0, cacheMiss: 0 }, // cumulative token usage (shown in status bar)
+    tokens: { prompt: 0, completion: 0, cacheHit: 0, cacheMiss: 0, reasoningTokens: 0 }, // cumulative token usage (shown in status bar)
     ctxCache: { len: -1, tokens: 0 }, // context utilization estimate cache (estimateTokens is O(n), only recompute when history grows)
     reasoning: "", // thinking stream buffer (dimmed display)
     completion: null, // Tab completion state { candidates, index }
@@ -74,6 +74,7 @@ export async function startTUI(agent, opts = {}) {
     processingStarted: 0, // current turn start time (status bar timer)
     status: "Ready",
     queue: [], // queued messages while processing: [{ text }], auto-dequeued when current turn finishes
+    interruptPrompt: null, // Ctrl+I interrupt message input: { text: "" } or null
   }
 
   // On session restore, if all tasks are completed, auto-collapse the todo panel (match runtime behavior)

package/src/tui/key-handler.mjs

@@ -91,7 +91,10 @@ export function createKeyHandler(ctx) {
               insertPastedText(state, text)
               render()
             }
-          }).catch(() => { q._pasting = false })
+          }).catch((e) => {
+            q._pasting = false
+            console.error(`[tui] clipboard paste failed: ${e.message}`)
+          })
         } else if (str && !key.ctrl && !key.meta) {
           q.answer = (q.answer ?? "") + str
           render()
@@ -111,6 +114,38 @@ export function createKeyHandler(ctx) {
       setTimeout(() => process.exit(0), 100)
     }
 
+    // Ctrl+I: interrupt current generation and inject a message (time-travel inject)
+    if (key.ctrl && !key.alt && key.name === "i") {
+      if (state.processing && state.controller && !state.interruptPrompt) {
+        state.interruptPrompt = { text: "" }
+        render()
+      }
+      return
+    }
+
+    // Interrupt prompt mode: type message, Enter to inject, Esc to cancel
+    if (state.interruptPrompt) {
+      if (key.name === "escape") {
+        state.interruptPrompt = null
+        render()
+      } else if (key.name === "return") {
+        const msg = (state.interruptPrompt.text ?? "").trim()
+        state.interruptPrompt = null
+        if (msg) {
+          pushLine(`  [inject] ${msg}`, C.warn)
+          state.controller.abort({ interrupt: true, message: msg })
+          render()
+        }
+      } else if (key.name === "backspace") {
+        state.interruptPrompt.text = state.interruptPrompt.text.slice(0, -1)
+        render()
+      } else if (str && !key.ctrl && !key.meta) {
+        state.interruptPrompt.text += str.replace(/[\r\n]+/g, "")
+        render()
+      }
+      return
+    }
+
     // generic list picker: ↑↓ move, Enter confirm, Esc cancel
     if (state.picker) {
       const items = state.picker?.entries.filter((e) => e.type === "item") ?? []

package/src/tui/layout.mjs

@@ -22,7 +22,9 @@ export function computeLayout(state, { cols, rows }) {
   const W = Math.max(20, cols - 1)
 
   // --- input box ---
-  const inputLayout = layoutInput(state.input, state.cursor, W - 4)
+  const inputBuf = state.interruptPrompt ? [...state.interruptPrompt.text] : state.input
+  const inputCursor = state.interruptPrompt ? inputBuf.length : state.cursor
+  const inputLayout = layoutInput(inputBuf, inputCursor, W - 4)
   let inputOffset = 0
   if (inputLayout.lines.length > MAX_INPUT_LINES) {
     inputOffset = Math.min(inputLayout.cursorLine, inputLayout.lines.length - MAX_INPUT_LINES)

package/src/tui/pickers.mjs

@@ -185,27 +185,27 @@ export function createPickers(ctx) {
     openPicker({
       title: "Add Provider",
       entries: presetEntries,
-      onCancel: () => openModelPicker().catch(() => {}),
+      onCancel: () => openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)),
       onSelect: async (se) => {
         if (se.kind === "custom") {
           const name = await askQuestion("Enter provider name:")
-          if (!name) { openModelPicker().catch(() => {}); return }
-          if (agent.providers.some((p) => p.name === name)) { openModelPicker().catch(() => {}); return }
+          if (!name) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
+          if (agent.providers.some((p) => p.name === name)) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           const baseURLRaw = await askQuestion("Enter baseURL (e.g. https://api.example.com/v1):")
-          if (!baseURLRaw) { openModelPicker().catch(() => {}); return }
+          if (!baseURLRaw) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           const baseURL = baseURLRaw.replace(/\/+$/, "")
-          if (!/^https?:\/\//.test(baseURL)) { openModelPicker().catch(() => {}); return }
+          if (!/^https?:\/\//.test(baseURL)) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           const model = await askQuestion("Enter model name:")
-          if (!model) { openModelPicker().catch(() => {}); return }
+          if (!model) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           agent.providers.push({ name, baseURL, model })
           await persistRaw((raw) => { raw.providers = agent.providers })
           const key = await askQuestion(`Enter API key for ${name} (leave empty to skip):`)
           if (key) { await setProviderKey(name, key) }
-          openModelPicker().catch(() => {})
+          openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
           return
         }
         // preset
-        if (agent.providers.some((p) => p.name === se.name)) { openModelPicker().catch(() => {}); return }
+        if (agent.providers.some((p) => p.name === se.name)) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
         const preset = PRESETS[se.name]
         const providerCfg = { name: se.name, baseURL: preset.baseURL, model: preset.model }
         if (preset.thinking) providerCfg.thinking = preset.thinking
@@ -217,7 +217,7 @@ export function createPickers(ctx) {
         await persistRaw((raw) => { raw.providers = agent.providers })
         const presetKey = await askQuestion(`Enter API key for ${se.name} (leave empty to skip):`)
         if (presetKey) await setProviderKey(se.name, presetKey)
-        openModelPicker().catch(() => {})
+        openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
       },
     })
   }
@@ -225,7 +225,7 @@ export function createPickers(ctx) {
   /** Remove provider (cannot remove the currently active one) */
   async function removeProviderFlow() {
     const candidates = agent.providers.filter((p) => p.name !== agent.activeProvider)
-    if (candidates.length === 0) { openModelPicker().catch(() => {}); return }
+    if (candidates.length === 0) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
     const removeEntries = [
       { type: "header", text: "Select provider to remove (current one cannot be removed)" },
       ...candidates.map((p) => ({ type: "item", text: `${p.name} (${p.model})`, name: p.name })),
@@ -233,12 +233,12 @@ export function createPickers(ctx) {
     openPicker({
       title: "Remove Provider",
       entries: removeEntries,
-      onCancel: () => openModelPicker().catch(() => {}),
+      onCancel: () => openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)),
       onSelect: async (se) => {
         const at = agent.providers.findIndex((p) => p.name === se.name)
         agent.providers.splice(at, 1)
         await persistRaw((raw) => { raw.providers = agent.providers })
-        openModelPicker().catch(() => {})
+        openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
       },
     })
   }
@@ -256,12 +256,12 @@ export function createPickers(ctx) {
     openPicker({
       title: "Configure API Key",
       entries: keyEntries,
-      onCancel: () => openModelPicker().catch(() => {}),
+      onCancel: () => openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)),
       onSelect: async (se) => {
         const key = await askQuestion(`Enter API key for ${se.name}:`)
-        if (!key) { openModelPicker().catch(() => {}); return }
+        if (!key) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
         await setProviderKey(se.name, key)
-        openModelPicker().catch(() => {})
+        openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
       },
     })
   }