mocode-ai 0.1.2 → 0.1.4

package/README.md

@@ -20,21 +20,43 @@
 
 ## 安装
 
+要求 Node.js ≥ 18。
+
 ```bash
+npm install -g mocode-ai
+```
+
+装完即得 `mocode` 命令。不想全局装也可免装直跑:`npx mocode-ai`。
+
+> mocode 启动时自动检测新版本,后台 `npm i -g mocode-ai@latest` 自更新——下次启动生效,零启动延迟、断网 / 失败静默。开发态 `npm start`(tsx 跑 `.ts`)不触发。
+
+### 从源码运行(开发 / 贡献)
+
+```bash
+git clone https://github.com/wanxunyang/mocode.git
 cd mocode
 npm install
+npm start
 ```
 
-> 依赖:`openai`、`dotenv`、`fast-glob`(运行时);`tsx`、`typescript`、`@types/node`(开发)。
+源码经 tsx 直接跑,无构建步骤。改完代码需重启 `npm start` 生效(tsx 启动时加载模块,不热更新)。依赖:`openai`、`dotenv`、`fast-glob`(运行时);`tsx`、`typescript`、`@types/node`(开发)。
 
 ## 配置
 
-复制 `.env.example` 为 `.env`,填三个必填项:
+首次使用运行配置向导,交互填三项(API 地址 / key / 模型名),写入 `~/.mocode/config`(全局,任意目录、任意终端生效):
 
 ```bash
-cp .env.example .env
+mocode config
 ```
 
+也可手写配置文件。mocode 按以下优先级加载(后者覆盖前者,仅回填未设置的环境变量;shell 里 `export` 的永远最优先):
+
+1. `~/.mocode/config` — 全局(`mocode config` 写此文件)
+2. `<cwd>/.mocode/config` — 项目级覆盖
+3. `<cwd>/.env` — 旧用法兼容(源码仓库内有 `.env.example` 可参考)
+
+必填三项:
+
 ```env
 LLM_BASE_URL=https://open.bigmodel.cn/api/v3   # 换成你的后端
 LLM_API_KEY=your-key-here
@@ -62,6 +84,8 @@ LLM_MODEL=glm-4.6                              # 换成你的模型名
 | `COMPACT_THRESHOLD` | 自动压缩触发阈值(占窗口比例) | `0.85` |
 | `LLM_STREAM_USAGE` | 流式请求带 `stream_options.include_usage` 拿真实用量 | `true` |
 | `AUTO_COMPACT` | 自动压缩总开关 | `true` |
+| `AUTO_REFLECT` | 后台反思 pass 总开关(定期从会话挖掘记忆) | `true` |
+| `REFLECT_EVERY_N` | 每 N 轮触发一次后台反思(与 agent 并发,不阻塞) | `5` |
 | `ANYSEARCH_API_KEY` | 联网搜索 API key(不配走匿名免费额度) | 无 |
 | `ANYSEARCH_BASE_URL` | 搜索 API 端点 | `https://api.anysearch.com` |
 | `SKILLS_DIRS` | 覆盖默认 skill 扫描目录(平台分隔符) | 三目录自动扫描 |
@@ -69,14 +93,17 @@ LLM_MODEL=glm-4.6                              # 换成你的模型名
 ## 运行
 
 ```bash
-npm start                          # 新会话
-npm start -- --resume              # 列出已保存会话
-npm start -- --resume <id>         # 续接指定会话
+mocode                          # 新会话(在目标项目目录里跑)
+mocode --resume                 # 列出已保存会话
+mocode --resume <id>            # 续接指定会话
+mocode config                   # 改配置
 ```
 
+从源码跑则用 `npm start`(等价于 `mocode`,但不触发自更新)。
+
 进入 REPL 后直接对话。启动即进全屏 TUI,显示横幅(模型 / 后端 / 工作目录 / 工具列表)。回复流式打印,思考段实时可见后折叠。
 
-agent 工作在**启动时所在的工作目录**——想让它操作某个项目,就 `cd` 到那个项目再 `npm start`。
+agent 工作在**启动时所在的工作目录**——想让它操作某个项目,就 `cd` 到那个项目再 `mocode`。
 
 ## 工具
 

package/dist/agent/index.js

@@ -4,7 +4,7 @@ import { chat, } from '../llm/index.js';
 import { executeTool } from '../tools/registry.js';
 import { ui } from '../ui/theme.js';
 import { Spinner } from '../ui/spinner.js';
