evolcore 0.0.33 → 0.0.35-test.0

package/dist/core/memory/consolidation-context.js

@@ -1,9 +1,13 @@
 /**
  * consolidation-context.ts — 整理上下文 MD 文档序列化（v3）
  *
- * 把一次整理所需的全部信息序列化成 Markdown，写两处：
- *   - sessionRuntimeDir（会话内读取用，随会话销毁）
- *   - $EVOLCORE_HOME/memory/consolidation-batches/<批次目录>/（长期留存，供调试）
+ * 把一次整理所需的全部信息序列化成 Markdown，写一处：
+ *   - $EVOLCORE_HOME/memory/consolidation-batches/<批次目录>/context.md
+ *
+ * 任务书只有一个落点。此前另写一份到会话运行目录（sessionRuntimeDir，缺省回落
+ * $EVOLCORE_HOME/tmp），导致落点随触发路径漂移，且该目录的读取范围不由任务书所在
+ * 的整理会话决定——整理会话读自己的任务书会被只读判定拦成 workspace_escape。
+ * 见 docs/memory/session-profile-design.md §5.1。
  *
  * 批次目录命名：<YYYYMMDDTHHmmss>-<selfAid>-<mode>/
  * 批次目录内：context.md（任务书）、ops.jsonl（操作流水）、threads/（话题快照）
@@ -15,6 +19,8 @@ import { resolveRoot, resolvePaths } from '../../paths.js';
 import { DEFAULT_FORGET_AFTER_DAYS, collectCandidates, isDueForReview } from './staleness.js';
 import { chatDirPath } from '../session/session-fs-store.js';
 import { getMemoryArray, getMemoryString, parseMemoryDocument } from './memory-document.js';
+import { writeBatchMeta } from './batch-meta.js';
+import { feedbackFilePath } from './consolidation-ops-records.js';
 export const CONSOLIDATION_MODES = ['notes', 'generalize', 'promote', 'profile', 'forget'];
 /**
  * 模式 → 允许写入的作用域（不含 forget）。
@@ -220,13 +226,50 @@ function fillCandidates(ctx, mode, forgetAfterDays) {
     else if (mode === 'forget') {
         const now = Date.now();
         const thresholds = { forgetAfterDays };
-        ctx.candidates = collectCandidates(source, thresholds, now)
-            .filter(info => isDueForReview(info, thresholds, now))
-            .map(info => ({
-            relPath: `consolidated/${info.name}`,
-            description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
-            tags: info.tags,
-        }));
+        // forget + scope=agent：扫描所有 relation 的 consolidated 目录，以及 agent 自身的 consolidated
+        if (ctx.scope === 'agent') {
+            ctx.candidates = [];
+            // ctx.consolidatedDir 是 agents/<selfAid>/personal/memory/consolidated，
+            // 往上走三级才是 agents/<selfAid>
+            const agentDir = path.dirname(path.dirname(path.dirname(ctx.consolidatedDir)));
+            const relationsRoot = path.join(agentDir, 'relations');
+            if (fs.existsSync(relationsRoot)) {
+                for (const peerKey of fs.readdirSync(relationsRoot)) {
+                    const consolidatedDir = path.join(relationsRoot, peerKey, 'memory', 'consolidated');
+                    if (fs.existsSync(consolidatedDir)) {
+                        const candidates = collectCandidates(consolidatedDir, thresholds, now)
+                            .filter(info => isDueForReview(info, thresholds, now))
+                            .map(info => ({
+                            relPath: `${peerKey}/consolidated/${info.name}`,
+                            description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
+                            tags: info.tags,
+                        }));
+                        ctx.candidates.push(...candidates);
+                    }
+                }
+            }
+            // agent 自身的 consolidated（原 ⑤b 拉起 forget/agent 的来源）
+            if (fs.existsSync(ctx.consolidatedDir)) {
+                const own = collectCandidates(ctx.consolidatedDir, thresholds, now)
+                    .filter(info => isDueForReview(info, thresholds, now))
+                    .map(info => ({
+                    relPath: `consolidated/${info.name}`,
+                    description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
+                    tags: info.tags,
+                }));
+                ctx.candidates.push(...own);
+            }
+        }
+        else {
+            // relation / owner 级 forget：只扫描当前层级的 consolidated
+            ctx.candidates = collectCandidates(source, thresholds, now)
+                .filter(info => isDueForReview(info, thresholds, now))
+                .map(info => ({
+                relPath: `consolidated/${info.name}`,
+                description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
+                tags: info.tags,
+            }));
+        }
     }
 }
 // ── 渲染 ────────────────────────────────────────────────────────────────────
@@ -256,15 +299,45 @@ function renderScopeSection(ctx, mode, threadFiles) {
         lines.push(`待整理的 note 在 \`${ctx.processingDir}\`（整理开始前已从 pending/ 整体移入，是本次的快照）。`);
     }
     else if (ctx.candidates) {
-        lines.push(`**候选记忆（${ctx.candidates.length} 条）** —— 只列路径与描述，按需读正文：`);
-        lines.push('');
-        if (ctx.candidates.length === 0) {
-            lines.push('（无候选）');
+        // forget + scope=agent：按 relation 分组展示
+        if (mode === 'forget' && ctx.scope === 'agent') {
+            const byRelation = new Map();
+            for (const c of ctx.candidates) {
+                const match = c.relPath.match(/^([^/\\]+)[/\\]consolidated[/\\]/);
+                const relation = match ? match[1] : 'unknown';
+                if (!byRelation.has(relation))
+                    byRelation.set(relation, []);
+                byRelation.get(relation).push(c);
+            }
+            lines.push(`**候选记忆（共 ${ctx.candidates.length} 条，分布在 ${byRelation.size} 个关系）** —— 只列路径与描述，按需读正文：`);
+            lines.push('');
+            if (ctx.candidates.length === 0) {
+                lines.push('（无候选）');
+            }
+            else {
+                for (const [relation, candidates] of byRelation) {
+                    lines.push(`#### relation: ${relation} (${candidates.length} 条)`);
+                    lines.push('');
+                    for (const c of candidates) {
+                        const tags = c.tags.length > 0 ? ` [${c.tags.join(', ')}]` : '';
+                        lines.push(`- \`${c.relPath}\`${tags} — ${c.description}`);
+                    }
+                    lines.push('');
+                }
+            }
         }
         else {
-            for (const c of ctx.candidates) {
-                const tags = c.tags.length > 0 ? ` [${c.tags.join(', ')}]` : '';
-                lines.push(`- \`${c.relPath}\`${tags} — ${c.description}`);
+            // 其他模式：直接列出候选
+            lines.push(`**候选记忆（${ctx.candidates.length} 条）** —— 只列路径与描述，按需读正文：`);
+            lines.push('');
+            if (ctx.candidates.length === 0) {
+                lines.push('（无候选）');
+            }
+            else {
+                for (const c of ctx.candidates) {
+                    const tags = c.tags.length > 0 ? ` [${c.tags.join(', ')}]` : '';
+                    lines.push(`- \`${c.relPath}\`${tags} — ${c.description}`);
+                }
             }
         }
     }
@@ -421,8 +494,6 @@ export function serializeConsolidationContext(input) {
     migrateLegacyConsolidationBatches();
     const scopes = resolveScopeContexts(input);
     const now = new Date();
-    // 会话内文件名用：去掉所有分隔符，无 T，14 字符（YYYYMMDDHHmmss）
-    const ts = now.toISOString().replace(/[-:T]/g, '').slice(0, 14);
     const forgetAfterDays = input.forgetAfterDays ?? DEFAULT_FORGET_AFTER_DAYS;
     for (const ctx of scopes) {
         fillCandidates(ctx, input.mode, forgetAfterDays);
@@ -435,6 +506,9 @@ export function serializeConsolidationContext(input) {
     fs.mkdirSync(batchRoot, { recursive: true });
     const batchDir = fs.mkdtempSync(path.join(batchRoot, `${prettyTs}-${selfAid}-${input.mode}-`));
     fs.mkdirSync(batchDir, { recursive: true });
+    // 反馈文件的父目录先建好：整理会话只被授权写这一个文件，无权建目录，
+    // 而各 runner 的补丁器 / 文件写入工具在父目录不存在时会失败。
+    fs.mkdirSync(path.dirname(feedbackFilePath(batchDir)), { recursive: true });
     // ── 话题快照（notes / compress / session-new 模式，有 peerId 时生成）───────
     let historyJsonlPath;
     let threadFiles;
@@ -487,6 +561,22 @@ export function serializeConsolidationContext(input) {
         '',
         ...scopes.flatMap(ctx => [renderScopeSection(ctx, input.mode, threadFiles), '', '---', '']),
     ];
+    // 列出可读根（工具 path/file_path 参数必须落在这些路径内）
+    lines.push('', '**可读根（工具 path/file_path 参数必须落在这些路径内）**：');
+    lines.push('- 批次目录：`' + batchDir + '`');
+    for (const ctx of scopes) {
+        if (ctx.processingDir)
+            lines.push('- processingDir: `' + ctx.processingDir + '`');
+        if (ctx.consolidatedDir)
+            lines.push('- consolidatedDir: `' + ctx.consolidatedDir + '`');
+        if (ctx.indexPath)
+            lines.push('- indexPath: `' + ctx.indexPath + '`');
+    }
+    if (historyJsonlPath)
+        lines.push('- 消息流水: `' + historyJsonlPath + '`');
+    if (threadFiles && threadFiles.length > 0)
+        lines.push('- 话题快照: `' + path.join(batchDir, 'threads') + '`');
+    lines.push('', '---', '');
     if (input.mode === 'notes' && threadFiles && threadFiles.length > 0) {
         const threadsDir = path.join(batchDir, 'threads');
         lines.push('## 话题快照文件', '');
@@ -512,21 +602,35 @@ export function serializeConsolidationContext(input) {
         lines.push('', '---', '');
     }
     lines.push('请按照本次会话注入的模式手册完成整理。');
+    lines.push('');
+    lines.push('整理结束后，用文件写入工具（Write / Edit）把本次整理的整体反馈写入以下**反馈文件路径**：');
+    lines.push('');
+    lines.push(`\`${feedbackFilePath(batchDir)}\``);
+    lines.push('');
+    lines.push('这是本次会话唯一可以写的文件（文件已建好，直接写即可）；写别的路径会被拒绝。');
+    lines.push('未写入则收尾时回退到默认统计模板（模式、触发方式、耗时、新建/更新/归档条数等）。');
     const text = lines.join('\n');
-    // ── 写会话运行目录（任务书，会话内读取用）────────────────────────────────
-    const tmpDir = input.sessionRuntimeDir && path.isAbsolute(input.sessionRuntimeDir)
-        ? input.sessionRuntimeDir
-        : path.join(resolveRoot(), 'tmp');
-    fs.mkdirSync(tmpDir, { recursive: true });
-    const filePath = path.join(tmpDir, `memory-consolidation-${ts}.md`);
-    fs.writeFileSync(filePath, text, 'utf-8');
-    // ── 写批次目录（长期留存）────────────────────────────────────────────────
+    // ── 写批次目录（任务书唯一落点）────────────────────────────────────────────
+    // 不再写会话运行目录：任务书落在 $EVOLCORE_HOME/tmp 或 %TEMP%/ec-session-<hash>/
+    // 会同时踩两个坑——落点随触发路径而变，且会话运行时目录的读取范围不由任务书
+    // 所在的会话决定（见 docs/memory/session-profile-design.md §5.1）。
     const contextFilePath = path.join(batchDir, 'context.md');
     try {
         fs.writeFileSync(contextFilePath, text, 'utf-8');
     }
     catch { /* 批次任务书写入失败不影响整理 */ }
