evolcore 0.0.39 → 0.0.40

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

@@ -1,23 +1,20 @@
 /**
- * consolidation-trigger.ts — 整理候选检查（v4，纯函数）
+ * consolidation-trigger.ts — 整理候选判据（v5，纯函数）
  *
- * 职责只有一个：**检查五类候选，返回该拉起哪些整理会话。**
+ * 整理一律以关系为单位。两类判据：
  *
- *   ① pending 堆积超过 backlogHours 的关系 → notes 模式（无会话历史，凭 note 内容整理）
- *   ② 带 to-generalize 的记忆              → generalize 模式
- *   ③ 带 to-promote 的记忆                 → promote 模式
- *   ④ 索引有变化且距上次画像超过 profileRegenDays → profile 模式
- *   ⑤ 有记忆 mtime 超过 forgetAfterDays     → forget 模式
+ * **关系级**（`isRelationModeDue`，供关系整理链逐步调用，见 relation-sweep.ts）：
+ *   notes      pending/ 里有 note
+ *   generalize 本关系有 to-generalize
+ *   promote    本关系是 owner 关系且有 to-promote
+ *   profile    索引有变化且距上次画像超过 profileRegenDays（或还没有画像）
+ *   forget     本关系有超期记忆
  *
- * 判据是**数文件和数标签**，不看轮次和工具调用次数——活干得多不代表写得出记忆，
- * 只干两轮也可能产出五条要整理的内容。
+ * **全局定时检查**（`checkConsolidationCandidates`，cron script 驱动）：只管不属于任何关系的部分——
+ *   agent 层 / owner 层 forget，外加 pending 堆积超过 backlogHours 的兜底。
  *
- * v4 变化：不再自己实现定时器（原 setInterval 类已删除）。定时由 evolcore trigger 的
- * cron `execution.type='script'` 驱动，脚本调 daemon 的 `memory.check-consolidation`，
- * daemon 侧调用本模块的 `checkConsolidationCandidates()`，结果经 enqueueConsolidation 入队。
- *
- * 因此本模块**不持有任何进程内状态**（无 lastTaskEndAt 空闲门控）——所有判据都读磁盘。
- * 并发安全由 daemon 侧的整理队列保证（同 agent 串行）。
+ * 判据是**数文件和数标签**，不看轮次和工具调用次数。本模块不持有进程内状态，判据都读磁盘；
+ * 关系的空闲 / 兜底计时在 relation-idle-monitor.ts。
  */
 import fs from 'fs';
 import path from 'path';
