mocode-ai 1.0.13 → 1.1.0

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, updateModelConfig, isModelConfigured, updateMemoryConfig, isMemoryEnabled, isSubAgentEnabled, updateSubAgentConfig, isProjectSkillEnabled, isProjectSnapshotEnabled, updateProjectSkillConfig, updateSnapshotConfig, updateLanguageConfig, languageFromShell, buildBasePrompt, getPlanModeSuffix, } from '../config/index.js';
+import { config, updateModelConfig, isModelConfigured, updateMemoryConfig, isMemoryEnabled, isSubAgentEnabled, updateSubAgentConfig, updateLanguageConfig, languageFromShell, buildBasePrompt, getPlanModeSuffix, hasCodegraphIndex, } from '../config/index.js';
 import { getLanguage, normalizeLanguage, t, } from '../i18n/index.js';
 import { updateConfigKey, writeConfigKeys, CONFIG_PATH } from '../config/file.js';
 import { deletePreset, getPreset, isValidPresetName, listPresets, migrateCurrentToPreset, savePreset, } from '../config/presets.js';
@@ -26,8 +26,7 @@ import { formatArtifactTokenSources } from '../context/artifacts.js';
 import { manualCompact, contextState, newSessionId, saveSession, loadSession, listSessions, appendCurrentSessionRuntimeEvent, hashTraceValue, } from '../session/index.js';
 import { listTurns, planRollback, applyRollback, persistSnapshots, loadSnapshots, rebuildFromHistory, resetState, getCurrentTurnId, } from '../rollback/index.js';
 import { listSkills, effectiveSystemPrompt, } from '../skills/index.js';
-import { buildMemorySection, buildMemoryIndexSection, kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, loadAll, } from '../memory/index.js';
-import { buildSnapshot, clearSnapshotCache } from '../project-snapshot/index.js';
+import { buildMemorySection, buildMemoryIndexSection, invalidateMemoryCache, kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, loadAll, } from '../memory/index.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { getSandboxRoot } from '../sandbox/root.js';
@@ -72,24 +71,6 @@ function buildSlashCommands() {
                 { name: 'status', value: '/subagent status', desc: d('commands.subagentStatus') },
             ],
         },
