mocode-ai 1.7.9 → 1.7.11

package/dist/agent/index.js

@@ -130,7 +130,7 @@ function writeToolHeader(tc, toolRuntime) {
         const id = batch.beginBatch();
         currentBatchId = id;
         batch.bindCall(tc.id, id);
-        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments));
+        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments), tc.id);
         batch.showLiveBatch(id, layout);
     }
     else {
@@ -143,7 +143,7 @@ function writeToolHeader(tc, toolRuntime) {
         // 结果按 tool_call id 归位：并行执行时 currentBatchId 会漂移，只按“当前批”回填会漏填，
         // 摘要行就永远停在 ◇（用户实测：子 agent 跑完主侧菱形没变成实心圆）。
         batch.bindCall(tc.id, id);
-        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments));
+        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments), tc.id);
         // 第一条工具开始时立即落摘要；后续调用加入同一 batch，并原地刷新计数。
         batch.showLiveBatch(id, layout);
     }
@@ -160,7 +160,7 @@ function writeToolResult(tc, output, parsed, preWriteOld, editStartLine, toolRun
         // 无需独立批。全部 entry 完成后收口组容器批(落完成态 + 开放点击展开),
         // 并与后续内容约定一条分隔空行。
         const preview = summarizeToolResult(tc.name, output);
-        batch.recordResult(batchId, tc.name, preview, null, output, isToolErrorOutput(output), tc.id);
+        batch.recordResult(batchId, tc.name, preview, null, output, isToolErrorOutput(output), tc.id, layout);
         if (batch.isBatchComplete(batchId)) {
             batch.endBatch(batchId, layout);
             subAgentGroupId = null;
@@ -189,7 +189,7 @@ function writeToolResult(tc, output, parsed, preWriteOld, editStartLine, toolRun
         });
     }
     const preview = diff ? '' : summarizeToolResult(tc.name, output);
-    batch.recordResult(batchId, tc.name, preview, diff, output, isToolErrorOutput(output));
+    batch.recordResult(batchId, tc.name, preview, diff, output, isToolErrorOutput(output), tc.id, layout);
     batch.showLiveBatch(batchId, layout);
     // mutation 结果（成功 diff 或错误输出）立即可见，并阻止后续普通工具并入这一批。
     if (isMutationTool(tc.name, toolRuntime))
@@ -404,6 +404,7 @@ runtimeOrContext = defaultRuntime) {
             writeToolHeader(tc, runtime.context.toolRuntime);
         },
         onToolStart: (name) => spinner.start(t('agent.executing', { tool: name })),
