thincoder 0.1.0

package/src/agent.mjs

@@ -0,0 +1,351 @@
+/**
+ * agent.mjs — Agent 主循环
+ * LLM ↔ 工具调用循环，直到任务完成。
+ * 工具执行用两段式：权限确认串行，只读工具并行、有副作用工具串行。
+ */
+
+import { chat } from "./provider.mjs"
+import { compressIfNeeded } from "./context.mjs"
+import { search as memorySearch } from "./memory.mjs"
+import { toOpenAISchema } from "./tools.mjs"
+import { readFile } from "node:fs/promises"
+import { join } from "node:path"
+
+const DEFAULT_MAX_TURNS = 50
+
+/**
+ * 修复断头 tool_calls：assistant 消息带了 tool_calls 但后面缺对应的 tool 结果
+ * （进程在工具执行中途被杀、会话中断等）。为每个缺失的 tool_call_id 补一条
+ * 中断占位消息，否则 API 会整单拒绝（invalid_request_error）。
+ * 返回修复后的新数组；无问题时返回原数组。
+ */
+export function repairHistory(history) {
+  const out = []
+  let dirty = false
+  for (let i = 0; i < history.length; i++) {
+    const m = history[i]
+    out.push(m)
+    if (m.role !== "assistant" || !m.tool_calls?.length) continue
+
+    // 收集紧随其后（下一个非 tool 消息之前）的 tool 结果 id
+    const answered = new Set()
+    let j = i + 1
+    while (j < history.length && history[j].role === "tool") {
+      answered.add(history[j].tool_call_id)
+      out.push(history[j])
+      j++
+    }
+    i = j - 1 // 外层 for 会再 +1
+
+    for (const tc of m.tool_calls) {
+      if (!answered.has(tc.id)) {
+        dirty = true
+        out.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: "[Tool execution was interrupted: session ended before the result was recorded]",
+        })
+      }
+    }
+  }
+  return dirty ? out : history
+}
+
+const VALID_TASK_STATUS = new Set(["pending", "in_progress", "done"])
+
+/**
+ * subagent 工具：派生子 agent 处理独立子任务（隔离上下文，只带回报告）。
+ * - 一批多个 subagent 调用走并行通道（parallel: true），适合广发探索
+ * - 不递归：子 agent 的 tools 里不含 subagent（depth > 0 不注入）
+ * - 普通模式：子 agent 的有副作用工具一律拒绝（研究型用法）；
+ *   auto 模式（agent.autoApprove）：全部放行
+ */
+export const subagentTool = {
+  name: "subagent",
+  description:
+    "Spawn a sub-agent to handle an independent subtask in an isolated context. The sub-agent has the same tools (except subagent itself) and returns only its final report. Spawn MULTIPLE subagents in the SAME response for parallel research—they run concurrently. Do not give parallel subagents tasks that edit the same files.",
+  parameters: {
+    type: "object",
+    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)" },
+    },
+    required: ["task"],
+  },
+  readonly: false,
+  parallel: true,
+  async execute(args, ctx) {
+    const parent = ctx.agent
+    const child = createAgent({
+      provider: parent.provider,
+      tools: parent.tools,
+      config: parent.config,
+      cwd: parent.cwd,
+      memory: parent.memory,
+    })
+    // 子 agent 的权限策略：auto 模式全放行；普通模式只读（拒绝写操作）
+    const childPermission = parent.autoApprove ? async () => true : async () => false
+    const input = args.context ? `背景：\n${args.context}\n\n任务：\n${args.task}` : args.task
+    const report = await runAgent(child, input, { onPermissionRequest: childPermission }, { depth: (ctx.depth ?? 0) + 1 })
+    const maxLen = 32000
+    return report.length > maxLen
+      ? report.slice(0, maxLen) + `\n\n[... report truncated: ${report.length} chars total, ${report.length - maxLen} omitted. Ask a follow-up if you need the missing details.]`
+      : report
+  },
+}
+
+/**
+ * task 工具：多步任务规划与进度跟踪（Claude Code 的 todo 模式）。
+ * 每次调用整体替换列表；只改 agent 内部状态、不碰外部世界，故 readonly。
+ * 通过 ctx.agent 访问调用方 agent（由 runAgent 注入）。
+ * 注：ctx.agent 的回写是有意的轻量耦合——task 本质是主循环的内建能力而非普通工具，
+ * 伪装成工具是为了让 LLM 用统一的 tool calling 协议调用它；替代方案（主循环特判）
+ * 会让循环代码更绕，不值。
+ */
+export const taskTool = {
+  name: "task",
+  description:
+    "Plan and track a task list for complex multi-step work. Replaces the entire list on each call. Use for requests needing 3+ steps: break work into items, keep exactly one in_progress, and CALL THIS TOOL AGAIN to mark each item done as soon as you complete it—a stale list is worse than none. Statuses: pending | in_progress | done.",
+  parameters: {
+    type: "object",
+    properties: {
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+            status: { type: "string", enum: ["pending", "in_progress", "done"] },
+          },
+          required: ["title", "status"],
+        },
+      },
+    },
+    required: ["items"],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const items = (args.items ?? []).map((it) => ({
+      title: String(it.title ?? "").slice(0, 200),
+      status: VALID_TASK_STATUS.has(it.status) ? it.status : "pending",
+    }))
+    ctx.agent.tasks = items
+    ctx.agent._onTaskUpdate?.(items)
+    const done = items.filter((i) => i.status === "done").length
+    const open = items.length - done
+    return `Task list updated: ${done}/${items.length} done` +
+      (open > 0 ? ` — ${open} item(s) still open; call task again as you complete them.` : " — all done.")
+  },
+}
+
+/** 项目指令文件候选（按优先级拼接所有存在的） */
+const INSTRUCTION_FILES = ["AGENTS.md", "agents.md", "PROJECT_RULES.md", "project_rules.md", ".thincoder/rules.md"]
+const MAX_INSTRUCTION_CHARS = 8000
+
+/** 读取项目指令（AGENTS.md / project_rules 等），没有则返回空串 */
+export async function loadProjectInstructions(cwd) {
+  const parts = []
+  for (const name of INSTRUCTION_FILES) {
+    try {
+      const text = await readFile(join(cwd, name), "utf8")
+      if (text.trim()) parts.push(`# ${name}\n${text.trim()}`)
+    } catch {
+      // 文件不存在，跳过
+    }
+    if (parts.join("\n").length > MAX_INSTRUCTION_CHARS) break
+  }
+  return parts.join("\n\n").slice(0, MAX_INSTRUCTION_CHARS)
+}
+
+const SYSTEM_PROMPT = `You are ThinCoder, a coding agent. Thin means sharp: you are a terse, precise engineer who cuts straight to the point—no fluff, no showing off, no filler. You write the most minimal, elegant code that solves the problem, and you say things in as few words as the truth allows.
+
+Rules:
+- Prefer tool calls over guessing. Read files before modifying them.
+- When you need multiple independent pieces of information (e.g. reading several files), make all independent tool calls in the SAME response so they can run in parallel.
+- Be concise in your final answers. Report what you did, not what you plan to do.
+- If the request is ambiguous at a decision that matters, stop and ask in your reply instead of guessing—but ask at most once, then proceed with the most reasonable interpretation.
+- When the user shares an observation or opinion, don't mistake it for a command—confirm before making changes.
+- For complex multi-step requests (3+ steps), use the task tool to plan and track progress; keep exactly one item in_progress, and update the list as you complete items—never finish with stale pending items.
+- 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. Delegate breadth-first exploration; do precision edits yourself. Never assign parallel subagents tasks that edit the same files.
+- Never fabricate file contents or command outputs; only trust tool results.
+- Before declaring a coding task complete, verify it: run the project's relevant tests/build if they exist. If you could not verify, say so explicitly—never present unverified work as done.
+- Run shell commands non-interactively: git commit -m, git --no-pager, -y/--yes flags where applicable. There is no TTY; editors and pagers (vim, less) cannot be used.
+- You have long-term memory via memory_put/memory_search. When you learn a durable fact about this project (convention, decision, debugging insight), save it with memory_put. Relevant memories may be injected below—use them.`
+
+/**
+ * 创建 agent。
+ * { provider, tools, config, cwd, memory? } —— memory 可空（无记忆模式）
+ */
+export function createAgent({ provider, tools, config, cwd, memory = null }) {
+  return {
+    provider,
+    tools,
+    config,
+    cwd,
+    memory,
+    history: [], // OpenAI 格式的对话历史（不含 system）
+    tasks: [], // task 工具维护的任务列表
+  }
+}
+
+/**
+ * 跑一轮任务。
+ * callbacks: {
+ *   onToken(text), onReasoning(text),
+ *   onToolCall(name, args), onToolResult(name, result),
+ *   onPermissionRequest(name, args) => Promise<boolean>  // 有副作用工具调用前询问；不提供则默认拒绝
+ * }
+ * 返回最终文本。
+ */
+export async function runAgent(agent, input, callbacks = {}, { depth = 0 } = {}) {
+  const maxTurns = agent.config?.agent?.maxTurns ?? DEFAULT_MAX_TURNS
+  const threshold = agent.config?.agent?.compactThreshold ?? 100_000
+  // 先修复历史（恢复的会话可能有中断的 tool_calls），再追加新输入
+  agent.history = repairHistory(agent.history)
+  agent.history.push({ role: "user", content: input })
+
+  // task 工具随主循环注入（内建能力）；subagent 只在顶层注入（禁止递归）
+  const tools = [...agent.tools, taskTool, ...(depth === 0 ? [subagentTool] : [])]
+  const toolSchemas = tools.map(toOpenAISchema)
+  const toolByName = new Map(tools.map((t) => [t.name, t]))
+  agent._onTaskUpdate = callbacks.onTaskUpdate
+
+  // 记忆注入：按用户输入检索相关记忆，附加到 system prompt
+  let systemPrompt = SYSTEM_PROMPT
+  const projectRules = await loadProjectInstructions(agent.cwd)
+  if (projectRules) {
+    systemPrompt += `\n\nProject instructions (follow these as project conventions):\n${projectRules}`
+  }
+  if (agent.memory) {
+    const memories = await memorySearch(agent.memory, input, { limit: 3 })
+    if (memories.length > 0) {
+      systemPrompt +=
+        "\n\nRelevant memories from previous sessions:\n" +
+        memories.map((m) => `- [${m.type}] ${m.title}: ${m.content}`).join("\n")
+    }
+  }
+
+  for (let turn = 0; turn < maxTurns; turn++) {
+    // 每轮 LLM 调用前检查上下文长度，超阈值先压缩（末尾是 user 或 tool 消息都是安全点；
+    // 但压缩只在末尾是 user 时最干净，tool 结尾说明在工具循环中段，下一轮再压）
+    if (agent.history.at(-1)?.role === "user") {
+      if (await compressIfNeeded(agent, threshold)) {
+        callbacks.onCompress?.()
+      }
+    }
+
+    const messages = [{ role: "system", content: systemPrompt }, ...agent.history]
+
+    const response = await chat(agent.provider, {
+      messages,
+      tools: toolSchemas,
+      onToken: callbacks.onToken,
+      onReasoning: callbacks.onReasoning,
+    })
+
+    // 无工具调用：最终回答，收尾
+    if (response.toolCalls.length === 0) {
+      agent.history.push({ role: "assistant", content: response.content })
+      return response.content
+    }
+
+    // 有工具调用：assistant 消息（含 tool_calls）入历史
+    agent.history.push({
+      role: "assistant",
+      content: response.content || null,
+      tool_calls: response.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments },
+      })),
+    })
+
+    const results = await executeToolCalls(agent, toolByName, response.toolCalls, callbacks, depth)
+
+    // 结果按 toolCallId 配对回喂（协议按 ID 不按位置，完成乱序无影响）
+    for (const { toolCall, result } of results) {
+      agent.history.push({
+        role: "tool",
+        tool_call_id: toolCall.id,
+        content: result,
+      })
+    }
+  }
+
+  throw new Error(`Agent exceeded max turns (${maxTurns})`)
+}
+
+/**
+ * 两段式执行：
+ * 阶段一（串行）：逐个解析参数 + 权限确认（有副作用工具）
+ * 阶段二（分类）：只读工具 Promise.all 并行；有副作用工具逐个串行
+ * 返回按 toolCallId 配对的结果数组。
+ */
+async function executeToolCalls(agent, toolByName, toolCalls, callbacks, depth = 0) {
+  // ---- 阶段一：串行准备 ----
+  const prepared = []
+  for (const toolCall of toolCalls) {
+    const tool = toolByName.get(toolCall.name)
+    let args = {}
+    try {
+      args = JSON.parse(toolCall.arguments || "{}")
+    } catch {
+      prepared.push({ toolCall, tool: null, error: `Invalid tool arguments JSON: ${toolCall.arguments}` })
+      continue
+    }
+
+    if (!tool) {
+      prepared.push({ toolCall, tool: null, error: `Unknown tool: ${toolCall.name}` })
+      continue
+    }
+
+    if (!tool.readonly) {
+      const allowed = callbacks.onPermissionRequest
+        ? await callbacks.onPermissionRequest(toolCall.name, args)
+        : false
+      if (!allowed) {
+        prepared.push({ toolCall, tool, denied: true })
+        continue
+      }
+    }
+
+    callbacks.onToolCall?.(toolCall.name, args)
+    prepared.push({ toolCall, tool, args })
+  }
+
+  // ---- 阶段二：分类执行 ----
+  const runOne = async (item) => {
+    if (item.error) return { ...item, result: `Error: ${item.error}` }
+    if (item.denied) return { ...item, result: "Error: permission denied by user" }
+    try {
+      const result = await item.tool.execute(item.args, {
+        cwd: agent.cwd,
+        agent,
+        depth,
+        onOutput: (chunk) => callbacks.onToolOutput?.(item.toolCall.name, chunk),
+      })
+      callbacks.onToolResult?.(item.toolCall.name, result)
+      return { ...item, result: String(result) }
+    } catch (error) {
+      return { ...item, result: `Error: ${error.message}` }
+    }
+  }
+
+  // 并行通道：只读工具 + 显式声明 parallel 的工具（subagent）；其余串行
+  const parallelItems = prepared.filter((p) => p.tool?.readonly || p.tool?.parallel)
+  const serialItems = prepared.filter((p) => p.tool && !p.tool.readonly && !p.tool.parallel)
+  const failedItems = prepared.filter((p) => !p.tool)
+
+  const parallelResults = await Promise.all(parallelItems.map(runOne))
+  const serialResults = []
+  for (const item of [...serialItems, ...failedItems]) {
+    serialResults.push(await runOne(item))
+  }
+
+  // 按原始 toolCall 顺序合并（保持历史可读性；协议层靠 ID 配对，顺序无关正确性）
+  const resultByCallId = new Map()
+  for (const r of [...parallelResults, ...serialResults]) {
+    resultByCallId.set(r.toolCall.id, r)
+  }
+  return toolCalls.map((tc) => resultByCallId.get(tc.id))
+}

