@raolin2025/claude-code-node 2.8.11 → 2.8.13

package/README.md

@@ -67,6 +67,8 @@ cc-node --resume session-1747000000000-abc123
 | `--resume` | `-r` | 恢复会话 ID | |
 | `--verbose` | `-v` | 详细输出 | `false` |
 | `--no-stream` | | 禁用流式响应 | `false` |
+| `--max-messages` | | 消息条数上限，超过则折叠早期历史为摘要（解决本地小模型"条数过多变傻"） | `0`（关闭） |
+| `--small-model` | | 小模型适配模式（强制工具调用 + 敷衍重试 + 意图引导 + 工具精简） | `false` |
 | `--stdio` | | **JSON-RPC 服务器模式**（供桥接层/外部客户端接入，见下） | |
 | `--help` | `-h` | 显示帮助 | |
 
@@ -136,16 +138,25 @@ cc-node 会自动感知当前所用模型的**上下文窗口长度**，并在
 
 ### 自动压缩机制（滑动窗口）
 
-上下文**永不超出窗口**，采用"摘要优先 + 滑动窗口裁剪兜底"的双层策略：
+上下文**永不超出窗口**，采用"条数折叠 + 摘要优先 + 滑动窗口裁剪兜底"的多层策略：
 
-1. **摘要式压缩**（信息量更高）：每次新消息加入 / 工具结果返回 / 发送前，用**实时 token
+**0. 发送前常驻工具结果截断**（v2.8.12）：每次发送前（不依赖是否超窗）对**超长工具结果**
+（默认 >6000 字符）做截断，从源头压住"工具结果过程噪音"堆积，避免它们淹没模型对最新
+指令的注意力。
+
+**1. 消息条数折叠**（v2.8.12，`--max-messages N` 开启，默认关闭）：当上下文**消息条数**
+超过 `N`（如 80）时，把早期历史折叠成一条摘要（保留 `Main goal` / 工具使用 / 关键结果），
+仅保留最近 4 轮完整对话。这解决**本地小模型（如 27B）"token 未超窗但 200+ 条消息却变傻、
+不干活"**的问题——这类模型对"消息条数"比"token 数"更敏感。
+
+**2. 摘要式压缩**（信息量更高）：每次新消息加入 / 工具结果返回 / 发送前，用**实时 token
    估算**判断是否超窗；超窗时把早期对话压缩为摘要（保留最近 4 轮 + 摘要），目标压到窗口
    的 60%。摘要会**显式标注最早的 `Main goal`（核心任务主线）**，并保留最早的关键发现与
    最新结果，避免例行内容淹没核心任务（防止 AI 压缩后失忆）。
    > **保守触发（v2.8.11）**：由于启发式估算可能比模型真实 token 偏少，压缩**提前到
    > 可用窗口的 85%** 即触发（`compressSafetyFactor`，默认 0.85），给 tokenization 差异
    > 留余量，避免实际请求超过模型窗口（如 `exceed_context_size_error` 400 错误）。
-2. **滑动窗口精确裁剪**（兜底，保证永不超窗）：摘要压缩后仍超窗时，从**最早的消息**逐条
+**3. 滑动窗口精确裁剪**（兜底，保证永不超窗）：摘要压缩后仍超窗时，从**最早的消息**逐条
    挤出，**最新信息始终保留在末尾**，直到总 token ≤ 窗口上限。system 提示永不裁剪；
    **被裁剪的早期历史会压缩成一条摘要 system 保留**（避免 AI 丢失上下文主线）；极端情况
    （单条消息超窗）仍保留 system + 最近一条，保证至少能发出请求。
@@ -166,6 +177,29 @@ cc-node 会自动感知当前所用模型的**上下文窗口长度**，并在
 
 > 切换模型（`/model`）后会自动重新探测窗口。`/budget` 也会显示当前窗口与 80% 触发阈值。
 
+### 🤖 小模型适配模式（--small-model）
+
+> 专为 **本地小模型**（如 27B Q3 量化）设计，让编程工具在弱模型下也能可靠工作。
+> 默认关闭，通过 `--small-model` 或 `config.smallModel=true` 开启。
+
+小模型的核心弱点是"规划 + 工具调用 + 自我纠错"不稳定——常只回 `Solved by sharing best practices.`
+这类空话、不调工具，或多轮往返后"丢"了目标。该模式把智能从"模型端"转移到"框架端"：
+
+| 层 | 机制 | 作用 |
+|----|------|------|
+| **A · 兜底** | 强化 system prompt | 明确告诉模型"必须调用工具完成任务，不能只回文字" |
+| **A · 兜底** | 敷衍输出检测 + 重试 | 检测到空话/太短/无工具调用时，追加强引导重试一次 |
+| **A · 兜底** | 工具数量精简 | 按用户指令意图只暴露核心工具子集，降低选择负担 |
+| **B · 替代** | 意图识别 + 引导 | 用规则把"写文档/找文件/跑命令/改代码"映射到明确工具，注入任务引导 |
+
+```bash
+cc-node --api-base http://127.0.0.1:18080/v1 --model ./local-model.gguf \
+  --with-notify --small-model --max-messages 80
+```
+
+> **配合 `--max-messages N`**：两者互补——`--max-messages` 解决"条数过多"，
+> `--small-model` 解决"模型不会自主调工具"。小模型场景建议一起开启。
+
 ---
 
 ## 🛠️ 内置工具（10 个）
@@ -330,6 +364,8 @@ cc-node --api-base http://localhost:11434/v1
   "model": "deepseek-chat",
   "maxTurns": 100,
   "maxBudgetTokens": 128000,
