evolcore 0.0.32 → 0.0.34

package/dist/core/memory/consolidation.js

@@ -12,37 +12,35 @@ import fs from 'fs';
 import path from 'path';
 import { agentDir, resolveRoot } from '../../paths.js';
 import { serializeConsolidationContext } from './consolidation-context.js';
-import { normalizeTriggerDefinition } from '../../trigger/validation.js';
+import { assertSystemSessionLaunchable } from '../system-session/registry.js';
+import { ensureSessionRuntimeDir } from '../../cli/task-context.js';
 import { formatChannelKey } from '../channel-loader.js';
-import { formatPeerKey } from '../relation/peer-identity.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}`);
             }
         }
     }
@@ -50,47 +48,6 @@ function cleanupPreviousConsolidationBatches(selfAid) {
         logger.warn(`[Memory] 清理整理批次时出错: ${e?.message}`);
     }
 }
-export function buildDebugTaskContext(input) {
-    const { session } = input;
-    const meta = (session.metadata ?? {});
-    const sessionType = session.sessionType ?? meta.sessionType ?? 'main';
-    let channel = session.channelType || session.channel;
-    let chatType = session.chatType || 'private';
-    let peerId = meta.peerId;
-    let peerKeyId = chatType === 'group'
-        ? (meta.groupId || session.channelId)
-        : (meta.peerId || session.channelId);
-    let threadId = session.threadId || undefined;
-    if (session.channelId?.startsWith('trigger:') && session.selfAID && input.getTrigger) {
-        const triggerId = session.channelId.slice('trigger:'.length);
-        const origin = input.getTrigger(session.selfAID, triggerId)?.origin;
-        if (origin?.channelType) {
-            channel = origin.channelType;
-            chatType = origin.delivery?.chatType ?? 'private';
-            peerId = origin.peerId;
-            peerKeyId = chatType === 'group' ? origin.channelId : (origin.peerId ?? origin.channelId);
-            threadId = origin.threadId;
-        }
-    }
-    return {
-        sessionId: session.id,
-        baseagent: session.baseagent,
-        channel,
-        channelId: session.channelId,
-        chatType,
-        selfAid: session.selfAID,
-        peerId,
-        peerKey: channel && peerKeyId ? formatPeerKey(channel, peerKeyId) : undefined,
-        peerName: meta.peerName,
-        peerType: meta.peerType,
-        threadId,
-        sessionType,
-        memoryMode: meta.memoryMode,
-        memoryScope: meta.memoryScope,
-        consolidationBatchDir: meta.consolidationBatchDir ?? meta.consolidationLogBase,
-        sessionRuntimeDir: input.sessionRuntimeDir,
-    };
-}
 /**
  * 序列化上下文并直接创建整理会话。
  * 失败抛错，调用方负责决定是否记录诊断或回传错误。
@@ -103,10 +60,15 @@ 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/ 快照迁移（在序列化上下文之前执行，声明认领）
     let memoryDir;
+    let claimedProcessing = false;
     if (mode === 'notes') {
         memoryDir = effectiveCtx.peerKey
             ? path.join(resolveRoot(), 'agents', selfAid, 'relations', effectiveCtx.peerKey, 'memory')
@@ -114,13 +76,13 @@ export async function launchConsolidation(channel, params) {
         const pendingDir = path.join(memoryDir, 'pending');
         const processingDir = path.join(memoryDir, 'processing');
         if (fs.existsSync(processingDir)) {
-            // 上一批还没收尾（会话仍在跑，或 daemon 中途重启丢了收尾），不覆盖、不合并
-            logger.warn(`[Memory] processing/ 已存在，跳过本次迁移（上一批未收尾）: ${processingDir}`);
+            throw new Error(`上一批整理尚未收尾，不能重新认领 processing: ${processingDir}`);
         }
         else if (fs.existsSync(pendingDir)) {
             try {
                 const count = fs.readdirSync(pendingDir).filter(f => f.endsWith('.md')).length;
                 fs.renameSync(pendingDir, processingDir);
+                claimedProcessing = true;
                 // 立即重建空 pending 目录，供主会话后续写 note
                 fs.mkdirSync(pendingDir, { recursive: true });
                 logger.info(`[Memory] pending → processing 快照完成（${count} 条 note）: ${processingDir}`);
@@ -131,20 +93,28 @@ export async function launchConsolidation(channel, params) {
             }
         }
     }
-    const ctxFile = serializeConsolidationContext({
-        mode,
-        triggeredBy,
-        taskCtx: effectiveCtx,
-        ownerAid,
-        sessionRuntimeDir: effectiveCtx.sessionRuntimeDir,
-        ownerInvolved: params.ownerInvolved,
-        forgetAfterDays: params.forgetAfterDays,
-        scopeOverride: params.scopeOverride,
-    });
+    let ctxFile;
+    try {
+        ctxFile = serializeConsolidationContext({
+            mode,
+            triggeredBy,
+            taskCtx: effectiveCtx,
+            ownerAid,
+            ownerInvolved: params.ownerInvolved,
+            forgetAfterDays: params.forgetAfterDays,
+            scopeOverride: params.scopeOverride,
+        });
+    }
+    catch (error) {
+        if (claimedProcessing && memoryDir)
+            restorePendingNotes(memoryDir);
+        throw error;
+    }
     const baseagent = effectiveCtx.baseagent ?? 'claude';
     const now = Date.now();
     const scopeTag = params.scopeOverride ? `-${params.scopeOverride}` : '';
-    const triggerId = `memory-consolidate-${mode}${scopeTag}-${now.toString(36)}`;
+    const kind = `memory-consolidate-${mode}${scopeTag}`;
+    const triggerId = `${kind}-${now.toString(36)}`;
     // 整理会话的渠道信息（origin）：发起时抓取，供反馈时直接投递到原会话渠道。
     // 用 channelId/peerId/threadId 三要素——不依赖 evolcore sessionId，renew/`/new` 换会话也不影响送达。
     const feedbackOrigin = effectiveCtx.channel && effectiveCtx.peerId ? {
@@ -156,109 +126,76 @@ export async function launchConsolidation(channel, params) {
         ...(effectiveCtx.threadId ? { threadId: effectiveCtx.threadId } : {}),
         delivery: { chatType: effectiveCtx.chatType ?? 'private' },
     } : undefined;
-    // 构造 TriggerDefinition 形状的数据载体。
-    // daemonChannel.converse() 从 ctx.trigger 读 execution.memoryMode / id / name / agentAid。
-    // 不再调 manager.create()——本函数直接创建会话，不进 trigger 系统的调度/持久化。
-    const triggerDef = normalizeTriggerDefinition({
-        $schema_version: 3.1,
-        id: triggerId,
-        agentAid: selfAid,
-        enabled: true,
-        name: triggerId,
-        description: `记忆整理（mode=${mode}${effectiveCtx.peerKey ? `，peerKey=${effectiveCtx.peerKey}` : ''}）`,
-        createdAt: now,
-        updatedAt: now,
-        source: { type: 'once' },
-        execution: {
-            type: 'trigger_session',
-            prompt: [
-                '你正在执行记忆整理任务。',
-                `本次整理模式：${mode}`,
-                `整理上下文文件路径：${ctxFile.filePath}`,
-                '',
-                '请先读取上述上下文文件，再按照注入的整理规范完成本次整理。',
-            ].join('\n'),
+    const projectPath = params.projectPath ?? path.join(resolveRoot(), 'agents', selfAid);
+    const prompt = [
+        '你正在执行记忆整理任务。',
+        `本次整理模式：${mode}`,
+        `整理上下文文件路径：${ctxFile.filePath}`,
+        '',
+        '请先读取上述上下文文件，再按照注入的整理规范完成本次整理。',
+    ].join('\n');
+    // 通过 BackgroundSessionLauncher 拉起独立会话。
+    // 不再构造 TriggerDefinition——与 trigger 调度系统完全解耦。
+    // on_next_launch 默认策略由 launchBackgroundSession() 负责清理 evolcore session chat 目录；
+    // cleanupPreviousConsolidationLogs()（上方已调用）负责清理 memory/consolidation-logs/ 日志目录。
+    // 两者清理的是不同的数据，互不重复。
+    // 详见 docs/background-session/background-session-launcher.md
+    let handle;
+    try {
+        handle = await channel.launch({
+            kind,
+            instanceId: now.toString(36),
             baseagent,
-            thread: 'by_run',
-            onError: 'retry',
-            noopSentinel: '[[NOOP]]',
-            memoryMode: mode,
-            ...(params.scopeOverride ? { memoryScope: params.scopeOverride } : {}),
-            // 透传到 session.metadata，供 ipc.ts 写 ops 流水、收尾流程读取
-            consolidationBatchDir: ctxFile.batchDir,
-            ...(ctxFile.chatDir ? { consolidationChatDir: ctxFile.chatDir } : {}),
-            ...(memoryDir ? { consolidationMemoryDir: memoryDir } : {}),
-        },
-        // 不使用 trigger 的 feedback 机制；反馈由收尾流程直接调 adapter.send() 投递
-        feedback: { strategy: 'silent' },
-        ...(feedbackOrigin ? { origin: feedbackOrigin } : {}),
-        reliability: {
-            concurrency: 'forbid',
-            missedPolicy: 'run_once',
-            retry: { maxAttempts: 0, backoffMs: 30_000 },
-        },
-    });
-    // normalizeTriggerDefinition 只保留白名单字段，自定义字段在其后补挂。
-    // 反馈目标（发起时渠道三元组）与触发方式，收尾流程据此投递 / 判断是否反馈。
-    if (feedbackOrigin) {
-        triggerDef.execution.feedbackOrigin = feedbackOrigin;
+            agentAid: selfAid,
+            projectPath,
+            prompt,
+            metadata: {
+                // 系统会话的唯一判据：路径 / 工具 / ec 命令由 system-session/memory.ts 决定，与角色无关
+                systemSession,
+                sessionType: 'memory',
+                memoryMode: mode,
+                ...(params.scopeOverride ? { memoryScope: params.scopeOverride } : {}),
+                // 透传到 session.metadata，供 ipc.ts 写 ops 流水、收尾流程读取
+                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 } : {}),
+                ...(feedbackOrigin ? { feedbackOrigin } : {}),
+                consolidationTriggeredBy: triggeredBy,
+            },
+            // cleanupPolicy 用默认 on_next_launch：清 evolcore session 记录；日志目录由 cleanupPreviousConsolidationLogs() 负责
+        });
     }
-    triggerDef.execution.consolidationTriggeredBy = triggeredBy;
-    // 直接创建整理会话并发送第一条消息——不再经 TriggerRuntimeScheduler。
-    // 用 getOrCreateConversationSession + converse，与旧 trigger_session 执行路径同源（见 daemon.ts）。
-    const projectPath = params.projectPath ?? path.join(resolveRoot(), 'agents', selfAid);
-    const runId = `${triggerId}-run`;
-    const session = await channel.getOrCreateConversationSession(triggerDef, projectPath, baseagent, runId);
-    const prompt = triggerDef.execution.prompt;
-    // 不 await：整理会话在后台跑，收尾由 task:completed/error/interrupted 事件驱动
-    void channel.converse(prompt, {
-        trigger: triggerDef,
-        runId,
-        firedAt: now,
-        projectPath,
-        baseagent,
-        session,
-        causation: undefined,
-    }).catch((e) => {
-        logger.warn(`[Memory] 整理会话执行失败（mode=${mode}，session=${session.id}）: ${e?.message}`);
+    catch (error) {
+        if (claimedProcessing && memoryDir)
+            restorePendingNotes(memoryDir);
+        recordConsolidationOutcome(ctxFile.contextFilePath, `启动失败: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+    // launch() 在会话创建后即返回，sessionId 立即可用；不等会话结束。
+    // 收尾由 bg-session:completed/error/interrupted 事件驱动，这里只记录异常结局。
+    const executionSessionId = handle.sessionId;
+    void handle.result.then(r => {
+        if (r.outcome !== 'completed') {
+            logger.warn(`[Memory] 整理会话未正常结束（mode=${mode}，outcome=${r.outcome}）: ${r.error ?? ''}`);
+        }
     });
     logger.info(`[Memory] 已拉起整理会话（mode=${mode}，triggeredBy=${triggeredBy}，` +
-        `selfAid=${selfAid}${effectiveCtx.peerKey ? `，peerKey=${effectiveCtx.peerKey}` : ''}，` +
-        `session=${session.id}）`);
+        `selfAid=${selfAid}${effectiveCtx.peerKey ? `，peerKey=${effectiveCtx.peerKey}` : ''}` +
+        `${executionSessionId ? `，session=${executionSessionId}` : ''}）`);
     return {
         triggerId,
         contextFile: ctxFile.filePath,
         contextFilePath: ctxFile.contextFilePath,
         logFile: ctxFile.contextFilePath,
         batchDir: ctxFile.batchDir,
-        executionSessionId: session.id,
+        executionSessionId,
+        waitForAgentSessionId: handle.waitForAgentSessionId,
     };
 }
-/**
- * 手动 consolidate 用：在超时内轮询等 runner 分配 agentSessionId。
- * 拿到立即返回；超时返回已拿到的部分，不抛错。
- *
- * 会话创建后 executionSessionId 立刻可用，但 agentSessionId 要等 runner 初始化
- * 并开始第一轮才写入 session 记录，所以这里必须轮询等待。
- */
-export async function waitForConsolidationSession(opts) {
-    const executionSessionId = opts.executionSessionId;
-    if (!executionSessionId)
-        return {};
-    const deadline = Date.now() + (opts.timeoutMs ?? 10_000);
-    const interval = opts.intervalMs ?? 250;
-    while (true) {
-        try {
-            const agentSessionId = await opts.readAgentSessionId(executionSessionId);
-            if (agentSessionId)
-                return { executionSessionId, agentSessionId };
-        }
-        catch { /* 会话记录写到一半，下一轮再读 */ }
-        if (Date.now() >= deadline)
-            return { executionSessionId };
-        await new Promise(r => setTimeout(r, interval));
-    }
-}
 /** 把 entry 移进 destDir；重名时加时间戳后缀，不覆盖已有文件。 */
 function moveIntoDir(srcPath, destDir, stamp) {
     const name = path.basename(srcPath);
@@ -276,6 +213,17 @@ function moveIntoDir(srcPath, destDir, stamp) {
     }
     fs.renameSync(srcPath, dest);
 }