package/src/checkpoint.mjs

@@ -0,0 +1,135 @@
+/**
+ * checkpoint.mjs — 工作区快照与回滚
+ * 快照 = git diff HEAD 补丁 + 未跟踪文件副本（尊重 .gitignore）。
+ * 仅 git 仓库内可用。回滚前会先打新快照（回滚可逆）。
+ */
+
+import { execFileSync } from "node:child_process"
+import { createHash } from "node:crypto"
+import { existsSync } from "node:fs"
+import { cp, mkdir, readFile, readdir, rm, writeFile, copyFile } from "node:fs/promises"
+import { dirname, join, relative } from "node:path"
+import { configDir } from "./config.mjs"
+
+const MAX_CHECKPOINTS = 20
+
+function git(cwd, args, { allowFail = false } = {}) {
+  try {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim()
+  } catch (error) {
+    if (allowFail) return null
+    throw new Error(`git ${args.join(" ")} failed: ${error.stderr?.toString().trim() || error.message}`)
+  }
+}
+
+function checkpointRoot(cwd) {
+  const hash = createHash("sha1").update(cwd).digest("hex").slice(0, 12)
+  return join(configDir, "checkpoints", hash)
+}
+
+/** 当前目录是否 git 仓库 */
+export function isGitRepo(cwd) {
+  return git(cwd, ["rev-parse", "--is-inside-work-tree"], { allowFail: true }) === "true"
+}
+
+/**
+ * 打快照。返回 { id, time, files } 或 null（非 git 仓库）。
+ */
+export async function createCheckpoint(cwd) {
+  if (!isGitRepo(cwd)) return null
+
+  const id = Date.now().toString(36)
+  const dir = join(checkpointRoot(cwd), id)
+  await mkdir(join(dir, "untracked"), { recursive: true })
+
+  // 跟踪文件的改动 → 补丁
+  const patch = git(cwd, ["diff", "HEAD", "--binary"], { allowFail: true }) ?? ""
+  await writeFile(join(dir, "patch.diff"), patch, "utf8")
+
+  // 未跟踪文件（尊重 .gitignore）→ 原样复制
+  const untrackedRaw = git(cwd, ["ls-files", "--others", "--exclude-standard"], { allowFail: true }) ?? ""
+  const untracked = untrackedRaw ? untrackedRaw.split("\n").filter(Boolean) : []
+  for (const rel of untracked) {
+    const src = join(cwd, rel)
+    const dst = join(dir, "untracked", rel)
+    await mkdir(dirname(dst), { recursive: true })
+    await copyFile(src, dst).catch(() => {}) // 复制失败（socket/设备文件等）跳过
+  }
+  await writeFile(join(dir, "meta.json"), JSON.stringify({ id, time: Date.now(), untracked }, null, 2), "utf8")
+
+  await pruneCheckpoints(cwd)
+  return { id, time: Date.now(), files: untracked.length + (patch ? 1 : 0) }
+}
+
+/** 列出快照（新→旧） */
+export async function listCheckpoints(cwd) {
+  const root = checkpointRoot(cwd)
+  if (!existsSync(root)) return []
+  const ids = (await readdir(root)).sort().reverse()
+  const out = []
+  for (const id of ids) {
+    try {
+      const meta = JSON.parse(await readFile(join(root, id, "meta.json"), "utf8"))
+      out.push({ id, time: meta.time, untracked: meta.untracked.length })
+    } catch {
+      // 损坏的快照跳过
+    }
+  }
+  return out
+}
+
+/**
+ * 回滚到指定快照（先把当前状态存成新快照，保证回滚可逆）。
+ * 返回恢复摘要。
+ */
+export async function rewind(cwd, id) {
+  const dir = join(checkpointRoot(cwd), id)
+  if (!existsSync(join(dir, "meta.json"))) throw new Error(`checkpoint ${id} not found`)
+  const meta = JSON.parse(await readFile(join(dir, "meta.json"), "utf8"))
+
+  // 回滚也可逆：先给当前状态打快照
+  await createCheckpoint(cwd)
+
+  // 1. 跟踪文件 → HEAD，再应用快照补丁 → 快照时状态
+  git(cwd, ["checkout", "--", "."])
+  const patch = await readFile(join(dir, "patch.diff"), "utf8")
+  if (patch.trim()) {
+    const patchFile = join(dir, "patch.diff")
+    git(cwd, ["apply", "--whitespace=nowarn", patchFile])
+  }
+
+  // 2. 快照之后新建的未跟踪文件 → 删除
+  const nowUntracked = (git(cwd, ["ls-files", "--others", "--exclude-standard"], { allowFail: true }) ?? "")
+    .split("\n")
+    .filter(Boolean)
+  const checkpointSet = new Set(meta.untracked)
+  let deleted = 0
+  for (const rel of nowUntracked) {
+    if (!checkpointSet.has(rel)) {
+      await rm(join(cwd, rel), { force: true })
+      deleted++
+    }
+  }
+
+  // 3. 快照时存在、现在被改/被删的未跟踪文件 → 还原
+  let restored = 0
+  for (const rel of meta.untracked) {
+    const src = join(dir, "untracked", rel)
+    if (existsSync(src)) {
+      await mkdir(dirname(join(cwd, rel)), { recursive: true })
+      await cp(src, join(cwd, rel), { force: true })
+      restored++
+    }
+  }
+
+  return { deleted, restored, patchApplied: Boolean(patch.trim()) }
+}
+
+/** 只留最近 MAX_CHECKPOINTS 个 */
+async function pruneCheckpoints(cwd) {
+  const root = checkpointRoot(cwd)
+  const ids = (await readdir(root)).sort()
+  while (ids.length > MAX_CHECKPOINTS) {
+    await rm(join(root, ids.shift()), { recursive: true, force: true })
+  }
+}

