mocode-ai 1.2.4 → 1.2.6

package/README.md

@@ -79,7 +79,7 @@ MoCode isn't a chat box with a coat of paint — it's an agent that actually get
 - **Plan / Auto dual mode** — In `plan` mode the agent is read-only (reads code, queries indexes, searches — never writes to disk, runs commands, or spawns sub-agents) and produces a plan; `auto` mode unlocks the full toolset. The agent can switch between the two on its own — scope out an unfamiliar codebase first, then start making changes.
 - **Pressure-driven context compression** — Normal history keeps full tool evidence. At 80% occupancy, one scheduler event runs all enabled cleanup and always follows with a history summary. `/context` shows live usage and `/compact` remains an explicit manual override.
 - **Cross-session long-term memory** — The agent can save project architecture, conventions, and lessons learned as long-term memory, auto-loaded in future sessions. A background process periodically reflects on conversations to mine things worth remembering. Memories can be created, searched, updated, and forgotten, with recall-based decay.
-- **Project context (`MOCODE.md`)** — A single project-level memory file at `MOCODE.md` captures both static facts (project description, commands, module list, directory tree) and human/AI-written insights (conventions, architectural decisions, pitfalls). Generate it once with `/init`, then keep it up to date by hand or by asking the agent to refresh it. Loaded automatically into the system prompt on every turn.
+- **Project context (`AGENTS.md`)** — A single project-level memory file at `AGENTS.md` captures both static facts (project description, commands, module list, directory tree) and human/AI-written insights (conventions, architectural decisions, pitfalls). Generate it once with `/init`, then keep it up to date by hand or by asking the agent to refresh it. Loaded automatically into the system prompt on every turn.
 - **Session notepad (notes.md)** — For complex multi-step tasks (≥3 file changes / ≥5 tool calls), the agent maintains a working notepad at `.mocode/sessions/<sessionId>/notes.md` (file-based, survives context compression). It records the execution plan with the dedicated `plan_update` tool — a three-state step machine (`pending`/`in_progress`/`completed`, at most one `in_progress`) that auto-settles to `## Done:` when finished. The active plan is re-injected into the system prompt after compaction and re-synced into context whenever notes.md changes, and a gentle reminder nudges the agent if it goes several tool-steps without updating the plan. A live progress chip in the TUI status bar shows `plan: [title] (3/7) ▸ [current step]`.
 - **Interruptible and reversible** — Ctrl+C interrupts the current turn at any time (kills child processes recursively, rolls history back to before the turn started, leaves no half-finished tool calls). `/rollback` restores file changes from per-turn snapshots, with a per-file keep/undo choice — no git dependency required.
 - **Sandbox protection** — File reads/writes go through a sandbox that blocks out-of-bounds paths (`../../`, absolute paths outside the root, symlink escapes, etc.), so the agent never touches files outside your working directory.
@@ -96,7 +96,7 @@ MoCode isn't a chat box with a coat of paint — it's an agent that actually get
 ## Documentation
 
 - [中文使用指南](./docs/usage.md) — 菜单式快速上手、命令速查、模式、会话、项目上下文与排障。