-    return { filePath, batchDir, contextFilePath, scopes, historyJsonlPath, threadFiles, chatDir,
+    // 写入初始 batch.md 元数据
+    writeBatchMeta(batchDir, {
+        selfAid: input.taskCtx.selfAid ?? 'unknown',
+        ...(input.taskCtx.peerKey ? { peerKey: input.taskCtx.peerKey } : {}),
+        ...(input.ownerAid ? { ownerAid: input.ownerAid } : {}),
+        ...(input.taskCtx.baseagent ? { baseagent: input.taskCtx.baseagent } : {}),
+        mode: input.mode,
+        triggeredBy: input.triggeredBy,
+        startedAt: now.toISOString(),
+        status: 'running',
+    });
+    return { filePath: contextFilePath, batchDir, contextFilePath, scopes, historyJsonlPath, threadFiles, chatDir,
         ...(threadFiles?.length ? { snapshotThroughTs: now.getTime() } : {}) };
 }
 /** 会话结束后回填本次产出，追加到任务书末尾。 */

package/dist/core/memory/consolidation-ops-records.js

@@ -38,7 +38,7 @@ export function summarizeOpsRecords(batchDir) {
     try {
         for (const line of fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean)) {
             const entry = JSON.parse(line);
-            if (entry.op === 'summary' || entry.op === 'session-start' || entry.op === 'session-end' || entry.op === 'feedback-set')
+            if (entry.op === 'summary' || entry.op === 'session-start' || entry.op === 'session-end')
                 continue;
             if (!entry.ok) {
                 summary.errors++;
@@ -56,25 +56,23 @@ export function summarizeOpsRecords(batchDir) {
     return summary;
 }
 /**
- * 读整理会话写入的反馈文本（`ec memory feedback`）。
- * 取最后一条 feedback-set；没有则返回 undefined（收尾回退默认模板）。
+ * 整理会话的反馈文件路径。任务书给出的路径、系统会话模块声明的唯一可写文件、
+ * 收尾读取与清理都以此为准，不要在别处重新拼接。
+ */
+export function feedbackFilePath(batchDir) {
+    return path.join(batchDir, 'scratch', 'feedback.txt');
+}
+/**
+ * 读整理会话写入的反馈文本：<batchDir>/scratch/feedback.txt。
+ * 文件不存在或内容为空时返回 undefined，收尾回退默认统计模板。
  */
 export function readFeedbackText(batchDir) {
-    const filePath = path.join(batchDir, 'ops.jsonl');
-    if (!fs.existsSync(filePath))
-        return undefined;
     try {
-        const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const entry = JSON.parse(lines[i]);
-            if (entry.op === 'feedback-set') {
-                const text = entry.text;
-                if (typeof text === 'string' && text.trim())
-                    return text;
-            }
-        }
+        const text = fs.readFileSync(feedbackFilePath(batchDir), 'utf-8').trim();
+        if (text)
+            return text;
     }
-    catch { /* ignore */ }
+    catch { /* 未写反馈属正常情况 */ }
     return undefined;
 }
 /**

package/dist/core/memory/consolidation-trigger.js

@@ -379,19 +379,27 @@ export function checkConsolidationCandidates(params) {
             out.push({ mode: 'profile', peerKey, reason: '索引有变化且画像超期' });
         }
     }
-    // ⑤ 超期记忆 → forget（关系级）
+    // ⑤ 超期记忆 → forget（agent 级，扫描所有 relation + agent 自身，合并成一个会话）
+    let hasRelationForget = false;
     for (const peerKey of peerKeys) {
         const dir = path.join(relationMemoryDir(root, selfAid, peerKey), 'consolidated');
         const due = checkStale(dir, now, config.forgetAfterDays);
-        if (due > 0) {
-            out.push({ mode: 'forget', peerKey, scope: 'relation', reason: `${due} 条记忆超过审查周期（未续期）` });
-        }
+        if (due > 0)
+            hasRelationForget = true;
     }
-    // ⑤b 超期记忆 → forget（agent 级 / owner 级）
+    // ⑤b agent 自身的 consolidated 超期
     const agentConsolidated = path.join(root, 'agents', selfAid, 'personal', 'memory', 'consolidated');
-    if (config.enableAgent && checkStale(agentConsolidated, now, config.forgetAfterDays) > 0) {
-        out.push({ mode: 'forget', scope: 'agent', reason: 'agent 级记忆超期' });
+    const hasAgentForget = config.enableAgent && checkStale(agentConsolidated, now, config.forgetAfterDays) > 0;
+    // 只要有任意一层超期，起一个 forget scope=agent 会话，由会话内统一扫描
+    if (hasRelationForget || hasAgentForget) {
+        const parts = [];
+        if (hasRelationForget)
+            parts.push('关系级记忆超期');
+        if (hasAgentForget)
+            parts.push('agent 级记忆超期');
+        out.push({ mode: 'forget', scope: 'agent', reason: parts.join('、') });
     }
+    // ⑤c owner 级 forget 保持独立（owner 层与 agent/relation 层是平行的）
     if (config.enableOwner && ownerAid) {
         const ownerConsolidated = path.join(root, 'memory', 'owner', ownerAid, 'consolidated');
         if (checkStale(ownerConsolidated, now, config.forgetAfterDays) > 0) {

package/dist/core/memory/consolidation.js

@@ -12,35 +12,36 @@ 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 { resolveAgentLifecycle } from '../../config/lifecycle.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}`);
             }
         }
     }
@@ -48,6 +49,21 @@ function cleanupPreviousConsolidationBatches(selfAid) {
         logger.warn(`[Memory] 清理整理批次时出错: ${e?.message}`);
     }
 }
+/**
+ * 首次设定（lifecycle）没完成的 agent 不能整理记忆：整理会话会被注入首次设定规则而拒绝干活，
+ * note 却照样被认领。返回拒绝原因；可以整理时返回 undefined。
+ * 直接读磁盘上的 config.json：首次设定完成时 lifecycle 就落在这里，不依赖内存里的注册表。
+ */
+export function consolidationBlockedReason(selfAid) {
+    const configPath = path.join(resolveRoot(), 'agents', selfAid, 'config.json');
+    const config = fs.existsSync(configPath)
+        ? JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+        : {};
+    const lifecycle = resolveAgentLifecycle(config);
+    if (lifecycle === 'active')
+        return undefined;
+    return `agent ${selfAid} 首次设定尚未完成（lifecycle=${lifecycle ?? String(config.lifecycle)}），完成后才能整理记忆`;
+}
 /**
  * 序列化上下文并直接创建整理会话。
  * 失败抛错，调用方负责决定是否记录诊断或回传错误。
@@ -60,6 +76,13 @@ 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');
+    const blockedReason = consolidationBlockedReason(selfAid);
+    if (blockedReason)
+        throw new Error(blockedReason);
     // 清理旧的整理批次（保留最新的一个历史）
     cleanupPreviousConsolidationBatches(selfAid);
     // notes 模式：pending/ → processing/ 快照迁移（在序列化上下文之前执行，声明认领）
@@ -96,7 +119,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 +169,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 +178,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 } : {}),
@@ -207,6 +232,20 @@ function moveIntoDir(srcPath, destDir, stamp) {
     }
     fs.renameSync(srcPath, dest);
 }
+/** 本次整理认领到 processing/ 的 note 条数（收尾归位之前调用）。 */
+function countClaimedNotes(memoryDir) {
+    if (!memoryDir)
+        return 0;
+    const processingDir = path.join(memoryDir, 'processing');
+    try {
+        return fs.readdirSync(processingDir)
+            .filter(entry => entry.endsWith('.md') && fs.statSync(path.join(processingDir, entry)).isFile())
+            .length;
+    }
+    catch {
+        return 0;
+    }
+}
 function restorePendingNotes(memoryDir) {
     const processingDir = path.join(memoryDir, 'processing');
     if (!fs.existsSync(processingDir))
@@ -357,6 +396,17 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
             finalizedSessions.add(sessionId);
             releaseAid = session.selfAID;
             const { summarizeOpsRecords, collectAffectedScopes } = await import('./consolidation-ops-records.js');
+            // 会话正常结束不等于整理做完了。notes 模式认领了 note，却既没写记忆也没写反馈，
+            // 说明 agent 没处理这批 note（例如拒绝了任务）——按失败收尾，note 回 pending 下次重试。
+            let failureReason;
+            if (success && meta.memoryMode === 'notes' && countClaimedNotes(meta.consolidationMemoryDir) > 0) {
+                const ops = summarizeOpsRecords(batchDir);
+                if (ops.created + ops.updated + ops.archived === 0 && !readFeedbackText(batchDir)) {
+                    success = false;
+                    failureReason = '整理会话结束时没有写入任何记忆，也没有写反馈，note 未被处理';
+                    logger.warn(`[Memory] ${failureReason}（session=${sessionId}），按失败收尾`);
+                }
+            }
             if (!success) {
                 await rollbackConsolidation(batchDir, session.selfAID);
             }
@@ -380,9 +430,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,18 +513,36 @@ 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 } : {}),
+                    ...(failureReason ? { failureReason } : {}),
+                    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,
                         success,
                         summary: summarizeOpsRecords(batchDir),
                         batchDir,
+                        failureReason,
                     });
                     await sendFeedback(feedbackOrigin, text, session.selfAID);
                 }