-import { summarizeToolCall, summarizeToolResult, truncateDisplay, } from '../ui/render.js';
+import { summarizeToolCall, summarizeToolResult, truncateDisplay, fmtElapsed, } from '../ui/render.js';
 import { renderFileChange } from '../ui/diff.js';
 import * as layout from '../ui/layout.js';
 import { beginTurn } from '../rollback/index.js';
@@ -19,6 +19,84 @@ function parseArgs(raw) {
         return null;
     }
 }
+/** 只读工具集:一轮多个时,连续的只读工具成组 Promise.all 并行(无副作用、互不依赖)。 */
+const READ_TOOL_NAMES = new Set([
+    'read_file',
+    'glob',
+    'grep',
+    'web_search',
+    'web_fetch',
+]);
+/** mutation 工具:写盘 + 在 executeTool 内记回滚 before 快照,必须串行保快照序。 */
+const isMutationTool = (name) => name === 'edit_file' || name === 'write_file';
+/** 工具调用 ● 头:工具名 + 参数摘要(按 tool_calls 原顺序打印,让用户看到本轮跑哪些工具)。 */
+function writeToolHeader(tc) {
+    const summary = summarizeToolCall(tc.name, tc.arguments);
+    layout.contentWrite(`  ${ui.brightMagenta}●${ui.reset} ${ui.cyan}${tc.name}${ui.reset}  ${ui.dim}${summary}${ui.reset}\n`);
+}
+/**
+ * mutation 执行前读旧内容供 diff:write_file 取整文件旧内容(不存在→null=新建),
+ * edit_file 取 old_string 起始行号(供 diff 显示真实文件行号)。读不到则 diff 退化为相对行号。
+ * 非 mutation 或参数非法返 { preWriteOld: null, editStartLine: 1 }。失败不阻断。
+ */
+function readDiffContext(tc, parsed) {
+    if (!parsed)
+        return { preWriteOld: null, editStartLine: 1 };
+    const p = String(parsed.path ?? '');
+    if (!p)
+        return { preWriteOld: null, editStartLine: 1 };
+    if (tc.name === 'write_file') {
+        try {
+            return { preWriteOld: readFileSync(resolve(p), 'utf8'), editStartLine: 1 };
+        }
+        catch {
+            return { preWriteOld: null, editStartLine: 1 }; // 文件不存在(新建)或不可读
+        }
+    }
+    if (tc.name === 'edit_file') {
+        const oldStr = String(parsed.old_string ?? '');
+        try {
+            const data = readFileSync(resolve(p), 'utf8');
+            const idx = oldStr ? data.indexOf(oldStr) : -1;
+            return {
+                preWriteOld: null,
+                editStartLine: idx >= 0 ? data.slice(0, idx).split('\n').length : 1,
+            };
+        }
+        catch {
+            return { preWriteOld: null, editStartLine: 1 }; // 读不到:diff 退化为相对行号
+        }
+    }
+    return { preWriteOld: null, editStartLine: 1 };
+}
+/** 渲染工具结果:mutation 成功走 diff 块(行号 + 语法高亮,仿 Claude Code);其余走一行 preview。 */
+function writeToolResult(tc, output, parsed, preWriteOld, editStartLine) {
+    if (isMutationTool(tc.name) && parsed && !output.startsWith('错误')) {
+        layout.contentWrite(renderFileChange({
+            path: String(parsed.path ?? ''),
+            kind: tc.name === 'edit_file' ? 'edit' : 'write',
+            oldStr: tc.name === 'edit_file'
+                ? String(parsed.old_string ?? '')
+                : preWriteOld,
+            newStr: String((tc.name === 'edit_file' ? parsed.new_string : parsed.content) ?? ''),
+            startLine: tc.name === 'edit_file' ? editStartLine : 1,
+        }));
+    }
+    else {
+        const preview = summarizeToolResult(tc.name, output);
+        if (preview) {
+            layout.contentWrite(`  ${ui.gray}↳ ${preview}${ui.reset}\n`);
+        }
+    }
+}
+/** 回灌 tool 结果到 history(裁到单条上限);tool_call_id 与 assistant.tool_calls 按序配对。 */
+function pushToolResult(history, tc, output) {
+    history.push({
+        role: 'tool',
+        tool_call_id: tc.id,
+        content: capToolResultForHistory(tc.name, output),
+    });
+}
 /**
  * agent 核心循环:
  *  流式调 LLM(onText / onThinking 实时写内容区)→ 有 tool_calls 就执行并回灌
@@ -31,10 +109,16 @@ function parseArgs(raw) {
  *  思考段用 layout.beginSegment / eraseSegmentBack 精确按物理行折叠(修预存按 \n 数行漏擦 bug),
  *  原文存入 collapsedThinkings 供 /think N 重打。
  */