package/src/config.mjs

@@ -0,0 +1,106 @@
+/**
+ * config.mjs — 配置加载与保存
+ * 配置文件：~/.thincoder/config.json；API key 可用环境变量兜底。
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export const configDir = join(homedir(), ".thincoder")
+export const configPath = join(configDir, "config.json")
+
+const DEFAULTS = {
+  provider: {
+    baseURL: "https://api.deepseek.com/v1",
+    model: "deepseek-chat",
+  },
+  agent: {
+    maxTurns: 50,
+    compactThreshold: 100000,
+  },
+  memory: {
+    dbPath: join(configDir, "memory.db"),
+    projectDir: ".thincoder/memory",
+    team: null,
+  },
+  embedding: {
+    baseURL: "https://api.siliconflow.cn/v1",
+    model: "BAAI/bge-m3",
+  },
+}
+
+/**
+ * 已知模型的上下文窗口（前缀匹配，长的在前）。
+ * compactThreshold 未显式配置时，按窗口 * COMPACT_RATIO 自动推导。
+ */
+const MODEL_CONTEXT_WINDOWS = [
+  ["deepseek-v4-pro", 1_000_000],
+  ["deepseek-v4-flash", 256_000],
+  ["deepseek-reasoner", 64_000],
+  ["deepseek-chat", 64_000],
+  ["moonshot", 256_000],
+  ["kimi", 256_000],
+  ["gpt-4.1", 1_000_000],
+  ["gpt-4o", 128_000],
+  ["qwen", 128_000],
+]
+const DEFAULT_CONTEXT_WINDOW = 128_000
+const COMPACT_RATIO = 0.6
+
+export function contextWindowForModel(model) {
+  const m = (model ?? "").toLowerCase()
+  for (const [prefix, window] of MODEL_CONTEXT_WINDOWS) {
+    if (m.startsWith(prefix)) return window
+  }
+  return DEFAULT_CONTEXT_WINDOW
+}
+
+/** 推导压缩阈值；explicit 为配置文件中显式设置的值（优先），否则按模型自动算 */
+export function resolveCompactThreshold(explicit, model) {
+  if (explicit != null) return { value: explicit, auto: false }
+  return { value: Math.floor(contextWindowForModel(model) * COMPACT_RATIO), auto: true }
+}
+
+/**
+ * 加载配置：文件 + 环境变量兜底（key 不明文落盘时走 env）。
+ * 环境变量优先级：THINCODER_API_KEY > DEEPSEEK_API_KEY > OPENAI_API_KEY
+ */
+export function loadConfig() {
+  let config = {}
+  if (existsSync(configPath)) {
+    config = JSON.parse(readFileSync(configPath, "utf8"))
+  }
+
+  const merged = {
+    ...DEFAULTS,
+    ...config,
+    provider: { ...DEFAULTS.provider, ...config.provider },
+    agent: { ...DEFAULTS.agent, ...config.agent },
+    memory: { ...DEFAULTS.memory, ...config.memory },
+    embedding: { ...DEFAULTS.embedding, ...config.embedding },
+  }
+
+  if (!merged.provider.apiKey) {
+    merged.provider.apiKey =
+      process.env.THINCODER_API_KEY || process.env.DEEPSEEK_API_KEY || process.env.OPENAI_API_KEY
+  }
+  if (process.env.THINCODER_BASE_URL) merged.provider.baseURL = process.env.THINCODER_BASE_URL
+  if (process.env.THINCODER_MODEL) merged.provider.model = process.env.THINCODER_MODEL
+  if (!merged.embedding.apiKey) {
+    merged.embedding.apiKey = process.env.SILICONFLOW_API_KEY || process.env.THINCODER_EMBEDDING_API_KEY
+  }
+
+  // 压缩阈值跟模型走：配置文件显式设置的优先，否则按模型上下文窗口自动推导
+  const explicitThreshold = config.agent?.compactThreshold
+  const { value, auto } = resolveCompactThreshold(explicitThreshold, merged.provider.model)
+  merged.agent.compactThreshold = value
+  merged.agent.compactThresholdAuto = auto
+
+  return merged
+}
+
+export function saveConfig(config) {
+  mkdirSync(configDir, { recursive: true })
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8")
+}

