thincoder 0.5.0 → 0.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 **Sharp Code, Zero Bloat.**
 
-**一个"薄"的 AI 编程 agent：纯 `.mjs`、无构建、零 npm 依赖、Node.js 原生。**
+**一个"薄"的 AI 编程 agent：纯** `.mjs`**、无构建、零 npm 依赖、Node.js 原生。**
 
 ThinCoder 的 "Thin" 不是"功能单薄"，而是**思维锐利、直击要害**——像刀刃。
 在 AI agent 都在卷"全能"的今天，ThinCoder 打的是反面那张牌：**克制、精准、不废话**。
@@ -12,32 +12,28 @@ ThinCoder 的 "Thin" 不是"功能单薄"，而是**思维锐利、直击要害*
 
 ## 特性
 
-- **Agent 主循环**：LLM ↔ 工具调用循环，直到任务完成（上限 100 轮防失控）
-- **工具集**：`read` / `write` / `edit` / `bash` / `glob` / `grep` / `websearch` / `ls` / `fetch` + `code_search` / `doc_search` / `repo_outline` + MCP，全部零依赖实现
-- **代码库理解**：`repo_outline`（依赖大纲）、`code_search`（源码 FTS5 + 向量 + JSDoc）、`doc_search`（文档分块检索）——启动时后台索引，状态栏显示进度；write/edit/delete 后自动增量更新
-- **两段式工具调度**：权限确认串行（一个一个问），只读工具并行执行，有副作用工具串行
-- **会话持久化**：退出自动保存，启动自动恢复（按项目目录隔离），`/new` 开始新会话
-- **子 agent 并发**：`subagent` 工具派发独立子任务，`role="explore"`（只读搜索）和 `role="coder"`（全套工具；写操作需 AUTO 模式），并发执行；coder 完成后自动提醒主 agent 校验报告
-- **Plan Mode**：`plan` 工具进入规划模式——只读探索 + 架构设计 + 方案展示，用户确认后退出并实现；TUI 状态栏显示 PLAN 标识
-- **AUTO 模式**：`/auto` 或 `chat --auto` 完全授权，长任务免确认，状态栏黄色 AUTO 标识
-- **任务跟踪**：`task` 工具让 agent 拆解多步任务并跟踪进度（pending/in_progress/done），TUI 状态栏实时显示 ▶n/m；上下文压缩后自动回注
-- **Goal 跟踪**：`goal` 工具设置长期目标，每 ~10 轮自动提醒，跨压缩会话保持
-- **Skills 系统**：`.thincoder/skills/*.md` 按需加载，可复用工作流
-- **质量验证**：`verify` 工具——完成前自查 git diff + task 列表 + 6 项自检清单
-- **MCP 支持**：在 `config.json` 的 `mcp.servers[]` 配 `command` / `args`，启动时自动连接并发现工具
-- **流式 TUI**：裸 ANSI 实现（无 UI 库），对话流 / 流式输出 / 权限确认（y/n/a，a=批准并转 AUTO）/ 翻页 / 输入历史 / 斜杠命令 Tab 补全
-- **上下文压缩**：对话超阈值时自动摘要（保留最早 2 条 + 最近 10 条，中间 LLM 摘要）
-- **三层记忆 + 团队共享**（见下）
-- **LLM 调用**：原生 `fetch` 直连 OpenAI 兼容协议（OpenAI / DeepSeek / Moonshot / Ollama），流式 SSE，指数退避重试，支持 `reasoning_content` 思考流
+- **Agent 主循环**：LLM ↔ 工具调用循环，上限 100 轮防失控，完成守卫拦截未验证的改动
+- **代码库理解** ⭐0.5.0：`repo_outline`（依赖大纲，启动自动注入）、`code_search`（源码 FTS5 + 向量 + JSDoc 提取）、`doc_search`（文档按 ## 标题分块检索）——后台索引、写文件自动增量更新、三工具按"结构→意图→细节"引导
+- **模型适配** ⭐：5 家国产大模型内置预设（DeepSeek/Kimi/GLM/Qwen/MiniMax），自动匹配上下文窗口、截断续写协议（prefix/partial）、思考模式 API（thinking.type / reasoning_effort）、输出上限
+- **工具集**：`read` / `write` / `edit` / `bash` / `glob`（支持 `**`） / `grep` / `websearch` / `ls` / `fetch` + 三个检索工具 + MCP，全部零依赖，文件工具目录隔离
+- **记忆系统**：三层（personal/project/team），FTS5 + 向量 RRF 混合检索，markdown 格式 git 友好
+- **两段式工具调度**：权限确认串行，只读工具并行，副作用工具串行
+- **会话持久化** ⭐0.5.0：最多 5 个归档槽位，`/session` 随时切换，恢复时工具结果可见
+- **子 agent 并发**：`explore`/`plan`/`coder` 三种角色，并行派发，流式输出可见，报告进对话区
+- **Plan Mode**：只读探索 + 方案设计，用户确认后实现
+- **AUTO 模式**：`/auto` 完全授权，长任务免确认
+- **任务跟踪**：`task` 工具拆解多步任务，状态栏 ✓n/m 实时进度，自动过滤已完成项
+- **Goal/Verify/Skills**：长目标跟踪、完成验证、可复用技能
+- **流式 TUI**：裸 ANSI，权限预览紧挨输入框，write/edit 自动展示 diff
 
 ## 记忆系统：一人学到，全队皆知
 
 三层记忆，全部"有就查、没有就跳过"，统一混合检索：
 
-| 层 | 位置 | 同步方式 |
-|---|---|---|
-| **Personal** | `~/.thincoder/memory.db`（sqlite） | 不同步，私有 |
-| **Project** | 项目仓库 `.thincoder/memory/*.md` | 随项目 git（ThinCoder **只写文件，绝不替你 commit**） |
+| 层               | 位置                                                | 同步方式                                                                          |
+| ---------------- | --------------------------------------------------- | --------------------------------------------------------------------------------- |
+| **Personal**     | `~/.thincoder/memory.db`（sqlite）                  | 不同步，私有                                                                      |
+| **Project**      | 项目仓库 `.thincoder/memory/*.md`                   | 随项目 git（ThinCoder **只写文件，绝不替你 commit**）                             |
 | **Team**（可选） | 独立记忆仓库，clone 到 `~/.thincoder/teams/<name>/` | `thincoder sync`（pull --rebase）；写入时自动 commit + push（专用设施，可选启用） |
 
 - **混合检索**：FTS5（BM25，中文逐字索引，双字词可命中）+ embedding 向量（暴力余弦）+ RRF(k=60) 融合排序
