mocode-ai 0.4.1 → 0.4.3

package/dist/memory/store.js

@@ -315,24 +315,66 @@ export function gcMemories() {
 /**
  * active 条目按 updatedAt 降序,封顶 MAX_INDEX_ENTRIES,只注 id/name/summary/type。
  * 无 active 返空串(零行为变化)。body 不注入——按需 memory_search 取。
+ *
+ * 索引策略(省 token):不全量塞进每轮 systemPrompt。
+ *  - pinned 永远包含(pinned = 用户明确想长期保留)
+ *  - recallCount ≥ 1 包含(被引用过,价值已验证)
+ *  - 否则仅当 (lastRecalledAt|createdAt) 近 RECENT_MS(=DECAY_DAYS×2) 内
+ * 排序:pinned 先 → recallCount 降 → updatedAt 降。
+ * 封顶 MAX_INDEX_ENTRIES;尾部标 hidden 数量,引导用 memory_list/memory_search 兜底。
+ * 真正「陈旧」被滤掉时也明示(让 LLM 知道有内容存在但被策略隐藏,而不是误以为空)。
+ *
+ * memoryEnabled=false 时(记忆子系统总开关关闭)直接返空串:Memory Index 段
+ * 不进系统提示,LLM 看不到工具使用提示;配合 tools/builtins 屏蔽 memory_* 工具,
+ * 实现「关闭时零侵入」(默认行为)。传参由 repl 的 buildSystemMessage 在拼装前调
+ * isMemoryEnabled() 注入(本文件是叶子,避免直接引 config 起环)。
  */
-export function buildMemoryIndexSection() {
-    const active = loadAll()
-        .filter((e) => e.status === 'active')
-        .sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
+export function buildMemoryIndexSection(memoryEnabled = true) {
+    if (!memoryEnabled)
+        return '';
+    const all = loadAll();
+    const active = all.filter((e) => e.status === 'active');
     if (active.length === 0)
         return '';
-    const shown = active.slice(0, MAX_INDEX_ENTRIES);
+    const now = Date.now();
+    // DECAY_DAYS×2 = 60 天(常量在下方定义,同模块作用域内可见)
+    const recentCutoff = now - DECAY_DAYS * 2 * DAY_MS;
+    const refTs = (e) => {
+        const r = e.lastRecalledAt ? Date.parse(e.lastRecalledAt) : Date.parse(e.createdAt);
+        return Number.isFinite(r) ? r : now;
+    };
+    // 过滤:只保留"近 60 天有动静 / 有 recall / pinned"的三类。其它 active 视为陈旧。
+    const eligible = active.filter((e) => {
+        if (e.pinned)
+            return true;
+        if (e.recallCount >= 1)
+            return true;
+        return refTs(e) >= recentCutoff;
+    });
+    eligible.sort((a, b) => {
+        if (a.pinned !== b.pinned)
+            return a.pinned ? -1 : 1;
+        if (a.recallCount !== b.recallCount)
+            return b.recallCount - a.recallCount;
+        return (b.updatedAt || '').localeCompare(a.updatedAt || '');
+    });
+    const staleCount = active.length - eligible.length;
+    const shown = eligible.slice(0, MAX_INDEX_ENTRIES);
     const lines = shown.map((e) => `- ${e.id}: ${e.name} — ${e.summary} (${e.type})`);
-    const tail = active.length > MAX_INDEX_ENTRIES
-        ? `\n\n…(${active.length} total, showing first ${MAX_INDEX_ENTRIES}; use memory_search <id or keyword> for more)`
-        : '';
+    const capOmitted = Math.max(0, eligible.length - shown.length);
+    const tailParts = [];
+    if (capOmitted > 0)
+        tailParts.push(`${capOmitted} additional active entries omitted by cap (${shown.length}/${eligible.length} shown)`);
+    if (staleCount > 0)
+        tailParts.push(`${staleCount} stale active entries hidden by index policy (no recall + older than ${DECAY_DAYS * 2}d; use memory_list to see all)`);
+    const tail = tailParts.length > 0 ? `\n\n…(${tailParts.join('; ')})` : '';
     return [
         '',
         '',
         '## Memory Index (retrieve full body via memory_search)',
         'The following are saved memory entries (title/summary only). Retrieve full body via memory_search (pass id or keyword); use memory_list to see all,'
-            + ' memory_update to modify, memory_forget to archive. This list is a startup snapshot; entries added during the session are not listed here — use memory_list/memory_search to find them.',
+            + ' memory_update to modify, memory_forget to archive. This list is a startup snapshot; entries added during the session are not listed here — use memory_list/memory_search to find them.'
+            + ' Index policy: pinned + recently-recalled always shown; long-untouched active entries are hidden to keep this section lean.',
         ...lines,
         tail,
     ].join('\n');

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 留空,不塞「处理」这种与内联重复的泛标签。
@@ -188,6 +195,13 @@ let runningInput = ''; // 运行中已打字缓冲(单行;agent 结束后预填
 let runningPlaceholder = '';
 let currentAbort = null;
 let pendingPrefill = null; // /rollback 选中后预填的 user 输入(下轮 INPUT 态消费)
+// ── pending send 撤回窗口(用户按 Enter 后、agent 真发请求前)──
+// 500ms 内 Ctrl+C / Esc → 整条用户气泡从内容区擦掉 + 原行 prefilled 回输入框(可改可再发);
+// 期间再按 Enter 立即推进 / 时间到自然推进 → 走原流程 enterRunningMode + runTurn。
+// attachmentsCount 记 pendingAttachments 当时长度——撤回时 attachments 保留(用户意图未变,只是改字)。
+const PENDING_RECALL_MS = 500;
+let pendingRecall = null;
+let pendingTimer = null;
 // agent 模式状态已提到 src/agent/mode.ts(共享叶子:switch_mode 工具可写、agent 每步读、repl 注册 onModeChange 监听器)。
 /** 多模态 user 输入的附件状态。pending = 本轮尚未提交的待发图片;messageAttachments = 已 push 进 history 的图片元数据
  *  (供 renderHistory 复显文件名——base64 不可逆地塞进 history 后,只能从侧 channel 拿原文件名)。 */
@@ -318,6 +332,76 @@ function echoInput(lines) {
         layout.contentWrite(`  ${ui.dim}${renderChip(a)}${ui.reset}\n`);
     }
 }
+/**
+ * 等待 pending 撤回窗口(用户 Enter 后、agent 真发请求前的 500ms 兜底)。
+ * 返 true=应 commit(走原 enterRunningMode + runTurn);false=应 recall(主循环 rewindContent 擦气泡 + prefill 回输入框)。
+ *
+ * 监听:
+ *   - Esc / Ctrl+C → recall(shouldCommit=false)
+ *   - Enter / Return → 立即 commit(shouldCommit=true)
+ *   - 其它键忽略(不进 paste 路径、不挂 timer)
+ *   - 500ms 定时器到 → 自动 commit(shouldCommit=true)
+ *
+ * 视觉:状态行 spinner 位临时改 '发送中…  (Esc / Ctrl+C 撤回)';commit 后
+ * runAgent.onStepStart 会 setStatus('思考中') 接管,无需手动还原。
+ *
+ * 降级:非 TTY(setRawMode 抛错)直接 commit,window=0 —— CI / 管道回放路径不退化。
+ */
+function awaitPendingRecall(input, attachmentsCount, placeholder) {
+    pendingRecall = { lines: input, attachmentsCount, placeholder };
+    layout.setStatus('发送中…  (Esc / Ctrl+C 撤回)', '●');
+    // 非 TTY:setRawMode 抛错 → window=0 直返 true(向后退化,不走 raw + 不挂监听)。
+    let ttyReady = false;
+    try {
+        stdin.setRawMode(true);
+        ttyReady = true;
+    }
+    catch {
+        ttyReady = false;
+    }
+    if (!ttyReady) {
+        pendingRecall = null;
+        return Promise.resolve(true);
+    }
+    stdin.resume();
+    emitKeypressEvents(stdin);
+    return new Promise((resolve) => {
+        let done = false;
+        const finalize = (shouldCommit) => {
+            if (done)
+                return;
+            done = true;
+            if (pendingTimer) {
+                clearTimeout(pendingTimer);
+                pendingTimer = null;
+            }
+            emitter.off('keypress', onPendingKey);
+            pendingRecall = null;
+            resolve(shouldCommit);
+        };
+        const onPendingKey = (_str, key) => {
+            if (!key || done)
+                return;
+            // 鼠标报表:吞(与 prompt.ts / onRunningKey 风格一致)
+            if (mouse.swallow(key.sequence ?? ''))
+                return;
+            // 撤回
+            if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+                finalize(false);
+                return;
+            }
+            // 立即 commit
+            if (key.name === 'enter' || key.name === 'return') {
+                finalize(true);
+                return;
+            }
+            // 其他键忽略
+        };
+        emitter.on('keypress', onPendingKey);
+        pendingTimer = setTimeout(() => finalize(true), PENDING_RECALL_MS);
+        pendingTimer.unref?.();
+    });
+}
 /** 把任意消息 content 拍平成字符串(OpenAI 可能 string / null / 多模态数组)。 */
 function textOf(c) {
     if (typeof c === 'string')
@@ -408,13 +492,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 +522,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 +689,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 +865,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 +1067,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 +1303,89 @@ 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 bubbleRows = input.length + 2 + pendingAttachments.length; // N 行 message + 2 行尾随空(含 \n\n 留下的 open current 行) + 每附件 1 行
+        const shouldCommit = await awaitPendingRecall(input, pendingAttachments.length, placeholder);
+        if (!shouldCommit) {
+            // 撤回:气泡从内容区擦掉 + 行放回输入框(下轮 promptWithSlashMenu 经 initialLines 消费)+ 切回 INPUT 视觉。
+            // pendingAttachments **保留** —— 撤回的是输入文本不是意图,再发时随消息一起带走
+            // (runTurn 入口的 pendingAttachments.flush 仍按现有逻辑把附件塞进 userInput)。
+            layout.rewindContent(bubbleRows);
+            pendingPrefill = input;
+            layout.enterInputMode('空闲');
+            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/content.js

@@ -55,6 +55,33 @@ export function breakRow() {
     rowStartSgr = curSgr; // 下行继承本行末状态
     hasCurrent = true; // 新空行即当前行
 }
+/**
+ * 弹出 buffer 末尾 n 物理行(供 layout.rewindContent 撤回刚写入段用)。
+ * 当前行先 commit 再裁剪(消除 hasCurrent 边界);n ≥ totalRows 则全清,
+ * 但**不动 segMark** —— recall 走普通 contentWrite、不撞 md 段;
+ * segMark 由 reset() / commitSegment() 清,recall 不掺和。
+ */
+export function rewind(n) {
+    if (n <= 0)
+        return;
+    const cur = totalRows();
+    if (n >= cur) {
+        rows = [];
+        curSgr = '';
+        rowStartSgr = '';
+        curRaw = '';
+        hasCurrent = false;
+        return;
+    }
+    // 当前行先 commit 再裁剪(否则 hasCurrent 边界会被打穿)
+    if (hasCurrent) {
+        rows.push(rowStartSgr + curRaw + '\x1B[0m');
+        curRaw = '';
+        rowStartSgr = curSgr;
+        hasCurrent = false;
+    }
+    rows.splice(rows.length - n);
+}
 /** 标记段起点:快照当前缓冲状态,供 setLines 截断定位段头(md 流式渲染每 chunk 截断重渲)。 */
 export function beginSegment() {
     segMark = { rowIdx: rows.length, rowStartSgr, curSgr, curRaw, hasCurrent };