-        {
-            name: '/project_skill', desc: d('commands.skill'), children: [
-                { name: 'toggle', value: '/project_skill', desc: d('commands.toggle') },
-                { name: 'on', value: '/project_skill on', desc: d('commands.skillOn') },
-                { name: 'off', value: '/project_skill off', desc: d('commands.skillOff') },
-                { name: 'view', value: '/project_skill view', desc: d('commands.skillView') },
-                { name: 'init', value: '/project_skill init', desc: d('commands.skillInit') },
-            ],
-        },
-        {
-            name: '/snapshot', desc: d('commands.snapshot'), children: [
-                { name: 'toggle', value: '/snapshot', desc: d('commands.snapshotToggle') },
-                { name: 'on', value: '/snapshot on', desc: d('commands.snapshotOn') },
-                { name: 'off', value: '/snapshot off', desc: d('commands.snapshotOff') },
-                { name: 'status', value: '/snapshot status', desc: d('commands.snapshotStatus') },
-                { name: 'refresh', value: '/snapshot_refresh', desc: d('commands.snapshotRefresh') },
-            ],
-        },
         { name: '/theme', desc: d('commands.theme') },
         {
             name: '/model', desc: d('commands.model'), children: [
@@ -181,12 +162,18 @@ function maskKey(k) {
 }
 /**
  * /init 指令:发给 agent 扫描项目并生成 MOCODE.md。已存在则让 agent 读后更新(不丢失事实)。写完供 memory 子系统下轮加载。
+ *
+ * 函数化(非 const):.codegraph/ 索引是否存在的探测放在调用瞬间,没索引时不提 codegraph,
+ * 避免 LLM 调出失败。/init 是冷启动动作,IO 开销可忽略。
  */
-const INIT_PROMPT = `分析当前项目(process.cwd()),生成 MOCODE.md 项目记忆文件,供 mocode 后续会话自动加载——目标是让后续会话无需重新摸索就能上手。
+function buildInitPrompt() {
+    const cg = hasCodegraphIndex()
+        ? '- 若有 .codegraph/:用 use_skill 加载 codegraph skill 后用 run_command 调 codegraph explore "<架构或入口符号>" 一次拿相关源码+调用路径,别逐文件读！！！\n'
+        : '';
+    return `分析当前项目(process.cwd()),生成 MOCODE.md 项目记忆文件,供 mocode 后续会话自动加载——目标是让后续会话无需重新摸索就能上手。
 
 先探查(尽量少调用拿全貌):
-- 若有 .codegraph/:用 codegraph 工具(explore "<架构或入口符号>")一次拿相关源码+调用路径,别逐文件读！！！
-- read_file package.json(或 Cargo.toml/pyproject.toml/go.mod 等):scripts、依赖、入口、模块类型。
+${cg}- read_file package.json(或 Cargo.toml/pyproject.toml/go.mod 等):scripts、依赖、入口、模块类型。
 - glob 顶层目录;read_file 入口文件 + 各子系统 index.ts/README。
 - 若 MOCODE.md 已存在:read_file 读它,在其基础上更新(补缺、修正过时),不丢已有准确事实。
 
@@ -204,9 +191,10 @@ install / dev / build / test / typecheck / lint 等——从 package.json script
 
 硬要求:
 - 从实际代码提炼,引用具体文件名/命令/符号;不编造、不泛泛。
-- 总长 ≤ 1500 字;只写后续会话有用的稳定事实,不写易变项(当前 bug、临时文件、未决 TODO)。
+- 总长 ≤ 3000 字;只写后续会话有用的稳定事实,不写易变项(当前 bug、临时文件、未决 TODO)。
 - 用 write_file 写入项目根 MOCODE.md。
 - 写完简述:写了哪几节 + 从代码里发现的 2-3 条非显然关键约定(供用户校验)。`;
+}
 /** 临时 readline 读一行(cooked,用于子提问;主输入走 promptWithSlashMenu)。 */
 async function askLine(prompt) {
     const rl = readline.createInterface({ input: stdin, output: stdout });
@@ -324,8 +312,6 @@ function runningStateFor(cmd) {
             return { status: t('running.rollback'), placeholder: t('running.chooseTurn') };
         case '/init':
             return { status: t('running.init'), placeholder: t('running.generateMemory') };
-        case '/snapshot_refresh':
-            return { status: t('running.snapshot'), placeholder: t('running.scanning') };
         case '/plan':
             return { status: t('running.plan'), placeholder: '…' };
         case '/auto':
@@ -344,10 +330,6 @@ function runningStateFor(cmd) {
             return { status: t('running.memoryStatus'), placeholder: '…' };
         case '/subagent':
             return { status: t('running.subagent'), placeholder: t('running.switching') };
-        case '/project_skill':
-            return { status: t('running.skill'), placeholder: t('running.processing') };
-        case '/snapshot':
-            return { status: t('running.snapshot'), placeholder: t('running.switching') };
         case '/language':
             return { status: t('running.language'), placeholder: t('running.chooseLanguage') };
         case '/upgrade':
@@ -724,12 +706,6 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     const mcpReport = await initializeAllMcp();
     registerToolsExtension('mcp', getMcpTools());
     refreshChatTools();
-    // 项目快照：sandboxRoot 设定后异步构建（完全由 LLM 生成）。
-    // 构建失败不阻断 REPL：snapshot 内部 catch 所有异常。
-    if (config.projectSnapshotEnabled) {
-        // 异步触发 LLM 快照生成（不阻塞 REPL 启动）
-        buildSnapshot().catch(() => { });
-    }
     // --resume:读回该会话的轮次/快照;无文件则从 history 重建 turns(无快照→旧轮次文件改动不可撤销)
     let currentSessionId = sessionId;
     if (!currentSessionId)
@@ -1118,9 +1094,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         // 语言命令把视觉分隔放在确认文案之后；避免回显后先空一行、下一条命令却紧贴确认。
         echoInput(input, cmd !== '/language');
         const state = runningStateFor(cmd);
-        const placeholder = line === '/snapshot_refresh' || line === '/project_skill init'
-            ? ''
-            : state.placeholder;
+        const placeholder = state.placeholder;
         refreshStatusBase(history);
         layout.enterRunningMode(state.status, placeholder);
         if (line === '/help') {
@@ -1157,7 +1131,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         }
         if (line === '/init') {
             // /init:把 init 指令当 user 输入发给 agent(扫描项目 + 生成 MOCODE.md),fall through 走 runAgent
-            joined = INIT_PROMPT;
+            joined = buildInitPrompt();
         }
         if (line === '/upgrade' || line.startsWith('/upgrade ')) {
             const arg = line === '/upgrade' ? '' : line.slice('/upgrade '.length).trim().toLowerCase();
@@ -1425,16 +1399,16 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             continue;
         }
         if (line === '/compact' || line.startsWith('/compact ')) {
-            // /compact 可选语法:/compact [focus]  或  /compact --force [focus]
-            // --force:即便 oldGroups 空(history 全在保护区)也强行把早期消息降级压一次。
+            // /compact 默认强制压缩(force=true)，不受阈值/保护区限制
+            // 语法:/compact [focus] 或 /compact --no-force [focus] (显式关闭强制)
             const rest = line.slice('/compact'.length).trim();
-            let force = false;
+            let force = true; // 默认强制
             let focus;
-            if (rest === '--force')
-                force = true;
-            else if (rest.startsWith('--force ')) {
-                force = true;
-                focus = rest.slice('--force '.length).trim() || undefined;
+            if (rest === '--no-force')
+                force = false;
+            else if (rest.startsWith('--no-force ')) {
+                force = false;
+                focus = rest.slice('--no-force '.length).trim() || undefined;
             }
             else if (rest)
                 focus = rest;
@@ -1500,44 +1474,6 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             }
             continue;
         }
-        if (line === '/snapshot_refresh') {
-            if (!config.projectSnapshotEnabled) {
-                layout.contentWrite(`${ui.dim}(项目快照功能已关闭,MOCODE_PROJECT_SNAPSHOT=false)${ui.reset}\n`);
-                continue;
-            }
-            // buildSnapshot 是异步操作(完全由 LLM 生成)，显示进度提示
-            layout.contentWrite(`${ui.dim}正在重新生成项目快照 (LLM 分析中)...${ui.reset}\n`);
-            const signal = startRunningListener('');
-            try {
-                // 清除缓存，强制重新生成
-                clearSnapshotCache();
-                const result = await buildSnapshot(signal, true);
-                if (result.snapshot) {
-                    layout.contentWrite(`${ui.cyan}✓ 项目快照已刷新${ui.reset} (${result.snapshot.builtAt})\n`);
-                    layout.contentWrite(`${ui.dim}已生成 markdown 快照，注入到系统提示词中${ui.reset}\n`);
-                    // 刷新 history[0]：buildSnapshotSection 内部 loadSnapshot() 会拿到新快照，
-                    // buildSystemMessage 重新拼 system prompt，快照段落就更新了。
-                    history[0] = { role: 'system', content: buildSystemMessage(getAgentMode() === 'plan') };
-                    layout.contentWrite(`${ui.dim}(system prompt 已同步刷新)${ui.reset}\n`);
-                }
-                else {
-                    layout.contentWrite(`${ui.red}✗ 快照生成失败${ui.reset}: ${result.error || '未知错误'}\n`);
-                    if (result.transcript) {
-                        layout.contentWrite(`${ui.dim}--- 子 agent 日志 ---${ui.reset}\n`);
-                        layout.contentWrite(`${ui.dim}${result.transcript}${ui.reset}\n`);
-                        layout.contentWrite(`${ui.dim}--- 日志结束 ---${ui.reset}\n`);
-                    }
-                }
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                layout.contentWrite(`${ui.red}[错误]${ui.reset} 刷新快照失败: ${msg}\n`);
-            }
-            finally {
-                stopRunningListener();
-            }
-            continue;
-        }
         if (line === '/sessions') {
             // /sessions:浏览全部已保存会话(慢路径,readdir+全量 JSON.parse,目录 N 大时会有可感知卡顿)。
             // 默认走 /resume(仅最近 10 条,瞬开);要翻历史续接更早的会话才用这条。
@@ -2098,201 +2034,6 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             }
             continue;
         }
-        if (line === '/project_skill' ||
-            line.startsWith('/project_skill ')) {
-            // /project_skill — 项目专属 Skill 总开关 + 查看/编辑。
-            // 用法:
-            //   /project_skill              切换 on/off
-            //   /project_skill on|off       显式开关
-            //   /project_skill view         查看当前内容
-            //   /project_skill edit         打开编辑器修改
-            try {
-                const arg = line.startsWith('/project_skill ')
-                    ? line.slice('/project_skill '.length).trim().toLowerCase()
-                    : '';
-                // /project_skill view — 查看当前内容
-                if (arg === 'view') {
-                    const enabled = isProjectSkillEnabled();
-                    layout.contentWrite(`${ui.accent}项目专属 Skill:${ui.reset} ${enabled ? `${ui.green}开启` : `${ui.yellow}关闭`}${ui.reset}\n`);
-                    if (enabled) {
-                        const { readProjectSkill } = await import('../project-skill/index.js');
-                        const content = readProjectSkill();
-                        if (content) {
-                            layout.contentWrite(`${ui.dim}--- 内容 ---${ui.reset}\n${content}\n${ui.dim}--- 结束 ---${ui.reset}\n`);
-                        }
-                        else {
-                            layout.contentWrite(`${ui.dim}(尚未创建,可用 /project_skill init 生成初始内容)${ui.reset}\n`);
-                        }
-                    }
-                    else {
-                        layout.contentWrite(`${ui.dim}(功能已关闭,用 /project_skill on 开启)${ui.reset}\n`);
-                    }
-                    continue;
-                }
-                // /project_skill init — 作为一条普通主 Agent 请求生成/优化 skill，不再派生高消耗子 agent。
-                if (arg === 'init') {
-                    if (!isProjectSkillEnabled()) {
-                        layout.contentWrite(`${ui.yellow}⚠ 项目专属 Skill 尚未开启${ui.reset}，请先运行 ${ui.cyan}/project_skill on${ui.reset}\n`);
-                        continue;
-                    }
-                    const initPrompt = `请直接初始化或优化当前项目的 Project Skill，并完成写入。
-
-要求：
-1. 直接由你完成，禁止调用 sub-agent 工具或派生任何子 agent。
-2. 优先利用系统提示中已有的 Project Snapshot 和 Project Skill；不要重复扫描其中已有的目录、依赖、命令和模块清单。
-3. 最多进行 1 次 codegraph 探索；只有缺少关键依据时，才额外进行少量定点 read_file/grep。禁止全仓 glob 和逐文件扫描。
-4. Skill 只记录 Snapshot 无法提供的 WHY/HOW/GOTCHAS/CONVENTIONS：设计取舍、关键调用链、非直觉边界、项目约定和可操作坑点。使用具体路径和例子，删除重复或过时内容。
-5. 最终内容应完整、结构清晰。调用 project_skill_update，使用 action=write 一次性写入完整内容。
-6. 写入成功后只简短说明更新了哪些关键洞察，不要输出完整 Skill。`;
-                    const previousMode = getAgentMode();
-                    try {
-                        await runTurn(initPrompt, false, '');
-                    }
-                    finally {
-                        // init 是一次明确写操作，临时使用 auto；完成后恢复用户原来的模式。
-                        if (previousMode === 'plan')
-                            setAgentMode('plan');
-                    }
-                    continue;
-                }
-                // 开关切换
-                let nextEnabled;
-                if (arg === '') {
-                    nextEnabled = !isProjectSkillEnabled();
-                }
-                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}/project_skill 用法:${ui.reset}\n` +
-                        `  /project_skill             切换(开↔关)\n` +
-                        `  /project_skill on|off      显式设值\n` +
-                        `  /project_skill view        查看当前内容\n` +
-                        `  /project_skill init        扫描项目生成/优化 skill（可重复运行）\n`);
-                    continue;
-                }
-                const prev = isProjectSkillEnabled();
-                if (nextEnabled === prev) {
-                    layout.contentWrite(`${ui.dim}(已是 ${nextEnabled ? '开启' : '关闭'},未变更 — 持久化字段未写入)${ui.reset}\n`);
-                    continue;
-                }
-                updateProjectSkillConfig(nextEnabled);
-                updateConfigKey('MOCODE_PROJECT_SKILL', nextEnabled ? 'true' : 'false');
-                const note = nextEnabled
-                    ? `${ui.green}已开启项目专属 Skill${ui.reset} — project_skill_update 工具进入工具表;` +
-                        `项目 Skill 内容会在下次拼 system message 时注入。工具表快照需重启 REPL 才完整刷新。`
-                    : `${ui.yellow}已关闭项目专属 Skill${ui.reset} — project_skill_update 工具将在下次拼 system message 时从工具表过滤;` +
-                        `项目 Skill 内容不再注入。重启 REPL 后工具表完全不出现。`;
-                layout.contentWrite(`${note}\n`);
-                layout.contentWrite(`${ui.dim}(写入 ${CONFIG_PATH}:MOCODE_PROJECT_SKILL=${nextEnabled ? 'true' : 'false'};${ui.reset}` +
-                    (process.env.MOCODE_PROJECT_SKILL
-                        ? `${ui.dim}同 session shell 未 export,文件写入即时生效)${ui.reset}\n`
-                        : `${ui.dim}下次启动仍生效)${ui.reset}\n`));
-            }
-            catch (e) {
-                layout.contentWrite(`${ui.red}/project_skill 失败:${ui.reset} ${e.message}\n`);
-            }
-            continue;
-        }
-        if (line === '/snapshot' ||
-            line.startsWith('/snapshot ')) {
-            // /snapshot — 项目快照总开关。无参切换 on/off;/on 或 /off 显式;/status 只读。
-            //
-            // 设计原则(与 /project_skill / /memory_switch 对齐):
-            //  - 单一来源 config.projectSnapshotEnabled(被 buildSnapshotSection() 现拼 +
-            //    read_file 工具每次 execute 现读);改完下一轮 chat 的 system prompt 即时反映。
-            //  - 持久化字段 MOCODE_PROJECT_SNAPSHOT,默认值 true(默认开启,启动 lazy build)。
-            //  - 关闭时:system prompt 不注入快照段,read_file 不查 cache 直接走真实 readFile。
-            //  - 开启时:若还没有 snapshot.json,主动 buildProjectSnapshot() 一次(仿 startRepl
-            //    655-658 的 lazy build 模式),否则 buildSnapshotSection() 会因 loadSnapshot=null
-            //    返空串,用户感知不到自己刚打开的开关已经生效。
-            try {
-                const arg = line.startsWith('/snapshot ')
-                    ? line.slice('/snapshot '.length).trim().toLowerCase()
-                    : '';
-                // /snapshot status — 只读查询
-                if (arg === 'status') {
-                    const on = isProjectSnapshotEnabled();
-                    layout.contentWrite(`${ui.accent}项目快照:${ui.reset} ${on ? `${ui.green}开启` : `${ui.yellow}关闭`}${ui.reset}\n`);
-                    layout.contentWrite(`${ui.dim}  单一来源 config.projectSnapshotEnabled(${on ? 'true' : 'false'});` +
-                        `持久化 ${ui.accent}MOCODE_PROJECT_SNAPSHOT${ui.dim};` +
-                        `配置文件 ${CONFIG_PATH}${ui.reset}\n`);
-                    layout.contentWrite(`${ui.dim}  关闭时:buildBasePrompt() 不含「## Project Snapshot」段;` +
-                        `read_file 工具直接走真实 readFile,不走 snapshot cache。${ui.reset}\n`);
-                    layout.contentWrite(`${ui.dim}  切换后下次 chat 即时反映(本轮已发出的请求不会回滚)。${ui.reset}\n`);
-                    continue;
-                }
-                // /snapshot(无参=切换;有参=按值设)
-                let nextEnabled;
-                if (arg === '') {
-                    nextEnabled = !isProjectSnapshotEnabled();
-                }
-                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}/snapshot 用法:${ui.reset}\n` +
-                        `  /snapshot                  切换(开↔关)\n` +
-                        `  /snapshot on|off           显式设值\n` +
-                        `  /snapshot status           查看当前状态\n`);
-                    continue;
-                }
-                const prev = isProjectSnapshotEnabled();
-                if (nextEnabled === prev) {
-                    layout.contentWrite(`${ui.dim}(已是 ${nextEnabled ? '开启' : '关闭'},未变更 — 持久化字段未写入)${ui.reset}\n`);
-                    continue;
-                }
-                updateSnapshotConfig(nextEnabled);
-                updateConfigKey('MOCODE_PROJECT_SNAPSHOT', nextEnabled ? 'true' : 'false');
-                // 开启时异步 build 一次,避免 buildSnapshotSection 因 loadSnapshot=null 返空串。
-                let built = false;
-                if (nextEnabled) {
-                    try {
-                        clearSnapshotCache();
-                        const result = await buildSnapshot();
-                        if (result.snapshot) {
-                            built = true;
-                        }
-                        else {
-                            layout.contentWrite(`${ui.yellow}⚠ 快照构建失败:${ui.reset} ${result.error || '未知错误'} ` +
-                                `${ui.dim}(开关已切换,系统提示词中的快照段将为空,稍后可用 /snapshot_refresh 重试)${ui.reset}\n`);
-                        }
-                    }
-                    catch (e) {
-                        layout.contentWrite(`${ui.yellow}⚠ 快照构建失败:${ui.reset} ${e.message} ` +
-                            `${ui.dim}(开关已切换,系统提示词中的快照段将为空,稍后可用 /snapshot_refresh 重试)${ui.reset}\n`);
-                    }
-                }
-                // 刷新 history[0] 使 system prompt 立即反映新值(仿 /snapshot_refresh)。
-                history[0] = { role: 'system', content: buildSystemMessage(getAgentMode() === 'plan') };
-                const note = nextEnabled
-                    ? `${ui.green}已开启项目快照${ui.reset} — ` +
-                        `system prompt 将在下次 chat 注入「## Project Snapshot」段;` +
-                        `read_file 工具优先走 snapshot cache(mtime 校验失败时回退真实 readFile)。`
-                    : `${ui.yellow}已关闭项目快照${ui.reset} — ` +
-                        `system prompt 不再注入「## Project Snapshot」段;` +
-                        `read_file 工具直接走真实 readFile,不再查 cache。`;
-                let extra = '';
-                if (nextEnabled && built) {
-                    extra = `${ui.dim}(已构建快照;如需刷新用 /snapshot_refresh)${ui.reset}\n`;
-                }
-                layout.contentWrite(`${note}\n${extra}`);
-                layout.contentWrite(`${ui.dim}(写入 ${CONFIG_PATH}:MOCODE_PROJECT_SNAPSHOT=${nextEnabled ? 'true' : 'false'};` +
-                    (process.env.MOCODE_PROJECT_SNAPSHOT
-                        ? `${ui.dim}同 session shell 已 export MOCODE_PROJECT_SNAPSHOT,文件写入下次启动仍以 shell 值为准;取消 shell 设置后生效)${ui.reset}\n`
-                        : `${ui.dim}下次启动仍生效)${ui.reset}\n`));
-            }
-            catch (e) {
-                layout.contentWrite(`${ui.red}/snapshot 失败:${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) {
@@ -2308,9 +2049,16 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         queryHistory.push(joined);
         const initialPlan = getAgentMode() === 'plan'; // 轮首模式(在 runTurn 之前读)
         const ok = await runTurn(joined, initialPlan, placeholder);
+        // /init 收尾:Agent 已 write_file 写完新 MOCODE.md,失效 cache 并用新内容重建 history[0],
+        // 否则下一轮拿到的还是写之前的旧 memory 段,必须重启 REPL 才生效。
+        if (ok && line === '/init') {
+            invalidateMemoryCache();
+            history[0] = { role: 'system', content: buildSystemMessage(getAgentMode() === 'plan') };
+            refreshStatusBase(history);
+        }
         // plan 轮正常结束(未中断 / 未抛错)→ 看轮末模式决定:
-        //  - 仍 plan:LLM 没自切(只产计划就 STOP)→ 弹审批面板(原行为)。
-        //  - 已 auto:LLM 调了 switch_mode('auto') 在同轮自主执行了 → 跳过审批,不重复打扰。
+        //  - 仍 plan:模型只产计划就 STOP(模型已无 switch_mode 工具)→ 弹审批面板(原行为)。
+        //  - 已 auto:本轮被切到 auto 模式(用户用 /auto 触发的合成执行轮)→ 跳过审批,不重复打扰。
         if (initialPlan && ok && getAgentMode() === 'plan') {
             // 桌宠:计划审批面板弹出期间广播 waiting_human(红灯闪烁);面板不在 runAgent/hooks 体系内,
             // 需在此单独广播——用户响应后由下一次 /pet 状态事件(或 idle 兜底)覆盖。

package/dist/sandbox/policy.js

@@ -6,16 +6,18 @@ import { jailResolve, jailGlobPattern } from './jail.js';
  *  - memory_*:操作 ~/.mocode 与 <cwd>/.mocode,本就该在外圈
  *  - use_skill:读 ~/.claude/skills、~/.mocode/skills、<cwd>/.mocode/skills,部分在外圈
  *  - web_*:跨网络,非文件路径
- *  - ask_human / switch_mode:无文件路径
- *  - codegraph:只读 cwd 下 .codegraph/ 索引(只读、不写盘)
+ *  - ask_human:无文件路径
  *  - sub-agent:派生子 agent，通过 scoped sandbox root 使用隔离 overlay
+ *
+ *  注:codegraph 不再是核心工具,已 skill 化(用 run_command 调 CLI),
+ * 不在此处登记。switch_mode 工具已砍,模式切换仅由 repl 的 /plan / /auto /
+ * Shift+Tab 等用户面触发,不经工具路径。
  */
 export const SANDBOX_EXEMPT_TOOLS = new Set([
     'memory_save', 'memory_update', 'memory_forget', 'memory_search', 'memory_list',
     'use_skill',
     'web_search', 'web_fetch',
-    'ask_human', 'switch_mode',
-    'codegraph',
+    'ask_human',
     'sub-agent',
 ]);
 /**

package/dist/skills/builtin-skills.js

@@ -0,0 +1,56 @@
+// 内置 Skill:随 mocode 一起发布的 skill,不依赖用户目录,作为最低优先级兜底。
+// 用户在 ~/.mocode/skills/<name>/SKILL.md 放置同名 skill 时覆盖内置版（更具体的优先）。
+//
+// 设计动机:把 "可被 use_skill 加载、按需激活" 的领域知识从「核心工具」剥离出来。
+// 典型用例:codegraph 工具原本是薄壳 CLI 包装,现改成 skill,模型按需加载说明后
+// 用 run_command 调用 codegraph CLI,核心工具集更瘦,无 codegraph 索引的项目零负担。
+const CODEGRAPH_BODY = `# Code Graph Query
+
+Pre-built \`.codegraph/\` 索引查询技能。**当 \`.codegraph/\` 存在时**,用它代替逐文件 grep+read,
+能一次拿到相关源码 + 调用链 + 影响面;不存在时**不要**使用本 skill（用 read_file / glob / grep）。
+
+## 调用方式（用 run_command 工具）
+
+codegraph 不再是核心工具,而是 skill 化后的 CLI 调用。模型在 REPL 中这样调:
+
+\`\`\`
+run_command({ command: "codegraph explore <query...>" })
+run_command({ command: "codegraph node <symbol-or-path>" })
+\`\`\`
+
+注意:
+
+- Windows 上 \`codegraph\` 是 .cmd,必须走 cmd.exe /c 包装(run_command 内部已处理,直接传 \`codegraph ...\` 即可)。
+- 单次查询 ≤ 60s 超时,模型按需重试/换 query。
+
+## 何时用
+
+- **理解架构/入口模块** → \`codegraph explore "<模块名或入口符号>"\`,一次拿相关源码 + 调用路径,别再逐文件读。
+- **定位单个符号** → \`codegraph node <symbol>\`(返回该符号源码 + callers + callees)。
+- **读一个文件 + 依赖** → \`codegraph node <file-path> --file <file>\`(file 模式)。
+- **评估改动影响面** → 先 \`explore\` 看 callers,再 \`node\` 单点深挖。
+
+## 何时不用
+
+- 没建过 \`.codegraph/\` 索引(运行 \`codegraph init\` 即可,需先 \`npm i -g @colbymchenry/codegraph\`)→ 用 read_file / glob / grep。
+- 单个已知小文件/刚编辑过的文件 → 直接 read_file / edit_file。
+- 同一会话内已经查过同一区域 → 复用历史结果,不要重复调。
+
+## 输出格式
+
+CLI dump 一般是 \`path/to/file.ts:line:col  symbol\` 形式,与 grep 一样可被 read_file 消费。
+`;
+/** 单一事实源:加新内置 skill 在此数组加一条。 */
+export const builtinSkills = [
+    {
+        name: 'codegraph',
+        description: 'Query a pre-built .codegraph/ index for symbol lookup, call chains, and impact analysis. ' +
+            'First choice over read_file/grep when the .codegraph/ index exists. ' +
+            'Invoke via run_command("codegraph explore …" | "codegraph node …").',
+        body: CODEGRAPH_BODY,
+        dir: 'builtin',
+        skillMdPath: 'builtin',
+    },
+];
+/** 内置 skill 名字集,供 discoverSkills 跳过/覆盖时使用。 */
+export const builtinSkillNames = new Set(builtinSkills.map((s) => s.name));

package/dist/skills/discover.js

@@ -7,6 +7,7 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { builtinSkillNames } from './builtin-skills.js';
 /** 把开头的 ~/ 或 ~ 展开为 home 目录(Windows 与 POSIX 通用)。 */
 function expandHome(p) {
     if (p === '~')
@@ -110,6 +111,12 @@ export function discoverSkills() {
             continue; // 目录不存在或无权限,静默跳过
         }
         for (const name of entries) {
+            // 跳过内置 skill 同名目录(项目级用户版可放在 ~/.mocode/skills/<name>/
+            // 覆盖内置版;cwd/.mocode/skills/<name>/ 也算项目级覆盖)。discoverSkills 按
+            // 优先级升序遍历、项目级 Map.set 后写覆盖先写,所以这里只是「不重复登记内置」,
+            // 真实覆盖逻辑在 listSkills 的合并步骤。
+            if (builtinSkillNames.has(name))
+                continue;
             const skillDir = path.join(dir, name);
             const skillMdPath = path.join(skillDir, 'SKILL.md');
             try {

package/dist/skills/index.js

@@ -1,23 +1,42 @@
 // skills barrel:缓存已发现的 skill、按需读正文、拼系统提示段。
 // 被 repl(注入 systemPrompt)与 tools/builtins/use-skill(加载正文)依赖;
-// 自身仅依赖 discover.ts + node:fs,是叶子级业务模块。
+// 自身仅依赖 discover.ts + builtin-skills.ts + node:fs,是叶子级业务模块。
+//
+// 优先级:内置 skill < 用户/系统 skill < 项目级 skill(后注册覆盖先注册,
+// 项目级最后扫描,自然在 Map 中胜出)。同名用户 skill 完全替换内置版。
 import { existsSync, readFileSync } from 'node:fs';
 import { discoverSkills, parseFrontmatter } from './discover.js';
+import { builtinSkills } from './builtin-skills.js';
 let cache = null;
-/** 已发现的 skill 列表(懒加载,首次调用触发扫描;启动期 repl 调一次)。 */
+/** 已发现的 skill 列表(懒加载,首次调用触发扫描;启动期 repl 调一次)。
+ * 合并策略:内置 skill 作兜底,discoverSkills 的输出(按目录优先级后写覆盖)优先生效。 */
 export function listSkills() {
-    if (cache === null)
-        cache = discoverSkills();
+    if (cache !== null)
+        return cache;
+    const discovered = discoverSkills();
+    const byName = new Map();
+    // 先放内置(最低优先级)
+    for (const skill of builtinSkills)
+        byName.set(skill.name, skill);
+    // 后放用户/项目级(覆盖内置)
+    for (const skill of discovered)
+        byName.set(skill.name, skill);
+    cache = Array.from(byName.values());
     return cache;
 }
 /**
  * 读取某 skill 的 SKILL.md 正文(去掉 frontmatter)。
  * 纯函数:找不到 / 读失败返 null(错误字符串交给调用方工具层生成)。
+ * 内置 skill 直接返回 body 字段(无 fs 依赖)。
  */
 export function getSkillBody(name) {
     const skill = listSkills().find((s) => s.name === name);
     if (!skill)
         return null;
+    if (skill.body) {
+        const trimmed = skill.body.trim();
+        return trimmed || '(skill 正文为空)';
+    }
     try {
         if (!existsSync(skill.skillMdPath))
             return null;