evolcore 0.0.33 → 0.0.35-test.0

package/dist/core/memory/index-manager.js

@@ -2,7 +2,7 @@
  * index-manager.ts — MEMORY.md 索引管理（v3）
  *
  * 负责：
- *  1. 重建索引：扫描 consolidated/，逐份验签，按 tags 筛选，截断到 indexMaxBytes
+ *  1. 重建索引：扫描 consolidated/，逐份过台账校验，按 tags 筛选，截断到 indexMaxBytes
  *  2. 追加条目：单条写入时的快速路径（写入后仍以 rebuild 为准）
  *
  * 排序与超期判断一律读**文件 mtime**；frontmatter 的 updatedAt 只作可读信息。
@@ -10,15 +10,16 @@
  * 索引行格式：`- 20261005 [slug] — 描述 [tag1,tag2]`
  *   slug 即文件名（consolidated/<slug>.md），不再重复写路径。
  *
- * 验签规则（v3 收紧）：只认 `verified`。
- *   - `invalid`（签名不符）→ 移入 archive/invalid/，不进索引
- *   - `unsigned`（没有签名块）→ 同样移入 archive/invalid/，不进索引
- * 主会话和整理会话都写不到 consolidated/（create 由程序签名），出现未签名文件
- * 说明有人绕过写入通道直接落盘。
+ * 完整性校验走 file-integrity 台账（docs/file-security/）：
+ *   - 没被动过 → 进索引
+ *   - 被带外修改 → 恢复到最后登记的版本，再进索引
+ *   - 被改动且无法恢复 → 跳过，不进索引，也不移动文件
+ * MEMORY.md 本身每次写入都会登记：它整份注入上下文，被改了同样要能恢复。
  */
 import fs from 'fs';
 import path from 'path';
 import { getMemoryArray, getMemoryString, parseMemoryDocument } from './memory-document.js';
+import { registerFile, verifyFile } from '../file-integrity/store.js';
 /** 索引容量上限（字节）。实际取值由调用方从 memory.indexMaxBytes 传入。 */
 export const DEFAULT_INDEX_MAX_BYTES = 5 * 1024;
 /** Fast metadata index for consolidation candidate scans. */
@@ -246,20 +247,19 @@ function writeIndexFile(indexPath, content) {
     const tmp = indexPath + '.tmp';
     fs.writeFileSync(tmp, content, 'utf-8');
     fs.renameSync(tmp, indexPath);
+    registerFile(indexPath);
 }
 // ── 重建索引 ────────────────────────────────────────────────────────────────
 /**
  * 从 consolidated/ 重建 MEMORY.md。
  *
- * verifyFn 可选。不传时所有文件视为通过，直接进索引，不移动任何文件。
- * 传入时验签失败的文件只跳过（不进索引），同样不移动文件——移动行为是验签门控
- * 开启后才需要的，暂未实现。排序读文件 mtime，按 tags 分级，超 indexMaxBytes
- * 从末尾截断（pinned 标签保留）。
+ * 每份文件先过台账校验（被带外修改的先恢复），被改动且无法恢复的跳过，不移动文件。
+ * 排序读文件 mtime，按 tags 分级，超 indexMaxBytes 从末尾截断（pinned 标签保留）。
  */