+  "maxMessages": 80,
+  "smallModel": true,
   "permissionMode": "ask",
   "tools": {
     "bash": { "timeout": 120 },
@@ -345,6 +381,14 @@ cc-node --api-base http://localhost:11434/v1
 > **`maxBudgetTokens`**：手动指定的上下文窗口上限（token 数）。
 > 为 `0` 或未设置时，自动探测模型真实窗口；手动指定后优先于自动探测，
 > 等价于 `/window N` 的效果，并持久化保存。
+>
+> **`maxMessages`**：消息条数上限（可选，默认关闭/`0`）。当上下文消息条数超过该值时，
+> 自动折叠早期历史为摘要（保留 Main goal + 最近 4 轮完整对话），解决本地小模型
+> "条数过多、token 不高却变傻"的问题。等价于 `--max-messages N`。
+>
+> **`smallModel`**：小模型适配模式（可选，默认关闭/`false`）。开启后启用强制工具调用
+> 引导、敷衍输出检测重试、意图识别 + 工具精简，让弱模型（如 27B Q3 量化）也能可靠
+> 完成编程任务。等价于 `--small-model`。
 
 [![npm version](https://img.shields.io/npm/v/@raolin2025/claude-code-node.svg)](https://www.npmjs.com/package/@raolin2025/claude-code-node) [![GitHub](https://img.shields.io/badge/GitHub-bg1avd%2Fclaude--code--node-blue)](https://github.com/bg1avd/claude-code-node) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.8.11",
+  "version": "2.8.13",
   "description": "Node.js AI Code Agent CLI - Zero dependencies, pure JavaScript, security hardened, multi-channel notifications, Telegram & QQ Bot remote programming, rich media upload, multi-account management",
   "type": "module",
   "main": "src/core/index.js",

package/src/__tests__/compact-window.test.js

@@ -11,7 +11,7 @@
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { trimToWindow, compactMessages } from '../core/compact.js'
+import { trimToWindow, compactMessages, foldHistoryByCount, trimToolResults } from '../core/compact.js'
 import { TokenBudget } from '../core/token-budget.js'
 
 /** 构造一个固定窗口的 TokenBudget */
@@ -187,3 +187,100 @@ test('摘要改进：数字归一化去重，避免例行序号占满摘要', ()
   const intentCount = (sm.content.match(/例行检查/g) || []).length
   assert.ok(intentCount <= 2, `例行意图应被去重（实际 ${intentCount} 条）`)
 })
+
+// ============================================================
+// foldHistoryByCount — 按消息条数折叠（解决"条数过多、token不高却变傻"）
+// ============================================================
+
+/** 构造带工具结果的对话：system + n 轮（每轮 user + assistant(tool_calls) + tool + assistant） */
+function makeToolMessages(n, { sysContent = 'SYS' } = {}) {
+  const msgs = [{ role: 'system', content: sysContent }]
+  for (let i = 0; i < n; i++) {
+    msgs.push({ role: 'user', content: `用户任务 ${i}：做点事` })
+    msgs.push({ role: 'assistant', content: '', toolCalls: [{ id: `c${i}`, name: 'Bash', input: { command: 'ls' } }] })
+    msgs.push({ role: 'tool', tool_call_id: `c${i}`, content: `工具结果 ${i} 的内容` })
+    msgs.push({ role: 'assistant', content: `完成 ${i} 的汇报` })
+  }
+  return msgs
+}
+
+test('条数折叠：未超过 maxMessages 时原样保留', () => {
+  const msgs = makeToolMessages(5) // 1 + 20 = 21 条
+  const r = foldHistoryByCount(msgs, { maxMessages: 80 })
+  assert.equal(r.folded, false)
+  assert.equal(r.removed, 0)
+  assert.equal(r.messages.length, msgs.length)
+})
+
+test('条数折叠：超过 maxMessages 时把早期历史折叠为摘要', () => {
+  const msgs = makeToolMessages(30) // 1 + 120 = 121 条 > 80
+  const r = foldHistoryByCount(msgs, { maxMessages: 80, keepRecentTurns: 4 })
+  assert.equal(r.folded, true)
+  assert.ok(r.removed > 0, '应移除早期消息')
+  assert.ok(r.messages.length < msgs.length, '折叠后消息数应减少')
+  // 折叠后消息数应显著降低（远低于 121）
+  assert.ok(r.messages.length < 60, `折叠后应降到可管理数量（实际 ${r.messages.length}）`)
+  // 摘要 system 保留
+  assert.ok(r.messages.some(m => m.role === 'system' && m.content.includes('Context Summary')),
+    '应插入折叠摘要 system')
+  // Main goal 保留最早的核心任务
+  assert.ok(r.summary.includes('用户任务 0'), '摘要应保留最早的核心任务')
+})
+
+test('条数折叠：最新 4 轮完整对话保留在末尾（含工具调用链无空洞）', () => {
+  const msgs = makeToolMessages(20) // 1 + 80 = 81 条 > 80
+  const r = foldHistoryByCount(msgs, { maxMessages: 80, keepRecentTurns: 4 })
+  // 保留最近 4 轮 = 16 条 + system + 摘要 system
+  // 检查末尾保留了最新的用户任务
+  const lastUser = [...r.messages].reverse().find(m => m.role === 'user')
+  assert.ok(lastUser, '应有 user 消息')
+  assert.ok(lastUser.content.includes('用户任务 19'), '最新一轮应保留')
+})
+
+test('条数折叠：system 提示永不折叠', () => {
+  const msgs = makeToolMessages(30)
+  const r = foldHistoryByCount(msgs, { maxMessages: 80 })
+  assert.equal(r.messages[0].role, 'system')
+  assert.equal(r.messages[0].content, 'SYS')
+})
+
+test('条数折叠：keepRecentTurns=1 时只保留最新一轮', () => {
+  const msgs = makeToolMessages(10) // 1 + 40 = 41 条
+  const r = foldHistoryByCount(msgs, { maxMessages: 20, keepRecentTurns: 1 })
+  assert.equal(r.folded, true)
+  // 1(system) + 1(摘要) + 4(最新一轮) = 6
+  assert.equal(r.messages.length, 6, `应保留 system+摘要+最新一轮（实际 ${r.messages.length}）`)
+})
+
+// ============================================================
+// trimToolResults — 发送前常驻工具结果截断（不依赖超窗）
+// ============================================================
+
+test('工具结果截断：超长工具结果被截断到 maxChars', () => {
+  const msgs = [
+    { role: 'tool', tool_call_id: 'a', content: 'x'.repeat(10000) },
+  ]
+  const r = trimToolResults(msgs, 6000)
+  assert.ok(r[0].content.length <= 6000 + 50, `截断后长度 ${r[0].content.length} 应 ≤ 6000`)
+  assert.ok(r[0].content.includes('truncated'), '应有截断标记')
+})
+
+test('工具结果截断：未超长的不受影响', () => {
+  const msgs = [
+    { role: 'tool', tool_call_id: 'a', content: 'short' },
+    { role: 'user', content: 'hello' },
+  ]
+  const r = trimToolResults(msgs, 6000)
+  assert.equal(r[0].content, 'short')
+  assert.equal(r[1].content, 'hello')
+})
+
+test('工具结果截断：非 tool 消息与空内容不受影响', () => {
+  const msgs = [
+    { role: 'user', content: 'x'.repeat(10000) }, // user 不截断
+    { role: 'tool', tool_call_id: 'a', content: '' },
+  ]
+  const r = trimToolResults(msgs, 100)
+  assert.equal(r[0].content.length, 10000, 'user 消息不应被截断')
+  assert.equal(r[1].content, '')
+})

package/src/__tests__/small-model.test.js

@@ -0,0 +1,140 @@
+/**
+ * 小模型适配层 (small-model.js) 测试
+ *
+ * 验证：
+ *   - 敷衍输出检测（isFillerResponse）：空话/太短/命中占位句识别
+ *   - 意图识别（detectIntent）：写文件/找文件/跑命令/改代码等映射
+ *   - 意图引导（buildIntentGuidance）：生成注入的引导文本
+ *   - 工具精简（selectRelevantTools）：按意图筛选核心工具
+ *   - system prompt 强化（buildSmallModelSystemPrompt）
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  isFillerResponse,
+  detectIntent,
+  buildIntentGuidance,
+  selectRelevantTools,
+  buildSmallModelSystemPrompt,
+  SMALL_MODEL_SYSTEM_PROMPT,
+  isSmallModelEnabled,
+} from '../core/small-model.js'
+
+// ---- 敷衍输出检测 ----
+test('敷衍检测：命中空话占位句', () => {
+  assert.equal(isFillerResponse({ content: 'Solved by sharing best practices.', toolCalls: [] }), true)
+  assert.equal(isFillerResponse({ content: 'Done. This is the kind of mistake that costs real money.', toolCalls: [] }), true)
+  assert.equal(isFillerResponse({ content: 'Let me think about this.', toolCalls: [] }), true)
+})
+
+test('敷衍检测：空回复/太短', () => {
+  assert.equal(isFillerResponse({ content: '', toolCalls: [] }), true)
+  assert.equal(isFillerResponse({ content: '  ', toolCalls: [] }), true)
+  assert.equal(isFillerResponse({ content: 'ok', toolCalls: [] }), true)
+  assert.equal(isFillerResponse({ content: '好的', toolCalls: [] }), true)
+})
+
+test('敷衍检测：有工具调用不算敷衍', () => {
+  assert.equal(isFillerResponse({ content: 'ok', toolCalls: [{ id: '1' }] }), false)
+})
+
+test('敷衍检测：正常实质回答不算敷衍', () => {
+  const content = '我已经分析了项目结构，发现3个主要模块需要重构，分别是订单、行情和风控模块，建议先处理订单模块。'
+  assert.equal(isFillerResponse({ content, toolCalls: [] }), false)
+})
+
+// ---- 意图识别 ----
+test('意图识别：写文档任务', () => {
+  const r = detectIntent('做好开发计划文档')
+  assert.ok(r, '应识别到意图')
+  assert.ok(r.toolHint.includes('Write'), '应提示用 Write 工具')
+  const r2 = detectIntent('把你的计划写入文档')
+  assert.ok(r2 && r2.toolHint.includes('Write'))
+})
+
+test('意图识别：找文件任务', () => {
+  const r = detectIntent('查找src目录下的文件')
+  assert.ok(r && r.toolHint.includes('Glob'))
+  assert.ok(r.toolHint.includes('Grep'))
+})
+
+test('意图识别：跑命令任务', () => {
+  const r = detectIntent('运行一下测试')
+  assert.ok(r && r.toolHint.includes('Bash'))
+})
+
+test('意图识别：改代码任务', () => {
+  const r = detectIntent('修复这个bug')
+  assert.ok(r && r.toolHint.includes('Edit'))
+})
+
+test('意图识别：联网搜索任务', () => {
+  const r = detectIntent('搜索一下最新的量化交易资料')
+  assert.ok(r && r.toolHint.includes('WebSearch'))
+})
+
+test('意图识别：无匹配返回 null', () => {
+  assert.equal(detectIntent('你好'), null)
+  assert.equal(detectIntent(''), null)
+})
+
+// ---- 意图引导 ----
+test('意图引导：生成注入文本', () => {
+  const g = buildIntentGuidance('做好开发计划文档', { enable: true })
+  assert.ok(g, '应生成引导')
+  assert.ok(g.includes('Write'), '引导应包含工具建议')
+  assert.ok(g.includes('任务引导'), '应有引导标记')
+})
+
+test('意图引导：未启用或未匹配返回 null', () => {
+  assert.equal(buildIntentGuidance('做好开发计划文档', { enable: false }), null)
+  assert.equal(buildIntentGuidance('你好', { enable: true }), null)
+})
+
+// ---- 工具精简 ----
+const fakeTools = [
+  { name: 'Bash', description: 'd' },
+  { name: 'Read', description: 'd' },
+  { name: 'Edit', description: 'd' },
+  { name: 'Write', description: 'd' },
+  { name: 'Glob', description: 'd' },
+  { name: 'Grep', description: 'd' },
+  { name: 'WebSearch', description: 'd' },
+  { name: 'WebFetch', description: 'd' },
+  { name: 'GitTool', description: 'd' },
+  { name: 'NpmPublish', description: 'd' },
+]
+
+test('工具精简：按意图保留相关工具', () => {
+  const reduced = selectRelevantTools(fakeTools, '做好开发计划文档', { enable: true })
+  assert.ok(reduced.length < fakeTools.length, '应精简工具数量')
+  assert.ok(reduced.some(t => t.name === 'Write'), '应保留 Write')
+  // 不相关的如 NpmPublish 不应保留
+  assert.ok(!reduced.some(t => t.name === 'NpmPublish'), '不应保留无关工具')
+})
+
+test('工具精简：未启用返回全部', () => {
+  assert.equal(selectRelevantTools(fakeTools, 'xx', { enable: false }), fakeTools)
+})
+
+test('工具精简：无明确意图时返回核心文件工具', () => {
+  const reduced = selectRelevantTools(fakeTools, '你好', { enable: true })
+  assert.ok(reduced.length <= 6, '应只保留核心工具')
+  assert.ok(reduced.some(t => t.name === 'Bash'))
+})
+
+// ---- system prompt 强化 ----
+test('system prompt 强化：追加工具使用铁律', () => {
+  const base = 'You are cc-node.'
+  const enhanced = buildSmallModelSystemPrompt(base)
+  assert.ok(enhanced.includes(base), '应保留基础 prompt')
+  assert.ok(enhanced.includes('工具调用 Agent'), '应包含工具调用强化引导')
+  assert.ok(enhanced.includes(SMALL_MODEL_SYSTEM_PROMPT), '应追加强化 prompt')
+})
+
+// ---- 开关判断 ----
+test('小模型开关判断', () => {
+  assert.equal(isSmallModelEnabled({ smallModel: true }), true)
+  assert.equal(isSmallModelEnabled({ smallModel: false }), false)
+  assert.equal(isSmallModelEnabled(undefined), false)
+})

package/src/core/cli.js

@@ -330,6 +330,8 @@ function parseArgs(argv) {
     apiBase: 'https://api.deepseek.com/v1',
     resume: null,
     noStream: false,
+    maxMessages: 0,
+    smallModel: false,
   }
 
   let i = 2
@@ -345,6 +347,8 @@ function parseArgs(argv) {
       case '--resume': case '-r': args.resume = argv[++i]; break
       case '--verbose': case '-v': args.verbose = true; break
       case '--no-stream': args.noStream = true; break
+      case '--max-messages': args.maxMessages = parseInt(argv[++i], 10); break
+      case '--small-model': args.smallModel = true; break
       case '--stdio': args.stdio = true; break
       case '--with-notify': args.withNotify = true; break
       case '--version':
@@ -365,6 +369,8 @@ Options:
   --version                 Show version
   -v, --verbose             Verbose mode
   --no-stream               Disable streaming
+  --max-messages N          Fold history when message count exceeds N (default: 0 = off)
+  --small-model             Enable small-model adaptation (tool-call enforcement, filler retry, intent guidance)
   --with-notify             Start built-in channel listener (Telegram)
                             (replaces cc-notify daemon — no external script needed)
   -h, --help                Show this help
@@ -525,6 +531,10 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
     costTracker,
     tokenBudget,
     configStore: config,
+    // 消息条数上限（折叠早期历史，解决本地小模型"条数过多变傻"）；0 = 关闭
+    maxMessages: cliArgs.maxMessages || config.get('maxMessages') || 0,
+    // 小模型适配模式（强制工具调用 + 敷衍重试 + 意图引导 + 工具精简）
+    smallModel: cliArgs.smallModel || config.get('smallModel') || false,
   })
   const engine = new QueryEngine(engineConfig)
 

package/src/core/compact.js

@@ -142,6 +142,115 @@ function isConclusionLike(text) {
   return CONCLUSION_HINTS.some(k => s.includes(k))
 }
 
+/**
+ * 发送前常驻工具结果截断 — 不依赖是否超窗
+ *
+ * 背景：长对话中工具结果（命令回显、git 输出等）会不断累积，即便单条不长，
+ * 条数一多也会让模型（尤其本地小模型）"迷失"在过程噪音里。旧逻辑只在 token
+ * 超窗时才截断，导致 token 未超窗（如 37%）但 200+ 条消息让模型变傻。
+ *
+ * 本函数在【每次发送前】都对工具结果做上限截断（默认 6000 字符），
+ * 阈值比压缩时的 maxToolResultChars（2000）宽松，避免频繁误截，
+ * 同时把"超长噪音"从源头上压住。
+ *
+ * @param {Array} messages — 消息列表
+ * @param {number} [maxChars=6000] — 工具结果保留的最大字符数
+ * @returns {Array} 截断后的消息列表（原列表被浅拷贝修改，不影响调用方原始引用结构）
+ */
+export function trimToolResults(messages, maxChars = 6000) {
+  return messages.map(msg => {
+    if (msg.role === 'tool' && typeof msg.content === 'string' && msg.content.length > maxChars) {
+      return {
+        ...msg,
+        content: msg.content.slice(0, maxChars) + `\n[...tool result truncated: kept ${maxChars} chars]`,
+      }
+    }
+    return msg
+  })
+}
+
+/**
+ * 按消息条数折叠历史 — 解决"条数过多、token 不高却变傻"
+ *
+ * 背景：27B 等本地小模型对"消息条数"比"token 数"更敏感。一个 session 塞进
+ * 200+ 条消息（113 条工具结果 + 84 条 assistant + 多个 user），即便 token 只占
+ * 窗口 37%，模型也会因为角色切换频繁、工具结果噪音堆积而"迷失"当前指令。
+ *
+ * 本函数在消息条数超过 maxMessages 时，把早期历史折叠成一条摘要
+ * （保留 Main goal + 工具使用 + 关键结果），仅保留最近 keepRecentTurns 轮的
+ * 完整对话，把消息条数压到可管理范围，同时不丢主线。
+ *
+ * @param {Array} messages — 完整消息列表
+ * @param {object} options
+ * @param {number} [options.maxMessages=80] — 超过此条数即触发折叠
+ * @param {number} [options.keepRecentTurns=4] — 保留最近 N 轮完整对话
+ * @param {number} [options.maxToolResultChars=2000] — 折叠时工具结果截断长度
+ * @returns {{ folded: boolean, messages: Array, removed: number, summary: string|null }}
+ */
+export function foldHistoryByCount(messages, options = {}) {
+  const maxMessages = options.maxMessages || 80
+  const keepRecentTurns = options.keepRecentTurns ?? 4
+  const maxToolResultChars = options.maxToolResultChars || 2000
+
+  // 未超过条数阈值 → 不折叠
+  if (messages.length <= maxMessages) {
+    return { folded: false, messages, removed: 0, summary: null }
+  }
+
+  // 分离 system 提示（首条 system 永不折叠）与普通消息
+  const systemMsgs = []
+  const body = []
+  for (const m of messages) {
+    if (m.role === 'system' && systemMsgs.length === 0) {
+      systemMsgs.push(m)
+    } else {
+      body.push(m)
+    }
+  }
+
+  // 找到分界点：保留最近 keepRecentTurns 轮
+  // 一轮 = user + assistant(+tool_calls) + tool 结果们 + assistant 最终回复
+  // 从末尾倒推，数到第 keepRecentTurns 个 user 即分界（splitIndex 指向该轮起点，
+  // 使得 recentMessages 恰好包含最近 keepRecentTurns 轮完整对话）
+  let turnCount = 0
+  let splitIndex = body.length
+  for (let i = body.length - 1; i >= 0; i--) {
+    if (body[i].role === 'user') {
+      turnCount++
+      if (turnCount >= keepRecentTurns) {
+        splitIndex = i
+        break
+      }
+    }
+  }
+
+  // 没有可折叠的早期消息（全都要保留）→ 不折叠
+  if (splitIndex <= 0 || splitIndex >= body.length) {
+    return { folded: false, messages, removed: 0, summary: null }
+  }
+
+  const earlyMessages = body.slice(0, splitIndex)
+  const recentMessages = body.slice(splitIndex)
+
+  // 对折叠掉的历史生成摘要（保留 Main goal / 工具 / 关键结果）
+  const summary = generateSummary(earlyMessages)
+
+  // 构建折叠后的消息列表：system + (摘要 system) + 最近 N 轮完整对话
+  const folded = [...systemMsgs]
+  folded.push({
+    role: 'system',
+    content: `[Context Summary — ${new Date().toISOString()}]\n${summary}\n[End of Summary — recent conversation follows]`,
+  })
+  folded.push(...recentMessages)
+
+  return {
+    folded: true,
+    messages: folded,
+    removed: earlyMessages.length,
+    summary,
+  }
+}
+
 /**
  * 从消息列表生成摘要
  *

package/src/core/query-engine.js

@@ -14,7 +14,15 @@
 import crypto from 'crypto'
 import { UserMessage, AssistantMessage, ToolCall, ToolResult, SessionState } from '../types/index.js'
 import { parseStream, parseNonStreamResponse } from './streaming.js'
-import { compactMessages, trimToWindow } from './compact.js'
+import { compactMessages, trimToWindow, foldHistoryByCount, trimToolResults } from './compact.js'
+import {
+  isSmallModelEnabled,
+  buildSmallModelSystemPrompt,
+  isFillerResponse,
+  buildIntentGuidance,
+  selectRelevantTools,
+  RETRY_GUIDANCE,
+} from './small-model.js'
 import { CostTracker } from './cost-tracker.js'
 import { EnhancedPermissionChecker } from '../security/enhanced-permission.js'
 import { isLocalLlmServer, buildAuthHeaders } from '../utils/index.js'
@@ -34,6 +42,17 @@ export class QueryEngineConfig {
     this.maxBudgetTokens = options.maxBudgetTokens || 1_000_000
     // 压缩触发保守系数（0~1）：估算到可用窗口的该比例即触发压缩，留出 tokenization 差异余量
     this.compressSafetyFactor = options.compressSafetyFactor ?? 0.85
+    // 消息条数上限：超过则强制折叠早期历史（解决本地小模型"条数过多、token不高却变傻"）
+    // 0 表示不启用条数折叠（仅按 token）
+    this.maxMessages = options.maxMessages || 0
+    // 发送前常驻工具结果截断长度（字符），防止超长工具结果堆积（0 表示不截断）
+    this.maxToolResultChars = options.maxToolResultChars || 6000
+    // 小模型适配模式（让弱模型可靠工作）：
+    //   - 强化 system prompt（强制工具调用）
+    //   - 敷衍输出检测 + 重试
+    //   - 工具数量精简 + 意图引导
+    // 默认关闭，通过 config.smallModel=true 或 --small-model 开启
+    this.smallModel = options.smallModel || false
     this.permissionMode = options.permissionMode || 'ask'
     this.verbose = options.verbose || false
     // API 配置 — 通用 OpenAI 兼容协议
@@ -69,6 +88,8 @@ export class QueryEngine {
     this.tokenBudget = this.config.tokenBudget || null
     // 最近一次 processMessage 是否已通过流式回调/直写把正文输出（供调用方避免重复打印 response）
     this.lastStreamed = false
+    // 当前正在处理的用户输入（小模型模式用于按意图精简工具集）
+    this.currentUserInput = ''
   }
 
   /**
@@ -84,6 +105,7 @@ export class QueryEngine {
     this.state.turnCount++
     this.lastStreamed = false  // 本轮是否已流式输出正文
     this.abortController = new AbortController()
+    this.currentUserInput = userInput  // 记录当前用户指令（小模型模式按意图精简工具）
     const userMsg = new UserMessage(userInput, images)
     this.state.messages.push(userMsg)
 
@@ -100,14 +122,17 @@ export class QueryEngine {
   }
 
   /**
-   * 确保上下文 ≤ 窗口（滑动窗口语义）
+   * 确保上下文 ≤ 窗口（滑动窗口语义）+ 消息条数可控
    *
-   * 处理顺序：
-   *   1. 估算当前消息总 token（实时估算，反映 state.messages 真实大小）；
-   *   2. 若未超窗 → 不做任何事；
+   * 处理顺序（每层都基于上一层的输出，逐层收敛）：
+   *   0. 发送前常驻工具结果截断（trimToolResults）—— 不依赖是否超窗，从源头压住
+   *      超长工具结果噪音，防止"token 未超窗但工具结果堆积"。
+   *   1. 消息条数折叠（foldHistoryByCount）—— 当 state.messages 条数超过
+   *      maxMessages 时，把早期历史折叠成摘要，保留最近 N 轮完整对话。
+   *      解决本地小模型"200+ 条消息、token 仅 37% 却变傻不干活"的核心问题。
+   *   2. 估算当前消息总 token（实时估算，反映 state.messages 真实大小）；
+   *      若未超窗 → 不做 token 层处理；
    *   3. 若超窗 → 先做摘要式压缩（保留最近 N 轮 + 早期摘要，信息量更高）。
-   *      注意：这里直接用实时 token 估算判断是否压缩，而非依赖滞后的
-   *      usagePercent（那会导致"判定超窗但压缩永不触发"）。
    *   4. 摘要后仍超窗 → 滑动窗口精确裁剪兜底：从最早完整 user 回合挤出，
    *      并把被裁掉的历史压缩成摘要 system 保留，避免 AI 失忆。
    *      保证最新信息（含刚加入的用户消息）保留在末尾，上下文永不超出窗口。
@@ -120,6 +145,33 @@ export class QueryEngine {
    */
   _ensureFitWindow() {
     if (!this.tokenBudget) return
+
+    // ---- 0) 发送前常驻工具结果截断（不依赖超窗）----
+    // 避免超长工具结果持续堆积成噪音；阈值宽松（默认 6000），仅在确实过长时截断
+    if (this.config.maxToolResultChars > 0) {
+      const beforeTrim = this.state.messages.length
+      this.state.messages = trimToolResults(this.state.messages, this.config.maxToolResultChars)
+      if (this.config.verbose && this.state.messages.length !== beforeTrim) {
+        console.error('[compact] 工具结果已按上限截断（常驻）')
+      }
+    }
+
+    // ---- 1) 消息条数折叠（解决本地小模型"条数过多变傻"）----
+    // 不依赖 token 是否超窗：只要消息条数超过 maxMessages，就折叠早期历史为摘要
+    if (this.config.maxMessages > 0) {
+      const { folded, messages: foldedMsgs, removed, summary } = foldHistoryByCount(this.state.messages, {
+        maxMessages: this.config.maxMessages,
+        keepRecentTurns: 4,
+      })
+      if (folded) {
+        this.state.messages = foldedMsgs
+        if (this.config.verbose) {
+          console.error(`[compact] 消息条数 ${removed + foldedMsgs.length} > ${this.config.maxMessages}，已折叠早期 ${removed} 条为摘要（保留最近 4 轮）`)
+          if (summary) console.error('[compact] 折叠摘要：\n' + summary)
+        }
+      }
+    }
+
     const maxTokens = this.tokenBudget.maxTokens
     const hardLimit = maxTokens - (this.tokenBudget.reservedForOutput || 0)
     // 保守触发阈值：估算到可用窗口的 85% 就开始压缩，避免估算偏差导致实际超窗
@@ -128,7 +180,7 @@ export class QueryEngine {
     const est = this.tokenBudget.estimateMessages(this.state.messages)
     if (est <= triggerLimit) return
 
-    // 1) 摘要式压缩优先：用实时估算直接决定是否压缩（不再依赖滞后的 usagePercent）
+    // 2) 摘要式压缩优先：用实时估算直接决定是否压缩（不再依赖滞后的 usagePercent）
     //    压缩目标也用保守阈值（而非 hardLimit），确保压缩后实际 token 远离窗口上限
     const summarized = compactMessages(this.state.messages, {
       maxTokens: Math.floor(maxTokens * 0.6),
@@ -140,7 +192,7 @@ export class QueryEngine {
       return
     }
 
-    // 2) 滑动窗口精确裁剪兜底（摘要仍超窗）：裁剪时保留被裁剪历史的摘要
+    // 3) 滑动窗口精确裁剪兜底（摘要仍超窗）：裁剪时保留被裁剪历史的摘要
     const { trimmed, messages: trimmedMsgs, removed, summary } = trimToWindow(this.state.messages, {
       tokenBudget: this.tokenBudget,
       maxTokens,
@@ -165,11 +217,27 @@ export class QueryEngine {
    */
   async _runToolLoop(userMessage) {
     let finalResponse = ''
+    const smallModel = isSmallModelEnabled(this.config)
+    // 小模型模式：首轮注入意图引导（层 B），帮助模型锁定该用哪些工具
+    let intentGuided = false
+    // 敷衍重试次数（层 A）：模型没调工具只回空话时，追加强引导重试
+    let fillerRetries = 0
+    const MAX_FILLER_RETRIES = 1
 
     for (let turn = 0; turn < this.config.maxTurns; turn++) {
       // 发送前硬校验：工具结果可能已使上下文超窗，确保 ≤ 窗口（摘要优先 + 滑动窗口裁剪兜底）
       this._ensureFitWindow()
 
+      // 小模型模式：首轮若识别到明确意图，注入意图引导 system 消息
+      if (smallModel && !intentGuided && this.state.messages.length > 0) {
+        const guidance = buildIntentGuidance(userMessage.content, { enable: true })
+        if (guidance) {
+          this.state.messages.push({ role: 'system', content: guidance })
+          if (this.config.verbose) console.error('[small-model] 已注入意图引导：' + guidance.slice(0, 80) + '...')
+        }
+        intentGuided = true
+      }
+
       const requestMessages = this._buildRequest(this.state.messages)
       const response = await this._callLLM(requestMessages, this.state.messages)
 
@@ -177,8 +245,20 @@ export class QueryEngine {
         throw new Error('操作已取消')
       }
 
-      // 没有工具调用 → 最终回复
+      // 没有工具调用 → 潜在最终回复
       if (!response.toolCalls || response.toolCalls.length === 0) {
+        // 小模型模式：检测敷衍输出（空话/太短/命中占位句），追加强引导重试
+        if (smallModel && fillerRetries < MAX_FILLER_RETRIES && isFillerResponse(response)) {
+          fillerRetries++
+          if (this.config.verbose) {
+            console.error(`[small-model] 检测到敷衍输出（第 ${fillerRetries} 次），追加强引导重试`)
+          }
+          // 把模型的空话 + 强制工具调用提醒注入上下文，再让模型重新决策
+          this.state.messages.push(new AssistantMessage(response.content, [], response.reasoningContent))
+          this.state.messages.push({ role: 'user', content: RETRY_GUIDANCE })
+          continue // 继续循环，重新请求模型
+        }
+
         finalResponse = response.content
         this.state.messages.push(new AssistantMessage(response.content, [], response.reasoningContent))
         break
@@ -222,9 +302,12 @@ export class QueryEngine {
   _buildRequest(messages) {
     const request = []
 
-    // 系统提示
+    // 系统提示（小模型模式：追加强制工具调用引导）
     if (this.config.systemPrompt) {
-      request.push({ role: 'system', content: this.config.systemPrompt })
+      const sysContent = isSmallModelEnabled(this.config)
+        ? buildSmallModelSystemPrompt(this.config.systemPrompt)
+        : this.config.systemPrompt
+      request.push({ role: 'system', content: sysContent })
     }
 
     // 历史消息 — 转换为 OpenAI 兼容格式
@@ -355,7 +438,16 @@ export class QueryEngine {
     }
 
     // 构建工具定义
-    const tools = this.config.tools.map(t => ({
+    // 小模型模式：按用户指令意图精简工具集，减少模型的选择负担（层 A）
+    let effectiveTools = this.config.tools
+    if (isSmallModelEnabled(this.config)) {
+      const reduced = selectRelevantTools(this.config.tools, this.currentUserInput, { enable: true })
+      effectiveTools = reduced
+      if (this.config.verbose && reduced.length !== this.config.tools.length) {
+        console.error(`[small-model] 按意图精简工具：${this.config.tools.length} → ${reduced.length}（${reduced.map(t => t.name).join(', ')}）`)
+      }
+    }
+    const tools = effectiveTools.map(t => ({
       type: 'function',
       function: { name: t.name, description: t.description, parameters: t.parameters },
     }))

package/src/core/small-model.js

@@ -0,0 +1,243 @@
+/**
+ * 小模型适配层 — 让 cc-node 在弱模型（如 27B Q3 量化）下也能可靠工作
+ *
+ * 背景：
+ *   小模型的核心弱点是"规划 + 工具调用 + 自我纠错"不稳定——常出现：
+ *     - 看不懂指令，只回 "Solved by sharing best practices." 等敷衍空话，不调工具；
+ *     - 一次请求里塞 16 个工具定义让它选择困难，乱调或漏调；
+ *     - 多轮工具往返后"丢"了原始目标。
+ *   本模块把智能从"模型端"转移到"框架端"，提供两层适配：
+ *
+ *   【层 A — 兜底（防呆）】：
+ *     - 强化 system prompt：明确告诉模型"必须调用工具完成任务，不能只回文字"；
+ *     - 敷衍输出检测：识别无工具调用 + 无实质内容的空话，返回需要重试的信号；
+ *     - 工具数量精简：按任务场景只暴露核心工具子集，减少选择负担。
+ *
+ *   【层 B — 替代（框架接管规划）】：
+ *     - 意图识别：用关键词规则把常见任务（写文件/找文件/跑命令/查代码）映射到
+ *       明确的工具动作，不完全依赖模型自主规划；
+ *     - 提供一个"计划"数据结构，框架可据此按序执行。
+ *
+ * 注意：本模块默认【不启用】。通过 config.smallModel=true 或 --small-model 开启。
+ */
+
+// ---- 敷衍/空话输出特征（层 A）----
+// 小模型在"没读懂、没调工具"时输出的占位句/空话模式。
+// 命中这些且【本轮无工具调用】时，判定为敷衍输出，触发重试。
+const FILLER_PATTERNS = [
+  /^\s*solved/i,
+  /^\s*done\b/i,
+  /by sharing best practices/i,
+  /this is the kind of mistake/i,
+  /next action/i,
+  /^\s*ok\b/i,
+  /^\s*okay\b/i,
+  /^\s*got it/i,
+  /^\s*understood/i,
+  /^\s*no problem/i,
+  /^\s*let me think/i,
+  /^\s*sure\b/i,
+  /^\s*yes\b/i,
+  /^\s*right\b/i,
+  /^\s*hmm/i,
+]
+
+// 有"实质内容"的最小长度（去掉空白/填充后）
+const MIN_SUBSTANTIVE_CHARS = 20
+
+/**
+ * 判断一次模型回复是否属于"敷衍输出"（无工具调用 + 空话/过短）
+ *
+ * 用途：小模型模式下，当模型没调工具却回了句空话时，判定为"没干活"，
+ *       触发框架重试（并在重试时追加强引导）。
+ *
+ * @param {object} response — _callLLM 的返回 { content, toolCalls, ... }
+ * @param {object} [opts]
+ * @param {number} [opts.minChars=20] — 判定"实质内容"的最小有效字符数
+ * @returns {boolean} true 表示敷衍输出（应重试）
+ */
+export function isFillerResponse(response, opts = {}) {
+  const minChars = opts.minChars || MIN_SUBSTANTIVE_CHARS
+  // 有工具调用 → 在干活，不是敷衍
+  if (response.toolCalls && response.toolCalls.length > 0) return false
+  const content = (response.content || '').trim()
+  if (!content) return true // 空回复 = 敷衍
+  // 去掉空白后的有效字符数
+  const substantive = content.replace(/\s+/g, '').replace(/[，。！？,.!?、；;：:]/g, '')
+  if (substantive.length < minChars) return true // 太短 = 敷衍
+  // 命中空话模式
+  for (const pat of FILLER_PATTERNS) {
+    if (pat.test(content)) return true
+  }
+  return false
+}
+
+// ---- 小模型强化 system prompt（层 A）----
+// 追加到基础 system prompt 之后的强工具引导。对小模型是决定性的：
+// 大模型能"猜"到要调工具，小模型必须被明确告知。
+export const SMALL_MODEL_SYSTEM_PROMPT = `
+## 工具使用铁律（对你至关重要）
+你是一个【工具调用 Agent】，不是一个聊天机器人。用户给你的是一个【任务】，你必须通过调用工具来完成任务，绝对不能只回复文字。
+
+遵守以下规则：
+1. **每次收到用户任务，第一反应是"该调用哪个工具"，而不是"该怎么用文字回答"。**
+2. 如果任务需要读取/查看/搜索文件，调用 Glob / Grep / Read。
+3. 如果任务需要创建/修改文件，调用 Write / Edit。
+4. 如果任务需要运行命令，调用 Bash。
+5. 如果任务需要联网，调用 WebFetch / WebSearch。
+6. **调用工具时，必须提供完整、正确的参数**（绝对路径、完整内容、具体命令）。
+7. 调用工具后，根据工具返回结果继续，直到任务真正完成。
+8. 除非任务只是简单问答（不需要任何工具），否则【禁止】不调用工具就回复。
+9. 禁止输出 "Solved by..."、"\u201cDone\u201d"、"Let me think" 等空话——这些不是完成任务。
+10. 如果一次要做多件事，一次调用一个工具，逐步推进，不要试图一次性解决。
+
+记住：**你的价值在于调用工具把事做完，而不是说漂亮话。**
+`
+
+/**
+ * 生成小模型模式下的完整 system prompt（基础 prompt + 强化引导）
+ * @param {string} basePrompt — 基础 system prompt
+ * @returns {string}
+ */
+export function buildSmallModelSystemPrompt(basePrompt) {
+  return basePrompt + SMALL_MODEL_SYSTEM_PROMPT
+}
+
+// ---- 重试追加强引导（层 A）----
+// 当模型敷衍输出触发重试时，往对话里注入一条"强制工具调用"的用户级提醒，
+// 让模型看到"我刚才敷衍了，现在必须调工具"。
+export const RETRY_GUIDANCE = `[系统提示] 你刚才没有调用任何工具就回复了，这不算完成任务。请立即重新审视任务，调用合适的工具（Write/Edit/Read/Grep/Glob/Bash 等）真正完成任务。不要再输出空话。`
+
+// ---- 意图识别 + 框架动作映射（层 B）----
+// 小模型模式下，框架用关键词规则把常见任务映射到明确的工具动作，
+// 作为"计划"注入，引导模型按序执行（而非让模型自由发挥）。
+//
+// 每个意图规则：
+//   pattern: 触发正则
+//   plan: 建议的工具调用序列（按序执行）
+//   note: 给模型的动作说明
+
+const INTENT_RULES = [
+  {
+    // 写文档/文件/计划/代码：覆盖"写/创建/生成/更新/保存/做好...文档/计划"等
+    pattern: /(写|创建|生成|更新|保存|做好|做一份|制定|起草|撰写|输出|整理|编写).*(文档|文件|计划|方案|说明|md|readme|代码|函数|模块|接口)/i,
+    plan: ['Grep/Glob（先看现状）', 'Write/Edit（写内容）'],
+    note: '先搜索确认目标文件是否存在/已有内容，再用 Write 或 Edit 写入。',
+    toolHint: 'Write, Edit, Glob, Grep',
+  },
+  {
+    // 明确提到"文档/文件"但未命中动词 → 归为写文件任务（"做...开发计划文档"）
+    pattern: /(文档|计划文档|开发计划|方案文档|说明文档|md文件).*(写好|完成|制作|做|实现|产出)?$/i,
+    plan: ['Write/Edit（写内容）'],
+    note: '这是一个要产出文档/计划的写作任务，直接 Write 或 Edit 写入目标文件。',
+    toolHint: 'Write, Edit',
+  },
+  {
+    pattern: /(找|搜索|查|列出|看看|查看|浏览).*(文件|代码|函数|目录|项目|结构)/i,
+    plan: ['Glob（找文件）', 'Grep（搜内容）', 'Read（读文件）'],
+    note: '用 Glob 找文件路径，用 Grep 搜内容，用 Read 读文件内容。',
+    toolHint: 'Glob, Grep, Read',
+  },
+  {
+    pattern: /(跑|运行|执行|测试|调试|编译|构建).*(命令|脚本|程序|测试|npm|node|python|项目|build)/i,
+    plan: ['Bash（运行命令）'],
+    note: '用 Bash 运行命令/脚本/测试，并读取输出。',
+    toolHint: 'Bash',
+  },
+  {
+    pattern: /(改|修|修复|编辑|更新|优化|重构).*(文件|代码|bug|问题|错误|逻辑|接口|函数)/i,
+    plan: ['Read（读当前内容）', 'Edit（精确修改）'],
+    note: '先 Read 查看当前内容，再用 Edit 精确修改指定位置。',
+    toolHint: 'Read, Edit',
+  },
+  {
+    pattern: /(联网|搜索|查一下|网页|网络|资料|信息|最新|资讯)/i,
+    plan: ['WebSearch（搜索）', 'WebFetch（抓网页）'],
+    note: '用 WebSearch 搜索，用 WebFetch 抓取具体网页内容。',
+    toolHint: 'WebSearch, WebFetch',
+  },
+  {
+    pattern: /(git|提交|push|pull|commit|pr|github|版本)/i,
+    plan: ['Bash（git 命令）', 'GitTool（PR 管理）'],
+    note: '用 Bash 执行 git 命令，或用 GitTool 管理 GitHub PR。',
+    toolHint: 'Bash, GitTool',
+  },
+]
+
+/**
+ * 根据用户指令识别意图，返回框架建议的动作计划
+ *
+ * @param {string} userInput — 用户指令
+ * @returns {{ matched: boolean, intent: string, note: string, toolHint: string } | null}
+ */
+export function detectIntent(userInput) {
+  if (!userInput) return null
+  for (const rule of INTENT_RULES) {
+    if (rule.pattern.test(userInput)) {
+      return {
+        matched: true,
+        intent: rule.plan.join(' → '),
+        note: rule.note,
+        toolHint: rule.toolHint,
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * 生成注入到消息里的"意图引导 system 提示"（层 B）
+ *
+ * 当检测到明确意图时，往上下文中插入一条引导，告诉模型该用哪些工具，
+ * 降低小模型的决策负担。
+ *
+ * @param {string} userInput
+ * @param {object} [opts]
+ * @param {boolean} [opts.enable=true] — 是否启用意图引导
+ * @returns {string|null} 引导文本；未匹配或未启用返回 null
+ */
+export function buildIntentGuidance(userInput, opts = {}) {
+  if (opts.enable === false) return null
+  const intent = detectIntent(userInput)
+  if (!intent) return null
+  return `[任务引导] 根据用户指令，建议按此思路用工具推进：${intent.intent}。\n说明：${intent.note}\n可用工具：${intent.toolHint}`
+}
+
+/**
+ * 精简工具列表（层 A）— 小模型一次看太多工具会混乱
+ *
+ * 从完整工具列表里，按用户指令筛选出最相关的核心工具子集。
+ * 这样模型的工具选择负担小，更不容易乱调/漏调。
+ *
+ * @param {Array} allTools — 完整 ToolDef 列表
+ * @param {string} userInput — 用户指令
+ * @param {object} [opts]
+ * @param {boolean} [opts.enable=true] — 是否启用精简
+ * @returns {Array} 精简后的工具列表
+ */
+export function selectRelevantTools(allTools, userInput, opts = {}) {
+  if (opts.enable === false) return allTools
+  if (!allTools || allTools.length === 0) return allTools
+
+  const intent = detectIntent(userInput)
+  // 未识别到明确意图 → 返回核心工具（不塞满 16 个）
+  const coreNames = intent
+    ? intent.toolHint.split(',').map(s => s.trim())
+    : ['Bash', 'Read', 'Edit', 'Write', 'Glob', 'Grep']
+
+  // 核心工具优先，保留指定工具；若一个都没命中则退回首屏核心集
+  const selected = allTools.filter(t => coreNames.includes(t.name))
+  if (selected.length === 0) {
+    return allTools.filter(t => ['Bash', 'Read', 'Edit', 'Write', 'Glob', 'Grep'].includes(t.name))
+  }
+  return selected
+}
+
+/**
+ * 小模型模式开关判断
+ * @param {object} engineConfig — QueryEngineConfig 实例
+ * @returns {boolean}
+ */
+export function isSmallModelEnabled(engineConfig) {
+  return !!(engineConfig && engineConfig.smallModel)
+}