evolcore 0.0.31 → 0.0.33

package/dist/core/handoff/runtime.js

@@ -33,13 +33,6 @@ export class HandoffDeliveryFailedError extends Error {
         this.name = 'HandoffDeliveryFailedError';
     }
 }
-export class HandoffReturnPolicyRequiredError extends Error {
-    code = 'HANDOFF_RETURN_POLICY_REQUIRED';
-    constructor() {
-        super('跨会话 ec msg/group send 必须显式指定 --return none|required');
-        this.name = 'HandoffReturnPolicyRequiredError';
-    }
-}
 export class TriggerHandoffRequiredForbiddenError extends Error {
     code = 'TRIGGER_HANDOFF_REQUIRED_FORBIDDEN';
     constructor() {
@@ -99,9 +92,10 @@ export class HandoffRuntime {
                 throw new Error('handoff context requires a different target session');
             return { crossSession: false, targetSession: target };
         }
-        if (!input.explicitReturnPolicy)
-            throw new HandoffReturnPolicyRequiredError();
-        if (input.explicitReturnPolicy === 'required' && input.causation?.trigger?.path.length) {
+        // --return 参数已废弃：跨会话 send 不再要求显式指定返回策略，默认 'none'。
+        // 内部调用方（agent-create 等）仍可显式传 'required' 走回流路径。
+        const effectiveReturnPolicy = input.explicitReturnPolicy ?? 'none';
+        if (effectiveReturnPolicy === 'required' && input.causation?.trigger?.path.length) {
             throw new TriggerHandoffRequiredForbiddenError();
         }
         const handoffCausation = deriveCausation(normalizeCausation(input.causation) ?? createRootCausation());
@@ -127,7 +121,7 @@ export class HandoffRuntime {
                 delivery: targetChatType === 'group'
                     ? { chatType: 'group', groupId: input.to }
                     : { chatType: 'private' },
-                returnPolicy: input.explicitReturnPolicy ?? 'required',
+                returnPolicy: effectiveReturnPolicy,
                 originAuthorization: input.originAuthorization,
                 causation: handoffCausation,
                 now: this.now?.(),

package/dist/core/handoff/store.js

@@ -1,3 +1,8 @@
+/**
+ * @deprecated Handoff 机制已被 Thread Context 取代，见
+ * `docs/thread-chain/handoff-deprecation.md`。保留仅为兼容在途 handoff，
+ * 将在清理阶段删除。
+ */
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';

package/dist/core/ipc-registration.js

@@ -1,10 +1,16 @@
 import { TriggerDefinitionManager } from '../trigger/manager.js';
+import { ensureSessionRuntimeDir } from '../cli/task-context.js';
 import { logger } from '../utils/logger.js';
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { executeTaskResume } from './task/task-resume-operation.js';
-import { isHClassPath, isSameOrDescendant } from './permission/protected-paths.js';
+import { isHClassPath, isLClassPath, isSameOrDescendant } from './permission/protected-paths.js';
+import { resolveStorageCommandArgv } from '../aun/storage/index.js';
+import { agentDir } from '../paths.js';
+import { parsePeerKey } from './relation/peer-identity.js';
+import { resolvePeerRoleDetail } from '../config/peer-role-resolver.js';
+import { buildDebugTaskContext } from './auth/debug-context.js';
 import { computeBuildId } from '../utils/evolcore-version.js';
 import { loadAgent } from '../config-store.js';
 import { executeLocalInitializationCommand, hasSuppliedInitialization } from '../cli/agent-create.js';
@@ -16,6 +22,7 @@ import { registerHandoffIpc } from './handoff/ipc-registration.js';
 import { registerAunIpcSender } from './message/aun-ipc-sender.js';
 import { registerConsolidationCheckExecutor, registerConsolidationLaunchExecutor, } from './memory/consolidation.js';
 import { createTriggerBaseagentResolver, registerTriggerIpcExecutor } from '../trigger/ipc-service.js';
+import { createThreadOperationExecutor } from './thread/ipc-operation.js';
 import { isLinkedInstall } from '../utils/npm-ops.js';
 export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationRegistry, sessionManager, statsCollector, aidStatsCollector, responseEngine, messageQueue, agentMap, commandHandler, channelInstances, eventBus, handoffRuntime, reloadCoordinator, agentApplicationService, agentInitializationService, enqueueConsolidation, completeAgentBootstrap, contactBinds, bindService, diagService, getProcessOwners, getControlAidState, daemonAid, triggerControlToken, triggerSchedulers, daemonTriggerOwner, primaryAgent, triggerAuthorization, }) {
     const authorizeManagedAgentOperation = createDelegationAuthorizer({
@@ -51,6 +58,137 @@ export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationReg
         agentMap,
         isLinkedInstall: isLinkedInstall(),
     });
+    if (process.env.EVOLCORE_DEBUG_MODE === '1') {
+        ipcServer.setDebugIssueTokenExecutor(async ({ sessionId }) => {
+            try {
+                const activeContext = responseEngine.getTaskRuntimeContext(sessionId);
+                let runtimeContext = activeContext;
+                if (!runtimeContext) {
+                    const session = await sessionManager.getSessionById(sessionId);
+                    if (!session)
+                        return { ok: false, error: `session not found: ${sessionId}` };
+                    runtimeContext = buildDebugTaskContext({
+                        session,
+                        getTrigger: (agentAid, triggerId) => new TriggerDefinitionManager(agentAid).get(triggerId),
+                        sessionRuntimeDir: ensureSessionRuntimeDir(session.id),
+                    });
+                }
+                if (!runtimeContext.selfAid)
+                    return { ok: false, error: 'debug session has no selfAid' };
+                const channelType = runtimeContext.channel || 'aun';
+                const channel = runtimeContext.channelKey || channelType;
+                const peerKeyId = (() => {
+                    try {
+                        return parsePeerKey(runtimeContext.peerKey || '').channelId;
+                    }
+                    catch {
+                        return runtimeContext.peerId || runtimeContext.channelId || '';
+                    }
+                })();
+                const chatType = runtimeContext.chatType === 'group' ? 'group' : 'private';
+                const conversationId = chatType === 'group'
+                    ? (runtimeContext.channelId || peerKeyId)
+                    : peerKeyId;
+                const peerRole = resolvePeerRoleDetail({
+                    selfAid: runtimeContext.selfAid,
+                    channelKey: channel,
+                    channelType,
+                    chatType,
+                    actorId: peerKeyId,
+                    conversationId,
+                });
+                const token = agentDelegationRegistry.issueDebug({
+                    sessionId,
+                    selfAid: runtimeContext.selfAid,
+                    channel,
+                    channelType,
+                    chatType,
+                    peerKey: runtimeContext.peerKey || '',
+                    actorId: peerKeyId || runtimeContext.selfAid,
+                    issuedRole: peerRole.effectiveRole || 'none',
+                });
+                return { ok: true, token, runtimeContext };
+            }
+            catch (error) {
+                return { ok: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        });
+    }
+    ipcServer.setThreadOperationExecutor(createThreadOperationExecutor({
+        sessionManager,
+        agentDelegationRegistry,
+        getProcessOwners,
+        sendSystemMsg: async (params) => {
+            if (ipcServer.hasAunMsgSender()) {
+                const sent = await ipcServer.sendAunMsg({
+                    aid: params.from,
+                    to: params.to,
+                    scope: params.peerKind === 'group' ? 'group' : 'msg',
+                    payload: { type: 'topic-created', topicName: params.topicName, threadId: params.threadId },
+                    thread: params.threadId,
+                });
+                if (!sent?.ok)
+                    throw new Error(sent?.error || 'Topic notification failed');
+            }
+        },
+        onDeleted: (aid, threadId) => {
+            const scheduler = triggerSchedulers.get(aid);
+            if (scheduler) {
+                const related = scheduler.list({ all: true }).filter((trigger) => trigger.origin?.threadId === threadId
+                    || trigger.labels?.originThreadId === threadId
+                    || trigger.labels?.targetThreadId === threadId);
+                for (const trigger of related) {
+                    try {
+                        scheduler.delete(trigger.id);
+                    }
+                    catch { }
+                }
+            }
+        },
+    }));
+    ipcServer.setSkillRefreshExecutor(async (aid, sessionId, delegationToken, delegationCommandHash) => {
+        const fail = (code, error) => ({ ok: false, code, error });
+        if (!agentRegistry.get(aid))
+            return fail('AGENT_NOT_FOUND', `Agent "${aid}" not found`);
+        if (sessionId) {
+            const authorization = await authorizeManagedAgentOperation({
+                sessionId,
+                delegationToken,
+                delegationCommandHash,
+                targetAid: aid,
+            }, 'skill.refresh');
+            if (!authorization.ok)
+                return fail(authorization.code, authorization.error);
+        }
+        try {
+            const { refreshSkillIndex } = await import('./skill/startup.js');
+            refreshSkillIndex(agentDir(aid), aid);
+            const skillsDir = path.join(agentDir(aid), 'skills');
+            return {
+                ok: true,
+                result: {
+                    aid,
+                    builtinIndexPath: path.join(skillsDir, '.index-builtin.md'),
+                    localIndexPath: path.join(skillsDir, '.index-local.md'),
+                },
+            };
+        }
+        catch (error) {
+            return fail('INTERNAL', error?.message || String(error));
+        }
+    });
+    commandHandler.setSkillIndexRefresher(async (aid) => {
+        if (!agentRegistry.get(aid))
+            return { ok: false, error: `Agent "${aid}" not found` };
+        try {
+            const { refreshSkillIndex } = await import('./skill/startup.js');
+            refreshSkillIndex(agentDir(aid), aid);
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    });
     registerHandoffIpc({
         ipcServer,
         agentDelegationRegistry,
@@ -60,7 +198,7 @@ export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationReg
         handoffRuntime,
         getProcessOwners,
     });
-    registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime });
+    registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime, triggerSchedulers });
     ipcServer.setAgentReloadExecutor((aid, options) => reloadCoordinator.reload(aid, options));
     registerConsolidationCheckExecutor({ ipcServer, agentRegistry, enqueueConsolidation });
     ipcServer.setInitializationExecutor(async (command) => executeLocalInitializationCommand(agentInitializationService, command));
@@ -75,6 +213,7 @@ export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationReg
         handoffRuntime,
         agentApplicationService,
         agentInitializationService,
+        executeConfigOperation: (argv, sessionId, token, commandHash) => commandHandler.handleConfigOperation(argv, sessionId, token, commandHash),
     });
     registerOperationIpcProviders({
         ipcServer,
@@ -210,7 +349,7 @@ export function registerRuntimeIpcProviders({ ipcServer, channelInstances, messa
             const session = await sessionManager.getSessionById(sessionId);
             if (!session)
                 return null;
-            const { buildDebugTaskContext } = await import('./memory/consolidation.js');
+            const { buildDebugTaskContext } = await import('./auth/debug-context.js');
             const { ensureSessionRuntimeDir } = await import('../cli/task-context.js');
             return buildDebugTaskContext({
                 session,
@@ -220,8 +359,12 @@ export function registerRuntimeIpcProviders({ ipcServer, channelInstances, messa
         });
         logger.info('[Memory] 开发仓安装：已启用 ec memory --debug <sessionId>');
     }
-    ipcServer.setTaskRuntimeContextAuthorizer(({ sessionId, delegationToken, delegationCommandHash }) => {
-        const authorization = agentDelegationRegistry.validateForContext(delegationToken, sessionId, delegationCommandHash);
+    ipcServer.setTaskRuntimeContextAuthorizer(({ sessionId, delegationToken, delegationCommandHash, consumeApproval }) => {
+        if (consumeApproval && !agentDelegationRegistry.validate)
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Command authorization is unavailable' };
+        const authorization = consumeApproval
+            ? agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash)
+            : agentDelegationRegistry.validateForContext(delegationToken, sessionId, delegationCommandHash);
         return authorization.ok
             ? { ok: true }
             : { ok: false, code: authorization.code, error: authorization.reason };
@@ -383,8 +526,17 @@ export function registerOperationIpcProviders({ ipcServer, sessionManager, messa
         recover: recoverTask,
     }));
     ipcServer.setQueueOperationExecutor(async (params) => {
+        try {
+            if (!params.argv)
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Managed queue operation requires argv' };
+            const { parseQueueOperationArgv } = await import('../cli/queue-command.js');
+            params = { ...params, ...parseQueueOperationArgv(params.argv) };
+        }
+        catch (error) {
+            return { ok: false, code: 'INVALID_ARGUMENT', error: error instanceof Error ? error.message : String(error) };
+        }
         const operation = `ec.queue.${params.action ?? 'read'}`;
-        const authorization = await authorizeManagedAgentOperation(params, operation);
+        const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.agent }, operation);
         if (!authorization.ok)
             return authorization;
         const handle = agentRegistry.get(authorization.aid);
@@ -419,10 +571,57 @@ export function registerOperationIpcProviders({ ipcServer, sessionManager, messa
         return authorization.ok ? { ok: true } : authorization;
     });
     ipcServer.setStorageAuthorizationExecutor(async (params) => {
-        const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.aid }, params.operation);
-        return authorization.ok ? { ok: true } : authorization;
+        try {
+            if (!params.argv)
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Managed storage requires argv' };
+            const command = resolveStorageCommandArgv(params.argv);
+            if (command.sub === 'upload')
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Upload requires the storage upload endpoint' };
+            const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: command.aid }, command.operation);
+            if (!authorization.ok)
+                return authorization;
+            const { storageDownload, storageLs, storageRm, storageQuota } = await import('../aun/storage/index.js');
+            if (command.sub === 'ls')
+                return storageLs(authorization.aid, command.prefix);
+            if (command.sub === 'quota')
+                return storageQuota(authorization.aid);
+            if (command.sub === 'rm') {
+                const result = await storageRm(authorization.aid, command.remotePath);
+                return { ...result, objectKey: command.remotePath };
+            }
+            const session = await sessionManager.getSessionById(params.sessionId);
+            if (!session)
+                return { ok: false, code: 'SESSION_NOT_FOUND', error: 'current session not found' };
+            const defaultName = path.basename(command.url.replace(/^https?:\/\//, '').split('/').slice(1).join('/'));
+            const destination = path.resolve(session.projectPath, command.localPath ?? defaultName);
+            const roots = [session.projectPath, authorization.sessionRuntimeDir].filter((root) => !!root).map(root => fs.realpathSync(root));
+            let parent = path.dirname(destination);
+            while (!fs.existsSync(parent) && path.dirname(parent) !== parent)
+                parent = path.dirname(parent);
+            const realParent = fs.realpathSync(parent);
+            if (!roots.some(root => isSameOrDescendant(destination, root) && isSameOrDescendant(realParent, root))
+                || isHClassPath(destination) || isLClassPath(destination)
+                || (fs.existsSync(destination) && (!fs.lstatSync(destination).isFile() || fs.lstatSync(destination).isSymbolicLink()))) {
+                return { ok: false, code: 'INVALID_LOCAL_PATH', error: 'Download destination must be an unprotected project/TMPDIR file' };
+            }
+            return storageDownload(authorization.aid, command.url, destination);
+        }
+        catch (error) {
+            return { ok: false, code: 'STORAGE_OPERATION_FAILED', error: error instanceof Error ? error.message : String(error) };
+        }
     });
     ipcServer.setStorageUploadExecutor(async (params) => {
+        try {
+            if (!params.argv)
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Managed storage upload requires argv' };
+            const command = resolveStorageCommandArgv(params.argv);
+            if (command.sub !== 'upload')
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Upload endpoint does not match argv' };
+            params = { ...params, aid: command.aid, localFile: command.localFile, remotePath: command.remotePath, isPublic: command.isPublic };
+        }
+        catch (error) {
+            return { ok: false, code: 'INVALID_ARGUMENT', error: error instanceof Error ? error.message : String(error) };
+        }
         const authorization = await authorizeManagedAgentOperation({ ...params, targetAid: params.aid }, 'storage.upload');
         if (!authorization.ok)
             return authorization;
@@ -438,7 +637,9 @@ export function registerOperationIpcProviders({ ipcServer, sessionManager, messa
             }
             const localFile = fs.realpathSync(requestedFile);
             const stat = fs.lstatSync(localFile);
-            if (!isSameOrDescendant(localFile, projectPath) || isHClassPath(localFile)) {
+            const inProject = isSameOrDescendant(localFile, projectPath);
+            const inRuntime = authorization.sessionRuntimeDir && isSameOrDescendant(localFile, fs.realpathSync(authorization.sessionRuntimeDir));
+            if ((!inProject && !inRuntime) || isHClassPath(localFile) || isLClassPath(localFile)) {
                 return { ok: false, code: 'INVALID_LOCAL_PATH', error: 'Upload source must be an unprotected file inside the current session project' };
             }
             if (!stat.isFile() || stat.isSymbolicLink()) {

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

@@ -34,7 +34,14 @@ export const MODE_SCOPE = {
 // 超期判据集中在 staleness.ts；这里做转发，保证 trigger 与 context 用同一套规则
 export { DEFAULT_FORGET_AFTER_DAYS, LONG_TERM_REVIEW_DAYS } from './staleness.js';
 // ── Checkpoint 读写 ──────────────────────────────────────────────────────────
-const CHECKPOINT_FILE = 'consolidation-checkpoint.json';
+const LEGACY_CHECKPOINT_FILE = 'consolidation-checkpoint.json';
+/** C1: checkpoint file name per mode; forget uses scopeOverride suffix. */
+function checkpointFileName(mode, scopeOverride) {
+    if (mode === 'forget' && scopeOverride) {
+        return `consolidation-checkpoint-forget-${scopeOverride}.json`;
+    }
+    return `consolidation-checkpoint-${mode}.json`;
+}
 /**
  * Move the pre-0.0.29 consolidation artifact root to its new name. Existing
  * batches are user data, so conflicts are preserved under a legacy suffix
@@ -70,22 +77,37 @@ export function migrateLegacyConsolidationBatches() {
     fs.rmSync(legacyRoot, { recursive: true, force: true });
 }
 /** 读上次整理时间戳（毫秒）。文件不存在或解析失败返回 0（取全量历史）。 */
-export function readCheckpoint(chatDir) {
+export function readCheckpoint(chatDir, mode, scopeOverride) {
+    const filePath = path.join(chatDir, checkpointFileName(mode, scopeOverride));
     try {
-        const raw = fs.readFileSync(path.join(chatDir, CHECKPOINT_FILE), 'utf-8');
+        const raw = fs.readFileSync(filePath, 'utf-8');
         const parsed = JSON.parse(raw);
         const v = Number(parsed.lastConsolidatedAt);
-        return Number.isFinite(v) ? v : 0;
+        if (Number.isFinite(v))
+            return v;
     }
-    catch {
-        return 0;
+    catch { /* 新文件不存在，尝试迁移旧文件 */ }
+    // 向后兼容: notes 模式读旧的 consolidation-checkpoint.json，成功后自动迁移
+    if (mode === 'notes') {
+        try {
+            const legacyPath = path.join(chatDir, LEGACY_CHECKPOINT_FILE);
+            const raw = fs.readFileSync(legacyPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const v = Number(parsed.lastConsolidatedAt);
+            if (Number.isFinite(v)) {
+                writeCheckpoint(chatDir, v, mode, scopeOverride);
+                return v;
+            }
+        }
+        catch { /* ignore */ }
     }
+    return 0;
 }
 /** 写整理完成时间戳。由 index.ts 在整理会话完成后调用。 */
-export function writeCheckpoint(chatDir, lastConsolidatedAt) {
+export function writeCheckpoint(chatDir, lastConsolidatedAt, mode, scopeOverride) {
     try {
         fs.mkdirSync(chatDir, { recursive: true });
-        fs.writeFileSync(path.join(chatDir, CHECKPOINT_FILE), JSON.stringify({ lastConsolidatedAt }, null, 2) + '\n', 'utf-8');
+        fs.writeFileSync(path.join(chatDir, checkpointFileName(mode, scopeOverride)), JSON.stringify({ lastConsolidatedAt }, null, 2) + '\n', 'utf-8');
     }
     catch { /* 失败静默 */ }
 }
@@ -276,7 +298,7 @@ function shortTime(time) {
  *
  * 返回生成的文件路径列表（空列表表示无增量消息或读取失败）。
  */
-function buildThreadSnapshots(historyJsonlPath, sinceMs, threadsDir) {
+function buildThreadSnapshots(historyJsonlPath, sinceMs, threadsDir, throughMs) {
     const rawLines = fs.readFileSync(historyJsonlPath, 'utf-8').split('\n');
     // 第一遍：扫全量行（不限 sinceMs）收集会话元信息
     let chatType = 'private';
@@ -312,7 +334,7 @@ function buildThreadSnapshots(historyJsonlPath, sinceMs, threadsDir) {
         try {
             const entry = JSON.parse(line);
             const ts = typeof entry.ts === 'number' ? entry.ts : 0;
-            if (ts < sinceMs)
+            if (ts <= sinceMs || ts > throughMs)
                 continue;
             const content = typeof entry.content === 'string' ? entry.content.trim() : '';
             if (!content)
@@ -410,26 +432,36 @@ export function serializeConsolidationContext(input) {
     const selfAid = input.taskCtx.selfAid ?? 'unknown';
     // 目录名：YYYYMMDDTHHmmss-<selfAid>-<mode>
     const prettyTs = now.toISOString().replace(/[-:]/g, '').slice(0, 15);
-    const batchDir = path.join(batchRoot, `${prettyTs}-${selfAid}-${input.mode}`);
+    fs.mkdirSync(batchRoot, { recursive: true });
+    const batchDir = fs.mkdtempSync(path.join(batchRoot, `${prettyTs}-${selfAid}-${input.mode}-`));
     fs.mkdirSync(batchDir, { recursive: true });
     // ── 话题快照（notes / compress / session-new 模式，有 peerId 时生成）───────
     let historyJsonlPath;
     let threadFiles;
     let chatDir;
-    if ((input.mode === 'notes' || input.triggeredBy === 'compress' || input.triggeredBy === 'session-new')
+    // C2: generate thread snapshots for all modes that operate on relation-level memories
+    const needsThreadSnapshots = (input.mode === 'notes'
+        || input.mode === 'generalize'
+        || input.mode === 'promote'
+        || input.mode === 'profile'
+        || (input.mode === 'forget' && input.scopeOverride === 'relation')
+        || input.triggeredBy === 'compress'
+        || input.triggeredBy === 'session-new');
+    if (needsThreadSnapshots
         && input.taskCtx.channel
         && input.taskCtx.peerId
         && input.taskCtx.selfAid) {
         try {
             const sessionsDir = resolvePaths().sessionsDir;
-            chatDir = chatDirPath(sessionsDir, input.taskCtx.channel, input.taskCtx.peerId, input.taskCtx.selfAid);
+            const peerId = input.taskCtx.chatType === 'group' ? input.taskCtx.channelId || input.taskCtx.peerId : input.taskCtx.peerId;
+            chatDir = chatDirPath(sessionsDir, input.taskCtx.channel, peerId, input.taskCtx.selfAid, input.taskCtx.channelKey);
             const rawJsonlPath = path.join(chatDir, 'messages.jsonl');
             if (fs.existsSync(rawJsonlPath)) {
                 historyJsonlPath = rawJsonlPath;
-                const sinceMs = readCheckpoint(chatDir);
+                const sinceMs = readCheckpoint(chatDir, input.mode, input.scopeOverride);
                 const threadsDir = path.join(batchDir, 'threads');
                 try {
-                    const files = buildThreadSnapshots(rawJsonlPath, sinceMs, threadsDir);
+                    const files = buildThreadSnapshots(rawJsonlPath, sinceMs, threadsDir, now.getTime());
                     if (files.length > 0)
                         threadFiles = files;
                 }
@@ -494,7 +526,8 @@ export function serializeConsolidationContext(input) {
         fs.writeFileSync(contextFilePath, text, 'utf-8');
     }
     catch { /* 批次任务书写入失败不影响整理 */ }
-    return { filePath, batchDir, contextFilePath, scopes, historyJsonlPath, threadFiles, chatDir };
+    return { filePath, batchDir, contextFilePath, scopes, historyJsonlPath, threadFiles, chatDir,
+        ...(threadFiles?.length ? { snapshotThroughTs: now.getTime() } : {}) };
 }
 /** 会话结束后回填本次产出，追加到任务书末尾。 */
 export function recordBatchOutcome(contextFilePath, outcome) {

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

@@ -122,3 +122,38 @@ export function readRollbackRecords(batchDir) {
         return [];
     }
 }
+/**
+ * 统计 batchDir/threads/ 下所有快照文件里的消息条数。
+ * 每个 .md 文件里以 "L" 开头（后跟数字）的行就是一条消息。
+ * 文件不存在或为空时返回 0。
+ */
+export function countInputMessages(batchDir) {
+    const threadsDir = path.join(batchDir, 'threads');
+    if (!fs.existsSync(threadsDir))
+        return 0;
+    let total = 0;
+    try {
+        for (const f of fs.readdirSync(threadsDir)) {
+            if (!f.endsWith('.md'))
+                continue;
+            const content = fs.readFileSync(path.join(threadsDir, f), 'utf-8');
+            for (const line of content.split('\n')) {
+                if (/^L\d+\s/.test(line))
+                    total++;
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return total;
+}
+/**
+ * 读取 batchDir/context.md 的字节数。文件不存在返回 0。
+ */
+export function readContextBytes(batchDir) {
+    try {
+        return fs.statSync(path.join(batchDir, 'context.md')).size;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/core/memory/consolidation-queue-format.js

@@ -0,0 +1,21 @@
+/**
+ * 整理请求入队时的提示文案。CLI（ec memory consolidate）和 /memory consolidate 共用。
+ * 不依赖其他模块，CLI 侧引入不会拖进 daemon 代码。
+ */
+/** 入队原因：本 agent 已有整理会话在跑，或全局并发已满 */
+export function queueReason(q) {
+    if (q.agentBusy)
+        return '当前 agent 已有整理会话在运行';
+    if (q.activeCount >= q.maxConcurrent)
+        return `全局并发已满（${q.activeCount}/${q.maxConcurrent}）`;
+    return '前面还有待处理的整理请求';
+}
+/** 多行明细，每行一个字段 */
+export function formatQueueDetails(q) {
+    return [
+        `原因:          ${queueReason(q)}`,
+        `本 agent 排队: 第 ${q.position} 位 / 共 ${q.agentQueueLength} 个`,
+        `全局运行中:    ${q.activeCount}/${q.maxConcurrent}`,
+        `全局排队:      ${q.totalQueued} 个`,
+    ];
+}