package/src/context.mjs

@@ -0,0 +1,76 @@
+/**
+ * context.mjs — 上下文管理与压缩
+ * token 用 length/4 粗估（不引 tokenizer 依赖）。
+ * 压缩策略：保留最早 2 条 + 最近 N 条，中间由 LLM 摘要成一条（学 kimi-code，简化版）。
+ */
+
+import { chat } from "./provider.mjs"
+
+/** 粗估一组消息的 token 数（正文 + tool_calls 参数） */
+export function estimateTokens(messages) {
+  let chars = 0
+  for (const m of messages) {
+    if (typeof m.content === "string") chars += m.content.length
+    for (const tc of m.tool_calls ?? []) {
+      chars += (tc.function?.name?.length ?? 0) + (tc.function?.arguments?.length ?? 0)
+    }
+  }
+  return Math.ceil(chars / 4)
+}
+
+const KEEP_HEAD = 2 // 最早的用户意图，不能丢
+const KEEP_TAIL = 10 // 最近的工作现场，不能丢
+
+const SUMMARIZE_PROMPT = `你是一个对话压缩器。把下面的 agent 工作记录压缩成一份紧凑的摘要，供后续对话作为上下文使用。
+要求：
+- 保留：用户的原始需求、做出的决策、修改过的文件及原因、未解决的问题、下一步计划
+- 丢弃：客套话、重复内容、工具输出的细枝末节
+- 用中文条目式输出，控制在 500 字以内
+
+工作记录：
+`
+
+/**
+ * 如果历史超长则压缩。返回是否发生了压缩。
+ * 只在循环的安全点调用（history 末尾是 user 消息时）。
+ */
+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
+
+  // 切分：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 // 没有可压缩的中间段
+
+  const head = history.slice(0, KEEP_HEAD)
+  const middle = history.slice(KEEP_HEAD, tailStart)
+  const tail = history.slice(tailStart)
+
+  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")
+
+  const summary = await chat(agent.provider, {
+    messages: [{ role: "user", content: SUMMARIZE_PROMPT + serialized }],
+  })
+
+  agent.history = [
+    ...head,
+    {
+      role: "user",
+      content: `[前文摘要：以下是更早对话的压缩记录]\n${summary.content}`,
+    },
+    { role: "assistant", content: "了解，我会基于这份摘要和最近的对话继续工作。" },
+    ...tail,
+  ]
+  return true
+}