mocode-ai 1.2.4 → 1.2.5

package/dist/config/index.js

@@ -216,8 +216,9 @@ export function reinjectActivePlanIntoSystem(history) {
 }
 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.`;
+- 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.`;
 /** Inject only retrieval guidance; MOCODE.md contents stay outside the prompt until read on demand. */
 function buildMemoryPromptSection() {
     if (!isMemoryEnabled())

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/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,6 @@
-// Memory barrel: Tier-2 JSONL store + background reflection.
+// Memory barrel: Tier-2 JSONL store + knowledge-graph layer + 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.
 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

@@ -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',

package/dist/tools/builtins/index.js

@@ -19,12 +19,13 @@ import { memorySearchTool } from './memory-search.js';
 import { memoryListTool } from './memory-list.js';
 import { memoryUpdateTool } from './memory-update.js';
 import { memoryForgetTool } from './memory-forget.js';
+import { memoryGraphTool } from './memory-graph.js';
 import { subAgentTool } from './task.js';
 /**
  * 所有内置工具,按注册顺序排列。
  * 加新工具:在本目录新建 `xxx.ts` 导出一个 Tool,再在下面数组里加一行。无需改 agent / llm。
  *
- * 记忆子系统总开关(MEMORY_ENABLED !== 'true'):5 个 memory_* 工具整体不进 builtinTools,
+ * 记忆子系统总开关(MEMORY_ENABLED !== 'true'):6 个 memory_* 工具整体不进 builtinTools,
  * 进而不进 LLM 的工具表(模型根本看不到、也不会想着去调)。运行时通过 /memory_switch 切;
  * 切换对当前会话的 tool list 不重算(取的是模块初始化时的快照),所以需要重启 REPL 才生效
  * —— 这是有意为之,避免切开关瞬间把已发出请求的工具列表打乱。
@@ -41,6 +42,7 @@ const _memoryTools = _memoryEnabledAtBoot
         memoryListTool,
         memoryUpdateTool,
         memoryForgetTool,
+        memoryGraphTool,
     ]
     : [];
 const pathResource = (args) => typeof args.path === 'string' && args.path ? [`file:${args.path}`] : ['workspace'];
@@ -71,6 +73,8 @@ const CAPABILITIES = {
     memory_list: { effect: 'read', concurrency: 'serial', resources: memoryResource },
     memory_update: { effect: 'write', concurrency: 'serial', resources: memoryResource },
     memory_forget: { effect: 'write', concurrency: 'serial', resources: memoryResource },
+    // memory_graph:search/neighbors/stats 只读、add 写,统一按写处理走串行(调用不频繁,简化)。
+    memory_graph: { effect: 'write', concurrency: 'serial', resources: memoryResource },
     // sub-agent 动态协调：只读任务无锁并行；写任务在 overlay 中执行，merge 时由 ChangeSet 持 canonical lock。
     'sub-agent': {
         effect: 'write',

package/dist/tools/builtins/memory-graph.js

@@ -0,0 +1,118 @@
+import { addTriple, graphStats, neighborsOf, pathBetween, } from '../../memory/graph.js';
+// ---------- memory_graph ----------
+// 知识图谱维护工具:邻居遍历(1-3 跳,可 relation 过滤)、两点最短路径、手工加三元组、看图统计。
+// 关键词搜索已并入 memory_search(条目 + 图谱事实一次返回),本工具不再提供 search。
+// 底层 memory-graph.json(Graphiti 式时序边:新事实取代旧边时旧边置 invalidAt,不删)。
+// neighbors/path/stats 只读;add 写。
+function fmtEdges(edges) {
+    if (edges.length === 0)
+        return '(无边)';
+    return edges
+        .map((e) => `${e.src} --[${e.relation}]--> ${e.dst}${e.fact ? ` (${e.fact})` : ''}`)
+        .join('\n');
+}
+function fmtEntities(entities) {
+    if (entities.length === 0)
+        return '(无实体)';
+    return entities
+        .map((e) => `- ${e.id}: ${e.name}${e.summary ? ` — ${e.summary}` : ''} [${e.scope}]`)
+        .join('\n');
+}
+export const memoryGraphTool = {
+    name: 'memory_graph',
+    description: 'Maintain/explore the knowledge-graph memory layer (entities + temporal triples). Keyword search lives in memory_search. ' +
+        'action=neighbors: BFS 1-3 hops around an entity (optional relation filter to follow one edge type); ' +
+        'action=path: shortest path between two entities (bidirectional BFS, max 6 hops); ' +
+        'action=add: add a triple (src --relation--> dst); existing edges with same src/relation/dst are temporally invalidated, not deleted; ' +
+        'action=stats: graph size overview.',
+    parameters: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['neighbors', 'path', 'add', 'stats'],
+                description: 'What to do',
+            },
+            query: { type: 'string', description: 'neighbors: entity name or id; path: start entity' },
+            depth: { type: 'integer', description: 'neighbors: hops, 1-3, default 1' },
+            src: { type: 'string', description: 'add: source entity name' },
+            relation: {
+                type: 'string',
+                description: 'add: relation in snake_case, e.g. depends_on / decided_by. neighbors: optional edge-type filter to follow only that relation',
+            },
+            dst: { type: 'string', description: 'add: target entity name; path: end entity' },
+            fact: { type: 'string', description: 'add: optional one-line statement for the edge' },
+            scope: {
+                type: 'string',
+                enum: ['project', 'global'],
+                description: 'add: which graph file to write, default project',
+            },
+        },
+        required: ['action'],
+    },
+    async execute(args) {
+        const action = String(args.action ?? '').trim();
+        if (action === 'stats') {
+            const s = graphStats();
+            return [
+                `实体 ${s.entities} 条边(active ${s.edgesActive} / 已失效 ${s.edgesInvalid})`,
+                `project: ${s.byScope.project.entities} 实体, ${s.byScope.project.edges} 边`,
+                `global:  ${s.byScope.global.entities} 实体, ${s.byScope.global.edges} 边`,
+            ].join('\n');
+        }
+        if (action === 'neighbors') {
+            const query = String(args.query ?? '').trim();
+            if (!query)
+                return '错误:neighbors 需要 query(实体名或 id)。';
+            const depth = typeof args.depth === 'number' ? args.depth : 1;
+            const rel = typeof args.relation === 'string' ? args.relation.trim() : '';
+            const r = neighborsOf(query, depth, rel || undefined);
+            if (!r.center)
+                return `(图中没有实体 "${query}")`;
+            const relNote = rel ? `,仅 ${rel} 边` : '';
+            const lines = [
+                `## ${r.center.name} (${r.center.id})${r.center.summary ? ` — ${r.center.summary}` : ''}`,
+                r.entities.length > 0 ? `\n## 邻居实体\n${fmtEntities(r.entities)}` : '',
+                `\n## 边(${r.edges.length}${relNote}${r.truncated ? ',已截断' : ''})\n${fmtEdges(r.edges)}`,
+            ].filter(Boolean);
+            return lines.join('\n');
+        }
+        if (action === 'path') {
+            const from = String(args.query ?? '').trim();
+            const to = String(args.dst ?? '').trim();
+            if (!from || !to)
+                return '错误:path 需要 query(起点实体)和 dst(终点实体)。';
+            const r = pathBetween(from, to);
+            if (!r)
+                return `(无 active 路径:${from} ⇸ ${to},或端点实体不存在)`;
+            const chain = r.path.map((e) => e.name).join(' → ');
+            const lines = [
+                `## ${r.from.name} ⇢ ${r.to.name}(${r.edges.length} 跳)`,
+                `路径:${chain}`,
+                `\n## 边\n${fmtEdges(r.edges)}`,
+            ];
+            return lines.join('\n');
+        }
+        if (action === 'add') {
+            const src = String(args.src ?? '').trim();
+            const relation = String(args.relation ?? '').trim();
+            const dst = String(args.dst ?? '').trim();
+            if (!src || !relation || !dst)
+                return '错误:add 需要 src、relation、dst。';
+            const r = addTriple({
+                src,
+                relation,
+                dst,
+                fact: typeof args.fact === 'string' ? args.fact : undefined,
+                scope: args.scope === 'global' ? 'global' : 'project',
+            });
+            if (!r.ok)
+                return `错误:三元组未写入 (${r.reason})。`;
+            if (r.duplicate)
+                return `已存在相同三元组 (${r.edgeId}),幂等跳过。`;
+            const sup = r.superseded > 0 ? `;旧边已时序失效(${r.superseded} 条)` : '';
+            return `已写入三元组 ${src} --[${relation.toLowerCase().replace(/\s+/g, '_')}]--> ${dst} [${r.edgeId}]${sup}。`;
+        }
+        return `错误:未知 action "${action}",可用 neighbors/path/add/stats(关键词搜索请用 memory_search)。`;
+    },
+};

package/dist/tools/builtins/memory-save.js

@@ -1,10 +1,12 @@
 import { saveEntry } from '../../memory/store.js';
+import { addTriple } from '../../memory/graph.js';
 // ---------- memory_save ----------
 // 存一条长期记忆(跨会话)。启动只把标题/摘要注入索引(几百 token);详情按需 memory_search 取。
 // 撞库(name→id 已存在)拒绝,引导用 memory_update。
+// 可选 links:把本条记忆挂进知识图谱(memory-graph.json)——src 省略时默认以记忆 name 为主实体。
 export const memorySaveTool = {
     name: 'memory_save',
-    description: 'Save a cross-session long-term memory entry. Store only non-obvious, useful facts/decisions/pitfalls. Title enters the startup index; retrieve body via memory_search.',
+    description: 'Save a cross-session long-term memory entry. Store only non-obvious, useful facts/decisions/pitfalls. Title enters the startup index; retrieve body via memory_search. Optionally attach knowledge-graph links (triples) to relate this memory to entities.',
     risk: 'confirm',
     parameters: {
         type: 'object',
@@ -23,6 +25,20 @@ export const memorySaveTool = {
                 enum: ['project', 'global'],
                 description: 'Store at project level (<cwd>/.mocode/) or global (~/.mocode/), default project',
             },
+            links: {
+                type: 'array',
+                description: 'Optional knowledge-graph triples relating this memory to entities, e.g. [{"src":"mocode","relation":"depends_on","dst":"JSONL store"}]. src defaults to the memory name when omitted.',
+                items: {
+                    type: 'object',
+                    properties: {
+                        src: { type: 'string', description: 'Source entity name (defaults to the memory name)' },
+                        relation: { type: 'string', description: 'Relation, snake_case, e.g. depends_on / decided_by / conflicts_with' },
+                        dst: { type: 'string', description: 'Target entity name' },
+                        fact: { type: 'string', description: 'Optional one-line statement for the edge' },
+                    },
+                    required: ['relation', 'dst'],
+                },
+            },
         },
         required: ['name', 'summary', 'body'],
     },
@@ -37,16 +53,37 @@ export const memorySaveTool = {
         if (!body)
             return '错误:缺少 body。';
         const type = typeof args.type === 'string' ? args.type : undefined;
+        const scope = args.scope === 'global' ? 'global' : 'project';
         const r = saveEntry({
             name,
             summary,
             body,
             type,
             pinned: args.pinned === true,
-            scope: args.scope === 'global' ? 'global' : 'project',
+            scope,
         });
-        if (r.ok)
-            return `已保存记忆 [${r.id}] "${name}"(下次启动进索引)。`;
-        return `已存在同名记忆 [${r.exists}]。改用 memory_update(id="${r.exists}", …) 更新,或换一个 name。`;
+        if (!r.ok) {
+            return `已存在同名记忆 [${r.exists}]。改用 memory_update(id="${r.exists}", …) 更新,或换一个 name。`;
+        }
+        // 知识图谱挂边:容错——图失败不影响记忆保存结果
+        const links = Array.isArray(args.links) ? args.links : [];
+        let linked = 0;
+        for (const l of links) {
+            if (!l || typeof l !== 'object')
+                continue;
+            const link = l;
+            const tr = addTriple({
+                src: typeof link.src === 'string' && link.src.trim() ? link.src : name,
+                relation: typeof link.relation === 'string' ? link.relation : '',
+                dst: typeof link.dst === 'string' ? link.dst : '',
+                fact: typeof link.fact === 'string' ? link.fact : undefined,
+                sourceEntry: r.id,
+                scope,
+            });
+            if (tr.ok)
+                linked++;
+        }
+        const linkNote = links.length > 0 ? `;知识图谱挂边 ${linked}/${links.length}` : '';
+        return `已保存记忆 [${r.id}] "${name}"(下次启动进索引)${linkNote}。`;
     },
 };

package/dist/tools/builtins/memory-search.js

@@ -1,10 +1,13 @@
 import { searchEntries } from '../../memory/store.js';
+import { searchGraph } from '../../memory/graph.js';
 // ---------- memory_search ----------
-// 关键词搜记忆正文(多词子串匹配,name 权重最高)。命中即 bump recallCount(遗忘衰减依据)。
+// 唯一记忆搜索入口:关键词搜记忆正文(多词子串匹配,name 权重最高)+ 知识图谱事实段
+// (命中实体的 active 边)。命中条目即 bump recallCount(遗忘衰减依据)。
 // 结果走 capToolResultForHistory 的放宽上限(同 use_skill,保正文完整)。
+const GRAPH_FACTS_LIMIT = 10;
 export const memorySearchTool = {
     name: 'memory_search',
-    description: 'Search memory entries by keyword (substring match), returning full body.',
+    description: 'Search memory entries by keyword (substring match), returning full body. Also surfaces knowledge-graph facts (active edges) for entities matching the query.',
     parameters: {
         type: 'object',
         properties: {
@@ -33,10 +36,28 @@ export const memorySearchTool = {
                 : undefined,
             limit: typeof args.limit === 'number' ? args.limit : undefined,
         });
-        if (r.length === 0)
-            return `(无匹配记忆:query="${query}")`;
-        return r
+        const entryText = r
             .map((e) => `# [${e.id}] ${e.name} (${e.type}, recalled ${e.recallCount})\nsummary: ${e.summary}\n\n${e.body}`)
             .join('\n\n---\n\n');
+        // 知识图谱事实段:命中实体的 active 边(容错:图坏了不连累条目搜索)。
+        let graphText = '';
+        try {
+            const g = searchGraph(query, 8);
+            if (g.edges.length > 0) {
+                const lines = g.edges
+                    .slice(0, GRAPH_FACTS_LIMIT)
+                    .map((e) => `${e.src} --[${e.relation}]--> ${e.dst}${e.fact ? ` (${e.fact})` : ''}`);
+                const more = g.edges.length > GRAPH_FACTS_LIMIT ? `\n…(共 ${g.edges.length} 条,其余用 memory_graph action=neighbors 展开)` : '';
+                graphText = `\n\n## 知识图谱事实\n${lines.join('\n')}${more}`;
+            }
+        }
+        catch {
+            // 静默:图谱段是增强,失败只降级为纯条目结果
+        }
+        if (!entryText && !graphText)
+            return `(无匹配记忆:query="${query}")`;
+        if (!entryText)
+            return `(无匹配记忆条目,但图谱有命中)\n${graphText.trimStart()}`;
+        return entryText + graphText;
     },
 };

package/dist/tools/constants.js

@@ -23,6 +23,11 @@ export const DECAY_DAYS = 30;
 export const GC_DAYS = 90;
 /** memory_search 结果(召回的记忆正文)的放宽上限:指令性内容,中截破坏语义,对齐 use_skill。 */
 export const MAX_MEMORY_RESULT = 64000;
+// ── 知识图谱层(memory-graph.json,单 scope 容量)──────────────────────────
+/** 单 scope 实体封顶:超限先清孤儿实体(无 active 边相连),仍超则拒绝新建。 */
+export const MAX_GRAPH_ENTITIES = 500;
+/** 单 scope 边封顶:超限先清已失效边,仍超则拒绝新边。 */
+export const MAX_GRAPH_EDGES = 2000;
 // .codegraph:codegraph 索引目录(codegraph.db 是 SQLite 二进制 + daemon.log),
 // grep/glob 扫它无意义且会产出数 KB 的超长「行」,污染 TUI 展开渲染。
 export const IGNORE = ['**/node_modules/**', '**/.git/**', '**/.codegraph/**'];
@@ -56,6 +61,7 @@ export const PLAN_DISABLED_TOOLS = new Set([
     'memory_save',
     'memory_update',
     'memory_forget',
+    'memory_graph', // 混合工具(add 写图),plan 只读模式整体屏蔽
     'sub-agent',
     'run_skill', // fork 子 agent 执行面;plan 模式不应派生子工作流
 ]);

package/dist/ui/layout.js

@@ -1361,8 +1361,8 @@ function composeSpinnerLine(status, cols) {
         leadW = 1 + 1 + displayWidth(status.status) + (elapsed ? 1 + displayWidth(elapsed) : 0);
     }
     else if (spinning) {
-        // 运行态心跳帧(流式输出中):帧 + 生成中 + 走时
-        const label = '生成中';
+        // 运行态心跳帧(流式输出中 / 命令态如 /rollback /compact /resume):帧 + 状态文字(优先)或生成中(兜底) + 走时
+        const label = status.status || '生成中';
         const ePart = elapsed ? ` ${ui.dim}${elapsed}${ui.reset}` : '';
         lead = `${ui.bold}${ui.accent}${RUNNING_FRAMES[runningFrame]}${ui.reset} ${ui.dim}${label}${ui.reset}${ePart}`;
         leadW = 1 + 1 + displayWidth(label) + (elapsed ? 1 + displayWidth(elapsed) : 0);

package/dist/ui/theme.js

@@ -29,7 +29,7 @@ const DEFAULT = {
     brightCyan: '\x1B[38;2;86;182;194m',
     brightMagenta: '\x1B[38;2;198;120;221m',
     accent: '\x1B[38;2;86;182;194m', // 与 cyan 同源(One Dark):logo/标题/输入框顶线/选中项统一承载
-    userBg: '\x1B[48;2;44;49;60m', // One Dark current-line bg,深色终端上微妙可辨
+    userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
     // diff 行底色:One Dark bg #282c34 上加 ~14% 亮度的对应色,够辨识但不刺眼
     addBg: '\x1B[48;2;44;62;42m', // 偏暗绿(One Dark green(152,195,121)暗化)
     delBg: '\x1B[48;2;62;38;42m', // 偏暗红(One Dark red(224,108,117)暗化)
@@ -54,7 +54,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;42;161;152m',
         brightMagenta: '\x1B[38;2;108;113;196m',
         accent: '\x1B[38;2;38;139;210m', // Solarized blue:浅底下更醒目的强调
-        userBg: '\x1B[48;2;238;232;213m',
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:Solarized Light base2(238,232,213)上贴同色族浅 tint,
         // 比直接用 base1 更柔,跟深 fg(red/green)对比充足
         addBg: '\x1B[48;2;220;235;205m',
@@ -72,7 +72,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;147;161;161m',
         brightMagenta: '\x1B[38;2;108;113;196m',
         accent: '\x1B[38;2;42;161;152m', // Solarized cyan(深底版):暗底上跳出
-        userBg: '\x1B[48;2;7;54;66m',
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:Solarized Dark base03(0,43,54)上加对应色族暗 tint
         addBg: '\x1B[48;2;20;50;38m',
         delBg: '\x1B[48;2;55;30;30m',
@@ -89,7 +89,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;142;192;124m',
         brightMagenta: '\x1B[38;2;211;134;155m',
         accent: '\x1B[38;2;250;189;47m', // Gruvbox yellow(主题色)
-        userBg: '\x1B[48;2;40;40;40m',
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:Gruvbox dark bg(40,40,40)上贴暗 bg0_a 风格
         addBg: '\x1B[48;2;40;55;30m',
         delBg: '\x1B[48;2;70;35;30m',
@@ -106,7 +106,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;136;192;208m',
         brightMagenta: '\x1B[38;2;180;142;173m',
         accent: '\x1B[38;2;136;192;208m', // Nord 浅冰蓝(主题色)
-        userBg: '\x1B[48;2;67;76;94m',
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:Nord polar night(46,52,64)上贴对应色族暗 tint
         addBg: '\x1B[48;2;46;66;52m',
         delBg: '\x1B[48;2;72;46;52m',
@@ -126,7 +126,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;160;220;220m',
         brightMagenta: '\x1B[38;2;245;165;215m',
         accent: '\x1B[38;2;255;170;60m', // 南瓜橙(主题主色:logo/标题/输入框顶线/选中项)
-        userBg: '\x1B[48;2;55;42;32m', // 暖深棕(略亮于 #231c16 背景)
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:暖深棕底上贴对应色族暗 tint,跟 fg 配对柔和可辨
         addBg: '\x1B[48;2;55;70;35m',
         delBg: '\x1B[48;2;78;42;32m',
@@ -145,7 +145,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;170;220;220m',
         brightMagenta: '\x1B[38;2;250;160;200m',
         accent: '\x1B[38;2;230;90;150m', // 玫粉(主题主色)
-        userBg: '\x1B[48;2;50;32;46m', // 深紫底
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:深紫底贴对应色族暗 tint,绿暗化偏橄榄、红暗化偏紫红
         addBg: '\x1B[48;2;50;60;42m',
         delBg: '\x1B[48;2;75;40;52m',
@@ -164,7 +164,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;140;230;210m',
         brightMagenta: '\x1B[38;2;210;170;230m',
         accent: '\x1B[38;2;80;210;140m', // 翡翠绿(主题主色)
-        userBg: '\x1B[48;2;18;42;34m', // 深绿底
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:深绿底贴对应色族暗 tint,绿暗化偏深绿、红暗化偏暗红
         addBg: '\x1B[48;2;30;55;40m',
         delBg: '\x1B[48;2;60;40;40m',
@@ -183,7 +183,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;170;210;200m',
         brightMagenta: '\x1B[38;2;240;180;210m',
         accent: '\x1B[38;2;255;200;80m', // 琥珀金黄(主题主色)
-        userBg: '\x1B[48;2;43;31;14m', // 深棕底(比 orange 略浅,避免撞色)
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:深棕底贴对应色族暗 tint,绿暗化偏橄榄、红暗化偏暗棕红
         addBg: '\x1B[48;2;50;55;25m',
         delBg: '\x1B[48;2;70;40;28m',
@@ -202,7 +202,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;180;230;230m',
         brightMagenta: '\x1B[38;2;210;180;250m',
         accent: '\x1B[38;2;180;150;230m', // 薰衣草紫(主题主色)
-        userBg: '\x1B[48;2;31;26;46m', // 深紫底(比 rose 更冷)
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:深紫底贴对应色族暗 tint,绿暗化偏冷绿、红暗化偏冷紫红
         addBg: '\x1B[48;2;38;46;42m',
         delBg: '\x1B[48;2;60;40;55m',
@@ -221,7 +221,7 @@ const THEMES = {
         brightCyan: '\x1B[38;2;170;225;215m',
         brightMagenta: '\x1B[38;2;250;170;210m',
         accent: '\x1B[38;2;255;120;100m', // 珊瑚红(主题主色)
-        userBg: '\x1B[48;2;42;22;20m', // 深棕红底
+        userBg: '\x1B[48;2;72;78;90m', // 统一灰白用户消息底(黑底终端可见)
         // diff 行底色:深棕红底贴对应色族暗 tint,绿暗化偏橄榄、红暗化偏暗棕红
         addBg: '\x1B[48;2;50;55;30m',
         delBg: '\x1B[48;2;75;32;30m',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {