mocode-ai 1.6.4 → 1.6.6

package/dist/config/index.js

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import dotenv from 'dotenv';
+import { parseReasoningEffort, getScopedEffort } from '../llm/reasoning.js';
+import { getActiveSkill } from '../skills/activation.js';
 import { getCurrentSessionId } from '../session/state.js';
 import { getNotesFilePath, extractActiveNotesSections } from '../session/notes.js';
 import { buildGuiActionsSection } from '../session/gui-actions.js';
@@ -43,7 +45,7 @@ function loadEnvFiles() {
             process.env[k] = v;
     }
 }
-// 在 loadEnvFiles 回填前捕获:MOCODE_THEME / MOCODE_LANGUAGE 是否由 shell 设置。
+// 在 loadEnvFiles 回填前先捕获:MOCODE_THEME / MOCODE_LANGUAGE 是否由 shell 显式 export(决定后续优先级提示)。
 const themeFromShell = process.env.MOCODE_THEME !== undefined;
 export const languageFromShell = process.env.MOCODE_LANGUAGE !== undefined;
 // 在 loadEnvFiles 回填前捕获:哪些 LLM 键由 shell 设置(决定 /model 写文件是否下次启动生效)。
@@ -56,6 +58,7 @@ const LLM_ENV_KEYS = [
     'LLM_MODEL',
     'CONTEXT_WINDOW_TOKENS',
     'ANTHROPIC_PROMPT_CACHE',
+    'REASONING_EFFORT',
 ];
 export const DEFAULT_CONTEXT_WINDOW_TOKENS = 256000;
 const llmKeysFromShell = LLM_ENV_KEYS.filter((k) => process.env[k] !== undefined);
@@ -492,7 +495,8 @@ ${buildVoiceSection()}
 - Stop immediately when no more tools are needed; give conclusions directly.
 - **Do not stop prematurely during exploration**: if you started investigating but haven't gathered enough information to answer the user's question, keep calling tools. Only stop when you have sufficient evidence or hit a dead end.
 - **No flattery / no preamble in conclusions**: skip "Sure", "好的", "我已经完成了" and similar no-information prefixes — jump straight to substance.
-- Report honestly: say success when successful, say where you're stuck when failing, and mention anything skipped. Reference code in "path:line" format (e.g., src/index.ts:42). Keep it concise.`;
+- Report honestly: say success when successful, say where you're stuck when failing, and mention anything skipped. Reference code in "path:line" format (e.g., src/index.ts:42). Keep it concise.
+- Definition of done: never declare a multi-feature request finished just because the code exists. Each distinct user request listed in the plan must be actually verified (the relevant check run / observed result), not merely implemented; mark plan steps \`[x]\` only after that verification. If the user supplied an acceptance list, every item on it must pass. Leave unverified items explicitly listed as pending instead of collapsing them into "done".`;
     // 动态段(置于末尾):AGENTS.md 项目记忆 + notepad 索引/说明。工具簇特定指导由
     // ToolPolicyController.reminder() 按当前 turn 的 route 注入，避免旧全局 profile 与真实 schema 分裂。
     // 按需注入(#13):有内容的索引才拼对应标题,避免空标题噪声。