@@ -48,7 +44,7 @@ ThinCoder 的 "Thin" 不是"功能单薄"，而是**思维锐利、直击要害*
 
 ## 要求
 
-- Node.js >= 22（记忆功能用到 `node:sqlite`；推荐 24）
+- Node.js >= 24
 - 一个 OpenAI 兼容端点的 API key
 - 可选：embedding 服务的 key（不配置则退化为纯 FTS 检索）
 
@@ -88,7 +84,7 @@ thincoder upgrade
 
 从源码运行：把上面的 `thincoder` 换成 `node bin/thincoder.mjs`。
 
-TUI 内斜杠命令：`/help`、`/model`（方向键选择全部 provider 的全部模型；`/model <名称>` 直接切换）、`/provider`（增/删 provider、配 key，支持自定义端点）、`/think`（思维模式开关与推理强度）、`/config`（查看配置、`/config embedkey` 配 embedding key、`/config set` 改参数）、`/distill`（从当前会话提取知识）、`/clear`、`/exit`。输入 `/` 时状态栏实时提示匹配命令。
+TUI 内斜杠命令：`/help`、`/model`（方向键选择全部 provider 的全部模型；`/model <名称>` 直接切换）、`/provider`（增/删 provider、配 key，支持自定义端点）、`/think`（思维模式开关与推理强度）、`/config`（查看配置、`/config embedkey` 配 embedding key、`/config set` 改参数）、`/session`（列出/切换归档会话）、`/reindex`（重建索引）、`/distill`（从当前会话提取知识）、`/clear`、`/exit`。输入 `/` 时状态栏实时提示匹配命令。
 
 环境变量：`THINCODER_API_KEY`（或 `DEEPSEEK_API_KEY` / `OPENAI_API_KEY`）、`THINCODER_BASE_URL`、`THINCODER_MODEL`、`SILICONFLOW_API_KEY`。
 
@@ -98,41 +94,45 @@ TUI 内斜杠命令：`/help`、`/model`（方向键选择全部 provider 的全
 
 ```jsonc
 {
-  "providers": [                              // 可配多个，/model <名称> 切换
+  "providers": [
+    // 可配多个，/model <名称> 切换
     {
       "name": "deepseek",
-      "baseURL": "https://api.deepseek.com/v1",  // 任意 OpenAI 兼容端点
-      "apiKey": "sk-...",                         // 或留空走环境变量
-      "model": "deepseek-chat"
-    }
+      "baseURL": "https://api.deepseek.com/v1", // 任意 OpenAI 兼容端点
+      "apiKey": "sk-...", // 或留空走环境变量
+      "model": "deepseek-chat",
+    },
   ],
-  "activeProvider": "deepseek",               // 当前激活的 provider 名
-  "embedding": {                                // 可选：不配则纯 FTS 检索
+  "activeProvider": "deepseek", // 当前激活的 provider 名
+  "embedding": {
+    // 可选：不配则纯 FTS 检索
     "baseURL": "https://api.siliconflow.cn/v1",
-    "apiKey": "sk-...",                         // 或 SILICONFLOW_API_KEY
-    "model": "BAAI/bge-m3"
+    "apiKey": "sk-...", // 或 SILICONFLOW_API_KEY
+    "model": "BAAI/bge-m3",
   },
   "agent": {
-    "maxTurns": 100,                             // 工具循环上限
-    "compactThreshold": 100000                  // 上下文压缩阈值（约 token 数）
+    "maxTurns": 100, // 工具循环上限
+    "compactThreshold": 100000, // 上下文压缩阈值（约 token 数）
   },
   "memory": {
-    "dbPath": "~/.thincoder/memory.db",         // sqlite 索引库路径
-    "projectDir": ".thincoder/memory",          // Project 层目录（相对项目根）
-    "team": {                                   // 可选：不配则 Team 层禁用
+    "dbPath": "~/.thincoder/memory.db", // sqlite 索引库路径
+    "projectDir": ".thincoder/memory", // Project 层目录（相对项目根）
+    "team": {
+      // 可选：不配则 Team 层禁用
       "name": "myteam",
-      "repo": "git@github.com:org/team-memory.git"
-    }
+      "repo": "git@github.com:org/team-memory.git",
+    },
   },
-  "mcp": {                                      // 可选：MCP server 列表
+  "mcp": {
+    // 可选：MCP server 列表
     "servers": [
       {
         "name": "filesystem",
         "command": "npx",
-        "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
-      }
-    ]
-  }
+        "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
+      },
+    ],
+  },
 }
 ```
 
@@ -187,6 +187,44 @@ node scripts/verify-team.mjs      # 团队记忆 A->git->B 全链路验证（本
 - MCP HTTP transport（当前仅 stdio）
 - 更多内置 skills
 