@@ -321,22 +318,70 @@ function checkStale(consolidatedDir, now, forgetAfterDays) {
 export function shouldUseMetaIndex(agentCount, relationCount) {
     return agentCount * relationCount > META_INDEX_THRESHOLD;
 }
+/** 关系整理链的固定顺序。每步在上一步收尾后重新判定，notes 新产出的标签要被后面几步看到。 */
+export const RELATION_SWEEP_ORDER = ['notes', 'generalize', 'promote', 'profile', 'forget'];
+/** pending/ 里有没有待整理的 note。 */
+function hasPendingNotes(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return false;
+    try {
+        return fs.readdirSync(pendingDir).some(f => f.endsWith('.md'));
+    }
+    catch {
+        return false;
+    }
+}
+/** 默认的关系空闲时长与兜底时长（小时）。 */
+export const DEFAULT_RELATION_IDLE_HOURS = 1;
+export const DEFAULT_MAX_UNCONSOLIDATED_HOURS = 8;
 /**
- * 检查五类候选，返回该拉起的整理会话列表。
+ * 单个关系的某个整理模式现在该不该跑。关系整理链逐步调用。
  *
- * 纯检查 + 少量副作用（forget 的长期记忆减速刷新 mtime）。
- * 调用方负责把结果入队（见 index.ts 的 enqueueConsolidation）。
+ * 与全局检查不同：notes 只要有 pending 就跑（关系已空闲 / 兜底到期，不再等堆积），
+ * promote 只在该关系就是 owner 关系时才可能命中。
+ */
+export function isRelationModeDue(params) {
+    const { mode, selfAid, peerKey } = params;
+    const now = params.now ?? Date.now();
+    const root = params.root ?? resolveRoot();
+    const config = effectiveConfig(params.config);
+    const useMetaIndex = params.useMetaIndex ?? false;
+    if (!config.enableRelation)
+        return false;
+    const memDir = relationMemoryDir(root, selfAid, peerKey);
+    switch (mode) {
+        case 'notes':
+            return hasPendingNotes(path.join(memDir, 'pending'));
+        case 'generalize':
+            return config.enableAgent && !!countTagged(root, selfAid, [peerKey], 'to-generalize', useMetaIndex);
+        case 'promote':
+            return config.enableOwner
+                && findOwnerPeerKey([peerKey], params.ownerAid) === peerKey
+                && !!countTagged(root, selfAid, [peerKey], 'to-promote', useMetaIndex);
+        case 'profile':
+            return profileDueWithMeta(memDir, now, config.profileRegenDays, useMetaIndex);
+        case 'forget':
+            return checkStale(path.join(memDir, 'consolidated'), now, config.forgetAfterDays) > 0;
+    }
+}
+/**
+ * 全局定时检查：只管**不属于任何一个关系**的部分，外加 pending 堆积兜底。
+ *
+ *   ① pending 堆积超过 backlogHours 的关系 → notes（由调用方转成该关系的整理链）
+ *   ② agent 层超期记忆（只看 personal/memory 自身）→ forget scope=agent
+ *   ③ owner 层超期记忆 → forget scope=owner
  *
- * 两种扫描路径：
- *   - useMetaIndex=false（默认）：读每个 .md 全文数标签 / 找画像（全量扫描）
- *   - useMetaIndex=true：先读 `_meta.json` 汇总；缺失或不符时该作用域回退全量扫描
+ * generalize / promote / profile / 关系层 forget 由关系整理链负责（relation-sweep.ts），
+ * 这里不再产出：整理一律以关系为单位。
+ *
+ * 纯检查 + 少量副作用（forget 的长期记忆减速刷新 mtime）。
+ * useMetaIndex 参数保留兼容：当前三类判据都不读 `_meta.json`（关系级判据见 isRelationModeDue）。
  */
 export function checkConsolidationCandidates(params) {
     const { selfAid, ownerAid } = params;
     const now = params.now ?? Date.now();
     const root = params.root ?? resolveRoot();
     const config = effectiveConfig(params.config);
-    const useMetaIndex = params.useMetaIndex ?? false;
     const out = [];
     if (!config.enableRelation)
         return out;
@@ -356,50 +401,12 @@ export function checkConsolidationCandidates(params) {
             });
         }
     }
-    // ② 待泛化 → generalize（扫所有关系）
-    if (config.enableAgent) {
-        const hit = countTagged(root, selfAid, peerKeys, 'to-generalize', useMetaIndex);
-        if (hit)
-            out.push({ mode: 'generalize', reason: `发现 ${hit.count} 条 to-generalize` });
-    }
-    // ③ 待提升 → promote（只看 owner 关系）
-    if (config.enableOwner && ownerAid) {
-        const ownerPeerKey = findOwnerPeerKey(peerKeys, ownerAid);
-        if (ownerPeerKey) {
-            const hit = countTagged(root, selfAid, [ownerPeerKey], 'to-promote', useMetaIndex);
-            if (hit) {
-                out.push({ mode: 'promote', peerKey: ownerPeerKey, reason: `发现 ${hit.count} 条 to-promote` });
-            }
-        }
-    }
-    // ④ 画像超期 → profile
-    for (const peerKey of peerKeys) {
-        const memDir = relationMemoryDir(root, selfAid, peerKey);
-        if (profileDueWithMeta(memDir, now, config.profileRegenDays, useMetaIndex)) {
-            out.push({ mode: 'profile', peerKey, reason: '索引有变化且画像超期' });
-        }
-    }
-    // ⑤ 超期记忆 → 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)
-            hasRelationForget = true;
-    }
-    // ⑤b agent 自身的 consolidated 超期
+    // ② agent 层超期 → forget scope=agent（只审 personal/memory 自身；关系层由关系整理链负责）
     const agentConsolidated = path.join(root, 'agents', selfAid, 'personal', 'memory', 'consolidated');
