mocode-ai 1.2.3 → 1.2.5

package/dist/agent/index.js

@@ -118,8 +118,9 @@ function writeToolHeader(tc) {
         }
         return;
     }
-    // sub-agent 组还在跑但普通/mutation 工具先来了：收口 sub-agent 组，并补一条分隔空行。
-    if (subAgentGroupId) {
+    // sub-agent 组还在跑，或组刚收口但尚未写入分隔空行时，
+    // 普通/mutation 工具先来了：先 flush 补一条分隔空行，避免摘要行粘在一起。
+    if (subAgentGroupId || subAgentGroupPendingSeparator) {
         flushToolBatch();
     }
     if (isMutationTool(tc.name)) {

package/dist/agent/spawn.js

@@ -74,6 +74,8 @@ export async function spawnAgent(opts) {
     const requested = opts.tools?.length ? new Set(opts.tools) : null;
     const readOnly = new Set(['read_file', 'glob', 'grep', 'web_search', 'web_fetch', 'use_skill', 'memory_search', 'memory_list']);
     toolsOverride = chatTools.filter((tool) => tool.function.name !== 'sub-agent' &&
+        // run_skill 会再次 spawn,禁止递归(避免 fork skill 里又 run_skill 套娃)。
+        tool.function.name !== 'run_skill' &&
         // plan_update 直写主会话 notes.md(不走 overlay),子代理不应改动主计划——统一排除。
         tool.function.name !== 'plan_update' &&
         (!requested || requested.has(tool.function.name)) &&
@@ -93,7 +95,11 @@ export async function spawnAgent(opts) {
     // 主屏实时渲染(子 agent 透明化):TUI 激活时把子 agent 内部步骤实时写入主内容区,
     // 复用 batch 折叠机制(mouse 点击摘要行可展开/收起)。TUI 未激活(host/非 TTY)时
     // 保持纯静默——只缓冲 transcript,不写屏,兼容嵌入宿主。
-    const live = isTuiActive();
+    //
+    // quiet 模式(供 run_skill 等 opaque workflow 用):不产可展开 batch,
+    // 只在首次工具调用时写一行「◐ 执行 skill…」,完成后替换为「● skill 完成: 摘要」。
+    const live = isTuiActive() && !opts.quiet;
+    const quiet = isTuiActive() && !!opts.quiet;
     let liveBatchId = null;
     const liveLayout = () => ({
         contentWrite: (s) => layout.contentWrite(s),
@@ -106,6 +112,16 @@ export async function spawnAgent(opts) {
     });
     /** 本批是否挂在主侧调用行下(挂上了就由主侧负责分隔空行,自己不能往 buffer 末尾追加)。 */
     let nested = false;
+    // quiet 模式:完全静默,不写任何行(连 spinner 都没有);
+    // 子 agent 的执行过程与结果只回灌为主 agent 的 run_skill 工具结果。
+    const ensureQuietLine = (_label) => {
+        if (!quiet)
+            return; // 静默:什么都不输出
+    };
+    const replaceQuietLine = (_status, _detail) => {
+        if (!quiet)
+            return; // 静默:什么都不输出
+    };
     const ensureLiveBatch = () => {
         if (!live || liveBatchId)
             return;
@@ -163,6 +179,7 @@ export async function spawnAgent(opts) {
             const summary = summarizeToolCall(tc.name, tc.arguments);
             writeBuf(`  ● ${tc.name}  ${summary}\n`);
             // 实时写入主内容区:子 agent 的每次工具调用累计到摘要行计数。
+            ensureQuietLine(opts.quietLabel ?? t('skill.executing', { name: opts.prompt.slice(0, 40) }));
             ensureLiveBatch();
             if (liveBatchId) {
                 batch.recordCall(liveBatchId, tc.name, summary);
@@ -198,6 +215,8 @@ export async function spawnAgent(opts) {
         onMaxSteps: () => {
             writeBuf(`  ● 达到最大步数(${maxSteps}),子 agent 停止。\n`);
             finishLiveBatch('failed');
+            if (quiet)
+                replaceQuietLine('failed', t('skill.maxSteps', { max: String(maxSteps) }));
         },
         onDone: (elapsedMs, usage) => {
             const tok = usage && usage.totalTokens
@@ -205,10 +224,15 @@ export async function spawnAgent(opts) {
                 : '';
             writeBuf(`  ✻ 子 agent 耗时 ${(elapsedMs / 1000).toFixed(1)}s${tok}\n`);
             finishLiveBatch('complete');
+            if (quiet) {
+                replaceQuietLine('complete', `${t('skill.complete')}  ${(elapsedMs / 1000).toFixed(1)}s${tok}`);
+            }
         },
         onAbort: () => {
             // 中断:子 agent 未完成,收尾批(不折叠——用户可能想看中断前做了什么)。
             finishLiveBatch('aborted');
+            if (quiet)
+                replaceQuietLine('aborted', t('skill.aborted'));
         },
         // onStepStart / onChatDone / onToolStart / onToolDone:子 agent 静默,无需 spinner 渲染。
         // abort 还原(history 还原 + 模式还原)由 core 的 abortRestore 处理,hooks 只管展示。

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/context/pipeline.js

@@ -37,7 +37,7 @@ function tryParseArgs(raw) {
  * 仅作 encoder 软目标;最终裁剪仍由末尾 capToolResultForHistory 兜底,故两处常量偶有漂移不致命。
  */
 function budgetFor(name) {
-    if (name === 'use_skill')
+    if (name === 'use_skill' || name === 'run_skill')
         return MAX_SKILL_RESULT;
     if (name === 'memory_search')
         return MAX_MEMORY_RESULT;

package/dist/i18n/index.js

@@ -217,6 +217,10 @@ const zhCN = {
     'subagent.stateOff': '关闭',
     'subagent.changedOn': '已开启子 Agent；sub-agent 将从下一次模型请求起可用。',
     'subagent.changedOff': '已关闭子 Agent；sub-agent 已从模型工具表移除。',
+    'skill.executing': '执行 skill: {name}…',
+    'skill.complete': 'Skill 执行完成',
+    'skill.aborted': 'Skill 执行已中断',
+    'skill.maxSteps': 'Skill 达到最大步数({max})',
     'subagent.usage': '用法：/subagent on|off|status',
     'fe.status': '前端工具簇：{state}',
     'fe.stateOn': '开启',
@@ -472,6 +476,10 @@ const en = {
     'subagent.stateOff': 'disabled',
     'subagent.changedOn': 'Sub-agents enabled; sub-agent will be available from the next model request.',
     'subagent.changedOff': 'Sub-agents disabled; sub-agent has been removed from the model tool list.',
+    'skill.executing': 'Executing skill: {name}…',
+    'skill.complete': 'Skill complete',
+    'skill.aborted': 'Skill aborted',
+    'skill.maxSteps': 'Skill reached max steps ({max})',
     'subagent.usage': 'Usage: /subagent on|off|status',
     'fe.status': 'Frontend tools: {state}',
     'fe.stateOn': 'enabled',

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})`);
     }