thincoder 0.4.0 → 0.5.0

package/src/plan-overlay.md

@@ -0,0 +1,13 @@
+You are a planning subagent. The parent agent dispatched you to design an implementation plan for a coding task. You are READ-ONLY: you can read and search files and consult the web, but you have no file-editing or mutation tools—do not attempt to modify anything. Your deliverable IS the plan itself, returned as your final message.
+
+Guidelines:
+- Before planning, use repo_outline to understand the project structure, doc_search for conventions and design docs, and code_search to locate relevant symbols. Ground the plan in real paths, not guesses.
+- First judge whether you understand the codebase areas the task touches. If not, say so instead of guessing—structure your reply as:
+  1. What you already know from the provided information
+  2. Which open questions would benefit from an explore subagent's investigation (the parent can dispatch one)
+  3. Your plan—preliminary if questions remain, final if context is sufficient
+- Ground the plan in reality: cite real file paths and line numbers, name actual functions and modules. No invented architecture.
+- Make steps concrete and verifiable: each step small enough to check, ordered so dependencies come first.
+- Where a real design choice exists, call out the trade-offs and recommend ONE option with reasoning—don't list possibilities without taking a stance.
+- Keep scope minimal: the plan should solve the task, not redesign the codebase.
+- If something is ambiguous, note it in the plan; do not ask the user.

package/src/provider.mjs

@@ -2,10 +2,14 @@
  * provider.mjs — LLM 调用层
  * 原生 fetch 直连 OpenAI 兼容协议，SSE 流式，零依赖。
  * 覆盖：OpenAI / DeepSeek / Moonshot / Ollama / 一切 OpenAI 兼容端点。
+ * 模型私有能力（Kimi/Qwen Partial Mode、DeepSeek Prefix Completion）由 config.mjs 的规格表声明，这里只按能力开关分支。
  */
 
+import { specForModel } from "./config.mjs"
+
 export const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504])
 const MAX_RETRIES = 3
