evolcore 0.0.29 → 0.0.30

package/dist/core/memory/consolidation.js

@@ -0,0 +1,838 @@
+/**
+ * consolidation.ts — 记忆整理生命周期
+ *
+ * 两个入口共用这一处实现：
+ *   - ipc.ts：手动 `ec memory consolidate --mode X`
+ *   - index.ts：定时检查（五类候选）、compress / session-new 自动触发
+ *
+ * 流程：请求入队 → 序列化上下文 → 创建整理会话 → 完成或回滚 → 反馈投递。
+ * `execution.memoryMode` 会经 session.metadata 透传到渲染层与 ipc 的权限校验。
+ */
+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 { 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 { checkConsolidationCandidates, shouldUseMetaIndex } from './consolidation-trigger.js';
+/**
+ * 清理当前 agent 的旧整理批次。
+ * 启动新整理时调用，保留最新的一个会话历史用于查看和调试。
+ */
+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))
+            .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++) {
+            const dir = entries[i];
+            try {
+                fs.rmSync(dir.path, { recursive: true, force: true });
+                logger.debug(`[Memory] 清理前一次整理批次: ${dir.name}`);
+            }
+            catch (e) {
+                logger.warn(`[Memory] 清理前一次整理批次失败 ${dir.name}: ${e?.message}`);
+            }
+        }
+    }
+    catch (e) {
+        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,
+    };
+}
+/**
+ * 序列化上下文并直接创建整理会话。
+ * 失败抛错，调用方负责决定是否记录诊断或回传错误。
+ */
+export async function launchConsolidation(channel, params) {
+    const { taskCtx, mode, triggeredBy, ownerAid } = params;
+    const effectiveCtx = params.peerKeyOverride
+        ? { ...taskCtx, peerKey: params.peerKeyOverride }
+        : taskCtx;
+    const selfAid = effectiveCtx.selfAid;
+    if (!selfAid)
+        throw new Error('无法确定当前 agent AID（selfAid 为空）');
+    // 清理旧的整理批次（保留最新的一个历史）
+    cleanupPreviousConsolidationBatches(selfAid);
+    // notes 模式：pending/ → processing/ 快照迁移（在序列化上下文之前执行，声明认领）
+    let memoryDir;
+    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)) {
+            // 上一批还没收尾（会话仍在跑，或 daemon 中途重启丢了收尾），不覆盖、不合并
+            logger.warn(`[Memory] processing/ 已存在，跳过本次迁移（上一批未收尾）: ${processingDir}`);
+        }
+        else if (fs.existsSync(pendingDir)) {
+            try {
+                const count = fs.readdirSync(pendingDir).filter(f => f.endsWith('.md')).length;
+                fs.renameSync(pendingDir, processingDir);
+                // 立即重建空 pending 目录，供主会话后续写 note
+                fs.mkdirSync(pendingDir, { recursive: true });
+                logger.info(`[Memory] pending → processing 快照完成（${count} 条 note）: ${processingDir}`);
+            }
+            catch (e) {
+                // 迁移失败不阻断整理会话启动，整理会话会发现 processing 目录空并输出 NOOP
+                logger.warn(`[Memory] pending → processing 迁移失败: ${e?.message}`);
+            }
+        }
+    }
+    const ctxFile = serializeConsolidationContext({
+        mode,
+        triggeredBy,
+        taskCtx: effectiveCtx,
+        ownerAid,
+        sessionRuntimeDir: effectiveCtx.sessionRuntimeDir,
+        ownerInvolved: params.ownerInvolved,
+        forgetAfterDays: params.forgetAfterDays,
+        scopeOverride: params.scopeOverride,
+    });
+    const baseagent = effectiveCtx.baseagent ?? 'claude';
+    const now = Date.now();
+    const scopeTag = params.scopeOverride ? `-${params.scopeOverride}` : '';
+    const triggerId = `memory-consolidate-${mode}${scopeTag}-${now.toString(36)}`;
+    // 整理会话的渠道信息（origin）：发起时抓取，供反馈时直接投递到原会话渠道。
+    // 用 channelId/peerId/threadId 三要素——不依赖 evolcore sessionId，renew/`/new` 换会话也不影响送达。
+    const feedbackOrigin = effectiveCtx.channel && effectiveCtx.peerId ? {
+        channelKey: formatChannelKey({ type: effectiveCtx.channel, selfAID: selfAid, name: 'main' }),
+        channelId: effectiveCtx.peerId,
+        channelType: effectiveCtx.channel,
+        peerId: effectiveCtx.peerId,
+        session: effectiveCtx.threadId ? 'thread' : 'main',
+        ...(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'),
+            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;
+    }
+    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}`);
+    });
+    logger.info(`[Memory] 已拉起整理会话（mode=${mode}，triggeredBy=${triggeredBy}，` +
+        `selfAid=${selfAid}${effectiveCtx.peerKey ? `，peerKey=${effectiveCtx.peerKey}` : ''}，` +
+        `session=${session.id}）`);
+    return {
+        triggerId,
+        contextFile: ctxFile.filePath,
+        contextFilePath: ctxFile.contextFilePath,
+        logFile: ctxFile.contextFilePath,
+        batchDir: ctxFile.batchDir,
+        executionSessionId: session.id,
+    };
+}
+/**
+ * 手动 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);
+    let dest = path.join(destDir, name);
+    if (fs.existsSync(dest)) {
+        if (fs.statSync(srcPath).isDirectory() && fs.statSync(dest).isDirectory()) {
+            // 目录（如 pending/archive/）逐个合并子项
+            for (const child of fs.readdirSync(srcPath))
+                moveIntoDir(path.join(srcPath, child), dest, stamp);
+            fs.rmdirSync(srcPath);
+            return;
+        }
+        const ext = path.extname(name);
+        dest = path.join(destDir, `${path.basename(name, ext)}-${stamp}${ext}`);
+    }
+    fs.renameSync(srcPath, dest);
+}
+/**
+ * 整理会话结束后的收尾，task:completed / task:error / task:interrupted 都走这里。
+ *   - processing/ 里的 note：成功 → archive/notes/，失败 → 归还 pending/（下次重试）
+ *   - processing/ 里的其他条目（如 pending/archive/）原样还回 pending/
+ *   - 成功才写 checkpoint，失败时下次整理仍取同一段增量消息
+ *   - ops 汇总无论成败都写
+ * 幂等：processing/ 不存在时只写汇总。
+ */
+export async function onConsolidationComplete(params) {
+    const now = params.now ?? Date.now();
+    const stamp = new Date(now).toISOString().replace(/[-:]/g, '').slice(0, 15);
+    const result = { moved: 0, checkpointWritten: false };
+    if (params.memoryDir) {
+        const processingDir = path.join(params.memoryDir, 'processing');
+        if (fs.existsSync(processingDir)) {
+            const pendingDir = path.join(params.memoryDir, 'pending');
+            const noteDest = params.success ? path.join(params.memoryDir, 'archive', 'notes') : pendingDir;
+            fs.mkdirSync(noteDest, { recursive: true });
+            fs.mkdirSync(pendingDir, { recursive: true });
+            for (const entry of fs.readdirSync(processingDir)) {
+                const src = path.join(processingDir, entry);
+                const isNote = entry.endsWith('.md') && fs.statSync(src).isFile();
+                moveIntoDir(src, isNote ? noteDest : pendingDir, stamp);
+                if (isNote)
+                    result.moved++;
+            }
+            fs.rmdirSync(processingDir);
+            result.movedTo = noteDest;
+        }
+    }
+    if (params.success && params.chatDir) {
+        const { writeCheckpoint } = await import('./consolidation-context.js');
+        writeCheckpoint(params.chatDir, now);
+        result.checkpointWritten = true;
+    }
+    const { summarizeOpsRecords, appendOpsRecord } = await import('./consolidation-ops-records.js');
+    appendOpsRecord(params.batchDir, summarizeOpsRecords(params.batchDir));
+    logger.info(`[Memory] 整理收尾（${params.success ? '成功' : '失败'}）：归位 ${result.moved} 条 note` +
+        `${result.movedTo ? ` → ${result.movedTo}` : ''}，checkpoint=${result.checkpointWritten}`);
+    return result;
+}
+/** 会话结束后把产出回填到批次任务书。 */
+export function recordConsolidationOutcome(contextFilePath, outcome) {
+    try {
+        fs.appendFileSync(contextFilePath, `\n---\n\n## 本次产出\n\n${outcome}\n`, 'utf-8');
+    }
+    catch { /* ignore */ }
+}
+/**
+ * 整理会话失败/中断时，依据 ops.jsonl 逐条回撤成功的写操作。
+ * 回撤顺序：倒序（最后写的先撤）。
+ *
+ *   create → 删除写入的文件，若有 archivedFiles 将其还原回 consolidated/
+ *   update → 用 prevTags 重写文件（恢复修改前的标签，不改 updatedAt 以外的内容）
+ *   archive → 将文件从 archivedTo 移回 sourceFile
+ */
+export async function rollbackConsolidation(batchDir, selfAid) {
+    const { readRollbackRecords, appendOpsRecord } = await import('./consolidation-ops-records.js');
+    const entries = readRollbackRecords(batchDir);
+    let rolledBack = 0;
+    const errors = [];
+    for (const entry of entries) {
+        try {
+            if (entry.op === 'create') {
+                // 删除写入的文件
+                if (entry.filePath && fs.existsSync(entry.filePath)) {
+                    fs.unlinkSync(entry.filePath);
+                }
+                // 还原被归档的旧文件
+                for (const af of (entry.archivedFiles ?? [])) {
+                    if (af.archivedTo && fs.existsSync(af.archivedTo)) {
+                        const dest = af.source.includes('/') || af.source.includes('\\')
+                            ? af.source
+                            : path.join(path.dirname(af.archivedTo), path.basename(af.archivedTo));
+                        fs.mkdirSync(path.dirname(dest), { recursive: true });
+                        fs.renameSync(af.archivedTo, dest);
+                    }
+                }
+                rolledBack++;
+            }
+            else if (entry.op === 'update') {
+                // 恢复修改前的 tags：读文件、替换 tags 行、重写（不重签名，仅文本恢复）
+                const target = entry.target;
+                if (target && fs.existsSync(target)) {
+                    const raw = fs.readFileSync(target, 'utf-8');
+                    const prevTags = entry.prevTags ?? [];
+                    const tagsLine = prevTags.length > 0 ? `tags: [${prevTags.join(', ')}]` : '';
+                    // 替换 tags: [...] 行；若 prevTags 为空则移除该行
+                    const updated = raw.replace(/^tags: \[.*\]$/m, tagsLine).replace(/^\n$/, '');
+                    fs.writeFileSync(target, updated, 'utf-8');
+                    rolledBack++;
+                }
+            }
+            else if (entry.op === 'archive') {
+                // 将文件从 archivedTo 移回 sourceFile
+                if (entry.archivedTo && entry.sourceFile && fs.existsSync(entry.archivedTo)) {
+                    fs.mkdirSync(path.dirname(entry.sourceFile), { recursive: true });
+                    fs.renameSync(entry.archivedTo, entry.sourceFile);
+                    rolledBack++;
+                }
+            }
+        }
+        catch (e) {
+            const msg = `回撤 ${entry.op} "${entry.target}" 失败: ${e?.message}`;
+            errors.push(msg);
+            logger.warn(`[Memory] ${msg}`);
+        }
+    }
+    appendOpsRecord(batchDir, {
+        ts: new Date().toISOString(),
+        op: 'session-end',
+        success: false,
+        movedNotes: 0,
+        checkpointWritten: false,
+    });
+    logger.info(`[Memory] 回撤完成：回撤 ${rolledBack} 条操作，${errors.length} 个失败`);
+    return { rolledBack, errors };
+}
+const MAX_CONCURRENT_CONSOLIDATION = 5;
+export function createConsolidationSessionFinalizer({ sessionManager, getAgent, agentMap, releaseSlot, enqueueConsolidation, sendFeedback, }) {
+    return async (sessionId, success) => {
+        let releaseAid;
+        try {
+            if (!sessionId)
+                return;
+            const session = await sessionManager.getSessionById(sessionId);
+            if (!session)
+                return;
+            const meta = (session.metadata ?? {});
+            const batchDir = (meta.consolidationBatchDir ?? meta.consolidationLogBase);
+            if (!batchDir)
+                return;
+            releaseAid = session.selfAID;
+            const { summarizeOpsRecords, collectAffectedScopes } = await import('./consolidation-ops-records.js');
+            if (!success) {
+                await rollbackConsolidation(batchDir, session.selfAID);
+            }
+            const completeResult = await onConsolidationComplete({
+                success,
+                batchDir,
+                chatDir: meta.consolidationChatDir,
+                memoryDir: meta.consolidationMemoryDir,
+            });
+            try {
+                const affectedScopes = collectAffectedScopes(batchDir);
+                if (affectedScopes.size > 0) {
+                    const { rebuildIndex } = await import('./index-manager.js');
+                    const selfAid = session.selfAID;
+                    const memoryConfig = selfAid ? getAgent(selfAid)?.config.memory : undefined;
+                    const maxBytes = memoryConfig?.indexMaxBytes ?? 5 * 1024;
+                    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);
+                        }
+                        catch { }
+                    }
+                }
+            }
+            catch { }
+            appendOpsRecord(batchDir, {
+                ts: new Date().toISOString(),
+                op: 'session-end',
+                success,
+                movedNotes: completeResult.moved,
+                checkpointWritten: completeResult.checkpointWritten,
+            });
+            if (success) {
+                const memoryMode = meta.memoryMode;
+                if (memoryMode && memoryMode !== 'forget') {
+                    const opsSummary = summarizeOpsRecords(batchDir);
+                    const hasOutput = completeResult.moved > 0 || opsSummary.created > 0 || opsSummary.updated > 0;
+                    if (hasOutput) {
+                        try {
+                            const { collectCandidates, isDueForReview, deferCandidate } = await import('./staleness.js');
+                            const selfAid = session.selfAID;
+                            if (selfAid) {
+                                const memoryConfig = getAgent(selfAid)?.config.memory;
+                                const thresholds = { forgetAfterDays: memoryConfig?.forgetAfterDays ?? 3 };
+                                const now = Date.now();
+                                const affectedScopes = collectAffectedScopes(batchDir);
+                                for (const [scope, memoryDir] of affectedScopes) {
+                                    const consolidatedDir = path.join(memoryDir, 'consolidated');
+                                    let due = 0;
+                                    try {
+                                        for (const candidate of collectCandidates(consolidatedDir, thresholds, now)) {
+                                            if (isDueForReview(candidate, thresholds, now))
+                                                due++;
+                                            else {
+                                                try {
+                                                    deferCandidate(candidate.filePath, now);
+                                                }
+                                                catch { }
+                                            }
+                                        }
+                                    }
+                                    catch {
+                                        continue;
+                                    }
+                                    if (due > 0) {
+                                        const ownerAid = memoryConfig ? getAgent(selfAid)?.config.owners?.[0] : undefined;
+                                        const taskCtx = { selfAid, peerKey: meta.peerKey };
+                                        void enqueueConsolidation({
+                                            taskCtx,
+                                            mode: 'forget',
+                                            triggeredBy: 'periodic-trigger',
+                                            ownerAid,
+                                            forgetAfterDays: memoryConfig?.forgetAfterDays,
+                                            scopeOverride: scope,
+                                        }).catch(() => { });
+                                    }
+                                }
+                            }
+                        }
+                        catch { }
+                    }
+                }
+            }
+            const agentSessionId = session.agentSessionId;
+            const projectPath = session.projectPath;
+            const baseagent = session.baseagent ?? 'claude';
+            if (agentSessionId && projectPath) {
+                const historyPath = path.join(batchDir, 'history.jsonl');
+                const runner = agentMap.get(`${session.selfAID}::${baseagent}`);
+                if (runner?.getSessionMessages) {
+                    try {
+                        const messages = await runner.getSessionMessages(agentSessionId, projectPath);
+                        fs.writeFileSync(historyPath, messages.map((message) => JSON.stringify(message)).join('\n') + '\n', 'utf-8');
+                    }
+                    catch { }
+                }
+                else {
+                    fs.writeFileSync(historyPath, JSON.stringify({ note: `runner ${baseagent} does not support getSessionMessages` }) + '\n', 'utf-8');
+                }
+            }
+            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,
+                    });
+                    await sendFeedback(feedbackOrigin, text, session.selfAID);
+                }
+                catch (error) {
+                    logger.warn(`[Memory] 整理反馈投递失败（session=${sessionId}）: ${error?.message}`);
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`[Memory] 整理收尾失败（session=${sessionId}）: ${error?.message}`);
+        }
+        finally {
+            if (releaseAid)
+                releaseSlot(releaseAid);
+        }
+    };
+}
+export function createConsolidationFeedbackSender(getChannel) {
+    return async (origin, text, selfAid) => {
+        const { buildEnvelope } = await import('../message/message-utils.js');
+        const channelKey = origin.channelKey;
+        const channelId = origin.channelId;
+        if (!channelKey || !channelId) {
+            logger.warn('[Memory] 反馈目标缺少 channelKey/channelId，跳过投递');
+            return;
+        }
+        const binding = getChannel(selfAid, channelKey);
+        if (!binding) {
+            logger.warn(`[Memory] 找不到渠道绑定（aid=${selfAid}，channelKey=${channelKey}），跳过反馈`);
+            return;
+        }
+        const threadId = origin.threadId;
+        const chatType = origin.delivery?.chatType;
+        const replyContext = {};
+        if (threadId)
+            replyContext.threadId = threadId;
+        if (chatType)
+            replyContext.delivery = { chatType };
+        await binding.adapter.send(buildEnvelope({
+            taskId: `memory-feedback-${Date.now()}`,
+            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}）`);
+    };
+}
+export function registerConsolidationSessionEvents({ eventBus, permissionGateway, finalize, }) {
+    eventBus.subscribe('task:interrupted', event => {
+        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);
+    });
+}
+export class ConsolidationQueue {
+    daemonChannel;
+    activeAgents = new Set();
+    queues = new Map();
+    constructor(daemonChannel) {
+        this.daemonChannel = daemonChannel;
+    }
+    async enqueue(params) {
+        const aid = params.taskCtx.selfAid;
+        if (!aid)
+            return null;
+        const agentBusy = this.activeAgents.has(aid);
+        const queue = this.queues.get(aid) ?? [];
+        const globalFull = this.activeAgents.size >= MAX_CONCURRENT_CONSOLIDATION;
+        if (!agentBusy && !globalFull && queue.length === 0) {
+            return await this.start(params);
+        }
+        queue.push(params);
+        this.queues.set(aid, queue);
+        logger.info(`[Memory] 整理请求入队（aid=${aid}，mode=${params.mode}，` +
+            `队列长度=${queue.length}，全局活跃=${this.activeAgents.size}）`);
+        return null;
+    }
+    release(aid) {
+        this.activeAgents.delete(aid);
+        void this.drain();
+    }
+    async start(params) {
+        const aid = params.taskCtx.selfAid;
+        if (!aid)
+            return null;
+        this.activeAgents.add(aid);
+        try {
+            return await launchConsolidation(this.daemonChannel, params);
+        }
+        catch (error) {
+            logger.warn(`[Memory] 拉起整理会话失败（aid=${aid}，mode=${params.mode}）: ${error?.message}`);
+            this.activeAgents.delete(aid);
+            void this.drain();
+            return null;
+        }
+    }
+    async drain() {
+        while (this.activeAgents.size < MAX_CONCURRENT_CONSOLIDATION) {
+            let picked;
+            for (const [aid, queue] of this.queues) {
+                if (queue.length === 0)
+                    continue;
+                if (this.activeAgents.has(aid))
+                    continue;
+                picked = { aid, params: queue.shift() };
+                break;
+            }
+            if (!picked)
+                break;
+            if (this.queues.get(picked.aid)?.length === 0)
+                this.queues.delete(picked.aid);
+            await this.start(picked.params);
+        }
+    }
+}
+export function registerConsolidationLaunchExecutor({ ipcServer, sessionManager, 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 };
+    });
+}
+export function registerConsolidationCheckExecutor({ ipcServer, agentRegistry, enqueueConsolidation, }) {
+    ipcServer.setConsolidationCheckExecutor(async ({ selfAid }) => {
+        const agentConfig = agentRegistry.get(selfAid)?.config;
+        if (agentConfig?.memory?.enableRelation === false)
+            return { launched: [] };
+        const ownerAid = agentConfig?.owners?.[0];
+        const agentCount = agentRegistry.runnableAgents().length;
+        const relationsDir = path.join(agentDir(selfAid), 'relations');
+        let relationCount = 0;
+        try {
+            relationCount = fs.existsSync(relationsDir)
+                ? fs.readdirSync(relationsDir, { withFileTypes: true }).filter(entry => entry.isDirectory()).length
+                : 0;
+        }
+        catch {
+            // The relation directory is optional during initial bootstrap.
+        }
+        const useMetaIndex = shouldUseMetaIndex(agentCount, relationCount);
+        const candidates = checkConsolidationCandidates({
+            selfAid,
+            ownerAid,
+            config: agentConfig?.memory,
+            useMetaIndex,
+        });
+        const launched = [];
+        for (const candidate of candidates) {
+            const taskCtx = {
+                selfAid,
+                peerKey: candidate.peerKey,
+                baseagent: undefined,
+                sessionId: undefined,
+            };
+            try {
+                await enqueueConsolidation({
+                    taskCtx,
+                    mode: candidate.mode,
+                    triggeredBy: 'periodic-trigger',
+                    ownerAid,
+                    forgetAfterDays: agentConfig?.memory?.forgetAfterDays,
+                    ...(candidate.scope ? { scopeOverride: candidate.scope } : {}),
+                });
+                launched.push({ mode: candidate.mode, ...(candidate.peerKey ? { peerKey: candidate.peerKey } : {}) });
+            }
+            catch (error) {
+                logger.warn(`[Memory] 定时检查入队失败（aid=${selfAid}，mode=${candidate.mode}）: ${error?.message}`);
+            }
+        }
+        if (launched.length > 0) {
+            logger.info(`[Memory] 定时检查拉起 ${launched.length} 个整理会话（aid=${selfAid}）: `
+                + launched.map(item => `${item.mode}${item.peerKey ? `(${item.peerKey})` : ''}`).join(', '));
+        }
+        return { launched };
+    });
+}
+export function registerRelationConsolidationEvents({ eventBus, agentRegistry, responseEngine, enqueueConsolidation, }) {
+    const triggerRelationConsolidation = async (taskCtx, triggeredBy) => {
+        try {
+            if (!taskCtx?.selfAid || !taskCtx?.peerKey)
+                return;
+            if (taskCtx.sessionType === 'memory')
+                return;
+            const memoryConfig = agentRegistry.get(taskCtx.selfAid)?.config?.memory;
+            if (memoryConfig?.enableRelation === false)
+                return;
+            const ownerAid = agentRegistry.get(taskCtx.selfAid)?.config?.owners?.[0];
+            await enqueueConsolidation({
+                taskCtx,
+                mode: 'notes',
+                triggeredBy,
+                ownerAid,
+            });
+        }
+        catch (error) {
+            logger.warn(`[MemoryT17] relation 整理触发失败（${triggeredBy}）: ${error?.message}`);
+        }
+    };
+    eventBus.subscribe('runner:compact-start', event => {
+        const compactEvent = event;
+        if (!compactEvent.sessionId)
+            return;
+        void triggerRelationConsolidation(responseEngine.getTaskRuntimeContext(compactEvent.sessionId), 'compress');
+    });
+    eventBus.subscribe('session:created', event => {
+        const sessionEvent = event;
+        if (!sessionEvent.sourceSessionId)
+            return;
+        let snapshot;
+        if (sessionEvent.sourceChannel && sessionEvent.sourceChannelId && sessionEvent.sourceSelfAid) {
+            const peerKeyId = sessionEvent.sourceChatType === 'group'
+                ? sessionEvent.sourceChannelId
+                : (sessionEvent.sourcePeerId ?? sessionEvent.sourceChannelId);
+            const peerKey = peerKeyId
+                ? `${sessionEvent.sourceChannel}#${encodeURIComponent(peerKeyId)}`
+                : undefined;
+            snapshot = {
+                sessionId: sessionEvent.sourceSessionId,
+                selfAid: sessionEvent.sourceSelfAid,
+                peerKey,
+                channel: sessionEvent.sourceChannel,
+                channelId: sessionEvent.sourceChannelId,
+                peerId: sessionEvent.sourcePeerId ?? sessionEvent.sourceChannelId,
+                chatType: sessionEvent.sourceChatType,
+                threadId: sessionEvent.sourceThreadId,
+            };
+        }
+        const taskCtx = snapshot ?? responseEngine.getTaskRuntimeContext(sessionEvent.sourceSessionId);
+        void triggerRelationConsolidation(taskCtx, 'session-new');
+    });
+}
+/** Render the default feedback message for a completed memory consolidation. */
+export function renderDefaultConsolidationFeedback(input) {
+    const triggerLabel = {
+        manual: '手动触发',
+        compress: '上下文压缩',
+        'session-new': '新会话',
+        'periodic-trigger': '定时检查',
+    };
+    const mode = input.mode ?? 'notes';
+    const cause = triggerLabel[input.triggeredBy] ?? input.triggeredBy;
+    if (!input.success) {
+        return [
+            '## 记忆整理失败',
+            '',
+            `**模式**：${mode}`,
+            `**触发**：${cause}`,
+            '',
+            '本次整理未完成，已回退未归档的改动。详情见整理批次：',
+            `\`${input.batchDir}\``,
+        ].join('\n');
+    }
+    const { created, updated, archived, errors } = input.summary;
+    const lines = [
+        '## 记忆整理完成',
+        '',
+        `**模式**：${mode}  `,
+        `**触发**：${cause}`,
+        '',
+        '### 处理结果',
+        `- 新建记忆：${created} 条`,
+        `- 更新记忆：${updated} 条`,
+        `- 归档记忆：${archived} 条`,
+    ];
+    if (errors > 0)
+        lines.push(`- 错误：${errors} 条`);
+    lines.push('', `整理批次：\`${input.batchDir}\``);
+    return lines.join('\n');
+}
+export { resolveRoot };