mocode-ai 1.7.9 → 1.7.11

package/dist/memory/recall-stats.js

@@ -0,0 +1,61 @@
+// recall-stats.ts —— 项目图谱 pull 召回的轻量埋点。
+//
+// 目的(memory-2.2 决策):项目图谱曾"只写不读"。pull 通道(常驻 hint + memory_search
+// 强化)上线后,用零依赖计数器回答"模型到底有没有在用图谱":搜了几次、图谱段有几次命中。
+// 数据只存项目 <cwd>/.mocode/memory-recall-stats.json,供 memory_graph stats 展示,据此
+// 决定要不要再加"turn 起步阈值注入"的安全网。全部静默容错、tmp+rename 原子写。
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+const EMPTY = { searches: 0, graphHits: 0, graphEmpty: 0, lastSearchedAt: null };
+function statsPath() {
+    return path.join(process.cwd(), '.mocode', 'memory-recall-stats.json');
+}
+/** 读取项目召回统计;文件缺失/损坏一律返回零值(不抛错)。 */
+export function readRecallStats() {
+    try {
+        const p = statsPath();
+        if (!existsSync(p))
+            return { ...EMPTY };
+        const obj = JSON.parse(readFileSync(p, 'utf8'));
+        return {
+            searches: Number.isFinite(obj.searches) ? Number(obj.searches) : 0,
+            graphHits: Number.isFinite(obj.graphHits) ? Number(obj.graphHits) : 0,
+            graphEmpty: Number.isFinite(obj.graphEmpty) ? Number(obj.graphEmpty) : 0,
+            lastSearchedAt: typeof obj.lastSearchedAt === 'string' ? obj.lastSearchedAt : null,
+        };
+    }
+    catch {
+        return { ...EMPTY };
+    }
+}
+/**
+ * 记录一次 memory_search。graphHit=true 表示图谱事实段非空。
+ * 返回更新后的统计;写盘失败静默(埋点绝不影响检索主流程)。
+ */
+export function recordRecallSearch(graphHit) {
+    const s = readRecallStats();
+    s.searches += 1;
+    if (graphHit)
+        s.graphHits += 1;
+    else
+        s.graphEmpty += 1;
+    s.lastSearchedAt = new Date().toISOString();
+    try {
+        const p = statsPath();
+        mkdirSync(path.dirname(p), { recursive: true });
+        const tmp = p + '.tmp';
+        writeFileSync(tmp, JSON.stringify(s, null, 2), 'utf8');
+        renameSync(tmp, p);
+    }
+    catch {
+        // 静默:埋点不可写不影响功能
+    }
+    return s;
+}
+/** 一行人类可读摘要(供 memory_graph stats)。 */
+export function formatRecallStats(s = readRecallStats()) {
+    if (s.searches === 0)
+        return '图谱召回:尚无 memory_search 调用(pull 通道未被使用)';
+    const rate = Math.round((s.graphHits / s.searches) * 100);
+    return `图谱召回:memory_search ${s.searches} 次,图谱命中 ${s.graphHits}(${rate}%) / 空 ${s.graphEmpty}`;
+}

package/dist/memory/recall.js