+const MAX_CONTINUATIONS = 3 // Partial Mode 截断续写上限（防异常的无限 length 循环）
 
 /**
  * 创建 provider。config: { baseURL, apiKey, model, maxTokens?, temperature?, thinking?, reasoningEffort? }
@@ -34,6 +38,13 @@ export function createProvider(config) {
  * signal: AbortSignal（可选）
  * 返回 { content, reasoning, toolCalls: [{id, name, arguments}], usage, finishReason }
  * 注意：toolCalls[i].arguments 是 JSON 字符串，调用方负责 parse
+ *
+ * 截断续写（按规格表能力门控，未声明的模型原样返回截断结果）：
+ * finish_reason=length 且已有正文时，把已输出内容作为前缀 assistant 消息回传，
+ * 模型接着续写而非丢弃重跑。思考阶段被截断（content 为空）时无前缀可续，直接返回。
+ * - partialMode（Kimi / Qwen）：assistant 消息带 partial:true；K3 思考续写需回传 reasoning_content
+ * - prefixMode（DeepSeek）：assistant 消息带 prefix:true，且须走 /beta 端点；
+ *   思考模式不支持前缀续写，已产出 reasoning 时放弃续写
  */
 export async function chat(provider, { messages, tools, onToken, onReasoning, signal }) {
   const body = {
@@ -49,7 +60,51 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, si
   if (tools?.length) body.tools = tools
 
   const response = await requestWithRetry(provider, body, signal)
-  return readSSE(response, { onToken, onReasoning })
+  const result = await readSSE(response, { onToken, onReasoning })
+
+  // 截断续写：仅规格表声明续写协议的模型（其他端点不认识 partial/prefix 字段，可能 400）
+  const spec = specForModel(provider.model)
+  if (!spec.partialMode && !spec.prefixMode) return result
+  // DeepSeek prefix 续写不支持思考模式，已产出 reasoning 时无前缀协议可用
+  if (spec.prefixMode && !spec.partialMode && result.reasoning) return result
+  for (let n = 0; result.finishReason === "length" && result.content && n < MAX_CONTINUATIONS; n++) {
+    const continued = await chat(spec.prefixMode ? { ...provider, baseURL: betaBaseURL(provider.baseURL) } : provider, {
+      messages: [
+        ...messages,
+        spec.partialMode
+          ? {
+              role: "assistant",
+              content: result.content,
+              partial: true,
+              // K3 思考模式续写必须回传 reasoning_content
+              ...(result.reasoning ? { reasoning_content: result.reasoning } : {}),
+            }
+          : { role: "assistant", content: result.content, prefix: true },
+      ],
+      tools,
+      onToken,
+      onReasoning,
+      signal,
+    })
+    result.content += continued.content
+    result.reasoning += continued.reasoning ?? ""
+    for (const tc of continued.toolCalls ?? []) {
+    if (tc.index == null) { result.toolCalls = continued.toolCalls; break }
+    const s = result.toolCalls[tc.index] ??= { id: "", name: "", arguments: "" }
+    if (tc.id) s.id = tc.id
+    s.name += tc.name ?? ""
+    s.arguments += tc.arguments ?? ""
+  }
+    result.finishReason = continued.finishReason
+    if (continued.usage) {
+    result.usage = {
+      prompt_tokens: (result.usage?.prompt_tokens??0) + (continued.usage.prompt_tokens??0),
+      completion_tokens: (result.usage?.completion_tokens??0) + (continued.usage.completion_tokens??0),
+      total_tokens: (result.usage?.total_tokens??0) + (continued.usage.total_tokens??0),
+    }
+  }
+  }
+  return result
 }
 
 /**
@@ -111,11 +166,7 @@ async function readSSE(response, { onToken, onReasoning }) {
   const decoder = new TextDecoder()
   let buffer = ""
 
-  for await (const chunk of response.body) {
-    buffer += decoder.decode(chunk, { stream: true })
-    const lines = buffer.split("\n")
-    buffer = lines.pop() // 最后半行留到下一轮
-
+  const processLines = (lines) => {
     for (const line of lines) {
       if (!line.startsWith("data:")) continue
       const data = line.slice(5).trim()
@@ -151,9 +202,25 @@ async function readSSE(response, { onToken, onReasoning }) {
       }
     }
   }
+
+  if (!response.body) throw new Error("No stream response body")
+    for await (const chunk of response.body) {
+    buffer += decoder.decode(chunk, { stream: true })
+    const lines = buffer.split("\n")
+    buffer = lines.pop() // 最后半行留到下一轮
+    processLines(lines)
+  }
+  // flush 解码器内部残留（流以不完整 UTF-8 序列截断时不丢尾部字节），并处理没有换行结尾的尾行
+  buffer += decoder.decode()
+  processLines(buffer.split("\n"))
   return result
 }
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
+
+/** DeepSeek Prefix Completion 只在 /beta 端点开放：.../v1 → .../beta */
+function betaBaseURL(baseURL) {
+  return baseURL.replace(/\/v1$/, "/beta")
+}

package/src/repomap.mjs

@@ -0,0 +1,204 @@
+/**
+ * repomap.mjs — 仓库依赖大纲（零依赖，纯 regex）
+ * 实时解析 import/export 关系，生成紧凑文本给 LLM 理解代码结构。
+ * 不存索引——每次调用读文件解析，~50ms 完成。
+ */
+import { readFileSync, existsSync } from "node:fs"
+import { join } from "node:path"
+
+/** 提取 JS/TS 文件的 import 路径（去掉 .ts/.js/.mjs 后缀统一） */
+function parseImports(lines, ext) {
+  const imports = []
+  const text = lines.join("\n")
+  // 普通 import
+  const re = /import\s+(?:{[^}]*}|\*\s+as\s+\w+|\w+\s*,?\s*(?:{[^}]*})?)\s*from\s*['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]/g
+  let m
+  while ((m = re.exec(text))) {
+    const raw = m[1] || m[2]
+    if (!raw || raw.startsWith("node:") || !raw.startsWith(".")) continue
+    imports.push(normalizeExt(raw))
+  }
+  // re-export: export { x } from './module'
+  const reExportRe = /export\s*\{[^}]*\}\s*from\s*['"]([^'"]+)['"]/g
+  while ((m = reExportRe.exec(text))) {
+    const raw = m[1]
+    if (!raw || raw.startsWith("node:") || !raw.startsWith(".")) continue
+    imports.push(normalizeExt(raw))
+  }
+  return [...new Set(imports)]
+}
+
+/** 提取 JS/TS 文件的 export 符号 */
+function parseExports(lines, ext) {
+  const exports = []
+  const text = lines.join("\n")
+  // export function/class/const/let/var name
+  const namedRe = /export\s+(?:async\s+)?(?:function\s+(\w+)|class\s+(\w+)|(?:const|let|var)\s+(\w+))/g
+  let m
+  while ((m = namedRe.exec(text))) {
+    exports.push(m[1] || m[2] || m[3])
+  }
+  // export default function/class name / export default expression
+  const defaultRe = /export\s+default\s+(?:(?:async\s+)?(?:function\s+(\w+)|class\s+(\w+))|(\w+))/g
+  while ((m = defaultRe.exec(text))) {
+    const name = m[1] || m[2] || m[3]
+    if (name) exports.push(name)
+    else if (!exports.some((e) => e === "default")) exports.push("default")
+  }
+  // export { a, b as c } —— 优先取 as 后的导出名
+  const braceRe = /export\s*\{([^}]+)\}/g
+  while ((m = braceRe.exec(text))) {
+    for (const name of m[1].split(",")) {
+      const parts = name.trim().split(/\s+/)
+      // "a as b" → b（导出名），"a" → a
+      const exported = parts.length >= 3 ? parts[2] : parts[0]
+      if (exported) exports.push(exported)
+    }
+  }
+  // export const { a, b } = ...（解构导出）
+  const destructRe = /export\s+(?:const|let|var)\s*\{([^}]+)\}\s*=/g
+  while ((m = destructRe.exec(text))) {
+    for (const name of m[1].split(",")) {
+      const parts = name.trim().split(/\s*:\s*/)
+      const n = parts[0].trim()
+      if (n) exports.push(n)
+    }
+  }
+  return [...new Set(exports)]
+}
+
+/** 提取 Python 的 import 和顶层 def/class */
+function parsePyOutline(lines) {
+  const imports = []
+  const symbols = []
+  for (const line of lines) {
+    const fromRe = line.match(/^from\s+(\S+)\s+import\s+(.+)/)
+    if (fromRe) {
+      const mod = fromRe[1]
+      if (!mod.startsWith(".")) continue // 只本地
+      imports.push(normalizeExt(mod.replace(/^\.+/, "")))
+      continue
+    }
+    const impRe = line.match(/^import\s+(.+)/)
+    if (impRe) {
+      for (const mod of impRe[1].split(",")) {
+        const m = mod.trim().split(/\s+/)[0]
+        if (!m.startsWith(".")) continue
+        imports.push(normalizeExt(m.replace(/^\.+/, "")))
+      }
+      continue
+    }
+    const defRe = line.match(/^(?:async\s+)?(?:def|class)\s+(\w+)/)
+    if (defRe) symbols.push(defRe[1])
+  }
+  return { imports: [...new Set(imports)], symbols: [...new Set(symbols)] }
+}
+
+function normalizeExt(p) {
+  return p.replace(/\.(m?js|jsx|tsx?)$/i, "")
+}
+
+/** 从 code_chunks 取已知文件列表（复用索引），按路径解析生成大纲文本 */
+export function buildOutline(db, cwd, focusPath) {
+  const allFiles = db.prepare(`SELECT DISTINCT path FROM code_chunks ORDER BY path`).all().map((r) => r.path)
+
+  if (allFiles.length === 0) return "(no indexed source files; run codeSync or /reindex first)"
+
+  // 构建正向（谁 import 谁）+ 反向（被谁 import）图——总是全量扫描，
+  // 因为聚焦一个文件也需要知道别的文件是否 import 了它
+  const deps = new Map()      // path → { imports: Set, exports: Set, size: number }
+  const importers = new Map() // importee → Set<importer>
+
+  for (const rel of allFiles) {
+    const abs = join(cwd, ...rel.split("/"))
+    if (!existsSync(abs)) continue
+    const text = readFileSync(abs, "utf8")
+    const lines = text.split("\n")
+    const ext = rel.slice(rel.lastIndexOf(".")).toLowerCase()
+
+    let imports, exports
+    if (ext === ".py") {
+      const py = parsePyOutline(lines)
+      imports = py.imports
+      exports = py.symbols
+    } else {
+      imports = parseImports(lines, ext)
+      exports = parseExports(lines, ext)
+    }
+
+    // 把 import 路径解析成相对路径（处理 ./ ../）
+    const resolved = []
+    for (let imp of imports) {
+      // 去掉 ./ 前缀
+      if (imp.startsWith("./")) imp = imp.slice(2)
+      const dir = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : ""
+      const parts = imp.split("/")
+      if (parts[0] === "..") {
+        const up = dir.split("/").filter(Boolean)
+        let i = 0
+        while (parts[i] === ".." && up.length > 0) { up.pop(); i++ }
+        resolved.push([...up, ...parts.slice(i)].join("/"))
+      } else {
+        resolved.push(dir ? `${dir}/${imp}` : imp)
+      }
+    }
+
+    deps.set(rel, { imports: new Set(resolved), exports: new Set(exports), size: Math.floor(text.length / 1024) })
+
+    for (const r of resolved) {
+      if (!importers.has(r)) importers.set(r, new Set())
+      importers.get(r).add(rel)
+    }
+  }
+
+  // 生成文本
+  const files = focusPath ? [focusPath] : [...deps.keys()]
+  const out = []
+  const sorted = files.sort()
+  for (const rel of sorted) {
+    const d = deps.get(rel)
+    if (!d) continue
+    const parts = []
+    // imported by（匹配时去掉扩展名，因为 import 路径通常不含 .mjs/.js 后缀）
+    const key = rel.replace(/\.(m?js|jsx|tsx?)$/i, "")
+    const rev = importers.get(key)
+    if (rev?.size) parts.push(`← imported by: ${[...rev].join(", ")}`)
+    // imports
+    if (d.imports.size) parts.push(`→ imports: ${[...d.imports].join(", ")}`)
+    // exports
+    if (d.exports.size) parts.push(`→ exports: ${[...d.exports].join(", ")}`)
+
+    const kb = d.size > 0 ? ` (${d.size} KB)` : ""
+    if (parts.length) {
+      out.push(`${rel}${kb}\n  ${parts.join("\n  ")}`)
+    } else {
+      out.push(`${rel}${kb}`)
+    }
+  }
+
+  return out.join("\n")
+}
+
+/**
+ * 生成 repo_outline 工具（只读）。
+ * 需要 memory.db（复用 code_chunks 文件列表）和 cwd。
+ */
+export function repoOutlineTool(db, cwd) {
+  return {
+    name: "repo_outline",
+    description:
+      "Show the project's file dependency outline: which files import/export from which, and what symbols they export. Use when you need to understand the project structure, find where a function is defined, or see what files depend on a module. Pass a path to focus on a single file's relationships.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Optional: focus on a specific file path (relative to project root)" },
+      },
+      required: [],
+    },
+    readonly: true,
+    async execute(args) {
+      const outline = buildOutline(db, cwd, args.path ?? null)
+      return outline
+    },
+  }
+}