@@ -490,6 +557,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 +596,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, }) {
@@ -673,6 +784,10 @@ export function registerConsolidationLaunchExecutor({ ipcServer, enqueueConsolid
     ipcServer.setConsolidationLaunchExecutor(async (params) => {
         if (!params.taskCtx.selfAid)
             throw new Error('无法确定当前 agent AID（selfAid 为空）');
+        // 入队前就拦：拉起失败在队列里只会记成一句笼统的「拉起整理会话失败」
+        const blockedReason = consolidationBlockedReason(params.taskCtx.selfAid);
+        if (blockedReason)
+            throw new Error(blockedReason);
         const launched = await enqueueConsolidation(params);
         if (!launched)
             throw new Error('拉起整理会话失败，详见 daemon 日志');
@@ -687,6 +802,8 @@ export function registerConsolidationCheckExecutor({ ipcServer, agentRegistry, e
         const agentConfig = agentRegistry.get(selfAid)?.config;
         if (agentConfig?.memory?.enableRelation === false)
             return { launched: [] };
+        if (consolidationBlockedReason(selfAid))
+            return { launched: [] };
         const ownerAid = agentConfig?.owners?.[0];
         const agentCount = agentRegistry.runnableAgents().length;
         const relationsDir = path.join(agentDir(selfAid), 'relations');
@@ -743,6 +860,8 @@ export function registerRelationConsolidationEvents({ eventBus, agentRegistry, r
                 return;
             if (taskCtx.sessionType === 'memory')
                 return;
+            if (consolidationBlockedReason(taskCtx.selfAid))
+                return;
             const memoryConfig = agentRegistry.get(taskCtx.selfAid)?.config?.memory;
             if (memoryConfig?.enableRelation === false)
                 return;
@@ -807,6 +926,7 @@ export function renderDefaultConsolidationFeedback(input) {
             '',
             `**模式**：${mode}`,
             `**触发**：${cause}`,
+            ...(input.failureReason ? [`**原因**：${input.failureReason}`] : []),
             '',
             '本次整理未完成，已回退未归档的改动。详情见整理批次：',
             `\`${input.batchDir}\``,