@@ -582,10 +586,17 @@ export const config = {
         ? process.env.ANTHROPIC_PROMPT_CACHE !== 'false'
         : (__activePreset?.anthropicPromptCache ?? process.env.ANTHROPIC_PROMPT_CACHE !== 'false'),
     autoCompact: process.env.AUTO_COMPACT !== 'false',
+    reasoningEffort: llmKeysFromShell.includes('REASONING_EFFORT')
+        ? (parseReasoningEffort(process.env.REASONING_EFFORT) ?? 'auto')
+        : (__activePreset?.reasoningEffort ?? parseReasoningEffort(process.env.REASONING_EFFORT) ?? 'auto'),
+    compactFork: process.env.MOCODE_COMPACT_FORK !== 'false',
+    readDedup: process.env.MOCODE_READ_DEDUP !== 'false',
     contextOptimize: process.env.MOCODE_CONTEXT_OPTIMIZE !== 'false',
     contextRelprune: process.env.MOCODE_CONTEXT_RELPRUNE !== 'false',
     contextLifecycle: process.env.MOCODE_LIFECYCLE !== 'false',
     contextBudget: process.env.MOCODE_BUDGET_SCHEDULER !== 'false',
+    lowPressureRatio: Math.min(0.95, Math.max(0.1, Number(process.env.MOCODE_LOW_PRESSURE_RATIO) || 0.6)),
+    toolClearing: process.env.MOCODE_TOOL_CLEARING !== 'false',
     autoReflect: process.env.AUTO_REFLECT === 'true',
     memoryEnabled: process.env.MEMORY_ENABLED === 'true',
     reflectEveryN: Number(process.env.REFLECT_EVERY_N) || 5,
@@ -593,6 +604,7 @@ export const config = {
     subAgentEnabled: process.env.MOCODE_SUBAGENT_ENABLED === 'true',
     subAgentMaxSteps: Number(process.env.SUB_AGENT_MAX_STEPS) || Number(process.env.MAX_STEPS) || 1000,
     subAgentConcurrency: Math.max(1, Number(process.env.SUB_AGENT_CONCURRENCY) || 5),
+    subAgentMaxDepth: Math.max(1, Number(process.env.SUB_AGENT_MAX_DEPTH) || 3),
     frontendToolsEnabled: process.env.MOCODE_FRONTEND_TOOLS_ENABLED === 'true',
     computerUseEnabled: process.env.MOCODE_COMPUTER_USE_ENABLED === 'true',
     mcpEnabled: process.env.MOCODE_MCP_ENABLED !== 'false',
@@ -606,6 +618,7 @@ export const config = {
     llmKeysFromShell,
     permissionEnabled: process.env.MOCODE_PERMISSION !== 'false',
     permissionNonInteractiveAllow: process.env.MOCODE_PERMISSION_NON_INTERACTIVE_ALLOW === 'true',
+    notifyWebhook: process.env.MOCODE_NOTIFY_WEBHOOK || undefined,
 };
 /**
  * 创建一份独立 Config 快照，不重新读取环境变量、配置文件或 preset。
@@ -636,6 +649,38 @@ export function pinSessionModel() {
 export function getActiveModel() {
     return sessionModel ?? config.model;
 }
+/**
+ * 会话级思考强度钉死(P3),与 sessionModel 同构:窗口启动 pinSessionEffort() 捕获,
+ * /effort 显式修改同步更新钉死值;其它窗口的设置互不影响。
+ */
+let sessionEffort = null;
+/** REPL 启动时调用一次。 */
+export function pinSessionEffort() {
+    sessionEffort = config.reasoningEffort;
+}
+/** 运行中 agent 实际使用的思考强度。 */
+export function getActiveEffort() {
+    return sessionEffort ?? config.reasoningEffort;
+}
+/**
+ * 生效思考强度统一解析(P3 §4.8):
+ *   显式 per-request 参数(compact/reflect 的 low)> fork ALS scope(skill 子树)
+ *   > inline 激活 skill 的 effort > 会话级。
+ * shell env 显式设置 REASONING_EFFORT 时,skill effort 不参与(对齐 Claude Code:env 最高)。
+ */
+export function effectiveReasoningEffort(explicit) {
+    if (explicit !== undefined)
+        return explicit;
+    const scoped = getScopedEffort();
+    if (scoped)
+        return scoped;
+    if (!config.llmKeysFromShell.includes('REASONING_EFFORT')) {
+        const skillEffort = getActiveSkill()?.effort;
+        if (skillEffort)
+            return skillEffort;
+    }
+    return getActiveEffort();
+}
 /**
  * 运行时更新模型相关配置(/model 命令调)。
  * - 更新 config 对象字段(即时生效:chat() 读 config.model,reconfigureClient 读 config.baseURL/apiKey)。
@@ -673,6 +718,12 @@ export function updateModelConfig(opts) {
         config.anthropicPromptCache = opts.anthropicPromptCache;
         process.env.ANTHROPIC_PROMPT_CACHE = opts.anthropicPromptCache ? 'true' : 'false';
     }
+    if (opts.reasoningEffort !== undefined) {
+        config.reasoningEffort = opts.reasoningEffort;
+        if (sessionEffort !== null)
+            sessionEffort = opts.reasoningEffort;
+        process.env.REASONING_EFFORT = opts.reasoningEffort;
+    }
 }
 /** legacy 嵌入路径的 profile 查询；官方主 Agent 不读取。 */
 export function getActiveProfile() {

package/dist/config/presets.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { parseReasoningEffort } from '../llm/reasoning.js';
 /**
  * 多模型预设(`/model save <name>` 保存的命名配置)的纯 I/O 叶子。
  *
@@ -78,6 +79,41 @@ export function parsePreset(raw) {
     }
     const provider = obj.provider === 'anthropic' ? 'anthropic' : 'openai';
     const anthropicPromptCache = provider === 'anthropic' && obj.anthropicPromptCache !== false;
+    // reasoningEffort 缺省 = auto;显式写了非法值按现有校验风格报错(坏文件由 listPresets 跳过)。
+    let reasoningEffort;
+    if (obj.reasoningEffort !== undefined) {
+        reasoningEffort = parseReasoningEffort(obj.reasoningEffort);
+        if (!reasoningEffort)
+            throw new Error(`预设 ${name}: reasoningEffort 非法(off|low|medium|high|auto)`);
+    }
+    // ── 目录可选字段:只在「存在且类型正确」时采纳,缺失/错误即 undefined,不报错 ──
+    const extra = {};
+    if (typeof obj.catalogProvider === 'string' && obj.catalogProvider)
+        extra.catalogProvider = obj.catalogProvider;
+    if (typeof obj.catalogModel === 'string' && obj.catalogModel)
+        extra.catalogModel = obj.catalogModel;
+    if (obj.capabilities && typeof obj.capabilities === 'object') {
+        const c = obj.capabilities;
+        const caps = {};
+        if (typeof c.reasoning === 'boolean')
+            caps.reasoning = c.reasoning;
+        if (typeof c.toolCall === 'boolean')
+            caps.toolCall = c.toolCall;
+        if (typeof c.attachment === 'boolean')
+            caps.attachment = c.attachment;
+        if (Array.isArray(c.reasoningOptions))
+            caps.reasoningOptions = c.reasoningOptions;
+        extra.capabilities = caps;
+    }
+    if (obj.pricing && typeof obj.pricing === 'object') {
+        const p = obj.pricing;
+        const pricing = {};
+        for (const k of ['input', 'output', 'cacheRead']) {
+            if (typeof p[k] === 'number' && Number.isFinite(p[k]))
+                pricing[k] = p[k];
+        }
+        extra.pricing = pricing;
+    }
     return {
         name,
         provider,
@@ -86,6 +122,8 @@ export function parsePreset(raw) {
         model,
         contextWindow: Math.floor(contextWindow),
         anthropicPromptCache,
+        ...(reasoningEffort ? { reasoningEffort } : {}),
+        ...extra,
     };
 }
 /** 读单个预设;不存在抛错。 */
@@ -217,7 +255,8 @@ export function migrateCurrentToPreset(input) {
         p.apiKey === input.apiKey &&
         p.model === input.model &&
         p.contextWindow === input.contextWindow &&
-        p.anthropicPromptCache === anthropicPromptCache);
+        p.anthropicPromptCache === anthropicPromptCache &&
+        (p.reasoningEffort ?? 'auto') === 'auto');
     if (dup)
         return null;
     // 'default' 已被占 → 用户已显式起过预设,无需老数据迁入;返回 null 让调用方跳过即可。

package/dist/config/profiles.js

@@ -19,7 +19,15 @@ export const TOOL_GROUPS = {
     web: ['web_search', 'web_fetch'],
     frontend: ['browser', 'screenshot'],
     computer: ['computer'],
-    memory: ['memory_save', 'memory_search', 'memory_list', 'memory_update', 'memory_forget', 'memory_graph'],
+    memory: [
+        'memory_save',
+        'memory_search',
+        'memory_list',
+        'memory_update',
+        'memory_forget',
+        'memory_graph',
+        'session_search',
+    ],
     subagent: ['sub-agent'],
 };
 // ── LLM 自动工具路由 ──────────────────────────────────────────────────────

package/dist/context/clearing.js

@@ -0,0 +1,53 @@
+// Tool-result clearing: 可重取结果的低成本清除(Anthropic 三原语之一)。
+//
+// 与 relevance pruner 的区别:pruner 只在有「精确的新替代」时 stub;clearing 更宽——
+// 冷区中来自可重取工具的结果,无论有没有新替代,内容都可丢弃(需要时重新调用即可),
+// 只保留「调用发生过」的 tombstone。不删消息、不改 tool_call_id 配对。
+//
+// 在低压阶段(60%)运行:零 LLM 成本、不依赖摘要质量。热区(最近 hotTurnWindow 个
+// user turn)不动。
+import { toText } from './utils.js';
+/** 结果可随时重取的工具:纯读、无副作用。 */
+export const REFETCHABLE_TOOLS = new Set(['read_file', 'grep', 'glob', 'web_search', 'web_fetch']);
+/** Tombstone 前缀,与 relevance stub 同属 ⌦[ 家族,其余子系统据此识别已清除内容。 */
+const CLEARED_PREFIX = '⌦[已清除:';
+/** 回溯 tool_call_id → 产生该结果的工具名(同 relevance.ts callAt 的最小版本)。 */
+function toolNameAt(history, idx) {
+    const tcId = history[idx]?.tool_call_id;
+    if (!tcId)
+        return null;
+    for (let j = idx - 1; j >= 1; j--) {
+        if (history[j].role !== 'assistant')
+            continue;
+        const calls = history[j].tool_calls;
+        const hit = calls?.find((tc) => tc?.id === tcId);
+        if (hit?.function?.name)
+            return hit.function.name;
+    }
+    return null;
+}
+/**
+ * 清除冷区可重取工具的结果内容。
+ * @param coldBoundary 仅处理 index < coldBoundary 的消息(热区保留)。
+ * @returns 被清除的消息数。
+ */
+export function clearRetrievableResults(history, coldBoundary) {
+    let cleared = 0;
+    const end = Math.min(coldBoundary, history.length);
+    for (let idx = 1; idx < end; idx++) {
+        const message = history[idx];
+        if (message.role !== 'tool' || !message.tool_call_id)
+            continue;
+        const content = toText(message.content);
+        if (!content || content.startsWith('⌦['))
+            continue;
+        const name = toolNameAt(history, idx);
+        if (!name || !REFETCHABLE_TOOLS.has(name))
+            continue;
+        message.content =
+            `${CLEARED_PREFIX}${name}] 原结果 ${content.length} 字符已清除(可重新调用获取)` +
+                ` · id …${message.tool_call_id.slice(-6)}⌫`;
+        cleared++;
+    }
+    return cleared;
+}

package/dist/context/relevance.js

@@ -258,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)
@@ -280,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));
+    }
+}