package/src/session.mjs

@@ -1,37 +1,142 @@
 /**
  * session.mjs — 会话持久化
- * 每个项目（按 cwd 哈希）保存最近一个会话到 ~/.thincoder/sessions/。
- * 退出时存、启动时恢复；agent.history 本来就是可 JSON 序列化的。
+ * 每个项目（按 cwd 哈希）最多保留 5 轮会话，按最后使用时间轮转。
+ * 两种恢复需求分开存：agent 恢复（history）要上下文连续，用户恢复（display）要所见即所得。
+ *
+ * 文件布局：{hash}.json（当前）、{hash}.json.1~5（槽位）、{hash}.json.manifest（槽位元数据）
  */
 
 import { createHash } from "node:crypto"
-import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs"
+import { mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, unlinkSync, existsSync } from "node:fs"
 import { join, dirname } from "node:path"
 import { configDir } from "./config.mjs"
 
+const MAX_SLOTS = 5
+
 export function sessionPath(cwd) {
   const hash = createHash("sha1").update(cwd).digest("hex").slice(0, 12)
   return join(configDir, "sessions", `${hash}.json`)
 }
 
-/** 保存会话（同步：退出清理路径也能用） */
-export function saveSession(agent) {
+function slotPath(cwd, n) { return sessionPath(cwd) + "." + n }
+function manifestPath(cwd) { return sessionPath(cwd) + ".manifest" }
+
+/** 原子写：先写临时文件再替换，防写入中途崩溃留下截断的 JSON 丢整个会话。
+ *  不用 renameSync：Windows rename 目标已存在抛 EPERM */
+function writeSessionFile(p, data) {
+  mkdirSync(dirname(p), { recursive: true })
+  const tmp = `${p}.tmp`
+  writeFileSync(tmp, JSON.stringify(data), "utf8")
+  try { unlinkSync(p) } catch { /* 旧文件不存在就算了 */ }
+  renameSync(tmp, p)
+}
+
+// ========== 槽位管理 ==========
+
+function loadManifest(cwd) {
+  try {
+    const p = manifestPath(cwd)
+    if (!existsSync(p)) return { slots: {} }
+    return JSON.parse(readFileSync(p, "utf8"))
+  } catch { return { slots: {} } }
+}
+
+function saveManifest(cwd, m) {
+  writeSessionFile(manifestPath(cwd), m)
+}
+
+/** 归档当前会话到空闲槽位——满了踢最老 */
+export function archiveCurrent(cwd) {
+  const src = sessionPath(cwd)
+  if (!existsSync(src)) return
+  const m = loadManifest(cwd)
+
+  let slot
+  const entries = Object.entries(m.slots)
+  if (entries.length < MAX_SLOTS) {
+    slot = 1
+    while (m.slots[slot]) slot++
+  } else {
+    slot = Number(entries.sort((a, b) => a[1] - b[1])[0][0])
+  }
+
+  const dst = slotPath(cwd, slot)
+  writeFileSync(dst, readFileSync(src, "utf8"), "utf8") // 复制（rename 会丢当前）
+  m.slots[slot] = Date.now()
+  delete m.slots._currentName
+  saveManifest(cwd, m)
+  return slot
+}
+
+/** 列出所有归档槽位，最新在前 */
+export function listSlots(cwd) {
+  const m = loadManifest(cwd)
+  return Object.entries(m.slots)
+    .map(([n, ts]) => ({ slot: Number(n), timestamp: ts, date: new Date(ts).toLocaleString() }))
+    .sort((a, b) => b.timestamp - a.timestamp)
+}
+
+/** 切换到指定槽位：归档当前 → 槽位文件复制到当前 → 返回恢复数据（失败返回 null） */
+export function switchToSlot(cwd, slot) {
+  const m = loadManifest(cwd)
+  if (!m.slots[slot]) return null
+
+  // 归档当前（内部写 manifest；之后我们的 m 已过期，需重读）
+  archiveCurrent(cwd)
+
+  // 槽位文件 → 当前（copy+unlink，不用 rename：Windows rename 目标已存在会抛 EPERM）
+  const src = slotPath(cwd, slot)
+  const dst = sessionPath(cwd)
+  if (!existsSync(src)) return null
+  // 先删当前文件（archiveCurrent 是复制不是移动，所以它还在）
+  try { unlinkSync(dst) } catch { /* 不存在就算了 */ }
+  copyFileSync(src, dst)
+  unlinkSync(src)
+
+  // 重读 manifest（archiveCurrent 改了它）
+  const m2 = loadManifest(cwd)
+  delete m2.slots[slot]
+  saveManifest(cwd, m2)
+
+  return loadSession(cwd)
+}
+
+// ========== 旧版 transient 前缀清理 ==========
+
+const LEGACY_TRANSIENT_PREFIXES = [
+  "[System reminder: working directory snapshot:",
+  "[Relevant memories from previous sessions",
+]
+
+function isLegacyTransient(m) {
+  return (
+    m.role === "user" &&
+    typeof m.content === "string" &&
+    LEGACY_TRANSIENT_PREFIXES.some((p) => m.content.startsWith(p))
+  )
+}
+
+// ========== 核心读写 ==========
+
+export function saveSession(agent, display) {
+  const history = agent.history.filter((m) => !m.transient && !isLegacyTransient(m))
   const data = {
     version: 2,
     cwd: agent.cwd,
-    activeProvider: agent.provider?.name,
+    activeProvider: agent.activeProvider ?? agent.provider?.name,
     updatedAt: Date.now(),
-    history: agent.history,
+    history,
+    display: display ?? [],
     tasks: agent.tasks ?? [],
     planMode: agent.planMode ?? false,
+    autoApprove: agent.autoApprove ?? false,
     goal: agent.goal ?? null,
+    pendingReminders: agent._pendingReminders ?? [],
+    sessionStart: agent._sessionStart ?? null,
   }
-  const p = sessionPath(agent.cwd)
-  mkdirSync(dirname(p), { recursive: true })
-  writeFileSync(p, JSON.stringify(data), "utf8")
+  writeSessionFile(sessionPath(agent.cwd), data)
 }
 
-/** 恢复会话。没有或损坏返回 null */
 export function loadSession(cwd) {
   try {
     const p = sessionPath(cwd)
@@ -39,17 +144,39 @@ export function loadSession(cwd) {
     const data = JSON.parse(readFileSync(p, "utf8"))
     if (data?.version !== 1 && data?.version !== 2) return null
     if (!Array.isArray(data.history)) return null
+    if (data.cwd && data.cwd.toLowerCase() !== cwd.toLowerCase()) return null
+    data.history = data.history.filter((m) => !isLegacyTransient(m))
+    data.display = Array.isArray(data.display)
+      ? data.display.filter((l) => l && typeof l.text === "string").map((l) => ({ text: l.text, color: l.color }))
+      : []
     return data
-  } catch {
-    return null
+  } catch { return null }
+}
+
+export function applySession(agent, data) {
+  agent.history = data.history
+  agent.tasks = data.tasks ?? []
+  agent.planMode = data.planMode ?? false
+  agent.autoApprove = data.autoApprove ?? false
+  agent.goal = data.goal ?? null
+  agent._pendingReminders = data.pendingReminders ?? []
+  agent._sessionStart = data.sessionStart ?? null
+  if (data.activeProvider && data.activeProvider !== agent.activeProvider) {
+    const p = agent.providers?.find((pr) => pr.name === data.activeProvider)
+    if (p) {
+      agent.provider = { ...p }
+      agent.activeProvider = p.name
+      return true
+    }
   }
+  return false
 }
 
-/** 清空会话（/new） */
 export function clearSession(cwd) {
   try {
+    archiveCurrent(cwd)
     const p = sessionPath(cwd)
-    if (existsSync(p)) writeFileSync(p, JSON.stringify({ version: 2, cwd, history: [], tasks: [] }), "utf8")
+    writeSessionFile(p, { version: 2, cwd, history: [], tasks: [], display: [], goal: null, autoApprove: false, pendingReminders: [], sessionStart: null })
   } catch {
     // 清不掉就算了，下次保存会覆盖
   }

package/src/skills.mjs

@@ -50,13 +50,14 @@ export async function loadSkills(cwd) {
 /**
  * 生成技能列表文本，注入 system prompt。
  * 最多 3 个（占位少），超过则标 "... and N more"。
+ * 以 DISREGARD 开头：清单刷新（技能增删）后旧清单自动作废，无需删历史（借鉴 kimi-code）。
  */
 export function formatSkillListing(skills) {
   if (skills.length === 0) return ""
   const listed = skills.slice(0, 3)
   const lines = listed.map((s) => `- **${s.name}**: ${s.description}`)
   if (skills.length > 3) lines.push(`  ... and ${skills.length - 3} more`)
-  return "Available skills (use the skill tool to load one):\n" + lines.join("\n")
+  return "DISREGARD any earlier skill listings. Current available skills (use the skill tool to load one):\n" + lines.join("\n")
 }
 
 /**

package/src/tools/bash.md

@@ -11,3 +11,4 @@ Notes:
 - On Windows, use Unix shell syntax inside bash commands (Git Bash): forward slashes, `/dev/null` not `NUL`
 - 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.

package/src/tools.mjs

@@ -15,7 +15,9 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 const DESC = (name) => readFileSync(join(__dirname, "tools", `${name}.md`), "utf8")
 
 const MAX_READ_LINES = 2000
-const MAX_OUTPUT_CHARS = 50_000
+// 输出上限只是内存安全阀：超过 16k 的输出由 agent 层 offload 整体落盘（全量保留、预览+路径回喂），
+// 这里截断必须远高于落盘阈值，否则被截掉的内容在落盘前就永远丢了
+const MAX_OUTPUT_CHARS = 200_000
 const BASH_TIMEOUT_MS = 120_000
 const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "build", ".turbo", "coverage"])
 
@@ -36,7 +38,7 @@ export function toOpenAISchema(tool) {
 /** 剥离 ANSI 转义序列（vim/less/颜色码会冲花 TUI 渲染），并把 \r 进度条改写转成换行 */
 function sanitizeOutput(s) {
   return s
-    .replace(/\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][0-9A-B]|\x1b[=>#][0-9]?/g, "")
+    .replace(/\x1b\[[0-9;?]*[\x40-\x7E]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][0-9A-B]|\x1b[=>#][0-9]?/g, "")
     .replace(/\r\n/g, "\n")
     .replace(/\r/g, "\n")
 }
@@ -47,7 +49,9 @@ function truncate(text, max = MAX_OUTPUT_CHARS) {
 }
 
 function resolveInCwd(ctx, p) {
-  return resolve(ctx.cwd, p)
+  const resolved = resolve(ctx.cwd, p)
+  if (relative(ctx.cwd, resolved).startsWith("..")) throw new Error(`Access denied outside working directory: ${p}`)
+  return resolved
 }
 
 // ---------------------------------------------------------------- read
@@ -95,6 +99,8 @@ const writeTool = {
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
     await mkdir(dirname(abs), { recursive: true })
+    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}`
   },
@@ -149,6 +155,20 @@ const bashTool = {
   },
   readonly: false,
   async execute(args, ctx) {
+    // 安全预检：销毁性 git 操作（checkout -- / reset --hard）先检查未提交改动，
+    // 有则拒绝——防一键清掉几小时工作（像今天 git checkout -- 六个文件那次）
+    const DESTRUCTIVE_GIT = /^git\s+(?:checkout\s+--?\s+|reset\s+--hard\b)/
+    if (DESTRUCTIVE_GIT.test(args.command)) {
+      const status = execFileSync("git", ["status", "--porcelain"], {
+        cwd: ctx.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"],
+      }).trim()
+      if (status) {
+        throw new Error(
+          `Refusing destructive git command: uncommitted changes exist. Commit or stash first.\n\n${status}`
+        )
+      }
+    }
+
     return new Promise((resolve) => {
       const child = spawn(args.command, {
         cwd: ctx.cwd,
@@ -170,6 +190,8 @@ const bashTool = {
       // 编码嗅探：cmd 自带消息是 GBK，git/node 等程序是 UTF-8，平台判断不了。
       // 策略：纯 ASCII 段两种编码一致，直接透传不判定；遇到高位字节才用
       // fatal UTF-8 试解（容忍尾部 1~3 字节截断），失败则判 GBK；一经判定不再变更。
+      // 已知边界：GBK 字节流极低概率恰好构成合法 UTF-8 序列，会误判为 UTF-8 产生乱码。
+      // 更严谨的做法是 chcp 探测控制台代码页，但当前策略覆盖 99.9% 场景，不值得那份复杂度。
       let decoder = null
       let pending = Buffer.alloc(0)
       const feed = (d, flush = false) => {
@@ -374,14 +396,16 @@ const websearchTool = {
     required: ["query"],
   },
   readonly: true,
-  async execute(args) {
+  async execute(args, ctx) {
     const limit = args.limit ?? 8
     const url = `https://www.bing.com/search?q=${encodeURIComponent(args.query)}`
     let html
     try {
       const response = await fetch(url, {
         headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" },
-        signal: AbortSignal.timeout(15_000),
+        signal: ctx?.signal
+          ? AbortSignal.any([ctx.signal, AbortSignal.timeout(15_000)])
+          : AbortSignal.timeout(15_000),
       })
       if (!response.ok) throw new Error(`HTTP ${response.status}`)
       html = await response.text()
@@ -471,14 +495,16 @@ const fetchTool = {
     required: ["url"],
   },
   readonly: true,
-  async execute(args) {
+  async execute(args, ctx) {
     if (!/^https?:\/\//.test(args.url)) throw new Error("url must start with http:// or https://")
     let response
     try {
       response = await fetch(args.url, {
         headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" },
         redirect: "follow",
-        signal: AbortSignal.timeout(20_000),
+        signal: ctx?.signal
+          ? AbortSignal.any([ctx.signal, AbortSignal.timeout(20_000)])
+          : AbortSignal.timeout(20_000),
       })
     } catch (error) {
       throw new Error(`fetch failed: ${error.cause?.code ?? error.message}`)