mocode-ai 1.7.10 → 1.7.11

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

package/dist/session/compact-archive.js

@@ -0,0 +1,232 @@
+// compact-archive.ts — 压缩旧区原文的归档渲染器。
+//
+// 目的:compactHistory 成功摘要后旧区消息会被整体丢弃(连 session.json 也被
+// 压缩后的 history 覆盖)。这里把旧区渲染成 grep 友好的 Markdown 段文件,落盘到
+// `<session>/compacted/seg-NNN.md`,模型事后可用现有 grep/read_file 回捞精确原文,
+// 不新增任何工具。
+//
+// 设计约束:
+//  - 纯函数,不碰文件系统(落盘/编号/淘汰在 SessionStore)。
+//  - 每个 seg 文件首行是单行 HTML 注释元数据(自描述,index.md 可随时重建)。
+//  - 图片不归档(base64 无检索价值且体积爆炸),只留占位,与 stripImagesForSummary 同口径。
+//  - 消息按 history 原时序;turn 序号按非空 user 消息递增,方便模型按回合定位。
+/** 压缩归档子目录名(相对会话目录)。 */
+export const COMPACTED_DIRNAME = 'compacted';
+/** 段索引文件名。 */
+export const ARCHIVE_INDEX_FILE = 'index.md';
+/** seg 文件名:seg-001.md … seg-999.md(超出也不报错,只是不补零)。 */
+export function segmentFileName(seq) {
+    return `seg-${String(seq).padStart(3, '0')}.md`;
+}
+export const SEGMENT_FILE_RE = /^seg-(\d+)\.md$/;
+/** push-time 被 capToolResultForHistory 截断的工具完整结果,按 tool_call_id 单存。 */
+export function resultBlobFileName(toolCallId) {
+    // call id 理论上安全(toolu_xxx / call-N),仍做一次白名单清洗防路径穿越。
+    const safe = toolCallId.replace(/[^A-Za-z0-9_.-]/g, '_').slice(0, 120) || 'unknown';
+    return `result-${safe}.txt`;
+}
+export const RESULT_BLOB_FILE_RE = /^result-.+\.txt$/;
+/** retention 归档时打包进 gz 的 compacted/ 资产白名单(其余临时文件不带走)。 */
+export function isCompactedAssetName(name) {
+    return SEGMENT_FILE_RE.test(name) || RESULT_BLOB_FILE_RE.test(name) || name === ARCHIVE_INDEX_FILE;
+}
+function asToolCalls(m) {
+    const tcs = m.tool_calls;
+    if (!Array.isArray(tcs))
+        return [];
+    return tcs;
+}
+/** 多模态 content 拍平:text 拼接;image_url 留占位;其余形状 JSON 化(与摘要器同口径)。 */
+function messageText(content) {
+    if (content == null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const p of content) {
+            if (p && typeof p === 'object') {
+                const part = p;
+                if (part.type === 'text')
+                    parts.push(part.text ?? '');
+                else if (part.type === 'image_url') {
+                    const url = part.image_url?.url ?? '';
+                    const mime = url.startsWith('data:') ? url.slice(5, url.indexOf(';')) : 'image';
+                    parts.push(`[图片已剥离: ${mime}]`);
+                }
+                else {
+                    parts.push(`[${part.type ?? 'content'} part]`);
+                }
+            }
+            else {
+                parts.push(String(p ?? ''));
+            }
+        }
+        return parts.join('');
+    }
+    try {
+        return JSON.stringify(content);
+    }
+    catch {
+        return String(content);
+    }
+}
+const PATH_KEYS = new Set(['path', 'file', 'filePath', 'filename', 'dir', 'directory']);
+const MAX_META_FILES = 8;
+const MAX_FIRST_USER_CHARS = 60;
+function collectFilesFromArgs(argsRaw, sink) {
+    if (!argsRaw || sink.length >= MAX_META_FILES)
+        return;
+    let parsed;
+    try {
+        parsed = JSON.parse(argsRaw);
+    }
+    catch {
+        return;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return;
+    for (const [k, v] of Object.entries(parsed)) {
+        if (typeof v !== 'string' || !PATH_KEYS.has(k))
+            continue;
+        const norm = v.replace(/\\/g, '/').replace(/^\.\//, '');
+        if (norm && !sink.includes(norm))
+            sink.push(norm);
+        if (sink.length >= MAX_META_FILES)
+            break;
+    }
+}
+function oneLine(text, max) {
+    const line = text.replace(/\s+/g, ' ').trim();
+    return line.length > max ? `${line.slice(0, max)}…` : line;
+}
+/**
+ * 把一段旧区消息渲染成 Markdown 段。输出同时包含文件全文与元数据,
+ * 调用方负责把返回的 { markdown, meta } 一起落盘。
+ */
+export function renderCompactedSegment(seq, messages, archivedAt = new Date().toISOString()) {
+    const file = segmentFileName(seq);
+    const tools = [];
+    const files = [];
+    let turns = 0;
+    let firstUser = '';
+    // tool_call_id → tool 名(tool 消息自身不带工具名,靠前导 assistant 配对)。
+    const callNames = new Map();
+    for (const m of messages) {
+        if (m.role !== 'assistant')
+            continue;
+        for (const tc of asToolCalls(m)) {
+            const name = tc.function?.name;
+            if (tc.id && name)
+                callNames.set(tc.id, name);
+            if (name && !tools.includes(name))
+                tools.push(name);
+            collectFilesFromArgs(tc.function?.arguments, files);
+        }
+    }
+    const blocks = [];
+    for (const m of messages) {
+        if (m.role === 'user') {
+            const text = messageText(m.content);
+            if (text.trim()) {
+                turns++;
+                if (!firstUser)
+                    firstUser = oneLine(text, MAX_FIRST_USER_CHARS);
+            }
+            blocks.push(`### [turn ${turns}] user\n${text.trim()}`);
+            continue;
+        }
+        if (m.role === 'system') {
+            // 上一代摘要的叙述段(pin 除外):内容会随本代重新压缩,归档里标记出处。
+            blocks.push(`### [prior-summary] system\n${messageText(m.content).trim()}`);
+            continue;
+        }
+        if (m.role === 'tool') {
+            const id = m.tool_call_id ?? '';
+            const name = (id && callNames.get(id)) || '';
+            const label = [`### [turn ${turns}] tool_result`, id && `call=${id}`, name && `tool=${name}`]
+                .filter(Boolean)
+                .join(' ');
+            blocks.push(`${label}\n${messageText(m.content).trim()}`);
+            continue;
+        }
+        // assistant:正文一个块,每个 tool_call 一个块(参数是 grep 的高频目标,独立成块)。
+        const text = messageText(m.content).trim();
+        if (text)
+            blocks.push(`### [turn ${turns}] assistant\n${text}`);
+        for (const tc of asToolCalls(m)) {
+            const name = tc.function?.name;
+            const label = [`### [turn ${turns}] assistant call`, tc.id && `call=${tc.id}`, name && `tool=${name}`]
+                .filter(Boolean)
+                .join(' ');
+            const args = (tc.function?.arguments ?? '').trim();
+            blocks.push(`${label}\n${args ? `args: ${args}` : '(no args)'}`);
+        }
+    }
+    const body = blocks.join('\n\n') + '\n';
+    const baseMeta = {
+        seq,
+        file,
+        archivedAt,
+        messages: messages.length,
+        turns,
+        tools,
+        files,
+        firstUser,
+    };
+    const heading = `# 已压缩历史段 ${file}\n\n`;
+    // chars 是淘汰策略的依据,需含 header 自身:先估后定(header 只差 chars 一个数字位)。
+    const measure = (chars) => `<!-- mocode-archive ${JSON.stringify({ ...baseMeta, chars })} -->\n\n`;
+    let chars = measure(0).length + heading.length + body.length;
+    let header = measure(chars);
+    if (header.length !== measure(0).length) {
+        // 数字位数变化(9→10)的罕见情况,再定标一次即收敛。
+        chars = header.length + heading.length + body.length;
+        header = measure(chars);
+    }
+    const meta = { ...baseMeta, chars };
+    return { markdown: `${header}${heading}${body}`, meta };
+}
+/** 从 seg 文件内容解析首行元数据;损坏/旧格式返 null。 */
+export function parseSegmentMeta(markdown) {
+    const nl = markdown.indexOf('\n');
+    const first = (nl >= 0 ? markdown.slice(0, nl) : markdown).trim();
+    const m = /^<!-- mocode-archive (\{.*\}) -->$/.exec(first);
+    if (!m)
+        return null;
+    try {
+        const meta = JSON.parse(m[1]);
+        if (typeof meta.seq === 'number' && typeof meta.file === 'string')
+            return meta;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 由全部段元数据重建 index.md。模型读它决定去哪段 grep;确定性输出,
+ * 不经过摘要器(避免漏写)。relativeDir 是相对 cwd 的 POSIX 路径,
+ * 直接写给模型/grep 用。
+ */
+export function renderArchiveIndex(metas, relativeDir) {
+    const sorted = [...metas].sort((a, b) => a.seq - b.seq);
+    const lines = [
+        '# 已压缩历史索引(compacted history index)',
+        '',
+        '本目录是历次上下文压缩前的原始消息(用户原话、assistant 决策、工具参数与完整结果)。',
+        `路径:\`${relativeDir}/\``,
+        '需要精确原文(报错、命令/测试输出、旧决策)时,不要凭摘要猜也不要急着重跑:',
+        `1. 用 grep 搜索并把 glob 限定在 \`${relativeDir}/**\`(.mocode 在 .gitignore 里,必须 glob 限定才搜得到);`,
+        '2. 按命中行号用 read_file 的 offset/limit 精读对应 seg 文件。',
+        '',
+    ];
+    for (const m of sorted) {
+        const tools = m.tools.length ? m.tools.join(', ') : '-';
+        const files = m.files.length ? m.files.join(', ') : '-';
+        const first = m.firstUser ? m.firstUser.replace(/\|/g, '/') : '(无 user 消息)';
+        lines.push(`- [${m.file}](${m.file}) · ${m.archivedAt} · ${m.turns} turns · ${m.messages} msgs · 工具 ${tools} · 文件 ${files} · 首句:${first}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/session/compact.js

@@ -160,6 +160,8 @@ const ANY_HEADING_RE = /^ {0,3}##\s+\S/;
 const PRIOR_NARRATIVE_LABEL = '[prior summary — 上一代摘要的叙述部分:与下方新内容合并压缩,不要重复罗列细节]';
 /** 尾部 provenance 块:解析时剥掉,重建时按当次 older 重算(否则跨代累积并重复)。 */
 const ARTIFACT_REFS_RE = /\n*\[artifact refs:[^\]]*\]\s*$/;
+/** 尾部归档指针:同理按当次压缩重算(指向最新 seg),跨代不累积进叙述/Key Facts。 */
+const ARCHIVED_REFS_RE = /\n*\[archived:[^\]]*\]\s*$/;
 /** Key Facts 累计预算(字符):窗口比例换算 + 上下限——小窗口留得住初始约束,
  *  大窗口也不会让索引段膨胀成正文。 */
 export function keyFactsBudgetChars(window) {
@@ -172,7 +174,7 @@ export function keyFactsBudgetChars(window) {
  * older 重算,不该跨代累积。无 Key Facts 段时 rest 为全文、keyFacts 为空。
  */
 export function splitSummaryText(raw) {
-    let text = (raw ?? '').replace(ARTIFACT_REFS_RE, '').trim();
+    let text = (raw ?? '').replace(ARCHIVED_REFS_RE, '').replace(ARTIFACT_REFS_RE, '').trim();
     if (text.startsWith(SUMMARY_MARKER)) {
         const nl = text.indexOf('\n');
         text = (nl < 0 ? '' : text.slice(nl + 1)).trim();
@@ -874,10 +876,25 @@ export async function compactHistory(history, opts) {
             if (snapshot)
                 writeCompactionSnapshot(snapshot);
         }
+        // 旧区原文归档(仅主 agent):摘要成功后这些消息将被整体丢弃且 session.json
+        // 随后被覆盖——落盘 compacted/seg-NNN.md,模型事后靠 grep/read_file 回捞精确原文。
+        // best-effort:失败只丢回捞能力,绝不阻塞压缩。
+        let archivedPath = null;
+        if (state === contextState) {
+            try {
+                archivedPath = getActiveSessionStore().archiveCompactedMessages(getCurrentSessionId() ?? '', older);
+            }
+            catch {
+                archivedPath = null;
+            }
+        }
         const body = [parsed.rest, pinnedFacts ? `## Key Facts\n${pinnedFacts}` : ''].filter(Boolean).join('\n\n');
+        const archivedRef = archivedPath
+            ? `\n\n[archived: ${archivedPath} — 被压缩内容的精确原文;更早段见同目录 index.md]`
+            : '';
         const summaryMsg = {
             role: 'system',
-            content: `${SUMMARY_MARKER}\n${body}${provenance}`,
+            content: `${SUMMARY_MARKER}\n${body}${provenance}${archivedRef}`,
         };
         // 原地重建:[systemPrompt, summaryMsg, ...kept]
         const systemMsg = history[0];

package/dist/session/persist.js

@@ -11,9 +11,10 @@ export function newSessionId() {
 export function saveSession(history, id, queryHistory = [], lastToolGroups = []) {
     return defaultSessionStore.save(history, id, queryHistory, lastToolGroups);
 }
-/** 加载会话；不存在或损坏时返回 null。 */
-export function loadSession(id) {
-    return defaultSessionStore.load(id);
+/** 加载会话；不存在或损坏时返回 null。restoreAssets=true 时(resume)把归档 gz
+ *  内嵌的 compacted 资产写回磁盘;列表/检索等只读场景保持默认不产生写盘副作用。 */
+export function loadSession(id, opts) {
+    return defaultSessionStore.load(id, opts);
 }
 /** 列出最近会话，按 createdAt 降序。 */
 export function listSessions(limit) {