evolcore 0.0.21 → 0.0.23

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

@@ -101,6 +101,8 @@ export class MessageBridge {
     processOwnersProvider;
     debouncers = new Map();
     defaultDebounce;
+    /** Serializes session selection/renewal with inbound log admission per route. */
+    admissionLocks = new Map();
     agentRegistry;
     bootstrapService;
     menuDeduper = new MenuRequestDeduper();
@@ -724,6 +726,7 @@ export class MessageBridge {
     register(channelName, onMessage, sendReply, adapter, channelType) {
         const effectiveChannelType = channelType || channelName;
         onMessage(async (msg) => {
+            let releaseAdmission;
             let releaseSessionIngress;
             const releaseIngress = () => {
                 releaseSessionIngress?.();
@@ -754,6 +757,12 @@ export class MessageBridge {
                 const conversationId = chatType === 'group' ? (msg.groupId || msg.channelId) : msg.peerId;
                 const selfAid = msg.selfAID || owningAgent?.aid || parsedChannelKey?.selfAID;
                 const resolvedChannelType = msg.channelType || parsedChannelKey?.type || effectiveChannelType;
+                const admissionRoute = [
+                    resolvedChannelType,
+                    selfAid || '',
+                    msg.channelId,
+                    msg.threadId || '',
+                ].join('#');
                 const trustedHandoffEcho = msg.source === 'handoff'
                     && resolvedChannelType === 'aun'
                     && !!selfAid
@@ -1034,6 +1043,12 @@ export class MessageBridge {
                     && !executionPermissionOverride
                     && !parseFullAccessCommand(cmdContent).matched
                     && this.cmdHandler.isCommand(cmdContent);
+                if (isCmd && /^\/new(?:\s|$)/i.test(cmdContent)) {
+                    // /new changes the active main-session boundary. Serialize it with
+                    // ordinary session admission so an in-flight renew cannot append or
+                    // enqueue against a superseded session after /new commits.
+                    releaseAdmission = await this.acquireAdmission(admissionRoute);
+                }
                 if (isCmd) {
                     logger.debug(`[MessageBridge] Command detected: "${cmdContent}", routing to handler`);
                     // 命令也要记录入方向 jsonl（不创建 session，直接用 chatDirPath 计算路径）
@@ -1115,6 +1130,11 @@ export class MessageBridge {
                 // 通道找不到归属时退回到 globalConfig（一般是测试场景）
                 const effectiveProjectPath = owningAgent?.projectPath
                     ?? this.defaultProjectPath;
+                // Session renewal and inbound history append form one admission
+                // transaction. Without this per-route single-flight, a second message
+                // can observe the just-renewed empty session before the first message
+                // has been appended and create another renewed session.
+                releaseAdmission = await this.acquireAdmission(admissionRoute);
                 const hadMainSession = msg.threadId ? true : this.sessionManager.hasMainSession(channelName, msg.channelId, msg.channelType || effectiveChannelType, msg.selfAID || selfAid);
                 let session = await this.sessionManager.getOrCreateSession(channelName, msg.channelId, effectiveProjectPath, msg.threadId, Object.keys(metadata).length ? metadata : undefined, this.extractTopicName(msg), msg.peerId, chatType, owningAgent?.baseagent, msg.selfAID, msg.channelType || effectiveChannelType, msg.peerType, identity);
                 if (session.threadId && typeof this.messageQueue.reserveSessionIngress === 'function') {
@@ -1244,6 +1264,12 @@ export class MessageBridge {
                 }
                 if (!handoffCandidate)
                     appendMessageLog(inboundEntry.chatDir, inboundEntry.entry);
+                // The authoritative session choice is now paired with its first
+                // conversation record. Release before waiting for queue completion so
+                // later group messages can still exercise the normal interrupt/FIFO
+                // policy instead of being serialized behind the whole model turn.
+                releaseAdmission?.();
+                releaseAdmission = undefined;
                 // 6. ACK + debounce/enqueue
                 //    ACK 在到达时立即做（每条独立 ACK），不等合并
                 //    Interrupt 模式（单聊）→ 入队前 debounce 合并
@@ -1305,10 +1331,28 @@ export class MessageBridge {
                 logger.error(`[MessageBridge] Error in onMessage handler for ${channelName}:`, error);
             }
             finally {
+                releaseAdmission?.();
                 releaseIngress();
             }
         });
     }
+    async acquireAdmission(key) {
+        const previous = this.admissionLocks.get(key) ?? Promise.resolve();
+        let release;
+        const current = new Promise(resolve => { release = resolve; });
+        const tail = previous.then(() => current);
+        this.admissionLocks.set(key, tail);
+        await previous;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            release();
+            if (this.admissionLocks.get(key) === tail)
+                this.admissionLocks.delete(key);
+        };
+    }
     // ── Menu Protocol ──
     extractTopicName(msg) {
         const raw = msg.topicName
@@ -1717,7 +1761,22 @@ export class MessageBridge {
         if (!this.cmdHandler.isCommand(content))
             return false;
         logger.info(`[${channel}] ${channelId}: ${content}${source === 'card-trigger' ? ' [card]' : ''}`);
-        const cmdResult = await this.cmdHandler.handle(content, channel, channelId, (_cid, text, opts) => sendReply(text), userId, threadId, chatType, source, messageId, selfAID, authSubject?.identity, authSubject, replyContext);
+        const adapter = this.processor.getChannelInfo?.(channel)?.adapter;
+        const cmdResult = await this.cmdHandler.handle(content, channel, channelId, async (_cid, text, opts, updatePayload) => {
+            if (updatePayload && adapter?.send) {
+                const envelope = buildEnvelope({
+                    taskId: `cmd-update-${randomBytes(5).toString('hex')}`,
+                    channel,
+                    channelId,
+                    agentName: this.agentRegistry?.resolveByChannel(channel)?.name ?? '<unknown>',
+                    chatmode: 'interactive',
+                    replyContext: opts ?? replyContext,
+                });
+                await adapter.send(envelope, updatePayload);
+                return;
+            }
+            await sendReply(text, opts, updatePayload);
+        }, userId, threadId, chatType, source, messageId, selfAID, authSubject?.identity, authSubject, replyContext);
         logger.debug(`[MessageBridge] handleCommand: result type=${typeof cmdResult}`);
         if (cmdResult === undefined)
             return false;
@@ -1735,7 +1794,6 @@ export class MessageBridge {
                 return true;
             }
             // 出站走 adapter.send 统一入口
-            const adapter = this.processor.getChannelInfo?.(channel)?.adapter;
             let responseSessionId;
             try {
                 const responseSession = threadId

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

@@ -233,6 +233,39 @@ export function messageLogPath(chatDir) {
 export function hasMessageLogOperation(chatDir, operationId) {
     return findMessageLogOperationMessageId(chatDir, operationId) !== undefined;
 }
+/** Find the newest completed outbound operation whose ID starts with prefix. */
+export function findLatestMessageLogOperation(chatDir, operationPrefix) {
+    const file = messageLogPath(chatDir);
+    if (!fs.existsSync(file))
+        return undefined;
+    let latest;
+    try {
+        for (const line of fs.readFileSync(file, 'utf-8').split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry?.dir !== 'out'
+                    || typeof entry.operationId !== 'string'
+                    || (!entry.operationId.startsWith(operationPrefix))
+                    || typeof entry.msgId !== 'string'
+                    || !entry.msgId)
+                    continue;
+                const ts = typeof entry.ts === 'number' && Number.isFinite(entry.ts) ? entry.ts : 0;
+                if (!latest || ts >= latest.ts) {
+                    latest = { messageId: entry.msgId, operationId: entry.operationId, ts };
+                }
+            }
+            catch {
+                // skip malformed message log lines
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return latest;
+}
 export function findMessageLogOperationMessageId(chatDir, operationId) {
     const file = messageLogPath(chatDir);
     if (!fs.existsSync(file))

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

@@ -88,6 +88,17 @@ export class MessageQueue {
                 this.markActiveTerminal(event.sessionId, event.reason || 'interrupted');
             }
         });
+        subscribe.call(eventBus, 'task:started', event => {
+            if (!('sessionId' in event) || !event.sessionId)
+                return;
+            const taskEvent = event;
+            for (const [queueKey, state] of this.activeStates) {
+                if (this.matchesSession(queueKey, taskEvent.sessionId)) {
+                    state.taskId = taskEvent.taskId;
+                    state.generation = taskEvent.generation;
+                }
+            }
+        });
         subscribe.call(eventBus, 'task:completed', event => {
             if ('sessionId' in event && event.sessionId)
                 this.markActiveTerminal(event.sessionId, 'completed');
@@ -223,6 +234,7 @@ export class MessageQueue {
         }
         const tmp = `${this.dedupPath}.tmp-${process.pid}-${Date.now()}-${this.enqueueSequence}`;
         let fd;
+        let renamed = false;
         try {
             fs.mkdirSync(path.dirname(this.dedupPath), { recursive: true });
             const content = Buffer.from(JSON.stringify({
@@ -242,20 +254,22 @@ export class MessageQueue {
             fs.closeSync(fd);
             fd = undefined;
             fs.renameSync(tmp, this.dedupPath);
-            const persistedFd = fs.openSync(this.dedupPath, 'r');
-            try {
-                fs.fsyncSync(persistedFd);
-            }
-            finally {
-                fs.closeSync(persistedFd);
-            }
+            renamed = true;
             if (process.platform !== 'win32') {
-                const directoryFd = fs.openSync(path.dirname(this.dedupPath), 'r');
                 try {
-                    fs.fsyncSync(directoryFd);
+                    const directoryFd = fs.openSync(path.dirname(this.dedupPath), 'r');
+                    try {
+                        fs.fsyncSync(directoryFd);
+                    }
+                    finally {
+                        fs.closeSync(directoryFd);
+                    }
                 }
-                finally {
-                    fs.closeSync(directoryFd);
+                catch (error) {
+                    // The file contents were already fsynced before rename. A platform
+                    // that cannot fsync directory metadata must not make a committed
+                    // dedup claim look uncommitted to the caller.
+                    logger.warn(`[Queue] Durable dedup ledger directory fsync unavailable after commit: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
             return true;
@@ -268,11 +282,13 @@ export class MessageQueue {
                 }
                 catch { }
             }
-            try {
-                fs.unlinkSync(tmp);
+            if (!renamed) {
+                try {
+                    fs.unlinkSync(tmp);
+                }
+                catch { }
             }
-            catch { }
-            return false;
+            return renamed;
         }
     }
     hasEnqueuedMessage(sessionKey, messageId, selfAID) {
@@ -623,6 +639,8 @@ export class MessageQueue {
                 sessionId: sessionKey,
                 reason: 'daemon_restart',
                 agentName,
+                taskId: this.activeStates.get(queueKey)?.taskId,
+                generation: this.activeStates.get(queueKey)?.generation,
                 causation: item.message.causation,
             });
             barriers.push(this.triggerInterrupt(queueKey, sessionKey, this.activeStates.get(queueKey)?.baseagent, agentName, 'daemon_restart'));
@@ -1022,6 +1040,8 @@ export class MessageQueue {
                         sessionId: sessionKey,
                         reason: 'new_message',
                         agentName: this.processingAgent.get(queueKey),
+                        taskId: this.activeStates.get(queueKey)?.taskId,
+                        generation: this.activeStates.get(queueKey)?.generation,
                         causation: this.activeBatches.get(queueKey)?.message.causation,
                     });
                     if (this.interruptCallback) {
@@ -1518,6 +1538,8 @@ export class MessageQueue {
                 sessionId: sessionKey,
                 reason: 'recalled',
                 agentName,
+                taskId: activeState?.taskId,
+                generation: activeState?.generation,
                 causation: active?.message.causation,
             });
             const barrier = this.interruptCallback
@@ -1766,6 +1788,8 @@ export class MessageQueue {
                     sessionId: sessionKey,
                     reason: 'stop',
                     agentName: name,
+                    taskId: this.activeStates.get(queueKey)?.taskId,
+                    generation: this.activeStates.get(queueKey)?.generation,
                     causation: this.activeBatches.get(queueKey)?.message.causation,
                 });
                 if (this.interruptCallback) {
@@ -2038,6 +2062,8 @@ export class MessageQueue {
             sessionId: sessionKey,
             reason: 'new_message',
             agentName: targetAgentName,
+            taskId: this.activeStates.get(targetQueueKey)?.taskId,
+            generation: this.activeStates.get(targetQueueKey)?.generation,
             causation: this.activeBatches.get(targetQueueKey)?.message.causation,
         });
         if (this.interruptCallback) {