mocode-ai 1.2.4 → 1.2.6

package/dist/memory/graph.js

@@ -0,0 +1,409 @@
+// memory 知识图谱层(Tier-2):Graphiti 式时序三元组,纯 JSON 文件存储。
+// 叶子模块:仅依赖 node 标准库 + tools/constants(常量叶子)+ store.ts 的类型,
+// 与 store.ts 同风格:同步读写、整文件 tmp+rename 原子落盘、静默容错。
+//
+// 两文件(镜像 store.ts 的双 scope):
+//   全局  ~/.mocode/memory-graph.json
+//   项目  <cwd>/.mocode/memory-graph.json
+// 文件形如 {"entities":[...],"edges":[...]}。scope 以所在文件为准(loadAllGraph 归一化)。
+//
+// 时序语义(抄 Graphiti/Zep 的核心思想,文件实现):边带 validAt/invalidAt。
+// 新三元组与既有 active 边同(src,dst,relation)且 fact 不同 → 旧边 invalidAt=now(不删,可追溯);
+// fact 相同 → 幂等跳过。查询默认只看 active(invalidAt==null)。
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { MAX_GRAPH_EDGES, MAX_GRAPH_ENTITIES } from '../tools/constants.js';
+// ── 路径 / 原子写(同 store.ts 风格)──────────────────────────────────────
+function globalGraphPath() {
+    return path.join(os.homedir(), '.mocode', 'memory-graph.json');
+}
+function projectGraphPath() {
+    return path.join(process.cwd(), '.mocode', 'memory-graph.json');
+}
+function graphPathForScope(scope) {
+    return scope === 'global' ? globalGraphPath() : projectGraphPath();
+}
+function ensureDir(p) {
+    const dir = path.dirname(p);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+function writeGraphAtomic(p, g) {
+    const tmp = p + '.tmp';
+    writeFileSync(tmp, JSON.stringify(g, null, 2), 'utf8');
+    renameSync(tmp, p);
+}
+function readGraphFile(p) {
+    if (!existsSync(p))
+        return { entities: [], edges: [] };
+    try {
+        const raw = readFileSync(p, 'utf8');
+        if (!raw.trim())
+            return { entities: [], edges: [] };
+        const obj = JSON.parse(raw);
+        return {
+            entities: Array.isArray(obj.entities) ? obj.entities : [],
+            edges: Array.isArray(obj.edges) ? obj.edges : [],
+        };
+    }
+    catch {
+        return { entities: [], edges: [] }; // 损坏文件不连累全局
+    }
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+let entCounter = 0;
+/** 实体名 → ASCII slug;纯 CJK 等空结果用 ent 前缀兜底(同 store.ts slugify 思路)。 */
+function entitySlug(name) {
+    const s = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (s)
+        return s;
+    entCounter++;
+    return 'ent-' + Date.now().toString(36) + entCounter.toString(36);
+}
+let edgeCounter = 0;
+function nextEdgeId() {
+    edgeCounter++;
+    return 'edge-' + Date.now().toString(36) + edgeCounter.toString(36);
+}
+/** 读两文件并按文件归一化 scope。 */
+export function loadAllGraph() {
+    const out = { entities: [], edges: [] };
+    for (const scope of ['global', 'project']) {
+        const g = readGraphFile(graphPathForScope(scope));
+        for (const e of g.entities) {
+            e.scope = scope;
+            out.entities.push(e);
+        }
+        for (const e of g.edges) {
+            e.scope = scope;
+            out.edges.push(e);
+        }
+    }
+    return out;
+}
+function writeGraphForScope(scope, g) {
+    const p = graphPathForScope(scope);
+    ensureDir(p);
+    writeGraphAtomic(p, { entities: g.entities, edges: g.edges });
+}
+/** 单 scope 的完整图(读文件,scope 归一化)。 */
+function loadScopeGraph(scope) {
+    const g = readGraphFile(graphPathForScope(scope));
+    for (const e of g.entities)
+        e.scope = scope;
+    for (const e of g.edges)
+        e.scope = scope;
+    return g;
+}
+// ── 实体 ─────────────────────────────────────────────────────────────────
+const norm = (s) => s.trim().toLowerCase();
+function findEntityIn(g, name) {
+    const q = norm(name);
+    if (!q)
+        return undefined;
+    return g.entities.find((e) => e.id === q || norm(e.name) === q || e.aliases.some((a) => norm(a) === q));
+}
+/** 全局找实体(两 scope,project 优先——项目事实比全局更具体)。 */
+export function findEntity(name) {
+    const proj = findEntityIn(loadScopeGraph('project'), name);
+    if (proj)
+        return proj;
+    return findEntityIn(loadScopeGraph('global'), name);
+}
+/**
+ * upsert 实体:按 name/alias/id 匹配,命中则合并 alias/summary;未命中建新。
+ * scope 容量保护:超限先清孤儿实体(无任何 active 边相连);仍超 → 拒绝新实体。
+ */
+export function upsertEntity(name, opts = {}) {
+    const scope = opts.scope === 'global' ? 'global' : 'project';
+    const trimmed = name.trim();
+    if (!trimmed)
+        return { id: '', created: false, rejected: 'empty-name' };
+    const g = loadScopeGraph(scope);
+    const hit = findEntityIn(g, trimmed);
+    if (hit) {
+        let dirty = false;
+        if (opts.alias && !hit.aliases.some((a) => norm(a) === norm(opts.alias))) {
+            hit.aliases.push(opts.alias.trim());
+            dirty = true;
+        }
+        if (opts.summary && opts.summary.trim() && opts.summary.trim() !== hit.summary) {
+            hit.summary = opts.summary.trim();
+            dirty = true;
+        }
+        if (dirty) {
+            hit.updatedAt = nowIso();
+            writeGraphForScope(scope, g);
+        }
+        return { id: hit.id, created: false };
+    }
+    // 新建:容量保护
+    if (g.entities.length >= MAX_GRAPH_ENTITIES) {
+        const linked = new Set();
+        for (const e of g.edges) {
+            if (!e.invalidAt) {
+                linked.add(e.src);
+                linked.add(e.dst);
+            }
+        }
+        g.entities = g.entities.filter((e) => linked.has(e.id));
+        if (g.entities.length >= MAX_GRAPH_ENTITIES) {
+            return { id: '', created: false, rejected: 'entity-cap' };
+        }
+    }
+    const now = nowIso();
+    const ent = {
+        id: entitySlug(trimmed),
+        name: trimmed,
+        aliases: opts.alias && norm(opts.alias) !== norm(trimmed) ? [opts.alias.trim()] : [],
+        summary: opts.summary?.trim() ?? '',
+        createdAt: now,
+        updatedAt: now,
+        scope,
+    };
+    // slug 碰撞兜底(两个不同名字 slug 相同)
+    while (g.entities.some((e) => e.id === ent.id))
+        ent.id += 'x';
+    g.entities.push(ent);
+    writeGraphForScope(scope, g);
+    return { id: ent.id, created: true };
+}
+/**
+ * 写一条三元组。src/dst 自动 upsert 为实体。
+ * 冲突策略:同 scope 内已有 active 边同(src,dst,relation):
+ *  - fact 相同 → 幂等跳过(duplicate);
+ *  - fact 不同 → 旧边 invalidAt=now(时序失效),新边入库。
+ * 容量保护:边超限先清已失效边;仍超 → 拒绝。
+ */
+export function addTriple(input) {
+    const src = input.src?.trim();
+    const dst = input.dst?.trim();
+    const relation = input.relation?.trim().toLowerCase().replace(/\s+/g, '_');
+    if (!src || !dst || !relation)
+        return { ok: false, reason: 'missing src/relation/dst' };
+    if (src.length > 80 || dst.length > 80 || relation.length > 60) {
+        return { ok: false, reason: 'src/dst/relation too long' };
+    }
+    const scope = input.scope === 'global' ? 'global' : 'project';
+    const s = upsertEntity(src, { scope });
+    if (s.rejected)
+        return { ok: false, reason: `src entity: ${s.rejected}` };
+    const d = upsertEntity(dst, { scope });
+    if (d.rejected)
+        return { ok: false, reason: `dst entity: ${d.rejected}` };
+    const g = loadScopeGraph(scope);
+    const fact = (input.fact ?? '').trim();
+    const clash = g.edges.find((e) => !e.invalidAt && e.src === s.id && e.dst === d.id && e.relation === relation);
+    if (clash) {
+        if (!fact || clash.fact === fact) {
+            return { ok: true, edgeId: clash.id, superseded: 0, duplicate: true };
+        }
+        clash.invalidAt = nowIso(); // 时序失效,保留可追溯
+    }
+    // 容量保护:先清失效边
+    if (g.edges.length >= MAX_GRAPH_EDGES) {
+        g.edges = g.edges.filter((e) => !e.invalidAt);
+        if (g.edges.length >= MAX_GRAPH_EDGES) {
+            return { ok: false, reason: 'edge-cap' };
+        }
+    }
+    const edge = {
+        id: nextEdgeId(),
+        src: s.id,
+        dst: d.id,
+        relation,
+        fact,
+        validAt: nowIso(),
+        invalidAt: null,
+        sourceEntry: input.sourceEntry ?? null,
+        scope,
+    };
+    g.edges.push(edge);
+    writeGraphForScope(scope, g);
+    return { ok: true, edgeId: edge.id, superseded: clash ? 1 : 0 };
+}
+/** 实体关键词搜索(多词子串,name/alias/id 加权),返回命中实体 + 相连 active 边。 */
+export function searchGraph(query, limit = 8) {
+    const g = loadAllGraph();
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const scored = g.entities
+        .map((e) => {
+        let sc = 0;
+        const name = e.name.toLowerCase();
+        const id = e.id.toLowerCase();
+        const aliases = e.aliases.map((a) => a.toLowerCase());
+        for (const t of terms) {
+            if (id.includes(t))
+                sc += 8;
+            if (name.includes(t))
+                sc += 10;
+            if (aliases.some((a) => a.includes(t)))
+                sc += 6;
+            if (e.summary.toLowerCase().includes(t))
+                sc += 2;
+        }
+        return { e, sc };
+    })
+        .filter((x) => (terms.length === 0 ? true : x.sc > 0))
+        .sort((a, b) => b.sc - a.sc)
+        .slice(0, Math.max(1, Math.min(limit, 20)));
+    const hitIds = new Set(scored.map((x) => x.e.id));
+    const edges = g.edges.filter((e) => !e.invalidAt && (hitIds.has(e.src) || hitIds.has(e.dst)));
+    return { entities: scored.map((x) => x.e), edges };
+}
+function buildAdjacency(g, relation) {
+    const adj = new Map();
+    for (const e of g.edges) {
+        if (e.invalidAt)
+            continue;
+        if (relation && e.relation !== relation)
+            continue;
+        const a = adj.get(e.src);
+        if (a)
+            a.push(e);
+        else
+            adj.set(e.src, [e]);
+        const b = adj.get(e.dst);
+        if (b)
+            b.push(e);
+        else
+            adj.set(e.dst, [e]);
+    }
+    return adj;
+}
+/**
+ * 邻居遍历:depth 1-3(BFS + 邻接表 O(V+E)),只看 active 边,边数封顶 40 防图爆炸。
+ * relation 可选:只沿该类型的边走(深跳聚焦用,如沿 depends_on 链追踪)。
+ */
+export function neighborsOf(nameOrId, depth = 1, relation) {
+    const g = loadAllGraph();
+    const center = findEntityIn(g, nameOrId) ?? g.entities.find((e) => e.id === nameOrId);
+    if (!center)
+        return { center: null, entities: [], edges: [], truncated: false };
+    const rel = relation?.trim().toLowerCase().replace(/\s+/g, '_') || undefined;
+    const maxDepth = Math.max(1, Math.min(Math.floor(depth) || 1, 3));
+    const MAX_EDGES_OUT = 40;
+    const adj = buildAdjacency(g, rel);
+    const visited = new Set([center.id]);
+    const seenEdges = new Set();
+    const outEdges = [];
+    let frontier = [center.id];
+    let truncated = false;
+    outer: for (let d = 0; d < maxDepth; d++) {
+        const next = [];
+        for (const id of frontier) {
+            for (const e of adj.get(id) ?? []) {
+                if (seenEdges.has(e.id))
+                    continue;
+                seenEdges.add(e.id);
+                if (outEdges.length >= MAX_EDGES_OUT) {
+                    truncated = true;
+                    break outer; // 截断立即退出,不再空扫剩余边
+                }
+                outEdges.push(e);
+                const other = e.src === id ? e.dst : e.src;
+                if (!visited.has(other)) {
+                    visited.add(other);
+                    next.push(other);
+                }
+            }
+        }
+        frontier = next;
+    }
+    const entities = g.entities.filter((e) => visited.has(e.id) && e.id !== center.id);
+    return { center, entities, edges: outEdges, truncated };
+}
+const MAX_PATH_DEPTH = 6;
+/**
+ * 两实体间最短路径:active 边视为无向,双向 BFS(每次展开较小前沿),
+ * 总跳数封顶 MAX_PATH_DEPTH 防图爆炸。不连通 / 未知端 → null。
+ */
+export function pathBetween(aNameOrId, bNameOrId) {
+    const g = loadAllGraph();
+    const from = findEntityIn(g, aNameOrId) ?? g.entities.find((e) => e.id === aNameOrId);
+    const to = findEntityIn(g, bNameOrId) ?? g.entities.find((e) => e.id === bNameOrId);
+    if (!from || !to)
+        return null;
+    if (from.id === to.id)
+        return { from, to, path: [from], edges: [] };
+    const fwd = new Map([[from.id, { prev: null, edge: null }]]);
+    const bwd = new Map([[to.id, { prev: null, edge: null }]]);
+    let fFront = [from.id];
+    let bFront = [to.id];
+    const adj = buildAdjacency(g);
+    let meet = null;
+    for (let d = 0; d < MAX_PATH_DEPTH && !meet; d++) {
+        const expandFwd = fFront.length <= bFront.length;
+        const mine = expandFwd ? fwd : bwd;
+        const theirs = expandFwd ? bwd : fwd;
+        const frontier = expandFwd ? fFront : bFront;
+        const next = [];
+        for (const id of frontier) {
+            for (const e of adj.get(id) ?? []) {
+                const other = e.src === id ? e.dst : e.src;
+                if (mine.has(other))
+                    continue;
+                mine.set(other, { prev: id, edge: e });
+                next.push(other);
+                if (theirs.has(other)) {
+                    meet = other;
+                    break;
+                }
+            }
+            if (meet)
+                break;
+        }
+        if (expandFwd)
+            fFront = next;
+        else
+            bFront = next;
+    }
+    if (!meet)
+        return null;
+    // 重组:fwd 链 from→…→meet,再接 bwd 链 meet→…→to
+    const rev = [];
+    for (let cur = meet; cur; cur = fwd.get(cur)?.prev ?? null)
+        rev.push(cur);
+    rev.reverse(); // [from, ..., meet]
+    const pathIds = [...rev];
+    const pathEdges = [];
+    for (const id of rev.slice(1)) {
+        const e = fwd.get(id)?.edge;
+        if (e)
+            pathEdges.push(e);
+    }
+    for (let cur = meet;;) {
+        const t = bwd.get(cur);
+        if (!t?.prev)
+            break;
+        if (t.edge)
+            pathEdges.push(t.edge);
+        pathIds.push(t.prev);
+        cur = t.prev;
+    }
+    const byId = new Map();
+    for (const e of g.entities)
+        if (!byId.has(e.id))
+            byId.set(e.id, e);
+    const path = pathIds.map((id) => byId.get(id)).filter((e) => !!e);
+    return { from, to, path, edges: pathEdges };
+}
+export function graphStats() {
+    const g = loadAllGraph();
+    const count = (scope) => ({
+        entities: g.entities.filter((e) => e.scope === scope).length,
+        edges: g.edges.filter((e) => e.scope === scope && !e.invalidAt).length,
+    });
+    return {
+        entities: g.entities.length,
+        edgesActive: g.edges.filter((e) => !e.invalidAt).length,
+        edgesInvalid: g.edges.filter((e) => !!e.invalidAt).length,
+        byScope: { project: count('project'), global: count('global') },
+    };
+}

package/dist/memory/index.js

@@ -1,5 +1,7 @@
-// Memory barrel: Tier-2 JSONL store + background reflection.
-// MOCODE.md is intentionally not loaded here: the system prompt only tells the agent
-// to read the workspace file on demand, keeping its full body out of every request.
+// Memory barrel: Tier-2 JSONL store + knowledge-graph layer + background reflection.
+// AGENTS.md is intentionally not loaded here either: config/index.ts
+// (buildAgentsImportSection) auto-imports the workspace-root AGENTS.md body into the
+// system prompt — independent of the memory switch — truncating it when it exceeds the cap.
 export { buildMemoryIndexSection, loadAll, gcMemories, } from './store.js';
+export { addTriple, upsertEntity, findEntity, searchGraph, neighborsOf, pathBetween, graphStats, } from './graph.js';
 export { kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, runReflection, } from './reflect.js';

package/dist/memory/reflect.js

@@ -13,6 +13,7 @@ import path from 'node:path';
 import { chat } from '../llm/index.js';
 import { config, isMemoryEnabled } from '../config/index.js';
 import { saveEntry, updateEntry, forgetEntry, loadAll, gcMemories, } from './store.js';
+import { addTriple } from './graph.js';
 // ── 日志(静默容错,裁尾保最近)─────────────────────────────────────────────
 function logPath() {
     return path.join(process.cwd(), '.mocode', 'memory.log');
@@ -93,15 +94,16 @@ function buildMemorySample() {
 }
 const TYPES = 'decision | fact | pitfall | reference | feedback';
 const REFLECT_SYS = `You are mocode's memory reflector. Review the recent session and existing memories, producing **only** updates worth remembering long-term.
-Output strictly JSON (no markdown code blocks, no explanatory text): {"saves":[{"type":"...","name":"...","summary":"...","body":"..."}],"updates":[{"id":"...","reason":"...","summary":"...","body":"..."}],"forgets":[{"id":"...","reason":"..."}]}
-Empty arrays are valid (if nothing is worth saving, all three arrays are empty).
+Output strictly JSON (no markdown code blocks, no explanatory text): {"saves":[{"type":"...","name":"...","summary":"...","body":"..."}],"updates":[{"id":"...","reason":"...","summary":"...","body":"..."}],"forgets":[{"id":"...","reason":"..."}],"triples":[{"src":"...","relation":"...","dst":"...","fact":"..."}]}
+Empty arrays are valid (if nothing is worth saving, all arrays are empty).
 Rules:
 ① Only store non-obvious, cross-session-useful facts/decisions/pitfalls; do not store current bugs, temp files, undecided TODOs, or volatile items;
 ② Better to store less than to store trivially correct info (e.g. "keep it concise");
 ③ ids in updates/forgets must come from the "existing memories" list below; do not fabricate ids not listed there;
 ④ names in saves must be concise and not collide with existing ones; type ∈ {${TYPES}};
 ⑤ If an existing memory contradicts new facts or is outdated, update the old entry (modify summary/body) rather than creating a duplicate;
-⑥ forgets are for memories clearly stale / superseded by a new entry (archive, not hard-delete).`;
+⑥ forgets are for memories clearly stale / superseded by a new entry (archive, not hard-delete);
+⑦ triples are knowledge-graph facts distilled from this session: concise entity names (lowercase snake_case or proper nouns), relation in snake_case (e.g. depends_on, decided_by, implemented_in, conflicts_with), plus a one-line fact. Only emit triples that are stable, non-obvious and cross-session-useful (2-6 at most); they may reference entities from saves/updates or existing memories.`;
 const REFLECT_USER = (transcript, sample) => `## Recent session\n${transcript}\n\n## Existing memories\n${sample}\n\nProduce JSON:`;
 function parsePlan(content) {
     if (!content)
@@ -141,6 +143,7 @@ export async function runReflection(transcript, signal) {
         saves: 0,
         updates: 0,
         forgets: 0,
+        triples: 0,
         gcDecayed: 0,
         gcCapped: 0,
         gcGced: 0,
@@ -200,8 +203,24 @@ export async function runReflection(transcript, signal) {
                 forgets++;
         }
     }
+    // 知识图谱三元组:容错——单项失败跳过,不影响 saves/updates/forgets 已落地的结果。
+    let triples = 0;
+    if (Array.isArray(plan.triples)) {
+        for (const t of plan.triples.slice(0, 10)) {
+            if (!t?.src || !t?.relation || !t?.dst)
+                continue;
+            const r = addTriple({
+                src: String(t.src),
+                relation: String(t.relation),
+                dst: String(t.dst),
+                fact: t.fact ? String(t.fact) : undefined,
+            });
+            if (r.ok && !r.duplicate)
+                triples++;
+        }
+    }
     const gc = gcMemories();
-    result = { ...result, saves, updates, forgets, gcDecayed: gc.decayed, gcCapped: gc.capped, gcGced: gc.gced };
+    result = { ...result, saves, updates, forgets, triples, gcDecayed: gc.decayed, gcCapped: gc.capped, gcGced: gc.gced };
     return result;
 }
 function normalizeType(t) {
@@ -215,9 +234,9 @@ function normalizeType(t) {
 // ── 后台编排:kickoff / drain / 缓存 ─────────────────────────────────────────
 let inflight = null;
 let lastReflectResult = null;
-/** 摘要串(供 repl flush):存N 改N 忘N;有错误附上。 */
+/** 摘要串(供 repl flush):存N 改N 忘N 图N;有错误附上。 */
 export function formatReflectResult(r) {
-    const parts = [`存${r.saves}`, `改${r.updates}`, `忘${r.forgets}`];
+    const parts = [`存${r.saves}`, `改${r.updates}`, `忘${r.forgets}`, `图${r.triples}`];
     if (r.gcDecayed || r.gcCapped || r.gcGced) {
         parts.push(`遗忘(衰减${r.gcDecayed}/封顶${r.gcCapped}/清除${r.gcGced})`);
     }

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, isFrontendToolsEnabled, updateFrontendToolsConfig, updateLanguageConfig, languageFromShell, buildBasePrompt, getPlanModeSuffix, hasCodegraphIndex, reinjectActivePlanIntoSystem, DEFAULT_CONTEXT_WINDOW_TOKENS, } from '../config/index.js';
+import { config, updateModelConfig, isModelConfigured, updateMemoryConfig, isMemoryEnabled, isSubAgentEnabled, updateSubAgentConfig, isFrontendToolsEnabled, updateFrontendToolsConfig, updateLanguageConfig, languageFromShell, buildBasePrompt, getPlanModeSuffix, hasCodegraphIndex, reinjectSessionStateIntoSystem, DEFAULT_CONTEXT_WINDOW_TOKENS, } from '../config/index.js';
 import { getLanguage, normalizeLanguage, t, } from '../i18n/index.js';
 import { DEFAULT_BUDGET_POLICY } from '../context/budget.js';
 import { updateConfigKey, writeConfigKeys, CONFIG_PATH } from '../config/file.js';
@@ -66,9 +66,9 @@ function buildSlashCommands() {
                 { name: 'off', value: '/memory_switch off', desc: d('commands.memoryOff') },
                 { name: 'status', value: '/memory_status', desc: d('commands.memoryStatus') },
                 { name: 'reflect', value: '/reflect', desc: d('commands.memoryReflect') },
-                { name: 'init', value: '/init', desc: d('commands.memoryInit') },
             ],
         },
+        { name: '/init', desc: d('commands.memoryInit') },
         {
             name: '/subagent', desc: d('commands.subagent'), children: [
                 { name: 'on', value: '/subagent on', desc: d('commands.subagentOn') },
@@ -173,7 +173,7 @@ function maskKey(k) {
     return `${'='.repeat(Math.min(k.length - 4, 20))}${k.slice(-4)}`;
 }
 /**
- * /init 指令:发给 agent 扫描项目并生成 MOCODE.md。已存在则让 agent 读后更新(不丢失事实)。写完供 memory 子系统下轮加载。
+ * /init 指令:发给 agent 扫描项目并生成 AGENTS.md。已存在则让 agent 读后更新(不丢失事实)。写完供 memory 子系统下轮加载。
  *
  * 函数化(非 const):.codegraph/ 索引是否存在的探测放在调用瞬间,没索引时不提 codegraph,
  * 避免 LLM 调出失败。/init 是冷启动动作,IO 开销可忽略。
@@ -182,14 +182,14 @@ function buildInitPrompt() {
     const cg = hasCodegraphIndex()
         ? '- 若有 .codegraph/:用 use_skill 加载 codegraph skill 后用 run_command 调 codegraph explore "<架构或入口符号>" 一次拿相关源码+调用路径,别逐文件读！！！\n'
         : '';
-    return `分析当前项目(process.cwd()),生成 MOCODE.md 项目记忆文件,供 mocode 后续会话自动加载——目标是让后续会话无需重新摸索就能上手。
+    return `分析当前项目(process.cwd()),生成 AGENTS.md 项目记忆文件,供 mocode 后续会话自动加载——目标是让后续会话无需重新摸索就能上手。
 
 先探查(尽量少调用拿全貌):
 ${cg}- read_file package.json(或 Cargo.toml/pyproject.toml/go.mod 等):scripts、依赖、入口、模块类型。
 - glob 顶层目录;read_file 入口文件 + 各子系统 index.ts/README。
-- 若 MOCODE.md 已存在:read_file 读它,在其基础上更新(补缺、修正过时),不丢已有准确事实。
+- 若 AGENTS.md 已存在:read_file 读它,在其基础上更新(补缺、修正过时),不丢已有准确事实。
 
-MOCODE.md 按以下结构写(每节简短,只写稳定、非显然的事实):
+AGENTS.md 按以下结构写(每节简短,只写稳定、非显然的事实):
 ## 项目
 一两句:是什么、技术栈、运行环境。
 ## 命令
@@ -204,7 +204,7 @@ install / dev / build / test / typecheck / lint 等——从 package.json script
 硬要求:
 - 从实际代码提炼,引用具体文件名/命令/符号;不编造、不泛泛。
 - 总长 ≤ 3000 字;只写后续会话有用的稳定事实,不写易变项(当前 bug、临时文件、未决 TODO)。
-- 用 write_file 写入项目根 MOCODE.md。
+- 用 write_file 写入项目根 AGENTS.md。
 - 写完简述:写了哪几节 + 从代码里发现的 2-3 条非显然关键约定(供用户校验)。`;
 }
 /** 临时 readline 读一行(cooked,用于子提问;主输入走 promptWithSlashMenu)。 */
@@ -768,7 +768,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     //
     // 与开关联动:① base 用 buildBasePrompt() 取代 config.systemPrompt(后者是启动时一次性
     // 求值的常量,运行时 /memory_switch 不会刷新);② plan suffix 走 getPlanModeSuffix() 现拼;
-    // ③ MOCODE.md 只在 base 中提示按需 read_file，不注入正文；④ Memory Index 按开关注入。
+    // ③ AGENTS.md 存在工作区根时由 base 无条件自动导入正文(超长截断，与 memory 开关无关)；④ Memory Index 按开关注入。
     const buildSystemMessage = (planMode) => effectiveSystemPrompt(buildBasePrompt(currentSessionId) +
         (planMode ? getPlanModeSuffix() : '') +
         buildMemoryIndexSection(isMemoryEnabled()));
@@ -1199,7 +1199,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             continue;
         }
         if (line === '/init') {
-            // /init:把 init 指令当 user 输入发给 agent(扫描项目 + 生成 MOCODE.md),fall through 走 runAgent
+            // /init:把 init 指令当 user 输入发给 agent(扫描项目 + 生成 AGENTS.md),fall through 走 runAgent
             joined = buildInitPrompt();
         }
         if (line === '/upgrade' || line.startsWith('/upgrade ')) {
@@ -1438,7 +1438,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
                 layout.contentWrite(`  ${ui.accent}${e.id}${ui.reset}  ${ui.dim}${e.name} — ${e.summary}${ui.reset}\n`);
             }
             if (active.length === 0)
-                layout.contentWrite(`${ui.dim}(无 active 记忆;用 memory_save 存,或 /init 生成 MOCODE.md)${ui.reset}\n`);
+                layout.contentWrite(`${ui.dim}(无 active 记忆;用 memory_save 存,或 /init 生成 AGENTS.md)${ui.reset}\n`);
             layout.contentWrite(`${ui.dim}(详情用 memory_search;启动索引已注入 systemPrompt)${ui.reset}\n`);
             continue;
         }
@@ -1545,9 +1545,9 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             // focus 透传到 compact_history action 的 LLM 摘要 prompt。
             // 返回 SchedulerRunLog 给 UI 显示决策;退化路径(开关关时)在 manualCompact 内部走 compactHistory。
             const log = await manualCompact(history, focus, { force });
-            // ② compact 后把活跃 plan 重注入系统提示（history[0]），避免 agent 因上下文压缩丢失执行计划。
+            // ② compact 后把会话状态(plan + 笔记段)重注入系统提示（history[0]），避免 agent 因上下文压缩丢失计划与笔记。
             if (log.compactHistoryCalled)
-                reinjectActivePlanIntoSystem(history);
+                reinjectSessionStateIntoSystem(history);
             const d = log.compactDetail;
             appendCurrentSessionRuntimeEvent('compact', {
                 source: 'manual',
@@ -2186,9 +2186,9 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
                 // 写盘:mode 文件 values,/~/.mocode/config;writeConfigKeys 不会动其它键(主题 / 模型等)
                 updateConfigKey('MEMORY_ENABLED', nextEnabled ? 'true' : 'false');
                 const note = nextEnabled
-                    ? `${ui.green}已开启记忆子系统${ui.reset} — memory_save/search/list/update/forget 进入工具表;` +
+                    ? `${ui.green}已开启记忆子系统${ui.reset} — memory_save/search/list/update/forget/graph 进入工具表;` +
                         `Memory Index 段会在下次拼 system message 时注入。工具表本身的快照需要重启 REPL 才完整刷新。`
-                    : `${ui.yellow}已关闭记忆子系统${ui.reset} — 五个 memory_* 工具将在下次拼 system message 时从工具表过滤;` +
+                    : `${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}` +

package/dist/sandbox/policy.js

@@ -14,7 +14,7 @@ import { jailResolve, jailGlobPattern } from './jail.js';
  * Shift+Tab 等用户面触发,不经工具路径。
  */
 export const SANDBOX_EXEMPT_TOOLS = new Set([
-    'memory_save', 'memory_update', 'memory_forget', 'memory_search', 'memory_list',
+    'memory_save', 'memory_update', 'memory_forget', 'memory_search', 'memory_list', 'memory_graph',
     'use_skill',
     'web_search', 'web_fetch',
     'ask_human',