@@ -0,0 +1,47 @@
+// recall.ts —— 项目知识图谱的「可检索性」提示(pull 召回的触发器)。
+//
+// 问题:项目 triples 写入 memory-graph.json 后,常驻上下文里没有任何线索告诉模型
+// "仓库里存了这些事实",模型不知道要搜 → 85 条事实近乎只写不读。这里产出一小段
+// 稳定的项目图谱提示(主要主题实体 + 检索指引),拼进 system prompt,让模型在相关时
+// 主动 memory_search / memory_graph。只给"地图"不给正文,正文仍走按需 pull(零空转成本)。
+//
+// 与 About you(global、内化画像)对称:这是 project 轨、可检索的仓库事实索引。
+// 纯读、叶子依赖(graph)。内容只依赖图文件,会话内不随每步变化(同 Memory Index 的启动快照语义)。
+import { loadScopeGraph } from './graph.js';
+/** 图谱提示段硬预算(字符)。 */
+export const GRAPH_HINT_MAX_CHARS = 600;
+/** 列出的主题实体上限。 */
+const GRAPH_HINT_TOP_ENTITIES = 12;
+/**
+ * 项目图谱常驻提示:无 active 边 → 空串(零注入)。
+ * 主题实体按 active 度数(参与的 active 边数)降序、再按名字排序,取前 N。
+ */
+export function buildProjectGraphHint(memoryEnabled = true, scope = 'project') {
+    if (!memoryEnabled)
+        return '';
+    const g = loadScopeGraph(scope);
+    const activeEdges = g.edges.filter((e) => !e.invalidAt);
+    if (activeEdges.length === 0)
+        return '';
+    const degree = new Map();
+    for (const e of activeEdges) {
+        degree.set(e.src, (degree.get(e.src) ?? 0) + 1);
+        degree.set(e.dst, (degree.get(e.dst) ?? 0) + 1);
+    }
+    const named = g.entities.filter((x) => !!x && typeof x.name === 'string' && x.name.length > 0);
+    const top = named
+        .map((e) => ({ e, d: degree.get(e.id) ?? 0 }))
+        .filter((x) => x.d > 0)
+        .sort((a, b) => b.d - a.d || a.e.name.localeCompare(b.e.name))
+        .slice(0, GRAPH_HINT_TOP_ENTITIES)
+        .map((x) => x.e.name);
+    const header = `## Project knowledge graph (query on demand, not auto-loaded)`;
+    const body = `This repo has a memory graph with ${g.entities.length} entities / ${activeEdges.length} facts ` +
+        `(modules, tools, configs, decisions, pitfalls…). When relevant to the current task, query it before re-deriving: ` +
+        `memory_search("keywords") also returns matching graph facts (CJK-aware, with one-hop neighbors); ` +
+        `memory_graph action=neighbors|path expands connections. Main subjects: ${top.join('、')}.`;
+    const out = ['', header, body].join('\n');
+    return out.length <= GRAPH_HINT_MAX_CHARS
+        ? out
+        : out.slice(0, GRAPH_HINT_MAX_CHARS).replace(/[、,]\s*[^、,]*$/, ' …');
+}

package/dist/memory/reflect.js

@@ -13,7 +13,8 @@ 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';
+import { addTriple, ensurePrimaryPerson, PRIMARY_PERSON_ID } from './graph.js';
+import { normalizeRelation, isKnownRelation, relationCheatSheet } from './relation-vocab.js';
 // ── 日志(静默容错,裁尾保最近)─────────────────────────────────────────────
 function logPath() {
     return path.join(process.cwd(), '.mocode', 'memory.log');
@@ -91,7 +92,7 @@ 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":"..."}],"triples":[{"src":"...","relation":"...","dst":"...","fact":"..."}]}
+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":"..."}],"profile":[{"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;
@@ -100,16 +101,17 @@ Rules:
 ④ 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);
-⑦ 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.`;
+⑦ triples are PROJECT knowledge-graph facts about THIS CODEBASE distilled from this session: concise entity names (lowercase snake_case or proper nouns) plus a one-line fact. Prioritize the high-reuse structural relations in this order — dependency/ownership (depends_on, uses, used_by, calls, part_of), location (implemented_in, reads, writes, configured_by, runs_on, listens_on), verification (tests, documented_in), rationale/risk (decided_by, conflicts_with); full list: ${relationCheatSheet('project')}. Favor facts that would help a future session navigate or avoid re-deriving (which module implements X, what depends on Y, what conflicts with Z). A relation outside this list is allowed only when none fits (it gets flagged for review). Only emit triples that are stable, non-obvious and reusable in this repo (2-6 at most).
+⑧ profile is for facts about THE USER (the human), which must apply across ALL projects — identity, role, expertise, language/communication style, stable preferences, current goals, constraints. They are attached to the single canonical person entity. Each item: dst is a short atomic value/entity, fact is one neutral Chinese sentence stating it. Prefer these relations: ${relationCheatSheet('global')}. A relation outside this list is allowed only when none fits. NEVER put repo paths, commands, file names, ports, secrets or one-task details in profile — those belong in triples. Only emit profile when the user explicitly revealed something durable about themselves (0-3 items); when unsure, omit.`;
 const REFLECT_USER = (transcript, sample) => `## Recent session\n${transcript}\n\n## Existing memories\n${sample}\n\nProduce JSON:`;
