thincoder 0.12.1 → 0.12.3

package/src/tools/file.mjs

@@ -122,6 +122,7 @@ export const writeTool = {
     required: ["path", "content"],
   },
   readonly: false,
+  touchedPaths(args) { return args.path ? [args.path] : [] },
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
     await mkdir(dirname(abs), { recursive: true })
@@ -149,6 +150,7 @@ export const editTool = {
     required: ["path", "old_string", "new_string"],
   },
   readonly: false,
+  touchedPaths(args) { return args.path ? [args.path] : [] },
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
     if (!args.old_string) {
@@ -194,6 +196,7 @@ export const insertAfterTool = {
     required: ["path", "content"],
   },
   readonly: false,
+  touchedPaths(args) { return args.path ? [args.path] : [] },
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
     const text = normalizeEOL(await readFile(abs, "utf8"))
@@ -257,6 +260,7 @@ export const hashlineEditTool = {
     required: ["path", "old_hashes", "new_content"],
   },
   readonly: false,
+  touchedPaths(args) { return args.path ? [args.path] : [] },
   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")

package/src/tools/git.md

@@ -0,0 +1,15 @@
+Run a git command. Use this to see uncommitted changes, staged changes, diff against a ref, recent commits, or manage checkpoints. Only works inside a git repository.
+- action='diff': Show unified diff — what changed since last commit. Set staged=true for staged-only diff, ref=<ref> to compare against a specific commit/branch, path=<dir> to scope to a file or directory.
+- action='status': Show working tree state — staged, unstaged, untracked files, and conflicts. Returns categorized lists.
+- action='log': Show recent commit history. Set count to limit, oneline=true for compact format, path=<file> to see history of one file.
+- action='checkpoint': Manage git-based snapshots. Use checkpointAction to choose: list (overview), create (snapshot now), rewind (restore snapshot by id), cat (read a file from a snapshot).
+
+Parameters:
+- action (required): diff / status / log / checkpoint
+- staged: (diff) Show staged changes instead of working tree
+- path: (diff/log/checkpoint:cat/checkpoint:rewind) File or directory to scope to
+- ref: (diff) Compare against this ref (default HEAD)
+- count: (log) Number of commits (default 10)
+- oneline: (log) One-line-per-commit format
+- checkpointAction: (checkpoint) list snapshots / create one / restore by id / read file from snapshot
+- checkpointId: (checkpoint) Snapshot id — required for rewind and cat; optional for list (shows file tree)

package/src/tools/git.mjs

@@ -9,12 +9,7 @@ import { join } from "node:path";
 
 export const gitTool = {
   name: "git",
-  description:
-    "Run a git command. Use this to see uncommitted changes, staged changes, diff against a ref, recent commits, or manage checkpoints. Only works inside a git repository.\n" +
-    "- action='diff': Show unified diff — what changed since last commit. Set staged=true for staged-only diff, ref=<ref> to compare against a specific commit/branch, path=<dir> to scope to a file or directory.\n" +
-    "- action='status': Show working tree state — staged, unstaged, untracked files, and conflicts. Returns categorized lists.\n" +
-    "- action='log': Show recent commit history. Set count to limit, oneline=true for compact format, path=<file> to see history of one file.\n" +
-    "- action='checkpoint': Manage git-based snapshots. Use checkpointAction to choose: list (overview), create (snapshot now), rewind (restore snapshot by id), cat (read a file from a snapshot).",
+  description: DESC("git"),
   parameters: {
     type: "object",
     properties: {

package/src/tools/lint.md

@@ -0,0 +1,8 @@
+Run the appropriate linter/checker for a file. Auto-detects based on file extension and project config.
+Without 'full', runs a fast node --check (JS/TS syntax only, catches parse errors in milliseconds).
+With 'full', runs the language-aware cascade: eslint → tsc –noEmit → node --check (JS/TS/TSX); ruff (Python); cargo check (Rust); go vet (Go).
+Use the fast default after every write/edit; use 'full' before declaring a task complete.
+
+Parameters:
+- path: File to check (default: most recently modified file)
+- full: Run the full language-aware cascade instead of just node --check (default false)

package/src/tools/linter.mjs

@@ -5,11 +5,7 @@ import { join, relative } from "node:path"
 
 export const lintTool = {
   name: "lint",
-  description:
-    "Run the appropriate linter/checker for a file. Auto-detects based on file extension and project config.\n" +
-    "Without 'full', runs a fast node --check (JS/TS syntax only, catches parse errors in milliseconds).\n" +
-    "With 'full', runs the language-aware cascade: eslint → tsc –noEmit → node --check (JS/TS/TSX); ruff (Python); cargo check (Rust); go vet (Go).\n" +
-    "Use the fast default after every write/edit; use 'full' before declaring a task complete.",
+  description: DESC("lint"),
   parameters: {
     type: "object",
     properties: {

package/src/tools/lsp.md

@@ -0,0 +1,7 @@
+LSP code intelligence: go to definition, find references, hover info, document symbols, diagnostics. Use this to understand code structure without grep-guessing function locations or type shapes.
+
+Parameters:
+- subcommand (required): LSP operation — "definition" | "references" | "hover" | "symbols" | "diagnostics"
+- uri (required): Target file path (relative to project root)
+- line: 1-based line number (for definition/references/hover)
+- character: 1-based character offset (for definition/references/hover)

package/src/tools/lsp.mjs

@@ -17,6 +17,7 @@
 import { spawn } from "node:child_process"
 import { existsSync, readFileSync } from "node:fs"
 import { join, extname } from "node:path"
+import { DESC } from "./shared.mjs"
 
 // ---- JSON-RPC transport over stdio ----
 
@@ -184,9 +185,7 @@ async function ensureOpen(proc, uri, ext) {
 
 export const lspTool = {
   name: "lsp",
-  description:
-    "LSP code intelligence: go to definition, find references, hover info, document symbols, diagnostics. " +
-    "Use this to understand code structure without grep-guessing function locations or type shapes.",
+  description: DESC("lsp"),
   parameters: {
     type: "object",
     properties: {
@@ -240,7 +239,7 @@ export const lspTool = {
             textDocument: { uri },
             position: { line: args.line - 1, character: args.character - 1 },
           }, 10)
-          if (!res?.result) return "No definition found."
+          if (!res?.result) return "(no definition found)"
           const locs = Array.isArray(res.result) ? res.result : [res.result]
           return locs.map((l) => {
             const path = l.uri.replace(/^file:\/\/\//, "").replace(/%3A/, ":")
@@ -255,7 +254,7 @@ export const lspTool = {
             position: { line: args.line - 1, character: args.character - 1 },
             context: { includeDeclaration: false },
           }, 10)
-          if (!res?.result?.length) return "No references found."
+          if (!res?.result?.length) return "(no references found)"
           return res.result.slice(0, 50).map((l) => {
             const path = l.uri.replace(/^file:\/\/\//, "").replace(/%3A/, ":")
             return `${path}:${l.range.start.line + 1}:${l.range.start.character + 1}`
@@ -268,7 +267,7 @@ export const lspTool = {
             textDocument: { uri },
             position: { line: args.line - 1, character: args.character - 1 },
           }, 10)
-          if (!res?.result?.contents) return "No hover info available."
+          if (!res?.result?.contents) return "(no hover info)"
           const contents = res.result.contents
           if (typeof contents === "string") return contents
           if (Array.isArray(contents)) return contents.map((c) => typeof c === "string" ? c : c.value).join("\n")
@@ -280,7 +279,7 @@ export const lspTool = {
           const res = await request(proc, "textDocument/documentSymbol", {
             textDocument: { uri },
           }, 10)
-          if (!res?.result?.length) return "No symbols found."
+          if (!res?.result?.length) return "(no symbols found)"
           function render(nodes, depth) {
             const lines = []
             for (const n of nodes) {
@@ -295,7 +294,7 @@ export const lspTool = {
 
         case "diagnostics": {
           const diags = proc._diagnostics?.[uri]
-          if (!diags?.length) return "No diagnostics."
+          if (!diags?.length) return "(no diagnostics)"
           return diags.slice(0, 30).map((d) => {
             const sev = { 1: "ERROR", 2: "WARN", 3: "INFO", 4: "HINT" }[d.severity] || "?"
             return `L${d.range.start.line + 1}: ${sev}: ${d.message}${d.code ? ` [${d.code}]` : ""}`
@@ -306,7 +305,7 @@ export const lspTool = {
           return `Unknown subcommand: ${args.subcommand}`
       }
     } catch (err) {
-      return `LSP error: ${err.message}`
+      return `lsp error: ${err.message}`
     }
   },
 }

package/src/tools/patch.mjs

@@ -159,36 +159,7 @@ export const applyPatchTool = {
   },
 }
 
-// ---------------------------------------------------------------- syntax_check
 
-export const syntaxCheckTool = {
-  name: "syntax_check",
-  description: DESC("syntax_check"),
-  parameters: {
-    type: "object",
-    properties: {
-      path: { type: "string", description: "File path (.js/.mjs/.cjs only)" },
-    },
-    required: ["path"],
-  },
-  readonly: true,
-  execute(args, ctx) {
-    const abs = resolveInCwd(ctx, args.path)
-    if (!/\.(?:[mc]?js)$/.test(abs)) {
-      return `syntax_check only supports .js/.mjs/.cjs files; ${args.path} skipped.`
-    }
-    try {
-      execFileSync(process.execPath, ["--check", abs], {
-        cwd: ctx.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"],
-      })
-      return `Syntax OK: ${args.path}`
-    } catch (e) {
-      // node --check writes errors to stderr
-      const msg = (e.stderr || e.stdout || e.message || "").trim()
-      return `Syntax error in ${args.path}:\n${msg || "(unknown)"}`
-    }
-  },
-}
 
 // ---------------------------------------------------------------- bash
 
@@ -204,6 +175,7 @@ export const deleteTool = {
     required: ["path"],
   },
   readonly: false,
+  touchedPaths(args) { return args.path ? [args.path] : [] },
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
     let s

package/src/tools/read_image.md

@@ -1,3 +1,7 @@
 Read an image file and return it as multimodal content visible to the model. Use this to view screenshots, UI mockups, diagrams, or any visual content. The model only sees images through this tool — it cannot "see" files directly. Supports png, jpg, gif, webp, bmp, svg. The image is base64-encoded and included in the response. Large images (>20MB) are rejected.
 
-Note: this tool only works with models that support vision/image input (Kimi K3, Qwen3.7, MiniMax M3). Pure text models (DeepSeek V4, GLM-5) will receive an error.
+Parameters:
+- path (required): Path to image file (relative to cwd or absolute). Supports png, jpg, gif, webp, bmp, svg.
+
+Notes:
+- This tool only works with models that support vision/image input (Kimi K3, Qwen3.7, MiniMax M3). Pure text models (DeepSeek V4, GLM-5) will receive an error.

package/src/tools/system.mjs

@@ -378,7 +378,7 @@ export const lsTool = {
       }),
     )
     rows.sort((a, b) => (a.dir === b.dir ? a.name.localeCompare(b.name) : a.dir ? -1 : 1))
-    if (rows.length === 0) return "(empty directory)"
+    if (rows.length === 0) return "(no entries)"
     const out = rows.map((r) => `${r.dir ? "d" : "-"}  ${r.name.padEnd(40)} ${String(r.size).padStart(10)}  ${r.mtime}`)
     return truncate(out.join("\n"))
   },

package/src/tools/web.mjs

@@ -77,12 +77,12 @@ export const websearchTool = {
       const engine = ENGINES.find(e => e.name === args.engine)
       if (!engine) return `Unknown engine '${args.engine}'. Available: ${ENGINE_NAMES.join(", ")}`
       const fetched = await fetchEngine(engine, args.query, page, ctx)
-      if (!fetched || fetched.results.length === 0) return `(no results from ${engine.label})`
-      return truncate(fetched.results.slice(0, limit).map((r, i) => `${i + 1}. ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"))
+      if (!fetched || fetched.results.length === 0) return "(no results)"
+      return truncate(fetched.results.slice(0, limit).map((r, i) => `${i + 1}. [${engine.label}] ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"))
     }
     const promises = ENGINES.map(e => fetchEngine(e, args.query, 1, ctx))
     const fetched = (await Promise.all(promises)).filter(Boolean)
-    if (fetched.length === 0) return "(no results — all search engines failed)"
+    if (fetched.length === 0) return "(no results)"
     const merged = [], indexes = fetched.map(() => 0)
     let done = false
     while (!done && merged.length < limit) {

package/src/tui/agent-turn.mjs

@@ -3,6 +3,22 @@ import { saveSession } from "../session.mjs"
 import { sliceByWidth } from "./render.mjs"
 import { ansi, C } from "./ansi.mjs"
 
+/** Tool execution start timestamps (performance.now ms), keyed by tool name. */
+const _toolTicks = Object.create(null)
+
+/** Per-tool streaming preview line limits — tools with verbose output get more lines */
+const LIVE_LINE_LIMITS = {
+  bash: 10,
+  advisor: 15,
+  read: 3,
+  grep: 8,
+  glob: 8,
+  search: 8,
+  websearch: 8,
+  code_search: 8,
+  doc_search: 8,
+}
+
 /** Execute one agent conversation turn (triggered by submit or queue).
  *  Extracted from index.mjs: agent loop + callback construction + error handling + queue processing.
  *  ctx: { agent, state, pushLine, pushLabel, render, scheduleRender,
@@ -29,6 +45,8 @@ export async function runAgentTurn(ctx, text) {
   state.status = "Processing..."
   state.streaming = ""
   state.reasoning = ""
+  state.advisorStreaming = ""
+  state._advisorThink = ""
   state.subTasks = {}
   state.currentTool = null
   state.processingStarted = Date.now()
@@ -49,6 +67,8 @@ export async function runAgentTurn(ctx, text) {
       pushLine(state.streaming, C.text)
       state.streaming = ""
     }
+    state.advisorStreaming = ""
+    state._advisorThink = ""
   }
 
   const callbacks = {
@@ -102,14 +122,36 @@ export async function runAgentTurn(ctx, text) {
         scheduleRender()
         return
       }
+      if (name === "advisor") { state.advisorStreaming = ""; state._advisorThink = "" }
       flushStream()
       ensureAssistantLabel()
       state.currentTool = name
+      // Update status bar with current tool and key arguments for user visibility
+      if (name === "bash" && args.command) {
+        const cmd = args.command.replace(/\s+/g, " ").trim()
+        state.status = `Running: ${cmd.length > 50 ? cmd.slice(0, 50) + "…" : cmd}`
+      } else if ((name === "read" || name === "write" || name === "edit" || name === "grep" || name === "glob") && args.path) {
+        state.status = `${name}: ${args.path}`
+      } else if (name === "grep" && args.pattern) {
+        state.status = `grep: ${args.pattern}`
+      } else if (name === "glob" && args.pattern) {
+        state.status = `glob: ${args.pattern}`
+      } else if (name === "websearch" && args.query) {
+        state.status = `search: ${args.query.length > 40 ? args.query.slice(0, 40) + "…" : args.query}`
+      } else if (name === "advisor") {
+        state.status = `advisor review (round ${(agent._advisorRound || 0) + 1})`
+      } else {
+        state.status = `tool: ${name}`
+      }
       // Advisor: tag the round in the tool title — the model's own "第N轮" narration
       // is unreliable (it glues onto the previous line), so the round belongs here.
       const roundTag = name === "advisor" ? ` (round ${(agent._advisorRound || 0) + 1})` : ""
       const argSummary = summarize(args)
-      pushLine(`  [tool] ${name}${roundTag}${argSummary ? ` ${argSummary}` : ""}`, C.tool)
+      // Inline block title — panel tools get both the title AND the
+      // streaming output panel, complementary display.
+      const color = ({ advisor: C.advisor, bash: C.warn, verify: C.tool }[name] ?? C.text)
+      pushLine(`❯ ${name}${roundTag}${argSummary ? ` ${argSummary}` : ""}`, color)
+      _toolTicks[name] = performance.now()
     },
     onToolResult: (name, result) => {
       state.currentTool = null
@@ -137,83 +179,74 @@ export async function runAgentTurn(ctx, text) {
           if (state.processing) render()
         }, 3000)
       }
-      const stream = state.toolStreams[name]
-      const panel = state.outputPanels[name]
-      if (panel) {
-        delete state.toolStreams[name]
-        // Keep the panel visible for a 3s grace period (layout filters by closeAt);
-        // the render loop prunes it once expired. No defer hacks needed — row-diff
-        // repaints whatever should be on screen.
-        panel.done = true
-        panel.closeAt = Date.now() + 3000
-        scheduleRender()
-        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)
+      if (!isSubagent && name !== "advisor") {
+        // Remove live streaming lines — done line handles the summary.
+        for (let i = state.lines.length - 1; i >= 0; i--) {
+          if (state.lines[i]._live === name) state.lines.splice(i, 1)
         }
-        // Trigger a repaint after the grace period so the pruned panel disappears
-        setTimeout(() => render(), 3000)
-      } else if (stream) {
-        const tail = stream.trimEnd().slice(-4000)
-        if (tail) pushLine(tail, C.dim)
-        delete state.toolStreams[name]
+        const summary = formatToolSummary(name, result)
+        if (summary) pushLine(`  ${summary}`, C.dim)
       }
-      if (!isSubagent && !panel) {
-        const first = result.split("\n")[0]
-        pushLine(`  [done] ${name} → ${sliceByWidth(first, 100)}`, C.dim)
+      if (name === "advisor") { state.advisorStreaming = ""; state._advisorThink = "" }
+      // Done line for ALL tools (panel area abolished — inline only).
+      if (!isSubagent) {
+        const elapsed = _toolTicks[name] ? ` (${Math.round(performance.now() - _toolTicks[name])}ms)` : ""
+        const summary = formatToolSummary(name, result)
+        const tail = summary ? ` → ${sliceByWidth(summary, 60)}` : ""
+        pushLine(`❯ ${name} — done${elapsed}${tail}`, C.dim)
       }
+      delete _toolTicks[name]
     },
     onToolOutput: (name, chunk) => {
-      // Route streaming output to a panel if one exists or was requested via outputPanel flag.
-      // Chunk may be a string or { kind, text } — kind ("think" | "text" | "tool") drives
-      // per-kind coloring in renderOutput so reasoning / answer / tool progress are distinct.
-      let panel = state.outputPanels[name]
-      if (!panel) {
-        // Lazy-create panel: defensive against race conditions where setupOutputPanel
-        // hasn't fired yet or the callbacks chain dropped it (subagent relay, reconnect, etc.)
-        state.outputPanels[name] = { parts: [], len: 0, done: false }
-        panel = state.outputPanels[name]
-      }
+      // All tools use inline conversation blocks — panel area is abolished.
+      // Stream up to 5 preview lines; the full result is in the tool message.
       const part = typeof chunk === "string"
-        ? { kind: "text", text: chunk }
-        : { kind: chunk?.kind ?? "text", text: String(chunk?.text ?? "") }
+        ? { kind: "text", text: chunk.trimEnd() }
+        : { kind: chunk?.kind ?? "text", text: String(chunk?.text ?? "").trimEnd() }
       if (!part.text) return
-      // Separate phase transitions with a newline — think → answer → tool progress
-      // would otherwise glue onto each other mid-line.
-      const last = panel.parts[panel.parts.length - 1]
-      if (last && last.kind !== part.kind && !last.text.endsWith("\n") && !part.text.startsWith("\n")) {
-        part.text = "\n" + part.text
-      }
-      panel.parts.push(part)
-      panel.len += part.text.length
-      // Cap at 4000 chars, trimming oldest parts first
-      while (panel.len > 4000 && panel.parts.length > 1) {
-        const first = panel.parts[0]
-        const excess = panel.len - 4000
-        if (first.text.length <= excess) {
-          panel.len -= first.text.length
-          panel.parts.shift()
+      if (name === "advisor") {
+        // Accumulate to buffer — formatTables + wrapText in render-conversation
+        // handles markdown formatting, same as main agent response.
+        const raw = typeof chunk === "string" ? chunk : String(chunk?.text ?? "")
+        const kind = typeof chunk === "string" ? "text" : (chunk?.kind ?? "text")
+        if (kind === "think") {
+          state._advisorThink = (state._advisorThink || "") + raw
         } else {
-          first.text = first.text.slice(excess)
-          panel.len -= excess
+          state.advisorStreaming += raw
+        }
+        scheduleRender()
+        return
+      }
+      // Rolling output — show latest N lines with fold marker per tool.
+      // _live marker per tool enables per-tool pruning without affecting other content.
+      const color = ({ think: C.reason, tool: C.tool }[part.kind] ?? C.dim)
+      for (const line of part.text.split("\n")) {
+        const trimmed = line.trimEnd()
+        if (!trimmed) continue
+        state.lines.push({ text: `│ ${trimmed}`, color, _live: name })
+      }
+      // Prune: keep at most N lines + "│ …" fold marker per tool (configurable, tool-specific)
+      const configLimit = agent.config?.agent?.streamPreviewLines
+      const toolLimit = LIVE_LINE_LIMITS[name]
+      const previewLines = configLimit ?? toolLimit ?? 5
+      let count = 0
+      let hasFold = false
+      for (let i = state.lines.length - 1; i >= 0; i--) {
+        if (state.lines[i]._live === name) {
+          if (++count > previewLines) {
+            if (!hasFold) {
+              state.lines[i] = { text: "│ …", color: C.dim, _live: name }
+              hasFold = true; count = previewLines
+            } else {
+              state.lines.splice(i, 1)
+            }
+          }
         }
       }
       scheduleRender()
     },
     onPermissionRequest: (name, args) => askPermission(name, args),
     onQuestion: (text, options) => askQuestion(text, options),
-    setupOutputPanel: (name) => {
-      state.outputPanels[name] = { parts: [], len: 0, done: false }
-      scheduleRender()
-    },
     onCompress: () => {
       pushLine("  [context] Context too long, auto-compacted (early conversation summarized by LLM, task state preserved)", C.warn)
     },
@@ -243,6 +276,17 @@ export async function runAgentTurn(ctx, text) {
     onTurnEnd: (() => {
       let n = 0
       return () => {
+        // Flush pending reasoning/streaming before the next turn starts.
+        // Guard pushbacks (verify/advisor) continue the agent loop without
+        // returning to the TUI — without flushing, old thinking bleeds into
+        // the next turn and the guard reminder is invisible.
+        flushStream()
+        // Mirror the last system-reminder from agent.history so guard
+        // pushback messages appear in the conversation at the right spot.
+        const last = agent.history.at(-1)
+        if (last?.role === "user" && typeof last.content === "string" && last.content.startsWith("[System reminder:")) {
+          pushLine(last.content, C.warn)
+        }
         if (++n % 5 !== 0) return
         try { saveSessionImpl(agent, state.lines) } catch (e) { console.error(`[session] incremental save failed: ${e.message}`) }
       }
@@ -303,6 +347,8 @@ export async function runAgentTurn(ctx, text) {
     clearInterval(ticker)
     state.processing = false
     state.subTasks = {}
+    state.advisorStreaming = ""
+    state._advisorThink = ""
     state.controller = null
     state.status = "Ready"
     // Auto-collapse todo panel when all tasks done (matching kimi-code TUI; agent.tasks are preserved)
@@ -333,15 +379,55 @@ export async function runAgentTurn(ctx, text) {
   }
 }
 
-/** Extract a one-line summary from a panel tool's output */
-function formatPanelSummary(name, result) {
+/** Extract a one-line summary from tool output for the done line */
+function formatToolSummary(name, result) {
   if (name === "verify") return _verifySummary(result)
   if (name === "bash") return _bashSummary(result)
+  if (name === "advisor") return _advisorSummary(result)
+  if (name === "read" || name === "read_file") return _readSummary(result)
+  if (name === "write" || name === "write_file") return _writeSummary(result)
+  if (name === "grep" || name === "search") return _grepSummary(result)
+  if (name === "glob") return _globSummary(result)
   // Default: first non-empty line
   const first = result.split("\n").find((l) => l.trim())
   return first ? `${name}: ${first.slice(0, 100)}` : null
 }
 
+function _readSummary(result) {
+  const lines = result.split("\n")
+  // Look for line count in result
+  const countMatch = result.match(/(\d+) lines?/)
+  if (countMatch) return `${countMatch[1]} lines`
+  // Fallback: count actual lines
+  return `${lines.length} lines`
+}
+
+function _writeSummary(result) {
+  // Extract file size or confirmation
+  if (result.includes("wrote") || result.includes("created")) {
+    const sizeMatch = result.match(/(\d+)(?:\s*(?:bytes?|chars?))/i)
+    return sizeMatch ? `wrote ${sizeMatch[1]} bytes` : "wrote file"
+  }
+  const first = result.split("\n").find((l) => l.trim())
+  return first ? first.slice(0, 80) : "wrote"
+}
+
+function _grepSummary(result) {
+  const lines = result.split("\n").filter((l) => l.trim())
+  const count = lines.length
+  if (count === 0) return "no matches"
+  if (count === 1) return "1 match"
+  return `${count} matches`
+}
+
+function _globSummary(result) {
+  const lines = result.split("\n").filter((l) => l.trim())
+  const count = lines.length
+  if (count === 0) return "no files"
+  if (count === 1) return "1 file"
+  return `${count} files`
+}
+
 /**
  * bash result format: "[stdout]:\n<out>\n\n[stderr]:\n<err>\n\n(exit code 0)".
  * The first non-empty line is always the "[stdout]:" marker — useless as a summary.
@@ -357,6 +443,23 @@ function _bashSummary(result) {
   return parts.length > 0 ? `bash: ${parts.join(" ")}` : null
 }
 
+function _advisorSummary(result) {
+  const text = String(result ?? "")
+  if (/no 🔴|all.*(?:resolved|fixed|pass)/im.test(text)) return "advisor: passed"
+  // Error / skip messages — extract the reason after "Advisor:"
+  const errMatch = text.trimStart().match(/^Advisor:\s*(.+)/)
+  if (errMatch) return `advisor: ${errMatch[1].split(".")[0]}`
+  const critical = (text.match(/\| \d+ \|.*\| 🔴/g) || []).length
+  const advisory = (text.match(/\| \d+ \|.*\| 🟡/g) || []).length
+  const style = (text.match(/\| \d+ \|.*\| 🔵/g) || []).length
+  const parts = []
+  if (critical) parts.push(`${critical} critical`)
+  if (advisory) parts.push(`${advisory} advisory`)
+  if (style) parts.push(`${style} style`)
+  if (parts.length === 0) return null
+  return `advisor: ${parts.join(", ")}`
+}
+
 function _verifySummary(result) {
   const lines = result.split("\n")
   const summary = []

package/src/tui/cmd-config.mjs

@@ -38,6 +38,7 @@ export async function handleConfigCommand(ctx, args = []) {
     const cfg = loadConfig()
     injectProxy(cfg.providersList, cfg)
     const runtimeName = agent.activeProvider
+    const runtimeModel = agent.activeModel
     agent.providers = cfg.providersList
     agent.config = cfg
     agent.config.agent ??= {}
@@ -45,9 +46,20 @@ export async function handleConfigCommand(ctx, args = []) {
     if (runtimeName && runtimeName !== cfg.activeProvider && keep) {
       // 运行时选择在新配置里仍存在 → 保持（provider 为注入 proxyUri 后的新对象）
       agent.activeProvider = runtimeName
+      agent.activeModel = runtimeModel
       agent.provider = { ...keep }
+      if (agent.activeModel) agent.provider.model = agent.activeModel
+    } else if (runtimeName && runtimeName === cfg.activeProvider && runtimeModel) {
+      // Same provider, runtime had a model override — keep it
+      agent.activeProvider = cfg.activeProvider
+      agent.activeModel = runtimeModel
+      const p = cfg.providersList.find((pr) => pr.name === cfg.activeProvider)
+      agent.provider = p ? { ...p } : cfg.provider
+      agent.provider.model = runtimeModel
+      agent.provider.proxyUri = p?.proxyUri
     } else {
       agent.activeProvider = cfg.activeProvider
+      agent.activeModel = cfg.activeModel ?? null
       agent.provider = cfg.provider
       agent.provider.proxyUri = cfg.providersList.find((p) => p.name === cfg.activeProvider)?.proxyUri
     }

package/src/tui/cmd-eng.mjs

@@ -0,0 +1,44 @@
+/** /eng command: toggle engineering mode.
+ *  Requires METHODOLOGY.md in project root. Offers to create one if missing.
+ *  ctx: { agent, pushLine, pushLabel, persistRaw, showPicker } */
+import { existsSync, copyFileSync } from "node:fs"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { ansi, C } from "./ansi.mjs"
+
+const templateDir = join(fileURLToPath(import.meta.url), "..", "..", "prompts")
+
+export async function handleEngCommand(ctx) {
+  const { agent, pushLine, pushLabel, persistRaw, showPicker } = ctx
+  agent.config.agent ??= {}
+  const methodologyPath = join(agent.cwd, "METHODOLOGY.md")
+
+  // Toggle on: check METHODOLOGY.md exists
+  if (!agent.config.agent.engineering) {
+    if (!existsSync(methodologyPath)) {
+      pushLabel("❯ Eng", ansi.bold + C.tool)
+      pushLine("METHODOLOGY.md not found in project root.", C.warn)
+      const choice = await showPicker("Create METHODOLOGY.md?", [
+        { type: "header", text: "Engineering mode requires a methodology file" },
+        { type: "item", text: "Yes, create from template", action: "create" },
+        { type: "item", text: "No, cancel", action: "cancel" },
+      ])
+      if (!choice || choice.action !== "create") return
+      const src = join(templateDir, "methodology-template.md")
+      copyFileSync(src, methodologyPath)
+      pushLine(`Created METHODOLOGY.md (from template) → edit it to fit your project`, C.tool)
+    }
+  }
+
+  agent.config.agent.engineering = !agent.config.agent.engineering
+  if (!agent.config.agent.engineering) agent._engDesignToken = null // invalidate stale token
+  await persistRaw((raw) => {
+    raw.agent ??= {}
+    raw.agent.engineering = agent.config.agent.engineering
+  })
+  pushLabel("❯ Eng", ansi.bold + C.tool)
+  pushLine(`Engineering mode: ${agent.config.agent.engineering ? "ON" : "OFF"}`, C.tool)
+  if (agent.config.agent.engineering) {
+    pushLine(`  → strictly following ${methodologyPath}`, C.dim)
+  }
+}