-export async function runAgent(history, userInput, collapsedThinkings = [], signal) {
+export async function runAgent(history, userInput, collapsedThinkings = [], signal, 
+/** 每步 chat() 返回后回调:repl 据此重算并重画状态行 context 用量条(运行中实时刷新,不冻结在轮首)。 */
+onContextUpdate) {
     // 中断回滚快照:入口(本 turn push 任何消息前)整段浅拷贝。abort 时 length=0;push(...saved) 还原。
     // 用 slice() 而非 length:maybeCompact 会原地重建(length=0;push(...rebuilt)),savedLen 会失效。
     const savedHistory = history.slice();
+    // 本轮计时:从入口到完毕(正常 return / 达上限),供 finally 打 ✻ Worked for 摘要行。
+    // 与 layout 的 turnStart 各自独立(差几毫秒),避免 agent 反向读 layout 状态的耦合。
+    const t0 = Date.now();
+    let done = false; // 正常完毕 / 达上限 true;中断 false(不显摘要)
     history.push({ role: 'user', content: userInput });
     // 开新轮次(回滚用):首行截断 40,供 /rollback 轮次菜单展示。
     beginTurn(truncateDisplay(userInput.split('\n')[0] ?? '', 40));
@@ -138,6 +222,8 @@ export async function runAgent(history, userInput, collapsedThinkings = [], sign
             }
             contextState.lastUsage = result.usage; // 供 /context 与状态行显示实测 token
             spinner.stop();
+            // lastUsage 已更新:触发状态行 context 用量条重算+重画,运行中不再冻结在轮首。
+            onContextUpdate?.();
             if (result.toolCalls.length > 0) {
                 // 思考后直接进入 tool_call(无 text):先把可见的思考段折叠
                 flushThinkCollapsed();
@@ -154,68 +240,50 @@ export async function runAgent(history, userInput, collapsedThinkings = [], sign
                         function: { name: tc.name, arguments: tc.arguments },
                     })),
                 });
