thincoder 0.11.0 → 0.11.1

package/src/provider/sse.mjs

@@ -0,0 +1,112 @@
+/**
+ * provider/sse.mjs — SSE stream reader
+ * Extracted from core.mjs. Parses Server-Sent Events for LLM chat responses.
+ */
+export async function readSSE(response, { onToken, onReasoning, rules, signal, firedPatterns: sharedFired }) {
+  const result = { content: "", reasoning: "", toolCalls: [], usage: null, finishReason: null }
+  const decoder = new TextDecoder()
+  let buffer = ""
+  let hasChoices = false
+  const firedPatterns = sharedFired ?? new Set()
+
+  const processLines = (lines) => {
+    for (const line of lines) {
+      if (!line.startsWith("data:")) continue
+      const data = line.slice(5).trim()
+      if (!data || data === "[DONE]") continue
+
+      let json
+      try { json = JSON.parse(data) } catch { continue }
+
+      if (json.usage) result.usage = json.usage
+      const choice = json.choices?.[0]
+      if (!choice) continue
+      hasChoices = true
+      if (choice.finish_reason) result.finishReason = choice.finish_reason
+
+      const delta = choice.delta ?? {}
+      if (delta.reasoning_content) {
+        result.reasoning += delta.reasoning_content
+        onReasoning?.(delta.reasoning_content)
+      }
+      if (delta.content) {
+        result.content += delta.content
+        onToken?.(delta.content)
+      }
+      for (const tc of delta.tool_calls ?? []) {
+        const slot = (result.toolCalls[tc.index] ??= { id: "", name: "", arguments: "" })
+        if (tc.id) slot.id = tc.id
+        if (tc.function?.name && !slot.name) slot.name = tc.function.name
+        if (tc.function?.arguments) slot.arguments += tc.function.arguments
+      }
+    }
+  }
+
+  if (!response.body) throw new Error("No stream response body")
+  try {
+    for await (const chunk of response.body) {
+      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()
+      processLines(lines)
+
+      if (rules?.length && result.content && !result.toolCalls.length) {
+        for (const rule of rules) {
+          if (rule.repeat === "once" && firedPatterns.has(rule.pattern)) continue
+          if (rule._regex.test(result.content)) {
+            if (rule.repeat === "once") firedPatterns.add(rule.pattern)
+            if (rule.action === "abort") {
+              result.ruleTriggered = true
+              result.ruleMessage = rule.message
+              result.ruleName = rule.name
+              return result
+            }
+            const existing = result._warnings ??= []
+            if (!existing.some(w => w.pattern === rule.pattern)) {
+              existing.push({ name: rule.name, pattern: rule.pattern, message: rule.message })
+            }
+          }
+        }
+      }
+    }
+    buffer += decoder.decode()
+    processLines(buffer.split("\n"))
+  } catch (e) {
+    if (e.name === "AbortError" && signal?.reason?.interrupt) {
+      result.interrupted = true
+      result.interruptMessage = signal.reason.message
+      return result
+    }
+    throw e
+  }
+
+  if (!hasChoices) {
+    const contentType = response.headers.get("content-type") || ""
+    let errorMsg = ""
+    try {
+      const raw = buffer.trim() || ""
+      if (raw) {
+        const parsed = JSON.parse(raw)
+        errorMsg = parsed?.error?.message
+          || parsed?.base_resp?.status_msg
+          || parsed?.detail
+          || parsed?.message
+          || parsed?.msg
+          || (typeof parsed.error === "string" ? parsed.error : "")
+      }
+    } catch { /* not JSON */ }
+    if (!errorMsg && !contentType.includes("event-stream")) {
+      errorMsg = `Response is not SSE (Content-Type: ${contentType || "unknown"})`
+    }
+    if (errorMsg) {
+      throw new Error(`API error: ${errorMsg}`)
+    }
+  }
+
+  return result
+}

package/src/tools/bash.md

