mocode-ai 1.6.4 → 1.6.5

package/README.zh-CN.md

@@ -25,6 +25,15 @@ mocode 自己探索代码、读写改文件、执行命令、联网查资料,以
 
 <p align="center"><img src="./assets/demo-build-pomodoro.gif" alt="mocode 从零搭建番茄钟并通过浏览器截图自检" width="100%"></p>
 
+## 效率:更快、更省 token
+
+- **两级模型面板** — 裸 `/model` 先列厂商、Enter 进入后再选模型;搜索是作用域内过滤——顶层只匹配**厂商名**,厂商内只匹配**模型名**,不再把厂商和模型混在一个结果里。
+- **思考强度 `/effort`** — `off / low / medium / high / auto` 五档归一,按目标模型自动翻译成各家方言(Anthropic / OpenAI o·gpt-5 / Qwen3 / GLM / DeepSeek-R1 / 豆包);不认识的模型或第三方网关**不下发**未知字段,避免 400。
+- **用量统计 `/stats`** — 本会话缓存命中率、分层 token 用量与压缩次数,基于后端真实上报,不靠估算。
+- **缓存安全的压缩分叉** — 能整段复用旧对话时优先走 fork,保住 prompt-cache 前缀、减少重复计费;不满足条件再回落摘要(`MOCODE_COMPACT_FORK=false` 关闭)。
+- **重复读取去重** — 同一轮对同一文件的重复读取命中缓存,不再为相同内容重复付费(`MOCODE_READ_DEDUP=false` 关闭)。
+- **子 Agent 深度闸** — 递归派生默认最多 3 层(`SUB_AGENT_MAX_DEPTH` 可调),防止子 agent 无限膨胀。
+
 ## 架构
 
 MoCode 是一个分层的自治运行时：终端交互层驱动 Agent 内核，内核通过受控能力平面执行真实操作，持久化认知层则让长任务和跨会话工作保持连贯。
@@ -109,7 +118,7 @@ mocode 不是一个套壳聊天框,而是一个能真正动手干活的 agent:
 - **会话持久化** — 每轮自动落盘,`--resume` / `/resume` 续接历史会话
 - **Skills 系统** — 自动扫描 `~/.mocode/skills/` 等目录,description 注入系统提示,模型按需调 `use_skill` 加载完整指令(渐进式披露:先看简介,任务相关才加载正文)
 - **可选桌宠** — 独立悬浮窗(`/pet`)显示一个小角色,镜像 agent 活动(空闲 / 思考 / 跑工具 / 等人工),独立进程走 WebSocket,`/pet quit` 完全关闭。挂在终端外,绝不挡终端。
-- **斜杠命令** — `/exit` `/clear` `/cd` `/context` `/skills` `/compact` `/resume` `/rollback` `/memory` `/reflect` `/init` `/theme` `/model` `/plan` `/auto` `/pet`,输入时下拉过滤
+- **斜杠命令** — `/exit` `/clear` `/cd` `/context` `/skills` `/compact` `/resume` `/rollback` `/memory` `/reflect` `/init` `/theme` `/model` `/effort` `/stats` `/plan` `/auto` `/pet`,输入时下拉过滤
 
 ## 使用文档
 
@@ -295,7 +304,9 @@ dev_server stop   id=srv-xxxx
 | `/memory`        | 看记忆库:条目数 + 近期索引                                          |
 | `/memory_switch` | 允许/禁止 memory 自动路由并切换 Memory Index；下一真实用户轮生效    |
 | `/reflect`       | 手动触发一次后台记忆反思 pass                                       |
-| `/model`         | 配置大模型(baseURL / apiKey / model / 上下文窗口),即时生效 + 持久化 |
+| `/model`         | 两级面板切换模型(先选厂商再选模型;顶层按厂商名、厂商内按模型名过滤);也可配置 baseURL / apiKey / 上下文窗口,即时生效 + 持久化 |
+| `/effort`        | 设置思考强度 off/low/medium/high/auto(如 `/effort high`);未识别模型不下发参数 |
+| `/stats`         | 本会话用量:缓存命中率 / 分层 token / 压缩次数 |
 | `/init`          | 扫描项目生成 `AGENTS.md` 项目记忆(发给 agent 执行)                  |
 | `/theme`         | 切换颜色主题(↑↓ · Enter,或 `/theme <name>` 直切)                    |
 | `/plan`          | 切到 plan 模式(只读探查 + 产出计划,审批后切 auto 执行)              |