-    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('、') });
+    if (config.enableAgent && checkStale(agentConsolidated, now, config.forgetAfterDays) > 0) {
+        out.push({ mode: 'forget', scope: 'agent', reason: 'agent 级记忆超期' });
     }
-    // ⑤c owner 级 forget 保持独立（owner 层与 agent/relation 层是平行的）
+    // ③ owner 层超期 → forget scope=owner（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,13 +12,14 @@ import fs from 'fs';
 import { getPrimaryOwner, ownerResolver } from '../ownership/owner-resolver.js';
 import path from 'path';
 import { agentDir, resolveRoot } from '../../paths.js';
-import { serializeConsolidationContext } from './consolidation-context.js';
+import { isSilentConsolidationTrigger, 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 { isTopicThreadId } from '../thread/topic-id.js';
 import { logger } from '../../utils/logger.js';
+import { atomicWriteText } from '../../utils/atomic-write.js';
 import { appendOpsRecord, feedbackFilePath, readFeedbackText } from './consolidation-ops-records.js';
 import { updateBatchMeta } from './batch-meta.js';
 import { checkConsolidationCandidates, shouldUseMetaIndex } from './consolidation-trigger.js';
@@ -51,6 +52,54 @@ function cleanupPreviousConsolidationBatches(_selfAid) {
         logger.warn(`[Memory] 清理整理批次时出错: ${e?.message}`);
     }
 }
