mocode-ai 1.6.3 → 1.6.5

package/dist/agent/stages/tool-dispatcher.js

@@ -46,6 +46,7 @@ class LegacyCompatibleToolDispatcher {
             callId: call.id,
             allowedToolNames: request.currentAllowedToolNames(),
             delegation: request.delegation(),
+            readDedup: request.readDedup,
             ...(hint ? { argumentErrorHint: hint } : {}),
             ...(onLockAcquired ? { onLockAcquired } : {}),
         });
@@ -76,95 +77,132 @@ class LegacyCompatibleToolDispatcher {
                 argumentSummary: argumentSummaries[index],
             });
         }
-        const hasRouteBarrier = calls.some((call) => call.name === ADD_TOOL_GROUPS_TOOL_NAME);
+        const controlIndexes = [];
+        const otherIndexes = [];
+        calls.forEach((call, index) => (call.name === ADD_TOOL_GROUPS_TOOL_NAME ? controlIndexes : otherIndexes).push(index));
+        const hasRouteBarrier = controlIndexes.length > 0;
         if (hasRouteBarrier) {
-            const mixedCall = calls.length !== 1;
-            for (let index = 0; index < calls.length; index++) {
-                const call = calls[index];
-                request.onEvent({ type: 'header', call });
-                const parsed = parseArgs(call.arguments);
-                let outcome;
-                if (mixedCall) {
+            // 同批的非控制调用全部是「未被禁用的并行安全(只读)工具」时(纯 solo 时空集也满足),
+            // 允许它们与扩容同批:先并发执行只读调用,再应用扩容。只读结果本 step 即得,新增 schema
+            // 下一 step 生效——不必为扩容空耗一轮。只要混有写/执行等非并行工具(或某只读调用已被
+            // 当前 snapshot 拒绝),即退回整批保守拒绝。
+            const safeReadonlyBatch = otherIndexes.every((index) => isParallelTool(calls[index].name, toolRuntime) && !request.isDenied(calls[index].name));
+            if (safeReadonlyBatch) {
+                // 所有 header 按调用原序先发(渲染侧据此建组容器),只读批的 header 必须先于 execute。
+                for (let index = 0; index < calls.length; index++) {
+                    request.onEvent({ type: 'header', call: calls[index] });
+                }
+                if (otherIndexes.length > 0) {
+                    request.onEvent({ type: 'start', tool: calls[otherIndexes[0]].name });
+                    const startedReadonly = otherIndexes.map((index) => execute(calls[index]));
+                    for (let offset = 0; offset < otherIndexes.length; offset++) {
+                        const index = otherIndexes[offset];
+                        const outcome = await startedReadonly[offset];
+                        record(index, outcome);
+                        executionEvents(index, parseArgs(calls[index].arguments), outcome);
+                        resultEvent(index, outcome, null);
+                    }
+                    request.onEvent({ type: 'done' });
+                }
+                // 控制调用(header 已发):逐个校验并应用扩容;solo 与同批语义一致。
+                for (const index of controlIndexes) {
+                    const call = calls[index];
+                    const parsed = parseArgs(call.arguments);
+                    let outcome;
+                    if (request.isDenied(call.name)) {
+                        outcome = {
+                            status: 'denied',
+                            code: 'TOOL_DISABLED',
+                            retryable: false,
+                            output: `错误:当前 tool policy snapshot 不允许调用 ${call.name}。`,
+                            changedFiles: [],
+                            durationMs: 0,
+                        };
+                    }
+                    else if (!request.expandToolGroups) {
+                        outcome = {
+                            status: 'denied',
+                            code: 'TOOL_DISABLED',
+                            retryable: false,
+                            output: '错误:当前 Agent 未启用动态工具策略，无法调用 add_tool_groups。',
+                            changedFiles: [],
+                            durationMs: 0,
+                        };
+                    }
+                    else if (!parsed ||
+                        !Array.isArray(parsed.groups) ||
+                        parsed.groups.length === 0 ||
+                        typeof parsed.reason !== 'string' ||
+                        !parsed.reason.trim()) {
+                        outcome = {
+                            status: 'error',
+                            code: 'INVALID_ARGUMENTS',
+                            retryable: false,
+                            output: '错误:add_tool_groups 需要非空 groups 数组和非空 reason。',
+                            changedFiles: [],
+                            durationMs: 0,
+                        };
+                    }
+                    else {
+                        const expansion = request.expandToolGroups(parsed.groups, parsed.reason);
+                        const succeeded = expansion.added.length > 0;
+                        const details = [
+                            succeeded
+                                ? `Tool policy expanded to v${expansion.snapshot.version}; added groups: ${expansion.added.join(', ')}.`
+                                : `Tool policy was not expanded (still v${expansion.snapshot.version}).`,
+                            expansion.implied.length > 0 ? `Implied groups also activated: ${expansion.implied.join(', ')}.` : '',
+                            expansion.rejected.length > 0 ? `Rejected: ${expansion.rejected.join('; ')}.` : '',
+                            succeeded ? 'The added tool schemas become available on the next model step.' : '',
+                        ]
+                            .filter(Boolean)
+                            .join('\n');
+                        outcome = {
+                            status: succeeded ? 'success' : 'error',
+                            code: succeeded ? 'OK' : 'INVALID_ARGUMENTS',
+                            retryable: false,
+                            output: details,
+                            changedFiles: [],
+                            durationMs: 0,
+                        };
+                        request.onEvent({
+                            type: 'route_expand',
+                            fromVersion: request.policy.toolPolicy?.version,
+                            expansion,
+                            requestedGroups: parsed.groups,
+                            reason: parsed.reason,
+                            status: outcome.status,
+                        });
+                    }
+                    record(index, outcome);
+                    request.onEvent({ type: 'host_outcome', call, parsed: parsed ?? {}, outcome });
+                    resultEvent(index, outcome, null);
+                    traceEnd(index, outcome);
+                }
+            }
+            else {
+                // 不安全批(混有写/执行等非并行工具):不扩容、不执行任何普通工具,逐 call 按原序配对拒绝结果。
+                for (let index = 0; index < calls.length; index++) {
+                    const call = calls[index];
+                    request.onEvent({ type: 'header', call });
                     const isControl = call.name === ADD_TOOL_GROUPS_TOOL_NAME;
-                    outcome = {
+                    const isReadonly = isParallelTool(call.name, toolRuntime);
+                    const outcome = {
                         status: 'denied',
                         code: isControl ? 'INVALID_ARGUMENTS' : 'TOOL_DISABLED',
                         retryable: false,
                         output: isControl
-                            ? '错误:add_tool_groups 必须在一个独立的 model step 中单独调用；本次没有扩容。'
-                            : `错误:同一响应包含 add_tool_groups，工具 ${call.name} 未执行。请等待扩容结果后在下一 step 重试。`,
-                        changedFiles: [],
-                        durationMs: 0,
-                    };
-                }
-                else if (request.isDenied(call.name)) {
-                    outcome = {
-                        status: 'denied',
-                        code: 'TOOL_DISABLED',
-                        retryable: false,
-                        output: `错误:当前 tool policy snapshot 不允许调用 ${call.name}。`,
+                            ? '错误:add_tool_groups 只能单独调用，或与只读工具(read_file/glob/grep/web 等)同批；本次没有扩容。'
+                            : isReadonly
+                                ? `错误:同一响应包含 add_tool_groups，工具 ${call.name} 未执行。请在下一 step 重试。`
+                                : `错误:add_tool_groups 不能与写/执行工具 ${call.name} 同批；请先完成扩容，再在下一 step 调用 ${call.name}。`,
                         changedFiles: [],
                         durationMs: 0,
                     };
+                    record(index, outcome);
+                    request.onEvent({ type: 'host_outcome', call, parsed: parseArgs(call.arguments) ?? {}, outcome });
+                    resultEvent(index, outcome, null);
+                    traceEnd(index, outcome);
                 }
-                else if (!request.expandToolGroups) {
-                    outcome = {
-                        status: 'denied',
-                        code: 'TOOL_DISABLED',
-                        retryable: false,
-                        output: '错误:当前 Agent 未启用动态工具策略，无法调用 add_tool_groups。',
-                        changedFiles: [],
-                        durationMs: 0,
-                    };
-                }
-                else if (!parsed ||
-                    !Array.isArray(parsed.groups) ||
-                    parsed.groups.length === 0 ||
-                    typeof parsed.reason !== 'string' ||
-                    !parsed.reason.trim()) {
-                    outcome = {
-                        status: 'error',
-                        code: 'INVALID_ARGUMENTS',
-                        retryable: false,
-                        output: '错误:add_tool_groups 需要非空 groups 数组和非空 reason。',
-                        changedFiles: [],
-                        durationMs: 0,
-                    };
-                }
-                else {
-                    const expansion = request.expandToolGroups(parsed.groups, parsed.reason);
-                    const succeeded = expansion.added.length > 0;
-                    const details = [
-                        succeeded
-                            ? `Tool policy expanded to v${expansion.snapshot.version}; added groups: ${expansion.added.join(', ')}.`
-                            : `Tool policy was not expanded (still v${expansion.snapshot.version}).`,
-                        expansion.implied.length > 0 ? `Implied groups also activated: ${expansion.implied.join(', ')}.` : '',
-                        expansion.rejected.length > 0 ? `Rejected: ${expansion.rejected.join('; ')}.` : '',
-                        succeeded ? 'The added tool schemas become available on the next model step.' : '',
-                    ]
-                        .filter(Boolean)
-                        .join('\n');
-                    outcome = {
-                        status: succeeded ? 'success' : 'error',
-                        code: succeeded ? 'OK' : 'INVALID_ARGUMENTS',
-                        retryable: false,
-                        output: details,
-                        changedFiles: [],
-                        durationMs: 0,
-                    };
-                    request.onEvent({
-                        type: 'route_expand',
-                        fromVersion: request.policy.toolPolicy?.version,
-                        expansion,
-                        requestedGroups: parsed.groups,
-                        reason: parsed.reason,
-                        status: outcome.status,
-                    });
-                }
-                record(index, outcome);
-                request.onEvent({ type: 'host_outcome', call, parsed: parsed ?? {}, outcome });
-                resultEvent(index, outcome, null);
-                traceEnd(index, outcome);
             }
         }
         let index = hasRouteBarrier ? calls.length : 0;

package/dist/agent/work-discipline.js

@@ -41,9 +41,11 @@ Call \`ask_human\` before coding only when repository evidence cannot resolve a
 3. multiple reasonable options that materially change product behavior;
 4. the request itself admits two or more materially different readings that lead to different deliverables (do not silently pick one and guess).
 
+When the request is ambiguous, vague, or missing key information, first load the \`brainstorming\` skill and clarify the need through a short dialogue (one question at a time) before starting work.
+
 For naming and implementation details, follow repository precedent and choose the safest reversible default. Disclose any consequential assumption.
 
-Budget: at most 2 \`ask_human\` calls per turn. Beyond that, use the safest reversible default and disclose it in the final reply.`;
+Budget: during requirement clarification (the \`brainstorming\` workflow) ask as many questions as genuinely advance understanding; during execution after requirements are clear, use at most 2 \`ask_human\` calls per turn, then fall back to the safest reversible default and disclose it in the final reply.`;
 /** Advisory guidance shared by main and sub-agents. */
 export function buildWorkDisciplineSection(_modelFamily) {
     return `${CORE_SECTION}\n\n${ASK_WHITELIST_SECTION}`;

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,29 +495,20 @@ ${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):有内容的索引才拼对应标题,避免空标题噪声。
     const dynamicParts = [];
-    // 会话级私有尾段(子 agent 切片会丢弃):Session state 说明无条件注入在前,Project context 按需在后。
+    // 会话级私有尾段(子 agent 切片会丢弃)。只放一句指针:plan/note 的完整规则由
+    // plan_update / note_append 的 description 承载(两工具在常驻面,调用时一定可见),
+    // 避免把规则在系统提示里每请求预付第三遍。**标题 '## Session state' 必须保留**:
+    // buildMocodeCorePrompt 靠 MARKER_DROPPABLE_SECTION 给子 agent 切片。
     dynamicParts.push(`## Session state (\`.mocode/sessions/${sessionId ?? '<id>'}/notes.md\`)\n` +
-        'Persistent working surface for tasks with 3+ steps or context-loss risk; skip it for simple work. It survives compaction.\n\n' +
-        'Record and update the execution plan with the `plan_update` tool (not by hand-editing checkboxes); it keeps at most one active plan:\n' +
-        '```\n' +
-        '## Plan: <title>\n' +
-        'Goal: <outcome>\n' +
-        '### Steps\n' +
-        '- [ ] 1. **<short label, ≤20 chars>** — <self-contained step: target file/symbol, the change, and how to verify>\n' +
-        '### Progress\n' +
-        '- <completed/total>\n' +
-        '```\n' +
-        'Each step: short `title` (≤20 chars, e.g. "编写测试" / "修 status bar", shown in the status bar) + self-contained `content` (target file/symbol, exact change, verification — readable cold, without this conversation). ' +
-        'Keep at most one step in_progress; mark a step completed as soon as its work is done, not batched to the end of the turn. ' +
-        'plan_update creates notes.md on demand and settles the plan to `## Done:` when all steps complete; run read_file on the full notes.md to recover context after compaction. ' +
-        'Keep other notes concise and session-specific; use memory for stable cross-session facts.\n' +
-        '## Session notes (resident memory)\n' +
-        'For lasting-value discoveries — subtle constraints, decisions with downstream impact, open questions, or risks — call `note_append` IMMEDIATELY when you make the discovery. Notes land in the same notes.md and are re-injected into the prompt automatically (5k-token budget), surviving compaction. Do NOT use for routine progress (that is the plan) or stable cross-session facts (that is memory_save). Each call appends one item.');
+        'For tasks with 3+ steps or context-loss risk, keep an execution plan with `plan_update`; record non-obvious findings/decisions/open questions/risks with `note_append`. ' +
+        'Both write notes.md, which survives compaction — run read_file on it to recover context after compaction. ' +
+        'Their formats and rules live in each tool\u2019s description; do not hand-edit the files.');
     // 日期段:模型需要知道今天才能判断 freshness(web 搜索、版本时效)。只随天变化,
     // 不破坏会话内前缀缓存;置于 '## Session state' 之前,子 agent 切片仍保留(无害且有用)。
     const todaySection = buildTodaySection();
@@ -592,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',
-    contextOptimize: process.env.MOCODE_CONTEXT_OPTIMIZE === 'true',
-    contextRelprune: process.env.MOCODE_CONTEXT_RELPRUNE === 'true',
+    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,
@@ -603,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',
@@ -646,6 +648,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)。
@@ -683,6 +717,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/encoders/passthrough.js

@@ -1,8 +1,8 @@
 /**
  * 兜底 encoder:identity,原样返回。
  *  - classifier 未命中任何 kind(返回 'passthrough')时用。
- *  - pipeline 总开关关闭(MOCODE_CONTEXT_OPTIMIZE=false)时,所有 kind 都走它 → 行为与改造前逐字节一致。
- *  - Phase 1 阶段 registry 只注册它 → 全链路零行为变化。
+ *  - pipeline 总开关关闭(MOCODE_CONTEXT_OPTIMIZE=false)时,所有 kind 都走它 → 与不启用该阶段时的行为逐字节一致。
+ *  - 未注册任何 encoder(仅 passthrough)→ 全链路零改写。
  *  - 任何 encoder 报错时,pipeline catch 后回落到它(传原 output)。
  *
  * 永不抛错:output 可能是任意字符串(含 ANSI / 多行 / 非法 UTF-8 片段),identity 直接返回,无解析风险。

package/dist/context/pipeline.js

@@ -2,8 +2,9 @@
 //
 // Normal tool insertion does not call this module: agent/core stores the raw
 // result after only capToolResultForHistory(). The pressure scheduler invokes
-// this encoder for Cold logs and retrievable searches when the opt-in switch is
-// enabled. Encoder failures always fall back to the raw hard-capped result.
+// this encoder for Cold logs and retrievable searches; the switch defaults to
+// enabled and can be turned off via MOCODE_CONTEXT_OPTIMIZE=false. Encoder
+// failures always fall back to the raw hard-capped result.
 //
 // This does not alter tool schemas, execution, tool_call_id pairing, or TUI
 // rendering; it only provides a pressure-stage representation transform.
@@ -53,7 +54,7 @@ function budgetFor(name) {
  */
 export function optimizeToolResult(name, output, argsRaw, context = {}) {
     boot();
-    // Disabled by default: normal history is raw apart from the hard cap.
+    // Opt-out: defaults on; when disabled, normal history is raw apart from the hard cap.
     if (!config.contextOptimize) {
         return capToolResultForHistory(name, output);
     }