evolcore 0.0.22 → 0.0.24

package/dist/core/handoff/store.js

@@ -122,6 +122,7 @@ export class HandoffStore {
             request: {
                 payload: clonePayload(input.payload),
                 encrypt: input.encrypt,
+                ...(input.contextOnly ? { contextOnly: true } : {}),
                 ...(input.delivery ? { delivery: input.delivery } : {}),
             },
             ...(input.originAuthorization
@@ -129,7 +130,12 @@ export class HandoffStore {
                 : {}),
             causation: normalizeCausation(input.causation),
             return_policy: input.returnPolicy ?? 'required',
-            state: 'queued',
+            // Local-only requests are already available for the next target-session
+            // turn and must never enter the outbound dispatch queue.  Keep them in
+            // target_sent while waiting for the target turn to bind the context;
+            // target_context_pending is reserved for a context-only handoff after
+            // it has been consumed by a returnPolicy=none target turn.
+            state: input.contextOnly ? 'target_sent' : 'queued',
             target_message_id: null,
             response_message_id: null,
             consumed_at: null,

package/dist/core/message/im-renderer.js

@@ -227,25 +227,32 @@ export class IMRenderer {
             durationMs: opts.durationMs,
         });
     }
-    /** 发送不进入 activity/thought 历史的非终态 warning status。 */
-    async sendWarningStatus(message, subtype, details) {
+    /** 发送不进入 activity/thought 历史、也不代表执行活跃的任务级 notice。 */
+    async sendStatusNotice(message, severity = 'info', subtype, details) {
         const payload = {
-            kind: 'status.progress',
+            kind: 'status.notice',
             metadata: {
-                activityType: 'progress',
                 message,
-                severity: 'warn',
+                severity,
                 ...(subtype !== undefined && { subtype }),
                 ...(details?.missingItems !== undefined && { missingItems: details.missingItems }),
+                ...(details?.idleSec !== undefined && { idleSec: details.idleSec }),
+                ...(details?.totalEvents !== undefined && { totalEvents: details.totalEvents }),
+                ...(details?.totalToolCalls !== undefined && { totalToolCalls: details.totalToolCalls }),
+                ...(details?.lastToolName !== undefined && { lastToolName: details.lastToolName }),
             },
         };
         try {
             await this.opts.send(payload);
         }
         catch (error) {
-            logger.warn(`[IMRenderer] warning status send failed: ${error instanceof Error ? error.message : String(error)}`);
+            logger.warn(`[IMRenderer] status notice send failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /** 兼容旧调用方：发送 warning 级别的任务 notice。 */
+    async sendWarningStatus(message, subtype, details) {
+        return this.sendStatusNotice(message, 'warn', subtype, details);
+    }
     /** 添加任务生命周期边界事件，复用 activity.batch 投影路径。 */
     addLifecycle(phase, metadata, text) {
         const item = {

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

@@ -680,40 +680,6 @@ export class MessageBridge {
         }
         return d;
     }
-    availableBaseagentsFor(channelName) {
-        const owningAgent = this.agentRegistry?.resolveByChannel(channelName);
-        if (!owningAgent)
-            return [];
-        const prefix = `${owningAgent.name}::`;
-        return this.processor.getAvailableAgents()
-            .filter(key => key.startsWith(prefix))
-            .map(key => key.slice(prefix.length));
-    }
-    async alignSessionBaseagent(channelName, session) {
-        const owningAgent = this.agentRegistry?.resolveByChannel(channelName);
-        if (!owningAgent)
-            return session;
-        const available = this.availableBaseagentsFor(channelName);
-        if (available.length === 0 || available.includes(session.baseagent))
-            return session;
-        // A topic's backend binding is fenced by SessionManager and cannot be
-        // cleared as a side effect of routing alignment. Reassigning the
-        // baseagent while leaving the old provider's agentSessionId persisted
-        // would make the new runner resume an incompatible backend. Keep the
-        // binding intact and let normal baseagent-mismatch handling report it;
-        // an explicit boundary operation must perform any future migration.
-        if (session.threadId) {
-            logger.error(`[MessageBridge] Cannot align topic to another baseagent: `
-                + `session=${session.id} thread=${session.threadId} current=${session.baseagent} preferred=${owningAgent.baseagent}`);
-            return session;
-        }
-        const preferred = available.includes(owningAgent.baseagent)
-            ? owningAgent.baseagent
-            : available[0];
-        logger.warn(`[MessageBridge] Aligning unavailable session baseagent: session=${session.id} ${session.baseagent} -> ${preferred} agent=${owningAgent.name} available=${available.join(',')}`);
-        await this.sessionManager.updateSession(session.id, { baseagent: preferred });
-        return { ...session, baseagent: preferred };
-    }
     /**
      * 为渠道注册消息桥梁：入站处理管线 + 出站命令响应
      *
@@ -1140,7 +1106,6 @@ export class MessageBridge {
                 if (session.threadId && typeof this.messageQueue.reserveSessionIngress === 'function') {
                     releaseSessionIngress = this.messageQueue.reserveSessionIngress(session.id);
                 }
-                session = await this.alignSessionBaseagent(channelName, session);
                 const replyToMessageId = typeof msg.replyContext?.metadata?.refMessageId === 'string'
                     ? msg.replyContext.metadata.refMessageId
                     : msg.replyContext?.replyToMessageId ?? null;
@@ -1163,6 +1128,7 @@ export class MessageBridge {
                     content,
                     replyToMessageId,
                     isNewSession: !hadMainSession,
+                    currentBaseagent: owningAgent?.baseagent,
                     causation: inboundCausation,
                 });
                 session = renewResult.session;
@@ -1537,7 +1503,10 @@ export class MessageBridge {
                         channelId: msg.channelId,
                         args,
                     });
-                    const result = await this.cmdHandler.execMenuUpdate(this.resolveCmd(name, cmd), request.value, channel, execution.channelId, execution.subject.actorId, execution.subject.identity, execution.subject.fromControlChannel, execution.args, execution.subject);
+                    const result = await this.cmdHandler.execMenuUpdate(this.resolveCmd(name, cmd), request.value, channel, execution.channelId, execution.subject.actorId, execution.subject.identity, execution.subject.fromControlChannel, execution.args, execution.subject, 'menu', {
+                        ...(msg.replyContext ?? {}),
+                        ...(msg.threadId ? { threadId: msg.threadId } : {}),
+                    });
                     if ('error' in result)
                         throw result;
                     return menuSuccess(header, result.data);

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

@@ -234,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({
@@ -253,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;
@@ -279,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) {

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

@@ -7,8 +7,9 @@ import { renderCommandCardAsText, renderActionAsText } from '../interaction-rout
 /** A legacy adapter resolved its send call without providing a structured receipt. */
 export const LEGACY_INTERACTION_ACCEPTED = 'legacy-accepted';
 export function isInteractionSendAccepted(result) {
-    return result === LEGACY_INTERACTION_ACCEPTED
-        || (result !== false && (result.status === 'sent' || result.status === 'queued'));
+    if (result === LEGACY_INTERACTION_ACCEPTED || result === 'sent')
+        return true;
+    return result !== false && (result.status === 'sent' || result.status === 'queued');
 }
 /**
  * 构造出站消息信封
@@ -148,8 +149,10 @@ export async function sendInteractionPayload(adapter, envelope, interaction, fal
     try {
         const enriched = replyCtx ? withEnvelopeReplyContext(envelope, replyCtx) : envelope;
         const receipt = await adapter.send(enriched, payload);
+        // Preserve the historical `sent` result for void-returning adapters while
+        // still accepting the newer structured SendReceipt contract.
         if (!receipt)
-            return LEGACY_INTERACTION_ACCEPTED;
+            return 'sent';
         if (receipt.status === 'sent' && !(receipt.messageId || receipt.messages[0]?.messageId))
             return false;
         return receipt;