evolcore 0.0.33 → 0.0.34

package/dist/core/memory/consolidation.js

@@ -12,35 +12,35 @@ import fs from 'fs';
 import path from 'path';
 import { agentDir, resolveRoot } from '../../paths.js';
 import { serializeConsolidationContext } from './consolidation-context.js';
+import { assertSystemSessionLaunchable } from '../system-session/registry.js';
+import { ensureSessionRuntimeDir } from '../../cli/task-context.js';
 import { formatChannelKey } from '../channel-loader.js';
 import { logger } from '../../utils/logger.js';
-import { appendOpsRecord } from './consolidation-ops-records.js';
+import { appendOpsRecord, feedbackFilePath, readFeedbackText } from './consolidation-ops-records.js';
+import { updateBatchMeta } from './batch-meta.js';
 import { checkConsolidationCandidates, shouldUseMetaIndex } from './consolidation-trigger.js';
 /**
- * 清理当前 agent 的旧整理批次。
- * 启动新整理时调用，保留最新的一个会话历史用于查看和调试。
+ * 清理旧整理批次，全局保留最新的 10 个（不区分 aid 或 mode）。
+ * 启动新整理时调用；selfAid 参数保留供日志上下文用，不参与过滤。
  */
-function cleanupPreviousConsolidationBatches(selfAid) {
+function cleanupPreviousConsolidationBatches(_selfAid) {
     try {
         const batchRoot = path.join(resolveRoot(), 'memory', 'consolidation-batches');
         if (!fs.existsSync(batchRoot))
             return;
-        // 匹配格式：YYYYMMDDTHHMMSS-<selfAid>-*
-        const escapedAid = selfAid.replace(/\./g, '\\.');
-        const pattern = new RegExp(`^\\d{8}T\\d{6}-${escapedAid}-`);
         const entries = fs.readdirSync(batchRoot, { withFileTypes: true })
-            .filter(e => e.isDirectory() && pattern.test(e.name))
+            .filter(e => e.isDirectory())
             .map(e => ({ name: e.name, path: path.join(batchRoot, e.name) }))
-            .sort((a, b) => b.name.localeCompare(a.name)); // 最新的在前
-        // 保留最新的一个，删除其他
-        for (let i = 1; i < entries.length; i++) {
+            .sort((a, b) => b.name.localeCompare(a.name)); // 时间戳前缀，字典序即时间序，最新的在前
+        const KEEP = 10;
+        for (let i = KEEP; i < entries.length; i++) {
             const dir = entries[i];
             try {
                 fs.rmSync(dir.path, { recursive: true, force: true });
-                logger.debug(`[Memory] 清理前一次整理批次: ${dir.name}`);
+                logger.debug(`[Memory] 清理旧整理批次: ${dir.name}`);
             }
             catch (e) {
-                logger.warn(`[Memory] 清理前一次整理批次失败 ${dir.name}: ${e?.message}`);
+                logger.warn(`[Memory] 清理旧整理批次失败 ${dir.name}: ${e?.message}`);
             }
         }
     }
@@ -60,6 +60,10 @@ export async function launchConsolidation(channel, params) {
     const selfAid = effectiveCtx.selfAid;
     if (!selfAid)
         throw new Error('无法确定当前 agent AID（selfAid 为空）');
+    // 系统会话标记：类型 / subtype 必须已注册，runner 必须受支持（Gemini 拒绝）。
+    // 放在认领 processing 之前，拒绝时不留副作用。
+    const systemSession = { type: 'memory', subtype: mode };
+    assertSystemSessionLaunchable(systemSession, effectiveCtx.baseagent ?? 'claude');
     // 清理旧的整理批次（保留最新的一个历史）
     cleanupPreviousConsolidationBatches(selfAid);
     // notes 模式：pending/ → processing/ 快照迁移（在序列化上下文之前执行，声明认领）
@@ -96,7 +100,6 @@ export async function launchConsolidation(channel, params) {
             triggeredBy,
             taskCtx: effectiveCtx,
             ownerAid,
-            sessionRuntimeDir: effectiveCtx.sessionRuntimeDir,
             ownerInvolved: params.ownerInvolved,
             forgetAfterDays: params.forgetAfterDays,
             scopeOverride: params.scopeOverride,
@@ -147,6 +150,8 @@ export async function launchConsolidation(channel, params) {
             projectPath,
             prompt,
             metadata: {
+                // 系统会话的唯一判据：路径 / 工具 / ec 命令由 system-session/memory.ts 决定，与角色无关
+                systemSession,
                 sessionType: 'memory',
                 memoryMode: mode,
                 ...(params.scopeOverride ? { memoryScope: params.scopeOverride } : {}),
@@ -154,6 +159,7 @@ export async function launchConsolidation(channel, params) {
                 consolidationBatchDir: ctxFile.batchDir,
                 ...(ctxFile.chatDir ? { consolidationChatDir: ctxFile.chatDir } : {}),
                 ...(claimedProcessing && memoryDir ? { consolidationMemoryDir: memoryDir } : {}),
+                ...(ownerAid ? { consolidationOwnerAid: ownerAid } : {}),
                 consolidationUsedThreadSnapshots: !!ctxFile.threadFiles?.length,
                 ...(ctxFile.snapshotThroughTs ? { consolidationSnapshotThroughTs: ctxFile.snapshotThroughTs } : {}),
                 ...(effectiveCtx.peerKey ? { peerKey: effectiveCtx.peerKey } : {}),
@@ -380,9 +386,8 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
                     for (const [scope, memoryDir] of affectedScopes) {
                         const consolidatedDir = path.join(memoryDir, 'consolidated');
                         const indexPath = path.join(memoryDir, 'MEMORY.md');
-                        const invalidDir = path.join(memoryDir, 'archive', 'invalid');
                         try {
-                            await rebuildIndex(consolidatedDir, indexPath, scope, invalidDir, undefined, maxBytes);
+                            await rebuildIndex(consolidatedDir, indexPath, scope, maxBytes);
                         }
                         catch { }
                     }
@@ -464,12 +469,28 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
                     fs.writeFileSync(historyPath, JSON.stringify({ note: `runner ${baseagent} does not support getSessionMessages` }) + '\n', 'utf-8');
                 }
             }
+            // feedback 只读一次：先落 batch.md，再清 scratch/，投递复用同一份文本
+            const customText = readFeedbackText(batchDir);
+            // batch.md 收尾更新：写入最终状态和 feedback 正文
+            try {
+                updateBatchMeta(batchDir, {
+                    status: success ? 'completed' : 'failed',
+                    finishedAt: new Date().toISOString(),
+                    success,
+                    ...(session.agentSessionId ? { agentSessionId: session.agentSessionId } : {}),
+                    feedbackText: customText,
+                });
+            }
+            catch { /* 失败静默 */ }
+            // scratch/ 是会话期临时工作区，feedback 已落 batch.md，不分成败与触发方式一律清掉
+            try {
+                fs.rmSync(path.dirname(feedbackFilePath(batchDir)), { recursive: true, force: true });
+            }
+            catch { /* 静默，不影响投递 */ }
             const feedbackOrigin = meta.feedbackOrigin;
             const triggeredBy = meta.consolidationTriggeredBy;
             if (feedbackOrigin && triggeredBy && triggeredBy !== 'periodic-trigger' && session.selfAID) {
                 try {
-                    const { readFeedbackText } = await import('./consolidation-ops-records.js');
-                    const customText = readFeedbackText(batchDir);
                     const text = customText ?? renderDefaultConsolidationFeedback({
                         mode: meta.memoryMode,
                         triggeredBy,
@@ -490,6 +511,21 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
         finally {
             if (releaseAid && sessionId)
                 releaseSlot(releaseAid, sessionId);
+            // runtime 目录清理：immediate 策略下，finalizer 是最后一个要读它的消费者。
+            // 用 sessionId 无状态重算路径，不依赖 spec 传递——保证即使 spec 不传 runtimeDir
+            // 字段，目录也能在会话结束后被清掉。
+            if (sessionId) {
+                const runtimeDir = ensureSessionRuntimeDir(sessionId);
+                if (runtimeDir) {
+                    try {
+                        fs.rmSync(runtimeDir, { recursive: true, force: true });
+                        logger.debug(`[Memory] 清理 runtime 目录: ${runtimeDir}`);
+                    }
+                    catch (cleanupError) {
+                        logger.warn(`[Memory] runtime 目录清理失败（session=${sessionId}）: ${cleanupError?.message}`);
+                    }
+                }
+            }
         }
     };
 }
@@ -514,19 +550,48 @@ export function createConsolidationFeedbackSender(getChannel) {
             replyContext.threadId = threadId;
         if (chatType)
             replyContext.delivery = { chatType };
-        await binding.adapter.send(buildEnvelope({
-            taskId: `memory-feedback-${Date.now()}`,
+        // 对比期：同一份反馈 notice、text 各发一条，观察两种模式在对端的差异，
+        // 跑通后删掉 text 那条。两条 taskId 后缀不同，避免共用 operationId 被出站去重吞掉一条；
+        // 各自 try，一条失败不连累另一条。
+        const stamp = Date.now();
+        const envelopeFor = (suffix) => buildEnvelope({
+            taskId: `memory-feedback-${stamp}-${suffix}`,
             channel: binding.adapter.channelKey,
             channelId,
             agentName: binding.agentName,
             replyContext: Object.keys(replyContext).length > 0 ? replyContext : undefined,
-        }), {
-            kind: 'result.text',
-            text,
-            isFinal: true,
-            format: 'markdown',
         });
-        logger.info(`[Memory] 整理反馈已投递（aid=${selfAid}，channelId=${channelId}）`);
+        const attempts = [
+            {
+                mode: 'notice',
+                send: () => binding.adapter.send(envelopeFor('notice'), {
+                    kind: 'system.notice',
+                    text,
+                    subtype: 'memory.consolidation.result',
+                }),
+            },
+            {
+                mode: 'text',
+                send: () => binding.adapter.send(envelopeFor('text'), {
+                    kind: 'result.text',
+                    text,
+                    isFinal: true,
+                    format: 'markdown',
+                }),
+            },
+        ];
+        const failures = [];
+        for (const { mode, send } of attempts) {
+            try {
+                await send();
+                logger.info(`[Memory] 整理反馈已投递（mode=${mode}，aid=${selfAid}，channelId=${channelId}）`);
+            }
+            catch (error) {
+                failures.push(`${mode}: ${error?.message}`);
+            }
+        }
+        if (failures.length > 0)
+            throw new Error(failures.join('; '));
     };
 }
 export function registerConsolidationSessionEvents({ eventBus, permissionGateway, finalize, }) {

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) {
@@ -76,8 +77,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);
@@ -134,10 +145,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 +161,7 @@ export async function createMemory(req) {
         try {
             fs.renameSync(p, dest);
             archived.push(dest);
+            moveRecord(p, dest);
         }
         catch { /* 归档失败不影响主流程，由下次整理清理 */ }
     }
@@ -206,7 +218,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 +242,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);
@@ -252,18 +267,17 @@ export async function updateMemory(req) {
     const filePath = resolveConsolidatedPath(dirs, req.target);
     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 };
 }
@@ -278,6 +292,7 @@ export async function archiveMemory(req) {
         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/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',