mocode-ai 0.4.1 → 0.4.2

package/dist/agent/core.js

@@ -7,7 +7,7 @@
 import { readFileSync } from 'node:fs';
 import { chat, planChatTools, } from '../llm/index.js';
 import { executeTool } from '../tools/registry.js';
-import { PLAN_DISABLED_TOOLS } from '../tools/constants.js';
+import { getPlanDisabledTools } from '../tools/constants.js';
 import { getAgentMode, setAgentMode } from './mode.js';
 import { maybeCompact, contextState, dropContextFromHistory } from '../session/index.js';
 import { createBudgetScheduler } from '../session/scheduler.js';
@@ -125,6 +125,20 @@ export async function runAgentCore(opts) {
     // 本轮计时:从入口到完毕(正常 return / 达上限),供 finally 打 ✻ Worked for 摘要行。
     const t0 = Date.now();
     let done = false; // 正常完毕 / 达上限 true;中断 false(不显摘要)
+    // 本轮 token 累计:每步 chat() 返回后把 result.usage 累加,供 onDone 摘要行 + AgentRunResult.usage
+    // 透传给 repl(显示在底栏模式 chip 右边)。未开启 include_usage 或全失败时为 undefined。
+    let turnUsage;
+    const addUsage = (u) => {
+        if (!u)
+            return;
+        turnUsage = turnUsage
+            ? {
+                promptTokens: turnUsage.promptTokens + u.promptTokens,
+                completionTokens: turnUsage.completionTokens + u.completionTokens,
+                totalTokens: turnUsage.totalTokens + u.totalTokens,
+            }
+            : u;
+    };
     history.push({ role: 'user', content: userInput });
     // drop_context 工具的上下文剔除回调:闭包捕获 history,原地剔除无关旧 tool 结果。
     // 保护由 dropContextFromHistory 内部保证:history[0](system)+ 当前轮(最后 user 及其后)永不剔除。
@@ -210,6 +224,7 @@ export async function runAgentCore(opts) {
                 throw e;
             }
             contextState.lastUsage = result.usage; // 供 /context 与状态行显示实测 token
+            addUsage(result.usage); // 本轮累计:onDone 摘要行 + AgentRunResult.usage 透传
             hooks.onChatDone?.(); // 主 agent:spinner.stop()
             // lastUsage 已更新:触发状态行 context 用量条重算+重画,运行中不再冻结在轮首。
             onContextUpdate?.();
@@ -301,7 +316,7 @@ export async function runAgentCore(opts) {
                         const tc = calls[i];
                         // plan 模式防御 backstop:schema 已剔除这些工具,正常不会进这里;防后端幻觉调用——
                         // 不执行,直接返错回灌(让模型看到「plan 模式禁用」并停止),绝不写盘 / 跑命令。
-                        if (getAgentMode() === 'plan' && PLAN_DISABLED_TOOLS.has(tc.name)) {
+                        if (getAgentMode() === 'plan' && getPlanDisabledTools().has(tc.name)) {
                             hooks.onToolHeader?.(tc);
                             const err = `错误:计划模式下禁用工具 ${tc.name}(仅读探查,不改动文件 / 不跑命令)`;
                             hooks.onToolResult?.(tc, err, null, null, 1);
@@ -346,16 +361,16 @@ export async function runAgentCore(opts) {
                 hooks.onNoReply?.();
             history.push({ role: 'assistant', content: result.content });
             done = true;
-            return { completed: true, finalText: result.content };
+            return { completed: true, finalText: result.content, usage: turnUsage };
         }
         hooks.onMaxSteps?.();
         done = true;
-        return { completed: true, finalText: null };
+        return { completed: true, finalText: null, usage: turnUsage };
     }
     finally {
         // 跑完(正常 / 达上限)在回复末尾打耗时摘要行(仿 Claude Code);中断 done=false 不打。
         if (done) {
-            hooks.onDone?.(Date.now() - t0);
+            hooks.onDone?.(Date.now() - t0, turnUsage);
         }
     }
 }

package/dist/agent/index.js

@@ -110,15 +110,19 @@ onContextUpdate) {
                 layout.contentWrite('\n');
             layout.contentWrite(`${ui.dim}(已中断)${ui.reset}\n`);
         },
-        onDone: (elapsedMs) => layout.contentWrite(`  ${ui.dim}✻ Worked for ${fmtElapsed(elapsedMs)}${ui.reset}\n`),
+        onDone: (elapsedMs, usage) => {
+            const tok = formatTurnTokens(usage);
+            layout.contentWrite(`  ${ui.dim}✻ Worked for ${fmtElapsed(elapsedMs)}${tok}${ui.reset}\n`);
+        },
     };
     // 桌宠状态广播:与 TUI hooks 并列注入,互不干扰(petHooks 只调 bridge.sendState,不写屏;
     // 未 /pet 连接时 sendState 内部 no-op)。仅主 agent 走这里——子 agent(spawn.ts)不引用 createPetHooks,
     // 故子 agent 永不广播桌宠状态。
     const petHooks = createPetHooks();
     const combinedHooks = mergeHooks(hooks, petHooks);
