evolcore 0.0.28 → 0.0.29-test.0

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

@@ -19,6 +19,7 @@ export class MessageQueue {
     activeStates = new Map(); // queueKey → active task state
     interruptCallback;
     interruptBarriers = new Map();
+    interruptFailures = new Map();
     activeTerminalReasons = new Map();
     eventBus;
     recentMessageIds = new Set();
@@ -53,7 +54,7 @@ export class MessageQueue {
     setInterruptCallback(callback) {
         this.interruptCallback = callback;
     }
-    triggerInterrupt(queueKey, sessionKey, baseagent, evolagentName, reason, timeout) {
+    triggerInterrupt(queueKey, sessionKey, baseagent, evolagentName, reason, timeout, strict) {
         const existing = this.interruptBarriers.get(queueKey);
         if (existing)
             return existing;
@@ -62,15 +63,20 @@ export class MessageQueue {
         this.activeTerminalReasons.set(queueKey, reason);
         let interruption;
         try {
-            interruption = Promise.resolve(timeout
-                ? this.interruptCallback(sessionKey, baseagent, evolagentName, reason, timeout)
-                : this.interruptCallback(sessionKey, baseagent, evolagentName, reason));
+            interruption = Promise.resolve(strict
+                ? this.interruptCallback(sessionKey, baseagent, evolagentName, reason, timeout, true)
+                : timeout
+                    ? this.interruptCallback(sessionKey, baseagent, evolagentName, reason, timeout)
+                    : this.interruptCallback(sessionKey, baseagent, evolagentName, reason));
         }
         catch (error) {
             interruption = Promise.reject(error);
         }
         const barrier = interruption
             .catch(error => {
+            this.interruptFailures.set(queueKey, error instanceof Error ? error : new Error(String(error)));
+            const cleanup = setTimeout(() => this.interruptFailures.delete(queueKey), 60_000);
+            cleanup.unref?.();
             logger.warn(`[Queue] Interrupt barrier failed for ${queueKey}: ${error instanceof Error ? error.message : String(error)}`);
         })
             .finally(() => {
@@ -379,25 +385,35 @@ export class MessageQueue {
     }
     messageIdsFor(item) {
         return this.partsOf(item)
-            .map(part => part.message.messageId)
+            .flatMap(part => [...(part.message.sourceMessageIds ?? []), part.message.messageId])
             .filter((id) => !!id);
     }
     partMatchesMessage(part, messageId, selfAID, queueKey) {
-        if (part.message.messageId !== messageId)
+        if (part.message.messageId !== messageId && !part.message.sourceMessageIds?.includes(messageId))
             return false;
         if (selfAID === undefined)
             return true;
         const messageScope = part.message.selfAID ?? (queueKey ? this.selfAIDFromQueueKey(queueKey) : undefined);
         return messageScope === selfAID;
     }
+    partMatchesScope(part, scope) {
+        if (!scope)
+            return true;
+        const message = part.message;
+        if (scope.channelId !== undefined && message.channelId !== scope.channelId)
+            return false;
+        if (scope.groupId !== undefined && message.groupId !== scope.groupId)
+            return false;
+        if (scope.threadId !== undefined && (message.threadId || '') !== (scope.threadId || ''))
+            return false;
+        return true;
+    }
     peerIdsFor(item) {
         return this.partsOf(item).map(part => part.message.peerId);
     }
     serializePart(part, fallbackEnqueuedAt) {
         const enqueuedAt = part.enqueuedAt ?? part.message.enqueuedAt ?? fallbackEnqueuedAt ?? Date.now();
-        const message = part.message.enqueuedAt === enqueuedAt
-            ? part.message
-            : { ...part.message, enqueuedAt };
+        const message = { ...part.message, enqueuedAt };
         return {
             message,
             projectPath: part.projectPath,
@@ -408,9 +424,7 @@ export class MessageQueue {
     }
     serializeItem(item, fallbackEnqueuedAt) {
         const enqueuedAt = item.enqueuedAt ?? item.message.enqueuedAt ?? fallbackEnqueuedAt ?? Date.now();
-        const message = item.message.enqueuedAt === enqueuedAt
-            ? item.message
-            : { ...item.message, enqueuedAt };
+        const message = { ...item.message, enqueuedAt };
         return {
             message,
             projectPath: item.projectPath,
@@ -580,6 +594,8 @@ export class MessageQueue {
     canDequeueGroupTimeline(first, next) {
         if (first.role === undefined || next.role === undefined)
             return false;
+        if (first.message.attentionPolicy !== next.message.attentionPolicy)
+            return false;
         if ((first.agentName || DEFAULT_AGENT_NAME) !== (next.agentName || DEFAULT_AGENT_NAME))
             return false;
         if (path.resolve(first.projectPath) !== path.resolve(next.projectPath))
@@ -678,14 +694,17 @@ export class MessageQueue {
             const buckets = [];
             const activeBuckets = [];
             for (const [queueKey, queue] of this.queues.entries()) {
-                if (queue.length === 0)
+                const durable = queue.filter(item => item.message.source !== 'owner-inject');
+                if (durable.length === 0)
                     continue;
                 buckets.push({
                     queueKey,
-                    items: queue.map(item => this.serializeItem(item)),
+                    items: durable.map(item => this.serializeItem(item)),
                 });
             }
             for (const [queueKey, item] of this.activeBatches.entries()) {
+                if (item.message.source === 'owner-inject')
+                    continue;
                 activeBuckets.push({
                     queueKey,
                     items: [this.serializeItem(item)],
@@ -872,6 +891,8 @@ export class MessageQueue {
         return sessionIds;
     }
     shouldRestoreMessage(message, sessionId) {
+        if (message.source === 'owner-inject')
+            return false;
         // The Trigger scheduler records open runs as daemon_restart. Replaying their
         // queued work afterwards would execute side effects for an already-failed run.
         if (message.executionPermissionOverride)
@@ -896,7 +917,7 @@ export class MessageQueue {
             message = { ...message, selfAID: options.selfAID };
         }
         // 消息去重检查
-        if (!this.shouldProcess(sessionKey, message, options?.selfAID)) {
+        if (message.source !== 'owner-inject' && !this.shouldProcess(sessionKey, message, options?.selfAID)) {
             options?.onPersisted?.();
             return Promise.resolve();
         }
@@ -920,6 +941,19 @@ export class MessageQueue {
         const isProcessing = this.processing.has(queueKey);
         const currentQueue = this.queues.get(queueKey);
         logger.info(`[Queue] enqueue: key=${queueKey} processing=${isProcessing} queueLen=${currentQueue?.length ?? 0} pending=${currentQueue?.length ?? 0} rawPending=${currentQueue ? this.queueRawMessageCount(currentQueue) : 0} agent=${agentName} role=${options?.role ?? '<none>'} peer=${message.peerId ?? '<none>'} msg=${message.messageId ?? '<none>'}`);
+        // Do not await diagnostic logging before the queue entry is admitted.  The
+        // enqueue API must expose the message to concurrent session barriers in the
+        // same turn; yielding here creates a window where recovery can observe an
+        // empty queue and enqueue a duplicate task.
+        void import('../../utils/msg-diag.js').then(({ diagLog }) => {
+            diagLog('queue_enqueue', {
+                aid: message.selfAID ?? agentName,
+                from: message.peerId ?? '',
+                to: message.selfAID ?? agentName,
+                msgId: message.messageId ?? '',
+                text: message.content ?? '',
+            });
+        }).catch(() => { });
         return new Promise((resolve, reject) => {
             let settled = false;
             let aborting = false;
@@ -967,8 +1001,14 @@ export class MessageQueue {
                 timestamp: message.receivedAt ?? message.timestamp ?? enqueuedAt,
             };
             const queuedItem = { message, projectPath, agentName, role: options?.role, resolve: queuedResolve, reject: queuedReject, enqueuedAt };
-            queue.push(queuedItem);
-            this.logicalQueue.enqueue(queueKey, message); // 通知逻辑队列记录出队顺序
+            if (options?.priority) {
+                const firstOrdinary = queue.findIndex(item => item.message.source !== 'owner-inject');
+                queue.splice(firstOrdinary < 0 ? queue.length : firstOrdinary, 0, queuedItem);
+            }
+            else
+                queue.push(queuedItem);
+            if (message.source !== 'owner-inject' && message.attentionPolicy !== 'interrupt')
+                this.logicalQueue.enqueue(queueKey, message);
             abortHandler = () => {
                 if (settled || aborting)
                     return;
@@ -1009,7 +1049,8 @@ export class MessageQueue {
             // A duplicate must not re-enter a runner after the queue entry has
             // survived its write-ahead snapshot. Keep this separate from the queue
             // snapshot because the latter is removed as soon as the task completes.
-            this.rememberDurably(sessionKey, message, options?.selfAID);
+            if (message.source !== 'owner-inject')
+                this.rememberDurably(sessionKey, message, options?.selfAID);
             try {
                 options?.onPersisted?.();
             }
@@ -1030,9 +1071,12 @@ export class MessageQueue {
                 //  - 单聊（interruptible !== false）：始终打断
                 //  - 群聊（interruptible === false）+ interruptSamePeer：仅当「同一发送者连发」
                 //    且队列里没有其他人的消息时打断，避免抢占群里他人的排队消息
-                const interruptSingle = options?.interruptible !== false;
+                const interruptSingle = options?.attentionPolicy === 'interrupt'
+                    || (options?.attentionPolicy !== 'defer' && options?.interruptible !== false);
                 const activeState = this.activeStates.get(queueKey);
-                const interruptGroupSamePeer = options?.interruptible === false &&
+                const interruptGroupSamePeer = options?.attentionPolicy !== 'interrupt' &&
+                    options?.attentionPolicy !== 'defer' &&
+                    options?.interruptible === false &&
                     options?.interruptSamePeer === true &&
                     !!message.peerId &&
                     activeState?.peerId === message.peerId &&
@@ -1125,7 +1169,8 @@ export class MessageQueue {
                 return;
             }
             // 逻辑队列重排：让响应模式的出队策略决定队首（默认 FIFO，不改变顺序）
-            this.logicalQueue.reorderPhysical(queueKey, queue);
+            if (queue[0]?.message.source !== 'owner-inject' && queue[0]?.message.attentionPolicy !== 'interrupt')
+                this.logicalQueue.reorderPhysical(queueKey, queue);
             // 贪心合并：群聊按完整时间线，旧路径/私聊按 peerId
             const items = this.dequeueGreedy(queue);
             // 同步逻辑队列：移除所有被合并处理的消息
@@ -1158,8 +1203,8 @@ export class MessageQueue {
             // 记录正在执行的 messageId（用于撤回中断）
             const activeMessageIds = new Set();
             for (const item of rawItems) {
-                if (item.message.messageId)
-                    activeMessageIds.add(item.message.messageId);
+                for (const messageId of this.messageIdsFor(item))
+                    activeMessageIds.add(messageId);
             }
             const activeState = {
                 baseagent: merged.message.baseagent,
@@ -1266,7 +1311,8 @@ export class MessageQueue {
         return result;
     }
     isMergeBarrier(message) {
-        return !!message.taskRecovery
+        return message.source === 'owner-inject'
+            || !!message.taskRecovery
             || !!message.asyncQuestionAnswer
             || !!message.executionPermissionOverride
             || !!message.handoffDelivery
@@ -1424,6 +1470,12 @@ export class MessageQueue {
         const earliestEnqueuedAt = this.earliestEnqueuedAt(items);
         const merged = {
             ...last.message,
+            autoMentionBatch: items.some(item => item.message.autoMentionBatch),
+            attentionPolicy: items.some(item => item.message.attentionPolicy === 'interrupt')
+                ? 'interrupt'
+                : items.some(item => item.message.attentionPolicy === 'defer')
+                    ? 'defer'
+                    : last.message.attentionPolicy,
             content: contents.join('\n'),
             items: subMessages,
             images: allImages.length > 0 ? allImages : undefined,
@@ -1558,9 +1610,7 @@ export class MessageQueue {
                 }
                 else {
                     this.activeBatches.set(queueKey, this.buildCoalescedItem(remaining));
-                    activeState.messageIds = new Set(remaining
-                        .map(part => part.message.messageId)
-                        .filter((id) => !!id));
+                    activeState.messageIds = new Set(remaining.flatMap(part => this.messageIdsFor(this.itemFromPart(part))));
                 }
                 this.persistQueuesImmediate();
             }
@@ -1651,6 +1701,22 @@ export class MessageQueue {
         }
         return { state: 'missing' };
     }
+    /** Resolve a stable inbound message ID when the caller has not yet resolved a thread session. */
+    getMessageStateByMessageId(messageId, selfAid, scope) {
+        for (const [key, queue] of this.queues) {
+            if (queue.some(item => this.partsOf(item)
+                .some(part => this.partMatchesMessage(part, messageId, selfAid, key)
+                && this.partMatchesScope(part, scope))))
+                return { state: 'queued' };
+        }
+        for (const [key, item] of this.activeBatches) {
+            if (this.partsOf(item)
+                .some(part => this.partMatchesMessage(part, messageId, selfAid, key)
+                && this.partMatchesScope(part, scope)))
+                return { state: 'active' };
+        }
+        return { state: 'missing' };
+    }
     /** Live admission state, including work that arrived after an older gate. */
     getSessionSnapshot(sessionKey) {
         let queued = 0;
@@ -2129,6 +2195,27 @@ export class MessageQueue {
         }
         return true;
     }
+    async interruptForPriority(sessionId) {
+        for (const [queueKey, active] of this.activeBatches) {
+            if (!this.matchesSession(queueKey, sessionId))
+                continue;
+            if (!this.interruptCallback)
+                throw new Error('Interrupt callback is unavailable');
+            this.interruptFailures.delete(queueKey);
+            this.eventBus?.publish({
+                type: 'task:interrupted', sessionId, reason: 'new_message',
+                agentName: this.processingAgent.get(queueKey),
+                taskId: this.activeStates.get(queueKey)?.taskId,
+                generation: this.activeStates.get(queueKey)?.generation,
+                causation: active.message.causation,
+            });
+            await this.triggerInterrupt(queueKey, sessionId, this.activeStates.get(queueKey)?.baseagent, this.processingAgent.get(queueKey), 'new_message', undefined, true);
+            const failure = this.interruptFailures.get(queueKey);
+            this.interruptFailures.delete(queueKey);
+            if (failure)
+                throw failure;
+        }
+    }
 }
 function abortError(reason) {
     if (reason instanceof Error)