+const PROCESSING_LEASE_FILENAME = '.processing-lease.json';
+export const PROCESSING_LEASE_TIMEOUT_MS = 2 * 60 * 60_000;
+function processingLeasePath(memoryDir) {
+    return path.join(memoryDir, PROCESSING_LEASE_FILENAME);
+}
+function writeProcessingLease(memoryDir, lease) {
+    atomicWriteText(processingLeasePath(memoryDir), JSON.stringify(lease) + '\n');
+}
+function readProcessingLease(memoryDir) {
+    const filePath = processingLeasePath(memoryDir);
+    let stat;
+    try {
+        stat = fs.lstatSync(filePath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    if (!stat.isFile())
+        throw new Error(`记忆整理 processing 租约不是普通文件: ${filePath}`);
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        throw new Error(`记忆整理 processing 租约损坏: ${filePath}`);
+    }
+    if (!value || typeof value !== 'object'
+        || value.version !== 1
+        || !Number.isSafeInteger(value.claimedAt)
+        || value.claimedAt < 0) {
+        throw new Error(`记忆整理 processing 租约格式无效: ${filePath}`);
+    }
+    return value;
+}
+function removeProcessingLease(memoryDir) {
+    const filePath = processingLeasePath(memoryDir);
+    fs.rmSync(filePath, { force: true });
+    try {
+        for (const entry of fs.readdirSync(memoryDir)) {
+            if (entry.startsWith(`${PROCESSING_LEASE_FILENAME}.tmp.`)) {
+                fs.rmSync(path.join(memoryDir, entry), { force: true });
+            }
+        }
+    }
+    catch { /* The memory directory may already have been removed. */ }
+}
 /**
  * 首次设定（lifecycle）没完成的 agent 不能整理记忆：整理会话会被注入首次设定规则而拒绝干活，
  * note 却照样被认领。返回拒绝原因；可以整理时返回 undefined。
@@ -93,27 +142,39 @@ export async function launchConsolidation(channel, params) {
     // notes 模式：pending/ → processing/ 快照迁移（在序列化上下文之前执行，声明认领）
     let memoryDir;
     let claimedProcessing = false;
+    let processingClaimedAt;
     if (mode === 'notes') {
         memoryDir = effectiveCtx.peerKey
             ? path.join(resolveRoot(), 'agents', selfAid, 'relations', effectiveCtx.peerKey, 'memory')
             : path.join(resolveRoot(), 'agents', selfAid, 'personal', 'memory');
         const pendingDir = path.join(memoryDir, 'pending');
         const processingDir = path.join(memoryDir, 'processing');
+        if (fs.existsSync(processingDir))
+            recoverStaleProcessing(memoryDir, Date.now());
         if (fs.existsSync(processingDir)) {
             throw new Error(`上一批整理尚未收尾，不能重新认领 processing: ${processingDir}`);
         }
-        else if (fs.existsSync(pendingDir)) {
+        if (fs.existsSync(pendingDir)) {
             try {
                 const count = fs.readdirSync(pendingDir).filter(f => f.endsWith('.md')).length;
                 fs.renameSync(pendingDir, processingDir);
                 claimedProcessing = true;
+                processingClaimedAt = Date.now();
                 // 立即重建空 pending 目录，供主会话后续写 note
                 fs.mkdirSync(pendingDir, { recursive: true });
+                writeProcessingLease(memoryDir, { version: 1, claimedAt: processingClaimedAt });
                 logger.info(`[Memory] pending → processing 快照完成（${count} 条 note）: ${processingDir}`);
             }
             catch (e) {
-                // 迁移失败不阻断整理会话启动，整理会话会发现 processing 目录空并输出 NOOP
-                logger.warn(`[Memory] pending → processing 迁移失败: ${e?.message}`);
+                if (claimedProcessing) {
+                    try {
+                        restorePendingNotes(memoryDir);
+                    }
+                    catch (restoreError) {
+                        logger.error(`[Memory] pending → processing 失败后归还 note 失败: ${restoreError instanceof Error ? restoreError.message : String(restoreError)}`);
+                    }
+                }
+                throw new Error(`pending → processing 迁移失败: ${e?.message ?? String(e)}`, { cause: e });
             }
         }
     }
@@ -189,6 +250,7 @@ export async function launchConsolidation(channel, params) {
                 ...(effectiveCtx.peerKey ? { peerKey: effectiveCtx.peerKey } : {}),
                 ...(feedbackOrigin ? { feedbackOrigin } : {}),
                 consolidationTriggeredBy: triggeredBy,
+                ...(params.relationSweepId ? { relationSweepId: params.relationSweepId } : {}),
             },
             // cleanupPolicy 用默认 on_next_launch：清 evolcore session 记录；日志目录由 cleanupPreviousConsolidationLogs() 负责
         });
@@ -255,12 +317,60 @@ function restorePendingNotes(memoryDir) {
     const processingDir = path.join(memoryDir, 'processing');
     if (!fs.existsSync(processingDir))
         return;
+    if (!fs.lstatSync(processingDir).isDirectory())
+        throw new Error(`processing 不是普通目录: ${processingDir}`);
     const pendingDir = path.join(memoryDir, 'pending');
     fs.mkdirSync(pendingDir, { recursive: true });
     const stamp = Date.now().toString(36);
-    for (const entry of fs.readdirSync(processingDir))
+    for (const entry of fs.readdirSync(processingDir)) {
+        if (entry === PROCESSING_LEASE_FILENAME) {
+            fs.rmSync(path.join(processingDir, entry), { force: true });
+            continue;
+        }
         moveIntoDir(path.join(processingDir, entry), pendingDir, stamp);
+    }
     fs.rmdirSync(processingDir);
+    removeProcessingLease(memoryDir);
+}
+function recoverStaleProcessing(memoryDir, now) {
+    const processingDir = path.join(memoryDir, 'processing');
+    const stat = fs.lstatSync(processingDir);
+    if (!stat.isDirectory())
+        throw new Error(`processing 不是普通目录: ${processingDir}`);
+    const lease = readProcessingLease(memoryDir);
+    const claimedAt = lease?.claimedAt ?? stat.mtimeMs;
+    const ageMs = Math.max(0, now - claimedAt);
+    if (ageMs < PROCESSING_LEASE_TIMEOUT_MS)
+        return false;
+    restorePendingNotes(memoryDir);
+    logger.warn(`[Memory] 回收过期 processing 锁并归还 note（ageMs=${ageMs}）: ${processingDir}`);
+    return true;
+}
+export function recoverStaleConsolidationProcessing(selfAid, now = Date.now()) {
+    const root = resolveRoot();
+    const memoryDirs = [path.join(root, 'agents', selfAid, 'personal', 'memory')];
+    const relationsDir = path.join(root, 'agents', selfAid, 'relations');
+    try {
+        for (const entry of fs.readdirSync(relationsDir, { withFileTypes: true })) {
+            if (entry.isDirectory())
+                memoryDirs.push(path.join(relationsDir, entry.name, 'memory'));
+        }
+    }
+    catch { /* The Agent may not have relation data yet. */ }
+    const recovered = [];
+    for (const memoryDir of memoryDirs) {
+        const processingDir = path.join(memoryDir, 'processing');
+        if (!fs.existsSync(processingDir))
+            continue;
+        try {
+            if (recoverStaleProcessing(memoryDir, now))
+                recovered.push(processingDir);
+        }
+        catch (error) {
+            logger.warn(`[Memory] 检查 processing 租约失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return recovered;
 }
 /**
  * 整理会话结束后的收尾，task:completed / task:error / task:interrupted 都走这里。
@@ -283,6 +393,10 @@ export async function onConsolidationComplete(params) {
             fs.mkdirSync(pendingDir, { recursive: true });
             for (const entry of fs.readdirSync(processingDir)) {
                 const src = path.join(processingDir, entry);
+                if (entry === PROCESSING_LEASE_FILENAME) {
+                    fs.rmSync(src, { force: true });
+                    continue;
+                }
                 const isNote = entry.endsWith('.md') && fs.statSync(src).isFile();
                 moveIntoDir(src, isNote ? noteDest : pendingDir, stamp);
                 if (isNote)
@@ -291,6 +405,7 @@ export async function onConsolidationComplete(params) {
             fs.rmdirSync(processingDir);
             result.movedTo = noteDest;
         }
+        removeProcessingLease(params.memoryDir);
     }
     // C3: update mode-specific checkpoint only when thread snapshots were used
     if (params.success && params.chatDir && params.mode && params.usedThreadSnapshots) {
@@ -382,24 +497,52 @@ export async function rollbackConsolidation(batchDir, selfAid) {
     return { rolledBack, errors };
 }
 const MAX_CONCURRENT_CONSOLIDATION = 5;
-export function createConsolidationSessionFinalizer({ sessionManager, getAgent, agentMap, releaseSlot, enqueueConsolidation, sendFeedback, }) {
+/** 从 ops 记录涉及的 memory 目录里挑出关系目录，返回它们的 peerKey（排除 exclude）。 */
+function relationPeerKeysOf(scopes, exclude) {
+    const out = new Set();
+    for (const [scope, memoryDir] of scopes) {
+        if (scope !== 'relation')
+            continue;
+        // .../relations/<peerKey>/memory
+        const peerKey = path.basename(path.dirname(memoryDir));
+        if (peerKey && peerKey !== exclude)
+            out.add(peerKey);
+    }
+    return [...out];
+}
+export function createConsolidationSessionFinalizer({ sessionManager, getAgent, agentMap, releaseSlot, enqueueConsolidation, sendFeedback, onSessionFinalized, }) {
     const finalizedSessions = new Set();
-    return async (sessionId, success) => {
+    return async (sessionId, success, models = {}) => {
         let releaseAid;
+        let finalizedInfo;
         try {
             if (!sessionId)
                 return;
+            if (finalizedSessions.has(sessionId))
+                return;
+            // 读不到会话或批次目录时也要通知一次（只带 sessionId，链按它认领），否则链只能干等看门狗
+            finalizedInfo = { sessionId, success, touchedPeerKeys: [] };
             const session = await sessionManager.getSessionById(sessionId);
             if (!session)
                 return;
             const meta = (session.metadata ?? {});
+            if (typeof meta.relationSweepId === 'string')
+                finalizedInfo.relationSweepId = meta.relationSweepId;
             const batchDir = (meta.consolidationBatchDir ?? meta.consolidationLogBase);
             if (!batchDir)
                 return;
-            if (finalizedSessions.has(sessionId))
-                return;
             finalizedSessions.add(sessionId);
             releaseAid = session.selfAID;
+            // 先占位：后续步骤即使抛错，链也要能推进，不能卡在这一步
+            finalizedInfo = {
+                sessionId,
+                selfAid: session.selfAID,
+                peerKey: typeof meta.peerKey === 'string' ? meta.peerKey : undefined,
+                mode: typeof meta.memoryMode === 'string' ? meta.memoryMode : undefined,
+                success,
+                relationSweepId: typeof meta.relationSweepId === 'string' ? meta.relationSweepId : undefined,
+                touchedPeerKeys: [],
+            };
             const { summarizeOpsRecords, collectAffectedScopes } = await import('./consolidation-ops-records.js');
             // 会话正常结束不等于整理做完了。notes 模式认领了 note，却既没写记忆也没写反馈，
             // 说明 agent 没处理这批 note（例如拒绝了任务）——按失败收尾，note 回 pending 下次重试。
@@ -427,7 +570,10 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
             });
             try {
                 const affectedScopes = collectAffectedScopes(batchDir);
-                if (affectedScopes.size > 0) {
+                // 回滚后仍在流水里的写入不算数：失败的会话不让别的关系去整理
+                if (success)
+                    finalizedInfo.touchedPeerKeys = relationPeerKeysOf(affectedScopes, finalizedInfo.peerKey);
+                if (affectedScopes.length > 0) {
                     const { rebuildIndex } = await import('./index-manager.js');
                     const selfAid = session.selfAID;
                     const memoryConfig = selfAid ? getAgent(selfAid)?.config.memory : undefined;
@@ -443,12 +589,17 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
                 }
             }
             catch { }
+            // feedback 只读一次：先落 batch.md，再清 scratch/，投递复用同一份文本。
+            // 同时挂到 session-end 记录上——scratch/ 收尾即删，batch.md 那段又嵌在
+            // frontmatter 后不好按时间线翻，ops 里留一份才能 grep 到。
+            const customText = readFeedbackText(batchDir);
             appendOpsRecord(batchDir, {
                 ts: new Date().toISOString(),
                 op: 'session-end',
                 success,
                 movedNotes: completeResult.moved,
                 checkpointWritten: completeResult.checkpointWritten,
+                ...(customText ? { feedbackText: customText } : {}),
             });
             if (success) {
                 const memoryMode = meta.memoryMode;
@@ -466,6 +617,9 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
                                 const now = Date.now();
                                 const affectedScopes = collectAffectedScopes(batchDir);
                                 for (const [scope, memoryDir] of affectedScopes) {
+                                    // 关系层的到期审查是关系整理链的最后一步（relation-sweep.ts），这里不重复拉会话
+                                    if (scope === 'relation')
+                                        continue;
                                     const consolidatedDir = path.join(memoryDir, 'consolidated');
                                     let due = 0;
                                     try {
@@ -519,8 +673,6 @@ 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, {
@@ -528,6 +680,8 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
                     finishedAt: new Date().toISOString(),
                     success,
                     ...(session.agentSessionId ? { agentSessionId: session.agentSessionId } : {}),
+                    ...(models.requestedModel ? { requestedModel: models.requestedModel } : {}),
+                    ...(models.actualModel ? { actualModel: models.actualModel } : {}),
                     ...(failureReason ? { failureReason } : {}),
                     feedbackText: customText,
                 });
@@ -540,7 +694,7 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
             catch { /* 静默，不影响投递 */ }
             const feedbackOrigin = meta.feedbackOrigin;
             const triggeredBy = meta.consolidationTriggeredBy;
-            if (feedbackOrigin && triggeredBy && triggeredBy !== 'periodic-trigger' && session.selfAID) {
+            if (feedbackOrigin && triggeredBy && !isSilentConsolidationTrigger(triggeredBy) && session.selfAID) {
                 try {
                     const text = customText ?? renderDefaultConsolidationFeedback({
                         mode: meta.memoryMode,
@@ -550,7 +704,18 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
                         batchDir,
                         failureReason,
                     });
-                    await sendFeedback(feedbackOrigin, text, session.selfAID);
+                    // 反馈是系统发起的一次性发送，不经过 runner 回复路径，context.debug 不会被自动填充。
+                    // 这里显式补上，线上 payload 才能通过 debug.agentSessionId 回溯到本次整理会话。
+                    // model 与 runner 回复路径同义（EvolCore 请求的模型），actualModel 为 runner 实际调用的模型。
+                    await sendFeedback({
+                        ...feedbackOrigin,
+                        debug: {
+                            sessionId: session.id,
+                            ...(session.agentSessionId ? { agentSessionId: session.agentSessionId } : {}),
+                            ...(models.requestedModel ? { model: models.requestedModel } : {}),
+                            ...(models.actualModel ? { actualModel: models.actualModel } : {}),
+                        },
+                    }, text, session.selfAID);
                 }
                 catch (error) {
                     logger.warn(`[Memory] 整理反馈投递失败（session=${sessionId}）: ${error?.message}`);
@@ -563,6 +728,15 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
         finally {
             if (releaseAid && sessionId)
                 releaseSlot(releaseAid, sessionId);
+            // 槽位释放之后再通知：链的下一步入队时，本 agent 的串行队列已经空出来
+            if (finalizedInfo && onSessionFinalized) {
+                try {
+                    onSessionFinalized(finalizedInfo);
+                }
+                catch (error) {
+                    logger.warn(`[Memory] 整理收尾回调失败（session=${sessionId}）: ${error?.message}`);
+                }
+            }
             // runtime 目录清理：immediate 策略下，finalizer 是最后一个要读它的消费者。
             // 用 sessionId 无状态重算路径，不依赖 spec 传递——保证即使 spec 不传 runtimeDir
             // 字段，目录也能在会话结束后被清掉。
@@ -602,6 +776,10 @@ export function createConsolidationFeedbackSender(getChannel) {
             replyContext.threadId = threadId;
         if (chatType)
             replyContext.delivery = { chatType };
+        // 诊断字典（sessionId/agentSessionId），由整理收尾流程写入 origin；缺省时不上线。
+        const debug = origin.debug;
+        if (debug)
+            replyContext.debug = debug;
         // 对比期：同一份反馈 notice、text 各发一条，观察两种模式在对端的差异，
         // 跑通后删掉 text 那条。两条 taskId 后缀不同，避免共用 operationId 被出站去重吞掉一条；
         // 各自 try，一条失败不连累另一条。
@@ -646,6 +824,13 @@ export function createConsolidationFeedbackSender(getChannel) {
             throw new Error(failures.join('; '));
     };
 }
+/** 从 bg-session 终态事件里取出模型字段，原样交给收尾流程。 */
+function modelsFromEvent(event) {
+    return {
+        ...(event.requestedModel ? { requestedModel: event.requestedModel } : {}),
+        ...(event.actualModel ? { actualModel: event.actualModel } : {}),
+    };
+}
 export function registerConsolidationSessionEvents({ eventBus, permissionGateway, finalize, }) {
     eventBus.subscribe('task:interrupted', event => {
         if ('sessionId' in event && event.sessionId) {
@@ -664,15 +849,15 @@ export function registerConsolidationSessionEvents({ eventBus, permissionGateway
     });
     eventBus.subscribe('bg-session:completed', event => {
         if (event.type === 'bg-session:completed')
-            void finalize(event.sessionId, true);
+            void finalize(event.sessionId, true, modelsFromEvent(event));
     });
     eventBus.subscribe('bg-session:error', event => {
         if (event.type === 'bg-session:error')
-            void finalize(event.sessionId, false);
+            void finalize(event.sessionId, false, modelsFromEvent(event));
     });
     eventBus.subscribe('bg-session:interrupted', event => {
         if (event.type === 'bg-session:interrupted')
-            void finalize(event.sessionId, false);
+            void finalize(event.sessionId, false, modelsFromEvent(event));
     });
 }
 export class ConsolidationQueue {
@@ -682,12 +867,20 @@ export class ConsolidationQueue {
     activeSessions = new Map();
     timers = new Map();
     finalizer;
+    launchFailedListener;
     constructor(daemonChannel) {
         this.daemonChannel = daemonChannel;
     }
     setFinalizer(finalizer) {
         this.finalizer = finalizer;
     }
+    /**
+     * 排队的请求轮到时拉起失败的通知。直接 enqueue 立即拉起失败时调用方已拿到 null，
+     * 不再重复通知；只有入队后由 drain 拉起的失败，调用方无从得知，靠这里补上。
+     */
+    setLaunchFailedListener(listener) {
+        this.launchFailedListener = listener;
+    }
     async enqueue(params) {
         const aid = params.taskCtx.selfAid;
         if (!aid)
@@ -729,7 +922,7 @@ export class ConsolidationQueue {
         this.activeAgents.delete(aid);
         void this.drain();
     }
-    async start(params) {
+    async start(params, fromDrain = false) {
         const aid = params.taskCtx.selfAid;
         if (!aid)
             return null;
@@ -763,6 +956,12 @@ export class ConsolidationQueue {
         catch (error) {
             logger.warn(`[Memory] 拉起整理会话失败（aid=${aid}，mode=${params.mode}）: ${error?.message}`);
             this.activeAgents.delete(aid);
+            if (fromDrain && this.launchFailedListener) {
+                try {
+                    this.launchFailedListener(params);
+                }
+                catch { /* 通知失败不影响队列 */ }
+            }
             void this.drain();
             return null;
         }
@@ -782,7 +981,7 @@ export class ConsolidationQueue {
                 break;
             if (this.queues.get(picked.aid)?.length === 0)
                 this.queues.delete(picked.aid);
-            await this.start(picked.params);
+            await this.start(picked.params, true);
         }
     }
 }
@@ -803,7 +1002,7 @@ export function registerConsolidationLaunchExecutor({ ipcServer, enqueueConsolid
         return result;
     });
 }
-export function registerConsolidationCheckExecutor({ ipcServer, agentRegistry, enqueueConsolidation, }) {
+export function registerConsolidationCheckExecutor({ ipcServer, agentRegistry, enqueueConsolidation, requestRelationSweep, }) {
     ipcServer.setConsolidationCheckExecutor(async ({ selfAid }) => {
         const agent = agentRegistry.get(selfAid);
         const agentConfig = agent?.config;
@@ -811,6 +1010,7 @@ export function registerConsolidationCheckExecutor({ ipcServer, agentRegistry, e
             return { launched: [] };
         if (consolidationBlockedReason(selfAid))
             return { launched: [] };
+        recoverStaleConsolidationProcessing(selfAid);
         await ownerResolver.refresh(selfAid);
         const ownerAid = getPrimaryOwner(selfAid);
         const agentCount = agentRegistry.runnableAgents().length;
@@ -833,6 +1033,11 @@ export function registerConsolidationCheckExecutor({ ipcServer, agentRegistry, e
         });
         const launched = [];
         for (const candidate of candidates) {
+            if (candidate.peerKey && requestRelationSweep) {
+                requestRelationSweep(selfAid, candidate.peerKey);
+                launched.push({ mode: `sweep:${candidate.mode}`, peerKey: candidate.peerKey });
+                continue;
+            }
             const taskCtx = {
                 selfAid,
                 peerKey: candidate.peerKey,
@@ -928,6 +1133,7 @@ export function renderDefaultConsolidationFeedback(input) {
         compress: '上下文压缩',
         'session-new': '新会话',
         'periodic-trigger': '定时检查',
+        'relation-idle': '关系空闲整理',
     };
     const mode = input.mode ?? 'notes';
     const cause = triggerLabel[input.triggeredBy] ?? input.triggeredBy;