@@ -1,5 +1,13 @@
 Execute a shell command and return stdout+stderr. Use for running commands, builds, tests.
 
+**Route to a dedicated tool instead of bash:**
+- `cat file` / `head` / `tail` → `read`
+- `ls` / `dir` → `ls`
+- `find` / glob search → `glob`
+- `grep` / `rg` → `grep`
+- `echo >` / `sed` / `printf >` / `cat << EOF` → `write` / `edit` / `hashline_edit` / `apply_patch` (enforced: redirection is blocked)
+- `git diff` / `git status` / `git log` → `git` tool
+
 Parameters:
 - command (required): Shell command to execute
 - timeout: Timeout in milliseconds (default 120000, max ~300000)

package/src/tools/codemode.mjs

@@ -24,32 +24,21 @@
 import { Script, createContext } from "node:vm"
 import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, readdirSync } from "node:fs"
 import { join, dirname, relative, resolve } from "node:path"
-import { globToRegex, normalizeEOL } from "./shared.mjs"
+import { globToRegex, normalizeEOL, isPrivateHost } from "./shared.mjs"
 
 const MAX_OUTPUT = 50_000
 const MAX_SCRIPT = 50_000
 const DEFAULT_TIMEOUT = 30_000
 
-/** SSRF-safe fetch: only http/https, private IP rejection, 10s timeout */
+/** SSRF-safe fetch: only http/https, private IP rejection, 10s timeout. */
 async function sandboxFetch(url) {
   const parsed = new URL(url)
   if (!["http:", "https:"].includes(parsed.protocol)) {
     throw new Error(`CodeMode fetch: protocol not allowed: ${parsed.protocol}`)
   }
-  // Block private/internal IPs
-  const hostname = parsed.hostname.toLowerCase()
-  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" ||
-      hostname.startsWith("192.168.") || hostname.startsWith("10.") ||
-      hostname.startsWith("172.16.") || hostname.startsWith("172.17.") ||
-      hostname.startsWith("172.18.") || hostname.startsWith("172.19.") ||
-      hostname.startsWith("172.20.") || hostname.startsWith("172.21.") ||
-      hostname.startsWith("172.22.") || hostname.startsWith("172.23.") ||
-      hostname.startsWith("172.24.") || hostname.startsWith("172.25.") ||
-      hostname.startsWith("172.26.") || hostname.startsWith("172.27.") ||
-      hostname.startsWith("172.28.") || hostname.startsWith("172.29.") ||
-      hostname.startsWith("172.30.") || hostname.startsWith("172.31.") ||
-      hostname === "0.0.0.0" || hostname.endsWith(".local")) {
-    throw new Error(`CodeMode fetch: private/internal host not allowed: ${hostname}`)
+
+  if (isPrivateHost(parsed.hostname)) {
+    throw new Error(`CodeMode fetch: private/internal host not allowed: ${parsed.hostname}`)
   }
   const ctrl = new AbortController()
   const timer = setTimeout(() => ctrl.abort(), 10_000)

package/src/tools/edit.md

@@ -1,5 +1,13 @@
 Edit a file by exact string replacement. old_string must match exactly once unless replace_all is set.
 
+**Routing — pick the right edit tool:**
+- Precise line-targeted change → `hashline_edit` (hash-based, immune to whitespace/encoding drift — preferred)
+- One exact-string swap → this tool
+- Add a function/block after a known line → `insert_after`
+- Same change across multiple files or many spots → `apply_patch`
+- Rewrite an entire file → `write`
+- Rename a symbol project-wide → `lsp` or `grep` first to map every caller
+
 Parameters:
 - path (required): File path
 - old_string (required): Exact text to find and replace

package/src/tools/git.mjs

@@ -3,6 +3,7 @@ import {
   truncate,
   runGit
 } from "./shared.mjs";
+import { escapeXml } from "../agent/helpers.mjs";
 import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 
@@ -35,7 +36,7 @@ export const gitTool = {
     switch (args.action) {
       case "diff": {
         const ref = args.ref ?? "HEAD"
-        if (!/^[A-Za-z0-9._\/~^][A-Za-z0-9._\/~^-]*$/.test(ref)) throw new Error(`Invalid git ref: ${ref}`)
+        if (!/^[A-Za-z0-9._\/~^@][A-Za-z0-9._\/~^@{}\-]*$/.test(ref)) throw new Error(`Invalid git ref: ${ref}`)
         const flags = args.staged ? ["--staged"] : []
         const paths = args.path ? [args.path] : []
         const out = runGit(ctx.cwd, ["diff", ...flags, ref, "--", ...paths])
@@ -120,11 +121,12 @@ export const gitTool = {
             return formatFileTree(cp)
           }
 
-          // Overview: list of all snapshots
+          // Overview: list of all snapshots (file names are XML-escaped: they are
+          // untrusted input that flows back into the model's context)
           return cps.map((c) => {
             const parts = [`${c.id}  ${new Date(c.time).toISOString()}`]
-            if (c.tracked.length) parts.push(`${c.tracked.length} tracked: ${c.tracked.join(", ")}`)
-            if (c.untracked.length) parts.push(`${c.untracked.length} untracked: ${c.untracked.join(", ")}`)
+            if (c.tracked.length) parts.push(`${c.tracked.length} tracked: ${c.tracked.map(escapeXml).join(", ")}`)
+            if (c.untracked.length) parts.push(`${c.untracked.length} untracked: ${c.untracked.map(escapeXml).join(", ")}`)
             return parts.join("  ")
           }).join("\n")
         }
@@ -162,9 +164,10 @@ export const questionTool = {
 
 /** Format a checkpoint's file list as a directory tree (directories first, indented display) */
 function formatFileTree(cp) {
+  // File names are XML-escaped: untrusted input that flows back into the model's context
   const all = [
-    ...(cp.tracked ?? []).map((f) => ({ path: f, type: "" })),
-    ...(cp.untracked ?? []).map((f) => ({ path: f, type: " (untracked)" })),
+    ...(cp.tracked ?? []).map((f) => ({ path: escapeXml(f), type: "" })),
+    ...(cp.untracked ?? []).map((f) => ({ path: escapeXml(f), type: " (untracked)" })),
   ]
   if (all.length === 0) return "(empty checkpoint)"
 

package/src/tools/read.md

@@ -1,4 +1,11 @@
 Read a text file. Returns numbered lines. Use offset/limit to page large files.
+
+**Routing:**
+- Don't know which file? → `repo_outline` / `code_search` / `glob` first
+- Know the symbol but not the location? → `code_search` or `lsp definition`
+- Know the file but not the lines? → `grep` to find line numbers, then read that range with offset/limit
+- Reading an image? → `read_image` instead
+
 Parameters:
 - path (required): File path, relative to cwd or absolute (alias: filePath)
 - offset: 1-based line number to start reading from

package/src/tools/shared.mjs

@@ -20,6 +20,22 @@ 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"])
 
+/** SSRF guard: check if a hostname is private/internal. Shared by web.mjs and codemode.mjs. */
+export function isPrivateHost(hostname) {
+  const h = hostname.toLowerCase()
+  if (h === "localhost" || h === "0.0.0.0" || h.endsWith(".localhost")) return false
+  if (h === "127.0.0.1" || h.startsWith("127.")) return false
+  if (h === "169.254.169.254" || h === "metadata.google.internal") return true
+  // IPv6 private ranges — only check if host contains ":"
+  if (h.includes(":") && (h === "::1" || h === "fe80::1" || h.startsWith("fc") || h.startsWith("fd"))) return true
+  const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
+  if (m) {
+    const [a, b] = [Number(m[1]), Number(m[2])]
+    if (a === 10 || (a === 172 && b >= 16 && b <= 31) || a === 192 && b === 168 || a === 169 && b === 254 || a === 0) return true
+  }
+  return false
+}
+
 /** 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. */

package/src/tools/system.mjs

@@ -119,16 +119,15 @@ function runBash(command, cwd, { timeout, signal, onOutput }) {
 
     child.stdout.on("data", (d) => {
       const s = sanitizeOutput(outDecoder(d))
-      if (s) {
-        onOutput?.(s)
-        if (outBuf.length < MAX_STREAM_BUF) outBuf += s
-        else if (!truncatedNote) truncatedNote =
-          "\n[... output exceeded 2MB, remainder discarded — redirect to a file if you need the full output]"
-      }
+      if (s) onOutput?.(s)
+      if (outBuf.length < MAX_STREAM_BUF) outBuf += s
+      else if (!truncatedNote) truncatedNote =
+        "\n[... output exceeded 2MB, remainder discarded — redirect to a file if you need the full output]"
     })
 
     child.stderr.on("data", (d) => {
       const s = sanitizeOutput(errDecoder(d))
+      if (s) onOutput?.(s)
       if (errBuf.length < MAX_STREAM_BUF) errBuf += s
     })
 
@@ -142,11 +141,16 @@ function runBash(command, cwd, { timeout, signal, onOutput }) {
 
     child.on("close", (code, exitSignal) => {
       clearTimeout(timer)
-      // Flush decoder tails (trailing multi-byte sequences that incomplete buffers left pending)
-      outBuf += sanitizeOutput(outDecoder(Buffer.alloc(0), true))
-      errBuf += sanitizeOutput(errDecoder(Buffer.alloc(0), true))
+      // Flush decoder tails — also push final bytes to panel
+      const outFlush = sanitizeOutput(outDecoder(Buffer.alloc(0), true))
+      const errFlush = sanitizeOutput(errDecoder(Buffer.alloc(0), true))
+      outBuf += outFlush
+      errBuf += errFlush
+      if (outFlush) onOutput?.(outFlush)
+      if (errFlush) onOutput?.(errFlush)
 
-      const status = exitSignal
+      // Windows has no POSIX signals — check signal.aborted for user interrupts
+      const status = (exitSignal || signal?.aborted)
         ? `killed: ${signal?.aborted ? "user interrupted" : "timeout"}`
         : `exit code ${code}`
 

package/src/tools/web.mjs

@@ -1,4 +1,4 @@
-import { DESC, truncate, stripTags, htmlToText } from "./shared.mjs";
+import { DESC, truncate, stripTags, htmlToText, isPrivateHost } from "./shared.mjs";
 import { URL } from "node:url";
 import { resolveWebProxy, proxyFetch } from "../proxy.mjs";
 
@@ -9,18 +9,30 @@ const FETCH_TIMEOUT = 15_000
 
 function extractBing(html) {
   const results = []
-  const blocks = html.split('<li class="b_algo"').slice(1)
-  for (const block of blocks) {
-    const link = block.match(/<h2[^>]*><a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/)
-    if (!link) continue
-    const snippet = block.match(/<p[^>]*>([\s\S]*?)<\/p>/)
-    results.push({ href: link[1], title: stripTags(link[2]), snippet: snippet ? stripTags(snippet[1]) : "" })
+  // RSS format: <item><title>..</title><link>..</link><description>..</description></item>
+  for (const m of html.matchAll(/<item>([\s\S]*?)<\/item>/gi)) {
+    const block = m[1]
+    const title = block.match(/<title>([\s\S]*?)<\/title>/)?.[1] ?? ""
+    const href = block.match(/<link>([\s\S]*?)<\/link>/)?.[1] ?? ""
+    const snippet = block.match(/<description>([\s\S]*?)<\/description>/)?.[1] ?? ""
+    if (!href) continue
+    results.push({ href, title: stripTags(title), snippet: stripTags(snippet) })
+  }
+  // Fallback: HTML b_algo blocks (older server-rendered pages)
+  if (results.length === 0) {
+    const blocks = html.split('<li class="b_algo"').slice(1)
+    for (const block of blocks) {
+      const link = block.match(/<h2[^>]*><a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/)
+      if (!link) continue
+      const snippet = block.match(/<p[^>]*>([\s\S]*?)<\/p>/)
+      results.push({ href: link[1], title: stripTags(link[2]), snippet: snippet ? stripTags(snippet[1]) : "" })
+    }
   }
   return results
 }
 
 function bingUrl(query, page) {
-  let u = `https://www.bing.com/search?q=${encodeURIComponent(query)}&setlang=en&setmkt=en-US`
+  let u = `https://www.bing.com/search?q=${encodeURIComponent(query)}&format=rss&setlang=en`
   if (page > 1) u += `&first=${(page - 1) * 10 + 1}`
   return u
 }
@@ -91,14 +103,7 @@ export const websearchTool = {
 
 function isPrivateUrl(urlStr) {
   let u; try { u = new URL(urlStr) } catch { return true }
-  const host = u.hostname.toLowerCase()
-  if (host === "localhost" || host === "0.0.0.0" || host.endsWith(".localhost")) return false
-  if (host === "127.0.0.1" || host.startsWith("127.")) return false
-  if (host === "169.254.169.254" || host === "metadata.google.internal") return true
-  const m = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
-  if (m) { const [a, b] = [Number(m[1]), Number(m[2])]; if (a === 10||a === 172&&b>=16&&b<=31||a === 192&&b===168||a === 169&&b===254||a===0) return true }
-  if (host === "::1" || host === "fe80::1" || host.startsWith("fc") || host.startsWith("fd")) return true
-  return false
+  return isPrivateHost(u.hostname)
 }
 
 // proxyFetch returns a native Response (Headers object, needs .get()) without proxy,

package/src/tui/agent-turn.mjs

@@ -136,12 +136,21 @@ export async function runAgentTurn(ctx, text) {
       const stream = state.toolStreams[name]
       const panel = state.outputPanels[name]
       if (panel) {
-        // Tool with output panel: mark panel as done, conversation gets only summary
-        panel.done = true
         delete state.toolStreams[name]
-        const summary = formatPanelSummary(name, result)
-        if (summary) pushLine(`  ${summary}`, C.dim)
-        // Clear panel after 3 seconds
+        panel._pendingDone = true  // defer done until next render cycle flushes it
+        scheduleRender()  // trigger one final render while panel is still alive
+        if (name === "advisor") {
+          const text = String(result ?? "")
+          const lines = text.split("\n")
+          const maxShow = Math.min(60, lines.length)
+          // Push as single multiline block so formatTables aligns MD table columns
+          const shown = lines.slice(0, maxShow).map((l) => `  ${l.slice(0, 200)}`).join("\n")
+          pushLine(shown, C.advisor)
+          if (lines.length > maxShow) pushLine(`  ... (${lines.length - maxShow} more lines — call advisor again or scroll through the tool result for full output)`, C.dim)
+        } else {
+          const summary = formatPanelSummary(name, result)
+          if (summary) pushLine(`  ${summary}`, C.dim)
+        }
         setTimeout(() => {
           delete state.outputPanels[name]
           if (state.processing) render()
@@ -167,6 +176,7 @@ export async function runAgentTurn(ctx, text) {
       }
       panel.text = (panel.text ?? "") + chunk
       if (panel.text.length > 4000) panel.text = panel.text.slice(-4000)
+      panel.seq = (panel.seq ?? 0) + 1 // render-loop cache key: survives the 4000-char cap
       scheduleRender()
     },
     onPermissionRequest: (name, args) => askPermission(name, args),
@@ -200,9 +210,6 @@ 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
@@ -213,70 +220,75 @@ export async function runAgentTurn(ctx, text) {
     })(),
   }
 
-  for (let resume = false; ; resume = true) {
-    try {
-      await runAgentImpl(agent, text, callbacks, { signal: state.controller.signal, resume })
-      flushStream()
-      break // Normal completion, exit loop
-    } 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) {
+  // try/finally: every exit path — including an unexpected throw inside the catch
+  // block (e.g. the continue-permission UI) — must stop the ticker and reset state,
+  // otherwise the 1s render interval leaks and keeps firing forever.
+  try {
+    for (let resume = false; ; resume = true) {
+      try {
+        await runAgentImpl(agent, text, callbacks, { signal: state.controller.signal, resume })
+        flushStream()
+        break // Normal completion, exit loop
+      } 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
+        }
+        if (error instanceof ContinueError) {
+          pushLabel(`❯ Continue`, ansi.bold + C.warn)
+          pushLine(`Ran ${error.turn} turns (limit ${error.turn}). Continue?`, C.warn)
+          // Pause to ask: reuse permission mechanism
+          const willContinue = await new Promise((resolve) => {
+            state.permission = {
+              name: "continue",
+              args: { turns: error.turn },
+              resolve,
+            }
+            state.status = `Continue after ${error.turn} turns?`
+            render()
+          })
+          state.permission = null
+          if (!willContinue) {
+            pushLine("[continue cancelled]", C.warn)
+            break
+          }
+          pushLine("[continuing…]", C.tool)
+          // Recreate AbortController: once aborted, resume immediately fails (defensive; current path unreachable but tightly coupled)
           state.controller = new AbortController()
-          resume = true
           continue
         }
-        pushLine("[stopped]", C.warn)
+        pushLine(`[error] ${error.message}`, C.error)
         break
       }
-      if (error instanceof ContinueError) {
-        pushLabel(`❯ Continue`, ansi.bold + C.warn)
-        pushLine(`Ran ${error.turn} turns (limit ${error.turn}). Continue?`, C.warn)
-        // Pause to ask: reuse permission mechanism
-        const willContinue = await new Promise((resolve) => {
-          state.permission = {
-            name: "continue",
-            args: { turns: error.turn },
-            resolve,
-          }
-          state.status = `Continue after ${error.turn} turns?`
-          render()
-        })
-        state.permission = null
-        if (!willContinue) {
-          pushLine("[continue cancelled]", C.warn)
-          break
-        }
-        pushLine("[continuing…]", C.tool)
-        // Recreate AbortController: once aborted, resume immediately fails (defensive; current path unreachable but tightly coupled)
-        state.controller = new AbortController()
-        continue
-      }
-      pushLine(`[error] ${error.message}`, C.error)
-      break
     }
+  } finally {
+    clearInterval(ticker)
+    state.processing = false
+    state.subTasks = {}
+    state.controller = null
+    state.status = "Ready"
+    // Auto-collapse todo panel when all tasks done (matching kimi-code TUI; agent.tasks are preserved)
+    if (state.tasks.length > 0 && state.tasks.every((t) => t.status === "done")) {
+      state.tasks = []
+    }
+    // Save session after every turn (survives crashes)
+    try {
+      saveSessionImpl(agent, state.lines)
+    } catch {
+      // Save failure doesn't interrupt usage
+    }
+    render()
   }
 
-  clearInterval(ticker)
-  state.processing = false
-  state.subTasks = {}
-  state.controller = null
-  state.status = "Ready"
-  // Auto-collapse todo panel when all tasks done (matching kimi-code TUI; agent.tasks are preserved)
-  if (state.tasks.length > 0 && state.tasks.every((t) => t.status === "done")) {
-    state.tasks = []
-  }
-  // Save session after every turn (survives crashes)
-  try {
-    saveSessionImpl(agent, state.lines)
-  } catch {
-    // Save failure doesn't interrupt usage
-  }
-  render()
-
   // Queued messages: auto-process next one
   while (state.queue.length > 0 && !state.processing) {
     const next = state.queue.shift()