+        onToolOutput: (tc, chunk) => batch.recordOutput(tc.id, chunk, layout),
         onToolDone: () => spinner.stop(),
         onToolResult: (tc, output, parsed, preWriteOld, editStartLine) => writeToolResult(tc, output, parsed, preWriteOld, editStartLine, runtime.context.toolRuntime),
         onToolBatchEnd: () => {

package/dist/agent/run-coordinator.js

@@ -326,6 +326,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                     delegation: delegationForOrchestrator,
                                     readDedup,
                                     argumentErrorHint: (name) => argumentErrorHint(name, runtimeContextState),
+                                    onToolOutput: (call, chunk) => hooks.onToolOutput?.(call, chunk),
                                     ...(opts.toolPolicy
                                         ? {
                                             expandToolGroups: (groups, reason) => opts.toolPolicy.expand(groups, reason),
@@ -396,6 +397,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         for (const index of eligibleReadonly) {
                                             startedReadonly[index] = ctx.toolRuntime.executeToolOutcome(calls[index].name, calls[index].arguments, signal, {
                                                 callId: calls[index].id,
+                                                onOutput: (chunk) => hooks.onToolOutput?.(calls[index], chunk),
                                                 allowedToolNames: currentAllowedToolNames(),
                                                 delegation: delegationForOrchestrator(),
                                                 readDedup,
@@ -566,6 +568,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         hooks.onToolStart?.(batch[0].name);
                                         const started = batch.map((tc) => ctx.toolRuntime.executeToolOutcome(tc.name, tc.arguments, signal, {
                                             callId: tc.id,
+                                            onOutput: (chunk) => hooks.onToolOutput?.(tc, chunk),
                                             allowedToolNames: currentAllowedToolNames(),
                                             delegation: delegationForOrchestrator(),
                                             readDedup,
@@ -663,6 +666,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                                     ? entry.denied
                                                     : await ctx.toolRuntime.executeToolOutcome(entry.tc.name, entry.tc.arguments, signal, {
                                                         callId: entry.tc.id,
+                                                        onOutput: (chunk) => hooks.onToolOutput?.(entry.tc, chunk),
                                                         allowedToolNames: currentAllowedToolNames(),
                                                         delegation: delegationForOrchestrator(),
                                                         readDedup,
@@ -751,6 +755,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                             const hint = argumentErrorHint(entry.tc.name, runtimeContextState);
                                             return ctx.toolRuntime.executeToolOutcome(entry.tc.name, entry.tc.arguments, signal, {
                                                 callId: entry.tc.id,
+                                                onOutput: (chunk) => hooks.onToolOutput?.(entry.tc, chunk),
                                                 allowedToolNames: currentAllowedToolNames(),
                                                 delegation: delegationForOrchestrator(),
                                                 readDedup,
@@ -846,6 +851,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         const serialHint = argumentErrorHint(tc.name, runtimeContextState);
                                         const outcome = await ctx.toolRuntime.executeToolOutcome(tc.name, tc.arguments, signal, {
                                             callId: tc.id,
+                                            onOutput: (chunk) => hooks.onToolOutput?.(tc, chunk),
                                             allowedToolNames: currentAllowedToolNames(),
                                             delegation: delegationForOrchestrator(),
                                             readDedup,

package/dist/agent/stages/tool-dispatcher.js

@@ -44,6 +44,7 @@ class LegacyCompatibleToolDispatcher {
         });
         const execute = (call, hint, onLockAcquired) => toolRuntime.executeToolOutcome(call.name, call.arguments, request.signal, {
             callId: call.id,
+            onOutput: (chunk) => request.onToolOutput?.(call, chunk),
             allowedToolNames: request.currentAllowedToolNames(),
             delegation: request.delegation(),
             readDedup: request.readDedup,

package/dist/agent/tool-helpers.js

@@ -13,6 +13,8 @@ import { defaultToolRuntime } from '../tools/registry.js';
 import { jailResolve } from '../sandbox/index.js';
 import { contextState } from '../session/compact.js';
 import { capToolResultForHistory } from '../session/compact.js';
+import { getActiveSessionStore } from '../session/store.js';
+import { getCurrentSessionId } from '../session/state.js';
 import { recordArtifact, knownEditTargets } from '../context/index.js';
 import { isToolResultSuccess } from '../context/utils.js';
 import { appendGuiAction } from '../session/gui-actions.js';
@@ -169,12 +171,27 @@ export function readDiffContext(tc, parsed, resolvePath = jailResolve) {
  *  不在这里改写旧正文;所有自动清理与压缩统一由 80% pressure scheduler 决定。 */
 export function pushToolResult(history, tc, output, pruner, lifecycle, _scheduler, runtimeContextState = contextState, succeededOverride) {
     const succeeded = succeededOverride ?? isToolResultSuccess(output);
+    const capped = capToolResultForHistory(tc.name, output);
+    // push-time 截断兜底:完整结果另存 compacted/result-<id>.txt,并在进 history 的
+    // 截断内容尾部留一行全文指针。仅主 agent(共享 contextState)落盘——子 agent 的
+    // 结果随其临时 history 消亡,不污染主会话。best-effort:存不上就只保留截断内容。
+    let content = capped;
+    if (capped.length < output.length && runtimeContextState === contextState) {
+        try {
+            const rel = getActiveSessionStore().archiveToolResult(getCurrentSessionId() ?? '', tc.id, output);
+            if (rel)
+                content = `${capped.replace(/\s+$/, '')}\n…[完整结果已归档,需要原文时 grep/read_file:${rel}]`;
+        }
+        catch {
+            // 归档失败不影响工具回灌。
+        }
+    }
     const msg = {
         role: 'tool',
         tool_call_id: tc.id,
         // Preserve evidence verbatim in normal operation; the hard per-result cap
         // remains solely as a request-size safety rail.
-        content: capToolResultForHistory(tc.name, output),
+        content,
     };
     history.push(msg);
     const messageIndex = history.length - 1;

package/dist/config/index.js

@@ -518,7 +518,10 @@ ${buildVoiceSection()}
     dynamicParts.push(`## Session state (\`.mocode/sessions/${sessionId ?? '<id>'}/notes.md\`)\n` +
         'For tasks with 3+ steps or context-loss risk, keep an execution plan with `plan_update`; record non-obvious findings/decisions/open questions/risks with `note_append`. ' +
         'Both write notes.md, which survives compaction — run read_file on it to recover context after compaction. ' +
-        'Their formats and rules live in each tool\u2019s description; do not hand-edit the files.');
+        'Their formats and rules live in each tool\u2019s description; do not hand-edit the files. ' +
+        'When compaction drops older conversation, its verbatim text (user messages, your earlier decisions, full tool args/results) is archived under ' +
+        `\`.mocode/sessions/${sessionId ?? '<id>'}/compacted/\` (see index.md there): the summary line ends with an [archived: …] pointer. ` +
+        'Before re-running a command or guessing what an old output said, grep that directory with glob narrowed to `.mocode/sessions/**` (required: .mocode is gitignored), then read_file the segment at the hit lines.');
     // 日期段:模型需要知道今天才能判断 freshness(web 搜索、版本时效)。只随天变化,
     // 不破坏会话内前缀缓存;置于 '## Session state' 之前,子 agent 切片仍保留(无害且有用)。
     const todaySection = buildTodaySection();

package/dist/headless.js

@@ -23,6 +23,8 @@ import { initializeAllMcp, getMcpTools, closeAllMcp } from './mcp/index.js';
 import { config, buildBasePrompt, isMemoryEnabled } from './config/index.js';
 import { effectiveSystemPrompt } from './skills/index.js';
 import { buildMemoryIndexSection } from './memory/store.js';
+import { buildAboutYouSection, initPersona } from './memory/persona.js';
+import { buildProjectGraphHint } from './memory/recall.js';
 import { defaultRuntime, Runtime } from './runtime/index.js';
 import { runAgentCore } from './agent/core.js';
 import { summarizeToolCall, summarizeToolResult } from './ui/render.js';
@@ -154,7 +156,12 @@ export async function runHeadless(opts) {
         }
     }
     // 系统提示：Bot 岗位角色在前，基础约定在后；白名单存在时补一句工具边界。
-    const baseConventions = buildBasePrompt(sessionId) + buildMemoryIndexSection(isMemoryEnabled());
+    const memoryOn = isMemoryEnabled();
+    initPersona(memoryOn);
+    const baseConventions = buildBasePrompt(sessionId) +
+        buildAboutYouSection(memoryOn) +
+        buildMemoryIndexSection(memoryOn) +
+        buildProjectGraphHint(memoryOn);
     const systemContent = botInfo
         ? `# Role\n${botInfo.bot.systemPrompt}\n\n` +
             `${botInfo.bot.description ? `**Position:** ${botInfo.bot.description}\n\n` : ''}` +

package/dist/i18n/index.js

@@ -164,6 +164,8 @@ const zhCN = {
     'repl.queuedCommandHeld': '排队的是斜杠命令，已填入输入框，请确认后手动发送',
     'repl.loadFailed': '（加载失败）',
     'repl.resumeAnchor': '已恢复会话 {id} · {count} 条消息 · 当前模型 {model}（/model switch 可切换）',
+    'repl.compactedNotice': '── 更早的对话已被压缩成摘要（助手回复与工具过程不再保留），以下为摘要与保留的用户原话 ──',
+    'repl.compactedTruncated': '…（摘要共 {total} 字符，仅显示前 {shown} 字符）',
     'repl.noSessions': '（没有已保存的会话）',
     'repl.noValue': '（无）',
     'repl.historyCleared': '（历史已清空，保留系统提示）',
@@ -554,6 +556,8 @@ const en = {
     'repl.queuedCommandHeld': 'Queued text is a slash command; filled into the input for you to send manually',
     'repl.loadFailed': '(load failed)',
     'repl.resumeAnchor': 'Resumed session {id} · {count} messages · model {model} (/model switch to change)',
+    'repl.compactedNotice': '── Earlier conversation was compacted into a summary (assistant replies and tool steps are not kept); below are the summary and the preserved user messages ──',
+    'repl.compactedTruncated': '… (summary is {total} chars, showing the first {shown})',
     'repl.noSessions': '(no saved sessions)',
     'repl.noValue': '(none)',
     'repl.historyCleared': '(history cleared; system prompt kept)',

package/dist/index.js

@@ -252,7 +252,7 @@ async function main() {
             }
             process.exit(0);
         }
-        const loaded = loadSession(id);
+        const loaded = loadSession(id, { restoreAssets: true });
         if (!loaded || !loaded.history.length) {
             console.error(t('cli.sessionMissing', { id }));
             process.exit(1);

package/dist/memory/graph.js

@@ -93,7 +93,7 @@ function writeGraphForScope(scope, g) {
     writeGraphAtomic(p, { entities: g.entities, edges: g.edges });
 }
 /** 单 scope 的完整图(读文件,scope 归一化)。 */
-function loadScopeGraph(scope) {
+export function loadScopeGraph(scope) {
     const g = readGraphFile(graphPathForScope(scope));
     for (const e of g.entities)
         e.scope = scope;
@@ -125,6 +125,7 @@ export function upsertEntity(name, opts = {}) {
     const trimmed = name.trim();
     if (!trimmed)
         return { id: '', created: false, rejected: 'empty-name' };
+    const nextType = opts.type?.trim() || undefined;
     const g = loadScopeGraph(scope);
     const hit = findEntityIn(g, trimmed);
     if (hit) {
@@ -137,6 +138,10 @@ export function upsertEntity(name, opts = {}) {
             hit.summary = opts.summary.trim();
             dirty = true;
         }
+        if (nextType && (hit.type ?? '') !== nextType) {
+            hit.type = nextType;
+            dirty = true;
+        }
         if (dirty) {
             hit.updatedAt = nowIso();
             writeGraphForScope(scope, g);
@@ -163,6 +168,7 @@ export function upsertEntity(name, opts = {}) {
         name: trimmed,
         aliases: opts.alias && norm(opts.alias) !== norm(trimmed) ? [opts.alias.trim()] : [],
         summary: opts.summary?.trim() ?? '',
+        type: nextType,
         createdAt: now,
         updatedAt: now,
         scope,
@@ -257,6 +263,95 @@ export function searchGraph(query, limit = 8) {
     const edges = g.edges.filter((e) => !e.invalidAt && (hitIds.has(e.src) || hitIds.has(e.dst)));
     return { entities: scored.map((x) => x.e), edges };
 }
+// ── 边(事实)级词面检索:供 memory_search 的图谱事实段 ─────────────────────
+// searchGraph 是实体名/别名子串匹配,中文整句 fact 与多词 query 召回弱。这里用
+// context/text-search 的 CJK 分词(unigram+bigram)对「端点实体名/别名 + relation +
+// fact」做加权词面打分,再做一跳邻接扩展(命中实体相连的其它 active 边,降权补全)。
+import { tokenize } from '../context/text-search.js';
+const FIELD_WEIGHTS = { name: 6, alias: 4, fact: 2, relation: 2 };
+/** 统计 query terms 在一段文本里的命中次数。 */
+function termHits(terms, text) {
+    if (!text)
+        return 0;
+    const lower = text.toLowerCase();
+    let hits = 0;
+    for (const t of terms)
+        if (lower.includes(t))
+            hits++;
+    return hits;
+}
+/**
+ * 边级相关度检索。仅 active 边;按 scope 过滤。排序:score 降序、其次边 id(稳定)。
+ * 要求至少一个 query term 直接命中才返回(邻接边依附于直接命中,不会凭空出现)。
+ */
+export function searchGraphFacts(query, opts = {}) {
+    const terms = [...new Set(tokenize(query))];
+    if (terms.length === 0)
+        return [];
+    const scope = opts.scope ?? 'all';
+    const limit = Math.max(1, opts.limit ?? 8);
+    const neighborCap = Math.max(0, opts.neighbors ?? 4);
+    const g = loadAllGraph();
+    const inScope = (s) => scope === 'all' || s === scope;
+    const byId = new Map(g.entities.map((e) => [e.id, e]));
+    const activeEdges = g.edges.filter((e) => !e.invalidAt && inScope(e.scope));
+    const scoreEdge = (e) => {
+        const src = byId.get(e.src);
+        const dst = byId.get(e.dst);
+        let score = 0;
+        if (src) {
+            score += termHits(terms, src.name) * FIELD_WEIGHTS.name;
+            for (const a of src.aliases)
+                score += termHits(terms, a) * FIELD_WEIGHTS.alias;
+        }
+        if (dst) {
+            score += termHits(terms, dst.name) * FIELD_WEIGHTS.name;
+            for (const a of dst.aliases)
+                score += termHits(terms, a) * FIELD_WEIGHTS.alias;
+        }
+        score += termHits(terms, e.relation) * FIELD_WEIGHTS.relation;
+        score += termHits(terms, e.fact) * FIELD_WEIGHTS.fact;
+        return score;
+    };
+    const direct = activeEdges
+        .map((edge) => ({ edge, score: scoreEdge(edge) }))
+        .filter((x) => x.score > 0)
+        .sort((a, b) => b.score - a.score || a.edge.id.localeCompare(b.edge.id));
+    const chosen = [];
+    const chosenIds = new Set();
+    const hitEndpoints = new Set();
+    for (const { edge, score } of direct.slice(0, limit)) {
+        chosen.push({
+            edge,
+            srcEntity: byId.get(edge.src) ?? null,
+            dstEntity: byId.get(edge.dst) ?? null,
+            score,
+            viaNeighbor: false,
+        });
+        chosenIds.add(edge.id);
+        hitEndpoints.add(edge.src);
+        hitEndpoints.add(edge.dst);
+    }
+    // 一跳邻接:命中实体相连的其它 active 边,固定降权(0.45× 直接边的保底分),补足上下文。
+    if (neighborCap > 0 && chosen.length > 0) {
+        const directTop = direct[0]?.score ?? 1;
+        const neighborScore = Math.max(1, Math.round(directTop * 0.45));
+        const extras = activeEdges
+            .filter((e) => !chosenIds.has(e.id) && (hitEndpoints.has(e.src) || hitEndpoints.has(e.dst)))
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .slice(0, neighborCap);
+        for (const edge of extras) {
+            chosen.push({
+                edge,
+                srcEntity: byId.get(edge.src) ?? null,
+                dstEntity: byId.get(edge.dst) ?? null,
+                score: neighborScore,
+                viaNeighbor: true,
+            });
+        }
+    }
+    return chosen;
+}
 function buildAdjacency(g, relation) {
     const adj = new Map();
     for (const e of g.edges) {
@@ -407,3 +502,169 @@ export function graphStats() {
         byScope: { project: count('project'), global: count('global') },
     };
 }
+// ── 规范用户画像实体(G0 身份归一)──────────────────────────────────────────
+//
+// 全局图里历史上反思自由起名,把同一个用户碎成多个实体(实测:mocode user / 万 /
+// user-name-wanjizhu / user-role-… 互不相连)。这里固定一个主键实体,所有"关于人"
+// 的属性都挂到它身上;角色值(user-role-*)是属性的**值**不是人,不并入。
+/** 全局规范用户实体的固定 id(概念名 person:primary,实现用文件安全 slug)。 */
+export const PRIMARY_PERSON_ID = 'person-primary';
+/** 规范用户实体的轻量类型标记。 */
+export const PERSON_TYPE = 'Person';
+/** 未分型实体的占位类型(历史数据无 type 字段时按此处理,不参与跨类型守卫)。 */
+export const UNKNOWN_TYPE = 'unknown';
+/** 实体有效类型(缺省/空串视为 unknown)。 */
+function entityType(e) {
+    const t = (e.type ?? '').trim();
+    return t || UNKNOWN_TYPE;
+}
+/** 判定一个全局实体是否"用户指称碎片"(应并入 primary),角色值实体除外。 */
+function isPersonFragment(e, selfNameHints) {
+    const id = e.id.toLowerCase();
+    const name = e.name.trim().toLowerCase();
+    if (id === PRIMARY_PERSON_ID)
+        return false;
+    if (id.startsWith('user-role-'))
+        return false; // 角色值,不是人
+    if (id === 'mocode-user' || name === 'mocode user')
+        return true;
+    if (id.startsWith('user-name-'))
+        return true;
+    // 经 named 边收集到的自称(如"万")
+    if (selfNameHints.has(name))
+        return true;
+    return false;
+}
+/** 确保全局规范用户实体存在(固定 id,绕过自由 slug);返回其最新内容。 */
+export function ensurePrimaryPerson(displayName) {
+    const scope = 'global';
+    const g = loadScopeGraph(scope);
+    let p = g.entities.find((e) => e.id === PRIMARY_PERSON_ID);
+    if (!p) {
+        const now = nowIso();
+        p = {
+            id: PRIMARY_PERSON_ID,
+            name: (displayName ?? 'user').trim() || 'user',
+            aliases: [],
+            summary: '规范用户实体(所有跨项目的用户画像属性挂这里)',
+            type: PERSON_TYPE,
+            createdAt: now,
+            updatedAt: now,
+            scope,
+        };
+        g.entities.push(p);
+        writeGraphForScope(scope, g);
+        return p;
+    }
+    let dirty = false;
+    if (entityType(p) !== PERSON_TYPE) {
+        p.type = PERSON_TYPE; // 历史库回填:G0 已建的 primary 当时无 type
+        dirty = true;
+    }
+    if (displayName && displayName.trim() && displayName.trim() !== p.name) {
+        if (!p.aliases.includes(p.name))
+            p.aliases.push(p.name);
+        p.name = displayName.trim();
+        dirty = true;
+    }
+    if (!p.summary) {
+        p.summary = '规范用户实体(所有跨项目的用户画像属性挂这里)';
+        dirty = true;
+    }
+    if (dirty) {
+        p.updatedAt = nowIso();
+        writeGraphForScope(scope, g);
+    }
+    return p;
+}
+/**
+ * 把同一 scope 内 source 实体并入 target:
+ *  - source 的 active 边 endpoint 改写为 target;改写后与 target 现有 active 边
+ *    (src,relation,dst) 全等的重复边置 invalidAt(时序失效,不删);
+ *  - source 名字/别名并入 target.aliases;source 标 mergedInto 保留(可追溯、可被别名词命中)。
+ * 类型守卫(轻量本体):双方都已明确分型(非 unknown)且类型不同 → 拒绝,防止把
+ * Port/Hobby 等异类实体误并进 Person;任一方 unknown(历史未分型)则照常允许。
+ * 幂等:source===target 或不存在则 no-op(null)。
+ */
+export function mergeEntities(targetId, sourceId, scope = 'global') {
+    if (targetId === sourceId)
+        return null;
+    const g = loadScopeGraph(scope);
+    const target = g.entities.find((e) => e.id === targetId);
+    const source = g.entities.find((e) => e.id === sourceId);
+    if (!target || !source)
+        return null;
+    const tt = entityType(target);
+    const st = entityType(source);
+    if (tt !== UNKNOWN_TYPE && st !== UNKNOWN_TYPE && tt !== st) {
+        return { target: targetId, merged: [], dedupedEdges: 0, rejected: `type-mismatch: ${st} != ${tt}` };
+    }
+    const activeOf = (id) => g.edges.filter((e) => !e.invalidAt && (e.src === id || e.dst === id));
+    const existsActive = (src, relation, dst) => g.edges.some((e) => !e.invalidAt && e.src === src && e.relation === relation && e.dst === dst);
+    let dedupedEdges = 0;
+    for (const edge of activeOf(sourceId)) {
+        const nextSrc = edge.src === sourceId ? targetId : edge.src;
+        const nextDst = edge.dst === sourceId ? targetId : edge.dst;
+        if (nextSrc === nextDst) {
+            edge.invalidAt = nowIso(); // 自指环(并入自己)无意义,失效
+            dedupedEdges++;
+            continue;
+        }
+        if (existsActive(nextSrc, edge.relation, nextDst) && (nextSrc !== edge.src || nextDst !== edge.dst)) {
+            edge.invalidAt = nowIso(); // target 已有等价 active 边,去重
+            dedupedEdges++;
+            continue;
+        }
+        edge.src = nextSrc;
+        edge.dst = nextDst;
+    }
+    const addAlias = (a) => {
+        const v = a.trim();
+        if (v && v !== target.name && !target.aliases.includes(v))
+            target.aliases.push(v);
+    };
+    addAlias(source.name);
+    for (const a of source.aliases)
+        addAlias(a);
+    source.mergedInto = targetId;
+    source.updatedAt = nowIso();
+    target.updatedAt = nowIso();
+    writeGraphForScope(scope, g);
+    return { target: targetId, merged: [sourceId], dedupedEdges };
+}
+/**
+ * 一次性身份归一(幂等):确保 person-primary 存在,把全局图里的用户指称碎片
+ * (mocode-user / user-name-* / 沿 named 边找到的自称,如"万")并入它。
+ * 角色值实体(user-role-*)、兴趣、地点、项目/工具实体不碰。返回合并报告(无操作时 merged 为空)。
+ */
+export function canonicalizePrimaryPerson() {
+    const scope = 'global';
+    const g = loadScopeGraph(scope);
+    // 沿 named 边收集自称:X --named--> N,则 N.name 是用户的名字。
+    const selfNameHints = new Set();
+    for (const e of g.edges) {
+        if (e.invalidAt || e.relation !== 'named')
+            continue;
+        const src = g.entities.find((x) => x.id === e.src);
+        const dst = g.entities.find((x) => x.id === e.dst);
+        if (src && dst && (src.id === 'mocode-user' || src.id.startsWith('user-name-') || /user/i.test(src.name))) {
+            selfNameHints.add(dst.name.trim().toLowerCase());
+        }
+    }
+    const fragments = g.entities.filter((e) => isPersonFragment(e, selfNameHints));
+    // 显示名:优先最短的中文/字母自称(通常是"万"),退回已存在 primary 的名字。
+    const existing = g.entities.find((e) => e.id === PRIMARY_PERSON_ID);
+    const nameCandidates = [...selfNameHints].filter((n) => n && !/^user/.test(n));
+    const displayName = nameCandidates.sort((a, b) => a.length - b.length)[0] ?? existing?.name ?? null;
+    ensurePrimaryPerson(displayName ?? undefined);
+    let deduped = 0;
+    const merged = [];
+    for (const f of fragments) {
+        const r = mergeEntities(PRIMARY_PERSON_ID, f.id, scope);
+        if (r && !r.rejected) {
+            merged.push(f.id);
+            deduped += r.dedupedEdges;
+        }
+    }
+    return { primary: PRIMARY_PERSON_ID, displayName, merged, dedupedEdges: deduped };
+}

package/dist/memory/index.js

@@ -3,5 +3,7 @@
 // (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 { addTriple, upsertEntity, findEntity, searchGraph, searchGraphFacts, neighborsOf, pathBetween, graphStats, ensurePrimaryPerson, mergeEntities, canonicalizePrimaryPerson, PRIMARY_PERSON_ID, } from './graph.js';
+export { buildAboutYouSection, initPersona, __resetPersonaInitForTests, ABOUT_YOU_MAX_CHARS } from './persona.js';
+export { buildProjectGraphHint, GRAPH_HINT_MAX_CHARS } from './recall.js';
 export { kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, runReflection, } from './reflect.js';

package/dist/memory/persona.js

@@ -0,0 +1,142 @@
+// persona.ts —— 全局「用户画像」内化层(Memory 2.1 双轨的 global 轨)。
+//
+// 与 buildMemoryIndexSection(条目摘要、按需召回、会衰减)不同,这里产出的
+// `## About you` 是**高等级(L2)画像**:锚定在全局规范实体 person-primary 的
+// active 图谱边上,每个会话无条件常驻 system prompt,体量硬封顶以保护 prompt cache。
+// 身份类事实用图谱时序边表达(换工作/搬家时旧边 invalidAt),天然不受 memory 条目
+// 30 天衰减影响——这是"越用越懂用户"那条易失通道之外的确定性内化通道。
+//
+// 纯读、不建实体(建实体/归一走 graph.canonicalizePrimaryPerson,在启动期显式做)。
+import { loadScopeGraph, canonicalizePrimaryPerson, PRIMARY_PERSON_ID, } from './graph.js';
+/** About you 段硬预算(字符):只放高等级画像,超了按置信/顺序截断。 */
+export const ABOUT_YOU_MAX_CHARS = 800;
+/** 关系 → 人类可读标签(画像白名单;不在表内的关系用 fact 原文,仍可展示)。 */
+const RELATION_LABEL = {
+    named: '称呼',
+    has_role: '角色',
+    works_at: '就职于',
+    located_in: '所在地',
+    speaks: '语言',
+    verbosity: '回复详略',
+    communication_style: '沟通风格',
+    current_goal: '当前目标',
+    constraint: '约束',
+    prefers: '偏好',
+    avoids: '避免',
+    travel_preference: '旅行偏好',
+    has_hobby: '兴趣',
+    skill_level: '擅长',
+    related_to: '相关',
+};
+function displayName(name) {
+    // 图谱里部分历史实体名是 snake_case(leisure_travel / hangzhou),展示时松绑。
+    if (/[\u4e00-\u9fff]/.test(name))
+        return name;
+    return name.replace(/[_-]+/g, ' ').trim();
+}
+/**
+ * 渲染全局 L2 画像段。无 person-primary / 无 active 画像边 → 空串(零注入)。
+ * 优先用边上的中文 fact 原文;没有 fact 时用「关系标签 + 目标实体名」。
+ * 同名去重;has_hobby 合并为一行;整体截断到 ABOUT_YOU_MAX_CHARS。
+ */
+export function buildAboutYouSection(memoryEnabled = true) {
+    if (!memoryEnabled)
+        return '';
+    const g = loadScopeGraph('global');
+    const me = g.entities.find((e) => e.id === PRIMARY_PERSON_ID);
+    if (!me)
+        return '';
+    const byId = new Map(g.entities.map((e) => [e.id, e]));
+    const outgoing = g.edges.filter((e) => !e.invalidAt && e.src === PRIMARY_PERSON_ID && e.dst !== PRIMARY_PERSON_ID);
+    if (outgoing.length === 0)
+        return '';
+    const hobbies = [];
+    const lines = [];
+    const seen = new Set();
+    const push = (text, relation) => {
+        const key = text.trim();
+        if (!key || seen.has(key))
+            return;
+        seen.add(key);
+        lines.push({ text: key, relation });
+    };
+    for (const e of outgoing) {
+        const dst = byId.get(e.dst);
+        const target = dst ? displayName(dst.name) : displayName(e.dst);
+        if (e.relation === 'has_hobby') {
+            if (target && !hobbies.includes(target))
+                hobbies.push(target);
+            continue;
+        }
+        if (e.fact && e.fact.trim()) {
+            push(e.fact.trim(), e.relation);
+        }
+        else {
+            const label = RELATION_LABEL[e.relation] ?? e.relation.replace(/_/g, ' ');
+            push(`${label}:${target}`, e.relation);
+        }
+    }
+    if (hobbies.length)
+        push(`兴趣:${hobbies.join('、')}`, 'has_hobby');
+    if (lines.length === 0)
+        return '';
+    // 稳定排序:白名单关系按预定义优先级,其余按文本;让输出跨会话稳定(护 cache)。
+    const order = Object.keys(RELATION_LABEL);
+    lines.sort((a, b) => {
+        const ia = order.indexOf(a.relation);
+        const ib = order.indexOf(b.relation);
+        if (ia !== ib)
+            return (ia === -1 ? 999 : ia) - (ib === -1 ? 999 : ib);
+        return a.text.localeCompare(b.text);
+    });
+    const header = `## About you(长期用户画像,跨项目始终生效)`;
+    // 内部 slug 实体名(mocode user / user-name-* 归一后留下的别名)不作为"又称"展示。
+    const visibleAliases = me.aliases
+        .map(displayName)
+        .filter((a) => a && a !== displayName(me.name) && !/^(mocode user|user name)\b/i.test(a));
+    const nameLine = `- 用户:${displayName(me.name)}${visibleAliases.length ? `(又称 ${visibleAliases.join('、')})` : ''}`;
+    const body = ['', header, nameLine, ...lines.map((l) => `- ${l.text}`)].join('\n');
+    if (body.length <= ABOUT_YOU_MAX_CHARS)
+        return body;
+    // 截断:从低优先级行往前丢,保住身份/地点/目标等高等级项。
+    const kept = [header, nameLine];
+    let budget = ABOUT_YOU_MAX_CHARS - kept.join('\n').length;
+    for (const l of lines) {
+        const piece = `- ${l.text}`;
+        if (piece.length + 1 > budget)
+            continue;
+        kept.push(piece);
+        budget -= piece.length + 1;
+    }
+    return kept.join('\n');
+}
+/** 仅供测试/调试:列出 person-primary 当前 active 画像边(原始结构)。 */
+export function inspectPrimaryProfile() {
+    const g = loadScopeGraph('global');
+    const me = g.entities.find((e) => e.id === PRIMARY_PERSON_ID) ?? null;
+    const edges = g.edges.filter((e) => !e.invalidAt && (e.src === PRIMARY_PERSON_ID || e.dst === PRIMARY_PERSON_ID));
+    return { me, edges };
+}
+let personaInitialized = false;
+/**
+ * 启动期幂等初始化:做一次全局身份归一(把 mocode-user / user-name-* / 自称等碎片
+ * 并入 person-primary)。每进程至多一次;记忆开关关闭时不碰图谱。best-effort——
+ * 归一失败不应影响 REPL 启动(调用方自行 catch)。
+ */
+export function initPersona(memoryEnabled = true) {
+    if (personaInitialized)
+        return;
+    personaInitialized = true;
+    if (!memoryEnabled)
+        return;
+    try {
+        canonicalizePrimaryPerson();
+    }
+    catch {
+        // 归一只是增强(图谱损坏/IO 异常),绝不能拖垮 REPL 启动。
+    }
+}
+/** 测试专用:重置进程内初始化标记。 */
+export function __resetPersonaInitForTests() {
+    personaInitialized = false;
+}