mocode-ai 1.7.10 → 1.8.0

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/models/map-preset.js

@@ -57,6 +57,9 @@ export function buildPreset(input) {
     const contextWindow = typeof model.limit?.context === 'number' && model.limit.context > 0
         ? Math.floor(model.limit.context)
         : FALLBACK_CONTEXT_WINDOW;
+    // 单次输出上限:目录有 limit.output 就带上(避免吃网关小默认导致长 write_file 被截断);
+    // 目录缺失则留 undefined=不下发,绝不硬编码大值(超过模型真实上限会被后端 400 拒整请求)。
+    const maxOutput = typeof model.limit?.output === 'number' && model.limit.output > 0 ? Math.floor(model.limit.output) : undefined;
     return {
         name: input.name ?? defaultPresetName(provider.id, model.id),
         provider: presetProvider,
@@ -64,6 +67,7 @@ export function buildPreset(input) {
         apiKey: input.apiKey,
         model: input.modelOverride ?? model.id,
         contextWindow,
+        ...(maxOutput ? { maxTokens: maxOutput } : {}),
         anthropicPromptCache: presetProvider === 'anthropic',
     };
 }

package/dist/repl/commands/model-actions.js

@@ -23,6 +23,8 @@ export function applyPresetConfig(ctx, p) {
         baseURL: p.baseURL,
         apiKey: p.apiKey,
         contextWindowTokens: p.contextWindow,
+        // 预设带值用值;不带显式清除(否则旧 MAX_TOKENS 残留会盖过新预设)。
+        maxTokens: p.maxTokens ?? null,
         anthropicPromptCache: p.anthropicPromptCache,
         ...(p.reasoningEffort ? { reasoningEffort: p.reasoningEffort } : {}),
     });
@@ -32,6 +34,7 @@ export function applyPresetConfig(ctx, p) {
         LLM_API_KEY: p.apiKey,
         LLM_MODEL: p.model,
         CONTEXT_WINDOW_TOKENS: String(p.contextWindow),
+        MAX_TOKENS: p.maxTokens ? String(p.maxTokens) : null,
         ANTHROPIC_PROMPT_CACHE: p.anthropicPromptCache ? 'true' : 'false',
     });
     // 关键不变量：应用预设即激活——必须同步 .active 指针。否则重启时旧激活预设的优先级

package/dist/repl/commands/model.js

@@ -25,14 +25,15 @@ import { renderHistory } from '../message-format.js';
 import { MODEL_PRESETS, maskKey } from '../commands.js';
 import { unhandled, next } from './types.js';
 /** 决定自动存的预设名:协议、缓存配置和连接四元组都一致时不重复存。 */
-function uniquePresetName(desired, provider, baseURL, apiKey, model, contextWindow, anthropicPromptCache) {
+function uniquePresetName(desired, provider, baseURL, apiKey, model, contextWindow, anthropicPromptCache, maxTokens) {
     const existing = listPresets();
     const sameEntry = existing.find((p) => p.provider === provider &&
         p.baseURL === baseURL &&
         p.apiKey === apiKey &&
         p.model === model &&
         p.contextWindow === contextWindow &&
-        p.anthropicPromptCache === anthropicPromptCache);
+        p.anthropicPromptCache === anthropicPromptCache &&
+        (p.maxTokens ?? undefined) === maxTokens);
     if (sameEntry)
         return null;
     const sanitized = desired
@@ -73,6 +74,8 @@ export const modelCommands = [
                 baseURL: target.baseURL,
                 apiKey: target.apiKey,
                 contextWindowTokens: target.contextWindow,
+                // 预设带值用值;不带则显式清除(否则本窗口/配置文件里的旧 MAX_TOKENS 会一直盖过新预设)。
+                maxTokens: target.maxTokens ?? null,
                 anthropicPromptCache: target.anthropicPromptCache,
                 ...(target.reasoningEffort ? { reasoningEffort: target.reasoningEffort } : {}),
             });
@@ -82,6 +85,8 @@ export const modelCommands = [
                 LLM_API_KEY: target.apiKey,
                 LLM_MODEL: target.model,
                 CONTEXT_WINDOW_TOKENS: String(target.contextWindow),
+                // null = 从配置文件删除该键(写不下发=吃后端默认)。
+                MAX_TOKENS: target.maxTokens ? String(target.maxTokens) : null,
                 ANTHROPIC_PROMPT_CACHE: target.anthropicPromptCache ? 'true' : 'false',
                 ...(target.reasoningEffort ? { REASONING_EFFORT: target.reasoningEffort } : {}),
             });