+function restorePendingNotes(memoryDir) {
+    const processingDir = path.join(memoryDir, 'processing');
+    if (!fs.existsSync(processingDir))
+        return;
+    const pendingDir = path.join(memoryDir, 'pending');
+    fs.mkdirSync(pendingDir, { recursive: true });
+    const stamp = Date.now().toString(36);
+    for (const entry of fs.readdirSync(processingDir))
+        moveIntoDir(path.join(processingDir, entry), pendingDir, stamp);
+    fs.rmdirSync(processingDir);
+}
 /**
  * 整理会话结束后的收尾，task:completed / task:error / task:interrupted 都走这里。
  *   - processing/ 里的 note：成功 → archive/notes/，失败 → 归还 pending/（下次重试）
@@ -306,9 +254,10 @@ export async function onConsolidationComplete(params) {
             result.movedTo = noteDest;
         }
     }
-    if (params.success && params.chatDir) {
+    // C3: update mode-specific checkpoint only when thread snapshots were used
+    if (params.success && params.chatDir && params.mode && params.usedThreadSnapshots) {
         const { writeCheckpoint } = await import('./consolidation-context.js');
-        writeCheckpoint(params.chatDir, now);
+        writeCheckpoint(params.chatDir, params.snapshotThroughTs ?? now, params.mode, params.scopeOverride);
         result.checkpointWritten = true;
     }
     const { summarizeOpsRecords, appendOpsRecord } = await import('./consolidation-ops-records.js');
@@ -396,6 +345,7 @@ export async function rollbackConsolidation(batchDir, selfAid) {
 }
 const MAX_CONCURRENT_CONSOLIDATION = 5;
 export function createConsolidationSessionFinalizer({ sessionManager, getAgent, agentMap, releaseSlot, enqueueConsolidation, sendFeedback, }) {
+    const finalizedSessions = new Set();
     return async (sessionId, success) => {
         let releaseAid;
         try {
@@ -408,6 +358,9 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
             const batchDir = (meta.consolidationBatchDir ?? meta.consolidationLogBase);
             if (!batchDir)
                 return;
+            if (finalizedSessions.has(sessionId))
+                return;
+            finalizedSessions.add(sessionId);
             releaseAid = session.selfAID;
             const { summarizeOpsRecords, collectAffectedScopes } = await import('./consolidation-ops-records.js');
             if (!success) {
@@ -418,6 +371,10 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
                 batchDir,
                 chatDir: meta.consolidationChatDir,
                 memoryDir: meta.consolidationMemoryDir,
+                mode: meta.memoryMode,
+                scopeOverride: meta.memoryScope,
+                usedThreadSnapshots: meta.consolidationUsedThreadSnapshots === true,
+                snapshotThroughTs: meta.consolidationSnapshotThroughTs,
             });
             try {
                 const affectedScopes = collectAffectedScopes(batchDir);
@@ -429,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 { }
                     }
@@ -513,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,
@@ -537,8 +509,23 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
             logger.warn(`[Memory] 整理收尾失败（session=${sessionId}）: ${error?.message}`);
         }
         finally {
-            if (releaseAid)
-                releaseSlot(releaseAid);
+            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}`);
+                    }
+                }
+            }
         }
     };
 }
@@ -563,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, }) {
@@ -583,28 +599,43 @@ export function registerConsolidationSessionEvents({ eventBus, permissionGateway
         if ('sessionId' in event && event.sessionId) {
             permissionGateway.cancelAll(event.sessionId, event.reason || 'interrupted');
         }
-        void finalize(event.sessionId, false);
     });
     eventBus.subscribe('task:error', event => {
         if ('sessionId' in event && event.sessionId) {
             permissionGateway.cancelAll(event.sessionId, 'task_error', false);
         }
-        void finalize(event.sessionId, false);
     });
     eventBus.subscribe('task:completed', event => {
         if ('sessionId' in event && event.sessionId) {
             permissionGateway.cancelAll(event.sessionId, 'task_completed', false);
         }
-        void finalize(event.sessionId, true);
+    });
+    eventBus.subscribe('bg-session:completed', event => {
+        if (event.type === 'bg-session:completed')
+            void finalize(event.sessionId, true);
+    });
+    eventBus.subscribe('bg-session:error', event => {
+        if (event.type === 'bg-session:error')
+            void finalize(event.sessionId, false);
+    });
+    eventBus.subscribe('bg-session:interrupted', event => {
+        if (event.type === 'bg-session:interrupted')
+            void finalize(event.sessionId, false);
     });
 }
 export class ConsolidationQueue {
     daemonChannel;
     activeAgents = new Set();
     queues = new Map();
+    activeSessions = new Map();
+    timers = new Map();
+    finalizer;
     constructor(daemonChannel) {
         this.daemonChannel = daemonChannel;
     }
+    setFinalizer(finalizer) {
+        this.finalizer = finalizer;
+    }
     async enqueue(params) {
         const aid = params.taskCtx.selfAid;
         if (!aid)
@@ -619,9 +650,30 @@ export class ConsolidationQueue {
         this.queues.set(aid, queue);
         logger.info(`[Memory] 整理请求入队（aid=${aid}，mode=${params.mode}，` +
             `队列长度=${queue.length}，全局活跃=${this.activeAgents.size}）`);
-        return null;
+        return {
+            triggerId: '',
+            contextFile: '',
+            contextFilePath: '',
+            batchDir: '',
+            queued: {
+                position: queue.length,
+                agentQueueLength: queue.length,
+                agentBusy,
+                activeCount: this.activeAgents.size,
+                maxConcurrent: MAX_CONCURRENT_CONSOLIDATION,
+                totalQueued: [...this.queues.values()].reduce((total, pending) => total + pending.length, 0),
+            },
+        };
     }
-    release(aid) {
+    release(aid, sessionId) {
+        const activeSessionId = this.activeSessions.get(aid);
+        if (sessionId && activeSessionId !== undefined && activeSessionId !== sessionId)
+            return;
+        const timer = this.timers.get(aid);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(aid);
+        this.activeSessions.delete(aid);
         this.activeAgents.delete(aid);
         void this.drain();
     }
@@ -631,7 +683,30 @@ export class ConsolidationQueue {
             return null;
         this.activeAgents.add(aid);
         try {
-            return await launchConsolidation(this.daemonChannel, params);
+            const launched = await launchConsolidation(this.daemonChannel, params);
+            if (launched.executionSessionId) {
+                const sessionId = launched.executionSessionId;
+                this.activeSessions.set(aid, sessionId);
+                const timer = setTimeout(() => {
+                    if (this.activeSessions.get(aid) !== sessionId)
+                        return;
+                    logger.warn(`[Memory] 整理会话超时收尾（aid=${aid}，session=${sessionId}）`);
+                    if (this.finalizer)
+                        void this.finalizer(sessionId, false).finally(() => this.release(aid, sessionId));
+                    else
+                        this.release(aid, sessionId);
+                }, 15 * 60_000);
+                timer.unref?.();
+                this.timers.set(aid, timer);
+            }
+            appendOpsRecord(launched.batchDir, {
+                ts: new Date().toISOString(),
+                op: 'session-start',
+                sessionId: launched.executionSessionId ?? launched.triggerId,
+                mode: params.mode,
+                triggeredBy: params.triggeredBy,
+            });
+            return launched;
         }
         catch (error) {
             logger.warn(`[Memory] 拉起整理会话失败（aid=${aid}，mode=${params.mode}）: ${error?.message}`);
@@ -659,33 +734,17 @@ export class ConsolidationQueue {
         }
     }
 }
-export function registerConsolidationLaunchExecutor({ ipcServer, sessionManager, enqueueConsolidation, }) {
+export function registerConsolidationLaunchExecutor({ ipcServer, enqueueConsolidation, }) {
     ipcServer.setConsolidationLaunchExecutor(async (params) => {
         if (!params.taskCtx.selfAid)
             throw new Error('无法确定当前 agent AID（selfAid 为空）');
         const launched = await enqueueConsolidation(params);
-        if (!launched) {
-            return {
-                triggerId: '',
-                contextFile: '',
-                contextFilePath: '',
-                logFile: '',
-                batchDir: '',
-                queued: true,
-            };
-        }
-        appendOpsRecord(launched.batchDir, {
-            ts: new Date().toISOString(),
-            op: 'session-start',
-            sessionId: launched.triggerId,
-            mode: params.mode,
-            triggeredBy: params.triggeredBy,
-        });
-        const ids = await waitForConsolidationSession({
-            executionSessionId: launched.executionSessionId,
-            readAgentSessionId: async (id) => (await sessionManager.getSessionById(id))?.agentSessionId,
-        });
-        return { ...launched, ...ids };
+        if (!launched)
+            throw new Error('拉起整理会话失败，详见 daemon 日志');
+        if (launched.queued)
+            return launched;
+        const { waitForAgentSessionId, ...result } = launched;
+        return result;
     });
 }
 export function registerConsolidationCheckExecutor({ ipcServer, agentRegistry, enqueueConsolidation, }) {