evolcore 0.0.3 → 0.0.4

package/dist/core/message/message-log.js

@@ -320,6 +320,7 @@ export function buildOutboundEntry(opts) {
         usage: opts.usage ?? null,
         encrypt: opts.encrypt,
         chatmode: opts.chatmode,
+        transport: opts.transport,
         peerType: opts.peerType,
         source: opts.source ?? 'daemon',
         handoff_trace: opts.handoff_trace,

package/dist/core/message/message-queue.js

@@ -14,6 +14,7 @@ export class MessageQueue {
     activeStates = new Map(); // queueKey → active task state
     interruptCallback;
     interruptBarriers = new Map();
+    activeTerminalReasons = new Map();
     eventBus;
     recentMessageIds = new Set();
     DEDUP_WINDOW = 60_000; // 1 分钟窗口
@@ -24,6 +25,8 @@ export class MessageQueue {
     processingStartTime = new Map(); // queueKey → 处理开始时间戳
     queueKeyToSessionKey = new Map(); // queueKey → sessionKey（human-readable 格式）
     droppedTriggerSessionIds = new Set();
+    shuttingDown = false;
+    shutdownPromise;
     /** 逻辑队列桥接：管理出队顺序（响应模式可注入自定义策略，默认 FIFO） */
     logicalQueue = new LogicalQueueBridge();
     constructor(handler, options) {
@@ -43,7 +46,15 @@ export class MessageQueue {
             return existing;
         if (!this.interruptCallback)
             return Promise.resolve();
-        const barrier = this.interruptCallback(sessionKey, baseagent, evolagentName, reason)
+        this.activeTerminalReasons.set(queueKey, reason);
+        let interruption;
+        try {
+            interruption = Promise.resolve(this.interruptCallback(sessionKey, baseagent, evolagentName, reason));
+        }
+        catch (error) {
+            interruption = Promise.reject(error);
+        }
+        const barrier = interruption
             .catch(error => {
             logger.warn(`[Queue] Interrupt barrier failed for ${queueKey}: ${error instanceof Error ? error.message : String(error)}`);
         })
@@ -57,6 +68,29 @@ export class MessageQueue {
     }
     setEventBus(eventBus) {
         this.eventBus = eventBus;
+        const subscribe = eventBus.subscribe;
+        if (typeof subscribe !== 'function')
+            return;
+        subscribe.call(eventBus, 'task:interrupted', event => {
+            if ('sessionId' in event && event.sessionId) {
+                this.markActiveTerminal(event.sessionId, event.reason || 'interrupted');
+            }
+        });
+        subscribe.call(eventBus, 'task:completed', event => {
+            if ('sessionId' in event && event.sessionId)
+                this.markActiveTerminal(event.sessionId, 'completed');
+        });
+        subscribe.call(eventBus, 'task:error', event => {
+            if ('sessionId' in event && event.sessionId)
+                this.markActiveTerminal(event.sessionId, 'error');
+        });
+    }
+    /** 标记 active handler 已有业务终态，避免 shutdown 将其重新放回恢复队列。 */
+    markActiveTerminal(sessionId, reason) {
+        for (const queueKey of this.activeBatches.keys()) {
+            if (this.matchesSession(queueKey, sessionId))
+                this.activeTerminalReasons.set(queueKey, reason);
+        }
     }
     /**
      * 注册一次性消息拦截器：下一条来自 sessionKey 的消息不入队、不触发 interrupt，
@@ -213,7 +247,9 @@ export class MessageQueue {
             images: undefined,
             mentions: undefined,
             mentionAids: undefined,
-            messageId: undefined,
+            // Retain the inbound anchor so the resumed task can replace the
+            // daemon-restart CrossMark with its current processing state.
+            messageId: source.messageId,
             batchRole: item.role,
             items: [{
                     kind: 'restart-resume',
@@ -326,6 +362,69 @@ export class MessageQueue {
     persistQueuesImmediate() {
         this.persistQueuesSync();
     }
+    /**
+     * 冻结当前队列并优雅中断所有正在执行的主任务。
+     *
+     * activeBatches 会原样保留到进程退出，供下次启动恢复主消息；runner 内部
+     * 子任务不进入队列，也不在这里重建。task:interrupted 必须同步发布，确保
+     * ResponseEngine 在任何 handler continuation 之前先使旧 turn lease 失效。
+     */
+    shutdownGracefully(timeoutMs = 6_500) {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        this.shuttingDown = true;
+        const allActive = Array.from(this.activeBatches.entries());
+        const active = allActive.filter(([queueKey]) => !this.activeTerminalReasons.has(queueKey));
+        const barriers = [];
+        // 已因 stop/new_message/timeout/recalled 进入中断的任务不应被 restart 恢复。
+        // pending 队列仍照常保留，下一次启动只处理尚未消费的后续输入。
+        for (const [queueKey] of allActive) {
+            if (!this.activeTerminalReasons.has(queueKey))
+                continue;
+            this.activeBatches.delete(queueKey);
+            const existingBarrier = this.interruptBarriers.get(queueKey);
+            if (existingBarrier)
+                barriers.push(existingBarrier);
+        }
+        const persisted = this.persistQueuesSync() || this.persistQueuesSync();
+        if (!persisted) {
+            logger.error('[Queue] CRITICAL: graceful shutdown snapshot could not be persisted');
+        }
+        for (const [queueKey, item] of active) {
+            const sessionKey = this.sessionKeyFromQueueKey(queueKey);
+            const agentName = this.processingAgent.get(queueKey) || item.agentName;
+            this.eventBus?.publish({
+                type: 'task:interrupted',
+                sessionId: sessionKey,
+                reason: 'daemon_restart',
+                agentName,
+                causation: item.message.causation,
+            });
+            barriers.push(this.triggerInterrupt(queueKey, sessionKey, this.activeStates.get(queueKey)?.baseagent, agentName, 'daemon_restart'));
+        }
+        this.shutdownPromise = (async () => {
+            let timedOut = false;
+            let timer;
+            if (barriers.length > 0) {
+                await Promise.race([
+                    Promise.allSettled(barriers),
+                    new Promise(resolve => {
+                        timer = setTimeout(() => { timedOut = true; resolve(); }, Math.max(1, timeoutMs));
+                    }),
+                ]);
+            }
+            if (timer)
+                clearTimeout(timer);
+            if (timedOut) {
+                logger.warn(`[Queue] Graceful shutdown interrupt barrier timed out after ${timeoutMs}ms`);
+            }
+            // 发布 interrupt 前的同步写盘是唯一恢复点。runner 收尾可能继续修改
+            // handler 持有的 message 对象，不能在这里用可变对象覆盖冻结快照。
+            logger.info(`[Queue] Graceful shutdown froze ${active.length} active task(s)`);
+            return active.length;
+        })();
+        return this.shutdownPromise;
+    }
     persistQueuesSync() {
         if (!this.persistencePath)
             return true;
@@ -430,10 +529,15 @@ export class MessageQueue {
             if (rawParts.length === 0)
                 continue;
             const first = rawParts[0];
-            const submittedPart = first.message.handoffDelivery
-                ? this.restoredPart(first)
-                : this.restoreSubmittedPart(first);
-            const submittedItem = this.itemFromPart(submittedPart);
+            const restoredOriginParts = rawParts.length > 1
+                && rawParts.every(part => this.isOriginHandoff(part.message))
+                ? rawParts.map(part => this.restoredPart(part))
+                : undefined;
+            const submittedItem = restoredOriginParts
+                ? this.buildCoalescedItem(restoredOriginParts)
+                : this.itemFromPart(first.message.handoffDelivery
+                    ? this.restoredPart(first)
+                    : this.restoreSubmittedPart(first));
             submittedItem.message.timestamp = first.message.timestamp;
             queue.push(submittedItem);
             for (const part of rawParts) {
@@ -505,6 +609,11 @@ export class MessageQueue {
         return false;
     }
     async enqueue(sessionKey, message, projectPath, options) {
+        if (this.shuttingDown) {
+            const error = new Error('Daemon is shutting down');
+            error.code = 'DAEMON_SHUTTING_DOWN';
+            return Promise.reject(error);
+        }
         if (options?.signal?.aborted) {
             return Promise.reject(abortError(options.signal.reason));
         }
@@ -680,6 +789,11 @@ export class MessageQueue {
         this.processing.add(queueKey);
         logger.info(`[Queue] processNext: start key=${queueKey}`);
         while (true) {
+            if (this.shuttingDown) {
+                this.processing.delete(queueKey);
+                this.processingAgent.delete(queueKey);
+                return;
+            }
             const interruptBarrier = this.interruptBarriers.get(queueKey);
             if (interruptBarrier) {
                 logger.debug(`[Queue] Waiting for interrupt barrier on ${queueKey}`);
@@ -691,6 +805,11 @@ export class MessageQueue {
                 logger.debug(`[Queue] Waiting for external lock on ${queueKey}`);
                 await lock;
             }
+            if (this.shuttingDown) {
+                this.processing.delete(queueKey);
+                this.processingAgent.delete(queueKey);
+                return;
+            }
             const queue = this.queues.get(queueKey);
             if (!queue || queue.length === 0) {
                 logger.info(`[Queue] processNext: queue empty, releasing key=${queueKey}`);
@@ -766,10 +885,18 @@ export class MessageQueue {
                 rejects.forEach(r => r(error));
             }
             finally {
-                this.activeBatches.delete(queueKey);
-                this.processingStartTime.delete(queueKey);
-                this.activeStates.delete(queueKey);
-                this.persistQueuesImmediate();
+                if (!this.shuttingDown) {
+                    this.activeBatches.delete(queueKey);
+                    this.processingStartTime.delete(queueKey);
+                    this.activeStates.delete(queueKey);
+                    this.activeTerminalReasons.delete(queueKey);
+                    this.persistQueuesImmediate();
+                }
+            }
+            if (this.shuttingDown) {
+                this.processing.delete(queueKey);
+                this.processingAgent.delete(queueKey);
+                return;
             }
         }
     }
@@ -781,6 +908,15 @@ export class MessageQueue {
     dequeueGreedy(queue) {
         const first = queue.shift();
         const result = [first];
+        if (this.isOriginHandoff(first.message)) {
+            while (queue.length > 0 && this.canMergeOriginHandoffs(first, queue[0])) {
+                result.push(queue.shift());
+            }
+            if (result.length > 1) {
+                logger.info(`[Queue] Greedy dequeue: merged ${result.length} pending origin handoff result(s)`);
+            }
+            return result;
+        }
         if (this.isMergeBarrier(first.message))
             return result;
         const mergeSubmittedResume = first.message.restartResume?.submitted === true;
@@ -833,6 +969,24 @@ export class MessageQueue {
     isMergeBarrier(message) {
         return !!message.handoffDelivery || !!message.triggerMeta || !!message.causation?.trigger?.path.length;
     }
+    isOriginHandoff(message) {
+        return message.source === 'handoff' && message.handoffDelivery?.direction === 'origin';
+    }
+    canMergeOriginHandoffs(first, next) {
+        if (!this.isOriginHandoff(next.message))
+            return false;
+        if (first.projectPath !== next.projectPath || first.agentName !== next.agentName)
+            return false;
+        const a = first.message.handoffDelivery?.originAuthorization;
+        const b = next.message.handoffDelivery?.originAuthorization;
+        if (!a || !b)
+            return a === b;
+        return a.actorId === b.actorId
+            && a.channelKey === b.channelKey
+            && a.channelType === b.channelType
+            && a.chatType === b.chatType
+            && a.peerKey === b.peerKey;
+    }
     firstTimestamp(item) {
         const parts = this.partsOf(item);
         let ts = Number.POSITIVE_INFINITY;
@@ -869,6 +1023,9 @@ export class MessageQueue {
         const seenSourceMessageIds = new Set();
         let hasRestartResume = false;
         let hasMessagesAfterRestartResume = false;
+        const originHandoffIds = [];
+        const seenOriginHandoffIds = new Set();
+        const allOriginHandoffs = items.every(item => this.isOriginHandoff(item.message));
         for (const item of items) {
             const m = item.message;
             if (hasRestartResume && !m.restartResume?.submitted) {
@@ -882,6 +1039,17 @@ export class MessageQueue {
                 allImages.push(...m.images);
             if (m.mentions)
                 allMentions.push(...m.mentions);
+            if (allOriginHandoffs && m.handoffDelivery) {
+                const ids = m.handoffDelivery.handoffIds?.length
+                    ? m.handoffDelivery.handoffIds
+                    : [m.handoffDelivery.handoffId];
+                for (const id of ids) {
+                    if (!seenOriginHandoffIds.has(id)) {
+                        seenOriginHandoffIds.add(id);
+                        originHandoffIds.push(id);
+                    }
+                }
+            }
             for (const id of [...(m.sourceMessageIds ?? []), ...(m.messageId ? [m.messageId] : [])]) {
                 if (!seenSourceMessageIds.has(id)) {
                     seenSourceMessageIds.add(id);
@@ -939,6 +1107,13 @@ export class MessageQueue {
             restartResume: hasRestartResume
                 ? { submitted: true, pendingInterrupted: hasMessagesAfterRestartResume }
                 : undefined,
+            handoffDelivery: allOriginHandoffs && originHandoffIds.length > 0
+                ? {
+                    ...last.message.handoffDelivery,
+                    handoffId: originHandoffIds[0],
+                    handoffIds: originHandoffIds,
+                }
+                : last.message.handoffDelivery,
         };
         return {
             message: merged,

package/dist/core/message/peer-mode.js

@@ -77,21 +77,20 @@ export function resolveChatModeForPeer(params) {
     const field = chatmodeFieldForPeer(params.chatType, params.peerType);
     return params.configured?.[field] ?? chatmodeFactoryDefaults()[field];
 }
-let _factoryChatmode = null;
 /**
  * chatMode 出厂默认表 —— 唯一来源是 agent-config schema 的 chatmode.default
  * （配置数据，非代码分支）。agent 级配置改默认表、关系级按键覆盖，均经
  * ConfigManager 合并后以 `configured` 传入；此表仅在配置链完全未设值时兜底。
+ *
+ * 不做二级 memo：`loadSchema` 自己走 FileCache，这里再存一份等于绕过
+ * invalidateKitCache——schema 换了新的，出厂默认表却永久停在进程启动那一刻。
  */
 export function chatmodeFactoryDefaults() {
-    if (!_factoryChatmode) {
-        const d = loadSchema('agent-config').fields.get('chatmode')?.default;
-        if (!d?.private || !d?.group || !d?.nothuman) {
-            throw new Error('[peer-mode] agent-config schema 缺少 chatmode 出厂默认表（default.private/group/nothuman）');
-        }
-        _factoryChatmode = d;
+    const d = loadSchema('agent-config').fields.get('chatmode')?.default;
+    if (!d?.private || !d?.group || !d?.nothuman) {
+        throw new Error('[peer-mode] agent-config schema 缺少 chatmode 出厂默认表（default.private/group/nothuman）');
     }
-    return _factoryChatmode;
+    return { ...d }; // d 挂在缓存的 schema 对象上，拷一层避免调用方改写污染缓存
 }
 export function chatmodeFieldForPeer(chatType, peerType) {
     const kind = normalizePeerType(peerType);