@@ -185,6 +190,7 @@ export const modelCommands = [
             layout.contentWrite(`  ${ui.accent}effort  ${ui.reset}  ${config.reasoningEffort}` +
                 (recognized ? '\n' : `${ui.dim}(当前模型未识别,参数不会下发)${ui.reset}\n`));
             layout.contentWrite(`  ${ui.accent}窗口    ${ui.reset}  ${config.contextWindowTokens} tokens\n`);
+            layout.contentWrite(`  ${ui.accent}输出上限${ui.reset} ${config.maxTokens ? `${config.maxTokens} tokens` : `${ui.dim}未设置(不下发,吃后端默认)${ui.reset}`}\n`);
             if (config.provider === 'anthropic') {
                 layout.contentWrite(`  ${ui.accent}缓存    ${ui.reset}  Prompt Cache ${config.anthropicPromptCache ? 'on' : 'off'}\n`);
             }
@@ -284,11 +290,14 @@ export const modelCommands = [
         let apiKey;
         let model;
         let window;
+        // 单次输出上限;undefined = 不下发(吃后端默认)。quickApply 沿用当前值。
+        let maxTokens;
         if (quickApply) {
             baseURL = preset.baseURL;
             apiKey = config.apiKey;
             model = preset.model;
             window = preset.window;
+            maxTokens = config.maxTokens;
         }
         else {
             // baseURL
@@ -364,6 +373,29 @@ export const modelCommands = [
                     window = Math.floor(n);
                 }
             }
+            // maxTokens(可选):单次回复输出上限。回车采纳当前值;填 0/留空 = 不下发吃后端默认。
+            {
+                const res = await promptIntervention({
+                    type: 'input',
+                    title: 'MAX_TOKENS',
+                    detail: '单次回复最大输出 token(思考+正文+工具参数)。留空=不下发吃后端默认;' +
+                        '部分兼容网关默认仅 4k/8k,长文件写入会被截断,建议填该模型官方最大输出(常见 8k-64k)。回车采纳当前值。',
+                    seed: config.maxTokens ? String(config.maxTokens) : '',
+                });
+                if (res.action === 'cancelled') {
+                    return next();
+                }
+                const v = (res.value ?? '').trim();
+                if (v) {
+                    const n = Number(v);
+                    if (Number.isFinite(n) && n > 0)
+                        maxTokens = Math.floor(n);
+                    // 非法值不阻断:保持 undefined(不下发),与留空同义。
+                }
+                else {
+                    maxTokens = undefined;
+                }
+            }
         }
         // 3) 应用协议、连接与缓存配置；Anthropic 原生协议无需重建 OpenAI client，但统一刷新无害。
         const provider = preset.provider;
@@ -374,6 +406,8 @@ export const modelCommands = [
             baseURL,
             apiKey,
             contextWindowTokens: window,
+            // 手填向导里留空 = undefined → 显式清除旧值,不下发 max_tokens。
+            maxTokens: maxTokens ?? null,
             anthropicPromptCache,
         });
         writeConfigKeys({
@@ -382,13 +416,14 @@ export const modelCommands = [
             LLM_API_KEY: apiKey,
             LLM_MODEL: model,
             CONTEXT_WINDOW_TOKENS: String(window),
+            MAX_TOKENS: maxTokens ? String(maxTokens) : null,
             ANTHROPIC_PROMPT_CACHE: anthropicPromptCache ? 'true' : 'false',
         });
         reconfigureClient();
         // 3.5) 自动存为命名预设；协议与缓存策略也是去重键的一部分。
         let savedName = null;
         try {
-            const finalName = uniquePresetName(model, provider, baseURL, apiKey, model, window, anthropicPromptCache);
+            const finalName = uniquePresetName(model, provider, baseURL, apiKey, model, window, anthropicPromptCache, maxTokens);
             if (finalName) {
                 savePreset({
                     name: finalName,
@@ -397,6 +432,7 @@ export const modelCommands = [
                     apiKey,
                     model,
                     contextWindow: window,
+                    ...(maxTokens ? { maxTokens } : {}),
                     anthropicPromptCache,
                 });
                 savedName = finalName;

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