-export async function rebuildIndex(consolidatedDir, indexPath, scope, invalidDir, verifyFn, indexMaxBytes = DEFAULT_INDEX_MAX_BYTES) {
+export async function rebuildIndex(consolidatedDir, indexPath, scope, indexMaxBytes = DEFAULT_INDEX_MAX_BYTES) {
     if (!fs.existsSync(consolidatedDir)) {
         writeIndexFile(indexPath, serializeIndex(scope, []));
-        return { indexed: 0, invalidMoved: 0, verifiedFiles: [] };
+        return { indexed: 0, verifiedFiles: [] };
     }
     const files = fs.readdirSync(consolidatedDir).filter(f => f.endsWith('.md')).sort();
     const entries = [];
@@ -269,26 +269,17 @@ export async function rebuildIndex(consolidatedDir, indexPath, scope, invalidDir
         let content;
         let mtimeMs;
         try {
-            content = fs.readFileSync(filePath, 'utf-8');
+            const checked = verifyFile(filePath, { restoreOnFail: true });
+            if (!checked.bytes)
+                continue; // missing / 无法恢复：不进索引
+            content = checked.bytes.toString('utf-8');
+            // 恢复会把 mtime 还原成登记时的值，所以在校验之后再取
             mtimeMs = fs.statSync(filePath).mtimeMs;
         }
         catch {
             continue;
         }
-        if (verifyFn) {
-            const verifyResult = await verifyFn(content);
-            if (verifyResult.status === 'verified') {
-                verifiedFiles.push(file);
-            }
-            else {
-                // 验签失败：跳过，不进索引，不移动文件（门控开启后的移动逻辑暂未实现）
-                continue;
-            }
-        }
-        else {
-            // 未开启验签：所有文件视为通过
-            verifiedFiles.push(file);
-        }
+        verifiedFiles.push(file);
         const document = parseMemoryDocument(content);
         const description = getMemoryString(document, 'description') ?? file.replace(/\.md$/, '');
         const tags = getMemoryArray(document, 'tags');
@@ -304,5 +295,5 @@ export async function rebuildIndex(consolidatedDir, indexPath, scope, invalidDir
     sortEntries(entries);
     const kept = truncateToLimit(scope, entries, indexMaxBytes);
     writeIndexFile(indexPath, serializeIndex(scope, kept));
-    return { indexed: kept.length, invalidMoved: 0, verifiedFiles };
+    return { indexed: kept.length, verifiedFiles };
 }

package/dist/core/memory/memory-admin.js

@@ -12,7 +12,8 @@ import path from 'path';
 import { resolveScopeDirs, archiveMemory, dropMemoryNote, listMemoryNotes } from './memory-writer.js';
 import { rebuildIndex, DEFAULT_INDEX_MAX_BYTES } from './index-manager.js';
 import { refreshMemoryMeta, readMemoryMeta } from './index-manager.js';
-import { parseSignatureBlock, verifyMemoryFile } from './memory-signature.js';
+import { stripLegacySignature } from './memory-document.js';
+import { moveRecord, verifyFile } from '../file-integrity/store.js';
 import { readFmArray, readFmValue, readUpdatedAtMs, reviewWindowDays, DEFAULT_FORGET_AFTER_DAYS } from './staleness.js';
 export const MEMORY_SCOPES = ['relation', 'agent', 'owner'];
 const SLUG_RE = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,63}$/;
@@ -45,10 +46,6 @@ function fmtDate(ms) {
         return '-';
     return new Date(ms).toISOString().slice(0, 16).replace('T', ' ');
 }
-/** 去掉签名块，只留正文（含 frontmatter） */
-function stripSignature(content) {
-    return parseSignatureBlock(content).payload.trimEnd();
-}
 // ── 查看 ────────────────────────────────────────────────────────────────────
 /** 概览：各作用域条数、pending 数、索引大小、最近更新时间。 */
 export function memoryOverview(target, scopes) {
@@ -120,7 +117,6 @@ export function listMemoryFiles(target, scope, archived = false, now = Date.now(
             tags,
             mtimeMs,
             updatedAtMs,
-            signed: !!parseSignatureBlock(content).fields,
             reviewInDays: Math.floor((updatedAtMs + windowMs - now) / DAY_MS),
         });
     }
@@ -135,7 +131,7 @@ export function formatMemoryFiles(scope, files, archived = false) {
     for (const f of files) {
         const tags = f.tags.length ? ` [${f.tags.join(',')}]` : '';
         const review = archived ? '' : f.reviewInDays < 0 ? '  ⏳待审查' : `  ${f.reviewInDays}天后审查`;
-        lines.push(`- ${f.slug}${tags}${f.signed ? '' : '  ⚠️未签名'}${review}`);
+        lines.push(`- ${f.slug}${tags}${review}`);
         if (f.description)
             lines.push(`  ${f.description}`);
         lines.push(`  更新于 ${fmtDate(f.updatedAtMs)}`);
@@ -158,16 +154,21 @@ export async function showMemoryFile(target, scope, slug, archived = false) {
     const fp = path.join(dir, `${slug}.md`);
     if (!fs.existsSync(fp))
         throw new Error(`找不到记忆: ${scope}/${archived ? 'archive/' : ''}${slug}`);
-    const content = fs.readFileSync(fp, 'utf-8');
     let verify;
+    let content;
     try {
-        const r = await verifyMemoryFile(content, target.selfAid);
-        verify = r.status === 'verified' ? '✅ 签名有效' : r.status === 'unsigned' ? '⚠️ 未签名' : `❌ 签名无效（${r.reason ?? 'unknown'}）`;
+        const r = verifyFile(fp, { restoreOnFail: true });
+        verify = r.status === 'verified' ? '✅ 校验通过'
+            : r.status === 'restored' ? '♻️ 检测到带外修改，已恢复到最后登记版本'
+                : '❌ 被改动且无法恢复';
+        // tampered 时没有校验过的字节，显示磁盘现状供排查
+        content = r.bytes ? r.bytes.toString('utf-8') : fs.readFileSync(fp, 'utf-8');
     }
     catch (e) {
-        verify = `⚠️ 无法验签（${e?.message || String(e)}）`;
+        verify = `⚠️ 无法校验（${e?.message || String(e)}）`;
+        content = fs.readFileSync(fp, 'utf-8');
     }
-    let body = stripSignature(content);
+    let body = stripLegacySignature(content).trimEnd();
     if (body.length > MAX_SHOW_CHARS)
         body = `${body.slice(0, MAX_SHOW_CHARS)}\n…（已截断）`;
     return `📄 ${scope}/${archived ? 'archive/' : ''}${slug}  ${verify}\n${body}`;
@@ -201,8 +202,7 @@ export function showPendingNote(target, slug) {
 /** 重建某作用域的 MEMORY.md 并刷新 _meta.json。 */
 export async function reindexScope(target, scope) {
     const dirs = scopeDirs(target, scope);
-    const r = await rebuildIndex(dirs.consolidatedDir, path.join(dirs.memoryDir, 'MEMORY.md'), scope, path.join(dirs.memoryDir, 'archive', 'invalid'), undefined, // 与 ipc 一致：验签门控尚未开启
-    target.memoryConfig?.indexMaxBytes ?? DEFAULT_INDEX_MAX_BYTES);
+    const r = await rebuildIndex(dirs.consolidatedDir, path.join(dirs.memoryDir, 'MEMORY.md'), scope, target.memoryConfig?.indexMaxBytes ?? DEFAULT_INDEX_MAX_BYTES);
     refreshMemoryMeta(dirs.memoryDir);
     return { indexed: r.indexed };
 }
@@ -228,7 +228,12 @@ export async function restoreMemoryFile(target, scope, slug) {
         throw new Error(`找不到已归档记忆: ${scope}/${slug}`);
     if (fs.existsSync(dest))
         throw new Error(`正式记忆中已存在同名文件: ${scope}/${slug}，未恢复`);
+    // 归档期间被改过的话先恢复；恢复不了就拒绝，不把篡改内容放回正式记忆
+    const checked = verifyFile(src, { restoreOnFail: true });
+    if (!checked.bytes)
+        throw new Error(`MEMORY_TAMPERED: 已归档记忆被改动且无法恢复，未恢复: ${scope}/${slug}`);
     fs.mkdirSync(dirs.consolidatedDir, { recursive: true });
     fs.renameSync(src, dest);
+    moveRecord(src, dest);
     await reindexScope(target, scope);
 }

package/dist/core/memory/memory-document.js

@@ -2,10 +2,58 @@
  * Shared representation for memory Markdown documents.
  *
  * Memory files have two mutable blocks: YAML-like frontmatter and Markdown
- * body. AUN signature blocks are stripped while parsing and are never exposed
- * as a document block; consolidated writers sign the serialized result again.
+ * body. 新记忆不再签名（完整性改由 file-integrity 台账保证）；磁盘上的老记忆
+ * 可能还带尾部 AUN 签名块，解析时剥掉，重写时不再写回。
  */
-import { parseSignatureBlock } from './memory-signature.js';
+// ── 老签名块兼容剥离 ──────────────────────────────────────────────────────────
+// 规则与原 memory-signature.ts 的 parseSignatureBlock 一致：只有格式完全合法的
+// 签名块才剥；格式不对的标记可能就是正文，原样保留每个字节。
+const LEGACY_SIGNATURE_MARKER = '<!-- AUN-SIGNATURE';
+const LEGACY_SIGNATURE_RE = /^<!-- AUN-SIGNATURE(?:\r\n|\n|\r)(?<body>[\s\S]*?)(?:\r\n|\n|\r)-->\s*$/;
+const LEGACY_REQUIRED_FIELDS = ['cert_fingerprint', 'timestamp', 'signature'];
+const LEGACY_ALLOWED_FIELDS = [...LEGACY_REQUIRED_FIELDS, 'public_key_fingerprint'];
+const SHA256_FP_RE = /^sha256:[0-9a-f]{64}$/i;
+function isStrictBase64(value) {
+    if (!value || value.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(value))
+        return false;
+    return Buffer.from(value, 'base64').toString('base64') === value;
+}
+function isValidLegacySignatureBlock(tail) {
+    const match = tail.match(LEGACY_SIGNATURE_RE);
+    if (!match)
+        return false;
+    const fields = {};
+    for (const rawLine of (match.groups?.body ?? '').split(/\r\n|\n|\r/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const colon = line.indexOf(':');
+        if (colon < 0)
+            return false;
+        const key = line.slice(0, colon).trim().toLowerCase();
+        if (Object.prototype.hasOwnProperty.call(fields, key))
+            return false;
+        fields[key] = line.slice(colon + 1).trim();
+    }
+    if (LEGACY_REQUIRED_FIELDS.some(k => !fields[k]))
+        return false;
+    if (Object.keys(fields).some(k => !LEGACY_ALLOWED_FIELDS.includes(k)))
+        return false;
+    if (!SHA256_FP_RE.test(fields.cert_fingerprint))
+        return false;
+    if (fields.public_key_fingerprint && !SHA256_FP_RE.test(fields.public_key_fingerprint))
+        return false;
+    return /^\d+$/.test(fields.timestamp) && isStrictBase64(fields.signature);
+}
+/** 去掉老记忆尾部合法的 AUN 签名块；没有或不合法时原样返回。 */
+export function stripLegacySignature(content) {
+    const idx = content.lastIndexOf(LEGACY_SIGNATURE_MARKER);
+    if (idx < 0 || content.indexOf(LEGACY_SIGNATURE_MARKER) !== idx)
+        return content;
+    if (idx > 0 && content[idx - 1] !== '\n' && content[idx - 1] !== '\r')
+        return content;
+    return isValidLegacySignatureBlock(content.slice(idx)) ? content.slice(0, idx) : content;
+}
 function parseArray(raw) {
     const value = raw.match(/^\[([^\]]*)\]$/)?.[1] ?? raw;
     return value
@@ -29,13 +77,9 @@ function splitDocument(content) {
         hasFrontmatter: true,
     };
 }
-/** Parse frontmatter and body; an existing AUN signature is ignored. */
+/** Parse frontmatter and body; a legacy AUN signature block is ignored. */
 export function parseMemoryDocument(content) {
-    const signature = parseSignatureBlock(content);
-    // A malformed marker may be ordinary body text. Only strip a signature when
-    // the signature parser accepted the block; otherwise preserve every byte.
-    const unsigned = signature.fields ? signature.payload : content;
-    const parts = splitDocument(unsigned);
+    const parts = splitDocument(stripLegacySignature(content));
     const fields = {};
     const fieldOrder = [];
     const extraFrontmatterLines = [];

package/dist/core/memory/memory-writer.js

@@ -4,21 +4,22 @@
  * 只有整理会话（sessionType=memory）能调用这三个操作，由 ipc.ts 做会话类型与
  * 模式↔作用域的双重校验后委托到这里。本模块只负责文件层面的动作：
  *
- *   - createMemory  新建正式记忆：写 consolidated/、签名、归档 --replaces 的旧文件
- *   - updateMemory  改标签或续期（--touch），改完重新签名
+ *   - createMemory  新建正式记忆：写 consolidated/、归档 --replaces 的旧文件
+ *   - updateMemory  改标签或续期（--touch）
  *   - archiveMemory 归档（唯一的下线方式，没有删除）
  *
- * 签名基础设施已就绪（signMemoryFile），但验签门控尚未开启——
- * 门控设计已存档，待后续按需启用。
+ * 正式记忆的完整性由 file-integrity 台账保证（docs/file-security/）：
+ * 落盘后 registerFile，rename 后 moveRecord，读改写之前先 verifyFile。
+ * pending note 是草稿，不进台账。
  */
 import fs from 'fs';
 import path from 'path';
 import { resolveRoot } from '../../paths.js';
-import { signMemoryFile } from './memory-signature.js';
+import { moveRecord, registerFile, verifyFile } from '../file-integrity/store.js';
 import { refreshMemoryMeta } from './index-manager.js';
 import { getMemoryArray, getMemoryString, parseMemoryDocument, serializeMemoryDocument, setMemoryField, } from './memory-document.js';
 const SLUG_RE = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,63}$/;
-/** 与 memory-signature.ts 的 MAX_MEMORY_BYTES 保持一致（10KB）。 */
+/** 一条记忆应是一句话能说清的结论，10KB 足够；超过通常意味着该拆成多条。 */
 const MAX_CONTENT_BYTES = 10 * 1024;
 /** 解析某个作用域的记忆目录。 */
 export function resolveScopeDirs(scope, taskCtx, ownerAid, peerKeyOverride) {
@@ -49,8 +50,10 @@ export function resolveScopeDirs(scope, taskCtx, ownerAid, peerKeyOverride) {
 /**
  * 把用户给的路径解析成 consolidated/ 下的绝对路径。
  * 允许 slug / <slug>.md / 相对或绝对路径（须落在本作用域的 consolidated/ 内）。
+ *
+ * forget-agent 模式特殊处理：允许路径落在任意 relation 的 consolidated/ 下。
  */
-export function resolveConsolidatedPath(dirs, input) {
+export function resolveConsolidatedPath(dirs, input, taskCtx) {
     const base = path.resolve(dirs.consolidatedDir);
     const looksLikePath = input.includes('/') || input.includes('\\');
     if (!looksLikePath) {
@@ -65,6 +68,20 @@ export function resolveConsolidatedPath(dirs, input) {
         if (!rel.startsWith('..') && !path.isAbsolute(rel))
             return abs;
     }
+    // forget-agent 模式：允许路径落在任意 relation 的 consolidated/ 下，或 agent 自身的 consolidated/
+    const isForgetAgent = taskCtx?.memoryMode === 'forget' && taskCtx?.memoryScope === 'agent';
+    if (isForgetAgent && taskCtx?.selfAid) {
+        const relationsRoot = path.join(resolveRoot(), 'agents', taskCtx.selfAid, 'relations');
+        const absInput = path.resolve(input);
+        const relToRelations = path.relative(relationsRoot, absInput);
+        // 检查是否在某个 relation 的 consolidated/ 下
+        if (!relToRelations.startsWith('..') && !path.isAbsolute(relToRelations)) {
+            const parts = relToRelations.split(path.sep);
+            if (parts.length >= 3 && parts[1] === 'memory' && parts[2] === 'consolidated') {
+                return absInput;
+            }
+        }
+    }
     throw new Error(`ROLE_ACCESS_DENIED: 只能操作本作用域 consolidated/ 下的记忆（${base}），当前路径越界: ${input}`);
 }
 function assertSlug(slug) {
@@ -76,8 +93,18 @@ function assertSlug(slug) {
 function readMemory(content) {
     return parseMemoryDocument(content);
 }
-function writeSignedMemory(document, selfAid) {
-    return signMemoryFile(serializeMemoryDocument(document), selfAid).then(result => result.signed);
+/**
+ * 读 → 改 → 重写之前先过台账：被带外改过就先恢复，用校验过的内容做修改基础。
+ * 直接读盘的话，篡改内容改一下就会被重新登记成新基线。
+ */
+function readVerifiedMemory(filePath) {
+    const r = verifyFile(filePath, { restoreOnFail: true });
+    if (r.status === 'missing')
+        throw new Error(`找不到记忆文件: ${filePath}`);
+    if (!r.bytes) {
+        throw new Error(`MEMORY_TAMPERED: 记忆文件被改动且无法恢复，已拒绝操作: ${filePath}`);
+    }
+    return r.bytes.toString('utf-8');
 }
 export async function createMemory(req) {
     assertSlug(req.slug);
@@ -93,7 +120,7 @@ export async function createMemory(req) {
     const dirs = resolveScopeDirs(req.scope, req.taskCtx, req.ownerAid, req.targetPeerKey);
     fs.mkdirSync(dirs.consolidatedDir, { recursive: true });
     const targetPath = path.join(dirs.consolidatedDir, `${req.slug}.md`);
-    const replacePaths = (req.replaces ?? []).map(p => resolveConsolidatedPath(dirs, p));
+    const replacePaths = (req.replaces ?? []).map(p => resolveConsolidatedPath(dirs, p, req.taskCtx));
     // 撞名闸门：目标已存在且没被 --replaces 覆盖 → 拒绝
     if (fs.existsSync(targetPath) && !replacePaths.includes(targetPath)) {
         throw new Error(`SLUG_EXISTS: 目标已存在: ${targetPath}\n` +
@@ -134,10 +161,10 @@ export async function createMemory(req) {
     if (replacePaths.length > 0)
         setMemoryField(document, 'replaces', replacePaths.map(p => path.relative(dirs.memoryDir, p)));
     document.body = req.content.trimEnd();
-    const signed = await writeSignedMemory(document, req.taskCtx.selfAid);
     const tmp = targetPath + '.tmp';
-    fs.writeFileSync(tmp, signed, 'utf-8');
+    fs.writeFileSync(tmp, serializeMemoryDocument(document), 'utf-8');
     fs.renameSync(tmp, targetPath);
+    registerFile(targetPath, req.taskCtx.selfAid);
     // 归档被替换的旧文件（在写入成功之后做，失败不影响新文件）
     const archived = [];
     for (const p of replacePaths) {
@@ -150,6 +177,7 @@ export async function createMemory(req) {
         try {
             fs.renameSync(p, dest);
             archived.push(dest);
+            moveRecord(p, dest);
         }
         catch { /* 归档失败不影响主流程，由下次整理清理 */ }
     }
@@ -206,7 +234,8 @@ export async function demoteMemory(req) {
     const srcPath = path.join(srcDirs.consolidatedDir, `${req.slug}.md`);
     if (!fs.existsSync(srcPath))
         throw new Error(`找不到记忆文件: ${srcPath}`);
-    const content = fs.readFileSync(srcPath, 'utf-8');
+    // 降级目标由 frontmatter 决定，必须读校验过的内容，否则改一下来源字段就能把记忆搬去别处
+    const content = readVerifiedMemory(srcPath);
     const fromRelPath = getMemoryString(readMemory(content), req.scope === 'agent' ? 'generalizedFrom' : 'promotedFrom');
     if (!fromRelPath) {
         throw new Error(`DEMOTE_NO_SOURCE: 记忆文件缺少来源字段（${req.scope === 'agent' ? 'generalizedFrom' : 'promotedFrom'}），` +
@@ -229,12 +258,14 @@ export async function demoteMemory(req) {
         const archiveDest = archivePath(srcDirs.memoryDir, srcPath);
         fs.mkdirSync(path.dirname(archiveDest), { recursive: true });
         fs.renameSync(srcPath, archiveDest);
+        moveRecord(srcPath, archiveDest);
         finalDestPath = archiveDest;
         conflictArchived = true;
     }
     else {
         fs.mkdirSync(path.dirname(destPath), { recursive: true });
         fs.renameSync(srcPath, destPath);
+        moveRecord(srcPath, destPath);
     }
     // 跨作用域搬运，源与目标两个目录都要刷新元数据
     refreshMemoryMeta(srcDirs.memoryDir);
@@ -249,21 +280,20 @@ export async function demoteMemory(req) {
 }
 export async function updateMemory(req) {
     const dirs = resolveScopeDirs(req.scope, req.taskCtx, req.ownerAid);
-    const filePath = resolveConsolidatedPath(dirs, req.target);
+    const filePath = resolveConsolidatedPath(dirs, req.target, req.taskCtx);
     if (!fs.existsSync(filePath))
         throw new Error(`找不到记忆文件: ${filePath}`);
-    const raw = fs.readFileSync(filePath, 'utf-8');
-    const document = readMemory(raw);
+    const document = readMemory(readVerifiedMemory(filePath));
     const prevTags = getMemoryArray(document, 'tags');
     if (req.tags !== undefined)
         setMemoryField(document, 'tags', req.tags.length > 0 ? req.tags : undefined);
     // 刷新 updatedAt（--touch 的续期语义就是刷新这里 + 文件 mtime）
     const now = new Date().toISOString();
     setMemoryField(document, 'updatedAt', now);
-    const signed = await writeSignedMemory(document, req.taskCtx.selfAid);
     const tmp = filePath + '.tmp';
-    fs.writeFileSync(tmp, signed, 'utf-8');
+    fs.writeFileSync(tmp, serializeMemoryDocument(document), 'utf-8');
     fs.renameSync(tmp, filePath);
+    registerFile(filePath, req.taskCtx.selfAid);
     refreshMemoryMeta(dirs.memoryDir);
     return { ok: true, filePath, prevTags, scopeDirs: dirs };
 }
@@ -272,12 +302,13 @@ export async function archiveMemory(req) {
     const dirs = resolveScopeDirs(req.scope, req.taskCtx, req.ownerAid);
     const archived = [];
     for (const t of req.targets) {
-        const p = resolveConsolidatedPath(dirs, t);
+        const p = resolveConsolidatedPath(dirs, t, req.taskCtx);
         if (!fs.existsSync(p))
             throw new Error(`找不到记忆文件: ${p}`);
         const dest = archivePath(dirs.memoryDir, p);
         fs.mkdirSync(path.dirname(dest), { recursive: true });
         fs.renameSync(p, dest);
+        moveRecord(p, dest);
         archived.push(dest);
     }
     refreshMemoryMeta(dirs.memoryDir);

package/dist/core/message/aun-ipc-sender.js

@@ -28,7 +28,7 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
         const log = {
             content: classified.content,
             sessionId: targetSession.id,
-            threadId: targetSession.threadId || null,
+            threadId: targetSession.threadId || '',
             msgType: classified.msgType,
             payloadType: classified.payloadType,
             payloadSummary: classified.payloadSummary,
@@ -267,6 +267,24 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
         if (!payload) {
             return { ok: false, error: 'message payload is required', code: 'INVALID_PAYLOAD' };
         }
+        // 托管 argv 通道（runManagedSend）先前不带 log 元数据：群聊 sendDaemonGroupMsg
+        // 自身会写日志，私聊 sendDaemonMsg 只在 args.log 存在时才写，于是同一份
+        // `ec msg send` 在私聊下不落 messages.jsonl，话题历史里查不到已发出的消息。
+        // 这里在 payload 定型后按同一套规则补出日志元数据，让两条路径记账一致。
+        if (params.argv !== undefined && params.log === undefined) {
+            const classified = classifyAunPayloadForLog(payload);
+            params = {
+                ...params,
+                log: {
+                    content: classified.content,
+                    threadId: params.thread ?? '',
+                    msgType: classified.msgType,
+                    payloadType: classified.payloadType,
+                    payloadSummary: classified.payloadSummary,
+                    source: 'msg',
+                },
+            };
+        }
         try {
             if (Object.prototype.hasOwnProperty.call(payload, 'mentions')) {
                 payload = { ...payload, mentions: normalizeAunMentionEntries(payload.mentions) };

package/dist/core/message/im-renderer.js

@@ -1,6 +1,6 @@
 import { logger } from '../../utils/logger.js';
 import { summarizeToolInput, summarizeToolInputForDisplay, toolInputForDisplay } from '../../utils/tool-summary.js';
-import { getErrorMessage, isContextTooLongText } from '../../utils/error-utils.js';
+import { getErrorMessage, getToolResultErrorText, isContextTooLongText } from '../../utils/error-utils.js';
 import { tagErrorTextWithEvolcoreVersion } from '../../utils/evolcore-version.js';
 import { DEFAULT_FLUSH_DELAY_MS } from '../../types.js';
 import { classifyAunToolErrorCode, normalizeToolErrorClassification } from '../permission/tool-error-code.js';
@@ -275,7 +275,13 @@ export class IMRenderer {
             name,
             ok,
             ...(result !== undefined && { result }),
-            ...(error !== undefined && { error }),
+            ...(!ok
+                ? { error: getToolResultErrorText({ name, result, error, exitCode: classification?.exitCode }) }
+                : error !== undefined ? { error } : {}),
+            ...(typeof classification?.exitCode === 'number' && Number.isInteger(classification.exitCode)
+                ? { exit_code: classification.exitCode }
+                : {}),
+            ...(classification?.outputKind ? { output_kind: classification.outputKind } : {}),
             ...(!ok && {
                 error_code: classifyAunToolErrorCode({
                     ...(classification ?? {}),
@@ -904,7 +910,13 @@ export class IMRenderer {
                     item.arguments = toolInputForDisplay(event.name, event.input);
                 return item;
             }
-            case 'tool_result':
+            case 'tool_result': {
+                const executionFields = {
+                    ...(typeof event.exitCode === 'number' && Number.isInteger(event.exitCode)
+                        ? { exit_code: event.exitCode }
+                        : {}),
+                    ...(event.outputKind ? { output_kind: event.outputKind } : {}),
+                };
                 if (event.isError) {
                     const classification = normalizeToolErrorClassification(event);
                     return {
@@ -912,9 +924,11 @@ export class IMRenderer {
                         call_id: event.callId || this.synthCallId(),
                         name: event.name,
                         ok: false,
+                        ...executionFields,
+                        ...(event.result !== undefined ? { result: event.result } : {}),
                         error_code: classifyAunToolErrorCode({ ...event, ...classification }),
                         ...(classification.errorDetailCode ? { detail_code: classification.errorDetailCode } : {}),
-                        error: event.error || (typeof event.result === 'string' ? event.result : '执行失败'),
+                        error: getToolResultErrorText(event),
                         ...(event.durationMs !== undefined && { duration_ms: event.durationMs }),
                     };
                 }
@@ -925,11 +939,13 @@ export class IMRenderer {
                         call_id: event.callId || this.synthCallId(),
                         name: event.name,
                         ok: true,
+                        ...executionFields,
                         result: event.result,
                         text: resultText,
                         ...(event.durationMs !== undefined && { duration_ms: event.durationMs }),
                     };
                 }
+            }
             case 'compact':
                 return {
                     kind: 'notice',

package/dist/core/message/message-bridge.js

@@ -137,7 +137,8 @@ export class MessageBridge {
                     logger.debug(`[MessageBridge] Decision context group rules unavailable: ${String(error)}`);
                 }
             }
-            const personalPath = path.join(agentDir(item.selfAid), 'personal', 'personal.md');
+            // persona.md 是唯一的人格/个人资料文件（personal.md 已废弃并入）
+            const personalPath = path.join(agentDir(item.selfAid), 'personal', 'persona.md');
             if (fs.existsSync(personalPath))
                 resources.personal = fs.readFileSync(personalPath, 'utf8');
             if (item.projectPath) {
@@ -1263,7 +1264,7 @@ export class MessageBridge {
                         appendMessageLog(chatDir, buildInboundEntry({
                             from: msg.peerId || 'unknown',
                             to: msg.selfAID || 'self',
-                            threadId: msg.threadId ?? null,
+                            threadId: msg.threadId ?? '',
                             chatType: msg.chatType || 'private',
                             groupId: msg.groupId ?? null,
                             msgId: msg.messageId ?? null,
@@ -1548,7 +1549,7 @@ export class MessageBridge {
                             from: msg.peerId || 'unknown',
                             to: msg.selfAID || 'self',
                             sessionId: session.id,
-                            threadId: session.threadId || null,
+                            threadId: session.threadId || '',
                             chatType,
                             groupId: msg.groupId ?? null,
                             msgId: msg.messageId ?? null,
@@ -1607,7 +1608,7 @@ export class MessageBridge {
                         const member = item.value;
                         appendMessageLog(inboundEntry.chatDir, buildInboundEntry({
                             from: item.sender, to: selfAid || '', sessionId: session.id,
-                            threadId: session.threadId || null, chatType: 'group', groupId: msg.groupId,
+                            threadId: session.threadId || '', chatType: 'group', groupId: msg.groupId,
                             msgId: item.messageId, content: member.messageLogContent ?? item.content,
                             permMode: item.role, timestamp: item.receivedAt,
                             receivedAt: member.receivedAt, gatewaySeq: member.gatewaySeq,

package/dist/core/message/message-log.js

@@ -21,6 +21,7 @@ const TRANSIENT_PROTOCOL_TYPES = new Set([
     'handoff_state',
     'handoff_result',
     'topic-created', // 话题创建系统消息，不进大模型上下文
+    'topic-renamed', // 话题改名通知，由 channel 层直接消费，不进大模型上下文
 ]);
 const KNOWN_AUN_PAYLOAD_TYPES = new Set([
     'text',

package/dist/core/message/peer-mode.js

@@ -31,6 +31,23 @@ export function resolveChatMode(params) {
         ? effectiveValue
         : chatmodeFactoryDefaults()[field];
 }
+/**
+ * 出站发送路径（`ec msg send` / daemon 私聊发送）用的最小判定。
+ *
+ * 这两条路径只有对端身份、拿不到角色，因此不能复用 `resolveChatMode` 的
+ * 分层配置。口径与 `resolveChatMode` 的硬约束保持一致：
+ *   - 非人类对端（isMachine）→ proactive
+ *   - 人类但角色未知 → proactive（保守侧）
+ *   - 人类且 owner/admin → interactive
+ *
+ * 角色未知时不能假设高信任：interactive 表示"输出即回复"的同步交互，
+ * 只应给已确认的管理者。
+ */
+export function chatmodeForPeerIdentity(identity, role) {
+    if (identity.isMachine)
+        return 'proactive';
+    return resolveChatMode({ role: role ?? undefined, chatType: 'private', peerType: identity.type ?? 'human' });
+}
 export function resolveChatModeForField(params) {
     return resolveChatMode({
         ...params,