thincoder 0.12.47 → 0.12.49

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 本文件记录 ThinCoder CLI 的发布历史。格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/)，版本遵循[语义化版本](https://semver.org/lang/zh-CN/)。
 
+## [0.12.49] — 2026-08-29
+
+### Added
+
+- **Qwen enable_thinking 全链路**（CLI + VS Code 0.8.4 双端 parity）：`resolveEnableThinking` 按"模型前缀 qwen*（排除 qwen3-coder*）+ 百炼域名"白名单注入 `enable_thinking`——`thinking === null` 即显式 off（区别于未设置=ON）；`/think off` 真正关闭百炼强制思考（真实端点冒烟验证：off 1.0s 无 reasoning / 档位有思考）；PROVIDER.md §12 权威文档
+
+### Fixed
+
+- **opencode 400 残余排查**：`stripLocalMessageFields` 补齐 provider 载荷净化（Gitee IKBGX4 follow-up，与 VS Code 端 parity 测试互锁）
+
+### Changed
+
+- **subagent 工具描述升级**：角色能力矩阵 + Mode filtering 段（修复 role 参数 description 被运行期覆盖点的死文本）；read_image 多模态模型清单修正（补 GLM-5.3-Flash、移除纯文本 Qwen3.7）
+
+## [0.12.48] — 2026-08-28
+
+### Fixed
+
+- **opencode/LiteLLM 严校验端点 400 "Extra inputs are not permitted"（Gitee IKBGX4）**：本地标记 `transient` 泄漏进发送载荷——`escapeMessages` 发送前剥离整消息本地字段（新增 `stripLocalMessageFields`），云端不再拒绝 `messages[i].transient`；VS Code 端口同修（provider.mjs 净化链，函数体 parity）
+- **Ctrl+I 注入框粘贴落主输入框（Gitee IKBU3J）**：`insertPastedText` 目标选择缺 `interruptPrompt` 分支——粘贴直接进 `state.input`、Esc 后残留主输入框；补分支（去换行，与按键路径同语义）
+- **/think 交互异常卡死 TUI（Gitee IKBNUI）**：命令 handler 异常（如 config 写盘失败）一路冒泡击穿 submit 主循环→面板卡死回不了输入框；`handleSlash` 包 try/catch，异常转错误行、UI 保持存活
+
+### Changed
+
+- **系统提示词加两条约束**：①「先定正确再谈实现」——动手前先回答"正确应该是什么"（每个入口/视图/边界），再谈怎么实现，实现规模是"正确"的结果、不是决策标准；②「确认时暴露方案权衡」——确认理解时列出选的做法、为什么它对（绝不是"改动最小"）、考虑过但没选的替代方案。治"最小改动"偷懒病根
+
 ## [0.12.47] — 2026-08-28
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.12.47",
+  "version": "0.12.49",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",

package/src/agent/setup.mjs

@@ -183,12 +183,12 @@ export async function prepareRun(agent, input, callbacks, {
   const subagentRoles = (depth === 0 && agent.config?.agent?.engineering)
     ? {
         enum: ["explore", "plan", "eng-coder"],
-        description: "Sub-agent role: 'explore' (read-only search/analysis), 'plan' (read-only implementation planning), 'eng-coder' (engineering coder — strict methodology, design-driven). 'coder' is disabled in engineering mode.",
+        description: "The sub-agent role — see the tool description for the role capability matrix. Exact spelling required.",
         suffix: " In engineering mode, use role='eng-coder' for implementation (coder is disabled).",
       }
     : {
         enum: ["explore", "plan", "coder"],
-        description: "Sub-agent role: 'explore' (read-only search/analysis), 'plan' (read-only implementation planning), or 'coder' (full implementation). 'eng-coder' is disabled in normal mode.",
+        description: "The sub-agent role — see the tool description for the role capability matrix. Exact spelling required.",
         suffix: "",
       }
   const filteredSubagent = depth === 0 ? {

package/src/agent-tools/subagent.mjs

@@ -53,7 +53,13 @@ export const subagentTool = {
   name: "subagent",
   description:
     "Spawn a sub-agent to handle an independent subtask in an isolated context. The sub-agent returns only its final report. Spawn MULTIPLE subagents in the SAME response for parallel work—they run concurrently.\n" +
-    "Use role='explore' for codebase search/analysis (read-only, fast — specify thoroughness in the task: quick / medium / thorough (default medium)), role='plan' for read-only implementation planning (returns a step-by-step plan, never edits), role='coder' for self-contained implementation tasks. Do not give parallel subagents tasks that edit the same files.\n\n" +
+    "Why delegate? A sub-agent runs in its own isolated context — its reads, searches, tool calls and edits never enter your history or pollute your window; only its final report comes back. Delegation keeps your working context lean (you see the whole session, not the child's noise) and the child single-mindedly focused on one task. Parallel children run concurrently, saving wall-clock time. Every coder/eng-coder child carries its own verify + advisor self-review discipline — handed-off work is already verified before you read a word of it.\n\n" +
+    "Available roles (which roles are exposed depends on the active mode — see Mode filtering below):\n" +
+    "- explore — read-only search & analysis. Toolset: the read/search family (grep, read, glob, code_search, doc_search, repo_outline, lsp, tree...). Receives git context auto-injected (branch, recent commits, working-tree state) when the project is a git repo. Its report must list what it searched and what it did NOT find. Fast — specify thoroughness in the task: quick / medium / thorough (default medium).\n" +
+    "- plan — read-only implementation planning. Same read/search toolset; NEVER edits files. Returns a step-by-step plan for the parent to execute.\n" +
+    "- coder — full implementation. The parent's complete read/write/execute toolset plus verify and advisor for self-review. Its final report must include a delivery transparency table with one row per task requirement (Done / Simplified / Not done — no deferred column).\n" +
+    "- eng-coder — engineering-mode coder (available only in engineering mode, replacing coder). Same full toolset as coder plus the design-driven methodology overlay; REQUIRES a valid designToken arg obtained from a passed advisor(type='design') review.\n" +
+    "Mode filtering: normal mode exposes explore/plan/coder; engineering mode exposes explore/plan/eng-coder. The schema enum reflects the active mode.\n\n" +
     "Writing the prompt:\n" +
     "- The sub-agent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\n" +
     "- Put exact paths and commands in the prompt when you know them. The sub-agent should not search for things you already know.\n" +
@@ -64,7 +70,7 @@ export const subagentTool = {
     properties: {
       task: { type: "string", description: "Self-contained task description for the sub-agent" },
       context: { type: "string", description: "Optional background the sub-agent needs (it cannot see this conversation)" },
-      role: { type: "string", enum: ["explore", "plan", "coder", "eng-coder"], description: "Sub-agent role: 'explore' (read-only search/analysis), 'plan' (read-only implementation planning), 'coder' (full implementation), 'eng-coder' (engineering-mode coder — strict methodology, design-driven). ENUM IS OVERRIDDEN IN setup.mjs PER ENGINEERING MODE." },
+      role: { type: "string", enum: ["explore", "plan", "coder", "eng-coder"], description: "The sub-agent role — see the tool description for the role capability matrix. Exact spelling required." },
       model: { type: "string", description: "Provider/model override for this sub-agent: 'provider:model', a provider name from config, or a model name on the parent's provider. Defaults to the agent.subagentModel config, then the parent's provider. Useful for offloading heavy work to a cheaper model." },
       designToken: { type: "string", description: "Required when role='eng-coder': the token returned by advisor(type='design') after the design review passed. Without a valid token, eng-coder cannot modify files." },
     },

package/src/config.mjs

@@ -187,6 +187,36 @@ export function resolveCompactThreshold(explicit, model) {
   return { value, auto: true }
 }
 
+/**
+ * Bailian (阿里云百炼) host check — enable_thinking is a Bailian-only extension parameter;
+ * sending it to other endpoints (kimi/glm/custom proxies) would pollute the request.
+ */
+export function isBailianHost(baseURL) {
+  return typeof baseURL === "string"
+    && (baseURL.includes("dashscope.aliyuncs.com") || baseURL.includes(".maas.aliyuncs.com"))
+}
+
+/**
+ * Resolve the Bailian `enable_thinking` switch for qwen hybrid-thinking models (PROVIDER.md §12).
+ * qwen3.x on Bailian defaults to thinking ON, so an explicit off must send enable_thinking:false
+ * or the server silently keeps thinking. Whitelist: model name starts with "qwen" (excluding the
+ * non-thinking qwen3-coder line) AND the provider points at a Bailian host.
+ *   provider.thinking === null → false     (explicit off: /think off, panel off — NF1 convention)
+ *   provider.reasoningEffort   → true      (effort tier implies thinking on; rides with reasoning_effort)
+ *   otherwise                  → undefined (field omitted — server default stays, no behavior change)
+ * NOTE: spec carries no model field today — the name comes from provider.model (spec?.model is
+ * a forward-compatible fallback). Keep the body byte-aligned with thincoder-vscode config.mjs
+ * (cross-repo parity test compares them).
+ */
+export function resolveEnableThinking(provider, spec) {
+  const model = (provider?.model ?? spec?.model ?? "").toLowerCase()
+  if (!model.startsWith("qwen") || model.startsWith("qwen3-coder")) return undefined
+  if (!isBailianHost(provider?.baseURL)) return undefined
+  if (provider.thinking === null) return false
+  if (provider.reasoningEffort) return true
+  return undefined
+}
+
 /**
  * Find provider by name in providers[].
  * Throws if name is non-empty but not found — a typo in activeProvider silently falling to the first provider would use the wrong key on the wrong endpoint.

package/src/escape.mjs

@@ -43,7 +43,20 @@ export function escapeMessageContent(message) {
   return message
 }
 
-/** 对整个 messages 数组逐条应用 escapeMessageContent。 */
+/** IKBGX4 (2026-08-28)：剥离仅本地使用的整消息标记字段（transient 等）——发送给 provider 前移除。
+ * 严格 OpenAI 兼容服务端（opencode/LiteLLM 等）会拒绝消息级未知 key
+ * （"Extra inputs are not permitted, field: 'messages[i].transient'"）。 */
+export function stripLocalMessageFields(messages) {
+  return messages.map((m) => {
+    if (m && typeof m === "object" && "transient" in m) {
+      const { transient, ...rest } = m
+      return rest
+    }
+    return m
+  })
+}
+
+/** 对整个 messages 数组逐条应用 escapeMessageContent（先剥离本地字段，再转义）。 */
 export function escapeMessages(messages) {
-  return messages.map(escapeMessageContent)
+  return stripLocalMessageFields(messages).map(escapeMessageContent)
 }

package/src/prompts/system.md

@@ -11,7 +11,8 @@ Programming is collaborative labor between you and the human. The human decides
 - **Document ownership — find the doc that owns the topic before writing.** Before writing to `docs/design/`, check the `docs/design/README.md` document map (no map → check AGENTS.md and the docs directory) to locate the document that owns the topic — if it exists, update it; never create a new file for an existing section. Create a new file only when no section owns the topic, and register it in the map. Describe each mechanism in detail in exactly ONE place (the authoritative source); other documents reference it, never copy it.
 - **Check existing code.** Search for existing functions, helpers, patterns before writing new ones. Duplicates are technical debt.
 - **Understand intent.** Ask why this change is needed — the "why" reveals scope the literal request hides.
-- **Confirm understanding.** State what you believe the user asked for and what you plan to deliver, including the most important acceptance criteria. Wait for confirmation. No task is too small — a wrong assumption always costs more than the round-trip. Once confirmed, deliver exactly what was agreed — no simplifying, no substituting, no taking shortcuts after the fact. Simplifying a confirmed requirement frustrates the user and wastes time; they will just tell you to do it right anyway.
+- **Decide what's right before deciding what's smallest.** After understanding intent, before choosing HOW: first answer what SHOULD this be — every entry point, every view, every edge case — then how to implement it. Implementation size is a consequence of "right", never the criterion. "Smallest change" is not a goal; if you're about to choose something because it's a smaller change, you skipped "right" — go back and do it correctly.
+- **Confirm understanding.** State what you believe the user asked for and what you plan to deliver, including the most important acceptance criteria — and expose your choices: the approach you picked, WHY it's the right one (never "it's the smallest change"), and the alternatives you considered and rejected. Wait for confirmation. No task is too small — a wrong assumption always costs more than the round-trip. Once confirmed, deliver exactly what was agreed — no simplifying, no substituting, no taking shortcuts after the fact. Simplifying a confirmed requirement frustrates the user and wastes time; they will just tell you to do it right anyway.
 - **Confirm before any file-writing action.** Before ANY file-writing action (write / edit / apply_patch / insert_after / delete / hashline_edit, or any bash that writes files), restate in plain text your understanding of the task plus the key points of your plan, and WAIT for the user's explicit confirmation (an "OK / 可以 / continue"-type reply) before executing. For the changes you propose, there are no exemptions: no confirmation, silence, or the user answering with a new question or a new requirement → do not touch anything, no matter how small or obvious the change seems. Even after rounds of clarification, when you are completely sure you understand, you must still write the plan out and wait — "this is obvious enough to skip asking" is never a valid reason to skip, and a new question from the user is not a confirmation; it means the understanding has changed.
   - **Doc/code consistency outranks this gate (the one carve-out).** The gate above governs the changes you PROPOSE for the task — a new deliverable, a change of scope or approach. It does NOT govern standing obligations you already owe: (a) updating the document that already owns the topic (per the document map) so it stays consistent with code/logic the user already confirmed; (b) recording a decision the user just made ("Discussion → docs"); (c) closing an advisor-flagged doc-code gap. These complete the SAME confirmed task — do them in the same turn, without re-asking.
 - **Re-confirm when the requirement changes.** If what was confirmed is later changed by a new requirement in the conversation, restate your understanding and plan and wait for fresh confirmation before touching files.

package/src/provider/core.mjs

@@ -4,7 +4,7 @@
  * SSE parsing → provider/sse.mjs
  */
 
-import { specForModel } from "../config.mjs"
+import { specForModel, resolveEnableThinking } from "../config.mjs"
 import { proxyFetch } from "../proxy.mjs"
 import { escapeMessages } from "../escape.mjs"
 import { readSSE } from "./sse.mjs"
@@ -104,6 +104,11 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
     }
     body.reasoning_effort = provider.reasoningEffort
   }
+  // enable_thinking — Bailian hybrid-thinking switch (PROVIDER.md §12): qwen3.x defaults to
+  // thinking ON, so an explicit off must send enable_thinking:false or the server keeps thinking.
+  // NOT gated by isRouter: the whitelist keys on model prefix + Bailian host, not the model-ID slash.
+  const enableThinking = resolveEnableThinking(provider, spec)
+  if (enableThinking !== undefined) body.enable_thinking = enableThinking
   if (tools?.length) body.tools = tools
 
   const estimated = estimateRequestTokens(body)

package/src/tui/clipboard.mjs

@@ -84,6 +84,12 @@ export function insertPastedText(state, rawText) {
     q.answer = (q.answer ?? "") + rawText.replace(/[\r\n]+/g, "")
     return
   }
+  // IKBU3J (2026-08-28)：Ctrl+I 注入框激活时，粘贴进注入文本（与按键路径同语义：去换行保单行），
+  // 不得落入主输入框——此前缺失该分支导致粘贴进 state.input、Esc 后残留主输入框。
+  if (state.interruptPrompt) {
+    state.interruptPrompt.text += rawText.replace(/[\r\n]+/g, "")
+    return
+  }
   const text = rawText.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "  ")
   const chars = [...text]
   state.input.splice(state.cursor, 0, ...chars)

package/src/tui/cmd-think.mjs

@@ -42,8 +42,10 @@ export async function handleThinkCommand(ctx, args = []) {
   let mainIdx = 0
   for (;;) {
     const autoOn = agent.config?.agent?.autoThink === true
+    // thinking:null 是显式 off 标记（NF1 约定）——不得落入"未设置即 ON"的默认显示（评审 #3）。
+    // 用 !== null 而非 != null：undefined（从未设置）须保持既有 ON 显示（qwen3.x 服务端默认开思考）。
     const thinkingEnabled = cur.thinking?.type === thinkOnValue
-      || (cur.thinking?.type === undefined && !isCustomThink)
+      || (cur.thinking !== null && cur.thinking?.type === undefined && !isCustomThink)
 
     const entries = [
       { type: "header", text: `Auto: ${autoOn ? "ON" : "OFF"} | Thinking: ${thinkingEnabled ? "ON" : "OFF"} | Effort: ${cur.reasoningEffort || "—"}` },
@@ -92,17 +94,29 @@ async function applyThink(e, agent, syncProviderField, spec, isEffortOnly, isCus
     const cfg = agent.config.agent ??= {}
     cfg.autoThink = !cfg.autoThink
     if (cfg.autoThink) {
+      // 开 auto = 要思考：清显式 off 标记（thinking:null，NF1 约定；交付评审 #1）——残留 null
+      // 会让 auto 每轮写入的 reasoning_effort 与 enable_thinking:false 矛盾同发（F2 违约）。
+      // 仅清 null：thinking-type 模型的 {type:"disabled"} 不在评审 #1 范围，保持既有语义。
+      if (cur.thinking === null) { delete cur.thinking; await syncProviderField("thinking", undefined) }
       delete cur.reasoningEffort
       await syncProviderField("reasoningEffort", undefined)
     }
   } else if (e.action === "effort") {
+    // 选档位 = 要思考：清显式 off 标记（thinking:null，NF1 约定；交付评审 #1）——残留 null 会让
+    // enable_thinking:false 与 reasoning_effort 矛盾同发（F2 违约）。仅清 null（同上注释）。
+    if (cur.thinking === null) { delete cur.thinking; await syncProviderField("thinking", undefined) }
     cur.reasoningEffort = e.level
     await syncProviderField("reasoningEffort", e.level)
   } else {
     const enable = e.action === "on"
     if (isEffortOnly) {
-      if (!enable) delete cur.reasoningEffort
-      else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+      // Explicit off persists thinking:null (NF1 convention — distinguishable from autoThink's
+      // delete/undefined); "on" deletes the marker so enable_thinking maps from effort again.
+      if (!enable) { cur.thinking = null; delete cur.reasoningEffort }
+      // "on" 默认 effort 取 spec 枚举首值（交付评审 #2）：硬编码 "high" 对 qwen3.8-max
+      // （enum xhigh/medium/low）无效，会被 core.mjs 枚举校验 throw（400 前置）
+      else { delete cur.thinking; if (!cur.reasoningEffort) cur.reasoningEffort = spec.reasoningEffortEnum?.[0] ?? "high" }
+      await syncProviderField("thinking", cur.thinking)
       if (!enable) await syncProviderField("reasoningEffort", undefined)
       else await syncProviderField("reasoningEffort", cur.reasoningEffort)
     } else {

package/src/tui/slash-commands.mjs

@@ -114,7 +114,14 @@ export function createSlashCommands(ctx) {
     const resolved = SLASH_ALIASES[cmd] ?? cmd
     const handler = HANDLERS[resolved]
     if (handler) {
-      await handler(handlerCtx, args)
+      // IKBNUI (2026-08-28)：命令 handler 抛出的异常必须被拦截成错误行，不得击穿 TUI 主循环——
+      // 此前 /think 交互循环里 config 写盘失败会一路冒泡（submit 无 catch）导致面板卡死、回不了输入框。
+      // 调用点（index.mjs submit 路径）统一在 handleSlash 返回后 render，UI 保持存活。
+      try {
+        await handler(handlerCtx, args)
+      } catch (e) {
+        ctx.pushLine(`[error] ${e?.message ?? String(e)}`, C.error)
+      }
       return
     }
     ctx.pushLine(`Unknown command: ${rawCmd} (/help for available commands)`, C.error)