-                for (const tc of result.toolCalls) {
-                    const summary = summarizeToolCall(tc.name, tc.arguments);
-                    layout.contentWrite(`  ${ui.brightMagenta}●${ui.reset} ${ui.cyan}${tc.name}${ui.reset}  ${ui.dim}${summary}${ui.reset}\n`);
-                    const isMutation = tc.name === 'edit_file' || tc.name === 'write_file';
-                    const parsed = isMutation ? parseArgs(tc.arguments) : null;
-                    // write_file 覆盖场景:执行前读旧内容供 diff(不存在→null=新建)。
-                    // edit_file:执行前读文件定位 old_string 起始行,供 diff 显示真实文件行号。
-                    // 两者皆失败不阻断(读不到则 diff 退化为相对行号 / 不渲染)。
-                    let preWriteOld = null;
-                    let editStartLine = 1;
-                    if (parsed) {
-                        const p = String(parsed.path ?? '');
-                        if (p) {
-                            if (tc.name === 'write_file') {
-                                try {
-                                    preWriteOld = readFileSync(resolve(p), 'utf8');
-                                }
-                                catch {
-                                    preWriteOld = null; // 文件不存在(新建)或不可读
-                                }
-                            }
-                            else if (tc.name === 'edit_file') {
-                                const oldStr = String(parsed.old_string ?? '');
-                                try {
-                                    const data = readFileSync(resolve(p), 'utf8');
-                                    const idx = oldStr ? data.indexOf(oldStr) : -1;
-                                    if (idx >= 0)
-                                        editStartLine = data.slice(0, idx).split('\n').length;
-                                }
-                                catch {
-                                    // 读不到:startLine 保持 1(diff 退化为相对行号)
-                                }
-                            }
+                // 工具分组执行(保 tool_calls 原顺序):连续的只读工具(READ_TOOL_NAMES)成组并发——一次性启动全部
+                // executeTool(调用即开始 I/O),再按原顺序逐个 await + 渲染(● 头与 ↳ 结果紧邻,修并行时"全 ● 后全 ↳"分离)。
+                // mutation(write_file/edit_file)及 run_command/use_skill 各为单步串行屏障——mutation 串行保
+                // recordMutation 调用序 = 回滚快照序(executeTool 内写前记 before 快照,同文件多次写需按序)。
+                // 渲染与 history 回灌一律按原顺序;并发只影响执行时序,tool_call_id 仍按序配对。
+                // executeTool 永不抛错(调度器 try/catch 返字符串),故 await 单个 promise 不会抛(永远 resolve 为字符串)。
+                const calls = result.toolCalls;
+                let i = 0;
+                while (i < calls.length) {
+                    if (READ_TOOL_NAMES.has(calls[i].name)) {
+                        // 收集连续只读组(≥1),并发执行:先一次性启动所有(executeTool 调用即开始 I/O),
+                        // 再按原顺序逐个 await + 渲染——● 头与 ↳ 结果紧邻、顺序 = tool_calls 序(修"全 ● 后全 ↳"分离 bug)。
+                        // 异步工具(web_fetch 等)并发跑、总耗时 ≈ 最慢一个;同步工具(glob/grep)map 时已顺序跑完,await 即返。
+                        let j = i;
+                        while (j < calls.length && READ_TOOL_NAMES.has(calls[j].name))
+                            j++;
+                        const batch = calls.slice(i, j);
+                        const started = batch.map((tc) => executeTool(tc.name, tc.arguments));
+                        for (let k = 0; k < batch.length; k++) {
+                            const tc = batch[k];
+                            writeToolHeader(tc);
+                            spinner.start(`执行 ${tc.name}`);
+                            const output = await started[k];
+                            spinner.stop();
+                            writeToolResult(tc, output, null, null, 1); // 只读工具无 diff
+                            pushToolResult(history, tc, output);
                         }
-                    }
-                    spinner.start(`执行 ${tc.name}`);
-                    const output = await executeTool(tc.name, tc.arguments);
-                    spinner.stop();
-                    // edit_file / write_file 成功:渲染 diff 块(行号 + 语法高亮,仿 Claude Code);其余工具走一行 preview。
-                    if (isMutation && parsed && !output.startsWith('错误')) {
-                        layout.contentWrite(renderFileChange({
-                            path: String(parsed.path ?? ''),
-                            kind: tc.name === 'edit_file' ? 'edit' : 'write',
-                            oldStr: tc.name === 'edit_file'
-                                ? String(parsed.old_string ?? '')
-                                : preWriteOld,
-                            newStr: String((tc.name === 'edit_file' ? parsed.new_string : parsed.content) ??
-                                ''),
-                            startLine: tc.name === 'edit_file' ? editStartLine : 1,
-                        }));
+                        i = j;
                     }
                     else {
-                        const preview = summarizeToolResult(tc.name, output);
-                        if (preview) {
-                            layout.contentWrite(`  ${ui.gray}↳ ${preview}${ui.reset}\n`);
-                        }
+                        // 单步串行(mutation / run_command / use_skill)——逐个执行,保快照序
+                        const tc = calls[i];
+                        writeToolHeader(tc);
+                        const parsed = isMutationTool(tc.name)
+                            ? parseArgs(tc.arguments)
+                            : null;
+                        const { preWriteOld, editStartLine } = readDiffContext(tc, parsed);
+                        spinner.start(`执行 ${tc.name}`);
+                        const output = await executeTool(tc.name, tc.arguments);
+                        spinner.stop();
+                        writeToolResult(tc, output, parsed, preWriteOld, editStartLine);
+                        pushToolResult(history, tc, output);
+                        i++;
                     }
-                    history.push({
-                        role: 'tool',
-                        tool_call_id: tc.id,
-                        content: capToolResultForHistory(tc.name, output),
-                    });
                 }
                 continue; // 带着工具结果再调一次 LLM
             }
@@ -227,11 +295,17 @@ export async function runAgent(history, userInput, collapsedThinkings = [], sign
             if (!gotText)
                 layout.contentWrite(`${ui.dim}(无回复)${ui.reset}\n`);
             history.push({ role: 'assistant', content: result.content });
+            done = true;
             return;
         }
         layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}达到最大步数(${MAX_STEPS}),本轮停止。${ui.reset}\n`);
+        done = true;
     }
     finally {
         spinner.stop();
+        // 跑完(正常 / 达上限)在回复末尾打耗时摘要行(仿 Claude Code);中断 done=false 不打。
+        if (done) {
+            layout.contentWrite(`  ${ui.dim}✻ Worked for ${fmtElapsed(Date.now() - t0)}${ui.reset}\n`);
+        }
     }
 }

package/dist/config/index.js

@@ -49,9 +49,11 @@ const SYSTEM_PROMPT = `你是 mocode,一个终端编码 agent。你以"思考
 - 改代码前先 read_file 确认实际内容(带行号),不凭记忆猜。
 - 局部改用 edit_file:old_string 须唯一且精确匹配(含缩进/换行),多带上下文行确保唯一;新建或整体重写用 write_file。
 - 找路径用 glob,找内容用 grep;不要用 run_command 拼 cat / sed / find / grep。
+- 若当前目录存在 .codegraph/(已建代码索引),理解/定位代码、查调用链、看改动影响面时必须先 codegraph 再动手:run_command 跑 codegraph explore "<符号或问题>"(一次拿相关符号源码 + 调用路径)或 codegraph node <符号或文件>(单符号源码 + 调用者)。不要逐文件 glob/read_file/grep 去拼凑理解——那是 codegraph 已替你做完的事。仅当 codegraph 找不到、未索引、要看刚改的最新内容、或改单个已知小文件时才用 read_file/grep/glob。详见 use_skill codegraph。
 - run_command 按平台执行(Win 用 cmd、其他用 bash);有副作用的命令(删文件、装包、git push、重置等)执行前先简述意图。
 - 需要训练数据之外的最新信息(新版本、新闻、实时数据、最新 API)时用 web_search 联网搜索,不要凭记忆答可能过时的内容。
 - 要读取某个具体 URL 的内容(搜索结果里的链接、用户给的 URL)时用 web_fetch 抓取;它只抓静态 HTML,JS 渲染页面拿不到正文时改用 web_search(其结果自带清洗后的正文)。
+- 遇到需要用户决策的岔路(多种实现方案、不确定用户意图、需要额外信息才能继续),调 ask_human 列出选项让用户选(用户也可选"自定义输入"自由作答)。不要在任务明确、能自行决定时频繁打扰用户;用户取消后换方案或基于已有信息推进,不原地重复问。
 
 ## 失败处理
 - 工具以字符串返回错误(edit_file 未匹配或不唯一、run_command 非零退出码等)。先分析根因,调整后重试,不要原样重发同一条调用。
@@ -61,6 +63,13 @@ const SYSTEM_PROMPT = `你是 mocode,一个终端编码 agent。你以"思考
 - 不可逆或外向操作(删除、覆盖既有文件、推送、请求外部服务)执行前向用户确认,除非已获明确授权。
 - 只在授权范围内操作;不确定就问,别猜。
 
+## 记忆(跨会话长期事实)
+- 系统提示已注入「记忆索引」(仅 id/标题/摘要)。需要某条正文时调 memory_search(传 id 或关键词)取;memory_list 看全部索引。
+- 遇到非显然、跨会话有用的事实/决策/坑(架构约定、易踩坑、用户偏好、已做决策),用 memory_save 存——只存长期稳定项,不存当前 bug / 临时文件 / 未决 TODO。
+- 发现已存记忆过时或与新事实矛盾,用 memory_update(id, …) 原地纠正(别新建重复条);明确失效的用 memory_forget(id) 归档。
+- 存前先 memory_search 看是否已有同类条,避免重复。宁可少记,不记正确废话。
+- 后台反思 pass 会定期从会话里挖掘并整理记忆(无需你手动),但你主动存的关键事实更可靠。
+
 ## 终止与汇报
 - 无需更多工具时立即停止,直接给结论。
 - 如实汇报:成功说成功,失败说卡在哪,跳过的也要说。引用代码用 "path:行号" 格式(如 src/index.ts:42)。保持简洁。`;
@@ -74,6 +83,8 @@ export const config = {
     compactThreshold: Number(process.env.COMPACT_THRESHOLD) || 0.85,
     includeUsage: process.env.LLM_STREAM_USAGE !== 'false',
     autoCompact: process.env.AUTO_COMPACT !== 'false',
+    autoReflect: process.env.AUTO_REFLECT !== 'false',
+    reflectEveryN: Number(process.env.REFLECT_EVERY_N) || 5,
     sessionDir: path.join(process.cwd(), '.mocode', 'sessions'),
     searchApiKey: process.env.ANYSEARCH_API_KEY,
     searchBaseUrl: process.env.ANYSEARCH_BASE_URL || 'https://api.anysearch.com',

package/dist/memory/discover.js

@@ -0,0 +1,49 @@
+// memory 发现子系统:加载项目记忆 MOCODE.md(对标 skills/discover.ts 的叶子模式)。
+// 仅依赖 node 标准库,是叶子模块:不依赖 config/agent/llm/tools/skills,避免环。
+//
+// 约定:纯 MOCODE.md(不读 CLAUDE.md——mocode 是独立工具,接非 Claude 后端,
+// 有自己的工具集与约定,叫 CLAUDE.md 名不副实且可能读到 Claude 专属内容)。
+// 项目级从 cwd 向上逐级找,全局 ~/.mocode/MOCODE.md。全量注入 systemPrompt(超长截断);
+import { existsSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * 返回要查找的 MOCODE.md 路径列表,按「远→近」顺序(合并时近的在后,更突出):
+ * 全局 ~/.mocode/MOCODE.md → 项目级从根到 cwd 逐级 MOCODE.md。
+ * 向上遍历 cwd 到根收集 [cwd..root],反转为 [root..cwd](远→近),前拼全局。
+ */
+export function resolveMemoryFiles() {
+    const globalPath = path.join(os.homedir(), '.mocode', 'MOCODE.md');
+    const projectFiles = [];
+    let dir = process.cwd();
+    const root = path.parse(dir).root; // win32 'C:\\', POSIX '/'
+    for (;;) {
+        projectFiles.push(path.join(dir, 'MOCODE.md'));
+        if (dir === root || dir === path.dirname(dir))
+            break; // 到根:dirname 自身
+        dir = path.dirname(dir);
+    }
+    projectFiles.reverse(); // root..cwd(远→近)
+    return [globalPath, ...projectFiles];
+}
+/**
+ * 读取所有存在的 MOCODE.md,返回 { path, content }(content 已 trim)。
+ * 全程静默容错(不存在 / 读失败 → 跳过,不抛),风格对齐 skills/discover.ts 与 session/persist.ts。
+ */
+export function loadMemoryFiles() {
+    const files = resolveMemoryFiles();
+    const out = [];
+    for (const p of files) {
+        try {
+            if (!existsSync(p))
+                continue;
+            const content = readFileSync(p, 'utf8').trim();
+            if (content)
+                out.push({ path: p, content });
+        }
+        catch {
+            continue; // 读失败静默跳过
+        }
+    }
+    return out;
+}

package/dist/memory/index.js

@@ -0,0 +1,45 @@
+// memory barrel:Tier-1 MOCODE.md 懒加载(buildMemorySection,叶子)+ Tier-2 工具库 re-export。
+// 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';
+export { buildMemoryIndexSection, loadAll, gcMemories, } from './store.js';
+export { kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, runReflection, } from './reflect.js';
+/** system 消息中 memory 段的字符上限(防过大占窗口——system 在 history[0],compactHistory 不压缩)。 */
+const MAX_MEMORY_CHARS = 20000;
+let cache = null;
+/**
+ * 合并全局 + 项目各级 MOCODE.md(远→近拼接,各段空行分隔),超 MAX_MEMORY_CHARS 截断 + 提示。
+ * 懒加载(首次调用触发扫描;启动期 repl 调一次)。无 MOCODE.md 返空串。
+ */
+export function loadMemory() {
+    if (cache !== null)
+        return cache;
+    const files = loadMemoryFiles();
+    if (files.length === 0) {
+        cache = '';
+        return cache;
+    }
+    const body = files.map((f) => f.content).join('\n\n');
+    if (body.length <= MAX_MEMORY_CHARS) {
+        cache = body;
+    }
+    else {
+        cache =
+            body.slice(0, MAX_MEMORY_CHARS) +
+                `\n\n…(项目记忆已截断 ${body.length - MAX_MEMORY_CHARS} 字符,完整见各级 MOCODE.md)`;
+    }
+    return cache;
+}
+/** 拼进系统提示的 memory 段;无 memory 返空串(零行为变化)。 */
+export function buildMemorySection() {
+    const mem = loadMemory();
+    if (!mem)
+        return '';
+    return [
+        '',
+        '',
+        '## 项目记忆(MOCODE.md)',
+        '以下是项目记忆(架构 / 约定 / 命令等跨会话长期事实),据此行动:',
+        mem,
+    ].join('\n');
+}