-function parsePlan(content) {
+export function parsePlan(content) {
     if (!content)
         return null;
     let s = content.trim();
-    // 去 ```json … ``` 代码块(模型偶发包裹)
-    const fence = s.match(/```(?:json)?\s*([\s\S]*?)```/i);
-    if (fence)
-        s = fence[1].trim();
+    // 去 ```json … ``` 代码块(模型偶发包裹);取最后一个块(前面可能有解释文字)。
+    const fences = [...s.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)];
+    if (fences.length)
+        s = fences[fences.length - 1][1].trim();
     // 容错:截到首个 { 到末个 }
     const first = s.indexOf('{');
     const last = s.lastIndexOf('}');
@@ -122,12 +124,40 @@ function parsePlan(content) {
         return p;
     }
     catch {
+        // 再试一次:去掉对象/数组尾逗号(模型常见的非法 JSON)。
+        try {
+            const p = JSON.parse(s.replace(/,\s*([}\]])/g, '$1'));
+            if (p && typeof p === 'object')
+                return p;
+        }
+        catch {
+            // 落到 null
+        }
         return null;
     }
 }
+/** 取一次反思 LLM 返回的可解析文本(content 优先;tool_calls 的 JSON 串参数兜底)。 */
+async function fetchReflection(messages, signal) {
+    const r = await chat(messages, {}, signal, undefined, { reasoningEffort: 'low' });
+    if (!r.toolCalls.length && r.content)
+        return { content: r.content, raw: null };
+    // 推理模型偶发只把 JSON 塞进 tool_calls 参数、或 content 为 null:从工具调用里捞 JSON 串。
+    for (const tc of r.toolCalls) {
+        const args = tc.function?.arguments;
+        if (typeof args === 'string' && args.includes('{'))
+            return { content: args, raw: null };
+    }
+    // 无可用正文(典型:只吐 reasoning_content):保留简短指纹供日志排查。
+    const fingerprint = r.content
+        ? `content=${r.content.slice(0, 200)}`
+        : `content=null, toolCalls=${r.toolCalls.length}`;
+    return { content: null, raw: fingerprint };
+}
 /**
  * 跑一次反思:chat() 空 handlers(静默)→ 解析 JSON → 经 store 落地 → gcMemories。
- * 解析失败整 pass 放弃(不部分落地)。store 调用全同步,落地是一个原子块。
+ * 首轮解析失败时做**一次修复式重试**(明确要求"只输出 JSON、不要思考过程"),
+ * 重试仍失败才报 parse-failed——此时 rawParseFailure 带原始返回指纹,由 kickoff 落
+ * memory.log,不再像旧版那样无声丢掉一整轮且无从排查。store 调用全同步。
  * 60s 超时(AbortSignal.timeout)防 exit 时 drain 挂死。
  */
 export async function runReflection(transcript, signal) {
@@ -135,7 +165,7 @@ export async function runReflection(transcript, signal) {
     const sample = buildMemorySample();
     const sys = { role: 'system', content: REFLECT_SYS };
     const user = { role: 'user', content: REFLECT_USER(transcript, sample) };
-    let result = {
+    const result = {
         ts,
         saves: 0,
         updates: 0,
@@ -145,12 +175,27 @@ export async function runReflection(transcript, signal) {
         gcCapped: 0,
         gcGced: 0,
     };
+    const timeoutSignal = signal ?? AbortSignal.timeout(60000);
     let content = null;
     try {
-        const r = await chat([sys, user], {}, signal ?? AbortSignal.timeout(60000), undefined, { reasoningEffort: 'low' });
-        // 推理模型偶发只返 reasoning_content(content null)或幻觉 tool_calls → 视为无产出
-        if (!r.toolCalls.length && r.content)
-            content = r.content;
+        const first = await fetchReflection([sys, user], timeoutSignal);
+        content = first.content;
+        // 首轮拿不到可解析正文 → 一次修复式重试(同一超时信号的剩余预算)。
+        if (parsePlan(content) === null) {
+            result.repairAttempted = true;
+            const repairUser = {
+                role: 'user',
+                content: '你的上一条回复无法被解析为目标 JSON。现在只输出一个 JSON 对象,不要 markdown 围栏、不要解释、不要思考过程,' +
+                    '形状严格为 {"saves":[],"updates":[],"forgets":[],"triples":[]};没有值得长期记住的内容就全部给空数组。',
+            };
+            const second = await fetchReflection([sys, user, { role: 'assistant', content: content ?? '' }, repairUser], timeoutSignal);
+            if (second.content)
+                content = second.content;
+            if (!content && first.raw)
+                result.rawParseFailure = first.raw;
+            else if (second.raw && parsePlan(content) === null)
+                result.rawParseFailure = second.raw;
+        }
     }
     catch (e) {
         result.error = e instanceof Error ? e.name + ': ' + e.message : String(e);
@@ -159,6 +204,8 @@ export async function runReflection(transcript, signal) {
     const plan = parsePlan(content);
     if (!plan) {
         result.error = 'parse-failed';
+        if (!result.rawParseFailure)
+            result.rawParseFailure = (content ?? '').slice(0, 300);
         return result;
     }
     let saves = 0;
@@ -201,14 +248,19 @@ export async function runReflection(transcript, signal) {
         }
     }
     // 知识图谱三元组:容错——单项失败跳过,不影响 saves/updates/forgets 已落地的结果。
+    // 关系名先归一(别名/拼写);词表外关系仍允许写(软封闭世界),但计 relViolations 供观测。
     let triples = 0;
+    let relViolations = 0;
     if (Array.isArray(plan.triples)) {
         for (const t of plan.triples.slice(0, 10)) {
             if (!t?.src || !t?.relation || !t?.dst)
                 continue;
+            const relation = normalizeRelation(String(t.relation));
+            if (!isKnownRelation(relation, 'project'))
+                relViolations++;
             const r = addTriple({
                 src: String(t.src),
-                relation: String(t.relation),
+                relation,
                 dst: String(t.dst),
                 fact: t.fact ? String(t.fact) : undefined,
             });
@@ -216,8 +268,43 @@ export async function runReflection(transcript, signal) {
                 triples++;
         }
     }
+    // 全局用户画像:挂到规范 person-primary、写 global 图(与项目 triples 分流)。
+    let profiles = 0;
+    if (Array.isArray(plan.profile) && plan.profile.length > 0) {
+        let personId = PRIMARY_PERSON_ID;
+        try {
+            personId = ensurePrimaryPerson().id;
+        }
+        catch {
+            personId = PRIMARY_PERSON_ID;
+        }
+        for (const p of plan.profile.slice(0, 6)) {
+            if (!p?.relation || !p.dst)
+                continue;
+            const relation = normalizeRelation(String(p.relation));
+            if (!isKnownRelation(relation, 'global'))
+                relViolations++;
+            const r = addTriple({
+                src: personId,
+                relation,
+                dst: String(p.dst),
+                fact: p.fact ? String(p.fact) : undefined,
+                scope: 'global',
+            });
+            if (r.ok && !r.duplicate)
+                profiles++;
+        }
+    }
     const gc = gcMemories();
-    result = { ...result, saves, updates, forgets, triples, gcDecayed: gc.decayed, gcCapped: gc.capped, gcGced: gc.gced };
+    result.saves = saves;
+    result.updates = updates;
+    result.forgets = forgets;
+    result.triples = triples;
+    result.profiles = profiles;
+    result.relViolations = relViolations;
+    result.gcDecayed = gc.decayed;
+    result.gcCapped = gc.capped;
+    result.gcGced = gc.gced;
     return result;
 }
 function normalizeType(t) {
@@ -231,9 +318,13 @@ function normalizeType(t) {
 // ── 后台编排:kickoff / drain / 缓存 ─────────────────────────────────────────
 let inflight = null;
 let lastReflectResult = null;
-/** 摘要串(供 repl flush):存N 改N 忘N 图N;有错误附上。 */
+/** 摘要串(供 repl flush):存N 改N 忘N 图N [画像N 违N];有错误附上。 */
 export function formatReflectResult(r) {
     const parts = [`存${r.saves}`, `改${r.updates}`, `忘${r.forgets}`, `图${r.triples}`];
+    if (r.profiles)
+        parts.push(`画像${r.profiles}`);
+    if (r.relViolations)
+        parts.push(`违${r.relViolations}`);
     if (r.gcDecayed || r.gcCapped || r.gcGced) {
         parts.push(`遗忘(衰减${r.gcDecayed}/封顶${r.gcCapped}/清除${r.gcGced})`);
     }
@@ -256,6 +347,10 @@ export function kickoffReflection(transcript) {
             const r = await runReflection(transcript);
             lastReflectResult = r;
             appendLog(`[${r.ts}] ${formatReflectResult(r)}`);
+            if (r.error === 'parse-failed' && r.rawParseFailure) {
+                // 留证:旧版 parse-failed 无声丢弃,无法排查(实测约三成反思命中)。
+                appendLog(`  ↳ parse-failed 原始返回: ${r.rawParseFailure.replace(/\s+/g, ' ').slice(0, 500)}`);
+            }
         }
         catch (e) {
             appendLog(`[${new Date().toISOString()}] 反思异常: ${e instanceof Error ? e.message : String(e)}`);

package/dist/memory/relation-vocab.js

@@ -0,0 +1,84 @@
+// relation-vocab.ts —— 受控关系词表(轻量,不含实体类型/domain-range)。
+//
+// 这是 memory-2.2 本体方案里"软封闭世界"的最小落地:只约束**关系名**,不引入实体类型
+// 体系或推理。反思抽取 triples/profile 时优先用词表内关系;词表外关系**仍允许写入**
+// (软策略,不阻断长尾),但会被计数为 relViolation 供观测。等真实数据证明需要,再升级
+// 为完整 ontology.ts(实体 type + domain/range + 逆/传递)。
+//
+// 纯常量 + 纯函数,叶子模块,无 IO。
+/** 项目轨(懂仓库)首选关系:高复用、可结构化的连接。 */
+export const PROJECT_RELATIONS = [
+    'depends_on',
+    'uses',
+    'used_by',
+    'calls',
+    'part_of',
+    'implemented_in',
+    'reads',
+    'writes',
+    'configured_by',
+    'runs_on',
+    'listens_on',
+    'tests',
+    'documented_in',
+    'decided_by',
+    'conflicts_with',
+    'related_to',
+];
+/** 用户轨(懂用户)画像关系:挂 person-primary。 */
+export const PROFILE_RELATIONS = [
+    'named',
+    'has_role',
+    'works_at',
+    'located_in',
+    'speaks',
+    'verbosity',
+    'communication_style',
+    'prefers',
+    'avoid',
+    'avoids',
+    'current_goal',
+    'constraint',
+    'has_hobby',
+    'skill_level',
+    'related_to',
+];
+/** 常见同义/拼写漂移 → 规范关系(反思落库前归范)。 */
+export const RELATION_ALIASES = {
+    employed_by: 'works_at',
+    employer: 'works_at',
+    lives_in: 'located_in',
+    based_in: 'located_in',
+    location: 'located_in',
+    hobby: 'has_hobby',
+    role: 'has_role',
+    is_a: 'related_to',
+    uses_port: 'listens_on',
+    port: 'listens_on',
+    depends: 'depends_on',
+    dependency: 'depends_on',
+    implements: 'implemented_in',
+    impl: 'implemented_in',
+    decides: 'decided_by',
+    conflict: 'conflicts_with',
+    configure: 'configured_by',
+};
+const PROJECT_SET = new Set(PROJECT_RELATIONS);
+const PROFILE_SET = new Set(PROFILE_RELATIONS);
+/** 关系名归一:lowercase + 空白转下划线 + 别名映射。 */
+export function normalizeRelation(raw) {
+    const base = String(raw ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '_');
+    return RELATION_ALIASES[base] ?? base;
+}
+/** 关系是否在对应 scope 的首选词表内(先归一再判定)。 */
+export function isKnownRelation(relation, scope) {
+    const r = normalizeRelation(relation);
+    return scope === 'global' ? PROFILE_SET.has(r) : PROJECT_SET.has(r);
+}
+/** 注入反思提示词的紧凑词表(按 scope)。 */
+export function relationCheatSheet(scope) {
+    return scope === 'global' ? PROFILE_RELATIONS.join(', ') : PROJECT_RELATIONS.join(', ');
+}

package/dist/repl/message-format.js

@@ -3,7 +3,12 @@ import * as layout from '../ui/layout.js';
 import * as batch from '../ui/batch.js';
 import { displayWidth, padEndDisplay, summarizeToolCall, summarizeToolResult } from '../ui/render.js';
 import { renderChip } from '../attachments/image.js';
+import { t } from '../i18n/index.js';
 import { PROMPT } from './commands.js';
+/** compact 摘要消息头(与 session/compact.ts SUMMARY_MARKER 同值;本地复制避免拉入 compact 的重依赖图,同 retention.ts)。 */
+const SUMMARY_MARKER = '# 会话摘要';
+/** 回放时摘要最多显示的字符数(摘要上限 6000,全量回放会淹没保留的用户原话)。 */
+const SUMMARY_REPLAY_MAX_CHARS = 3000;
 /** side channel:history 中 user 消息的 index → 附件列表,供 renderHistory 复显文件名。runTurn 在 push 前设。 */
 export const messageAttachments = new Map();
 export function formatUserMessage(lines, trailingBlank = true) {
@@ -69,8 +74,25 @@ export function renderHistory(history) {
     };
     for (let idx = 0; idx < history.length; idx++) {
         const m = history[idx];
-        if (m.role === 'system')
+        if (m.role === 'system') {
+            // compact 摘要是被压缩掉的助手回复/工具过程的唯一留存:回放时显示出来(history[0] 的系统提示仍跳过)。
+            const body = textOf(m.content);
+            if (idx > 0 && body.startsWith(SUMMARY_MARKER)) {
+                flushBatch();
+                layout.normalizeMutationBoundary();
+                layout.contentWrite(`${ui.dim}${t('repl.compactedNotice')}${ui.reset}\n\n`);
+                const text = body.slice(SUMMARY_MARKER.length).trim();
+                if (text.length > SUMMARY_REPLAY_MAX_CHARS) {
+                    layout.contentWriteMdOnce(text.slice(0, SUMMARY_REPLAY_MAX_CHARS));
+                    layout.contentWrite(`${ui.dim}${t('repl.compactedTruncated', { total: text.length, shown: SUMMARY_REPLAY_MAX_CHARS })}${ui.reset}\n`);
+                }
+                else {
+                    layout.contentWriteMdOnce(text);
+                }
+                layout.normalizeMutationBoundary();
+            }
             continue;
+        }
         if (m.role === 'user') {
             flushBatch(); // 上一轮 batch(若有)收尾
             const lines = textOf(m.content).split('\n');

package/dist/repl/runtime.js

@@ -24,7 +24,7 @@ import { renderChip } from '../attachments/image.js';
 import { contextState, appendCurrentSessionRuntimeEvent } from '../session/index.js';
 import { effectiveSystemPrompt } from '../skills/index.js';
 import { clearSkillActivation } from '../skills/activation.js';
-import { buildMemoryIndexSection, kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, } from '../memory/index.js';
+import { buildMemoryIndexSection, buildAboutYouSection, buildProjectGraphHint, initPersona, kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, } from '../memory/index.js';
 import { collectQueryHistory } from '../session/query-history.js';
 import { ToolPolicyController } from '../tools/policy.js';
 import { routeToolGroups } from '../tools/router.js';
@@ -198,9 +198,18 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     // 与开关联动:① base 用 buildBasePrompt() 取代 config.systemPrompt(后者是启动时一次性
     // 求值的常量,运行时 /memory_switch 不会刷新);② plan suffix 走 getPlanModeSuffix() 现拼;
     // ③ AGENTS.md 存在工作区根时由 base 无条件自动导入正文(超长截断，与 memory 开关无关)；④ Memory Index 按开关注入。
-    const buildSystemMessage = (planMode) => effectiveSystemPrompt(buildBasePrompt(currentSessionId) +
-        (planMode ? getPlanModeSuffix() : '') +
-        buildMemoryIndexSection(isMemoryEnabled()));
+    // 启动期一次性身份归一(幂等,best-effort):把全局图里的用户指称碎片并入
+    // person-primary,随后 About you 段才能渲染出完整画像。
+    initPersona(isMemoryEnabled());
+    // 开关现读:运行时 /memory_switch 重建 history[0] 时,About you 与 Memory Index 同步显隐。
+    const buildSystemMessage = (planMode) => {
+        const memoryOn = isMemoryEnabled();
+        return effectiveSystemPrompt(buildBasePrompt(currentSessionId) +
+            buildAboutYouSection(memoryOn) +
+            (planMode ? getPlanModeSuffix() : '') +
+            buildMemoryIndexSection(memoryOn) +
+            buildProjectGraphHint(memoryOn));
+    };
     // 有预加载(--resume)则用它,并把 history[0] 刷成当前 system prompt(config 可能已变);
     // 否则新会话只塞 system 提示(默认 auto)。
     const history = initialHistory && initialHistory.length ? initialHistory : [{ role: 'system', content: buildSystemMessage(false) }];

package/dist/runtime/runtime.js

@@ -274,7 +274,7 @@ export class Runtime {
     }
     resumeSession(id) {
         this.assertIdle('resume session');
-        const loaded = this.context.sessionStore.load(id);
+        const loaded = this.context.sessionStore.load(id, { restoreAssets: true });
         if (!loaded?.history.length)
             return null;
         this.context.sessionStore.setCurrentSessionId(loaded.id);