@ai-setting/roy-agent-cli 1.7.56 → 1.7.57

package/dist/index.js

@@ -364,25 +364,46 @@ var exports_stream_output_service = {};
 __export(exports_stream_output_service, {
   streamAbortSignal: () => streamAbortSignal,
   resetStreamAbort: () => resetStreamAbort,
+  isStreamAborted: () => isStreamAborted,
   hasNumericUsage: () => hasNumericUsage,
   abortStream: () => abortStream,
+  __resetAllStreamAbortForTest: () => __resetAllStreamAbortForTest,
   StreamOutputService: () => StreamOutputService,
   COLORS: () => COLORS
 });
 import chalk2 from "chalk";
 import { createLogger as createLogger2, TracedAs as TracedAs2 } from "@ai-setting/roy-agent-core";
-function resetStreamAbort() {
-  streamAbortSignal.aborted = false;
+function resetStreamAbort(scope) {
+  if (scope === undefined) {
+    streamAbortSignal.aborted = false;
+    return;
+  }
+  abortedRuns.delete(scope);
 }
-function abortStream() {
-  streamAbortSignal.aborted = true;
+function abortStream(scope) {
+  if (scope === undefined) {
+    streamAbortSignal.aborted = true;
+    return;
+  }
+  abortedRuns.add(scope);
+}
+function isStreamAborted(scope) {
+  if (streamAbortSignal.aborted)
+    return true;
+  if (scope === undefined)
+    return false;
+  return abortedRuns.has(scope);
+}
+function __resetAllStreamAbortForTest() {
+  streamAbortSignal.aborted = false;
+  abortedRuns.clear();
 }
 function hasNumericUsage(usage) {
   if (!usage)
     return false;
   return typeof usage.promptTokens === "number" || typeof usage.completionTokens === "number" || typeof usage.totalTokens === "number" || typeof usage.cacheRead === "number" || typeof usage.cacheWrite === "number" || typeof usage.promptTokensTotal === "number";
 }
-var logger2, COLORS, streamAbortSignal, StreamOutputService;
+var logger2, COLORS, streamAbortSignal, abortedRuns, StreamOutputService;
 var init_stream_output_service = __esm(() => {
   init_markdown_renderer();
   logger2 = createLogger2("stream-output");
@@ -405,6 +426,7 @@ var init_stream_output_service = __esm(() => {
   streamAbortSignal = {
     aborted: false
   };
+  abortedRuns = new Set;
   StreamOutputService = class StreamOutputService {
     fullText = "";
     fullReasoning = "";
@@ -420,6 +442,9 @@ var init_stream_output_service = __esm(() => {
     reasoningClosedByText = false;
     chunkCallback = undefined;
     silent = false;
+    sessionFilter = undefined;
+    acceptsSidelessEvents = true;
+    runId = undefined;
     constructor(options = {}) {
       this.options = options;
       this.silent = options.silent ?? false;
@@ -434,6 +459,15 @@ var init_stream_output_service = __esm(() => {
     setChunkCallback(cb) {
       this.chunkCallback = cb;
     }
+    setSessionFilter(sessionId) {
+      this.sessionFilter = sessionId;
+    }
+    setAcceptsSidelessEvents(accepts) {
+      this.acceptsSidelessEvents = accepts;
+    }
+    setRunId(runId) {
+      this.runId = runId;
+    }
     emitChunk(event) {
       if (!this.chunkCallback)
         return;
@@ -454,7 +488,8 @@ var init_stream_output_service = __esm(() => {
       console.log(message);
     }
     checkAbort() {
-      if (streamAbortSignal.aborted) {
+      const aborted = this.runId !== undefined ? isStreamAborted(this.runId) : streamAbortSignal.aborted;
+      if (aborted) {
         this.logStdout(`
 ${COLORS.system("[已中断]")}
 `);
@@ -462,7 +497,25 @@ ${COLORS.system("[已中断]")}
       }
       return false;
     }
+    extractEventSessionId(event) {
+      const fromMeta = event?.metadata?.sessionId;
+      if (typeof fromMeta === "string" && fromMeta.length > 0)
+        return fromMeta;
+      const fromPayload = event?.payload?.metadata?.sessionId;
+      if (typeof fromPayload === "string" && fromPayload.length > 0)
+        return fromPayload;
+      return;
+    }
     handleEvent(event) {
+      if (this.sessionFilter !== undefined) {
+        const eventSessionId = this.extractEventSessionId(event);
+        if (eventSessionId === undefined) {
+          if (!this.acceptsSidelessEvents)
+            return;
+        } else if (eventSessionId !== this.sessionFilter) {
+          return;
+        }
+      }
       if (this.checkAbort()) {
         return;
       }
@@ -9585,7 +9638,7 @@ class CliQuietModeService {
 // package.json
 var package_default = {
   name: "@ai-setting/roy-agent-cli",
-  version: "1.7.56",
+  version: "1.7.57",
   type: "module",
   description: "CLI for roy-agent - Non-interactive command execution",
   main: "./dist/index.js",
@@ -11238,6 +11291,9 @@ class QueryExecutor {
     showToolResults: false
   };
   _pendingContextConfig = null;
+  _pendingSessionScope = undefined;
+  _pendingAcceptsSideless = undefined;
+  _sidelessPolicyExplicit = false;
   _pendingChunkCallback = undefined;
   failureNotifier;
   constructor(options) {
@@ -11276,6 +11332,14 @@ class QueryExecutor {
       this.streamService.setChunkCallback(this._pendingChunkCallback);
       this._pendingChunkCallback = undefined;
     }
+    if (this._pendingAcceptsSideless !== undefined) {
+      this.streamService.setAcceptsSidelessEvents(this._pendingAcceptsSideless);
+      this._pendingAcceptsSideless = undefined;
+    }
+    if (this._pendingSessionScope !== undefined) {
+      this.streamService.setSessionFilter(this._pendingSessionScope);
+      this.streamService.setRunId(this._pendingSessionScope);
+    }
     if (this._pendingContextConfig) {
       this.streamService.setContextInfo(this._pendingContextConfig.contextWindow, this._pendingContextConfig.contextWindow * this._pendingContextConfig.thresholdRatio);
       this._pendingContextConfig = null;
@@ -11301,6 +11365,18 @@ class QueryExecutor {
       this._pendingChunkCallback = cb;
     }
   }
+  setSessionScope(sessionId) {
+    this._pendingSessionScope = sessionId;
+    if (this.streamService) {
+      this.streamService.setSessionFilter(sessionId);
+      this.streamService.setRunId(sessionId);
+    }
+  }
+  setAcceptsSidelessEvents(accepts) {
+    this._pendingAcceptsSideless = accepts;
+    this._sidelessPolicyExplicit = true;
+    this.streamService?.setAcceptsSidelessEvents(accepts);
+  }
   handleEvent(event) {
     if (event.type === "context.threshold_exceeded" && !this.quiet) {
       const payload = event.payload;
@@ -11321,6 +11397,13 @@ class QueryExecutor {
       showToolResults: streamOptions?.showToolResults ?? this.streamOptions.showToolResults
     };
     this.subscribeToEvents(options);
+    if (sessionId) {
+      this.streamService?.setSessionFilter(sessionId);
+      this.streamService?.setRunId(sessionId);
+      if (!this._sidelessPolicyExplicit) {
+        this.streamService?.setAcceptsSidelessEvents(true);
+      }
+    }
     this.streamService?.reset();
     if (!this.quiet) {
       this.output.info(`执行: ${message}`);
@@ -11695,6 +11778,10 @@ import {
 } from "@ai-setting/roy-agent-core";
 
 // src/commands/shared/event-handler.ts
+import {
+  getEnvContext,
+  runWithEnvContextAsync
+} from "@ai-setting/roy-agent-core/env";
 import { TracedAs as TracedAs5 } from "@ai-setting/roy-agent-core";
 import { notifyReactFailure as notifyReactFailure2 } from "@ai-setting/roy-agent-core/env/error-reply";
 function parseLarkPerTaskChatId(contextJson) {
@@ -11716,6 +11803,8 @@ var NOTIFY_V2_TERMINAL_TYPES = new Set([
 ]);
 
 class EventHandler {
+  static DEFAULT_LANE_KEY = "__default__";
+  static DEFAULT_MAX_CONCURRENT_SESSIONS = 4;
   env;
   eventTypes;
   onEvent;
@@ -11723,10 +11812,25 @@ class EventHandler {
   formatter;
   isIdle;
   idleCheckInterval;
-  queue = [];
-  isProcessing = false;
+  isSessionIdleFn = null;
+  maxConcurrentSessions;
+  lanes = new Map;
+  runningLanes = new Set;
+  laneTails = new Map;
+  get isProcessing() {
+    return this.runningLanes.size > 0;
+  }
+  chatSessionCache = new Map;
+  inFlightCount = 0;
+  legacyQueue = [];
+  get queue() {
+    return this.legacyQueue;
+  }
   isStopped = false;
   unsubscribe = null;
+  activeSlots = 0;
+  slotWaiters = [];
+  sessionChains = new Map;
   sessionComponent = null;
   activeEventSessionId = null;
   resolvedSessionByTrigger = new Map;
@@ -11739,6 +11843,9 @@ class EventHandler {
     this.onEventWithEnv = options.onEventWithEnv;
     this.formatter = options.formatter ?? new EventMessageFormatter;
     this.isIdle = options.isIdle ?? (() => true);
+    this.isSessionIdleFn = options.isSessionIdle ?? null;
+    const maxSessions = options.maxConcurrentSessions;
+    this.maxConcurrentSessions = typeof maxSessions === "number" && Number.isFinite(maxSessions) && maxSessions >= 1 ? Math.floor(maxSessions) : EventHandler.DEFAULT_MAX_CONCURRENT_SESSIONS;
     this.idleCheckInterval = options.idleCheckInterval ?? 100;
     this.sessionComponent = options.sessionComponent ?? null;
     this.eventStore = options.eventStore ?? null;
@@ -11776,8 +11883,13 @@ class EventHandler {
       this.unsubscribe();
       this.unsubscribe = null;
     }
-    this.queue = [];
-    this.isProcessing = false;
+    this.lanes.clear();
+    this.legacyQueue = [];
+    this.laneTails.clear();
+    const waiters = this.slotWaiters.splice(0, this.slotWaiters.length);
+    for (const w of waiters)
+      w();
+    this.activeSlots = 0;
     this.clearActiveSession();
   }
   async handleEvent(event) {
@@ -11899,77 +12011,218 @@ class EventHandler {
       await this.onEvent(formatted.message);
     }
   }
+  laneKeyFor(item) {
+    if (item.chatId)
+      return item.chatId;
+    if (item.triggerSessionId)
+      return `trigger:${item.triggerSessionId}`;
+    return EventHandler.DEFAULT_LANE_KEY;
+  }
   enqueue(formattedEvent) {
     if (this.isStopped) {
       return;
     }
-    this.queue.push(formattedEvent);
-    if (!this.isProcessing) {
-      this.processQueue();
+    const item = { ...formattedEvent };
+    if (!item.envContext) {
+      item.envContext = getEnvContext();
+    }
+    const laneKey = this.laneKeyFor(item);
+    const lane = this.lanes.get(laneKey);
+    if (lane) {
+      lane.push(item);
+    } else {
+      this.lanes.set(laneKey, [item]);
     }
+    this.scheduleLane(laneKey);
   }
   getQueueLength() {
-    return this.queue.length;
+    let total = this.legacyQueue.length + this.inFlightCount;
+    for (const lane of this.lanes.values()) {
+      total += lane.length;
+    }
+    return total;
   }
   isQueueEmpty() {
-    return this.queue.length === 0;
+    return this.getQueueLength() === 0;
   }
-  async processQueue() {
-    this.isProcessing = true;
-    const chatSessionCache = new Map;
-    while (!this.isStopped && this.queue.length > 0) {
-      await this.waitForIdle();
-      if (this.isStopped) {
-        break;
+  isSessionIdle(laneKey) {
+    return !this.runningLanes.has(laneKey);
+  }
+  getRunningLaneKeys() {
+    return Array.from(this.runningLanes);
+  }
+  scheduleLane(laneKey) {
+    if (this.isStopped)
+      return;
+    if (this.runningLanes.has(laneKey))
+      return;
+    this.runningLanes.add(laneKey);
+    const tail = this.runLane(laneKey).catch((err) => {
+      console.error(`[EventHandler] lane ${laneKey} 处理异常:`, err);
+    }).finally(() => {
+      this.runningLanes.delete(laneKey);
+      this.laneTails.delete(laneKey);
+      const rest = this.lanes.get(laneKey);
+      if (rest && rest.length > 0) {
+        this.scheduleLane(laneKey);
       }
-      const item = this.queue.shift();
-      if (!item) {
+    });
+    this.laneTails.set(laneKey, tail);
+  }
+  async runLane(laneKey) {
+    while (!this.isStopped) {
+      const lane = this.lanes.get(laneKey);
+      if (!lane || lane.length === 0) {
         break;
       }
-      let sessionId = null;
-      if (item.chatId && this.sessionComponent) {
-        const cached = chatSessionCache.get(item.chatId);
-        if (cached) {
-          sessionId = cached;
-        } else {
-          sessionId = await this.ensureChatSession(item.chatId);
-          if (sessionId) {
-            chatSessionCache.set(item.chatId, sessionId);
+      const head = lane[0];
+      const sessionId = await runWithEnvContextAsync(head.envContext, () => this.resolveSessionForItem(laneKey, head));
+      if (this.isStopped)
+        break;
+      const canonicalKey = sessionId ?? laneKey;
+      if (canonicalKey !== laneKey) {
+        const mine = this.lanes.get(laneKey) ?? [];
+        if (mine.length > 0) {
+          const target = this.lanes.get(canonicalKey);
+          if (target) {
+            target.push(...mine);
+          } else {
+            this.lanes.set(canonicalKey, mine);
           }
+          this.lanes.delete(laneKey);
+          this.scheduleLane(canonicalKey);
         }
-        if (!sessionId) {
-          console.warn(`[EventHandler] Failed to ensure chat-keyed session (chatId=${item.chatId}), ` + `falling back to trigger_session_id path`);
-          sessionId = await this.ensureActiveSession(item.triggerSessionId);
-        }
-      } else {
-        sessionId = await this.ensureActiveSession(item.triggerSessionId);
+        return;
       }
+      await this.waitForIdle(sessionId ?? laneKey);
+      if (this.isStopped)
+        break;
+      const claimKey = sessionId ?? laneKey;
+      const releaseClaim = await this.claimSession(claimKey);
       if (this.isStopped) {
+        releaseClaim();
         break;
       }
-      if (sessionId) {
-        item.eventSessionId = sessionId;
+      await this.acquireSlot();
+      if (this.isStopped) {
+        releaseClaim();
+        this.releaseSlot();
+        break;
       }
       try {
+        const item = lane.shift();
+        if (!item)
+          break;
+        this.inFlightCount++;
+        try {
+          await this.processItem(item, sessionId);
+        } finally {
+          this.inFlightCount--;
+        }
+      } finally {
+        releaseClaim();
+        this.releaseSlot();
+      }
+    }
+    const rest = this.lanes.get(laneKey);
+    if (!rest || rest.length === 0) {
+      this.lanes.delete(laneKey);
+    }
+  }
+  async resolveSessionForItem(laneKey, item) {
+    if (item.sessionResolved) {
+      return item.resolvedSessionId ?? null;
+    }
+    const resolved = await this.resolveSessionForItemUncached(laneKey, item);
+    item.sessionResolved = true;
+    item.resolvedSessionId = resolved;
+    return resolved;
+  }
+  async resolveSessionForItemUncached(laneKey, item) {
+    if (item.chatId && this.sessionComponent) {
+      const cached = this.chatSessionCache.get(item.chatId);
+      if (cached)
+        return cached;
+      let resolved = await this.ensureChatSession(item.chatId);
+      if (!resolved) {
+        console.warn(`[EventHandler] Failed to ensure chat-keyed session (chatId=${item.chatId}), ` + `falling back to trigger_session_id path`);
+        resolved = await this.ensureActiveSession(item.triggerSessionId);
+      } else {
+        this.chatSessionCache.set(item.chatId, resolved);
+      }
+      return resolved;
+    }
+    return this.ensureActiveSession(item.triggerSessionId);
+  }
+  async processItem(item, sessionId) {
+    if (sessionId) {
+      item.eventSessionId = sessionId;
+    }
+    try {
+      await runWithEnvContextAsync(item.envContext, async () => {
         if (this.onEventWithEnv) {
           await this.onEventWithEnv(item);
-          continue;
+          return;
         }
         await this.onEvent(item.message);
-      } catch (error) {
-        console.error(`[EventHandler] 处理事件失败:`, error);
-        try {
-          await notifyReactFailure2({
-            error,
-            envEvent: item.envEvent,
-            sessionId
-          });
-        } catch (notifyErr) {
-          console.error(`[EventHandler] 失败说明回飞书异常:`, notifyErr);
-        }
+      });
+    } catch (error) {
+      console.error(`[EventHandler] 处理事件失败:`, error);
+      try {
+        await notifyReactFailure2({
+          error,
+          envEvent: item.envEvent,
+          sessionId: sessionId ?? undefined
+        });
+      } catch (notifyErr) {
+        console.error(`[EventHandler] 失败说明回飞书异常:`, notifyErr);
       }
     }
-    this.isProcessing = false;
+  }
+  async processQueue() {
+    if (this.isStopped)
+      return;
+    if (this.legacyQueue.length > 0) {
+      const pending = this.legacyQueue.splice(0, this.legacyQueue.length);
+      for (const item of pending) {
+        if (!item.envContext) {
+          item.envContext = getEnvContext();
+        }
+        const laneKey = this.laneKeyFor(item);
+        const lane = this.lanes.get(laneKey);
+        if (lane)
+          lane.push(item);
+        else
+          this.lanes.set(laneKey, [item]);
+      }
+    }
+    for (const [laneKey, lane] of Array.from(this.lanes.entries())) {
+      if (lane.length > 0)
+        this.scheduleLane(laneKey);
+    }
+    const tails = Array.from(this.laneTails.values());
+    if (tails.length > 0) {
+      await Promise.all(tails.map((t) => t.catch(() => {
+        return;
+      })));
+    }
+  }
+  async acquireSlot() {
+    if (this.activeSlots < this.maxConcurrentSessions) {
+      this.activeSlots++;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.slotWaiters.push(resolve);
+    });
+    this.activeSlots++;
+  }
+  releaseSlot() {
+    if (this.activeSlots > 0)
+      this.activeSlots--;
+    const next = this.slotWaiters.shift();
+    if (next)
+      next();
   }
   async ensureActiveSession(triggerSessionIdOverride) {
     if (!this.sessionComponent)
@@ -12079,6 +12332,7 @@ class EventHandler {
   clearActiveSession() {
     this.activeEventSessionId = null;
     this.resolvedSessionByTrigger.clear();
+    this.chatSessionCache.clear();
   }
   cacheResolvedSession(triggerSessionIdOverride, sessionId) {
     if (triggerSessionIdOverride && sessionId) {
@@ -12088,11 +12342,38 @@ class EventHandler {
   getActiveEventSessionId() {
     return this.activeEventSessionId;
   }
-  async waitForIdle() {
-    while (!this.isStopped && !this.isIdle()) {
+  async waitForIdle(sessionId) {
+    while (!this.isStopped && !this.isLaneIdle(sessionId)) {
       await this.sleep(this.idleCheckInterval);
     }
   }
+  isLaneIdle(sessionId) {
+    if (this.isSessionIdleFn && sessionId) {
+      return this.isSessionIdleFn(sessionId);
+    }
+    return this.isIdle();
+  }
+  claimSession(sessionKey) {
+    const prev = this.sessionChains.get(sessionKey) ?? Promise.resolve();
+    let releaseFn;
+    const current = new Promise((resolve) => {
+      releaseFn = resolve;
+    });
+    const tail = prev.then(() => current);
+    this.sessionChains.set(sessionKey, tail);
+    return prev.then(() => {
+      let released = false;
+      return () => {
+        if (released)
+          return;
+        released = true;
+        releaseFn();
+        if (this.sessionChains.get(sessionKey) === tail) {
+          this.sessionChains.delete(sessionKey);
+        }
+      };
+    });
+  }
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
@@ -12187,12 +12468,24 @@ function createEventHandlerForInteractive(options) {
   const dbPath = options.dbPath ?? createDefaultEventStoreDbPath();
   const eventStore = getOrCreateEventStore(dbPath);
   const getHandlerForEsType = getHandlerForEsTypeForEnv(options.env);
+  const maxConcurrentSessions = options.maxConcurrentSessions ?? readMaxConcurrentSessionsFromEnv();
   return new EventHandler({
     ...options,
+    ...maxConcurrentSessions !== undefined ? { maxConcurrentSessions } : {},
     eventStore,
     getHandlerForEsType
   });
 }
+var MAX_CONCURRENT_SESSIONS_ENV = "ROY_AGENT_MAX_CONCURRENT_SESSIONS";
+function readMaxConcurrentSessionsFromEnv(env = process.env) {
+  const raw = env[MAX_CONCURRENT_SESSIONS_ENV];
+  if (raw === undefined || raw.trim() === "")
+    return;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1)
+    return;
+  return Math.max(1, Math.floor(parsed));
+}
 
 // src/commands/shared/esc-active-descendant.ts
 function hasActiveDescendants(env, parentSessionId) {
@@ -12865,7 +13158,8 @@ var USER_PROMPT = COLORS.accent("❯ ");
 class REPL {
   rl;
   options;
-  isExecuting = false;
+  executingSessions = new Map;
+  static LEGACY_SESSION_KEY = "__legacy_isExecuting__";
   replMode = "ready";
   statusBarCtx = {};
   isAltEnterPending = false;
@@ -13058,7 +13352,10 @@ ${COLORS.system("[正在中断...]")}`);
           }
         }
         abortStream();
-        this.isExecuting = false;
+        for (const sid of this.getExecutingSessionIds()) {
+          abortStream(sid);
+        }
+        this.abortAllExecutingSessions();
         console.log(`${COLORS.system("[已中断，可以继续输入]")}`);
       } else {
         console.log(`
@@ -13143,7 +13440,8 @@ ${COLORS.system("[没有正在执行的请求]")}`);
           this.inkApi = api;
         },
         onSubmit: async (input) => {
-          this.isExecuting = true;
+          const inkSessionId = this.options.sessionId;
+          this.markSessionExecuting(inkSessionId, true);
           inkApiRef?.setMode("executing");
           try {
             await this.options.onExecute(input);
@@ -13161,7 +13459,7 @@ ${COLORS.system("[没有正在执行的请求]")}`);
             inkApiRef?.appendMessage({ role: "system", content: `[Error] ${msg}` });
             throw err;
           } finally {
-            this.isExecuting = false;
+            this.markSessionExecuting(inkSessionId, false);
           }
         },
         onCommand: async (cmd) => {
@@ -13314,7 +13612,8 @@ ${COLORS.error("❓ 未知命令: /" + cmd + "}")}`);
     }
   }
   async handleMessage(message) {
-    if (this.isExecuting) {
+    const inputSessionId = this.options.sessionId;
+    if (!this.isSessionIdle(inputSessionId)) {
       console.log(`
 ${COLORS.system("⏳ 上一次请求尚未完成，请稍候...")}
 `);
@@ -13381,7 +13680,7 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
         };
       }
     }
-    this.currentAgentContext = {
+    const agentContext = {
       agentType: agentFromEvent,
       pluginEnabled,
       envEvent: envEventForAgent,
@@ -13389,9 +13688,12 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
       eventSessionId,
       systemPrompt: envEvent.metadata?.systemPrompt
     };
-    await this.executeInternal(message, { showPrompt: true });
+    await this.executeInternal(message, {
+      showPrompt: true,
+      sessionId: eventSessionId,
+      agentContext
+    });
   }
-  currentAgentContext = undefined;
   lastReplyChannel = undefined;
   lastReplyChannelByChat = new Map;
   static REPLY_CHANNEL_CHAT_CACHE_MAX = 100;
@@ -13410,7 +13712,56 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
     }
   }
   isIdle() {
-    return !this.isExecuting;
+    return !this.anySessionBusy();
+  }
+  anySessionBusy() {
+    for (const count of this.execSet().values()) {
+      if (count > 0)
+        return true;
+    }
+    return false;
+  }
+  execSet() {
+    if (!this.executingSessions)
+      this.executingSessions = new Map;
+    return this.executingSessions;
+  }
+  get isExecuting() {
+    return this.anySessionBusy();
+  }
+  set isExecuting(executing) {
+    if (!executing) {
+      this.execSet().clear();
+      return;
+    }
+    this.execSet().set(REPL.LEGACY_SESSION_KEY, 1);
+  }
+  markSessionExecuting(sessionId, executing) {
+    const counts = this.execSet();
+    if (executing) {
+      counts.set(sessionId, (counts.get(sessionId) ?? 0) + 1);
+      return;
+    }
+    const current = counts.get(sessionId) ?? 0;
+    if (current <= 1) {
+      counts.delete(sessionId);
+    } else {
+      counts.set(sessionId, current - 1);
+    }
+  }
+  isSessionIdle(sessionId) {
+    return (this.execSet().get(sessionId) ?? 0) <= 0;
+  }
+  getExecutingSessionIds() {
+    const ids = [];
+    for (const [sid, count] of this.execSet().entries()) {
+      if (count > 0)
+        ids.push(sid);
+    }
+    return ids;
+  }
+  abortAllExecutingSessions() {
+    this.execSet().clear();
   }
   setMode(mode, detail) {
     this.replMode = mode;
@@ -13433,30 +13784,37 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
     }));
   }
   async executeInternal(message, options) {
-    this.isExecuting = true;
-    this.setMode("executing");
-    const agentContext = this.currentAgentContext;
-    this.currentAgentContext = undefined;
+    const execSessionId = options.sessionId ?? this.options.sessionId;
+    const agentContext = {
+      ...options.agentContext,
+      eventSessionId: options.agentContext?.eventSessionId ?? execSessionId
+    };
     resetStreamAbort();
     const provider = getTracerProvider3();
     const tracer = provider.getTracer("roy-tracer");
-    const existingContext = provider.getGlobalContext();
+    const payloadTraceContext = agentContext?.envEvent?.metadata?.traceContext;
+    const existingContext = payloadTraceContext ?? provider.getGlobalContext();
     let rootSpan;
     let traceId;
-    if (existingContext) {
-      rootSpan = tracer.startSpan("interactive.execute", {
-        parent: existingContext
-      });
-      traceId = existingContext.traceId;
-    } else {
-      rootSpan = tracer.startSpan("interactive.execute");
-      traceId = rootSpan.spanContext.traceId;
-      provider.setGlobalContext(rootSpan.spanContext);
-    }
-    console.log(`${COLORS.system("[Trace] " + traceId)}`);
-    console.log(`${COLORS.progress("[thinking...]")}`);
+    let runTraceContext = existingContext;
     try {
-      await this.options.onExecute(message, traceId, agentContext);
+      this.markSessionExecuting(execSessionId, true);
+      this.setMode("executing");
+      await provider.withGlobalContext(runTraceContext, async () => {
+        if (existingContext) {
+          rootSpan = tracer.startSpan("interactive.execute", {
+            parent: existingContext
+          });
+          traceId = existingContext.traceId;
+        } else {
+          rootSpan = tracer.startSpan("interactive.execute");
+          traceId = rootSpan.spanContext.traceId;
+          runTraceContext = rootSpan.spanContext;
+        }
+        console.log(`${COLORS.system("[Trace] " + traceId)}`);
+        console.log(`${COLORS.progress("[thinking...]")}`);
+        await this.options.onExecute(message, traceId, agentContext);
+      });
       if (this.options.onAfterExecute) {
         try {
           await this.options.onAfterExecute(this.lastUsage);
@@ -13472,7 +13830,7 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
         console.error(`
 ${COLORS.error("❌ 执行失败: " + error)}
 `);
-        rootSpan.setAttribute("error", String(error));
+        rootSpan?.setAttribute("error", String(error));
         try {
           await notifyReactFailure3({
             error,
@@ -13484,14 +13842,15 @@ ${COLORS.error("❌ 执行失败: " + error)}
         }
       }
     } finally {
-      rootSpan.end();
-      if (existingContext) {
-        provider.setGlobalContext(existingContext);
-      } else {
-        provider.setGlobalContext(undefined);
+      try {
+        provider.runInGlobalContextSync(runTraceContext, () => rootSpan?.end());
+      } catch (endErr) {
+        logger6.warn("root span end failed (ignored)", { error: String(endErr) });
+      }
+      this.markSessionExecuting(execSessionId, false);
+      if (this.isIdle()) {
+        this.setMode("ready");
       }
-      this.isExecuting = false;
-      this.setMode("ready");
       if (options.showPrompt) {
         this.redrawInputArea();
         if (this.rl) {
@@ -13661,6 +14020,9 @@ ${COLORS.error("❌ 执行失败: " + error)}
       }
     }
     abortStream();
+    for (const sid of this.getExecutingSessionIds()) {
+      abortStream(sid);
+    }
     if (this.inkApi && typeof this.inkApi.finishAssistantStream === "function") {
       try {
         this.inkApi.finishAssistantStream();
@@ -13687,7 +14049,7 @@ ${COLORS.error("❌ 执行失败: " + error)}
       }
     }
     if (isExecuting) {
-      this.isExecuting = false;
+      this.abortAllExecutingSessions();
     }
     this.setMode("ready");
     if (this.rl) {
@@ -13890,6 +14252,57 @@ function createInteractiveCommand(externalEnvService) {
           quiet: true,
           silent: useInk
         });
+        const MAX_SESSION_EXECUTORS = 16;
+        const sessionExecutors = new Map;
+        const runningTurns = new Set;
+        let sessionChunkCallback = undefined;
+        const getSessionExecutor = (sid) => {
+          if (!sid)
+            return queryExecutor;
+          const cached = sessionExecutors.get(sid);
+          if (cached) {
+            sessionExecutors.delete(sid);
+            sessionExecutors.set(sid, cached);
+            return cached;
+          }
+          const created = new QueryExecutor({
+            env,
+            sessionComponent,
+            output,
+            quiet: true,
+            silent: true
+          });
+          created.initStreamOutput(llmComponent);
+          created.setSessionScope(sid);
+          created.setAcceptsSidelessEvents(false);
+          created.setChunkCallback(sessionChunkCallback);
+          sessionExecutors.set(sid, created);
+          while (sessionExecutors.size > MAX_SESSION_EXECUTORS) {
+            let victim;
+            for (const key of sessionExecutors.keys()) {
+              if (!runningTurns.has(key)) {
+                victim = key;
+                break;
+              }
+            }
+            if (victim === undefined)
+              break;
+            const evicted = sessionExecutors.get(victim);
+            sessionExecutors.delete(victim);
+            try {
+              evicted?.dispose();
+            } catch {}
+          }
+          return created;
+        };
+        const disposeSessionExecutors = () => {
+          for (const ex of sessionExecutors.values()) {
+            try {
+              ex.dispose();
+            } catch {}
+          }
+          sessionExecutors.clear();
+        };
         let currentAgentContext = undefined;
         if (args.agent && args.agent !== "default") {
           const agentComponent = env.getComponent("agent");
@@ -13992,7 +14405,8 @@ function createInteractiveCommand(externalEnvService) {
           version: getPackageVersion(),
           useInk,
           onExecute: async (message, traceId, agentContext) => {
-            resetStreamAbort();
+            const runSessionId = agentContext?.eventSessionId;
+            resetStreamAbort(runSessionId);
             const preloadedPrompts = eventSourceSystemPrompts;
             const eventSourceSystemPrompt = preloadedPrompts.length > 0 ? joinResolvedSystemPrompts(preloadedPrompts) : undefined;
             const mergedContext = {
@@ -14007,16 +14421,27 @@ function createInteractiveCommand(externalEnvService) {
               }
             };
             const effectiveSessionId = mergedContext.eventSessionId ?? sessionId;
-            const result = await queryExecutor.execute(message, effectiveSessionId, {
-              showReasoning: args.reasoning,
-              showToolCalls: args.toolCalls,
-              showToolResults: args.toolResults
-            }, traceId, mergedContext);
-            if (result && !queryExecutor.getFullText()) {
-              console.log(result);
+            const isEventDrivenTurn = !!runSessionId && runSessionId !== sessionId;
+            const exec2 = isEventDrivenTurn ? getSessionExecutor(effectiveSessionId) : queryExecutor;
+            runningTurns.add(effectiveSessionId);
+            try {
+              const result = await exec2.execute(message, effectiveSessionId, {
+                showReasoning: args.reasoning,
+                showToolCalls: args.toolCalls,
+                showToolResults: args.toolResults
+              }, traceId, mergedContext);
+              if (result && !exec2.getFullText()) {
+                console.log(result);
+              } else if (isEventDrivenTurn) {
+                const full = exec2.getFullText();
+                if (full)
+                  console.log(full);
+              }
+              repl.setLastUsage(exec2.getLastUsage());
+              return result;
+            } finally {
+              runningTurns.delete(effectiveSessionId);
             }
-            repl.setLastUsage(queryExecutor.getLastUsage());
-            return result;
           },
           onAfterExecute: (usage) => {
             if (useInk)
@@ -14041,6 +14466,7 @@ function createInteractiveCommand(externalEnvService) {
           onSwitchSession: async (newSessionId) => {
             const result = await sessionManager.switchSession(newSessionId);
             queryExecutor.dispose();
+            disposeSessionExecutors();
             return result;
           },
           onCompact: async () => {
@@ -14090,6 +14516,7 @@ function createInteractiveCommand(externalEnvService) {
           eventTypes: ["task.background.*", "event-source.event.*"],
           formatter: new EventMessageFormatter({ prefix: "[通知]" }),
           isIdle: () => repl.isIdle(),
+          isSessionIdle: (sid) => repl.isSessionIdle(sid),
           sessionComponent,
           onEvent: async (_message) => {},
           onEventWithEnv: async (formattedEvent) => {
@@ -14123,6 +14550,20 @@ function createInteractiveCommand(externalEnvService) {
         repl.sessionManager = sessionManager;
         repl.sessionComponent = sessionComponent;
         repl._queryExecutor = queryExecutor;
+        {
+          let inkCb = null;
+          Object.defineProperty(repl, "inkChunkCallback", {
+            configurable: true,
+            get: () => inkCb,
+            set: (cb) => {
+              inkCb = cb;
+              sessionChunkCallback = cb ?? undefined;
+              for (const ex of sessionExecutors.values()) {
+                ex.setChunkCallback(sessionChunkCallback);
+              }
+            }
+          });
+        }
         await repl.start();
         process.removeListener("SIGINT", sigintHandler);
         console.log("正在清理资源...");
@@ -14134,6 +14575,7 @@ function createInteractiveCommand(externalEnvService) {
         }
         eventHandler.stop();
         queryExecutor.dispose();
+        disposeSessionExecutors();
         const esComponent = env.getComponent("event-source");
         if (esComponent) {
           const sources = esComponent.list?.();
@@ -15501,6 +15943,7 @@ async function loadHandleQuery(options, hooks) {
   const llmComponent = envService.getLLM();
   queryExecutor.initStreamOutput(llmComponent ?? null);
   const handleQuery = async (message, envEvent) => {
+    const eventTraceContext = envEvent?.metadata?.traceContext;
     const mergedContext = {
       ...agentContext,
       model: options.model,
@@ -15515,7 +15958,7 @@ async function loadHandleQuery(options, hooks) {
       showReasoning: options.reasoning ?? true,
       showToolCalls: options.toolCalls ?? true,
       showToolResults: options.toolResults ?? false
-    }, undefined, mergedContext);
+    }, eventTraceContext?.traceId, mergedContext);
     return String(result ?? "");
   };
   const taskEventHandler = new TaskEventHandler({
@@ -15592,6 +16035,7 @@ function createStreamHandleQuery(queryExecutor, sessionId, options, agentContext
           break;
       }
     });
+    const eventTraceContext = envEvent?.metadata?.traceContext;
     const mergedContext = {
       ...agentContext,
       model: options.model,
@@ -15606,7 +16050,7 @@ function createStreamHandleQuery(queryExecutor, sessionId, options, agentContext
       showReasoning: options.reasoning ?? true,
       showToolCalls: true,
       showToolResults: true
-    }, undefined, mergedContext);
+    }, eventTraceContext?.traceId, mergedContext);
     return String(result ?? "");
   };
 }