@openacp/cli 2026.403.8 → 2026.404.2

package/dist/index.js

@@ -3474,7 +3474,9 @@ var init_sse_manager = __esm({
           "session:updated",
           "session:deleted",
           "agent:event",
-          "permission:request"
+          "permission:request",
+          "message:queued",
+          "message:processing"
         ];
         for (const eventName of events) {
           const handler = (data) => {
@@ -3539,7 +3541,9 @@ data: ${JSON.stringify(data)}
         const sessionEvents = [
           "agent:event",
           "permission:request",
-          "session:updated"
+          "session:updated",
+          "message:queued",
+          "message:processing"
         ];
         for (const res of this.sseConnections) {
           const filter = res.sessionFilter;
@@ -8362,7 +8366,7 @@ var init_commands = __esm({
 
 // src/plugins/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard11 } from "grammy";
-import { nanoid as nanoid2 } from "nanoid";
+import { nanoid as nanoid4 } from "nanoid";
 var log30, PermissionHandler;
 var init_permissions = __esm({
   "src/plugins/telegram/permissions.ts"() {
@@ -8381,7 +8385,7 @@ var init_permissions = __esm({
       pending = /* @__PURE__ */ new Map();
       async sendPermissionRequest(session, request) {
         const threadId = Number(session.threadId);
-        const callbackKey = nanoid2(8);
+        const callbackKey = nanoid4(8);
         this.pending.set(callbackKey, {
           sessionId: session.id,
           requestId: request.id,
@@ -11182,6 +11186,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
         { sessionId: this.sessionId, exitCode: code, signal },
         "Agent process exited"
       );
+      if (signal === "SIGINT" || signal === "SIGTERM") return;
       if (code !== 0 && code !== null || signal) {
         const stderr = this.stderrCapture.getLastLines();
         this.emit("agent_event", {
@@ -11657,7 +11662,7 @@ var AgentManager = class {
 };
 
 // src/core/sessions/session.ts
-import { nanoid } from "nanoid";
+import { nanoid as nanoid2 } from "nanoid";
 
 // src/core/sessions/prompt-queue.ts
 var PromptQueue = class {
@@ -11668,21 +11673,21 @@ var PromptQueue = class {
   queue = [];
   processing = false;
   abortController = null;
-  async enqueue(text3, attachments) {
+  async enqueue(text3, attachments, routing, turnId) {
     if (this.processing) {
       return new Promise((resolve6) => {
-        this.queue.push({ text: text3, attachments, resolve: resolve6 });
+        this.queue.push({ text: text3, attachments, routing, turnId, resolve: resolve6 });
       });
     }
-    await this.process(text3, attachments);
+    await this.process(text3, attachments, routing, turnId);
   }
-  async process(text3, attachments) {
+  async process(text3, attachments, routing, turnId) {
     this.processing = true;
     this.abortController = new AbortController();
     const { signal } = this.abortController;
     try {
       await Promise.race([
-        this.processor(text3, attachments),
+        this.processor(text3, attachments, routing, turnId),
         new Promise((_, reject) => {
           signal.addEventListener("abort", () => reject(new Error("Prompt aborted")), { once: true });
         })
@@ -11700,7 +11705,7 @@ var PromptQueue = class {
   drainNext() {
     const next = this.queue.shift();
     if (next) {
-      this.process(next.text, next.attachments).then(next.resolve);
+      this.process(next.text, next.attachments, next.routing, next.turnId).then(next.resolve);
     }
   }
   clear() {
@@ -11790,6 +11795,33 @@ var PermissionGate = class {
 // src/core/sessions/session.ts
 init_log();
 import * as fs10 from "fs";
+
+// src/core/sessions/turn-context.ts
+import { nanoid } from "nanoid";
+function createTurnContext(sourceAdapterId, responseAdapterId, turnId) {
+  return {
+    turnId: turnId ?? nanoid(8),
+    sourceAdapterId,
+    responseAdapterId
+  };
+}
+function getEffectiveTarget(ctx) {
+  if (ctx.responseAdapterId === null) return null;
+  return ctx.responseAdapterId ?? ctx.sourceAdapterId;
+}
+var SYSTEM_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "session_end",
+  "system_message",
+  "session_info_update",
+  "config_option_update",
+  "commands_update",
+  "tts_strip"
+]);
+function isSystemEvent(event) {
+  return SYSTEM_EVENT_TYPES.has(event.type);
+}
+
+// src/core/sessions/session.ts
 var moduleLog = createChildLogger({ module: "session" });
 var TTS_PROMPT_INSTRUCTION = `
 
@@ -11807,7 +11839,15 @@ var VALID_TRANSITIONS = {
 var Session = class extends TypedEmitter {
   id;
   channelId;
-  threadId = "";
+  /** @deprecated Use threadIds map directly. Getter returns primary adapter's threadId. */
+  get threadId() {
+    return this.threadIds.get(this.channelId) ?? "";
+  }
+  set threadId(value) {
+    if (value) {
+      this.threadIds.set(this.channelId, value);
+    }
+  }
   agentName;
   workingDirectory;
   agentInstance;
@@ -11828,14 +11868,21 @@ var Session = class extends TypedEmitter {
   middlewareChain;
   /** Latest commands emitted by the agent — buffered before bridge connects so they're not lost */
   latestCommands = null;
+  /** Adapters currently attached to this session (including primary) */
+  attachedAdapters = [];
+  /** Per-adapter thread IDs: adapterId → threadId */
+  threadIds = /* @__PURE__ */ new Map();
+  /** Active turn context — sealed on prompt dequeue, cleared on turn end */
+  activeTurnContext = null;
   permissionGate = new PermissionGate();
   queue;
   speechService;
   pendingContext = null;
   constructor(opts) {
     super();
-    this.id = opts.id || nanoid(12);
+    this.id = opts.id || nanoid2(12);
     this.channelId = opts.channelId;
+    this.attachedAdapters = [opts.channelId];
     this.agentName = opts.agentName;
     this.firstAgent = opts.agentName;
     this.workingDirectory = opts.workingDirectory;
@@ -11845,7 +11892,7 @@ var Session = class extends TypedEmitter {
     this.log = createSessionLogger(this.id, moduleLog);
     this.log.info({ agentName: this.agentName }, "Session created");
     this.queue = new PromptQueue(
-      (text3, attachments) => this.processPrompt(text3, attachments),
+      (text3, attachments, routing, turnId) => this.processPrompt(text3, attachments, routing, turnId),
       (err) => {
         this.log.error({ err }, "Prompt execution failed");
         const message = err instanceof Error ? err.message : String(err);
@@ -11853,11 +11900,20 @@ var Session = class extends TypedEmitter {
         this.emit("agent_event", { type: "error", message: `Prompt execution failed: ${message}` });
       }
     );
-    this.agentInstance.on("agent_event", (event) => {
+    this.wireCommandsBuffer();
+  }
+  /** Wire a listener on the current agentInstance to buffer commands_update events.
+   *  Must be called after every agentInstance replacement (constructor + switchAgent). */
+  commandsBufferCleanup;
+  wireCommandsBuffer() {
+    this.commandsBufferCleanup?.();
+    const handler = (event) => {
       if (event.type === "commands_update") {
         this.latestCommands = event.commands;
       }
-    });
+    };
+    this.agentInstance.on("agent_event", handler);
+    this.commandsBufferCleanup = () => this.agentInstance.off("agent_event", handler);
   }
   // --- State Machine ---
   get status() {
@@ -11911,18 +11967,26 @@ var Session = class extends TypedEmitter {
     this.log.info({ voiceMode: mode }, "TTS mode changed");
   }
   // --- Public API ---
-  async enqueuePrompt(text3, attachments) {
+  async enqueuePrompt(text3, attachments, routing, externalTurnId) {
+    const turnId = externalTurnId ?? nanoid2(8);
     if (this.middlewareChain) {
       const payload = { text: text3, attachments, sessionId: this.id };
       const result = await this.middlewareChain.execute("agent:beforePrompt", payload, async (p) => p);
-      if (!result) return;
+      if (!result) return turnId;
       text3 = result.text;
       attachments = result.attachments;
     }
-    await this.queue.enqueue(text3, attachments);
+    await this.queue.enqueue(text3, attachments, routing, turnId);
+    return turnId;
   }
-  async processPrompt(text3, attachments) {
+  async processPrompt(text3, attachments, routing, turnId) {
     if (this._status === "finished") return;
+    this.activeTurnContext = createTurnContext(
+      routing?.sourceAdapterId ?? this.channelId,
+      routing?.responseAdapterId,
+      turnId
+    );
+    this.emit("turn_started", this.activeTurnContext);
     this.promptCount++;
     this.emit("prompt_count_changed", this.promptCount);
     if (this._status === "initializing" || this._status === "cancelled" || this._status === "error") {
@@ -11989,6 +12053,7 @@ ${text3}`;
         this.log.warn({ err }, "TTS post-processing failed");
       });
     }
+    this.activeTurnContext = null;
     if (!this.name) {
       await this.autoName();
     }
@@ -12231,6 +12296,7 @@ ${result.text}` : result.text;
     this.configOptions = [];
     this.latestCommands = null;
     this.applySpawnResponse(newAgent.initialSessionResponse, newAgent.agentCapabilities);
+    this.wireCommandsBuffer();
     this.log.info({ from: this.agentSwitchHistory.at(-1).agentName, to: agentName }, "Agent switched");
   }
   async destroy() {
@@ -12698,6 +12764,8 @@ var SessionManager = class {
   }
   getSessionByThread(channelId, threadId) {
     for (const session of this.sessions.values()) {
+      const adapterThread = session.threadIds.get(channelId);
+      if (adapterThread === threadId) return session;
       if (session.channelId === channelId && session.threadId === threadId) {
         return session;
       }
@@ -12765,6 +12833,67 @@ var SessionManager = class {
     if (channelId) return all.filter((s) => s.channelId === channelId);
     return all;
   }
+  listAllSessions(channelId) {
+    if (this.store) {
+      let records = this.store.list();
+      if (channelId) records = records.filter((r) => r.channelId === channelId);
+      return records.map((record) => {
+        const live2 = this.sessions.get(record.sessionId);
+        if (live2) {
+          return {
+            id: live2.id,
+            agent: live2.agentName,
+            status: live2.status,
+            name: live2.name ?? null,
+            workspace: live2.workingDirectory,
+            channelId: live2.channelId,
+            createdAt: live2.createdAt.toISOString(),
+            lastActiveAt: record.lastActiveAt ?? null,
+            dangerousMode: live2.clientOverrides.bypassPermissions ?? false,
+            queueDepth: live2.queueDepth,
+            promptRunning: live2.promptRunning,
+            configOptions: live2.configOptions?.length ? live2.configOptions : void 0,
+            capabilities: live2.agentCapabilities ?? null,
+            isLive: true
+          };
+        }
+        return {
+          id: record.sessionId,
+          agent: record.agentName,
+          status: record.status,
+          name: record.name ?? null,
+          workspace: record.workingDir,
+          channelId: record.channelId,
+          createdAt: record.createdAt,
+          lastActiveAt: record.lastActiveAt ?? null,
+          dangerousMode: record.clientOverrides?.bypassPermissions ?? false,
+          queueDepth: 0,
+          promptRunning: false,
+          configOptions: record.acpState?.configOptions,
+          capabilities: record.acpState?.agentCapabilities ?? null,
+          isLive: false
+        };
+      });
+    }
+    let live = Array.from(this.sessions.values());
+    if (channelId) live = live.filter((s) => s.channelId === channelId);
+    return live.map((s) => ({
+      id: s.id,
+      agent: s.agentName,
+      status: s.status,
+      name: s.name ?? null,
+      workspace: s.workingDirectory,
+      channelId: s.channelId,
+      createdAt: s.createdAt.toISOString(),
+      lastActiveAt: null,
+      dangerousMode: s.clientOverrides.bypassPermissions ?? false,
+      queueDepth: s.queueDepth,
+      promptRunning: s.promptRunning,
+      configOptions: s.configOptions?.length ? s.configOptions : void 0,
+      capabilities: s.agentCapabilities ?? null,
+      isLive: true
+    }));
+  }
   listRecords(filter) {
     if (!this.store) return [];
     let records = this.store.list();
@@ -12787,7 +12916,14 @@ var SessionManager = class {
       for (const session of this.sessions.values()) {
         const record = this.store.get(session.id);
         if (record) {
-          await this.store.save({ ...record, status: "finished" });
+          await this.store.save({
+            ...record,
+            status: "finished",
+            acpState: session.toAcpStateSnapshot(),
+            clientOverrides: session.clientOverrides,
+            currentPromptCount: session.promptCount,
+            agentSwitchHistory: session.agentSwitchHistory
+          });
         }
       }
       this.store.flush();
@@ -12797,6 +12933,8 @@ var SessionManager = class {
   /**
    * Forcefully destroy all sessions (kill agent subprocesses).
    * Use only when sessions must be fully torn down (e.g. archive).
+   * Unlike shutdownAll(), this does NOT snapshot live session state (acpState, etc.)
+   * because destroyed sessions are terminal and will not be resumed.
    */
   async destroyAll() {
     if (this.store) {
@@ -12827,13 +12965,15 @@ init_log();
 init_bypass_detection();
 var log6 = createChildLogger({ module: "session-bridge" });
 var SessionBridge = class {
-  constructor(session, adapter, deps) {
+  constructor(session, adapter, deps, adapterId) {
     this.session = session;
     this.adapter = adapter;
     this.deps = deps;
+    this.adapterId = adapterId ?? adapter.name;
   }
   connected = false;
   cleanupFns = [];
+  adapterId;
   get tracer() {
     return this.session.agentInstance.debugTracer ?? null;
   }
@@ -12864,6 +13004,15 @@ var SessionBridge = class {
       log6.error({ err, sessionId }, "Error in sendMessage middleware");
     }
   }
+  /** Determine if this bridge should forward the given event based on turn routing. */
+  shouldForward(event) {
+    if (isSystemEvent(event)) return true;
+    const ctx = this.session.activeTurnContext;
+    if (!ctx) return true;
+    const target = getEffectiveTarget(ctx);
+    if (target === null) return false;
+    return this.adapterId === target;
+  }
   connect() {
     if (this.connected) return;
     this.connected = true;
@@ -12871,11 +13020,29 @@ var SessionBridge = class {
       this.session.emit("agent_event", event);
     });
     this.listen(this.session, "agent_event", (event) => {
-      this.dispatchAgentEvent(event);
+      if (this.shouldForward(event)) {
+        this.dispatchAgentEvent(event);
+      } else {
+        this.deps.eventBus?.emit("agent:event", { sessionId: this.session.id, event });
+      }
+    });
+    if (!this.session.agentInstance.onPermissionRequest || this.session.agentInstance.onPermissionRequest.__bridgeId === void 0) {
+      const handler = async (request) => {
+        return this.resolvePermission(request);
+      };
+      handler.__bridgeId = this.adapterId;
+      this.session.agentInstance.onPermissionRequest = handler;
+    }
+    this.listen(this.session, "permission_request", async (request) => {
+      const current = this.session.agentInstance.onPermissionRequest;
+      if (current?.__bridgeId === this.adapterId) return;
+      if (!this.session.permissionGate.isPending) return;
+      try {
+        await this.adapter.sendPermissionRequest(this.session.id, request);
+      } catch (err) {
+        log6.error({ err, sessionId: this.session.id, adapterId: this.adapterId }, "Failed to send permission request to adapter");
+      }
     });
-    this.session.agentInstance.onPermissionRequest = async (request) => {
-      return this.resolvePermission(request);
-    };
     this.listen(this.session, "status_change", (from, to) => {
       this.deps.sessionManager.patchRecord(this.session.id, {
         status: to,
@@ -12904,6 +13071,16 @@ var SessionBridge = class {
     this.listen(this.session, "prompt_count_changed", (count) => {
       this.deps.sessionManager.patchRecord(this.session.id, { currentPromptCount: count });
     });
+    this.listen(this.session, "turn_started", (ctx) => {
+      if (ctx.sourceAdapterId !== "sse" && ctx.sourceAdapterId !== "api") {
+        this.deps.eventBus?.emit("message:processing", {
+          sessionId: this.session.id,
+          turnId: ctx.turnId,
+          sourceAdapterId: ctx.sourceAdapterId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    });
     if (this.session.latestCommands !== null) {
       this.session.emit("agent_event", { type: "commands_update", commands: this.session.latestCommands });
     }
@@ -12916,7 +13093,10 @@ var SessionBridge = class {
     this.connected = false;
     this.cleanupFns.forEach((fn) => fn());
     this.cleanupFns = [];
-    this.session.agentInstance.onPermissionRequest = async () => "";
+    const current = this.session.agentInstance.onPermissionRequest;
+    if (current?.__bridgeId === this.adapterId) {
+      this.session.agentInstance.onPermissionRequest = async () => "";
+    }
   }
   /** Dispatch an agent event through middleware and to the adapter */
   async dispatchAgentEvent(event) {
@@ -13047,8 +13227,10 @@ var SessionBridge = class {
         this.sendMessage(this.session.id, outgoing);
         break;
       case "config_option_update":
-        this.session.updateConfigOptions(event.options);
-        this.persistAcpState();
+        this.session.updateConfigOptions(event.options).then(() => {
+          this.persistAcpState();
+        }).catch(() => {
+        });
         outgoing = this.deps.messageTransformer.transform(event);
         this.sendMessage(this.session.id, outgoing);
         break;
@@ -13092,19 +13274,27 @@ var SessionBridge = class {
         return result.autoResolve;
       }
     }
-    this.session.emit("permission_request", permReq);
     this.deps.eventBus?.emit("permission:request", {
       sessionId: this.session.id,
       permission: permReq
     });
     const autoDecision = this.checkAutoApprove(permReq);
     if (autoDecision) {
+      this.session.emit("permission_request", permReq);
       this.emitAfterResolve(mw, permReq.id, autoDecision, "system", startTime);
       return autoDecision;
     }
     const promise = this.session.permissionGate.setPending(permReq);
+    this.session.emit("permission_request", permReq);
     await this.adapter.sendPermissionRequest(this.session.id, permReq);
     const optionId = await promise;
+    this.deps.eventBus?.emit("permission:resolved", {
+      sessionId: this.session.id,
+      requestId: permReq.id,
+      decision: optionId,
+      optionId,
+      resolvedBy: this.adapterId
+    });
     this.emitAfterResolve(mw, permReq.id, optionId, "user", startTime);
     return optionId;
   }
@@ -13298,6 +13488,65 @@ var SessionFactory = class {
     if (session) return session;
     return this.lazyResume(channelId, threadId);
   }
+  async getOrResumeById(sessionId) {
+    const live = this.sessionManager.getSession(sessionId);
+    if (live) return live;
+    if (!this.sessionStore || !this.createFullSession) return null;
+    const record = this.sessionStore.get(sessionId);
+    if (!record) return null;
+    if (record.status === "error" || record.status === "cancelled") return null;
+    const existing = this.resumeLocks.get(sessionId);
+    if (existing) return existing;
+    const resumePromise = (async () => {
+      try {
+        const p = record.platform;
+        const existingThreadId = p?.topicId ? String(p.topicId) : p?.threadId;
+        const session = await this.createFullSession({
+          channelId: record.channelId,
+          agentName: record.agentName,
+          workingDirectory: record.workingDir,
+          resumeAgentSessionId: record.agentSessionId,
+          existingSessionId: record.sessionId,
+          initialName: record.name,
+          threadId: existingThreadId
+        });
+        session.activate();
+        if (record.clientOverrides) {
+          session.clientOverrides = record.clientOverrides;
+        } else if (record.dangerousMode) {
+          session.clientOverrides = { bypassPermissions: true };
+        }
+        if (record.firstAgent) session.firstAgent = record.firstAgent;
+        if (record.agentSwitchHistory) session.agentSwitchHistory = record.agentSwitchHistory;
+        if (record.currentPromptCount != null) session.promptCount = record.currentPromptCount;
+        if (record.attachedAdapters) session.attachedAdapters = record.attachedAdapters;
+        if (record.platforms) {
+          for (const [adapterId, platformData] of Object.entries(record.platforms)) {
+            const data = platformData;
+            const tid = adapterId === "telegram" ? String(data.topicId ?? "") : String(data.threadId ?? "");
+            if (tid) session.threadIds.set(adapterId, tid);
+          }
+        }
+        if (record.acpState) {
+          if (record.acpState.configOptions && session.configOptions.length === 0) {
+            session.setInitialConfigOptions(record.acpState.configOptions);
+          }
+          if (record.acpState.agentCapabilities && !session.agentCapabilities) {
+            session.setAgentCapabilities(record.acpState.agentCapabilities);
+          }
+        }
+        log7.info({ sessionId }, "Lazy resume by ID successful");
+        return session;
+      } catch (err) {
+        log7.error({ err, sessionId }, "Lazy resume by ID failed");
+        return null;
+      } finally {
+        this.resumeLocks.delete(sessionId);
+      }
+    })();
+    this.resumeLocks.set(sessionId, resumePromise);
+    return resumePromise;
+  }
   async lazyResume(channelId, threadId) {
     const store = this.sessionStore;
     if (!store || !this.createFullSession) return null;
@@ -13306,7 +13555,7 @@ var SessionFactory = class {
     if (existing) return existing;
     const record = store.findByPlatform(
       channelId,
-      (p) => String(p.topicId) === threadId
+      (p) => String(p.topicId) === threadId || String(p.threadId ?? "") === threadId
     );
     if (!record) {
       log7.debug({ threadId, channelId }, "No session record found for thread");
@@ -13341,11 +13590,21 @@ var SessionFactory = class {
         if (record.firstAgent) session.firstAgent = record.firstAgent;
         if (record.agentSwitchHistory) session.agentSwitchHistory = record.agentSwitchHistory;
         if (record.currentPromptCount != null) session.promptCount = record.currentPromptCount;
+        if (record.attachedAdapters) {
+          session.attachedAdapters = record.attachedAdapters;
+        }
+        if (record.platforms) {
+          for (const [adapterId, platformData] of Object.entries(record.platforms)) {
+            const data = platformData;
+            const tid = adapterId === "telegram" ? String(data.topicId ?? "") : String(data.threadId ?? "");
+            if (tid) session.threadIds.set(adapterId, tid);
+          }
+        }
         if (record.acpState) {
-          if (record.acpState.configOptions) {
+          if (record.acpState.configOptions && session.configOptions.length === 0) {
             session.setInitialConfigOptions(record.acpState.configOptions);
           }
-          if (record.acpState.agentCapabilities) {
+          if (record.acpState.agentCapabilities && !session.agentCapabilities) {
             session.setAgentCapabilities(record.acpState.agentCapabilities);
           }
         }
@@ -13475,6 +13734,7 @@ var SessionFactory = class {
 // src/core/core.ts
 import path17 from "path";
 import os8 from "os";
+import { nanoid as nanoid3 } from "nanoid";
 
 // src/core/sessions/session-store.ts
 init_log();
@@ -13512,6 +13772,9 @@ var JsonFileSessionStore = class {
   }
   findByPlatform(channelId, predicate) {
     for (const record of this.records.values()) {
+      if (record.platforms?.[channelId]) {
+        if (predicate(record.platforms[channelId])) return record;
+      }
       if (record.channelId === channelId && predicate(record.platform)) {
         return record;
       }
@@ -13578,7 +13841,7 @@ var JsonFileSessionStore = class {
         return;
       }
       for (const [id, record] of Object.entries(raw.sessions)) {
-        this.records.set(id, record);
+        this.records.set(id, this.migrateRecord(record));
       }
       log8.debug({ count: this.records.size }, "Loaded session records");
     } catch (err) {
@@ -13589,6 +13852,19 @@ var JsonFileSessionStore = class {
       }
     }
   }
+  /** Migrate old SessionRecord format to new multi-adapter format. */
+  migrateRecord(record) {
+    if (!record.platforms && record.platform && typeof record.platform === "object") {
+      const platformData = record.platform;
+      if (Object.keys(platformData).length > 0) {
+        record.platforms = { [record.channelId]: platformData };
+      }
+    }
+    if (!record.attachedAdapters) {
+      record.attachedAdapters = [record.channelId];
+    }
+    return record;
+  }
   cleanup() {
     const cutoff = Date.now() - this.ttlDays * 24 * 60 * 60 * 1e3;
     let removed = 0;
@@ -13667,8 +13943,15 @@ var AgentSwitchHandler = class {
       toAgent,
       status: "starting"
     });
-    const bridge = bridges.get(sessionId);
-    if (bridge) bridge.disconnect();
+    const sessionBridgeKeys = this.deps.getSessionBridgeKeys(sessionId);
+    const hadBridges = sessionBridgeKeys.length > 0;
+    for (const key of sessionBridgeKeys) {
+      const bridge = bridges.get(key);
+      if (bridge) {
+        bridges.delete(key);
+        bridge.disconnect();
+      }
+    }
     const switchAdapter = adapters.get(session.channelId);
     if (switchAdapter?.sendSkillCommands) {
       await switchAdapter.sendSkillCommands(session.id, []);
@@ -13745,9 +14028,11 @@ var AgentSwitchHandler = class {
         session.agentInstance = oldInstance;
         session.agentName = fromAgent;
         session.agentSessionId = oldInstance.sessionId;
-        const adapter = adapters.get(session.channelId);
-        if (adapter) {
-          createBridge(session, adapter).connect();
+        for (const adapterId of session.attachedAdapters) {
+          const adapter = adapters.get(adapterId);
+          if (adapter) {
+            createBridge(session, adapter, adapterId).connect();
+          }
         }
         log9.warn({ sessionId, fromAgent, toAgent, err }, "Agent switch failed, rolled back to previous agent");
       } catch (rollbackErr) {
@@ -13756,10 +14041,14 @@ var AgentSwitchHandler = class {
       }
       throw err;
     }
-    if (bridge) {
-      const adapter = adapters.get(session.channelId);
-      if (adapter) {
-        createBridge(session, adapter).connect();
+    if (hadBridges) {
+      for (const adapterId of session.attachedAdapters) {
+        const adapter = adapters.get(adapterId);
+        if (adapter) {
+          createBridge(session, adapter, adapterId).connect();
+        } else {
+          log9.warn({ sessionId, adapterId }, "Adapter not available during switch reconnect, skipping bridge");
+        }
       }
     }
     await sessionManager.patchRecord(sessionId, {
@@ -15212,7 +15501,7 @@ var OpenACPCore = class {
   sessionManager;
   messageTransformer;
   adapters = /* @__PURE__ */ new Map();
-  /** sessionId → SessionBridge — tracks active bridges for disconnect/reconnect during agent switch */
+  /** "adapterId:sessionId" → SessionBridge — tracks active bridges for disconnect/reconnect */
   bridges = /* @__PURE__ */ new Map();
   /** Set by main.ts — triggers graceful shutdown with restart exit code */
   requestRestart = null;
@@ -15308,7 +15597,8 @@ var OpenACPCore = class {
       eventBus: this.eventBus,
       adapters: this.adapters,
       bridges: this.bridges,
-      createBridge: (session, adapter) => this.createBridge(session, adapter),
+      createBridge: (session, adapter, adapterId) => this.createBridge(session, adapter, adapterId),
+      getSessionBridgeKeys: (sessionId) => this.getSessionBridgeKeys(sessionId),
       getMiddlewareChain: () => this.lifecycleManager?.middlewareChain,
       getService: (name) => this.lifecycleManager.serviceRegistry.get(name)
     });
@@ -15488,7 +15778,22 @@ User message:
 ${text3}`;
       }
     }
-    await session.enqueuePrompt(text3, message.attachments);
+    const sourceAdapterId = message.routing?.sourceAdapterId ?? message.channelId;
+    if (sourceAdapterId && sourceAdapterId !== "sse" && sourceAdapterId !== "api") {
+      const turnId = nanoid3(8);
+      this.eventBus.emit("message:queued", {
+        sessionId: session.id,
+        turnId,
+        text: text3,
+        sourceAdapterId,
+        attachments: message.attachments,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        queueDepth: session.queueDepth
+      });
+      await session.enqueuePrompt(text3, message.attachments, message.routing, turnId);
+    } else {
+      await session.enqueuePrompt(text3, message.attachments, message.routing);
+    }
   }
   // --- Unified Session Creation Pipeline ---
   async createSession(params) {
@@ -15515,6 +15820,12 @@ ${text3}`;
         platform2.threadId = session.threadId;
       }
     }
+    const platforms = {
+      ...existingRecord?.platforms ?? {}
+    };
+    if (session.threadId) {
+      platforms[params.channelId] = params.channelId === "telegram" ? { topicId: Number(session.threadId) || session.threadId } : { threadId: session.threadId };
+    }
     await this.sessionManager.patchRecord(session.id, {
       sessionId: session.id,
       agentSessionId: session.agentSessionId,
@@ -15526,6 +15837,7 @@ ${text3}`;
       lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
       name: session.name,
       platform: platform2,
+      platforms,
       firstAgent: session.firstAgent,
       currentPromptCount: session.promptCount,
       agentSwitchHistory: session.agentSwitchHistory,
@@ -15533,7 +15845,7 @@ ${text3}`;
       acpState: session.toAcpStateSnapshot()
     }, { immediate: true });
     if (adapter) {
-      const bridge = this.createBridge(session, adapter);
+      const bridge = this.createBridge(session, adapter, session.channelId);
       bridge.connect();
       adapter.flushPendingSkillCommands?.(session.id).catch((err) => {
         log16.warn({ err, sessionId: session.id }, "Failed to flush pending skill commands");
@@ -15672,9 +15984,14 @@ ${text3}`;
     } else {
       adoptPlatform.threadId = session.threadId;
     }
+    const adoptPlatforms = {};
+    if (session.threadId) {
+      adoptPlatforms[adapterChannelId] = adapterChannelId === "telegram" ? { topicId: Number(session.threadId) || session.threadId } : { threadId: session.threadId };
+    }
     await this.sessionManager.patchRecord(session.id, {
       originalAgentSessionId: agentSessionId,
-      platform: adoptPlatform
+      platform: adoptPlatform,
+      platforms: adoptPlatforms
     });
     return {
       ok: true,
@@ -15696,18 +16013,101 @@ ${text3}`;
   async getOrResumeSession(channelId, threadId) {
     return this.sessionFactory.getOrResume(channelId, threadId);
   }
+  async getOrResumeSessionById(sessionId) {
+    return this.sessionFactory.getOrResumeById(sessionId);
+  }
+  async attachAdapter(sessionId, adapterId) {
+    const session = this.sessionManager.getSession(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    const adapter = this.adapters.get(adapterId);
+    if (!adapter) throw new Error(`Adapter "${adapterId}" not found or not running`);
+    if (session.attachedAdapters.includes(adapterId)) {
+      const existingThread = session.threadIds.get(adapterId) ?? session.id;
+      return { threadId: existingThread };
+    }
+    const threadId = await adapter.createSessionThread(
+      session.id,
+      session.name ?? `Session ${session.id.slice(0, 6)}`
+    );
+    session.threadIds.set(adapterId, threadId);
+    session.attachedAdapters.push(adapterId);
+    const bridge = this.createBridge(session, adapter, adapterId);
+    bridge.connect();
+    await this.sessionManager.patchRecord(session.id, {
+      attachedAdapters: session.attachedAdapters,
+      platforms: this.buildPlatformsFromSession(session)
+    });
+    return { threadId };
+  }
+  async detachAdapter(sessionId, adapterId) {
+    const session = this.sessionManager.getSession(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    if (adapterId === session.channelId) {
+      throw new Error("Cannot detach primary adapter (channelId)");
+    }
+    if (!session.attachedAdapters.includes(adapterId)) {
+      return;
+    }
+    const adapter = this.adapters.get(adapterId);
+    if (adapter) {
+      try {
+        await adapter.sendMessage(session.id, {
+          type: "system_message",
+          text: "Session detached from this adapter."
+        });
+      } catch {
+      }
+    }
+    const key = this.bridgeKey(adapterId, session.id);
+    const bridge = this.bridges.get(key);
+    if (bridge) {
+      bridge.disconnect();
+      this.bridges.delete(key);
+    }
+    session.attachedAdapters = session.attachedAdapters.filter((a) => a !== adapterId);
+    session.threadIds.delete(adapterId);
+    await this.sessionManager.patchRecord(session.id, {
+      attachedAdapters: session.attachedAdapters,
+      platforms: this.buildPlatformsFromSession(session)
+    });
+  }
+  buildPlatformsFromSession(session) {
+    const platforms = {};
+    for (const [adapterId, threadId] of session.threadIds) {
+      if (adapterId === "telegram") {
+        platforms.telegram = { topicId: Number(threadId) || threadId };
+      } else {
+        platforms[adapterId] = { threadId };
+      }
+    }
+    return platforms;
+  }
   // --- Event Wiring ---
+  /** Composite bridge key: "adapterId:sessionId" */
+  bridgeKey(adapterId, sessionId) {
+    return `${adapterId}:${sessionId}`;
+  }
+  /** Get all bridge keys for a session (regardless of adapter) */
+  getSessionBridgeKeys(sessionId) {
+    const keys = [];
+    for (const key of this.bridges.keys()) {
+      if (key.endsWith(`:${sessionId}`)) keys.push(key);
+    }
+    return keys;
+  }
   /** Connect a session bridge for the given session (used by AssistantManager) */
   connectSessionBridge(session) {
     const adapter = this.adapters.get(session.channelId);
     if (!adapter) return;
-    const bridge = this.createBridge(session, adapter);
+    const bridge = this.createBridge(session, adapter, session.channelId);
     bridge.connect();
   }
   /** Create a SessionBridge for the given session and adapter.
-   *  Disconnects any existing bridge for the same session first. */
-  createBridge(session, adapter) {
-    const existing = this.bridges.get(session.id);
+   *  Disconnects any existing bridge for the same adapter+session first. */
+  createBridge(session, adapter, adapterId) {
+    const id = adapterId ?? adapter.name;
+    const key = this.bridgeKey(id, session.id);
+    const existing = this.bridges.get(key);
     if (existing) {
       existing.disconnect();
     }
@@ -15718,8 +16118,8 @@ ${text3}`;
       eventBus: this.eventBus,
       fileService: this.fileService,
       middlewareChain: this.lifecycleManager?.middlewareChain
-    });
-    this.bridges.set(session.id, bridge);
+    }, id);
+    this.bridges.set(key, bridge);
     return bridge;
   }
 };
@@ -17754,12 +18154,14 @@ export {
   createApiServerService,
   createChildLogger,
   createSessionLogger,
+  createTurnContext,
   expandHome3 as expandHome,
   extractContentText,
   formatTokens,
   formatToolSummary,
   formatToolTitle,
   getConfigValue,
+  getEffectiveTarget,
   getFieldDef,
   getPidPath,
   getSafeFields,
@@ -17769,6 +18171,7 @@ export {
   isAutoStartInstalled,
   isAutoStartSupported,
   isHotReloadable,
+  isSystemEvent,
   log,
   nodeToWebReadable,
   nodeToWebWritable,