thincoder 0.4.0 → 0.6.0

package/src/coder-overlay.md

@@ -1,9 +1,10 @@
 You are a coding subagent. The parent agent dispatched you to handle a self-contained coding task. The parent CANNOT see your context — it only sees your final report.
 
 Guidelines:
-- Work independently: read files, make edits, run tests
+- Work independently: use repo_outline, code_search, and doc_search to find relevant code before editing. Then read, edit, and run tests.
 - Be thorough: include what you did, which files you changed, why, and any caveats
 - If the task is ambiguous, note the ambiguity in your report; do not ask the user
+- It is always OK to say "this is too hard for me." Bad work is worse than no work — you will not be penalized for escalating
 - BEFORE finishing, verify your changes:
   1. Run the project's tests — confirm they pass
   2. Read every file you changed — catch leftover debug code, stale comments, or incomplete edits

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,34 +46,62 @@ const DEFAULTS = {
 }
 
 /**
- * 已知模型的上下文窗口（前缀匹配，长的在前）。
- * compactThreshold 未显式配置时，按窗口 * COMPACT_RATIO 自动推导。
+ * 已知模型的能力规格表（前缀匹配，长的在前）。
+ * 用于压缩阈值推导、截断续写协议选择、能力感知优化。
+ *
+ * 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_CONTEXT_WINDOWS = [
-  ["deepseek-v4-pro", 1_000_000],
-  ["deepseek-v4-flash", 256_000],
-  ["deepseek-reasoner", 64_000],
-  ["deepseek-chat", 64_000],
-  ["kimi-k3", 256_000],
-  ["kimi-k2", 128_000],
-  ["moonshot", 128_000],
-  ["glm-5", 1_000_000],
-  ["glm-4", 128_000],
-  ["gpt-4.1", 1_000_000],
-  ["gpt-4o", 128_000],
-  ["qwen", 128_000],
+const MODEL_SPECS = [
+  // 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_CONTEXT_WINDOW = 128_000
+const DEFAULT_SPEC = { context: 128_000, maxOutput: 32_000, cacheMode: "none" }
 // 窗口利用率上限：0.8（DeepSeek 内部即全窗口；压缩本身要花一次 LLM 调用，过早压缩是纯浪费。
 // 留 20% 余量给压缩后的尾部增长与输出 token）
 const COMPACT_RATIO = 0.8
 
-export function contextWindowForModel(model) {
+/** 按模型名前缀查规格（大小写不敏感），未知模型给保守默认 */
+export function specForModel(model) {
   const m = (model ?? "").toLowerCase()
-  for (const [prefix, window] of MODEL_CONTEXT_WINDOWS) {
-    if (m.startsWith(prefix)) return window
+  for (const [prefix, spec] of [...MODEL_SPECS].sort((a,b) => b[0].length - a[0].length)) {
+    if (m.startsWith(prefix)) return spec
   }
-  return DEFAULT_CONTEXT_WINDOW
+  return DEFAULT_SPEC
+}
+
+export function contextWindowForModel(model) {
+  return specForModel(model).context
 }
 
 /** 推导压缩阈值；explicit 为配置文件中显式设置的值（优先），否则按模型自动算 */
@@ -140,7 +169,7 @@ export function loadConfig() {
 
   // apiKey 还可用环境变量兜底（当 providers 里没配 key 时）
   // 提供商专用的环境变量只对同名 provider 生效，避免 key 串到错误的端点
-  if (!runtimeProvider.apiKey) {
+  if (!runtimeProvider.apiKey?.trim()) {
     const envMap = { deepseek: "DEEPSEEK_API_KEY", openai: "OPENAI_API_KEY" }
     const keyVar = envMap[merged.activeProvider]
     if (keyVar && process.env[keyVar]) runtimeProvider.apiKey = process.env[keyVar]

package/src/context.mjs

@@ -1,22 +1,30 @@
 /**
  * context.mjs — 上下文管理与压缩
- * token 用 length/4 粗估（不引 tokenizer 依赖）。
+ * token 无实测值时用估算兜底（ASCII/4 + 非 ASCII/1，不引 tokenizer 依赖）；
+ * 有实测值（响应 usage.prompt_tokens）以实测为准——估算对 CJK 低估 3-4 倍，靠它触发可能永远来不及压缩。
  * 压缩策略：保留最早 2 条 + 最近 N 条，中间由 LLM 摘要成一条（学 kimi-code，简化版）。
  */
 
 import { chat } from "./provider.mjs"
 
+/** 粗估一段文本的 token 数：ASCII 约 4 字符 1 token，CJK 等非 ASCII 约 1 字符 1 token */
+function estimateText(s) {
+  let nonAscii = 0
+  for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) > 0x7f) nonAscii++
+  return Math.ceil((s.length - nonAscii) / 4) + nonAscii
+}
+
 /** 粗估一组消息的 token 数（正文 + 思考链 + tool_calls 参数） */
 export function estimateTokens(messages) {
-  let chars = 0
+  let tokens = 0
   for (const m of messages) {
-    if (typeof m.content === "string") chars += m.content.length
-    if (typeof m.reasoning_content === "string") chars += m.reasoning_content.length
+    if (typeof m.content === "string") tokens += estimateText(m.content)
+    if (typeof m.reasoning_content === "string") tokens += estimateText(m.reasoning_content)
     for (const tc of m.tool_calls ?? []) {
-      chars += (tc.function?.name?.length ?? 0) + (tc.function?.arguments?.length ?? 0)
+      tokens += estimateText(tc.function?.name ?? "") + estimateText(tc.function?.arguments ?? "")
     }
   }
-  return Math.ceil(chars / 4)
+  return tokens
 }
 
 const KEEP_HEAD = 2 // 最早的用户意图，不能丢
@@ -24,8 +32,10 @@ const KEEP_TAIL = 10 // 最近的工作现场，不能丢
 
 const SUMMARIZE_PROMPT = `你是一个对话压缩器。把下面的 agent 工作记录压缩成一份紧凑的摘要，供后续对话作为上下文使用。
 要求：
+- 用第一人称、现在时书写——这是"我"的交接笔记，延续自己的思路
 - 保留：用户的原始需求、做出的决策、修改过的文件及原因、未解决的问题、下一步计划
 - 丢弃：客套话、重复内容、工具输出的细枝末节
+- 诚实标注不确定项：没有实际验证过的事必须写"未验证"，不要把猜测写成事实
 - 用中文条目式输出，控制在 500 字以内
 
 工作记录：
@@ -34,64 +44,88 @@ const SUMMARIZE_PROMPT = `你是一个对话压缩器。把下面的 agent 工
 /** 压缩后的上下文前缀，告知 agent 发生了什么 */
 const COMPACTION_PREFIX =
   "[Context was automatically compacted. Below is a summary of earlier work. " +
-  "Trust its conclusions — don't redo what it reports as done — but re-verify " +
-  "transient state (open files, running processes) with tools.]\n\n"
+  "Treat it as notes, not proof — trust its conclusions (don't redo what it reports as done) " +
+  "but re-verify transient state (open files, running processes) with tools before relying on them.]\n\n"
 
-/**
- * 如果历史超长则压缩。返回是否发生了压缩。
- * 只在循环的安全点调用（history 末尾是 user 消息时）。
- * 压缩后自动回注 task 列表状态。
- */
-export async function compressIfNeeded(agent, threshold) {
-  const history = agent.history
-  if (estimateTokens(history) <= threshold) return false
-  if (history.length <= KEEP_HEAD + KEEP_TAIL + 1) return false
+/** 压缩摘要调用连续失败达到此次数后，降级为确定性截断（丢信息好过任务被 400 打死） */
+export const COMPRESS_FAILURE_LIMIT = 3
 
-  // 切分：head / middle(被摘要) / tail
-  // tail 起点必须避开孤儿 tool 消息（其 assistant tool_calls 在 middle 里无妨，middle 会被整体摘要成纯文本）
-  let tailStart = history.length - KEEP_TAIL
-  while (tailStart > KEEP_HEAD && history[tailStart].role === "tool") {
-    tailStart++
-  }
-  if (tailStart <= KEEP_HEAD) return false // 没有可压缩的中间段
+/** task 回注提醒前缀（压缩后重新注入前，先清掉历史里的旧版本，保持单一信息源） */
+const TASK_REINJECT_PREFIX = "[System reminder: your current task list after compaction:"
 
-  const head = history.slice(0, KEEP_HEAD)
-  const middle = history.slice(KEEP_HEAD, tailStart)
-  const tail = history.slice(tailStart)
+/** 截断兜底笔记（摘要 LLM 连续失败时用，无 LLM 调用） */
+const FALLBACK_NOTE =
+  "[Context was truncated after repeated summarization failures. " +
+  "The middle portion of earlier work was dropped WITHOUT a summary. " +
+  "Re-verify any state you need with tools before relying on it.]\n\n"
 
-  const serialized = middle
-    .map((m) => {
-      const toolNote = m.tool_calls ? ` [调用了工具: ${m.tool_calls.map((t) => t.function.name).join(", ")}]` : ""
-      const content = typeof m.content === "string" ? m.content.slice(0, 2000) : ""
-      return `[${m.role}]${toolNote} ${content}`
-    })
-    .join("\n")
+/**
+ * 切分 head / middle(被摘要) / tail；没有可压缩的中间段返回 null。
+ * head 终点必须避开断头 tool_calls：assistant 带了 tool_calls 时其 tool 响应必须留在 head，
+ * 否则响应被摘要成纯文本后协议校验 400（tool_calls must be followed by tool messages）。
+ * tail 起点必须包含 tool 结果对应的 assistant——tool 在 tail、assistant 在 middle 时，
+ * 摘要会把 assistant 吞掉，留下 orphan tool 结果 → 协议 400。
+ */
+function splitHistory(history) {
+  if (history.length <= KEEP_HEAD + KEEP_TAIL + 1) return null
+  let headEnd = KEEP_HEAD
+  while (
+    headEnd < history.length &&
+    history[headEnd - 1].role === "assistant" &&
+    history[headEnd - 1].tool_calls?.length &&
+    history[headEnd].role === "tool"
+  ) {
+    headEnd++
+  }
+  let tailStart = history.length - KEEP_TAIL
 
-  const summary = await chat(agent.provider, {
-    messages: [{ role: "user", content: SUMMARIZE_PROMPT + serialized }],
-  })
+  // tail 区域内的 tool 消息对应的 assistant tool_calls 若在 middle 里，摘要会把 assistant 吞掉，
+  // 剩下 orphan tool 结果 → 协议 400。从 tail 收集 tool_call_id，往前找回所属 assistant 拉进 tail
+  const tailToolIds = new Set()
+  for (let i = tailStart; i < history.length; i++) {
+    if (history[i].role === "tool") tailToolIds.add(history[i].tool_call_id)
+  }
+  for (let i = tailStart - 1; i > headEnd; i--) {
+    const m = history[i]
+    if (m.role === "assistant" && m.tool_calls?.some((tc) => tailToolIds.has(tc.id))) {
+      tailStart = i
+      break
+    }
+  }
 
-  // 摘要正文内嵌 task 快照（对齐 kimi-code 的 postProcessSummary）——
-  // 否则二次压缩时 task 列表会随旧提醒消息一起被摘要器丢掉
-  let compacted = COMPACTION_PREFIX + summary.content
-  if (agent.tasks.length > 0) {
-    const taskSummary = agent.tasks.map((t) => `- [${t.status}] ${t.title}`).join("\n")
-    compacted += `\n\n## Task List\n${taskSummary}`
+  // skip orphan tool messages at the new tail boundary (tool whose assistant was pulled in above)
+  while (tailStart > headEnd && history[tailStart].role === "tool") {
+    tailStart++
   }
+  if (tailStart <= headEnd) return null
+  return { headEnd, tailStart }
+}
 
+/** 用一条笔记替换 middle，并回注 task/plan 状态（LLM 摘要与截断兜底共用） */
+function applyCompression(agent, headEnd, tailStart, note) {
+  const head = agent.history.slice(0, headEnd)
+  const tail = agent.history.slice(tailStart)
   agent.history = [
     ...head,
-    { role: "user", content: compacted },
-    { role: "assistant", content: "Understood. I'll continue from this summary, re-verifying anything transient." },
+    { role: "user", content: note },
+    { role: "assistant", content: "Understood. I'll continue from these notes, re-verifying anything transient." },
     ...tail,
   ]
-
-  // 压缩后回注 task 列表（agent 需要知道自己做到哪了）
+  // 实测 token 基准随旧历史一起失效（prompt_tokens 对应的是压缩前的上下文），退回估算直到下次响应
+  agent._lastPromptTokens = null
+  agent._usageAtLen = null
+
+  // 压缩后回注 task 列表（agent 需要知道自己做到哪了）。
+  // 单一信息源：先清掉 tail 里残留的旧回注，再注入最新版本——
+  // 不再嵌入摘要正文（会与这里重复且逐渐过时）
+  agent.history = agent.history.filter(
+    (m) => !(m.role === "user" && typeof m.content === "string" && m.content.startsWith(TASK_REINJECT_PREFIX))
+  )
   if (agent.tasks.length > 0) {
     const taskSummary = agent.tasks.map((t) => `- [${t.status}] ${t.title}`).join("\n")
     agent.history.push({
       role: "user",
-      content: `[System reminder: your current task list after compaction:\n${taskSummary}\nContinue from where you left off.]`,
+      content: `${TASK_REINJECT_PREFIX}\n${taskSummary}\nContinue from where you left off.]`,
     })
   }
 
@@ -106,6 +140,52 @@ export async function compressIfNeeded(agent, threshold) {
       content: "[System reminder: plan mode is active. Explore the codebase read-only, design your solution, then call plan with action='exit' to present it for user approval.]",
     })
   }
+}
 
+/**
+ * 如果历史超长则压缩。返回是否发生了压缩。
+ * 只在循环的安全点调用（history 末尾是 user 或 tool 消息——完整交换的边界）。
+ * 压缩后自动回注 task 列表状态。
+ */
+export async function compressIfNeeded(agent, threshold) {
+  const history = agent.history
+  // 真实基准优先：上次响应的 prompt_tokens 是完整上下文（system+tools+history）的实测值，
+  // 之后追加的消息用估算补增量；无实测（首轮/恢复后/刚压缩完）退化为纯估算
+  const tokens =
+    agent._lastPromptTokens != null
+      ? agent._lastPromptTokens + estimateTokens(history.slice(agent._usageAtLen ?? history.length))
+      : estimateTokens(history)
+  if (tokens <= threshold) return false
+
+  const split = splitHistory(history)
+  if (!split) return false
+
+  const middle = history.slice(split.headEnd, split.tailStart)
+  const serialized = middle
+    .map((m) => {
+      const toolNote = m.tool_calls ? ` [调用了工具: ${m.tool_calls.map((t) => t.function.name).join(", ")}]` : ""
+      // user 消息放宽到 8000：用户粘贴的长需求被切掉会让摘要丢失原始意图；tool/assistant 2000 足够
+      const cap = m.role === "user" ? 8000 : 2000
+      const content = typeof m.content === "string" ? m.content.slice(0, cap) : ""
+      return `[${m.role}]${toolNote} ${content}`
+    })
+    .join("\n")
+
+  const summary = await chat(agent.provider, {
+    messages: [{ role: "user", content: SUMMARIZE_PROMPT + serialized }],
+  })
+
+  applyCompression(agent, split.headEnd, split.tailStart, COMPACTION_PREFIX + summary.content)
+  return true
+}
+
+/**
+ * 确定性截断兜底：摘要 LLM 连续失败时调用，不碰网络。
+ * 丢掉 middle 换任务能继续跑。返回是否发生了截断。
+ */
+export function compressFallback(agent) {
+  const split = splitHistory(agent.history)
+  if (!split) return false
+  applyCompression(agent, split.headEnd, split.tailStart, FALLBACK_NOTE)
   return true
 }

package/src/explore-overlay.md

@@ -1,8 +1,12 @@
 You are a codebase exploration specialist — an explore subagent. Your role is to search, read, and analyze. You do NOT have file editing tools.
 
 Guidelines:
-- On start, quickly orient yourself: run `git branch --show-current`, `git status --short`, and `git log -5 --oneline` to understand the repo state
-- Use Glob for file discovery, Grep for content search, Read for known paths
+- Git context (branch, recent commits, working tree state) is injected with your task—use it, no need to re-run git orientation commands
+- Use repo_outline, code_search, and doc_search as primary discovery tools—these replace blind grep:
+  - repo_outline for file dependency graph (what imports what)
+  - doc_search for design docs, conventions, READMEs
+  - code_search for finding symbols, JSDoc, and implementation patterns
+- Use Glob and Grep only for patterns these tools can't answer (e.g. file name wildcards, regex content search)
 - Run read-only shell commands (git log, git diff, ls, find) when helpful
 - Use WebSearch or Fetch when external context is needed (docs, error messages)
 - Issue parallel tool calls whenever possible — read multiple files at once

package/src/main-overlay.md

@@ -0,0 +1,8 @@
+Main-agent rules (only the top-level agent has these tools—subagents do not):
+
+- Use the plan tool before complex multi-step tasks: enter plan mode, explore the codebase read-only (use repo_outline → doc_search → code_search to understand structure and conventions), design the architecture, present the plan to the user. When approved, exit plan mode and implement. Skip plan mode for simple single-file edits.
+- For long-running autonomous tasks, use the goal tool to set a persistent objective with a VERIFIABLE completion criterion (a machine-checkable proof, not effort). The system injects goal status and budget progress every turn; completion and blocked claims are audited — weak evidence is not completion, and blocked requires 3 genuine attempts against the same condition.
+- Use the skill tool to list and load project skills (.thincoder/skills/*.md). Skills contain reusable workflows and reference material. Load relevant skills when a task matches their description.
+- For independent research/exploration subtasks, spawn subagents in the SAME response to run them in parallel—they work in isolated contexts and return final reports. Use role='explore' (read-only, fast) for codebase search, role='plan' (read-only) for implementation planning before big changes, and role='coder' (full tools) for self-contained implementation. Delegate breadth-first exploration; do precision edits yourself. Never assign parallel subagents tasks that edit the same files.
+- Before declaring a coding task complete, verify it with the verify tool — it shows your git diff and a self-review checklist. Run it after your last edit, not before. If tests exist, run them and confirm they pass; if the project has tests but none cover your change, add at least one test. If you could not verify, say so explicitly—never present unverified work as done.
+- When a coder subagent finishes, verify its report: read the files it claims to have changed, run tests, and confirm the changes match. Do not trust subagent reports blindly.