mocode-ai 1.6.3 → 1.6.5

package/dist/context/relevance.js

@@ -3,7 +3,14 @@
 import { canonicalizePath, extractPath, isToolResultSuccess, toText } from './utils.js';
 /** Shared prefix lets /context count read and observation supersession together. */
 const STUB_PREFIX = '⌦[已过时:';
-const READ_STUB_REASON = '同 path 已有新 read / 已被 mutation 覆写';
+/** read→read:仅同 path 同区间(offset+limit)的更新 read 才淘汰旧页。 */
+const READ_RANGE_STUB_REASON = '同 path 同区间已有新 read';
+/** mutation→read:文件被改写,该 path 旧 read 全区间淘汰。 */
+const READ_MUTATION_STUB_REASON = '同 path 已被 mutation 覆写';
+/** read_file 默认分页(对齐 tools/builtins/read-file.ts 的 DEFAULT_READ_LIMIT)。 */
+const READ_DEFAULT_LIMIT = 300;
+/** read_file 单次硬上限(对齐 MAX_FILE_LINES),把超传 limit 归一化到真实拿到的区间。 */
+const READ_LIMIT_CAP = 2000;
 function parseArgs(raw) {
     try {
         const parsed = raw.trim() ? JSON.parse(raw) : {};
@@ -17,6 +24,16 @@ function normalizedInteger(value, fallback) {
     const n = Number(value);
     return Number.isFinite(n) ? Math.trunc(n) : fallback;
 }
+/** read_file 实际拿到的行区间:offset 默认 1;limit 默认 300 且钳到 2000(同工具 execute 的归一化)。
+ *  无法解析参数时返 null(调用方保守跳过,不做区间淘汰)。 */
+function readRange(argsRaw) {
+    const args = parseArgs(argsRaw);
+    if (!args)
+        return null;
+    const offset = Math.max(1, normalizedInteger(args.offset, 1));
+    const limit = Math.max(1, Math.min(normalizedInteger(args.limit, READ_DEFAULT_LIMIT), READ_LIMIT_CAP));
+    return { offset, limit };
+}
 /** Only complete semantic-query equality is safe for whole-message replacement. */
 function observationKey(call) {
     const args = call.args;
@@ -46,7 +63,11 @@ function observationLabel(call) {
 }
 /**
  * Cross-message relevance pruning:
- * - read_file: a newer successful read of the same canonical path supersedes old reads.
+ * - read_file: a newer successful read of the same canonical path AND the same
+ *   line range (offset+limit) supersedes old reads; different pages of one file
+ *   are distinct and never prune each other.
+ * - edit_file/write_file: a mutation of a path supersedes that path's old reads
+ *   across ALL ranges (the whole file changed).
  * - grep: a newer successful call with the exact same semantic arguments
  *   supersedes old results. Partial file overlap is intentionally not enough.
  */
@@ -114,8 +135,10 @@ export class RelevancePruner {
      */
     pruneSuperseded(history, coldBoundary) {
         try {
+            // read→read:键 = path + 区间(offset+limit),只淘汰真正重复的同区间旧 read。
             const latestRead = new Map();
             const latestObservation = new Map();
+            // mutation→read:按 path 记录,稍后淘汰该文件所有区间旧 read。
             const mutations = [];
             for (let idx = 1; idx < history.length; idx++) {
                 const message = history[idx];
@@ -127,8 +150,10 @@ export class RelevancePruner {
                     continue;
                 if (call.name === 'read_file') {
                     const path = canonicalizePath(extractPath(call.argsRaw));
-                    if (path)
-                        latestRead.set(path, idx);
+                    const range = readRange(call.argsRaw);
+                    // path 或区间无法确定 → 保守跳过,不做 read→read 淘汰。
+                    if (path && range)
+                        latestRead.set(`${path}|${range.offset}|${range.limit}`, { path, range, index: idx });
                 }
                 else if (call.name === 'edit_file' || call.name === 'write_file') {
                     const path = canonicalizePath(extractPath(call.argsRaw));
@@ -140,11 +165,11 @@ export class RelevancePruner {
                     latestObservation.set(key, { tool: call.name, index: idx });
             }
             let pruned = 0;
-            for (const [path, index] of latestRead) {
-                pruned += this.stubPriorReads(history, path, index, coldBoundary);
+            for (const entry of latestRead.values()) {
+                pruned += this.stubPriorReads(history, entry, coldBoundary, 'range');
             }
             for (const mutation of mutations) {
-                pruned += this.stubPriorReads(history, mutation.path, mutation.index, coldBoundary);
+                pruned += this.stubPriorReads(history, { path: mutation.path, index: mutation.index }, coldBoundary, 'mutation');
             }
             for (const [key, latest] of latestObservation) {
                 pruned += this.stubPriorObservations(history, latest.tool, key, latest.index, coldBoundary);
@@ -155,12 +180,16 @@ export class RelevancePruner {
             return 0;
         }
     }
-    stubPriorReads(history, path, beforeIdx, coldBoundary) {
-        const targetPath = canonicalizePath(path);
+    /**
+     * @param mode 'range'(read→read:仅同区间淘汰) | 'mutation'(文件被改:该 path 全区间淘汰)
+     */
+    stubPriorReads(history, target, coldBoundary, mode) {
+        const targetPath = canonicalizePath(target.path);
         if (!targetPath)
             return 0;
+        const reason = mode === 'range' ? READ_RANGE_STUB_REASON : READ_MUTATION_STUB_REASON;
         let pruned = 0;
-        for (let idx = 1; idx < Math.min(beforeIdx, coldBoundary); idx++) {
+        for (let idx = 1; idx < Math.min(target.index, coldBoundary); idx++) {
             const message = history[idx];
             if (!message || message.role !== 'tool')
                 continue;
@@ -168,12 +197,22 @@ export class RelevancePruner {
             if (content.startsWith('⌦['))
                 continue;
             const call = this.callAt(history, idx);
-            if (call?.name !== 'read_file')
+            if (call?.name !== 'read_file' || !message.tool_call_id)
                 continue;
-            if (canonicalizePath(extractPath(call.argsRaw)) !== targetPath || !message.tool_call_id)
+            if (canonicalizePath(extractPath(call.argsRaw)) !== targetPath)
                 continue;
+            // read→read 必须同区间;mutation→read 不看区间(整文件已变)。
+            if (mode === 'range') {
+                const priorRange = readRange(call.argsRaw);
+                if (!priorRange ||
+                    !target.range ||
+                    priorRange.offset !== target.range.offset ||
+                    priorRange.limit !== target.range.limit) {
+                    continue;
+                }
+            }
             message.content =
-                `${STUB_PREFIX}${READ_STUB_REASON}] read_file(${targetPath}) ${content.length} 字符 ` +
+                `${STUB_PREFIX}${reason}] read_file(${targetPath}) ${content.length} 字符 ` +
                     `→ 已被新 read / mutation 替代 · id …${message.tool_call_id.slice(-6)}⌫`;
             pruned++;
         }
@@ -219,10 +258,15 @@ export function computePruneStats(history) {
     let stubbed = 0;
     let originalChars = 0;
     let stubChars = 0;
+    let cleared = 0;
     for (const message of history) {
         if (message.role !== 'tool')
             continue;
         const content = toText(message.content);
+        if (content.startsWith('⌦[已清除:')) {
+            cleared++;
+            continue;
+        }
         const isPruneStub = content.startsWith(STUB_PREFIX);
         const isDigest = content.startsWith('⌦[摘要:');
         if (!isPruneStub && !isDigest)
@@ -241,5 +285,6 @@ export function computePruneStats(history) {
         originalTokens,
         stubChars,
         freedTokens: Math.max(0, originalTokens - stubTokens),
+        cleared,
     };
 }

package/dist/context/text-search.js

@@ -0,0 +1,113 @@
+// 共享全文检索:CJK 感知分词 + BM25。零依赖纯函数,供 memory 与 archive 搜索复用。
+//
+// 分词:ASCII/数字按词;CJK 字符同时生成 unigram 与相邻 bigram——中文词多为两字,
+// 单字召回噪声大、纯 bigram 又漏掉单字成词的情况,unigram+bigram 是 Elasticsearch
+// cjk analyzer 的成熟折中。
+//
+// 多字段加权 BM25:每个字段独立长度归一,字段分按 weight 加权求和。
+const CJK_RE = /[㐀-䶿一-鿿豈-﫿぀-ヿ가-힯]/;
+/** CJK 感知分词(小写)。 */
+export function tokenize(input) {
+    const text = (input ?? '').toLowerCase();
+    const tokens = [];
+    const chars = Array.from(text);
+    let word = '';
+    const flushWord = () => {
+        if (word) {
+            tokens.push(word);
+            word = '';
+        }
+    };
+    for (let i = 0; i < chars.length; i++) {
+        const ch = chars[i];
+        if (/[a-z0-9]/.test(ch)) {
+            word += ch;
+            continue;
+        }
+        flushWord();
+        if (CJK_RE.test(ch)) {
+            tokens.push(ch); // unigram
+            if (i + 1 < chars.length && CJK_RE.test(chars[i + 1])) {
+                tokens.push(ch + chars[i + 1]); // bigram
+            }
+        }
+    }
+    flushWord();
+    return tokens;
+}
+/** BM25 多字段索引。文档量小(memory ≤百条、archive 索引),构建成本可忽略。 */
+export class TextSearchIndex {
+    k1;
+    b;
+    ids;
+    fieldStats;
+    fieldWeights;
+    constructor(docs, k1 = 1.5, b = 0.75) {
+        this.k1 = k1;
+        this.b = b;
+        this.ids = docs.map((d) => d.id);
+        const fieldCount = Math.max(1, ...docs.map((d) => d.fields.length));
+        this.fieldWeights = Array.from({ length: fieldCount }, (_, f) => docs[0]?.fields[f]?.weight ?? 1);
+        this.fieldStats = Array.from({ length: fieldCount }, () => ({
+            df: new Map(),
+            tf: new Map(),
+            dl: new Map(),
+            avgdl: 0,
+        }));
+        docs.forEach((doc, docId) => {
+            doc.fields.forEach((field, f) => {
+                const stats = this.fieldStats[f];
+                const toks = tokenize(field.text);
+                stats.dl.set(docId, toks.length);
+                const seen = new Set();
+                for (const t of toks) {
+                    let perDoc = stats.tf.get(t);
+                    if (!perDoc) {
+                        perDoc = new Map();
+                        stats.tf.set(t, perDoc);
+                    }
+                    perDoc.set(docId, (perDoc.get(docId) ?? 0) + 1);
+                    seen.add(t);
+                }
+                for (const t of seen)
+                    stats.df.set(t, (stats.df.get(t) ?? 0) + 1);
+            });
+        });
+        const n = docs.length || 1;
+        for (const stats of this.fieldStats) {
+            let total = 0;
+            for (const len of stats.dl.values())
+                total += len;
+            stats.avgdl = total / n;
+        }
+    }
+    /** 检索;无有效查询词时返回空数组(调用方自行决定是否回退全量)。 */
+    search(query, limit = 10) {
+        const terms = tokenize(query);
+        if (terms.length === 0 || this.ids.length === 0)
+            return [];
+        const n = this.ids.length;
+        const hits = [];
+        for (let docId = 0; docId < n; docId++) {
+            let score = 0;
+            this.fieldStats.forEach((stats, f) => {
+                const dl = stats.dl.get(docId);
+                if (dl === undefined)
+                    return;
+                const norm = this.k1 * (1 - this.b + (this.b * dl) / Math.max(stats.avgdl, 1));
+                for (const term of terms) {
+                    const tf = stats.tf.get(term)?.get(docId);
+                    if (!tf)
+                        continue;
+                    const df = stats.df.get(term) ?? 0;
+                    const idf = Math.log(1 + (n - df + 0.5) / (df + 0.5));
+                    score += ((this.fieldWeights[f] ?? 1) * (idf * (tf * (this.k1 + 1)))) / (tf + norm);
+                }
+            });
+            if (score > 0)
+                hits.push({ id: this.ids[docId], score });
+        }
+        hits.sort((a, b) => b.score - a.score);
+        return hits.slice(0, Math.max(1, limit));
+    }
+}

package/dist/llm/index.js

@@ -8,6 +8,9 @@ import { sanitizeToolSchemas } from './tool-schema.js';
 import { isMarkedStreamInterrupted } from './stream-interrupt.js';
 import { defaultAnthropicFetch, anthropicChatOnce } from './providers/anthropic.js';
 import { registerModelProvider, getModelProvider, listModelProviders } from './provider.js';
+import { effectiveReasoningEffort } from '../config/index.js';
+import { resolveReasoningParams } from './reasoning.js';
+import { getActivePresetName, readPreset } from '../config/presets.js';
 // 强制关闭第三方调试日志泄漏:openai SDK 在 process.env.DEBUG === 'true' 时用裸
 // console.log 把请求/响应直写 stdout,会污染 TUI 输入框(并泄露 headers/URL)。
 // 仅拦截 'true' 这一开关值——保留 namespace 形式的 DEBUG(如 DEBUG=express:*) 调试能力。
@@ -394,11 +397,11 @@ export function refreshChatTools() {
 // 新增 provider 只需 registerModelProvider,不必改 chat()。
 registerModelProvider({
     name: 'openai',
-    chatOnce: (messages, handlers, signal, tools, runtime) => chatOnce(messages, handlers, signal, tools, runtime),
+    chatOnce: (messages, handlers, signal, tools, runtime, overrides) => chatOnce(messages, handlers, signal, tools, runtime, overrides),
 });
 registerModelProvider({
     name: 'anthropic',
-    chatOnce: (messages, handlers, signal, tools, runtime) => anthropicChatOnce(messages, handlers, signal, tools ?? chatTools, runtime),
+    chatOnce: (messages, handlers, signal, tools, runtime, overrides) => anthropicChatOnce(messages, handlers, signal, tools ?? chatTools, runtime, overrides),
 });
 /**
  * 多 provider 兼容的 cache / reasoning 字段提取。
@@ -474,14 +477,14 @@ function retryErrorCode(error) {
 }
 /** Bind chat dispatch, retries and built-in providers to one explicit runtime. */
 export function createChatTransport(runtime) {
-    return (messages, handlers = {}, signal, toolsOverride) => chatWithRuntime(runtime, messages, handlers, signal, toolsOverride);
+    return (messages, handlers = {}, signal, toolsOverride, overrides) => chatWithRuntime(runtime, messages, handlers, signal, toolsOverride, overrides);
 }
 export function chat(messages, handlers = {}, signal, 
 /** 覆盖默认工具 schema;plan 模式传 planChatTools(只读子集),缺省=全量 chatTools。 */
-toolsOverride) {
-    return chatWithRuntime(defaultProviderRuntime, messages, handlers, signal, toolsOverride);
+toolsOverride, overrides) {
+    return chatWithRuntime(defaultProviderRuntime, messages, handlers, signal, toolsOverride, overrides);
 }
-async function chatWithRuntime(runtime, messages, handlers, signal, toolsOverride) {
+async function chatWithRuntime(runtime, messages, handlers, signal, toolsOverride, overrides) {
     let lastErr;
     // 本次尝试是否已向调用方产出过内容(可见文本 / 工具名)。用于判断「流中途故障可否安全重试」:
     // 重试会从请求头重放,已流出并显示在内容区的半截文本会再写一遍(history 因异常未落,倒是不脏)。
@@ -511,7 +514,7 @@ async function chatWithRuntime(runtime, messages, handlers, signal, toolsOverrid
                 // 未注册的 provider:给出可用名单,避免悄悄落到错误实现。
                 throw new Error(`未知的 LLM provider "${runtime.config.provider}";已注册:${listModelProviders().join(', ') || '(空)'}`);
             }
-            return await provider.chatOnce(messages, guardedHandlers, signal, toolsOverride, runtime);
+            return await provider.chatOnce(messages, guardedHandlers, signal, toolsOverride, runtime, overrides);
         }
         catch (err) {
             lastErr = err;
@@ -584,7 +587,7 @@ export function normalizeImageDetail(messages) {
     return changed ? next : messages;
 }
 /** 单次流式 LLM 请求(无重试);chat() 的内部实现,可被 __setChatCreateImpl 注入桩以做单测。 */
-async function chatOnce(messages, handlers, signal, toolsOverride, runtime = defaultProviderRuntime) {
+async function chatOnce(messages, handlers, signal, toolsOverride, runtime = defaultProviderRuntime, overrides) {
     // 防御:messages 必须至少含一条非空 user 消息,否则 OpenAI/Anthropic 都会 400。
     // compact force 分支曾把所有 user 丢进摘要 → 重建 history 无 user → 下一轮 400。
     // 在 transport 边界拦住所有类似回归(compact / 外部注入 / resume 损坏)。
@@ -611,6 +614,29 @@ async function chatOnce(messages, handlers, signal, toolsOverride, runtime = def
     // transport 边界消毒:剔除部分后端(kimi-k3@dashscope 实测)整请求 400 拒绝的
     // uniqueItems 关键字。无需改写时返回原引用,前缀缓存逐字节稳定不受影响。
     const activeTools = sanitizeToolSchemas(toolsOverride ?? chatTools);
+    const effort = effectiveReasoningEffort(overrides?.reasoningEffort);
+    // 实时读激活预设(#model-catalog M3):capabilities 只存在预设文件里,启动快照不反映切换。
+    const activePreset = (() => {
+        const n = getActivePresetName();
+        return n ? readPreset(n) : null;
+    })();
+    const reasoningParams = effort === 'auto'
+        ? {}
+        : resolveReasoningParams(effort, {
+            provider: runtimeConfig.provider === 'anthropic' ? 'anthropic' : 'openai',
+            model: runtime.getModel(),
+            maxTokens: runtimeConfig.maxTokens,
+            // 仅当激活预设来自目录且对应当前模型时携带,否则走正则兜底。
+            ...(activePreset && activePreset.catalogProvider && activePreset.model === runtime.getModel()
+                ? {
+                    catalogProviderId: activePreset.catalogProvider,
+                    catalogReasoning: activePreset.capabilities ? activePreset.capabilities.reasoning : undefined,
+                    catalogReasoningOptions: activePreset.capabilities
+                        ? activePreset.capabilities.reasoningOptions
+                        : undefined,
+                }
+                : {}),
+        });
     const stream = await create({
         model: runtime.getModel(),
         messages: normalizeImageDetail(messages),
@@ -626,6 +652,7 @@ async function chatOnce(messages, handlers, signal, toolsOverride, runtime = def
             : {}),
         ...(runtimeConfig.maxTokens ? { max_tokens: runtimeConfig.maxTokens } : {}),
         ...(runtimeConfig.includeUsage ? { stream_options: { include_usage: true } } : {}),
+        ...reasoningParams,
     }, signal ? { signal } : undefined);
     // content 内嵌 think 标签由独立增量状态机过滤。它只暂存“可能组成标签”的后缀，
     // 因而既能覆盖标签任意位置跨 chunk，也不会让普通正文固定延迟数个字符。

package/dist/llm/providers/anthropic.js

@@ -1,4 +1,5 @@
-import { config, getActiveModel } from '../../config/index.js';
+import { config, effectiveReasoningEffort, getActiveModel } from '../../config/index.js';
+import { resolveReasoningParams } from '../reasoning.js';
 import { markStreamInterrupted } from '../stream-interrupt.js';
 let fetchImplOverride = null;
 /** 仅供单测注入；生产路径使用 Node 18+ 全局 fetch。 */
@@ -179,10 +180,18 @@ function endpoint(baseURL) {
         return base;
     return `${base}/v1/messages`;
 }
-export function buildAnthropicRequest(messages, tools, runtime) {
+export function buildAnthropicRequest(messages, tools, runtime, overrides) {
     const runtimeConfig = runtime?.config ?? config;
     const encoded = encodeAnthropicMessages(messages, runtimeConfig.anthropicPromptCache);
     const anthropicTools = encodeAnthropicTools(tools, runtimeConfig.anthropicPromptCache);
+    const effort = effectiveReasoningEffort(overrides?.reasoningEffort);
+    const reasoningParams = effort === 'auto'
+        ? {}
+        : resolveReasoningParams(effort, {
+            provider: 'anthropic',
+            model: runtime?.getModel() ?? getActiveModel(),
+            maxTokens: runtimeConfig.maxTokens,
+        });
     return {
         model: runtime?.getModel() ?? getActiveModel(),
         max_tokens: runtimeConfig.maxTokens ?? 8192,
@@ -190,6 +199,7 @@ export function buildAnthropicRequest(messages, tools, runtime) {
         system: encoded.system,
         messages: encoded.messages,
         ...(anthropicTools.length > 0 ? { tools: anthropicTools } : {}),
+        ...reasoningParams,
     };
 }
 class AnthropicHttpError extends Error {
@@ -287,7 +297,7 @@ function addLiveCount(text, state) {
     }
 }
 /** Anthropic Messages API 单次请求；外层 chat() 继续统一负责重试。 */
-export async function anthropicChatOnce(messages, handlers, signal, tools, runtime) {
+export async function anthropicChatOnce(messages, handlers, signal, tools, runtime, overrides) {
     const runtimeConfig = runtime?.config ?? config;
     const fetchImpl = runtime?.clientState.anthropicFetchImpl ?? defaultAnthropicFetch;
     const response = await fetchImpl(endpoint(runtimeConfig.baseURL), {
@@ -298,7 +308,7 @@ export async function anthropicChatOnce(messages, handlers, signal, tools, runti
             'x-api-key': runtimeConfig.apiKey,
             'anthropic-version': process.env.ANTHROPIC_VERSION || '2023-06-01',
         },
-        body: JSON.stringify(buildAnthropicRequest(messages, tools, runtime)),
+        body: JSON.stringify(buildAnthropicRequest(messages, tools, runtime, overrides)),
         signal,
     });
     if (!response.ok)

package/dist/llm/reasoning.js

@@ -0,0 +1,141 @@
+/**
+ * Reasoning Effort 适配层(#token-efficiency P3)。
+ *
+ * 用户只面对归一化五档 `off | low | medium | high | auto`,本模块按 provider +
+ * 模型名模式匹配,翻译成各家方言字段:
+ * - Anthropic 4.6+:`output_config.effort` + `thinking:{type:'adaptive'}`(新)
+ * - Anthropic 旧版:`thinking:{type:'enabled', budget_tokens:N}`(budget 严格小于 max_tokens)
+ * - OpenAI o 系 / gpt-5:`reasoning_effort`
+ * - Qwen3(vLLM/OpenAI 兼容):`enable_thinking` + `thinking_budget`
+ * - GLM-4.5/4.6/5:`thinking:{type:'enabled'|'disabled'}`
+ *
+ * 白名单驱动:未匹配到已知族的模型一律返回 {} —— 第三方中转可能因严格 schema
+ * 校验对未知字段直接 400,不下发是唯一在所有后端都安全的策略。
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { paramsFromCatalog } from '../models/reasoning-cap.js';
+/**
+ * Skill 激活期 effort scope(P3 §4.8):嵌套异步树(含子 agent)自动继承。
+ * 取值优先级:显式 per-request overrides 参数 > 本 scope > 会话级 getActiveEffort()。
+ * 刻意低于显式参数 —— compact/reflect 显式传 low 不被 skill effort 改写。
+ */
+const effortScope = new AsyncLocalStorage();
+export function getScopedEffort() {
+    return effortScope.getStore();
+}
+/** 在 skill effort scope 内执行 fn;effort=auto 等同于不包。 */
+export function runWithEffortScope(effort, fn) {
+    if (effort === 'auto')
+        return fn();
+    return effortScope.run(effort, fn);
+}
+const EFFORTS = ['off', 'low', 'medium', 'high', 'auto'];
+/** 解析外部输入(env / 命令行);非法值返回 undefined(调用方决定回落策略)。 */
+export function parseReasoningEffort(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    let v = value.trim();
+    if (v.length >= 2 && (v[0] === '"' || v[0] === "'") && v[v.length - 1] === v[0])
+        v = v.slice(1, -1);
+    v = v.trim().toLowerCase();
+    return EFFORTS.includes(v) ? v : undefined;
+}
+/** 各档对应的思考预算(token):Anthropic budget_tokens / Qwen thinking_budget。 */
+const THINK_BUDGET = {
+    low: 1024,
+    medium: 4096,
+    high: 10240,
+};
+/** Anthropic:为正文预留的最小 token;budget = min(raw, maxTokens - RESERVED)。 */
+const ANTHROPIC_OUTPUT_RESERVED = 1024;
+const ANTHROPIC_DEFAULT_MAX = 8192;
+/**
+ * 目标模型是否识别 reasoning 参数(白名单命中)。
+ * 供 /model show 给出「参数不会下发」提示,避免用户设了 high 却静默无效。
+ */
+export function recognizesReasoning(target) {
+    // 目录来源显式声明了思考能力 → 直接采纳(含声明 false 时不识别)。
+    if (target.catalogProviderId && typeof target.catalogReasoning === 'boolean') {
+        return target.catalogReasoning;
+    }
+    if (target.provider === 'anthropic')
+        return true;
+    const m = target.model.toLowerCase();
+    return (/\bo[134]\b/.test(m) ||
+        /gpt-?5/.test(m) ||
+        /qwen[-_]?3/.test(m) ||
+        /deepseek[-_]?r1/.test(m) ||
+        /glm[-_]?4[.-]?[56]/.test(m) ||
+        /glm[-_]?5/.test(m) ||
+        /doubao[-_]?seed/.test(m));
+}
+/**
+ * 归一化 effort + 目标 → 要 merge 进请求体的字段(空对象 = 不下发)。纯函数。
+ */
+export function resolveReasoningParams(effort, target) {
+    if (effort === 'auto')
+        return {};
+    // 目录优先:带 catalogProviderId 时按目录能力+厂商方言产出。
+    // 注意 anthropic 路径的思考在 anthropic provider 内仍走它自己的 target.provider,
+    // 目录只对 OpenAI 兼容路径有意义;Anthropic 官方协议继续走下方既有分支。
+    if (target.catalogProviderId && target.provider !== 'anthropic') {
+        const fromCatalog = paramsFromCatalog({
+            effort,
+            catalogProviderId: target.catalogProviderId,
+            reasoningOptions: target.catalogReasoningOptions,
+            maxTokens: target.maxTokens,
+        });
+        // 目录能产出非空字段就用;方言未知/返 {} 则落到正则兜底(而不是直接放弃)。
+        if (Object.keys(fromCatalog).length > 0)
+            return fromCatalog;
+    }
+    if (target.provider === 'anthropic') {
+        const m = target.model.toLowerCase();
+        // 仅认显式分隔的版本号 4-6/4.6/4_6/4-10…;宽松写法会误匹配名字里的日期(…20241022 中的 410)。
+        const is46Plus = /4[.\-_](?:[6-9]|[1-9]\d)(?!\d)/.test(m);
+        if (is46Plus) {
+            if (effort === 'off')
+                return { thinking: { type: 'disabled' } };
+            return { output_config: { effort }, thinking: { type: 'adaptive' } };
+        }
+        if (effort === 'off')
+            return {};
+        // 旧版:budget 必须严格小于 max_tokens,clamp 后非正 → 无法启用,不下发。
+        const maxTokens = target.maxTokens ?? ANTHROPIC_DEFAULT_MAX;
+        const budget = Math.min(THINK_BUDGET[effort], maxTokens - ANTHROPIC_OUTPUT_RESERVED);
+        if (budget <= 0)
+            return {};
+        return { thinking: { type: 'enabled', budget_tokens: budget } };
+    }
+    // ── OpenAI 兼容路径 ──
+    const m = target.model.toLowerCase();
+    // Qwen3(先于通用规则:名字里不含冲突模式,但显式更清晰)。
+    if (/qwen[-_]?3/.test(m)) {
+        if (effort === 'off')
+            return { enable_thinking: false };
+        return { enable_thinking: true, thinking_budget: THINK_BUDGET[effort] };
+    }
+    // GLM-4.5/4.6/5。
+    if (/glm[-_]?4[.-]?[56]/.test(m) || /glm[-_]?5/.test(m)) {
+        if (effort === 'off')
+            return { thinking: { type: 'disabled' } };
+        return { thinking: { type: 'enabled' } };
+    }
+    // 豆包 Seed(火山 Ark):思考是开关式,无 low/medium/high 预算档——非 off 即启用。
+    if (/doubao[-_]?seed/.test(m)) {
+        if (effort === 'off')
+            return { thinking: { type: 'disabled' } };
+        return { thinking: { type: 'enabled' } };
+    }
+    // DeepSeek-R1:无开关参数,任何档位都不下发。
+    if (/deepseek[-_]?r1/.test(m))
+        return {};
+    // OpenAI o1/o3/o4 + gpt-5:off 无法真关,官方最低档 low。
+    if (/\bo[134]\b/.test(m) || /gpt-?5/.test(m)) {
+        if (effort === 'off')
+            return { reasoning_effort: 'low' };
+        return { reasoning_effort: effort };
+    }
+    // 未知模型/第三方网关:白名单策略,不下发。
+    return {};
+}

package/dist/memory/reflect.js

@@ -147,7 +147,7 @@ export async function runReflection(transcript, signal) {
     };
     let content = null;
     try {
-        const r = await chat([sys, user], {}, signal ?? AbortSignal.timeout(60000));
+        const r = await chat([sys, user], {}, signal ?? AbortSignal.timeout(60000), undefined, { reasoningEffort: 'low' });
         // 推理模型偶发只返 reasoning_content(content null)或幻觉 tool_calls → 视为无产出
         if (!r.toolCalls.length && r.content)
             content = r.content;

package/dist/memory/store.js

@@ -12,6 +12,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from '
 import os from 'node:os';
 import path from 'node:path';
 import { MAX_ACTIVE, MAX_INDEX_ENTRIES, MAX_MEMORY_ENTRY, DECAY_DAYS, GC_DAYS } from '../tools/constants.js';
+import { TextSearchIndex } from '../context/text-search.js';
 // ── 路径 ──────────────────────────────────────────────────────────────────
 function globalPath() {
     return path.join(os.homedir(), '.mocode', 'memory.jsonl');
@@ -139,57 +140,59 @@ export function saveEntry(input) {
     writeAtomic(p, fileEntries);
     return { ok: true, id };
 }
-function scoreEntry(e, terms) {
-    if (terms.length === 0)
-        return 1; // 无关键词:全命中(取前 limit)
-    const id = e.id.toLowerCase();
-    const name = e.name.toLowerCase();
-    const summary = e.summary.toLowerCase();
-    const body = e.body.toLowerCase();
-    let s = 0;
-    for (const t of terms) {
-        if (id.includes(t))
-            s += 8; // 含 id 匹配:模型常按索引里的 id 取详情(slug 带连字符,名字带空格,不单独匹配 id 会漏)
-        if (name.includes(t))
-            s += 10;
-        if (summary.includes(t))
-            s += 5;
-        if (body.includes(t))
-            s += 1;
-    }
-    return s;
-}
-/** 关键词搜索:多词子串匹配(name 权重最高)。命中即 bump recallCount/lastRecalledAt 写回(遗忘衰减依据)。 */
+/**
+ * 关键词搜索:CJK 感知 BM25(共享 context/text-search),字段权重 name 10 > id 8 >
+ * summary 5 > body 1。命中即 bump recallCount/lastRecalledAt 写回(遗忘衰减依据)。
+ * 空查询:按旧行为返回前 limit 条(全命中)。
+ */
 export function searchEntries(query, opts = {}) {
     const all = loadAll();
     const status = opts.status ?? 'active';
     const pool = all
         .filter((e) => (status === 'any' ? true : e.status === status))
         .filter((e) => (opts.type ? e.type === opts.type : true));
-    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
-    const scored = pool.map((e) => ({ e, s: scoreEntry(e, terms) })).filter((x) => x.s > 0);
-    scored.sort((a, b) => b.s - a.s);
     const limit = Math.max(1, Math.min(opts.limit ?? 5, 20));
-    const top = scored.slice(0, limit);
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const top = [];
+    if (terms.length === 0) {
+        top.push(...pool.slice(0, limit));
+    }
+    else {
+        const index = new TextSearchIndex(pool.map((e) => ({
+            id: e.id,
+            fields: [
+                { text: e.name, weight: 10 },
+                { text: e.id, weight: 8 },
+                { text: e.summary, weight: 5 },
+                { text: e.body, weight: 1 },
+            ],
+        })));
+        const byId = new Map(pool.map((e) => [e.id, e]));
+        for (const hit of index.search(query, limit)) {
+            const e = byId.get(hit.id);
+            if (e)
+                top.push(e);
+        }
+    }
     if (top.length === 0)
         return [];
     // bump recall:只写有命中的 scope 文件
     const now = nowIso();
-    const hitIds = new Set(top.map((x) => x.e.id));
+    const hitIds = new Set(top.map((x) => x.id));
     for (const e of all) {
         if (hitIds.has(e.id)) {
             e.recallCount++;
             e.lastRecalledAt = now;
         }
     }
-    const hitScopes = new Set(top.map((x) => x.e.scope));
+    const hitScopes = new Set(top.map((x) => x.scope));
     for (const scope of hitScopes) {
         const p = pathForScope(scope);
         const entries = all.filter((e) => e.scope === scope);
         ensureDir(p);
         writeAtomic(p, entries);
     }
-    return top.map((x) => x.e);
+    return top;
 }
 /** 索引(无 body、不 bump recall)。 */
 export function listEntries(opts = {}) {