-- [Project context](./docs/usage.md#项目上下文) — `MOCODE.md` and Skills.
+- [Project context](./docs/usage.md#项目上下文) — `AGENTS.md` and Skills.
 
 ## Installation
 
@@ -218,7 +218,7 @@ The agent operates in **the working directory it was launched from** — to have
 | `memory_update`     | Edit a memory in place (id unchanged; correct stale facts / update summary / toggle pin) |
 | `memory_forget`     | Forget a memory: archived by default (recoverable), `mode=delete` for a hard delete (pinned memories can't be deleted) |
 
-The five `memory_*` tools are gated on `MEMORY_ENABLED=true` at startup; toggle at runtime with `/memory_switch` (REPL restart required, by design — see Skills section for the difference between Tier-1 `MOCODE.md` and Tier-2 memory).
+The five `memory_*` tools are gated on `MEMORY_ENABLED=true` at startup; toggle at runtime with `/memory_switch` (REPL restart required, by design — see Skills section for the difference between Tier-1 `AGENTS.md` and Tier-2 memory).
 
 The four frontend tools — `browser`, `dev_server`, `screenshot`, `view_image` — are **off by default** (they depend on the Playwright binary, spawn long-lived processes, or capture the desktop). Enable the whole cluster at runtime with `/fe on`; the model only sees them once enabled. Toggle with `/fe on|off|status`.
 
@@ -254,7 +254,7 @@ dev_server stop   id=srv-xxxx
 | `/memory_switch`   | Toggle Tier-2 memory on/off (REPL restart required — by design)       |
 | `/reflect`          | Manually trigger a background memory reflection pass                  |
 | `/model`            | Configure the LLM (baseURL / apiKey / model / context window), applied immediately + persisted |
-| `/init`             | Scan the project and generate `MOCODE.md` project memory (dispatched to the agent) |
+| `/init`             | Scan the project and generate `AGENTS.md` project memory (dispatched to the agent) |
 | `/theme`            | Switch color theme (↑↓ · Enter, or `/theme <name>` directly)         |
 | `/plan`             | Switch to plan mode (read-only exploration + plan output, approve to switch to auto) |
 | `/auto`             | Switch back to auto mode (full toolset execution)                     |
@@ -293,11 +293,11 @@ A skill's `description` is injected into the system prompt (progressive disclosu
 
 The system prompt provides lightweight guidance rather than a framework gate: inspect only what matters, make focused changes, avoid repeated stale reads, and report uncertainty honestly. The agent decides whether validation is useful for the task and chooses the scope itself. Broad test/build suites are not run by default, and lack of validation never blocks completion or triggers an extra model turn.
 
-## Project memory (MOCODE.md)
+## Project memory (AGENTS.md)
 
 MoCode has a **two-tier memory** model distinct from skills:
 
-- **Tier-1 — `MOCODE.md` (auto-loaded every session):** Markdown project memory that gets concatenated into the system prompt on every turn. Discovery walks `~/.mocode/MOCODE.md` → every `MOCODE.md` from the cwd up to the filesystem root (far→near, near wins). On overflow the body is truncated with a marker pointing back at the files. Generate or refresh one with `/init`, or write it by hand — it's plain Markdown, no schema. `MOCODE.md` is also where the agent itself persists "next-session facts" it deduces (architecture, conventions, pitfalls).
+- **Tier-1 — `AGENTS.md` (auto-loaded every session):** Markdown project memory that gets concatenated into the system prompt on every turn. Discovery walks `~/.mocode/AGENTS.md` → every `AGENTS.md` from the cwd up to the filesystem root (far→near, near wins). On overflow the body is truncated with a marker pointing back at the files. Generate or refresh one with `/init`, or write it by hand — it's plain Markdown, no schema. `AGENTS.md` is also where the agent itself persists "next-session facts" it deduces (architecture, conventions, pitfalls).
 - **Tier-2 — `memory_*` tool library (agent-driven, opt-in):** Discrete tagged records (`decision` / `fact` / `pitfall` / `reference` / `feedback`) with recall-count-based decay (30-day → archived; 90-day → GC). The agent saves / searches / updates / forgets via tools; titles go in the system-prompt index (≤50), bodies fetched on demand via `memory_search`. Off by default; toggle with `MEMORY_ENABLED=true` at startup or `/memory_switch` (REPL restart required).
 
 ## Type checking

package/README.zh-CN.md

@@ -95,7 +95,7 @@ mocode 不是一个套壳聊天框,而是一个能真正动手干活的 agent:
 ## 使用文档
 
 - [菜单式使用指南](./docs/usage.md) — 快速上手、命令速查、模式、会话、项目上下文与排障。
-- [项目上下文：`MOCODE.md` 与 Skills](./docs/usage.md#项目上下文)
+- [项目上下文：`AGENTS.md` 与 Skills](./docs/usage.md#项目上下文)
 
 ## 安装
 
@@ -257,7 +257,7 @@ dev_server stop   id=srv-xxxx
 | `/memory_switch` | 切换 Tier-2 记忆开关(需重启 REPL,刻意为之)                  |
 | `/reflect`      | 手动触发一次后台记忆反思 pass                                   |
 | `/model`        | 配置大模型(baseURL / apiKey / model / 上下文窗口),即时生效 + 持久化 |
-| `/init`         | 扫描项目生成 `MOCODE.md` 项目记忆(发给 agent 执行)               |
+| `/init`         | 扫描项目生成 `AGENTS.md` 项目记忆(发给 agent 执行)               |
 | `/theme`        | 切换颜色主题(↑↓ · Enter,或 `/theme <name>` 直切)            |
 | `/plan`         | 切到 plan 模式(只读探查 + 产出计划,审批后切 auto 执行)              |
 | `/auto`         | 切回 auto 模式(全量工具执行)                                  |
@@ -296,11 +296,11 @@ skill 的 `description` 注入系统提示(渐进式披露第①层),模型只
 
 system prompt 提供轻量建议而不是框架硬门：只检查支持下一步决策的内容，做最小完整改动，避免重复读取，并诚实说明不确定性。agent 自主决定是否需要验证以及验证范围；框架不会因为未验证阻止完成或追加模型轮次。
 
-## 项目记忆(MOCODE.md)
+## 项目记忆(AGENTS.md)
 
 mocode 的**双层记忆**模型,跟 Skills 是两件事:
 
-- **Tier-1 — `MOCODE.md`(每轮自动加载):** Markdown 项目记忆,每轮拼进 system prompt。发现路径:`~/.mocode/MOCODE.md` → 从 cwd 往上逐级 `MOCODE.md`(远→近拼接,近的覆盖更突出);超长截断并标注原始文件。运行 `/init` 生成或刷新,纯 Markdown,可手写,无 schema。agent 自己推得的「下次要记住的事实」(架构/约定/坑位)也写在这里。
+- **Tier-1 — `AGENTS.md`(每轮自动加载):** Markdown 项目记忆,每轮拼进 system prompt。发现路径:`~/.mocode/AGENTS.md` → 从 cwd 往上逐级 `AGENTS.md`(远→近拼接,近的覆盖更突出);超长截断并标注原始文件。运行 `/init` 生成或刷新,纯 Markdown,可手写,无 schema。agent 自己推得的「下次要记住的事实」(架构/约定/坑位)也写在这里。
 - **Tier-2 — `memory_*` 工具库(agent 主导,需启用):** 离散带标签条目(`decision` / `fact` / `pitfall` / `reference` / `feedback`),按召回计数衰减(30 天 → archived,90 天 → 硬删 GC)。agent 用工具存 / 搜 / 改 / 删;索引(标题)进系统提示(≤50 条),正文按需 `memory_search` 取。默认关,启动 `MEMORY_ENABLED=true` 或 REPL 内 `/memory_switch`(需重启 REPL,刻意为之)。
 
 ## 类型检查

package/dist/agent/core.js

@@ -7,7 +7,7 @@
 import { readFileSync } from 'node:fs';
 import { getNotesMtime } from '../session/notes.js';
 import { chat, estimatePromptTokens, planChatTools, chatTools, } from '../llm/index.js';
-import { executeToolOutcome, getToolCapabilities, isFileMutationTool, tools, } from '../tools/registry.js';
+import { executeToolOutcome, findTool, getToolCapabilities, isFileMutationTool, } from '../tools/registry.js';
 import { checkPermission } from '../permissions/index.js';
 import { validateToolArguments } from '../tools/validation.js';
 import { getPlanDisabledTools, getRuntimeDisabledTools } from '../tools/constants.js';
@@ -18,7 +18,7 @@ import { createBudgetScheduler } from '../session/scheduler.js';
 import { recordArtifact, invalidateArtifacts, rehydrateArtifacts, } from '../context/index.js';
 import { createRelevancePruner } from '../context/relevance.js';
 import { isToolResultSuccess } from '../context/utils.js';
-import { config, extractActivePlanSection, reinjectActivePlanIntoSystem } from '../config/index.js';
+import { config, extractActivePlanSection, reinjectSessionStateIntoSystem } from '../config/index.js';
 import { t } from '../i18n/index.js';
 import { jailResolve } from '../sandbox/index.js';
 import { createLifecycleEngine } from '../context/lifecycle.js';
@@ -42,13 +42,13 @@ function parseArgs(raw) {
 }
 /** 只有显式声明 parallel 且无需权限确认的工具才进入普通并发组。 */
 function isParallelTool(name) {
-    const tool = tools.find((candidate) => candidate.name === name);
+    const tool = findTool(name);
     return !!tool && (tool.risk ?? 'safe') === 'safe' &&
         getToolCapabilities(tool).concurrency === 'parallel';
 }
 /** resource-locked 工具先顺序完成权限预检，再依赖 canonical resource lock 并发执行。 */
 function isResourceLockedTool(name) {
-    const tool = tools.find((candidate) => candidate.name === name);
+    const tool = findTool(name);
     return !!tool && getToolCapabilities(tool).concurrency === 'resource-locked';
 }
 function isResourceLockedCall(call) {
@@ -326,8 +326,8 @@ export async function runAgentCore(opts) {
                         runtimeContextState.lifecycleStats = lifecycle.stats();
                     }
                     rehydrateArtifacts(runtimeContextState, history);
-                    // ② compact 后把活跃 plan 重注入系统提示，避免 agent 因上下文压缩丢失执行计划。
-                    reinjectActivePlanIntoSystem(history);
+                    // ② compact 后把会话状态(活跃 plan + 笔记段)重注入系统提示，避免 agent 因上下文压缩丢失计划与笔记。
+                    reinjectSessionStateIntoSystem(history);
                 }
                 hooks.onStepStart?.(); // 主 agent:spinner.start('思考中')
                 mode = 'idle';
@@ -602,7 +602,7 @@ export async function runAgentCore(opts) {
                             for (let k = 0; k < batch.length; k++) {
                                 const tc = batch[k];
                                 const parsed = parseArgs(tc.arguments);
-                                const tool = tools.find((candidate) => candidate.name === tc.name);
+                                const tool = findTool(tc.name);
                                 const argumentsValid = tool && parsed !== null
                                     ? validateToolArguments(tool, parsed).valid
                                     : false;
@@ -693,7 +693,7 @@ export async function runAgentCore(opts) {
                             // 权限预检查:在渲染 ● 头之前弹确认面板(体验:先问再执行,而非执行完再问)。
                             // 拒绝时只渲染拒绝结果,不渲染执行头;放行则继续走 header → start → executeTool 流程。
                             const parsed = parseArgs(tc.arguments);
-                            const tool = tools.find((t) => t.name === tc.name);
+                            const tool = findTool(tc.name);
                             const argumentsValid = tool && parsed !== null
                                 ? validateToolArguments(tool, parsed).valid
                                 : false;
@@ -768,7 +768,7 @@ export async function runAgentCore(opts) {
                     // B(nag 提醒):连续 N 步有工具活动但没更新 plan,在当前步第一条 tool_result 前注入提醒。
                     const notesMtimeAfter = getNotesMtime();
                     if (notesMtimeAfter !== notesMtimeBefore) {
-                        reinjectActivePlanIntoSystem(history);
+                        reinjectSessionStateIntoSystem(history);
                         stepsSincePlanTouch = 0;
                     }
                     else {

package/dist/config/index.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import dotenv from 'dotenv';
 import { getCurrentSessionId } from '../session/state.js';
-import { getNotesFilePath } from '../session/notes.js';
+import { getNotesFilePath, extractActiveNotesSections } from '../session/notes.js';
 import { buildWorkDisciplineSection, inferModelFamily } from '../agent/work-discipline.js';
 import { detectLanguage, setLanguage, t, } from '../i18n/index.js';
 /**
@@ -214,19 +214,81 @@ export function reinjectActivePlanIntoSystem(history) {
     sys.content = `${content}${ACTIVE_PLAN_MARKER}${plan}\n`;
     return true;
 }
+/** compact 重注入用的幂等标记:history[0] 中夹住会话笔记段正文(Findings/Decisions/Open Questions/Risks),
+ *  重复注入只替换不累积。与 ACTIVE_PLAN_MARKER 独立,互不干扰。 */
+const NOTES_BODY_MARKER = '\n\n<!-- mocode:session-notes -->\n';
+/**
+ * 把会话笔记段正文重注入系统提示(history[0])。compact 后或本步改了 notes.md 时调用:
+ * 若 notes.md 有活跃笔记段(extractActiveNotesSections 返回非空,已按 5k token 预算裁剪),
+ * 则覆盖旧标记块写入最新内容;若无,则清掉残留标记块。直接改 history[0].content,
+ * 幂等,返回是否改动。与 reinjectActivePlanIntoSystem 独立:plan 段由后者管,笔记段由本函数管。
+ */
+export function reinjectSessionNotesIntoSystem(history) {
+    const sys = history[0];
+    if (!sys || sys.role !== 'system' || typeof sys.content !== 'string')
+        return false;
+    let content = sys.content;
+    const markerIdx = content.indexOf(NOTES_BODY_MARKER);
+    if (markerIdx >= 0) {
+        content = content.slice(0, markerIdx).replace(/\s+$/, '');
+    }
+    const notes = extractActiveNotesSections();
+    if (!notes) {
+        if (markerIdx < 0)
+            return false;
+        sys.content = content;
+        return true;
+    }
+    sys.content = `${content}${NOTES_BODY_MARKER}${notes}\n`;
+    return true;
+}
+/**
+ * 一次性重注入会话状态(plan 段 + 笔记段)到系统提示。调用点(core.ts compact 后 /
+ * 本步改 notes.md、repl compact 时)统一用本函数替代 reinjectActivePlanIntoSystem,
+ * 让笔记段享有与 plan 段完全对称的常驻 + 恢复时机。返回任一 marker 是否改动。
+ */
+export function reinjectSessionStateIntoSystem(history) {
+    const planChanged = reinjectActivePlanIntoSystem(history);
+    const notesChanged = reinjectSessionNotesIntoSystem(history);
+    return planChanged || notesChanged;
+}
 const SYSTEM_PROMPT_MEMORY_SECTION = `
 ## Memory (cross-session facts)
-- The prompt may contain a title/summary index; retrieve details with memory_search or inspect all with memory_list.
-- Save only stable, non-obvious cross-session facts. Search before saving; update an existing entry instead of duplicating it, and archive stale entries.`;
-/** Inject only retrieval guidance; MOCODE.md contents stay outside the prompt until read on demand. */
+- The prompt may contain a title/summary index; retrieve details with memory_search or inspect all with memory_list. memory_search also surfaces knowledge-graph facts (relations between entities) alongside entry bodies.
+- Save only stable, non-obvious cross-session facts. Search before saving; update an existing entry instead of duplicating it, and archive stale entries.
+- A knowledge-graph layer links entities across memories: explore relations/neighbors with memory_graph (neighbors/add/stats), and attach meaningful links via the links parameter of memory_save when saving.`;
+/** AGENTS.md 自动导入正文上限:system 位于 history[0] 且 compactHistory 不压缩 system,超长需截断防占窗口(见 memory/README.md)。 */
+const MAX_AGENTS_IMPORT_CHARS = 20000;
+/**
+ * 工作区根 AGENTS.md 自动导入段:与 memory 开关完全无关——
+ * 只要 <cwd>/AGENTS.md 存在就把正文直接拼进 prompt(超 {@link MAX_AGENTS_IMPORT_CHARS} 截断+末尾提示),
+ * 不再只指路让模型按需 read_file。读失败静默跳过(返空串)。
+ */
+function buildAgentsImportSection() {
+    try {
+        const projectAgents = path.join(process.cwd(), 'AGENTS.md');
+        if (!fs.existsSync(projectAgents))
+            return '';
+        const content = fs.readFileSync(projectAgents, 'utf8').trim();
+        if (!content)
+            return '';
+        const body = content.length > MAX_AGENTS_IMPORT_CHARS
+            ? `${content.slice(0, MAX_AGENTS_IMPORT_CHARS)}\n…[AGENTS.md truncated: first ${MAX_AGENTS_IMPORT_CHARS} characters injected]`
+            : content;
+        return `\n## Project memory (AGENTS.md, auto-imported)\n${body}\n- AGENTS.md may be stale: current code and the user request override stale memory.`;
+    }
+    catch {
+        return ''; // 读失败静默跳过:不让导入破坏 prompt 构建
+    }
+}
+/**
+ * Memory 检索指导段(与 AGENTS.md 导入无关):开 isMemoryEnabled() 时才拼,
+ * 注入 memory_search/list/graph 的使用指导。默认关(新用户零侵入)。
+ */
 function buildMemoryPromptSection() {
     if (!isMemoryEnabled())
         return '';
-    const projectMocode = path.join(process.cwd(), 'MOCODE.md');
-    const mocodeHint = fs.existsSync(projectMocode)
-        ? '\n- `MOCODE.md` exists at the workspace root but is not preloaded. Read it with `read_file` only when the task may depend on project architecture, conventions, commands, prior decisions, or user preferences; skip it for greetings and unrelated simple requests. Current code and the user request override stale memory.'
-        : '';
-    return SYSTEM_PROMPT_MEMORY_SECTION + mocodeHint;
+    return SYSTEM_PROMPT_MEMORY_SECTION;
 }
 /**
  * plan 模式追加到系统提示末尾的指令(切到 plan 模式时由 repl 拼进 history[0])。
@@ -257,6 +319,7 @@ ${buildPlanResearchRules()}`;
 }
 /** 兼容旧名字:repl 的 buildSystemMessage 仍引 PLAN_MODE_SUFFIX(变量)。运行时按需现拼。 */
 export function buildBasePrompt(sessionId = getCurrentSessionId()) {
+    const agentsImportSection = buildAgentsImportSection();
     const memorySection = buildMemoryPromptSection();
     const notepadSection = buildNotepadSection(sessionId);
     // 静态主体:稳定段落集中在前,让支持 prompt caching 的后端能命中前缀缓存(#12)。
@@ -312,9 +375,9 @@ ${buildVoiceSection()}
 - **No flattery / no preamble in conclusions**: skip "Sure", "好的", "我已经完成了" and similar no-information prefixes — jump straight to substance.
 - Report honestly: say success when successful, say where you're stuck when failing, and mention anything skipped. Reference code in "path:line" format (e.g., src/index.ts:42). Keep it concise.
 ${t('assistant.languageInstruction')}`;
-    // 动态段(置于末尾):memory 索引 + notepad 索引 + notepad 使用说明。
+    // 动态段(置于末尾):AGENTS.md 项目记忆(无条件) + memory 索引(按开关) + notepad 索引 + notepad 使用说明。
     // 按需注入(#13):有内容的索引才拼对应标题,避免空标题噪声。
-    //   - "## Project context" 仅当 memorySection/notepadSection 非空(notepad 索引依赖 notes.md 存在);
+    //   - "## Project context" 仅当 agentsImportSection/memorySection/notepadSection 任一非空(notepad 索引依赖 notes.md 存在);
     //   - "## Session state" 使用说明**无条件**注入(放在动态尾段首位):否则会陷入"说明依赖 notes.md 存在 → 模型不知要建 → 文件永不存在"的鸡生蛋循环,功能对模型不可见。动态段在静态前缀之后,不影响 prompt 缓存。
     const dynamicParts = [];
     // 会话级私有尾段(子 agent 切片会丢弃):Session state 说明无条件注入在前,Project context 按需在后。
@@ -332,8 +395,10 @@ ${t('assistant.languageInstruction')}`;
         'Keep at most one step in_progress, and mark a step completed as soon as its work is done — do not batch updates to the end of the turn. ' +
         'Write each step so a teammate who lost the conversation could pick it up cold: name the file or symbol, the exact change, and the verification, so the plan survives context compaction. ' +
         'plan_update creates notes.md for you when the task warrants it; read_file the full notes.md whenever you need to recover context after compaction. ' +
-        'When every step is completed, plan_update settles the plan to `## Done:` automatically. Keep other notes concise and session-specific; use memory for stable cross-session facts.');
-    const ctxContent = `${memorySection}${notepadSection}`.trimEnd();
+        'When every step is completed, plan_update settles the plan to `## Done:` automatically. Keep other notes concise and session-specific; use memory for stable cross-session facts.\n' +
+        '## Session notes (resident memory)\n' +
+        'For non-obvious, lasting-value discoveries — subtle constraints, decisions with downstream impact, open questions blocking a choice, or risks affecting later steps — call `note_append` IMMEDIATELY when you make the discovery. The note is written to the same notes.md and its body is re-injected into the prompt automatically (within a 5k-token budget), surviving compaction so you keep remembering what you found/decided this session. Do NOT use it for routine progress (that is the plan) or stable cross-session facts (that is memory_save). Each call appends one item.');
+    const ctxContent = `${agentsImportSection}${memorySection}${notepadSection}`.trimEnd();
     if (ctxContent) {
         dynamicParts.push(`## Project context\n${ctxContent}`);
     }

package/dist/context/classifier.js

@@ -32,6 +32,7 @@ const BY_NAME = {
     memory_save: 'status',
     memory_update: 'status',
     memory_forget: 'status',
+    memory_graph: 'status',
     // summary:子 agent 摘要(轻量)
     'sub-agent': 'summary',
 };

package/dist/context/encoders/table.js

@@ -6,7 +6,7 @@
  *  顶部加 `# N entries · table-encoded` 计数头。
  *
  * 不变量(离线脚本断言):id/name/summary/type 全保留;仅 `active` 状态被省略(默认值,无信息损失)。
- *  正则锚定整行 + 要求 `id: ... — ... (type, active)` 形,不匹配的行原样返回(防误伤 MOCODE.md 等正文)。
+ *  正则锚定整行 + 要求 `id: ... — ... (type, active)` 形,不匹配的行原样返回(防误伤 AGENTS.md 等正文)。
  *  group1 贪婪捕获到 `(\w+` 为止,故 name/summary 内含 ` — ` 或 ` (` 也不影响(仅丢尾部 `, active)`)。
  */
 const ACTIVE_LINE_RE = /^(- [^:]+: .+ — .+ \(\w+), active\)$/;

package/dist/i18n/index.js

@@ -18,7 +18,7 @@ const zhCN = {
     'commands.memoryOff': '关闭记忆子系统',
     'commands.memoryStatus': '查看当前开关与原理',
     'commands.memoryReflect': '手动触发后台记忆反思',
-    'commands.memoryInit': '扫描项目生成 MOCODE.md 项目记忆',
+    'commands.memoryInit': '扫描项目生成 AGENTS.md 项目记忆',
     'commands.subagent': '子 Agent 开关（默认关闭）',
     'commands.subagentOn': '开启子 Agent',
     'commands.subagentOff': '关闭子 Agent',
@@ -69,7 +69,7 @@ const zhCN = {
     'running.rollback': '回滚',
     'running.chooseTurn': '选择轮次…',
     'running.init': '初始化',
-    'running.generateMemory': '生成 MOCODE.md…',
+    'running.generateMemory': '生成 AGENTS.md…',
     'running.plan': '切 plan',
     'running.auto': '切 auto',
     'running.clear': '清空',
@@ -277,7 +277,7 @@ const en = {
     'commands.memoryOff': 'Disable the memory subsystem',
     'commands.memoryStatus': 'Show current state and behavior',
     'commands.memoryReflect': 'Run background memory reflection',
-    'commands.memoryInit': 'Scan project and generate MOCODE.md',
+    'commands.memoryInit': 'Scan project and generate AGENTS.md',
     'commands.subagent': 'Sub-agent controls (disabled by default)',
     'commands.subagentOn': 'Enable sub-agents',
     'commands.subagentOff': 'Disable sub-agents',
@@ -328,7 +328,7 @@ const en = {
     'running.rollback': 'Rollback',
     'running.chooseTurn': 'Choose a turn…',
     'running.init': 'Initialize',
-    'running.generateMemory': 'Generating MOCODE.md…',
+    'running.generateMemory': 'Generating AGENTS.md…',
     'running.plan': 'Plan mode',
     'running.auto': 'Auto mode',
     'running.clear': 'Clear',

package/dist/llm/index.js

@@ -180,7 +180,6 @@ export function refreshChatTools() {
     // MCP 协议没有可靠的副作用注解；plan 模式绝不暴露外部工具，保留只读探查保证。
     planChatTools.splice(0, planChatTools.length, ...next.filter((t) => !t.function.name.startsWith('mcp__') && !getPlanDisabledTools().has(t.function.name)));
 }
-refreshChatTools();
 /**
  * 多 provider 兼容的 cache / reasoning 字段提取。
  * 不同后端报 cached 字段名差异巨大,这里按"最常见的几种"顺序 probe,

package/dist/memory/discover.js

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