thincoder 0.12.3 → 0.12.4

package/README.md

@@ -89,6 +89,8 @@ Slash commands in the TUI: `/help`, `/model` (two-level picker: first select pro
 
 Environment variables: `THINCODER_API_KEY` (or `DEEPSEEK_API_KEY` / `OPENAI_API_KEY`), `THINCODER_BASE_URL`, `THINCODER_MODEL`, `SILICONFLOW_API_KEY`.
 
+> **Kimi note**: Kimi has **two separate platforms with non-interchangeable API keys** — Moonshot (`https://api.moonshot.cn/v1`, keys `sk-...`, platform.moonshot.cn) and **Kimi For Coding** (`https://api.kimi.com/coding/v1`, keys `sk-kimi-...`, platform.kimi.com, model ID `k3`). Use the `kimi` preset for Moonshot and `kimi-code` for Kimi For Coding — putting one platform's key on the other's endpoint fails with 401 (a hint is appended when the key/baseURL look mismatched).
+
 ## Configuration
 
 `~/.thincoder/config.json`:
@@ -171,7 +173,8 @@ src/
   distill.mjs       session knowledge extraction (candidates + human confirmation)
   config.mjs        config loading
   tui/              bare-ANSI terminal UI — index.mjs (startTUI), render.mjs (drawing primitives),
-                    render-frame.mjs (frame layout), ansi.mjs
+                    render-frame.mjs (frame layout), render-conversation.mjs (conversation panel),
+                    markdown.mjs (lightweight inline markdown → ANSI), ansi.mjs
   tui.mjs           re-export shim → src/tui/index.mjs
   tui-render.mjs    re-export shim → src/tui/render.mjs
   prompts/          prompt texts — system.md (core), discipline.md (coding/testing rules),
@@ -205,6 +208,13 @@ Code conventions: pure `.mjs`, no semicolons, no npm dependencies allowed (inclu
 
 ## Changelog
 
+### 0.12.4 (2026-08)
+- **Context compaction unified spec** — CLI/VS Code now share one compaction semantics (`docs/design/CONTEXT-COMPACTION.md`): window-adaptive tail size (`max(10, ctx/100K×30)`, ≤40% of history), measured prompt-token baseline preferred, pure-estimation path includes system+tools overhead, head/tail tool-call pairing protection on both sides, 3-tier fallback (LLM summary → deterministic truncation after 3 failures → per-message shrink), compaction summaries are silent to the frontend (no streaming into the conversation), task re-injection deduplicated. Unknown model names now warn once instead of silently degrading to the 128K default
+- **Kimi For Coding support** — new `kimi-code` preset (`api.kimi.com/coding/v1`, model `k3`, platform.kimi.com, `sk-kimi-` keys — NOT interchangeable with Moonshot); `MODEL_SPECS` gains the `k3` alias (1M context / multimodal / partialMode / reasoningEcho); 401 errors hint at the two-platform key mismatch; README documents the split
+- **Ctrl+C double-confirm** — idle-state first Ctrl+C only warns (3s window), second press exits; picker-cancel and in-flight abort semantics unchanged
+- **Empty-response auto-retry** — a transient empty LLM response (reasoning exhausted / truncated output) injects a retry reminder instead of aborting the whole turn; after 2 consecutive empties the original error surfaces (with the `/think` lowering hint)
+- **Lightweight inline markdown display** — model replies render `**bold**`, `` `code` `` (reverse video), `~~strike~~`, and `# headings` (marker-stripped + bold) via ANSI instead of showing literal markers; code spans are not re-interpreted; streaming-safe on unclosed markers; copied text comes out clean
+
 ### 0.12.3 (2026-08)
 - **Fix: user-level skills loading** — skills in `~/.thincoder/skills/` are now properly discovered and loaded alongside project-level skills. Project-level skills with the same name take priority. Both `skill list` and `skill load` support both directories.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.12.3",
+  "version": "0.12.4",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",
@@ -30,8 +30,8 @@
     "url": "https://gitee.com/shanghai-xinbo/thincoder.git"
   },
   "scripts": {
-    "test": "node --test",
-    "prepublishOnly": "node --test"
+    "test": "node --test \"test/*.mjs\"",
+    "prepublishOnly": "node --test \"test/*.mjs\""
   },
   "author": "liwei <liwei@51marine.com> (上海新舶)",
   "license": "MIT"

package/src/agent/completion.mjs

@@ -5,6 +5,7 @@
  * Returns { action: 'continue' | 'done', content?, guardPushbacks, honestReminderInjected, advisorPushbacks }
  */
 import { isDocFile } from "../advisor/repos.mjs"
+import { pushReal } from "../context.mjs"
 
 /** True when this run mutated at least one CODE file. Mirrors agent.mjs:hasCodeMutations. */
 function hasCodeMutations(agent) {
@@ -16,6 +17,7 @@ function hasCodeMutations(agent) {
 const MAX_VERIFY_PUSHBACKS = 2
 const MAX_VERIFY_RETRIES = 3
 const MAX_ADVISOR_PUSHBACKS = 3
+const MAX_EMPTY_RETRIES = 2
 
 /**
  * Handle a model turn with zero tool calls. May push back (verify/advisor/pending tasks)
@@ -32,6 +34,19 @@ const MAX_ADVISOR_PUSHBACKS = 3
  */
 export function handleCompletion(agent, response, depth, turn, guardPushbacks, honestReminderInjected, advisorPushbacks, callbacks) {
   if (!response.content) {
+    // Transient empty response (reasoning exhausted / output truncated): instead of
+    // aborting the whole turn, inject a reminder and let the model respond again.
+    // Bounded — after MAX_EMPTY_RETRIES consecutive empties, surface the original error.
+    const retries = agent._emptyRetries ?? 0
+    if (retries < MAX_EMPTY_RETRIES) {
+      agent._emptyRetries = retries + 1
+      agent.history.push({
+        role: "user",
+        content: "[System reminder: your last response was empty — the provider returned no content (likely reasoning was exhausted or output was truncated). Respond again, continuing your work from where you left off.]",
+      })
+      callbacks.onTurnEnd?.(agent, turn)
+      return { action: "continue", guardPushbacks, honestReminderInjected, advisorPushbacks }
+    }
     throw new Error(
       "LLM returned empty response (likely reasoning exhausted or output truncated). " +
       "Try lowering reasoning effort if this persists (/think in TUI). " +
@@ -42,7 +57,7 @@ export function handleCompletion(agent, response, depth, turn, guardPushbacks, h
   // Pending tasks: remind the model before it declares itself done
   if (depth === 0 && agent.tasks.some((t) => t.status === "pending")) {
     const pending = agent.tasks.filter((t) => t.status === "pending").map((t) => t.title).join(", ")
-    agent.history.push({ role: "assistant", content: response.content })
+    pushReal(agent, { role: "assistant", content: response.content })
     agent.history.push({
       role: "user",
       content: `[System reminder: you still have pending tasks: ${pending}. Update their status with the task tool before finishing — if they're done, mark them done; if they're not applicable, remove them.]`,
@@ -60,7 +75,7 @@ export function handleCompletion(agent, response, depth, turn, guardPushbacks, h
     // Not verified yet → pushback to run verify
     if (agent._mutatedThisRun && !agent._verifiedThisRun && hasCodeMutations(agent) && guardPushbacks < MAX_VERIFY_PUSHBACKS) {
       guardPushbacks++
-      agent.history.push({ role: "assistant", content: response.content })
+      pushReal(agent, { role: "assistant", content: response.content })
       agent.history.push({
         role: "user",
         content: "[System reminder: you modified files in this run but have not verified the changes. Before finishing: call the verify tool to run syntax checks and tests. If verify reports failures, fix them and run verify again. If verification is genuinely impossible here, say so explicitly in your reply.]",
@@ -71,7 +86,7 @@ export function handleCompletion(agent, response, depth, turn, guardPushbacks, h
     // Verified but still failing → pushback to fix (up to MAX_VERIFY_RETRIES)
     if (agent._verifiedThisRun && agent._verifyPassed === false && agent._verifyRetries < MAX_VERIFY_RETRIES) {
       agent._verifyRetries++
-      agent.history.push({ role: "assistant", content: response.content })
+      pushReal(agent, { role: "assistant", content: response.content })
       agent.history.push({
         role: "user",
         content: `[System reminder: verify reported test failures (retry ${agent._verifyRetries}/${MAX_VERIFY_RETRIES}). Review the failures, fix the issues, then run verify again. If you cannot fix after ${MAX_VERIFY_RETRIES} attempts, explain honestly what's blocking you.]`,
@@ -82,11 +97,11 @@ export function handleCompletion(agent, response, depth, turn, guardPushbacks, h
     // Exhausted retries — inject honesty reminder once
     if (agent._verifiedThisRun && agent._verifyPassed === false && agent._verifyRetries >= MAX_VERIFY_RETRIES) {
       if (honestReminderInjected) {
-        agent.history.push({ role: "assistant", content: response.content })
+        pushReal(agent, { role: "assistant", content: response.content })
         return { action: "done", content: response.content, guardPushbacks, honestReminderInjected, advisorPushbacks }
       }
       honestReminderInjected = true
-      agent.history.push({ role: "assistant", content: response.content })
+      pushReal(agent, { role: "assistant", content: response.content })
       agent.history.push({
         role: "user",
         content: `[System reminder: ${MAX_VERIFY_RETRIES} verify attempts exhausted and tests are still failing. In your response to the user, you MUST state explicitly: (1) what tests are still failing, (2) what you tried, (3) what you believe the root cause is. Do not present this as complete — the user needs to know the work is unfinished.]`,
@@ -104,7 +119,7 @@ export function handleCompletion(agent, response, depth, turn, guardPushbacks, h
     if (agent._mutatedThisRun && !agent._calledAdvisorThisRun && hasCodeMutations(agent)
         && advisorPushbacks < MAX_ADVISOR_PUSHBACKS) {
       advisorPushbacks++
-      agent.history.push({ role: "assistant", content: response.content })
+      pushReal(agent, { role: "assistant", content: response.content })
       agent.history.push({
         role: "user",
         content: `[System reminder: you changed code in this run and MUST get an advisor review before finishing (round ${agent._advisorRound + 1}). Call the \`advisor\` tool now. This is required, not optional — do not skip it even if you believe the changes are trivial — the review will be quick either way. After the review, produce a response table for every issue found (see discipline rules for format).]`,
@@ -114,6 +129,6 @@ export function handleCompletion(agent, response, depth, turn, guardPushbacks, h
     }
   }
 
-  agent.history.push({ role: "assistant", content: response.content })
+  pushReal(agent, { role: "assistant", content: response.content })
   return { action: "done", content: response.content, guardPushbacks, honestReminderInjected, advisorPushbacks }
 }

package/src/agent/setup.mjs

@@ -2,6 +2,7 @@
  * agent/setup.mjs — runAgent pre-flight setup: context injection, system prompt construction, tool injection
  */
 import { search as memorySearch, docSearch } from "../memory.mjs"
+import { pushReal } from "../context.mjs"
 import { toOpenAISchema } from "../tools/index.mjs"
 import { loadSkills, formatSkillListing } from "../skills.mjs"
 import {
@@ -137,7 +138,7 @@ export async function prepareRun(agent, input, callbacks, {
         }
       } catch { /* checklist not available — suppress error */ }
     }
-    agent.history.push({ role: "user", content: input })
+    pushReal(agent, { role: "user", content: input })
   }
 
   if (agent._pendingReminders.length > 0) {

package/src/agent.mjs

@@ -3,7 +3,8 @@
  * LLM ↔ tool-call loop, until the task is done.
  */
 import { chat } from "./provider/index.mjs"
-import { compressIfNeeded, compressFallback, COMPRESS_FAILURE_LIMIT } from "./context.mjs"
+import { estimateText } from "./provider/rate.mjs"
+import { compressIfNeeded, compressFallback, COMPRESS_FAILURE_LIMIT, pushReal } from "./context.mjs"
 import { specForModel } from "./config.mjs"
 import { readFileSync } from "node:fs"
 import { join, dirname } from "node:path"
@@ -131,6 +132,8 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     agent._advisorRound = 0
     agent._advisorSession = null // advisor session is per-run: discard when the task ends, next task starts fresh
     agent._advisorLastSnapshotHash = null // dedup baseline is per-run too — stale snapshot could wrongly suppress a diff refresh
+    agent._emptyRetries = 0 // empty-response retry budget is per-run: a fresh user turn restarts from zero
+    agent._compressFailures = 0 // compaction summary-failure counter is per-run: a fresh user turn restarts from zero
   }
   // eng-coder authorization is set by subagent.mjs AFTER token validation but BEFORE runAgent —
   // only reset for the top-level agent (depth 0); child runs must keep their granted authorization
@@ -145,6 +148,16 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
   // this set survives across chat() calls (rule abort-retry, tool loop) within the turn.
   const streamRuleFired = new Set()
 
+  // Compaction overhead for the pure-estimation path: system prompt + tools schema are
+  // part of every request but not in history — without them the first-turn/restored/just-
+  // compacted estimate under-counts and may never trigger compaction. Measured baseline
+  // path already includes both (prompt_tokens is the full context), so this only applies
+  // when _lastPromptTokens is null.
+  const compactionOverhead = {
+    systemPrompt,
+    tools: toolSchemas,
+  }
+
   for (let turn = 0; turn < maxTurns; turn++) {
     // Update turn counter for status bar display
     agent._currentTurn = turn + 1
@@ -153,7 +166,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     const lastRole = agent.history.at(-1)?.role
     if (lastRole === "user" || lastRole === "tool") {
       try {
-        if (await compressIfNeeded(agent, threshold, callbacks)) {
+        if (await compressIfNeeded(agent, threshold, callbacks, compactionOverhead)) {
           agent._compressFailures = 0
           agent._planReminderAtLen = 0 // After compression history shrinks, reset cadence so reminders resume
           recentCallSigs.length = 0 // After compression history is rebuilt, reset stall detection counter
@@ -236,7 +249,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     // inject rule's message as a reminder, and retry from the same context.
     if (response.ruleTriggered) {
       if (response.content) {
-        agent.history.push({ role: "assistant", content: response.content })
+        pushReal(agent, { role: "assistant", content: response.content })
       }
       const label = response.ruleName ? ` — stream rule "${response.ruleName}"` : ""
       agent.history.push({
@@ -262,7 +275,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     // the outer loop to recreate the controller and resume.
     if (response.interrupted) {
       if (response.content) {
-        agent.history.push({ role: "assistant", content: response.content })
+        pushReal(agent, { role: "assistant", content: response.content })
       }
       agent.history.push({
         role: "user",
@@ -306,7 +319,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     // abort after chat completes, before committing history: don't commit a half-finished turn
     if (signal?.aborted) throw new DOMException("Aborted", "AbortError")
 
-    agent.history.push({
+    pushReal(agent, {
       role: "assistant",
       content: response.content || null,
       tool_calls: response.toolCalls.map((tc) => ({
@@ -335,6 +348,12 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     guardPushbacks = 0
     advisorPushbacks = 0
 
+    // Multimodal user messages (injected images / not-injected reminders) must NOT be pushed
+    // between tool results of parallel calls — strict providers (DeepSeek) 400 when a tool
+    // message does not immediately follow its assistant tool_calls. Defer to after the loop.
+    // real: image injections are real messages (pushReal → _fullHistory); reminders stay machine-only.
+    const deferredUserMsgs = []
+
     for (const { toolCall, result, ok } of results) {
       const tool = toolByName.get(toolCall.name)
       // Multimodal tools return JSON { text, images } — inject as multimodal user message
@@ -343,26 +362,32 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
           const parsed = JSON.parse(result)
           if (parsed.images?.length) {
             // tool message first — closes the tool_call pairing (OpenAI API requires tool result immediately after assistant with tool_calls)
-            agent.history.push({ role: "tool", tool_call_id: toolCall.id, content: parsed.text })
+            pushReal(agent, { role: "tool", tool_call_id: toolCall.id, content: parsed.text })
             if (specForModel(agent.provider.model).multimodal) {
               // then inject multimodal user message with base64 images for the model to actually "see" them on the next turn
-              agent.history.push({
-                role: "user",
-                content: [{ type: "text", text: parsed.text }, ...parsed.images],
+              deferredUserMsgs.push({
+                real: true,
+                msg: {
+                  role: "user",
+                  content: [{ type: "text", text: parsed.text }, ...parsed.images],
+                },
               })
             } else {
               // Non-vision model: image parts must never enter history — text-only APIs 400 on them on EVERY
               // subsequent request, poisoning the conversation. (read_image itself already refuses; this is defense-in-depth.)
-              agent.history.push({
-                role: "user",
-                content: `[System reminder: the image returned by ${toolCall.name} was NOT injected — model ${agent.provider.model} does not support image input. Do not call ${toolCall.name} again under this provider; verify visual output programmatically instead.]`,
+              deferredUserMsgs.push({
+                real: false,
+                msg: {
+                  role: "user",
+                  content: `[System reminder: the image returned by ${toolCall.name} was NOT injected — model ${agent.provider.model} does not support image input. Do not call ${toolCall.name} again under this provider; verify visual output programmatically instead.]`,
+                },
               })
             }
             continue
           }
         } catch { /* Parse failure doesn't affect normal tool messages */ }
       }
-      agent.history.push({ role: "tool", tool_call_id: toolCall.id, content: result })
+      pushReal(agent, { role: "tool", tool_call_id: toolCall.id, content: result })
       if (tool && ok) {
         if (FILE_MUTATORS.has(toolCall.name)) {
           // Direct file edit — code was changed.
@@ -415,6 +440,12 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       }
     }
 
+    // All tool results committed — now safe to inject deferred multimodal user messages
+    for (const { real, msg } of deferredUserMsgs) {
+      if (real) pushReal(agent, msg)
+      else agent.history.push(msg)
+    }
+
     injectPostTurn(agent, results, recentCallSigs, callbacks, turn)
   }
 

package/src/config.mjs

@@ -16,8 +16,10 @@ export const configPath = join(configDir, "config.json")
 export const PROVIDER_PRESETS = {
   deepseek: { baseURL: "https://api.deepseek.com", 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" },
+  "kimi-code": { baseURL: "https://api.kimi.com/coding/v1", model: "k3", thinking: null, reasoningEffort: "max", maxTokens: 131072, desc: "Kimi For Coding (platform.kimi.com — sk-kimi- keys; NOT interchangeable with Moonshot)" },
   glm:      { baseURL: "https://open.bigmodel.cn/api/paas/v4", model: "glm-5.2", thinking: { type: "enabled" }, reasoningEffort: "max", maxTokens: 128000, desc: "Zhipu GLM" },
   qwen:     { baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1", model: "qwen3.7-max", reasoningEffort: "high", maxTokens: 131072, desc: "Qwen / Alibaba" },
+  qwenplan: { baseURL: "https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1", model: "qwen3.7-max", reasoningEffort: "high", maxTokens: 131072, desc: "Qwen Token Plan (百炼套餐)" },
   minimax:  { baseURL: "https://api.minimaxi.com/v1", model: "MiniMax-M3", thinking: { type: "adaptive" }, maxTokens: 128000, chatPath: "/text/chatcompletion_v2", desc: "MiniMax" },
   openai:   { baseURL: "https://api.openai.com/v1", model: "gpt-4o", desc: "OpenAI" },
   claude:   { baseURL: "https://api.anthropic.com/v1", model: "claude-sonnet-4", format: "anthropic", maxTokens: 8192, desc: "Claude (Anthropic)" },
@@ -88,6 +90,8 @@ const MODEL_SPECS = [
   ["deepseek-chat",     { context: 256_000,   maxOutput: 384_000, thinking: false, prefixMode: true,  cacheMode: "prompt", thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["high", "max"], tempRange: [0, 2] }],
   // Kimi series
   ["kimi-k3",           { context: 1_000_000, maxOutput: 131_072, thinking: true,  partialMode: true, multimodal: true, cacheMode: "auto",  thinkApi: "effort", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"] }],
+  // Kimi For Coding endpoint uses the short model ID "k3" (same specs as kimi-k3) — IK5VGJ
+  ["k3",                { context: 1_000_000, maxOutput: 131_072, thinking: true,  partialMode: true, multimodal: true, cacheMode: "auto",  thinkApi: "effort", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"] }],
   ["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 series
@@ -99,7 +103,8 @@ const MODEL_SPECS = [
   ["gpt-4o",            { context: 128_000,   maxOutput: 16_000,  thinking: false, multimodal: true, cacheMode: "prompt" }],
   // Qwen series
   ["qwen3.8-max-preview", { context: 1_000_000, maxOutput: 128_000, thinking: true, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "high"], tempRange: [0, 2] }],
-  ["qwen3.7-max",       { context: 1_000_000, maxOutput: 128_000, thinking: true, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "high"], tempRange: [0, 2] }],
+  // qwen3.7-max rejects image parts outright (DashScope 400 "Unexpected item type in content") — text-only
+  ["qwen3.7-max",       { context: 1_000_000, maxOutput: 128_000, thinking: true, partialMode: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "high"], tempRange: [0, 2] }],
   ["qwen3.8-max",       { context: 1_000_000, maxOutput: 128_000, thinking: true, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "high"], tempRange: [0, 2] }],
   ["qwen-max",          { context: 1_000_000, maxOutput: 128_000, thinking: false, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", tempRange: [0, 2] }],
   ["qwen-plus",         { context: 1_000_000, maxOutput: 32_000,  thinking: false, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", tempRange: [0, 2] }],
@@ -130,11 +135,18 @@ const DEFAULT_SPEC = { context: 128_000, maxOutput: 32_000, cacheMode: "none" }
 const COMPACT_RATIO = 0.6
 
 /** Look up spec by model name prefix (case-insensitive), conservative default for unknown models */
+const warnedModels = new Set() // warn once per model name — specForModel is a hot path (every request)
 export function specForModel(model) {
   const m = (model ?? "").toLowerCase()
   for (const [prefix, spec] of [...MODEL_SPECS].sort((a,b) => b[0].length - a[0].length)) {
     if (m.startsWith(prefix.toLowerCase())) return spec
   }
+  // Unknown model: warn ONCE (not per request) so a typo'd ID or a missing alias surfaces
+  // instead of silently degrading to the 128K default (IK5VGJ).
+  if (m && !warnedModels.has(m)) {
+    warnedModels.add(m)
+    console.warn(`[config] model "${model}" not found in MODEL_SPECS — using default spec (128K context, 32K output). Check the model ID or add an alias.`)
+  }
   return DEFAULT_SPEC
 }
 

package/src/context.mjs

@@ -7,8 +7,9 @@
 
 import { chat } from "./provider/index.mjs"
 import { estimateText } from "./provider/rate.mjs"
+import { specForModel } from "./config.mjs"
 
-const IMAGE_TOKEN_ESTIMATE = 256 // rough estimate for image placeholder tokens
+const IMAGE_TOKEN_ESTIMATE = 2000 // rough estimate for image content tokens (CLI legacy 256 underestimated real image costs, delaying compaction)
 
 /** Rough token count for a list of messages (body + reasoning + tool_calls params) */
 export function estimateTokens(messages) {
@@ -30,7 +31,13 @@ export function estimateTokens(messages) {
 }
 
 const KEEP_HEAD = 2 // Keep the earliest user intent — must not lose it
-const KEEP_TAIL = 10 // Keep the most recent work context — must not lose it
+// Tail size scales with the model context window (~30 messages per 100K tokens),
+// capped at 40% of history so small histories don't over-reserve. Window-adaptive
+// replaces the old fixed 10: on a 1M window, 10 messages is too thin for recent work.
+function keepTailSize(provider, historyLen) {
+  const ctxWindow = specForModel(provider?.model ?? "").context
+  return Math.min(Math.max(10, Math.floor((ctxWindow / 100_000) * 30)), Math.floor(historyLen * 0.4))
+}
 
 const SUMMARIZE_PROMPT = `You are a conversation compressor. Summarize the following agent work log into a compact summary for use as context in the ongoing conversation.
 Requirements:
@@ -69,15 +76,15 @@ const FALLBACK_NOTE =
  * The tail boundary must include any assistant whose tool results are in the tail — if the assistant is in the middle,
  * the summary swallows it, leaving orphan tool results → protocol 400.
  */
-function splitHistory(history) {
-  if (history.length <= KEEP_HEAD + KEEP_TAIL + 1) return null
+function splitHistory(history, keepTail) {
+  if (history.length <= KEEP_HEAD + keepTail + 1) return null
   let headEnd = KEEP_HEAD
   // head must not end with dangling tool_calls: when assistant declares tool_calls, all its tool results must stay in head.
   // Parallel calls: one assistant followed by multiple tool messages — accepting only one still causes 400, must collect all
   if (history[headEnd - 1]?.role === "assistant" && history[headEnd - 1].tool_calls?.length) {
     while (headEnd < history.length && history[headEnd].role === "tool") headEnd++
   }
-  let tailStart = history.length - KEEP_TAIL
+  let tailStart = history.length - keepTail
 
   // Tool messages in the tail region whose assistant tool_calls are in the middle: the summary would swallow the assistant,
   // leaving orphan tool results → protocol 400. Collect tool_call_ids from the tail, find their owner assistants and pull them into tail
@@ -101,8 +108,25 @@ function splitHistory(history) {
   return { headEnd, tailStart }
 }
 
+/**
+ * pushReal — the single entry point for REAL conversation messages.
+ * A real message (user input, assistant reply, tool result, multimodal image) is appended to BOTH:
+ *   agent.history      — the machine context (compaction shrinks this)
+ *   agent._fullHistory — the NEVER-COMPACTED human-readable record (persistence source)
+ * Machine-only messages ([System reminder:...], compaction notes, task/plan/checkpoint re-injections)
+ * are pushed directly to agent.history WITHOUT going through here, so they never enter _fullHistory.
+ * The two lines are written independently at the source — no after-the-fact delta sync.
+ */
+export function pushReal(agent, msg) {
+  if (!Array.isArray(agent._fullHistory)) agent._fullHistory = []
+  agent._fullHistory.push(msg)
+  agent.history.push(msg)
+}
+
 /** Replace middle with a note, then re-inject task/plan state (shared by LLM summary and truncation fallback) */
 function applyCompression(agent, headEnd, tailStart, note) {
+  // _fullHistory already holds every real message (written at the source via pushReal),
+  // so compaction only shrinks the machine line — nothing to preserve here.
   const head = agent.history.slice(0, headEnd)
   const tail = agent.history.slice(tailStart)
   agent.history = [
@@ -142,20 +166,30 @@ function applyCompression(agent, headEnd, tailStart, note) {
  * If history exceeds threshold, compact it. Returns whether compaction happened.
  * Only called at safe points in the loop (history ends with user or tool message — a complete exchange boundary).
  * Automatically re-injects task list state after compaction.
+ * @param {object} agent
+ * @param {number} threshold - compaction threshold in tokens
+ * @param {object} callbacks - { onToken, onReasoning, onCompress } — summary generation is SILENT
+ *   (never forwards onToken/onReasoning: the compaction process is an internal mechanism, not a model reply)
+ * @param {object} extras - { systemPrompt?, tools? } — estimated overhead for the pure-estimation
+ *   path (no measured baseline); the measured path already includes system+tools in prompt_tokens.
  */
-export async function compressIfNeeded(agent, threshold, callbacks) {
+export async function compressIfNeeded(agent, threshold, callbacks, extras = {}) {
   const history = agent.history
   // Prefer the real baseline: the last response's prompt_tokens is the measured value for the full context (system+tools+history).
   // Subsequent appended messages use estimation as increment; when no measured value exists (first turn / after restore / right after compaction), fall back to pure estimation
+  const overhead =
+    (extras.systemPrompt ? estimateText(extras.systemPrompt) : 0) +
+    (extras.tools ? estimateText(JSON.stringify(extras.tools)) : 0)
   const tokens =
     agent._lastPromptTokens != null
       ? agent._lastPromptTokens + estimateTokens(history.slice(agent._usageAtLen ?? history.length))
-      : estimateTokens(history)
+      : estimateTokens(history) + overhead
   if (tokens <= threshold) return false
 
-  const split = splitHistory(history)
+  const keepTail = keepTailSize(agent.provider, history.length)
+  const split = splitHistory(history, keepTail)
   if (!split) {
-    // History is too short (≤13 messages) to find a middle section, but tokens exceed threshold — typically a single giant message
+    // History is too short (≤KEEP_HEAD+keepTail+1 messages) to find a middle section, but tokens exceed threshold — typically a single giant message
     // (large paste / huge injection). When summarization has no room, degrade to deterministic shrinking to ensure context always reduces
     return shrinkOversized(agent)
   }
@@ -171,11 +205,10 @@ export async function compressIfNeeded(agent, threshold, callbacks) {
     })
     .join("\n")
 
-  // The summary is a plain-text task, no reasoning needed — passing thinking to the compaction provider wastes tokens
+  // The summary is a plain-text task, no reasoning needed — passing thinking to the compaction provider wastes tokens.
+  // Silent by design (D11): no onToken/onReasoning — the compaction process must not stream to the frontend.
   const summary = await chat({ ...agent.provider, thinking: null, reasoningEffort: null }, {
     messages: [{ role: "user", content: SUMMARIZE_PROMPT + serialized }],
-    onToken: callbacks?.onToken,
-    onReasoning: callbacks?.onReasoning,
   })
 
   // Auto-checkpoint before compaction: snapshot current state so the model can
@@ -205,7 +238,8 @@ export async function compressIfNeeded(agent, threshold, callbacks) {
  * Drops the middle so the task can continue. Returns whether truncation happened.
  */
 export function compressFallback(agent) {
-  const split = splitHistory(agent.history)
+  const keepTail = keepTailSize(agent.provider, agent.history.length)
+  const split = splitHistory(agent.history, keepTail)
   if (!split) return false
   applyCompression(agent, split.headEnd, split.tailStart, FALLBACK_NOTE)
   return true

package/src/generate-title.mjs

@@ -0,0 +1,44 @@
+/**
+ * generate-title.mjs — LLM-generated session titles (CLI side)
+ * Called after the first user message to auto-title the session.
+ * Mirrors thincoder-vscode/src/extension/generate-title.mjs but uses the CLI provider shape.
+ */
+
+/** Generate a session title from the first user message using an LLM. Returns title string or null. */
+export async function generateTitle(userContent, provider) {
+  // Extract text even from multimodal content (array of parts)
+  const userText = Array.isArray(userContent)
+    ? userContent.find((p) => p.type === "text")?.text || ""
+    : userContent
+  if (typeof userText !== "string" || userText.length < 10) return null
+  if (!provider?.apiKey || !provider?.baseURL || !provider?.model) return null
+
+  try {
+    const body = JSON.stringify({
+      model: provider.model,
+      messages: [
+        { role: "system", content: "Generate a concise title (max 40 chars, no quotes) for this conversation. Reply ONLY with the title." },
+        { role: "user", content: userText.slice(0, 200) },
+      ],
+      max_tokens: 30,
+      stream: false,
+    })
+    const chatPath = provider.chatPath ?? "/chat/completions"
+    const url = `${provider.baseURL.replace(/\/+$/, "")}${chatPath}`
+    const opts = {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${provider.apiKey}` },
+      body,
+      signal: AbortSignal.timeout(10000),
+    }
+    const res = provider.proxyUri
+      ? await (await import("../proxy.mjs")).proxyFetch(url, opts, provider.proxyUri)
+      : await fetch(url, opts)
+    if (!res.ok) return null
+    const data = await res.json()
+    const title = data.choices?.[0]?.message?.content?.trim().slice(0, 40)
+    return title || null
+  } catch {
+    return null
+  }
+}

package/src/prompts/system.md

@@ -7,7 +7,7 @@ Reply, reason, and ask in the user's language. If they switch languages mid-sess
 Programming is collaborative labor between you and the human. The human decides direction and makes the final call. You own the code — the entire project is your code. What you confirm is your contract.
 
 **How you work — before you write any code:**
-- **Read design docs first.** Use `doc_search` to find relevant design docs, AGENTS.md, and architecture decisions. Code without design context is guesswork. If docs conflict with code, docs are right.
+- **Read design docs first.** Use `doc_search` to find relevant design docs, AGENTS.md, and architecture decisions. Code without design context is guesswork. If docs conflict with code, docs are right. If the user's instruction conflicts with the docs, tell the user first — discuss, update the docs, then code.
 - **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. 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.

package/src/provider/core.mjs

@@ -63,7 +63,7 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
   }
 
   const spec = specForModel(provider.model)
-  messages = stripImagesForTextModel(messages, spec)
+  messages = normalizeToolPairing(stripImagesForTextModel(messages, spec))
   // Compile string-pattern rules to RegExp at call time
   const rules = compileStreamRules(streamRules)
   const body = {
@@ -199,6 +199,50 @@ export function stripImagesForTextModel(messages, spec) {
   return changed ? out : messages
 }
 
+/**
+ * Enforce the OpenAI tool-message protocol on the outgoing payload: every tool message must
+ * immediately follow the assistant message declaring its tool_call_id, and every declared
+ * tool_call must have a result. Strict providers (DeepSeek) reject the whole request with 400
+ * ("Messages with role 'tool' must be a response to a preceding message with 'tool_calls'").
+ * History can legitimately violate this — parallel read_image injects a user message between
+ * tool results, compaction splits, interrupted sessions leave dangling tool_calls — so sanitize
+ * at send time. History itself is left untouched.
+ */
+export function normalizeToolPairing(messages) {
+  // Detach all tool messages; reinsert each right after its owner assistant.
+  const toolById = new Map()
+  const rest = []
+  for (const m of messages) {
+    if (m.role === "tool") {
+      if (!toolById.has(m.tool_call_id)) toolById.set(m.tool_call_id, m)
+    } else {
+      rest.push(m)
+    }
+  }
+  if (toolById.size === 0) return messages // no tool messages — nothing to enforce
+  const out = []
+  for (const m of rest) {
+    out.push(m)
+    if (m.role !== "assistant" || !m.tool_calls?.length) continue
+    for (const tc of m.tool_calls) {
+      const t = toolById.get(tc.id)
+      if (t) {
+        toolById.delete(tc.id)
+        out.push(t)
+      } else {
+        // Declared tool_call with no recorded result (interrupted session / compaction split)
+        out.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: "[Tool result missing: the call was interrupted or its result was dropped by context compaction]",
+        })
+      }
+    }
+  }
+  // Leftovers in toolById are orphans (owner assistant compacted away or never recorded) — dropped
+  return out
+}
+
 /** List available model IDs from the provider's /models endpoint */
 export async function listModels(provider, { signal } = {}) {
   const response = await fetch(`${provider.baseURL}/models`, {
@@ -247,7 +291,19 @@ async function requestWithRetry(provider, body, signal, onWait) {
     if (response.ok) return response
 
     const text = await response.text().catch(() => "")
-    const message = `LLM API error ${response.status}: ${text}`
+    let message = `LLM API error ${response.status}: ${text}`
+    // Kimi has TWO separate platforms with non-interchangeable keys (IK5VGJ):
+    // Moonshot (api.moonshot.cn, sk-...) vs Kimi For Coding (api.kimi.com/coding/v1, sk-kimi-...).
+    // A 401 on either endpoint is usually a wrong-platform key — say so instead of a bare 401.
+    if (response.status === 401) {
+      const key = String(provider.apiKey ?? "").trim()
+      const base = String(provider.baseURL ?? "").toLowerCase()
+      const kimiCodeKey = /^sk-kimi-/i.test(key)
+      const kimiCodeUrl = base.includes("api.kimi.com")
+      if (kimiCodeKey || kimiCodeUrl) {
+        message += " — tip: Kimi has two separate platforms with NON-interchangeable API keys: Moonshot (api.moonshot.cn/v1, sk-...) and Kimi For Coding (api.kimi.com/coding/v1, sk-kimi-...). Your key or baseURL looks mismatched — check which platform issued it."
+      }
+    }
     lastStatus = response.status
     if (isNonRetryableError(response.status, text)) throw new Error(message)
     if (response.status === 429) {