+## 更新日志
+
+### 0.5.0（2026-07）
+- **代码库理解**：`repo_outline`（依赖大纲，启动自动注入）、`code_search`（FTS5 + 向量 + JSDoc）、`doc_search`（按 ## 标题分块），写文件自动增量索引
+- **模型适配**：5 家内置预设（DeepSeek/Kimi/GLM/Qwen/MiniMax），maxTokens 拉满、截断续写、思考模式 API 自动匹配
+- 会话 5 槽位归档、`/session` 切换、恢复时展示工具结果
+- 子 agent 流式输出可见、最终报告进对话区
+- 文件工具目录隔离、权限预览紧挨输入框
+- write/edit 自动附 git diff、edit 错误信息增强提示
+- task 自动过滤已完成项、全部 done 时主动提醒
+- 提示词引导"查官方文档 → 不一致就存项目记忆"
+
+### 0.4.0
+- 权限审批展示文件内容预览（write 内容、edit diff、bash 命令）
+- todo 面板进度可视、状态栏 token 用量与上下文利用率
+- 项目指令双层合并（全局 + 项目 AGENTS.md）
+
+### 0.3.0
+- MCP 客户端（JSON-RPC + stdio，零依赖）
+- Skills 系统（`.thincoder/skills/*.md`）
+- Plan/Goal/Question 工具
+- 提示词外部化到 `.md` 文件、子 agent 角色 overlay
+- task 严格纪律（keep ONE in_progress）、完成守卫（改文件未 verify 拦截）
+- DeepSeek thinking 回传、system prompt 前缀缓存
+- checkpoint 存档点 + `/rewind` 回滚
+
+### 0.2.0
+- multi-provider 配置（支持多端点切换）
+- 初始配置向导（方向键选模型、配 key）
+- `/think` 思维模式开关与推理强度
+- `/model` 模型选择器
+- bash 流式输出实时透传
+
+### 0.1.0
+- Agent 主循环、14 个内置工具、零依赖 TUI
+- 三层记忆（personal/project/team）、FTS5 检索
+- 会话持久化、上下文压缩、流式 SSE
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",
@@ -17,7 +17,7 @@
     "thincoder": "./bin/thincoder.mjs"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "files": [
     "bin/",

package/src/SYSTEM_PROMPT.md

@@ -25,6 +25,7 @@ Coding discipline (rigor over speed—tokens spent on verification are well spen
 - Before fixing a bug, find the root cause: read the error output, reproduce it, trace the code path. Don't patch symptoms.
 - Match the surrounding code: comment density, naming, structure. Prefer the project's existing patterns over your own defaults.
 - Before using a library or utility, confirm the project already depends on it (check imports, manifest, lockfile). If it's missing, surface that instead of silently adding a dependency.
+- When you need facts that may be outdated in your training data—API docs, framework versions, language features, npm packages, CLI flags, pricing, CVEs, platform differences—verify with authoritative sources first: read the project's own files (package.json, lockfile), check official docs (websearch/fetch), or test the actual environment. If findings contradict your training data, save the corrected fact to project memory so future sessions benefit.
 - Refactoring: update every caller when an interface changes; never change existing test logic just to make tests pass.
 - Deliver complete changes: no placeholder stubs, no "// rest unchanged", no TODO gaps left for the user to fill in.
 - After changing behavior, sweep comments and docstrings that now describe the old behavior and bring them in line with the code.

package/src/agent.mjs

@@ -296,6 +296,12 @@ export const subagentTool = {
     const relayPrefix = role ? `${role}/` : "sub/"
     const childOpts = {
       onPermissionRequest: childPermission,
+      onToken: ctx.callbacks?.onToken
+        ? (t) => ctx.callbacks.onToken(`${relayPrefix}${t}`)
+        : null,
+      onReasoning: ctx.callbacks?.onReasoning
+        ? (t) => ctx.callbacks.onReasoning(`${relayPrefix}${t}`)
+        : null,
       onToolCall: ctx.callbacks?.onToolCall
         ? (name, args) => ctx.callbacks.onToolCall(`${relayPrefix}${name}`, args)
         : null,
@@ -373,10 +379,14 @@ export const taskTool = {
   },
   readonly: true,
   async execute(args, ctx) {
-    const items = (args.items ?? []).map((it) => ({
+    // 只保留非 done 项 + 最近完成的 3 项（上下文参考），上限 20 项防堆积
+    const raw = (args.items ?? []).map((it) => ({
       title: String(it.title ?? "").slice(0, 200),
       status: VALID_TASK_STATUS.has(it.status) ? it.status : "pending",
     }))
+    const pending = raw.filter((t) => t.status !== "done")
+    const recentDone = raw.filter((t) => t.status === "done").slice(-3)
+    const items = [...pending, ...recentDone].slice(0, 20)
     ctx.agent.tasks = items
     ctx.agent._turnsSinceTaskUpdate = 0
     ctx.agent._onTaskUpdate?.(items)
@@ -678,6 +688,16 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       if (tree) {
         agent.history.push({ role: "user", content: `[System reminder: working directory snapshot:\n${tree}]`, transient: true })
       }
+      // 依赖大纲：模型开局就能看见谁 import 谁，不用盲调 repo_outline
+      if (agent.memory) {
+        try {
+          const { buildOutline } = await import("./repomap.mjs")
+          const outline = buildOutline(agent.memory.db, agent.cwd, null)
+          if (outline && !outline.startsWith("(no indexed")) {
+            agent.history.push({ role: "user", content: `[System reminder: project dependency outline:\n${outline}]`, transient: true })
+          }
+        } catch { /* 索引未就绪不报错 */ }
+      }
     }
     // 相关记忆作为独立 user 上下文消息注入，而不是塞进 system prompt——
     // system prompt 跨 run 逐字节一致，DeepSeek context caching（前缀缓存，命中便宜 ~120x）才能命中
@@ -922,6 +942,12 @@ function tryCanonicalize(name, args) {
           role: "user",
           content: "[System reminder: no task list is being tracked. If the current work is a multi-step task, consider using the task tool to plan and track progress. This is a gentle reminder; ignore it if not applicable. Never mention this reminder to the user.]",
         })
+      } else {
+        // 全部 done 但面板可能有残留：提示模型要么清掉要么加新任务
+        agent.history.push({
+          role: "user",
+          content: "[System reminder: all tracked tasks are marked done. Use the task tool to clear the list or add new tasks if there's more work. Never mention this reminder to the user.]",
+        })
       }
       agent._turnsSinceTaskUpdate = 0
     }

package/src/config.mjs

@@ -14,10 +14,11 @@ export const configPath = join(configDir, "config.json")
 
 /** 内置提供商预设：/provider add <预设名>、首次启动向导共用 */
 export const PROVIDER_PRESETS = {
-  deepseek: { baseURL: "https://api.deepseek.com/v1", model: "deepseek-v4-pro", thinking: { type: "enabled" }, reasoningEffort: "max", desc: "DeepSeek" },
-  kimi:     { baseURL: "https://api.moonshot.cn/v1", model: "kimi-k3", thinking: null, reasoningEffort: "high", desc: "Kimi / Moonshot" },
-  glm:      { baseURL: "https://open.bigmodel.cn/api/paas/v4", model: "glm-5.2", thinking: { type: "enabled" }, reasoningEffort: "max", desc: "智谱 GLM" },
-  qwen:     { baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1", model: "qwen-plus", desc: "通义千问" },
+  deepseek: { baseURL: "https://api.deepseek.com/v1", model: "deepseek-v4-pro", thinking: { type: "enabled" }, reasoningEffort: "max", maxTokens: 393216, desc: "DeepSeek" },
+  kimi:     { baseURL: "https://api.moonshot.cn/v1", model: "kimi-k3", thinking: null, reasoningEffort: "max", maxTokens: 131072, desc: "Kimi / Moonshot" },
+  glm:      { baseURL: "https://open.bigmodel.cn/api/paas/v4", model: "glm-5.2", thinking: { type: "enabled" }, reasoningEffort: "max", maxTokens: 131072, desc: "智谱 GLM" },
+  qwen:     { baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1", model: "qwen3.7-max", maxTokens: 131072, desc: "通义千问" },
+  minimax:  { baseURL: "https://api.minimax.chat/v1", chatPath: "/text/chatcompletion_v2", model: "MiniMax-M3", maxTokens: 131072, desc: "MiniMax" },
 }
 
 // 默认 provider 跟 deepseek 预设保持一致（去掉 desc 展示字段）
@@ -45,28 +46,47 @@ const DEFAULTS = {
 }
 
 /**
- * 已知模型的规格表（前缀匹配，长的在前）。
- * context: 上下文窗口
- * partialMode: Kimi Partial Mode 截断续写协议（assistant 消息带 partial:true；Kimi 与 Qwen 同协议，仅非思考模式）
- * prefixMode: DeepSeek Chat Prefix Completion 截断续写协议（assistant 消息带 prefix:true，走 /beta 端点）
- * compactThreshold 未显式配置时，按窗口 * COMPACT_RATIO 自动推导。
- * 注：deepseek-chat / deepseek-reasoner 已于 2026-07-24 弃用，官方映射到 v4-flash 非思考/思考模式。
+ * 已知模型的能力规格表（前缀匹配，长的在前）。
+ * 用于压缩阈值推导、截断续写协议选择、能力感知优化。
+ *
+ * context:     上下文窗口（tokens）
+ * maxOutput:   最大输出 tokens（默认 context）
+ * thinking:    是否支持思考/推理模式
+ * partialMode: Kimi/Qwen Partial Mode 截断续写（assistant 消息带 partial:true）
+ * prefixMode:  DeepSeek Prefix Completion 截断续写（走 /beta 端点，带 prefix:true）
+ * multimodal:  是否多模态（支持图片/视觉输入）
+ * cacheMode:   上下文缓存方式："auto"=自动/"prompt"=需显式/"none"=不支持
+ * thinkApi:    思考模式 API 类型："type"=thinking.type 字段 / "effort"=reasoning_effort 字段
  */
 const MODEL_SPECS = [
-  ["deepseek-v4-pro", { context: 1_000_000, prefixMode: true }],
-  ["deepseek-v4-flash", { context: 256_000, prefixMode: true }],
-  ["deepseek-reasoner", { context: 256_000, prefixMode: true }],
-  ["deepseek-chat", { context: 256_000, prefixMode: true }],
-  ["kimi-k3", { context: 1_000_000, partialMode: true }],
-  ["kimi-k2", { context: 256_000 }],
-  ["moonshot", { context: 128_000 }],
-  ["glm-5", { context: 1_000_000 }],
-  ["glm-4", { context: 128_000 }],
-  ["gpt-4.1", { context: 1_000_000 }],
-  ["gpt-4o", { context: 128_000 }],
-  ["qwen", { context: 1_000_000, partialMode: true }],
+  // DeepSeek V4 系列
+  ["deepseek-v4-pro",   { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  cacheMode: "prompt", thinkApi: "type" }],
+  ["deepseek-v4-flash", { context: 256_000,   maxOutput: 384_000, thinking: false, prefixMode: true,  cacheMode: "prompt", thinkApi: "type" }],
+  ["deepseek-reasoner", { context: 256_000,   maxOutput: 384_000, thinking: true,  prefixMode: true,  cacheMode: "prompt", thinkApi: "type" }],
+  ["deepseek-chat",     { context: 256_000,   maxOutput: 384_000, thinking: false, prefixMode: true,  cacheMode: "prompt", thinkApi: "type" }],
+  // Kimi 系列
+  ["kimi-k3",           { context: 1_000_000, maxOutput: 128_000, thinking: true,  partialMode: true, multimodal: true, cacheMode: "prompt", thinkApi: "effort" }],
+  ["kimi-k2",           { context: 256_000,   maxOutput: 128_000, thinking: false, partialMode: true, multimodal: true, cacheMode: "none" }],
+  ["moonshot",          { context: 128_000,   maxOutput: 32_000,  thinking: false, cacheMode: "none" }],
+  // GLM 系列
+  ["glm-5.2",           { context: 1_000_000, maxOutput: 128_000, thinking: true,  cacheMode: "auto", thinkApi: "type" }],
+  ["glm-5",             { context: 1_000_000, maxOutput: 128_000, thinking: true,  cacheMode: "auto", thinkApi: "type" }],
+  ["glm-4",             { context: 128_000,   maxOutput: 32_000,  thinking: true,  cacheMode: "auto", thinkApi: "type" }],
+  // GPT 系列
+  ["gpt-4.1",           { context: 1_000_000, maxOutput: 128_000, thinking: false, cacheMode: "prompt" }],
+  ["gpt-4o",            { context: 128_000,   maxOutput: 16_000,  thinking: false, multimodal: true, cacheMode: "prompt" }],
+  // Qwen 系列
+  ["qwen3.7-max",       { context: 1_000_000, maxOutput: 128_000, thinking: false, partialMode: true, cacheMode: "none", thinkApi: "effort" }],
+  ["qwen3.8-max",       { context: 1_000_000, maxOutput: 128_000, thinking: false, partialMode: true, cacheMode: "none", thinkApi: "effort" }],
+  ["qwen-max",          { context: 1_000_000, maxOutput: 128_000, thinking: false, partialMode: true, cacheMode: "none", thinkApi: "effort" }],
+  ["qwen-plus",         { context: 1_000_000, maxOutput: 32_000,  thinking: false, partialMode: true, cacheMode: "none", thinkApi: "effort" }],
+  ["qwen",              { context: 1_000_000, maxOutput: 128_000, thinking: false, partialMode: true, cacheMode: "none", thinkApi: "effort" }],
+  // MiniMax 系列
+  ["MiniMax-M3",        { context: 1_000_000, maxOutput: 128_000, thinking: false, cacheMode: "auto" }],
+  ["minimax-m3",        { context: 1_000_000, maxOutput: 128_000, thinking: false, cacheMode: "auto" }],
+  ["minimax-m1",        { context: 256_000,   maxOutput: 128_000, thinking: false, cacheMode: "auto" }],
 ]
-const DEFAULT_SPEC = { context: 128_000 }
+const DEFAULT_SPEC = { context: 128_000, maxOutput: 32_000, cacheMode: "none" }
 // 窗口利用率上限：0.8（DeepSeek 内部即全窗口；压缩本身要花一次 LLM 调用，过早压缩是纯浪费。
 // 留 20% 余量给压缩后的尾部增长与输出 token）
 const COMPACT_RATIO = 0.8

package/src/memory.mjs

@@ -13,7 +13,7 @@
 import { DatabaseSync } from "node:sqlite"
 import { mkdirSync } from "node:fs"
 import { readFile, readdir, stat, writeFile, mkdir } from "node:fs/promises"
-import { dirname, join } from "node:path"
+import { dirname, join, relative } from "node:path"
 import { parseEntry, serializeEntry, entryFilename } from "./markdown.mjs"
 import { embed, cosine, toBlob, fromBlob } from "./embedding.mjs"
 import { commitAndPush } from "./gitmem.mjs"
@@ -664,6 +664,33 @@ function extractLeadingDoc(lines, lineNum, ext) {
   return text.length > 0 && text.length < 300 ? text : ""
 }
 
+/** 单文件入索引：删除旧块 → 分块 → 插入新块（codeSync 和 reindexFile 共用） */
+function _upsertCodeFile(memory, rel, lines, lang, mtimeMs) {
+  const chunks = chunkCode(lines, rel)
+  memory.db.prepare(`DELETE FROM code_chunks WHERE path = ?`).run(rel)
+  const insert = memory.db.prepare(`
+    INSERT INTO code_chunks (path, language, chunk_type, symbol_name, content, line_start, line_end, mtime_ms, seg_content)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `)
+  for (const c of chunks) {
+    const isFile = c.name === rel
+    insert.run(rel, lang, isFile ? "file" : "symbol", isFile ? "" : c.name.slice(rel.length + 1), c.content, c.line_start, c.line_end, mtimeMs, segmentCJK(c.content))
+  }
+}
+
+function _upsertDocFile(memory, rel, lines, mtimeMs) {
+  const chunks = chunkMarkdown(lines, rel)
+  const lang = rel.endsWith(".rst") ? "rst" : rel.endsWith(".adoc") ? "asciidoc" : rel.endsWith(".txt") ? "text" : "markdown"
+  memory.db.prepare(`DELETE FROM doc_chunks WHERE path = ?`).run(rel)
+  const insert = memory.db.prepare(`
+    INSERT INTO doc_chunks (path, language, heading, content, line_start, line_end, mtime_ms, seg_content)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `)
+  for (const c of chunks) {
+    insert.run(rel, lang, c.heading, c.content, c.line_start, c.line_end, mtimeMs, segmentCJK(c.content))
+  }
+}
+
 /**
  * 同步代码索引：扫描 dir 下所有源文件 → 分块 → upsert 到 code_chunks。
  * 按 mtime 增量——只重建变更过的文件块。
@@ -713,28 +740,7 @@ export async function codeSync(memory, dir, { onProgress } = {}) {
     try { text = await readFile(abs, "utf8") } catch { continue }
     const lines = text.split("\n")
     const lang = detectLanguage(abs)
-    const chunks = chunkCode(lines, rel)
-
-    // 删除该文件的旧块，插入新块
-    memory.db.prepare(`DELETE FROM code_chunks WHERE path = ?`).run(rel)
-    const insert = memory.db.prepare(`
-      INSERT INTO code_chunks (path, language, chunk_type, symbol_name, content, line_start, line_end, mtime_ms, seg_content)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `)
-    for (const c of chunks) {
-      const isFile = c.name === rel
-      insert.run(
-        rel,
-        lang,
-        isFile ? "file" : "symbol",
-        isFile ? "" : c.name.slice(rel.length + 1), // 去掉 "filepath:" 前缀
-        c.content,
-        c.line_start,
-        c.line_end,
-        mtimeMs,
-        segmentCJK(c.content),
-      )
-    }
+    _upsertCodeFile(memory, rel, lines, lang, mtimeMs)
     updated++
 
     if (onProgress && i % 10 === 0) {
@@ -851,48 +857,27 @@ export function codeSearchTool(memory) {
  */
 export async function reindexFile(memory, cwd, absPath) {
   const ext = absPath.slice(absPath.lastIndexOf(".")).toLowerCase()
-  const rel = absPath.slice(cwd.length + 1).replaceAll("\\", "/")
+  const rel = relative(cwd, absPath).replaceAll("\\", "/")
+  if (rel.startsWith("..")) return // 越界路径拒索引
+
+  let text
+  try { text = await readFile(absPath, "utf8") } catch {
+    // 文件已删：清理索引
+    if (CODE_EXTS.has(ext)) memory.db.prepare(`DELETE FROM code_chunks WHERE path = ?`).run(rel)
+    else if (DOC_EXTS.has(ext)) memory.db.prepare(`DELETE FROM doc_chunks WHERE path = ?`).run(rel)
+    return
+  }
+  const lines = text.split("\n")
 
   if (CODE_EXTS.has(ext)) {
-    // 文件已删？清理索引
-    let text
-    try { text = await readFile(absPath, "utf8") } catch {
-      memory.db.prepare(`DELETE FROM code_chunks WHERE path = ?`).run(rel)
-      return
-    }
-    const lines = text.split("\n")
     const lang = detectLanguage(absPath)
-    const chunks = chunkCode(lines, rel)
-    memory.db.prepare(`DELETE FROM code_chunks WHERE path = ?`).run(rel)
-    const insert = memory.db.prepare(`
-      INSERT INTO code_chunks (path, language, chunk_type, symbol_name, content, line_start, line_end, mtime_ms, seg_content)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `)
     let mtimeMs = 0
     try { mtimeMs = Math.floor((await stat(absPath)).mtimeMs) } catch { /* 新文件 */ }
-    for (const c of chunks) {
-      const isFile = c.name === rel
-      insert.run(rel, lang, isFile ? "file" : "symbol", isFile ? "" : c.name.slice(rel.length + 1), c.content, c.line_start, c.line_end, mtimeMs, segmentCJK(c.content))
-    }
+    _upsertCodeFile(memory, rel, lines, lang, mtimeMs)
   } else if (DOC_EXTS.has(ext)) {
-    let text
-    try { text = await readFile(absPath, "utf8") } catch {
-      memory.db.prepare(`DELETE FROM doc_chunks WHERE path = ?`).run(rel)
-      return
-    }
-    const lines = text.split("\n")
-    const chunks = chunkMarkdown(lines, rel)
-    memory.db.prepare(`DELETE FROM doc_chunks WHERE path = ?`).run(rel)
-    const insert = memory.db.prepare(`
-      INSERT INTO doc_chunks (path, language, heading, content, line_start, line_end, mtime_ms, seg_content)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `)
-    const lang = rel.endsWith(".rst") ? "rst" : rel.endsWith(".adoc") ? "asciidoc" : rel.endsWith(".txt") ? "text" : "markdown"
     let mtimeMs = 0
     try { mtimeMs = Math.floor((await stat(absPath)).mtimeMs) } catch { /* 新文件 */ }
-    for (const c of chunks) {
-      insert.run(rel, lang, c.heading, c.content, c.line_start, c.line_end, mtimeMs, segmentCJK(c.content))
-    }
+    _upsertDocFile(memory, rel, lines, mtimeMs)
   }
 }
 
@@ -968,17 +953,7 @@ export async function docSync(memory, dir, { onProgress } = {}) {
     let text
     try { text = await readFile(abs, "utf8") } catch { continue }
     const lines = text.split("\n")
-    const chunks = chunkMarkdown(lines, rel)
-
-    memory.db.prepare(`DELETE FROM doc_chunks WHERE path = ?`).run(rel)
-    const insert = memory.db.prepare(`
-      INSERT INTO doc_chunks (path, language, heading, content, line_start, line_end, mtime_ms, seg_content)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `)
-    const lang = rel.endsWith(".rst") ? "rst" : rel.endsWith(".adoc") ? "asciidoc" : rel.endsWith(".txt") ? "text" : "markdown"
-    for (const c of chunks) {
-      insert.run(rel, lang, c.heading, c.content, c.line_start, c.line_end, mtimeMs, segmentCJK(c.content))
-    }
+    _upsertDocFile(memory, rel, lines, mtimeMs)
     updated++
 
     if (onProgress && i % 10 === 0) {

package/src/provider.mjs

@@ -132,7 +132,7 @@ async function requestWithRetry(provider, body, signal) {
 
     let response
     try {
-      response = await fetch(`${provider.baseURL}/chat/completions`, {
+      response = await fetch(`${provider.baseURL}${provider.chatPath ?? "/chat/completions"}`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",

package/src/tools/bash.md

@@ -12,3 +12,4 @@ Notes:
 - Never use bash to read, copy, or transmit secret files (.env, keys, tokens)
 - Do NOT run destructive commands (rm -rf, force-push, drop table) without explicit user confirmation
 - After commands that change files (git checkout, npm install, etc.), repo_outline and code_search may be stale — re-run them to get current results.
+- Prefer read/glob/grep/ls for file operations inside the project — bash has no directory confinement.

package/src/tools/glob.md

@@ -1,4 +1,4 @@
-Find files by glob pattern (e.g. 'src/**/*.mjs'). Returns matching paths.
+Find files by glob pattern. Returns matching paths. Supports `**` for recursive matching (e.g. `src/**/*.mjs` for all .mjs in src/, `**/*.test.mjs` for all test files).
 
 Parameters:
 - pattern (required): Glob pattern — supports **, *, ?, and character classes

package/src/tools.mjs

@@ -48,6 +48,22 @@ function truncate(text, max = MAX_OUTPUT_CHARS) {
   return text.slice(0, max) + `\n... (truncated, ${text.length - max} chars omitted)`
 }
 
+/** 对单个文件取 git diff，失败静默返回空 */
+function gitDiffOne(cwd, abs) {
+  try {
+    const diff = execFileSync("git", ["--no-pager", "diff", "--no-color", "--", abs], {
+      cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 1024 * 1024,
+    }).trim()
+    if (!diff) return ""
+    // 截断超长 diff（超大文件改动 diff 可能几十 KB），只保留前 200 行
+    const lines = diff.split("\n")
+    if (lines.length <= 200) return diff
+    return lines.slice(0, 200).join("\n") + `\n... (${lines.length - 200} more diff lines)`
+  } catch {
+    return ""
+  }
+}
+
 function resolveInCwd(ctx, p) {
   const resolved = resolve(ctx.cwd, p)
   if (relative(ctx.cwd, resolved).startsWith("..")) throw new Error(`Access denied outside working directory: ${p}`)
@@ -102,7 +118,8 @@ const writeTool = {
     const st = await stat(abs).catch(() => null)
     if (st?.isDirectory()) throw new Error(`Path is a directory: ${abs}`)
     await writeFile(abs, args.content, "utf8")
-    return `Wrote ${args.content.length} chars to ${abs}`
+    const diff = gitDiffOne(ctx.cwd, abs)
+    return `Wrote ${args.content.length} chars to ${abs}${diff ? "\n" + diff : ""}`
   },
 }
 
@@ -127,7 +144,13 @@ const editTool = {
     const content = await readFile(abs, "utf8")
     const occurrences = content.split(args.old_string).length - 1
     if (occurrences === 0) {
-      throw new Error(`old_string not found in ${abs}`)
+      // 给出线索帮模型定位：首行预览 + 常见原因
+      const preview = args.old_string.slice(0, 100).split("\n")[0]
+      throw new Error(
+        `old_string not found in ${abs}\n` +
+        `  searched: "${preview}${args.old_string.length > 100 ? "…" : ""}"\n` +
+        `  hints: whitespace mismatch? file already changed? try reading the file first`
+      )
     }
     if (occurrences > 1 && !args.replace_all) {
       throw new Error(`old_string matches ${occurrences} times in ${abs}; provide more context or set replace_all`)
@@ -136,7 +159,8 @@ const editTool = {
       ? content.split(args.old_string).join(args.new_string)
       : content.replace(args.old_string, args.new_string)
     await writeFile(abs, updated, "utf8")
-    return `Edited ${abs}: replaced ${args.replace_all ? occurrences : 1} occurrence(s)`
+    const diff = gitDiffOne(ctx.cwd, abs)
+    return `Edited ${abs}: replaced ${args.replace_all ? occurrences : 1} occurrence(s)${diff ? "\n" + diff : ""}`
   },
 }
 
@@ -272,7 +296,7 @@ const globTool = {
   },
   readonly: true,
   async execute(args, ctx) {
-    const base = resolve(ctx.cwd, args.path ?? ".")
+    const base = resolveInCwd(ctx, args.path ?? ".")
     const regex = globToRegex(args.pattern)
     const results = []
     for await (const relPath of walkFiles(base)) {
@@ -336,7 +360,7 @@ const grepTool = {
   },
   readonly: true,
   async execute(args, ctx) {
-    const base = resolve(ctx.cwd, args.path ?? ".")
+    const base = resolveInCwd(ctx, args.path ?? ".")
     const regex = new RegExp(args.pattern)
     const fileFilter = args.glob ? globToRegex(args.glob) : null
     const matches = []
@@ -461,7 +485,7 @@ const lsTool = {
   },
   readonly: true,
   async execute(args, ctx) {
-    const abs = resolve(ctx.cwd, args.path ?? ".")
+    const abs = resolveInCwd(ctx, args.path ?? ".")
     const entries = await readdir(abs, { withFileTypes: true })
     const rows = await Promise.all(
       entries.slice(0, 500).map(async (e) => {

package/src/tui.mjs

@@ -265,20 +265,28 @@ export async function startTUI(agent, opts = {}) {
     processing: false,
     controller: null, // AbortController for current agent run
     permission: null, // { name, args, resolve }
+    permissionPreview: [], // 权限审批的内容预览行（渲染在输入框上方，不分隔）
     question: null, // { text, options, resolve } — agent 的 question 工具回调
     picker: null, // 模型选择器 { entries, lines, index, scroll, selectedLine }
     wizard: null, // 首次配置向导 { step, index, scroll, selectedLine, fields, error, lines }
-    tasks: agent.tasks ?? [], // task 工具的任务列表（状态栏显示进度）；会话恢复时直接带上
+    tasks: agent.tasks ?? [], // task 工具的任务列表（状态栏显示进度）；会话恢复时直接带上，全完成自动收起
     tokens: { prompt: 0, completion: 0, cacheHit: 0, cacheMiss: 0 }, // 累计 token 用量（状态栏显示）
     ctxCache: { len: -1, tokens: 0 }, // 上下文占用估算缓存（estimateTokens 是 O(n)，history 变长才重算）
     reasoning: "", // 思考流缓冲（暗色展示）
     completion: null, // Tab 补全状态 { candidates, index }
     toolStreams: {}, // 各工具的实时输出（按工具名隔离，并行工具互不串扰）
+    subOutput: "", // 子 agent 流式输出（滚动显示，最长保留末尾 300 字符）
+    currentSub: null, // 当前活跃的子 agent 角色名
     currentTool: null, // 正在执行的工具名（状态栏显示）
     processingStarted: 0, // 本轮处理开始时间（状态栏计时）
     status: "Ready",
   }
 
+  // 恢复的会话如果所有任务已完成，自动收起 todo 面板（对齐运行时行为）
+  if (state.tasks.length > 0 && state.tasks.every((t) => t.status === "done")) {
+    state.tasks = []
+  }
+
   // 输入流先过一道滤网：鼠标序列（滚轮）在这里拦截处理，剥净后才交给 keypress 解析，
   // 防止序列残片（如 "64;72;42M"）漏进输入框
   const keyStream = new PassThrough()
@@ -424,7 +432,11 @@ export async function startTUI(agent, opts = {}) {
       visibleTasks = [...inProgress, ...pending, ...done].slice(0, MAX_TASK_LINES)
     }
     const taskPanelH = visibleTasks.length
-    const convH = Math.max(1, rows - headerH - inputBoxH - statusH - pickerH - taskPanelH)
+    // 子 agent 流式输出占位（显示时占最多 2 行）
+    const subOutLen = (state.subOutput && state.processing) ? wrapText(state.subOutput, W - 8).slice(-2).length : 0
+    // 权限预览占位
+    const permPreviewLen = state.permission ? 1 + state.permissionPreview.reduce((s, l) => s + wrapText(`  ${l}`, W - 1).length, 0) : 0
+    const convH = Math.max(1, rows - headerH - inputBoxH - statusH - pickerH - taskPanelH - subOutLen - permPreviewLen)
 
     // 对话区内容行（含流式缓冲）；markdown 表格先按显示宽度重排
     const convLines = []
@@ -498,6 +510,25 @@ export async function startTUI(agent, opts = {}) {
       out.push(`${color} ${mark} ${sliceByWidth(t.title, cols - 4)}${ansi.reset}${ansi.clearLine}`)
     }
 
+    // 子 agent 流式输出（最多 2 行，滚动显示最新内容）
+    if (state.subOutput && state.processing) {
+      const lines = wrapText(state.subOutput, W - 8)
+      const tail = lines.slice(-2)
+      for (const l of tail) {
+        out.push(`${C.dim}[${state.currentSub}] ${l}${ansi.reset}${ansi.clearLine}`)
+      }
+    }
+
+    // 权限审批内容预览（黄色，紧挨输入框上方）
+    if (state.permission) {
+      out.push(`${ansi.bold}${C.warn}❯ 权限请求${ansi.reset}${ansi.clearLine}`)
+      for (const line of state.permissionPreview) {
+        for (const wrapped of wrapText(`  ${line}`, W - 1)) {
+          out.push(`${C.warn}${wrapped}${ansi.reset}${ansi.clearLine}`)
+        }
+      }
+    }
+
     // 输入框（全边框，宽 W）
     let borderColor = C.tool
     let title
@@ -571,7 +602,7 @@ export async function startTUI(agent, opts = {}) {
       }
     } else {
       const taskHint = state.tasks.length > 0
-        ? ` │ ▶${state.tasks.filter((t) => t.status === "done").length}/${state.tasks.length}`
+        ? ` │ ✓${state.tasks.filter((t) => t.status === "done").length}/${state.tasks.length}`
         : ""
       // token 用量：↑输入 ↓输出 + 缓存命中率（DeepSeek usage 带 prompt_cache_hit/miss_tokens）
       const tk = state.tokens
@@ -666,6 +697,14 @@ export async function startTUI(agent, opts = {}) {
 
     const callbacks = {
       onToken: (t) => {
+        // 子 agent 流式输出：前缀匹配 explore/coder/plan 的 token 进 subOutput
+        const subMatch = t.match(/^(explore|coder|plan)\//)
+        if (subMatch) {
+          state.currentSub = subMatch[1]
+          state.subOutput = (state.subOutput + t.slice(subMatch[0].length)).slice(-300)
+          scheduleRender()
+          return
+        }
         ensureAssistantLabel()
         state.streaming += t
         scheduleRender()
@@ -683,14 +722,27 @@ export async function startTUI(agent, opts = {}) {
       },
       onToolResult: (name, result) => {
         state.currentTool = null
+        // 子 agent 结束：清空流式缓冲，报告进对话区
+        const isSubagent = name.startsWith("explore/") || name.startsWith("coder/") || name.startsWith("plan/")
+        if (isSubagent) {
+          state.subOutput = ""
+          state.currentSub = null
+          // 子 agent 报告摘要（最多 8 行）直接展示在对话区
+          const lines = result.split("\n")
+          const preview = lines.slice(0, 8).map((l) => l.slice(0, 120)).join("\n")
+          if (preview) pushLine(preview, C.dim)
+          if (lines.length > 8) pushLine(`  ... (${lines.length - 8} more lines)`, C.dim)
+        }
         const stream = state.toolStreams[name]
         if (stream) {
           const tail = stream.trimEnd().slice(-4000)
           if (tail) pushLine(tail, C.dim)
           delete state.toolStreams[name]
         }
-        const first = result.split("\n")[0]
-        pushLine(`  [done] ${name} → ${sliceByWidth(first, 100)}`, C.dim)
+        if (!isSubagent) {
+          const first = result.split("\n")[0]
+          pushLine(`  [done] ${name} → ${sliceByWidth(first, 100)}`, C.dim)
+        }
       },
       onToolOutput: (name, chunk) => {
         state.toolStreams[name] = (state.toolStreams[name] ?? "") + chunk
@@ -798,10 +850,8 @@ export async function startTUI(agent, opts = {}) {
       pushLine(`  [auto] ${name} ${summarize(args)}`, C.warn)
       return Promise.resolve(true)
     }
-    // 把关键参数摆出来：批什么要让人看明白
-    // 内容行用警告色——与正常输出（白）区分，滚动回看也能认出这是待审批内容
-    pushLabel(`❯ 权限请求`, ansi.bold + C.warn)
-    for (const line of formatPermission(name, args)) pushLine(`  ${line}`, C.warn)
+    // 预览内容存到 permissionPreview，渲染在输入框上方紧挨"Allow?"提示
+    state.permissionPreview = formatPermission(name, args)
     return new Promise((resolve) => {
       state.permission = { name, args, resolve }
       state.status = `Waiting: ${name}`
@@ -918,6 +968,10 @@ export async function startTUI(agent, opts = {}) {
               ? data.display.map((l) => ({ text: l.text, color: l.color }))
               : []
             state.tasks = agent.tasks ?? []
+            // 切换过来的会话如果任务全完成，自动收起面板
+            if (state.tasks.length > 0 && state.tasks.every((t) => t.status === "done")) {
+              state.tasks = []
+            }
             pushLabel(`── 已切换到槽位 ${slotNum}（${data.history.length} 条消息）──`, C.warn)
             render()
           }
@@ -1226,12 +1280,23 @@ export async function startTUI(agent, opts = {}) {
         // ---- /think on / off ----
         if (sub === "on" || sub === "off") {
           const enable = sub === "on"
-          cur.thinking = enable ? { type: "enabled" } : { type: "disabled" }
-          if (!enable) delete cur.reasoningEffort
-          else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
-          await syncProviderField("thinking", cur.thinking)
-          if (!enable) await syncProviderField("reasoningEffort", undefined)
-          else await syncProviderField("reasoningEffort", cur.reasoningEffort)
+          // 仅用 reasoning_effort 的模型（K3）：不碰 thinking 字段，只设/删 reasoningEffort
+          const { specForModel } = await import("./config.mjs")
+          const spec = specForModel(cur.model)
+          if (spec.thinkApi === "effort") {
+            // 仅用 reasoning_effort 的模型（K3 / Qwen）：不碰 thinking 字段
+            if (!enable) delete cur.reasoningEffort
+            else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+            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"
+            await syncProviderField("thinking", cur.thinking)
+            if (!enable) await syncProviderField("reasoningEffort", undefined)
+            else await syncProviderField("reasoningEffort", cur.reasoningEffort)
+          }
           pushLabel(`❯ Think`, ansi.bold + C.tool)
           pushLine(`思维模式已${enable ? "开启" : "关闭"}`, C.tool)
           if (enable) pushLine(`推理强度: ${cur.reasoningEffort}`, C.dim)
@@ -1864,6 +1929,7 @@ export async function startTUI(agent, opts = {}) {
       if (validKeys.includes(answer) || key.name === "escape") {
         const { resolve, name } = state.permission
         state.permission = null
+        state.permissionPreview = []
         state.status = "Processing..."
         if (answer === "a" && !isContinue) {
           agent.autoApprove = true
@@ -2076,8 +2142,9 @@ export async function startTUI(agent, opts = {}) {
     }
 
     // 可打印字符 / 粘贴（str 可能一次多个字符）；Tab 一律转成两个空格（\t 显示宽度不定，会顶破输入框）
+    // \r\n 在 Windows raw mode 下可能漏进来冲乱页面
     if (str && !key.ctrl && !key.meta) {
-      const chars = [...str.replace(/\r/g, "").replace(/\t/g, "  ")]
+      const chars = [...str.replace(/[\r\n]+/g, "").replace(/\t/g, "  ")]
       state.input.splice(state.cursor, 0, ...chars)
       state.cursor += chars.length
       render()
@@ -2099,7 +2166,9 @@ export async function startTUI(agent, opts = {}) {
     state.lines = [...opts.restored.display.map((l) => ({ text: l.text, color: l.color })), ...state.lines]
     pushLabel(`── 已恢复上次会话（退出前原样回放）；/new 开始新会话 ──`, C.warn)
   } else if (opts.restored?.history?.length) {
-    for (const m of opts.restored.history) {
+    // 重建对话区：user/assistant 消息逐条展示，tool 结果行只保留首行摘要
+    for (let i = 0; i < opts.restored.history.length; i++) {
+      const m = opts.restored.history[i]
       if (m.role === "user") {
         if (typeof m.content === "string" && m.content.startsWith("[System reminder:")) continue
         pushLabel(`❯ You:`, ansi.bold + C.user)
@@ -2108,10 +2177,14 @@ export async function startTUI(agent, opts = {}) {
         pushLabel(`❯ ThinCoder:`, ansi.bold + C.assistant)
         if (typeof m.content === "string" && m.content) pushLine(m.content, C.text)
         for (const tc of m.tool_calls ?? []) {
-          pushLine(`  [tool] ${tc.function?.name ?? "?"}`, C.tool)
+          // 找到下一条对应的 tool 结果，显示首行摘要
+          const toolResult = opts.restored.history[i + 1]
+          const hasResult = toolResult?.role === "tool" && toolResult?.tool_call_id === tc.id
+          const summary = hasResult ? " → " + sliceByWidth(String(toolResult.content).split("\n")[0], 80) : ""
+          pushLine(`  [tool] ${tc.function?.name ?? "?"}${summary}`, C.tool)
         }
       }
-      // tool 角色的结果行省略：调用行已足够还原现场
+      // tool 消息本身不单独渲染——已在 assistant 的 tool_calls 后以摘要形式展示
     }
     pushLabel(`── 已恢复上次会话（${opts.restored.history.length} 条消息）；/new 开始新会话 ──`, C.warn)
   }