package/dist/agent/model-turn.js

@@ -1,5 +1,8 @@
 import { estimatePromptTokens, estimateTokens, isContextLengthError, } from '../llm/index.js';
 import { visionBatch, visionKeep } from '../config/index.js';
+import { getActiveSessionStore } from '../session/store.js';
+import { getCurrentSessionId } from '../session/state.js';
+import { toUsageRecord } from '../session/usage-stats.js';
 /**
  * 沿 cause 链(≤3 层)取第一个 errno,供 trace 取证。
  * undici 把底层 errno 挂在 cause 上(`TypeError: fetch failed` → cause `read ECONNRESET`),
@@ -18,7 +21,7 @@ function traceCauseCode(err) {
 }
 /** Executes context preparation plus exactly one model step, including the single overflow retry path. */
 export async function runModelTurn(input) {
-    const { opts, ctx, history, historyManager, runtimeContextState, scheduler, contextTrimmer, modelRunner, activeTools, runPolicy, step, cacheState, turnLifecycle, cancellationLifecycle, rebuildHistoryIndexes, } = input;
+    const { opts, ctx, history, historyManager, runtimeContextState, scheduler, contextTrimmer, modelRunner, activeTools, runPolicy, step, readDedup, cacheState, turnLifecycle, cancellationLifecycle, rebuildHistoryIndexes, } = input;
     const { signal, onContextUpdate, hooks } = opts;
     const { usageMeter, emitTrace } = turnLifecycle;
     const requestBaseURL = ctx.config.baseURL;
@@ -37,6 +40,8 @@ export async function runModelTurn(input) {
     // 视觉滑动窗口**必须剪在 trim 之前**:contextTrimmer.trim() 拿的是 historyManager.snapshot(),
     // 若先 trim,预算口径还是未剪的旧数组,80% 压力线照旧被图像撑爆(design-notes/vision-window.md §2.1)。
     // 只在这一个地方剪;下面的 overflow 重试路径读同一个 snapshot,会自动受益。
+    runtimeContextState.currentStep = step;
+    readDedup.beginStep(step);
     const visionKeepN = visionKeep();
     if (visionKeepN > 0 && historyManager.pruneVisionWindow({ keep: visionKeepN, batch: visionBatch(), step })) {
         rebuildHistoryIndexes();
@@ -52,6 +57,8 @@ export async function runModelTurn(input) {
         signal,
     });
     historyRebuilt = trimResult.kind === 'rebuild';
+    if (trimResult.kind === 'rebuild' || trimResult.kind === 'content')
+        readDedup.markContextChanged();
     const trimStats = trimResult.kind === 'aborted' ? {} : trimResult.stats;
     if (scheduler && trimStats.compactHistoryCalled) {
         emitTrace('compact', {
@@ -244,6 +251,12 @@ export async function runModelTurn(input) {
     });
     runtimeContextState.lastUsage = result.usage;
     usageMeter.add(result.usage);
+    // P1:per-step 用量落盘(失败静默,见 appendUsage)。estimatedTotal 用本次裸估算,
+    // 供 /stats 校验估算偏差。
+    const record = toUsageRecord(step, 'main', result.usage, stepPromptEst);
+    const sessionId = getCurrentSessionId();
+    if (record && sessionId)
+        getActiveSessionStore().appendUsage(sessionId, record);
     if (result.usage) {
         cacheState.lastStepPromptTokens = result.usage.promptTokens;
         if (result.usage.cachedTokens > 0)

package/dist/agent/run-coordinator.js

@@ -13,6 +13,7 @@ import { runToolTurn } from './tool-turn.js';
 import { createTurnLifecycle } from './turn-lifecycle.js';
 import { parseArgs, argumentErrorHint, isParallelTool, isParallelOrchestrationCall, isResourceLockedCall, deniedOutcome, readDiffContext, pushToolResult, } from './tool-helpers.js';
 import { contextState, summarizeToolArguments } from '../session/index.js';
+import { createReadDedup } from '../tools/read-dedup.js';
 import { createBudgetScheduler } from '../session/scheduler.js';
 import { invalidateArtifacts, rehydrateArtifacts } from '../context/index.js';
 import { createRelevancePruner } from '../context/relevance.js';
@@ -64,6 +65,8 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
     const { usageMeter, emitTrace, traceTurnId } = turnLifecycle;
     const toolTurnPlanState = { stepsSincePlanTouch: 0 };
     historyManager.appendUserTurn(userInput);
+    // P2:每用户 turn 一个重复读 scope,经 dispatcher → ToolContext 透传给 read_file。
+    const readDedup = createReadDedup();
     // The initial cancellation checkpoint is captured after the user turn and before any model/tool work.
     // Relevance and lifecycle collect provenance during normal work. Neither path
     // rewrites history; exact supersession is applied only by the pressure scheduler.
@@ -173,6 +176,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                     activeTools,
                     runPolicy,
                     step,
+                    readDedup,
                     cacheState: modelCacheState,
                     turnLifecycle,
                     cancellationLifecycle,
@@ -318,6 +322,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                     isDenied: isToolDeniedForStep,
                                     currentAllowedToolNames,
                                     delegation: delegationForOrchestrator,
+                                    readDedup,
                                     argumentErrorHint: (name) => argumentErrorHint(name, runtimeContextState),
                                     ...(opts.toolPolicy
                                         ? {

package/dist/agent/spawn.js

@@ -10,6 +10,7 @@
 //  - 主屏渲染可选:TUI 激活时把子 agent 内部工具调用实时写入主内容区并复用 batch 折叠;
 //    TUI 未激活(host 嵌入 / 非 TTY)时纯静默,中间过程只缓冲进 transcript。
 //  - 独立 history 分支:子任务的工具噪声不回灌主对话,只有最终摘要回灌。
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { buildMocodeCorePrompt, isSubAgentHardDisabled } from '../config/index.js';
 import { getToolChatSchema } from '../tools/policy.js';
 import { effectiveSystemPrompt } from '../skills/index.js';
@@ -47,6 +48,11 @@ You are executing one delegated sub-task with the same engineering standards and
  * 中断:opts.signal 透传给子 runAgentCore——主 Ctrl+C 树杀子 agent(chat abort + 工具 abort)。
  * 子 agent 跑在主 signal 下,主 abort 即子 abort;子 agent 的 abortRestore 还原子 history + 模式。
  */
+/** 当前委派深度(P4 闸2):根 agent 无 store=0,每进一层 spawnAgent +1。 */
+const spawnDepthScope = new AsyncLocalStorage();
+function currentSpawnDepth() {
+    return spawnDepthScope.getStore() ?? 0;
+}
 export async function spawnAgent(opts) {
     const activeRuntime = opts.runtime ?? getActiveRuntime();
     const runtimeContext = opts.runtimeContext ?? activeRuntime?.context ?? getActiveAgentRuntimeContext() ?? defaultAgentRuntimeContext;
@@ -60,6 +66,20 @@ export async function spawnAgent(opts) {
             usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0, cachedTokens: 0, reasoningTokens: 0 },
         };
     }
+    // 深度闸:达上限直接结构化失败(模型看到后会改用直接工具完成)。执行层拦截,不裁 schema。
+    const depth = currentSpawnDepth() + 1;
+    if (depth > runtimeContext.config.subAgentMaxDepth) {
+        const msg = `Sub-agent depth limit ${runtimeContext.config.subAgentMaxDepth} reached ` +
+            '(nested delegation blocked to prevent fork-style recursion); complete the task directly with your own tools.';
+        return {
+            summary: msg,
+            completed: false,
+            transcript: msg,
+            status: 'failed',
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0, cachedTokens: 0, reasoningTokens: 0 },
+            changedFiles: [],
+        };
+    }
     const maxSteps = opts.maxSteps ?? runtimeContext.config.subAgentMaxSteps;
     const requested = opts.tools === undefined ? null : new Set(opts.tools);
     const shared = opts.delegation && opts.delegation.history.length > 0 && opts.delegation.history[0]?.role === 'system'
@@ -172,8 +192,8 @@ export async function spawnAgent(opts) {
         const childIndex = parentId ? batch.getGroupChildIndex(opts.callId) : undefined;
         liveBatchId = batch.beginBatch(t('subagent.running'), {
             parentId,
-            // 子批摘要行缩进 = 两层 entry 缩进(随 ENTRY_INDENT 联动,不硬编码空格数)。
-            indent: parentId ? batch.SUB_BATCH_INDENT : undefined,
+            // 缩进由 beginBatch 按父层级自动推导:组容器批下 = 两层 entry 缩进;
+            // 普通子 agent 批下再嵌套 = 父缩进 + 两层(树状逐层加深)。
             groupChildIndex: childIndex,
             running: true,
         });
@@ -205,6 +225,8 @@ export async function spawnAgent(opts) {
             layout.contentWrite('\n');
     };
     let lastChar = '';
+    // P4 闸3:只收集本 agent 树自己产生的改动(钩子按真实执行触发),不靠整轮全局快照。
+    const nestedChangedFiles = new Set();
     const hooks = {
         onText: (s) => {
             writeBuf(s); // 缓冲流式正文(无 markdown 渲染,原始文本)
@@ -225,7 +247,10 @@ export async function spawnAgent(opts) {
             ensureQuietLine(opts.quietLabel ?? t('skill.executing', { name: opts.prompt.slice(0, 40) }));
             ensureLiveBatch();
             if (liveBatchId) {
-                batch.recordCall(liveBatchId, tc.name, summary);
+                // 登记内部调用的 tool_call id:子 agent 嵌套派生时,孙 spawnAgent 据此反查到
+                // 本子批,把孙批挂到对应的内部 sub-agent entry 下(而非游离到 buffer 末尾)。
+                batch.bindCall(tc.id, liveBatchId);
+                batch.recordCall(liveBatchId, tc.name, summary, tc.id);
                 // 默认折叠,只刷新摘要行计数(glob/read_file 数量),不展开明细列表。
                 batch.showLiveBatch(liveBatchId, liveLayout());
             }
@@ -237,7 +262,7 @@ export async function spawnAgent(opts) {
             if (liveBatchId) {
                 // 子 agent 批不展示 diff(其写入已直接落工作区,由主 agent 的当前回滚事务统一追踪);
                 // 空 preview 用占位标记 entry 已完成,避免折叠后摘要仍显示"运行中"。
-                batch.recordResult(liveBatchId, tc.name, preview || t('toolSummary.noOutput'), null, output, isToolErrorOutput(output));
+                batch.recordResult(liveBatchId, tc.name, preview || t('toolSummary.noOutput'), null, output, isToolErrorOutput(output), tc.id);
                 batch.showLiveBatch(liveBatchId, liveLayout());
             }
         },
@@ -286,7 +311,7 @@ export async function spawnAgent(opts) {
     // 与主 agent 完全同源:写操作直接落在工作区,进入主 agent 当前轮次的同一回滚事务
     // (spawn 不调 beginTurn)。没有 overlay 拷贝/ChangeSet 合并这一步——那是旧 read/write
     // 双模式的产物,子 agent 不再受限,也就不需要"先隔离再合并"。
-    const result = await runtime.run({
+    const runResult = () => runtime.run({
         turn: 'inherit',
         history,
         userInput,
@@ -296,11 +321,18 @@ export async function spawnAgent(opts) {
         toolsOverride,
         runtimeAllowedToolNames,
         contextState: localContextState,
+        // P4 闸3:run-coordinator 只消费顶层 onToolOutcome(非 hooks),在此收集本树真实改动。
+        onToolOutcome: (_tool, _args, outcome) => {
+            for (const f of outcome.changedFiles ?? [])
+                nestedChangedFiles.add(f);
+        },
         suppressOpeningAnalysis: true, // 子代理不注入「开场分析」:仅主线面对用户的首次响应用
         // 子代理不注入主会话「会话状态」(plan + 笔记):那是主 agent 的工作面,委派消息已带齐
         // 子任务所需上下文,重复注入只白付 token。
         suppressSessionState: true,
     });
+    // 深度 scope:子 agent 内再派生子 agent 时 ALS 读到此 depth。
+    const result = await spawnDepthScope.run(depth, runResult);
     const status = opts.signal?.aborted || result.terminationReason === 'aborted'
         ? 'aborted'
         : result.completed
@@ -318,5 +350,6 @@ export async function spawnAgent(opts) {
             cachedTokens: result.usage?.cachedTokens ?? 0,
             reasoningTokens: result.usage?.reasoningTokens ?? 0,
         },
+        changedFiles: [...nestedChangedFiles],
     };
 }

package/dist/agent/stages/model-runner.js

@@ -7,7 +7,7 @@ class ChatModelRunner {
         this.transport = transport;
     }
     run(request, signal) {
-        return this.transport(request.history.slice(), request.handlers, signal, request.tools.slice());
+        return this.transport(request.history.slice(), request.handlers, signal, request.tools.slice(), request.reasoningEffort ? { reasoningEffort: request.reasoningEffort } : undefined);
     }
 }
 class LegacyChatModelRunner extends ChatModelRunner {

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 } : {}),
         });

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,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',
@@ -636,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)。
@@ -673,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/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,
     };
 }