+    let result;
     try {
-        await runAgentCore({
+        result = await runAgentCore({
             history,
             userInput,
             signal,
@@ -129,6 +133,7 @@ onContextUpdate) {
     finally {
         spinner.stop();
     }
+    return result;
 }
 /** 把两组 AgentHooks 合并为一组:每个方法依次调用两侧已定义的实现(顺序不保证跨方法一致,
  *  但同一事件内先 a 后 b)。用于把桌宠状态广播 hooks 与 TUI 渲染 hooks 并列挂载,互不影响。 */
@@ -145,3 +150,14 @@ function mergeHooks(a, b) {
     }
     return merged;
 }
+/** 摘要行后追加的本轮 token 文本。例:`  · 1.5k tokens (↑ 1.2k ↓ 0.3k)`。
+ *  关闭 include_usage / 全失败 → usage=undefined → 不输出(保持原摘要行长度,不留空白)。 */
+function formatTurnTokens(usage) {
+    if (!usage)
+        return '';
+    const total = usage.totalTokens;
+    if (!total)
+        return '';
+    const fmt = (n) => (n < 1000 ? `${n}` : `${(n / 1000).toFixed(total >= 10000 ? 0 : 1)}k`);
+    return `  ·  ${fmt(total)} tokens (↑ ${fmt(usage.promptTokens)} ↓ ${fmt(usage.completionTokens)})`;
+}

package/dist/agent/spawn.js

@@ -15,19 +15,19 @@
 //  - 逻辑隔离(回滚):skipRollback=true,子 agent 的 write_file/edit_file 改动不进主回滚快照链,
 //    主 /rollback 不撤销子 agent 改动(靠 git 兜底)。子 agent 与主 agent 共享 cwd(文件改动可见)。
 import { chatTools } from '../llm/index.js';
-import { config } from '../config/index.js';
+import { config, isMemoryEnabled } from '../config/index.js';
 import { effectiveSystemPrompt } from '../skills/index.js';
 import { buildMemorySection, buildMemoryIndexSection } from '../memory/index.js';
 import { ui } from '../ui/theme.js';
 import { runAgentCore } from './core.js';
 import { summarizeToolCall, summarizeToolResult, truncateDisplay } from '../ui/render.js';
 /** 子 agent 系统提示后缀:角色与约束。 */
-const SUBAGENT_SUFFIX = `
-
-## ⛯ SUB-AGENT MODE (you are a sub-agent)
-You are a sub-agent spawned by the main agent to handle an isolated sub-task. You have your own conversation history (independent of the main thread).
-- Focus solely on the assigned sub-task. Do NOT attempt to call the "task" tool (no recursive spawning).
-- Use the tools available to you to complete the sub-task.
+const SUBAGENT_SUFFIX = `
+
+## ⛯ SUB-AGENT MODE (you are a sub-agent)
+You are a sub-agent spawned by the main agent to handle an isolated sub-task. You have your own conversation history (independent of the main thread).
+- Focus solely on the assigned sub-task. Do NOT attempt to call the "task" tool (no recursive spawning).
+- Use the tools available to you to complete the sub-task.
 - When done, your final text reply will be returned to the main agent as a summary — make it concise and actionable: what you did, key findings, files changed, and any issues. The main agent will decide the next step based on your summary.`;
 /**
  * 派生一个子 agent 执行独立子任务。
@@ -44,9 +44,13 @@ You are a sub-agent spawned by the main agent to handle an isolated sub-task. Yo
 export async function spawnAgent(opts) {
     const maxSteps = opts.maxSteps ?? config.subAgentMaxSteps ?? 50;
     // 构造子 agent 系统提示:复用主 agent 组装链 + 子 agent 角色后缀 + 自定义后缀。
+    // config.systemPrompt 是 getter(每次访问现拼 buildBasePrompt,反映 isMemoryEnabled),
+    // 所以这里直接读 config.systemPrompt 即可;buildMemoryIndexSection 显式按 isMemoryEnabled() 传参,
+    // 关闭时该段不进。注意:不能从 spawn.ts 直接 import buildBasePrompt —— 这会
+    // 拉起 config → llm → registry → builtins → task → spawn 形成循环求值死锁。
     const systemPrompt = effectiveSystemPrompt(config.systemPrompt +
         buildMemorySection() +
-        buildMemoryIndexSection() +
+        buildMemoryIndexSection(isMemoryEnabled()) +
         SUBAGENT_SUFFIX +
         (opts.systemPromptSuffix ? `\n\n${opts.systemPromptSuffix}` : ''));
     // 工具子集:白名单过滤。无白名单 = 全量 chatTools,但始终剔除 task(防递归派生)。
@@ -102,7 +106,12 @@ export async function spawnAgent(opts) {
         onToolBatchEnd: () => writeBuf('\n'),
         onNoReply: () => writeBuf(`${ui.dim}(无回复)${ui.reset}\n`),
         onMaxSteps: () => writeBuf(`  ● 达到最大步数(${maxSteps}),子 agent 停止。\n`),
-        onDone: (elapsedMs) => writeBuf(`  ✻ 子 agent 耗时 ${(elapsedMs / 1000).toFixed(1)}s\n`),
+        onDone: (elapsedMs, usage) => {
+            const tok = usage && usage.totalTokens
+                ? `  · ${usage.totalTokens} tokens`
+                : '';
+            writeBuf(`  ✻ 子 agent 耗时 ${(elapsedMs / 1000).toFixed(1)}s${tok}\n`);
+        },
         // onStepStart / onChatDone / onToolStart / onToolDone / onAbort:子 agent 静默,无需 spinner / 中断渲染。
         // abort 还原(history 还原 + 模式还原)由 core 的 abortRestore 处理,hooks 只管展示。
     };

package/dist/config/index.js

@@ -71,7 +71,58 @@ const PLATFORM_NOTE = (() => {
 - You are on ${process.platform}; run_command runs via bash -c. GNU coreutils — standard POSIX/GNU shell syntax is safe.
 - Still prefer the dedicated tools (read_file/glob/grep) over hand-rolled shell where they fit — they avoid quoting pitfalls and are already wired in.`;
 })();
-const SYSTEM_PROMPT = `You are mocode, a terminal coding agent. You complete programming tasks through a "think → call tool → observe result → think again" loop until the problem is solved. Reply to the user in Chinese.
+/**
+ * 基础系统提示的"记忆段落":开 isMemoryEnabled() 时才拼。
+ * 默认关(新用户零侵入):这段 + 工具表里的 5 个 memory_* + 系统提示尾部的 Memory Index
+ * 都不出现;打开 /memory_switch 后下一次新建 system message 才注入。
+ */
+const SYSTEM_PROMPT_MEMORY_SECTION = `
+## Memory (cross-session long-term facts)
+- A "memory index" (id/title/summary only) is injected into the system prompt. Retrieve full body via memory_search (pass id or keyword); use memory_list to see the entire index.
+- Store non-obvious, cross-session-useful facts/decisions/pitfalls (architecture conventions, gotchas, user preferences, decisions made) with memory_save — only long-term stable items, not current bugs / temp files / undecided TODOs.
+- If an existing memory is outdated or contradicts new facts, correct it in-place with memory_update(id, …) (don't create a duplicate); archive clearly-stale ones with memory_forget(id).
+- Before saving, memory_search to check for an existing similar entry to avoid duplicates. Better to store less than to store trivially correct information.
+- A background reflection pass periodically mines and organizes memories from the session (no manual action needed), but key facts you proactively save are more reliable.`;
+/**
+ * plan 模式追加到系统提示末尾的指令(切到 plan 模式时由 repl 拼进 history[0])。
+ * 与 SYSTEM_PROMPT 同语种(英文),指示:只读探查、产出步骤化计划、不执行、审批后回 auto。
+ *
+ * memoryEnabled=false 时:memory_save/update/forget 三个写工具名字 + "memory-write tools" 这
+ * 句都不出现,且 read-only 列表里的 memory_search/memory_list 也移除——避免提示词里出现
+ * 根本不存在的工具名引起 LLM 调不到。
+ */
+function buildPlanModeSuffix() {
+    if (!isMemoryEnabled()) {
+        return `
+
+## ⛯ PLAN MODE (active now)
+You are in PLAN mode: investigate and design only — do NOT execute or change anything.
+- Your editing / command tools (write_file, edit_file, run_command) have been REMOVED from your tool list. Use only the read-only tools available to you (read_file, glob, grep, codegraph, web_search, web_fetch, use_skill, ask_human) to investigate.
+- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. Your FIRST action for code exploration should be the codegraph tool (explore/node) when a .codegraph/ index exists — not read_file/grep. Use read_file/grep only to fill gaps codegraph leaves.
+- Then produce a clear, actionable implementation plan: files to change (with paths), what to change in each and why, the ordered steps, edge cases to handle, and how to verify (typecheck / tests / build). Be specific enough to execute against.
+- Present the plan as your final reply and STOP, unless the user explicitly asked you to "plan first then execute" / "先 plan 再 auto" / autonomous execution: in that case, after presenting the plan, call the switch_mode tool with mode="auto" to switch back to auto mode WITHIN THE SAME TURN and continue implementing the plan yourself (your write/edit/command tools become available again immediately). The user will see no approval prompt because you self-switched.
+- If the user entered plan mode manually (via /plan or Shift+Tab) for a safety review and did NOT ask for autonomous execution, do NOT call switch_mode — present the plan and STOP. Do NOT ask the user for confirmation or approval in your text reply (e.g. "is this plan OK?", "shall I proceed?", "需要你确认") — the REPL automatically shows an approval prompt after you STOP, so asking in text is redundant and forces the user to answer twice. Just present the plan and end your reply.`;
+    }
+    return `
+
+## ⛯ PLAN MODE (active now)
+You are in PLAN mode: investigate and design only — do NOT execute or change anything.
+- Your editing / command / memory-write tools (write_file, edit_file, run_command, memory_save, memory_update, memory_forget) have been REMOVED from your tool list. Use only the read-only tools available to you (read_file, glob, grep, codegraph, web_search, web_fetch, use_skill, ask_human, memory_search, memory_list) to investigate.
+- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. Your FIRST action for code exploration should be the codegraph tool (explore/node) when a .codegraph/ index exists — not read_file/grep. Use read_file/grep only to fill gaps codegraph leaves.
+- Then produce a clear, actionable implementation plan: files to change (with paths), what to change in each and why, the ordered steps, edge cases to handle, and how to verify (typecheck / tests / build). Be specific enough to execute against.
+- Present the plan as your final reply and STOP, unless the user explicitly asked you to "plan first then execute" / "先 plan 再 auto" / autonomous execution: in that case, after presenting the plan, call the switch_mode tool with mode="auto" to switch back to auto mode WITHIN THE SAME TURN and continue implementing the plan yourself (your write/edit/command/memory-write tools become available again immediately). The user will see no approval prompt because you self-switched.
+- If the user entered plan mode manually (via /plan or Shift+Tab) for a safety review and did NOT ask for autonomous execution, do NOT call switch_mode — present the plan and STOP. Do NOT ask the user for confirmation or approval in your text reply (e.g. "is this plan OK?", "shall I proceed?", "需要你确认") — the REPL automatically shows an approval prompt after you STOP, so asking in text is redundant and forces the user to answer twice. Just present the plan and end your reply.`;
+}
+/** 兼容旧名字:repl 的 buildSystemMessage 仍引 PLAN_MODE_SUFFIX(变量)。运行时按需现拼。 */
+export function buildBasePrompt() {
+    const autoAllToolsLine = isMemoryEnabled()
+        ? '- Default is AUTO mode: you research and execute with all tools (read/edit/run_command/memory/web/skills).'
+        : '- Default is AUTO mode: you research and execute with all tools (read/edit/run_command/web/skills).';
+    const memorySection = isMemoryEnabled() ? SYSTEM_PROMPT_MEMORY_SECTION : '';
+    const planLine = isMemoryEnabled()
+        ? '- For complex or multi-step tasks, the user may switch to PLAN mode (Shift+Tab): your editing/command/memory-write tools are then removed from your tool list, and you must research with read-only tools only and produce a step-by-step plan (no execution). On approval the session returns to auto mode to execute the plan.'
+        : '- For complex or multi-step tasks, the user may switch to PLAN mode (Shift+Tab): your editing/command tools are then removed from your tool list, and you must research with read-only tools only and produce a step-by-step plan (no execution). On approval the session returns to auto mode to execute the plan.';
+    return `You are mocode, a terminal coding agent. You complete programming tasks through a "think → call tool → observe result → think again" loop until the problem is solved. Reply to the user in Chinese.
 
 ${PLATFORM_NOTE}
 
@@ -116,16 +167,9 @@ ${PLATFORM_NOTE}
 - Confirm with the user before irreversible or outward-facing operations (delete, overwrite existing files, push, request external services), unless explicitly authorized.
 - Operate only within authorized scope; when unsure, ask — don't guess.
 
-## Memory (cross-session long-term facts)
-- A "memory index" (id/title/summary only) is injected into the system prompt. Retrieve full body via memory_search (pass id or keyword); use memory_list to see the entire index.
-- Store non-obvious, cross-session-useful facts/decisions/pitfalls (architecture conventions, gotchas, user preferences, decisions made) with memory_save — only long-term stable items, not current bugs / temp files / undecided TODOs.
-- If an existing memory is outdated or contradicts new facts, correct it in-place with memory_update(id, …) (don't create a duplicate); archive clearly-stale ones with memory_forget(id).
-- Before saving, memory_search to check for an existing similar entry to avoid duplicates. Better to store less than to store trivially correct information.
-- A background reflection pass periodically mines and organizes memories from the session (no manual action needed), but key facts you proactively save are more reliable.
-
-## Plan vs Auto modes
-- Default is AUTO mode: you research and execute with all tools (read/edit/run_command/memory/web/skills).
-- For complex or multi-step tasks, the user may switch to PLAN mode (Shift+Tab): your editing/command/memory-write tools are then removed from your tool list, and you must research with read-only tools only and produce a step-by-step plan (no execution). On approval the session returns to auto mode to execute the plan.
+${memorySection}
+${autoAllToolsLine}
+${planLine}
 
 ## Working notepad (todolist) — checklist for complex tasks
 - For **complex multi-step tasks** (≥3 file changes OR ≥5 tool calls expected OR user says "先计划再执行" / "plan then do" / "按步骤来"), call the \`todolist\` tool FIRST to write a plan to \`.mocode/plans/<id>.md\`, then execute step by step, calling \`todolist update\` to mark progress. For trivial single-step tasks, skip it and just execute.
@@ -137,25 +181,30 @@ ${PLATFORM_NOTE}
 ## Termination & Reporting
 - Stop immediately when no more tools are needed; give conclusions directly.
 - 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.`;
+}
 /**
- * plan 模式追加到系统提示末尾的指令(切到 plan 模式时由 repl 拼进 history[0])。
- * 与 SYSTEM_PROMPT 同语种(英文),指示:只读探查、产出步骤化计划、不执行、审批后回 auto。
+ * plan 模式追加到系统提示末尾的指令。
+ * 历史曾是 `export const PLAN_MODE_SUFFIX`(顶层字面量);现改为按 isMemoryEnabled()
+ * 动态拼:false 时不出现 memory_* 工具名,避免 LLM 想调不存在的工具。
+ *
+ * 注意:已改为 getter(每次访问现拼),让运行时切 /memory_switch 后立即生效。
+ * 旧 import `PLAN_MODE_SUFFIX` 路径不变;repl 推荐改用 getPlanModeSuffix()(语义更清晰)。
+ * 不能直接 `export const PLAN_MODE_SUFFIX = buildPlanModeSuffix()`:
+ * 该表达式在模块初始化时立即求值,而 buildPlanModeSuffix 内部读 config,config 还未求值 → TDZ。
  */
-export const PLAN_MODE_SUFFIX = `
-
-## ⛯ PLAN MODE (active now)
-You are in PLAN mode: investigate and design only — do NOT execute or change anything.
-- Your editing / command / memory-write tools (write_file, edit_file, run_command, memory_save, memory_update, memory_forget) have been REMOVED from your tool list. Use only the read-only tools available to you (read_file, glob, grep, codegraph, web_search, web_fetch, use_skill, ask_human, memory_search, memory_list) to investigate.
-- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. Your FIRST action for code exploration should be the codegraph tool (explore/node) when a .codegraph/ index exists — not read_file/grep. Use read_file/grep only to fill gaps codegraph leaves.
-- Then produce a clear, actionable implementation plan: files to change (with paths), what to change in each and why, the ordered steps, edge cases to handle, and how to verify (typecheck / tests / build). Be specific enough to execute against.
-- Present the plan as your final reply and STOP, unless the user explicitly asked you to "plan first then execute" / "先 plan 再 auto" / autonomous execution: in that case, after presenting the plan, call the switch_mode tool with mode="auto" to switch back to auto mode WITHIN THE SAME TURN and continue implementing the plan yourself (your write/edit/command/memory-write tools become available again immediately). The user will see no approval prompt because you self-switched.
-- If the user entered plan mode manually (via /plan or Shift+Tab) for a safety review and did NOT ask for autonomous execution, do NOT call switch_mode — present the plan and STOP. Do NOT ask the user for confirmation or approval in your text reply (e.g. "is this plan OK?", "shall I proceed?", "需要你确认") — the REPL automatically shows an approval prompt after you STOP, so asking in text is redundant and forces the user to answer twice. Just present the plan and end your reply.`;
+export function getPlanModeSuffix() {
+    return buildPlanModeSuffix();
+}
 export const config = {
     baseURL: requireEnv('LLM_BASE_URL'),
     apiKey: requireEnv('LLM_API_KEY'),
     model: process.env.LLM_MODEL || 'gpt-4o-mini',
     maxTokens: process.env.MAX_TOKENS ? Number(process.env.MAX_TOKENS) : undefined,
-    systemPrompt: SYSTEM_PROMPT,
+    // 用 getter 而非 buildBasePrompt() 立即求值:因为本对象字面量求值时 buildBasePrompt 读 config.memoryEnabled,
+    // 而 config 还没完成初始化(TDZ)。Getter 让每次访问都现拼,运行时 /memory_switch 立即生效。
+    get systemPrompt() {
+        return buildBasePrompt();
+    },
     contextWindowTokens: Number(process.env.CONTEXT_WINDOW_TOKENS) || 128000,
     compactThreshold: Number(process.env.COMPACT_THRESHOLD) || 0.85,
     includeUsage: process.env.LLM_STREAM_USAGE !== 'false',
@@ -165,6 +214,7 @@ export const config = {
     contextLifecycle: process.env.MOCODE_LIFECYCLE !== 'false',
     contextBudget: process.env.MOCODE_BUDGET_SCHEDULER !== 'false',
     autoReflect: process.env.AUTO_REFLECT !== 'false',
+    memoryEnabled: process.env.MEMORY_ENABLED === 'true',
     reflectEveryN: Number(process.env.REFLECT_EVERY_N) || 5,
     maxSteps: Number(process.env.MAX_STEPS) || 200,
     subAgentMaxSteps: Number(process.env.SUB_AGENT_MAX_STEPS) || 50,
@@ -205,3 +255,26 @@ export function updateModelConfig(opts) {
         process.env.CONTEXT_WINDOW_TOKENS = String(opts.contextWindowTokens);
     }
 }
+/**
+ * 记忆子系统总开关:单一来源。/memory_switch、/memory_status、buildSystemPrompt、
+ * tools/builtins/index.ts、tools/constants.ts 的 plan-mode 列表都从这里查。
+ * 默认 false(新用户零侵入)。
+ */
+export function isMemoryEnabled() {
+    return config.memoryEnabled;
+}
+/**
+ * 切换记忆子系统开关(/memory_switch on|off 调)。
+ * - 更新 config 单例字段(其它模块下次调 isMemoryEnabled() 即拿新值)。
+ * - 同步 process.env.MEMORY_ENABLED(下次启动 loadEnvFiles 不被文件回填)。
+ * 持久化(写 ~/.mocode/config 的 MEMORY_ENABLED 键)由调用方走 writeConfigKeys。
+ *
+ * 注:开关切换对当前会话的 tool list / 已拼好的 systemPrompt 不会自动重算 —
+ * 工具表在 REPL 启动时构建,systemPrompt 在每轮 chat() 拼时按 isMemoryEnabled()
+ * 现查现拼(关掉时该轮拼出来的 prompt 即不带 memory_* 段)。所以切换在「下一轮
+ * agent 调用」起即时生效,本轮已发出的请求不会回滚。
+ */
+export function updateMemoryConfig(enabled) {
+    config.memoryEnabled = enabled;
+    process.env.MEMORY_ENABLED = enabled ? 'true' : 'false';
+}

package/dist/llm/index.js

@@ -1,7 +1,7 @@
 import OpenAI from 'openai';
 import { config } from '../config/index.js';
 import { tools } from '../tools/registry.js';
-import { PLAN_DISABLED_TOOLS } from '../tools/constants.js';
+import { getPlanDisabledTools } from '../tools/constants.js';
 /**
  * LLM 调用重试策略:
  *   可重试  →  429 (rate limit) / 5xx (server) / APIConnectionError / Node 网络错 (ETIMEDOUT 等)
@@ -155,10 +155,13 @@ export const chatTools = tools.map((t) => ({
     },
 }));
 /**
- * plan 模式用的受限工具 schema:剔除写盘 / 命令 / 记忆写入类(PLAN_DISABLED_TOOLS),
+ * plan 模式用的受限工具 schema:剔除写盘 / 命令 / 记忆写入类(getPlanDisabledTools())。
  * 模型在 plan 模式下只看得到只读工具 → 调不到会改文件的工具。runAgent 在 plan 模式传给 chat()。
+ *
+ * 注意:planChatTools 是顶层 const(模块初始化时一次性求值);若运行时 /memory_switch 关闭
+ * 记忆,这里仍是按当前 isMemoryEnabled() 算出的快照——重启 REPL 才完全生效。
  */
-export const planChatTools = chatTools.filter((t) => !PLAN_DISABLED_TOOLS.has(t.function.name));
+export const planChatTools = chatTools.filter((t) => !getPlanDisabledTools().has(t.function.name));
 /**
  * 流式调一次 LLM:增量回调文本,内部累加 tool_calls 片段。
  * tool_calls 跨 chunk 按 index 累加(id / name / arguments 拼接)。

package/dist/memory/index.js

@@ -2,6 +2,7 @@
 // Tier-2:store.ts(叶子,node:fs)做 JSONL CRUD/GC/索引段;reflect.ts(→llm,同 session/)做后台反思 pass。
 // 被 repl 依赖(注入 systemPrompt + 轮末触发反思 + 退出 drain)。Tier-1 仅依赖 discover.ts。
 import { loadMemoryFiles } from './discover.js';
+import { isMemoryEnabled } from '../config/index.js';
 export { buildMemoryIndexSection, loadAll, gcMemories, } from './store.js';
 export { kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, runReflection, } from './reflect.js';
 /** system 消息中 memory 段的字符上限(防过大占窗口——system 在 history[0],compactHistory 不压缩)。 */
@@ -30,8 +31,14 @@ export function loadMemory() {
     }
     return cache;
 }
-/** 拼进系统提示的 memory 段;无 memory 返空串(零行为变化)。 */
+/**
+ * 拼进系统提示的 memory 段(Tier-1 MOCODE.md);无 memory 返空串(零行为变化)。
+ * 记忆子系统总开关关闭(isMemoryEnabled()==false)直接返空串:
+ * 提示词、Memory Index 段都不进 — 配合 tools/builtins 把 memory_* 工具屏蔽。
+ */
 export function buildMemorySection() {
+    if (!isMemoryEnabled())
+        return '';
     const mem = loadMemory();
     if (!mem)
         return '';

package/dist/memory/store.js

@@ -315,8 +315,15 @@ export function gcMemories() {
 /**
  * active 条目按 updatedAt 降序,封顶 MAX_INDEX_ENTRIES,只注 id/name/summary/type。
  * 无 active 返空串(零行为变化)。body 不注入——按需 memory_search 取。
+ *
+ * memoryEnabled=false 时(记忆子系统总开关关闭)直接返空串:Memory Index 段
+ * 不进系统提示,LLM 看不到工具使用提示;配合 tools/builtins 屏蔽 memory_* 工具,
+ * 实现「关闭时零侵入」(默认行为)。传参由 repl 的 buildSystemMessage 在拼装前调
+ * isMemoryEnabled() 注入(本文件是叶子,避免直接引 config 起环)。
  */
-export function buildMemoryIndexSection() {
+export function buildMemoryIndexSection(memoryEnabled = true) {
+    if (!memoryEnabled)
+        return '';
     const active = loadAll()
         .filter((e) => e.status === 'active')
         .sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));

package/dist/repl/index.js

@@ -1,7 +1,7 @@
 import readline from 'node:readline/promises';
 import { emitKeypressEvents } from 'node:readline';
 import { stdin, stdout } from 'node:process';
-import { config, PLAN_MODE_SUFFIX, updateModelConfig, isModelConfigured } from '../config/index.js';
+import { config, updateModelConfig, isModelConfigured, updateMemoryConfig, isMemoryEnabled, buildBasePrompt, getPlanModeSuffix, } from '../config/index.js';
 import { updateConfigKey, writeConfigKeys, CONFIG_PATH } from '../config/file.js';
 import { runAgent } from '../agent/index.js';
 import { getAgentMode, setAgentMode, onModeChange } from '../agent/mode.js';
@@ -35,9 +35,11 @@ const SLASH_COMMANDS = [
     { name: '/compact', desc: '压缩历史(可带焦点 /compact …)' },
     { name: '/resume', desc: '续接已保存的会话' },
     { name: '/rollback', desc: '菜单选轮次回滚(↑↓·Enter)' },
-    { name: '/memory', desc: '记忆库:条目计数与近期索引' },
-    { name: '/reflect', desc: '手动触发后台记忆反思 pass' },
-    { name: '/init', desc: '扫描项目生成 MOCODE.md 项目记忆' },
+    { name: '/memory', desc: '记忆库:条目计数与近期索引(关闭时提示先开 /memory_switch)' },
+    { name: '/memory_switch', desc: '切换记忆子系统开关(无参=切换;/on 或 /off 显式;持久化 MEMORY_ENABLED)' },
+    { name: '/memory_status', desc: '查看记忆子系统当前开关与原理' },
+    { name: '/reflect', desc: '手动触发后台记忆反思 pass(需先开启记忆)' },
+    { name: '/init', desc: '扫描项目生成 MOCODE.md 项目记忆(需先开启记忆)' },
     { name: '/theme', desc: '切换颜色主题(↑↓·Enter)' },
     { name: '/model', desc: '配置大模型(baseURL/key/model/窗口)' },
     { name: '/plan', desc: '切到 plan 模式(只读探查+产出计划)' },
@@ -141,14 +143,15 @@ function renderContextBarInline(history) {
     const pctCol = pct >= config.compactThreshold ? ui.yellow : ui.cyan;
     return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${pctCol}${Math.round(pct * 100)}%${ui.reset} ${ui.dim}${k(est)}/${k(win)}${ui.reset}`;
 }
-/** 状态行基线:模型 / context / cwd / 模式标识 / 活跃 plan chip。repl 在轮次边界、切模式、plan 变更时调。 */
-function refreshStatusBase(history) {
+/** 状态行基线:模型 / context / cwd / 模式标识 / 活跃 plan chip / 本轮 token。repl 在轮次边界、切模式、plan 变更时调。 */
+function refreshStatusBase(history, lastTurnUsage) {
     layout.setStatusBase({
         model: config.model,
         contextBar: renderContextBarInline(history),
         cwd: process.cwd(),
         modeTag: getAgentMode() === 'plan' ? 'plan' : 'auto',
         planSummary: hasActivePlan() ? getActivePlanSummary(process.stdout.columns ?? 80) : '',
+        lastTurnUsage,
     });
 }
 /** 命令 → 运行态状态文字 + 底栏 dim 占位。 */
@@ -174,6 +177,10 @@ function runningStateFor(cmd) {
             return { status: '配模型', placeholder: '配置中…' };
         case '/pet':
             return { status: '桌宠', placeholder: '处理中…' };
+        case '/memory_switch':
+            return { status: '切记忆开关', placeholder: '切换中…' };
+        case '/memory_status':
+            return { status: '查记忆状态', placeholder: '…' };
         default:
             // 输入框留空(运行中可 typeahead 打字,dim 回显);运行状态由内联 spinner 承载(思考中/执行…),
             // 状态行只显走时——故常态 status 留空,不塞「处理」这种与内联重复的泛标签。
@@ -408,13 +415,17 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
     // 沙箱根:文件操作边界。优先级 --sandbox-root > SANDBOX_ROOT env > process.cwd()。
     // 纯边界记录(不 chdir),jail.ts 内部 resolve。子 agent 同进程继承全局 root。
     setSandboxRoot(sandboxRootOverride ?? config.sandboxRoot ?? process.cwd());
-    // 构造系统提示:auto 用 base;plan 在 config.systemPrompt 后追加 PLAN_MODE_SUFFIX。
+    // 构造系统提示:auto 用 base;plan 在 base 后追加按当前开关现拼的 plan suffix。
     // 切模式时 applyMode 重算 history[0](history[0] 恒 system,compaction 保它,不破坏)。
     // 活跃 plan 摘要拼在 memory 段后(systemPrompt 的尾段),todo 工具变更后 listener 重写 history[0]。
-    const buildSystemMessage = (planMode) => effectiveSystemPrompt(config.systemPrompt +
-        (planMode ? PLAN_MODE_SUFFIX : '') +
+    //
+    // 与开关联动:① base 用 buildBasePrompt() 取代 config.systemPrompt(后者是启动时一次性
+    // 求值的常量,运行时 /memory_switch 不会刷新);② plan suffix 走 getPlanModeSuffix() 现拼;
+    // ③ buildMemorySection 内已自决 ;④ buildMemoryIndexSection 显式传 isMemoryEnabled() 关闭段。
+    const buildSystemMessage = (planMode) => effectiveSystemPrompt(buildBasePrompt() +
+        (planMode ? getPlanModeSuffix() : '') +
         buildMemorySection() +
-        buildMemoryIndexSection() +
+        buildMemoryIndexSection(isMemoryEnabled()) +
         buildActivePlanSection());
     // 有预加载(--resume)则用它,并把 history[0] 刷成当前 system prompt(config 可能已变);
     // 否则新会话只塞 system 提示(默认 auto)。
@@ -434,6 +445,9 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
     let currentSessionId = sessionId;
     // 反思 cadence 计数:每 reflectEveryN 轮 fire-and-forget 一次后台反思 pass。
     let turnCount = 0;
+    // 本轮 token 累计:runAgent 返回后写入,供底栏模式 chip 右边显示。undefined=无实测
+    // (后端不开 include_usage / 后端失败时)。
+    let lastTurnUsage;
     const toolsLine = tools.map((t) => t.name).join(' · ');
     const banner = () => ({
         model: config.model,
@@ -598,10 +612,14 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             setAgentMode(planMode ? 'plan' : 'auto');
             // 运行中每步 chat() 返回后刷新状态行 context 用量条(用 fresh lastUsage / 估算),
             // 否则整轮冻结在轮首 refreshStatusBase 的值,「执行 grep」时 2k/1000k 不动。
-            await runAgent(history, userInput, signal, () => {
+            const result = await runAgent(history, userInput, signal, () => {
                 refreshStatusBase(history);
                 layout.drawStatusBar();
             });
+            // 本轮 token 累计(底栏模式 chip 右边显示)。undefined = 后端不开 include_usage。
+            lastTurnUsage = result.usage;
+            refreshStatusBase(history, lastTurnUsage); // 即时刷状态行显示本轮 token chip
+            layout.drawStatusBar();
             ok = !signal.aborted; // 中断(Ctrl+C)→ runAgent 已还原 history,ok=false 不弹审批
             // 成功轮次自动落盘(崩溃也保住上一轮);新会话首轮分配 id
             if (!currentSessionId)
@@ -770,6 +788,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             currentSessionId = undefined; // 下轮起新会话文件
             turnCount = 0; // 反思 cadence 重新计数
             contextState.lastUsage = undefined;
+            lastTurnUsage = undefined; // 清空旧轮的 token 累计
             pendingAttachments = []; // 一并清空待发图片
             layout.clearContent();
             layout.contentWrite(bannerString(banner()));
@@ -971,6 +990,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             if (!loadSnapshots(loaded.id))
                 rebuildFromHistory(history);
             contextState.lastUsage = undefined;
+            lastTurnUsage = undefined; // /resume:旧会话的 token 累计已无意义,清空等下轮覆写
             layout.clearContent();
             renderHistory(history);
             layout.contentWrite(`${ui.dim}(已续接会话 ${loaded.id})${ui.reset}\n`);
@@ -1206,6 +1226,78 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             await rollbackFlow();
             continue;
         }
+        if (line === '/memory_switch' ||
+            line.startsWith('/memory_switch ') ||
+            line === '/memory_status' ||
+            line.startsWith('/memory_status ')) {
+            // /memory_switch — 记忆子系统总开关。无参切换 on/off;/memory_switch on 或 /off 显式;
+            // /memory_switch true|false|1|0|yes|no 等同义。/memory_status 只读查询(不写盘)。
+            //
+            // 设计原则:
+            //  - 单一来源 isMemoryEnabled():工具表(builtins)、系统提示词(Memory Index 段 + 工具使用说明)、
+            //    plan-mode 提示(tools/constants.ts)三处都从这里查。
+            //  - 当前会话的 tool list 是模块初始化时的快照(/memory_switch 不重算 builtinTools)——已发出
+            //    请求的工具列表不会被回滚。要"完全生效"需要重启 REPL。但 buildSystemMessage 每次 chat 现拼,
+            //    所以系统提示词和 plan suffix 会在「下一轮 chat」即时反映新值。
+            //  - 持久化字段 MEMORY_ENABLED,默认值 false(新用户零侵入)。
+            try {
+                if (line === '/memory_status' || line.startsWith('/memory_status ')) {
+                    const on = isMemoryEnabled();
+                    layout.contentWrite(`${ui.cyan}记忆子系统:${ui.reset} ${on ? `${ui.green}开启` : `${ui.yellow}关闭`}${ui.reset}\n`);
+                    layout.contentWrite(`${ui.dim}  单一来源 isMemoryEnabled()(${config.memoryEnabled});` +
+                        `持久化 ${ui.cyan}MEMORY_ENABLED${ui.dim};` +
+                        `配置文件 ${CONFIG_PATH}${ui.reset}\n`);
+                    layout.contentWrite(`${ui.dim}  关闭时:memory_*_save/_search/_list/_update/_forget 五个工具整体不进工具表;` +
+                        `buildBasePrompt() 不含「## Memory」段;` +
+                        `plan-mode 提示词里也不出现 memory_* 工具名。${ui.reset}\n`);
+                    layout.contentWrite(`${ui.dim}  切换后下次新建 system message 即时反映;当前会话工具表需重启 REPL 才完整重算。${ui.reset}\n`);
+                    continue;
+                }
+                // /memory_switch(无参=on/off 切换;有参=按值设)
+                const arg = line.startsWith('/memory_switch ')
+                    ? line.slice('/memory_switch '.length).trim().toLowerCase()
+                    : '';
+                let nextEnabled;
+                if (arg === '') {
+                    nextEnabled = !isMemoryEnabled();
+                }
+                else if (['on', 'true', '1', 'yes', 'y', 'enable', 'enabled'].includes(arg)) {
+                    nextEnabled = true;
+                }
+                else if (['off', 'false', '0', 'no', 'n', 'disable', 'disabled'].includes(arg)) {
+                    nextEnabled = false;
+                }
+                else {
+                    layout.contentWrite(`${ui.yellow}/memory_switch 用法:${ui.reset}\n` +
+                        `  /memory_switch             切换(开↔关)\n` +
+                        `  /memory_switch on|off      显式设值\n` +
+                        `  /memory_switch status      等同 /memory_status\n`);
+                    continue;
+                }
+                const prev = isMemoryEnabled();
+                if (nextEnabled === prev) {
+                    layout.contentWrite(`${ui.dim}(已是 ${nextEnabled ? '开启' : '关闭'},未变更 — 持久化字段未写入)${ui.reset}\n`);
+                    continue;
+                }
+                updateMemoryConfig(nextEnabled);
+                // 写盘:mode 文件 values,/~/.mocode/config;writeConfigKeys 不会动其它键(主题 / 模型等)
+                updateConfigKey('MEMORY_ENABLED', nextEnabled ? 'true' : 'false');
+                const note = nextEnabled
+                    ? `${ui.green}已开启记忆子系统${ui.reset} — memory_save/search/list/update/forget 进入工具表;` +
+                        `Memory Index 段会在下次拼 system message 时注入。工具表本身的快照需要重启 REPL 才完整刷新。`
+                    : `${ui.yellow}已关闭记忆子系统${ui.reset} — 五个 memory_* 工具将在下次拼 system message 时从工具表过滤;` +
+                        `Memory Index 段不再出现;plan-mode 提示词里的 memory_* 字样消失。重启 REPL 后工具表完全不出现。`;
+                layout.contentWrite(`${note}\n`);
+                layout.contentWrite(`${ui.dim}(写入 ${CONFIG_PATH}:MEMORY_ENABLED=${nextEnabled ? 'true' : 'false'};${ui.reset}` +
+                    (process.env.MEMORY_ENABLED
+                        ? `${ui.dim}同 session shell 未 export,文件写入即时生效)${ui.reset}\n`
+                        : `${ui.dim}下次启动仍生效)${ui.reset}\n`));
+            }
+            catch (e) {
+                layout.contentWrite(`${ui.red}/memory_switch 失败:${ui.reset} ${e.message}\n`);
+            }
+            continue;
+        }
         const initialPlan = getAgentMode() === 'plan'; // 轮首模式(在 runTurn 之前读)
         const ok = await runTurn(joined, initialPlan, placeholder);
         // plan 轮正常结束(未中断 / 未抛错)→ 看轮末模式决定:

package/dist/tools/builtins/ask-human.js

@@ -1,5 +1,42 @@
 import { promptIntervention } from '../../ui/intervention.js';
 import { sendState } from '../../pet/bridge.js';
+/** 将单个选项元素安全地转为可读字符串。
+ *  LLM 有时会传对象(如 {name/label/title:"xxx", desc/description:"yyy"})而不是纯字符串,
+ *  直接 String(obj) 会变成 "[object Object]"——这里智能提取可读字段。 */
+function optionToString(o) {
+    if (o === null || o === undefined)
+        return '';
+    if (typeof o === 'string')
+        return o;
+    if (typeof o === 'number' || typeof o === 'boolean')
+        return String(o);
+    if (typeof o === 'object') {
+        const obj = o;
+        // 优先取常见的标签字段
+        const labelKeys = ['label', 'name', 'title', 'text', 'option', 'choice', 'value', 'key'];
+        for (const k of labelKeys) {
+            const v = obj[k];
+            if (typeof v === 'string' && v.trim())
+                return v;
+        }
+        // 其次尝试 "label + description" 组合
+        const label = obj.label ?? obj.name ?? obj.title;
+        const desc = obj.description ?? obj.desc ?? obj.detail;
+        if (typeof label === 'string' && typeof desc === 'string') {
+            return `${label}: ${desc}`;
+        }
+        // 兜底:JSON 序列化(去掉大括号让它看起来不像代码)
+        try {
+            const s = JSON.stringify(obj);
+            // 如果是简单对象尝试美化
+            return s;
+        }
+        catch {
+            return String(o);
+        }
+    }
+    return String(o);
+}
 /** 公开以便 check-ask-human-options.ts 单元测试。 */
 export function coerceOptions(raw) {
     // 路径 1:本身就是数组,map 成字符串。
@@ -11,14 +48,14 @@ export function coerceOptions(raw) {
                 try {
                     const parsed = JSON.parse(t);
                     if (Array.isArray(parsed))
-                        return parsed.map((o) => String(o));
+                        return parsed.map(optionToString);
                 }
                 catch {
                     // 不是合法 JSON 数组,降级原值
                 }
             }
         }
-        return raw.map((o) => (typeof o === 'string' ? o : String(o)));
+        return raw.map(optionToString);
     }
     // 路径 2:LLM 直接把整个数组 stringify 成单字符串塞 options 字段(JSON.parse 出来是字符串)
     // 例如 GLM 系经常这么做,arg h['options']='["A","B"]' → args.options='["A","B"]'
@@ -29,7 +66,7 @@ export function coerceOptions(raw) {
             try {
                 const parsed = JSON.parse(t);
                 if (Array.isArray(parsed))
-                    return parsed.map((o) => String(o));
+                    return parsed.map(optionToString);
             }
             catch {
                 // 不是合法 JSON,保留为单元素数组(对应 input 模式)

package/dist/tools/builtins/index.js

@@ -21,7 +21,26 @@ import { todolistTool } from './todolist.js';
 /**
  * 所有内置工具,按注册顺序排列。
  * 加新工具:在本目录新建 `xxx.ts` 导出一个 Tool,再在下面数组里加一行。无需改 agent / llm。
+ *
+ * 记忆子系统总开关(MEMORY_ENABLED !== 'true'):5 个 memory_* 工具整体不进 builtinTools,
+ * 进而不进 LLM 的工具表(模型根本看不到、也不会想着去调)。运行时通过 /memory_switch 切;
+ * 切换对当前会话的 tool list 不重算(取的是模块初始化时的快照),所以需要重启 REPL 才生效
+ * —— 这是有意为之,避免切开关瞬间把已发出请求的工具列表打乱。
+ *
+ * 注:这里直接读 env(MEMORY_ENABLED)而不是调 config.isMemoryEnabled(),因为本模块可能在
+ * config 单例尚未初始化时被其它模块拉起(import 链路:tools/registry → builtinTools,
+ * config 单例字段 getter 在 getPlanDisabledTools 等调用链路上 lazy 求值)。
  */
+const _memoryEnabledAtBoot = process.env.MEMORY_ENABLED === 'true';
+const _memoryTools = _memoryEnabledAtBoot
+    ? [
+        memorySaveTool,
+        memorySearchTool,
+        memoryListTool,
+        memoryUpdateTool,
+        memoryForgetTool,
+    ]
+    : [];
 export const builtinTools = [
     readFileTool,
     writeFileTool,
@@ -36,11 +55,7 @@ export const builtinTools = [
     askHumanTool,
     switchModeTool, // plan↔auto 自切(两模式都可见,不进 PLAN_DISABLED_TOOLS;副作用控制工具→串行分支)
     dropContextTool, // 运行中剔除无关 tool 结果(上下文管理,无副作用;两模式都可见,串行分支)
-    memorySaveTool,
-    memorySearchTool,
-    memoryListTool,
-    memoryUpdateTool,
-    memoryForgetTool,
+    ..._memoryTools,
     taskTool, // 派生子 agent(独立 history + 可受限工具集);plan 模式禁用(见 PLAN_DISABLED_TOOLS)
     todolistTool, // 工作记事本(plan 文件:复杂任务 checklist,落盘抗压缩);plan 模式可用(便于「先 plan 再 auto」时落地执行清单)
 ];

package/dist/tools/constants.js

@@ -1,4 +1,5 @@
 /** 工具共享的截断 / 上限 / 忽略规则。 */
+import { isMemoryEnabled } from '../config/index.js';
 export const MAX_FILE_LINES = 2000;
 export const MAX_OUTPUT = 20000;
 export const MAX_RESULTS = 100;
@@ -55,3 +56,18 @@ export const PLAN_DISABLED_TOOLS = new Set([
     'memory_forget',
     'task',
 ]);
+/**
+ * 按当前 isMemoryEnabled() 现算 plan 模式应屏蔽的工具。
+ * memoryEnabled=false 时记忆工具整体不在 builtinTools 里,plan 屏蔽集里也无须再列 ——
+ * 反之留着只是死名字。统一过滤,避免 Set 里残留与已下架工具不一致的概念性冗余。
+ * 调用方(agent/core 串行分支、llm/planChatTools)每次 chat 时调本函数拿当前值。
+ */
+export function getPlanDisabledTools() {
+    if (isMemoryEnabled())
+        return PLAN_DISABLED_TOOLS;
+    const next = new Set(PLAN_DISABLED_TOOLS);
+    next.delete('memory_save');
+    next.delete('memory_update');
+    next.delete('memory_forget');
+    return next;
+}

package/dist/ui/layout.js

@@ -742,29 +742,46 @@ function composeSpinnerLine(status, cols) {
     const rightStr = tail ? `${ui.yellow}${tail}${ui.reset}` : '';
     return twoColumn(lead, leadW, rightStr, tailW, cols);
 }
-/** 下线之下那行(model 行):左 = 模式标识;右 = context + cwd,右端对齐。
+/** 下线之下那行(model 行):左 = 模式标识 + 本轮 token chip;右 = context + cwd,右端对齐。
  *  活跃 plan chip 不再放这里,改放 spinner 行上方的「虚拟空行」(contentBottom+1,见 drawStatusBar),
  *  既不挤 model 行,又给输入区上方留出可视分隔带。 */
 function composeModelLine(status, cols) {
     const ctx = status.contextBar; // 已带色
     const ctxW = ansiDisplayWidth(ctx);
-    // 左段:仅模式标识
+    // 左段:模式标识 + 本轮 token chip。token chip 仅展示总量,用 mid 灰,不抢主色。
     const modeTag = status.modeTag ?? '';
     const modeColor = modeTag === 'plan' ? ui.yellow : ui.brightCyan;
-    const modePart = modeTag
-        ? `${modeColor}${modeTag}${ui.reset}`
-        : '';
-    const leftStr = modePart;
-    const leftW = modeTag ? displayWidth(modeTag) : 0;
+    const modePart = modeTag ? `${modeColor}${modeTag}${ui.reset}` : '';
+    const modeW = modeTag ? displayWidth(modeTag) : 0;
+    const tokChip = formatTurnTokenChip(status.lastTurnUsage);
+    const tokW = displayWidth(stripAnsi(tokChip));
+    // 合并左段:chip 前留 2 空格分隔,无 modeTag 也允许仅显示 chip(兜底边角)。
+    const sep = modePart && tokChip ? '  ' : '';
+    const leftStr = `${modePart}${sep}${tokChip}`;
+    const leftW = modeW + (modePart && tokChip ? sep.length : 0) + tokW;
     // 右段:ctx + sep + cwd,右端对齐。cwd 按预算截断,极窄(<6)隐藏。
+    // 任一 chip 极宽时收紧 cwd(toolbar 列挤压场景),先从 cwd 砍、再隐藏 cwd、再隐藏 token chip。
     const minGap = 2;
-    const cwdBudget = cols - leftW - minGap - ctxW - STATUS_SEP_W - 1;
-    const cwd = cwdBudget >= 6 ? truncateDisplay(status.cwd, cwdBudget) : '';
-    const cwdW = displayWidth(cwd);
-    const rightStr = `${ctx}${STATUS_SEP}${ui.dim}${cwd}${ui.reset}`;
-    const rightW = ctxW + STATUS_SEP_W + cwdW;
+    let cwdBudget = cols - leftW - minGap - ctxW - STATUS_SEP_W - 1;
+    let cwd = cwdBudget >= 6 ? truncateDisplay(status.cwd, cwdBudget) : '';
+    let cwdW = displayWidth(cwd);
+    let rightStr = `${ctx}${STATUS_SEP}${ui.dim}${cwd}${ui.reset}`;
+    let rightW = ctxW + STATUS_SEP_W + cwdW;
+    // 极窄(<24 列含 ctx):藏 token chip
+    if (modePart && tokChip && rightW + minGap + leftW > cols) {
+        return twoColumn(modePart, modeW, rightStr, rightW, cols);
+    }
     return twoColumn(leftStr, leftW, rightStr, rightW, cols);
 }
+/** 把本轮 token 总量格式化成 chip 文本(纯字符串,带 ANSI 色)。无 usage 返空串。 */
+function formatTurnTokenChip(usage) {
+    if (!usage || !usage.totalTokens)
+        return '';
+    const n = usage.totalTokens;
+    const text = n < 1000 ? `${n}` : `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}k`;
+    // 单段:量足够稳定时不显分项,避免无谓视觉负担。chip 用 mid 灰(降优先级)— 模式仍是主色。
+    return `${ui.dim}${text} tokens${ui.reset}`;
+}
 /** spinner 行上方的「虚拟空行」(contentBottom+1)。
  *  - 有活跃 plan:显「plan: <summary> ▸ N. step」整行左对齐(yellow + dim)
  *  - 无活跃 plan:空(保留原分隔视觉,避免内容贴输入区)
@@ -929,7 +946,7 @@ export function clearLiveAtCursor() {
     frameRow = 0;
     frameCol = 0;
 }
-/** 更新状态行基线(模型 / context / cwd / 模式标识 / 活跃 plan chip)。repl 在轮次边界与切模式时调。 */
+/** 更新状态行基线(模型 / context / cwd / 模式标识 / 活跃 plan chip / 本轮 token chip)。repl 在轮次边界与切模式时调。 */
 export function setStatusBase(b) {
     base = b;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {