@openacp/cli 2026.403.8 → 2026.404.1

package/dist/cli.js

@@ -6611,16 +6611,20 @@ var init_tunnel_service = __esm({
             return entry.publicUrl || `http://localhost:${apiPort}`;
           } catch (err) {
             if (this.config.provider === "openacp") {
-              log11.warn({ err: err.message }, "OpenACP tunnel service unreachable, falling back to Cloudflare quick tunnel");
+              const reason = err.message ?? String(err);
+              log11.error({ err: reason }, "[tunnel] OpenACP tunnel failed \u2014 falling back to Cloudflare quick tunnel");
               try {
                 const fallbackEntry = await this.registry.add(apiPort, {
                   type: "system",
                   provider: "cloudflare",
                   label: "system"
                 });
-                this.startError = "OpenACP tunnel unavailable \u2014 using Cloudflare quick tunnel";
-                return fallbackEntry.publicUrl || `http://localhost:${apiPort}`;
+                const fallbackUrl = fallbackEntry.publicUrl || `http://localhost:${apiPort}`;
+                log11.warn({ url: fallbackUrl, reason }, "[tunnel] Cloudflare fallback tunnel active");
+                this.startError = `OpenACP tunnel unavailable (${reason}) \u2014 using Cloudflare quick tunnel`;
+                return fallbackUrl;
               } catch (fallbackErr) {
+                log11.error({ err: fallbackErr.message }, "[tunnel] Cloudflare fallback also failed \u2014 no public URL");
                 this.startError = fallbackErr.message;
                 return `http://localhost:${apiPort}`;
               }
@@ -8068,7 +8072,10 @@ var init_sessions = __esm({
     });
     PromptBodySchema = z.object({
       // 100 KB limit — prevents memory exhaustion / DoS via enormous payloads
-      prompt: z.string().min(1).max(1e5)
+      prompt: z.string().min(1).max(1e5),
+      // Multi-adapter routing fields
+      sourceAdapterId: z.string().optional(),
+      responseAdapterId: z.string().nullable().optional()
     });
     PermissionResponseBodySchema = z.object({
       permissionId: z.string().min(1).max(200),
@@ -8105,22 +8112,23 @@ __export(sessions_exports, {
 });
 async function sessionRoutes(app, deps) {
   app.get("/", { preHandler: requireScopes("sessions:read") }, async () => {
-    const sessions = deps.core.sessionManager.listSessions();
+    const summaries = deps.core.sessionManager.listAllSessions();
     return {
-      sessions: sessions.map((s) => ({
+      sessions: summaries.map((s) => ({
         id: s.id,
-        agent: s.agentName,
+        agent: s.agent,
         status: s.status,
-        name: s.name ?? null,
-        workspace: s.workingDirectory,
-        createdAt: s.createdAt.toISOString(),
-        dangerousMode: s.clientOverrides.bypassPermissions ?? false,
+        name: s.name,
+        workspace: s.workspace,
+        channelId: s.channelId,
+        createdAt: s.createdAt,
+        lastActiveAt: s.lastActiveAt,
+        dangerousMode: s.dangerousMode,
         queueDepth: s.queueDepth,
         promptRunning: s.promptRunning,
-        lastActiveAt: deps.core.sessionManager.getSessionRecord(s.id)?.lastActiveAt ?? null,
-        // ACP state
-        configOptions: s.configOptions?.length ? s.configOptions : void 0,
-        capabilities: s.agentCapabilities ?? null
+        configOptions: s.configOptions,
+        capabilities: s.capabilities,
+        isLive: s.isLive
       }))
     };
   });
@@ -8232,7 +8240,7 @@ async function sessionRoutes(app, deps) {
     async (request, reply) => {
       const { sessionId: rawId } = SessionIdParamSchema.parse(request.params);
       const sessionId = decodeURIComponent(rawId);
-      const session = deps.core.sessionManager.getSession(sessionId);
+      const session = await deps.core.getOrResumeSessionById(sessionId);
       if (!session) {
         throw new NotFoundError(
           "SESSION_NOT_FOUND",
@@ -8243,7 +8251,10 @@ async function sessionRoutes(app, deps) {
         return reply.status(400).send({ error: `Session is ${session.status}` });
       }
       const body = PromptBodySchema.parse(request.body);
-      await session.enqueuePrompt(body.prompt);
+      await session.enqueuePrompt(body.prompt, void 0, {
+        sourceAdapterId: body.sourceAdapterId ?? "api",
+        responseAdapterId: body.responseAdapterId
+      });
       return {
         ok: true,
         sessionId,
@@ -8290,6 +8301,9 @@ async function sessionRoutes(app, deps) {
       const body = UpdateSessionBodySchema.parse(request.body);
       const changes = {};
       if (body.agentName !== void 0) {
+        if (session.promptRunning) {
+          await session.abortPrompt();
+        }
         const result = await deps.core.switchSessionAgent(sessionId, body.agentName);
         changes.agentName = body.agentName;
         changes.resumed = result.resumed;
@@ -8425,6 +8439,36 @@ async function sessionRoutes(app, deps) {
       }
     }
   );
+  app.post(
+    "/:sessionId/attach",
+    { preHandler: requireScopes("sessions:write") },
+    async (request, reply) => {
+      const { sessionId } = request.params;
+      const { adapterId } = request.body ?? {};
+      if (!adapterId) return reply.code(400).send({ error: "adapterId is required" });
+      try {
+        const result = await deps.core.attachAdapter(sessionId, adapterId);
+        return { ok: true, threadId: result.threadId };
+      } catch (err) {
+        return reply.code(400).send({ error: err.message });
+      }
+    }
+  );
+  app.post(
+    "/:sessionId/detach",
+    { preHandler: requireScopes("sessions:write") },
+    async (request, reply) => {
+      const { sessionId } = request.params;
+      const { adapterId } = request.body ?? {};
+      if (!adapterId) return reply.code(400).send({ error: "adapterId is required" });
+      try {
+        await deps.core.detachAdapter(sessionId, adapterId);
+        return { ok: true };
+      } catch (err) {
+        return reply.code(400).send({ error: err.message });
+      }
+    }
+  );
   app.get(
     "/:sessionId/history",
     { preHandler: requireScopes("sessions:read") },
@@ -10603,7 +10647,7 @@ async function sseRoutes(app, deps) {
         return reply.status(400).send({ error: `Session is ${session.status}` });
       }
       const body = PromptBodySchema.parse(request.body);
-      await session.enqueuePrompt(body.prompt);
+      await session.enqueuePrompt(body.prompt, void 0, { sourceAdapterId: "sse" });
       return { ok: true, sessionId, queueDepth: session.queueDepth };
     }
   );
@@ -18855,6 +18899,7 @@ var init_agent_instance = __esm({
             { 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", {
@@ -19351,21 +19396,21 @@ var init_prompt_queue = __esm({
       queue = [];
       processing = false;
       abortController = null;
-      async enqueue(text6, attachments) {
+      async enqueue(text6, attachments, routing) {
         if (this.processing) {
           return new Promise((resolve8) => {
-            this.queue.push({ text: text6, attachments, resolve: resolve8 });
+            this.queue.push({ text: text6, attachments, routing, resolve: resolve8 });
           });
         }
-        await this.process(text6, attachments);
+        await this.process(text6, attachments, routing);
       }
-      async process(text6, attachments) {
+      async process(text6, attachments, routing) {
         this.processing = true;
         this.abortController = new AbortController();
         const { signal } = this.abortController;
         try {
           await Promise.race([
-            this.processor(text6, attachments),
+            this.processor(text6, attachments, routing),
             new Promise((_, reject) => {
               signal.addEventListener("abort", () => reject(new Error("Prompt aborted")), { once: true });
             })
@@ -19383,7 +19428,7 @@ var init_prompt_queue = __esm({
       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).then(next.resolve);
         }
       }
       clear() {
@@ -19478,8 +19523,39 @@ var init_permission_gate = __esm({
   }
 });
 
-// src/core/sessions/session.ts
+// src/core/sessions/turn-context.ts
 import { nanoid as nanoid3 } from "nanoid";
+function createTurnContext(sourceAdapterId, responseAdapterId) {
+  return {
+    turnId: nanoid3(8),
+    sourceAdapterId,
+    responseAdapterId
+  };
+}
+function getEffectiveTarget(ctx) {
+  if (ctx.responseAdapterId === null) return null;
+  return ctx.responseAdapterId ?? ctx.sourceAdapterId;
+}
+function isSystemEvent(event) {
+  return SYSTEM_EVENT_TYPES.has(event.type);
+}
+var SYSTEM_EVENT_TYPES;
+var init_turn_context = __esm({
+  "src/core/sessions/turn-context.ts"() {
+    "use strict";
+    SYSTEM_EVENT_TYPES = /* @__PURE__ */ new Set([
+      "session_end",
+      "system_message",
+      "session_info_update",
+      "config_option_update",
+      "commands_update",
+      "tts_strip"
+    ]);
+  }
+});
+
+// src/core/sessions/session.ts
+import { nanoid as nanoid4 } from "nanoid";
 import * as fs41 from "fs";
 var moduleLog, TTS_PROMPT_INSTRUCTION, TTS_BLOCK_REGEX, TTS_MAX_LENGTH, TTS_TIMEOUT_MS, VALID_TRANSITIONS, Session;
 var init_session2 = __esm({
@@ -19489,6 +19565,7 @@ var init_session2 = __esm({
     init_prompt_queue();
     init_permission_gate();
     init_log();
+    init_turn_context();
     moduleLog = createChildLogger({ module: "session" });
     TTS_PROMPT_INSTRUCTION = `
 
@@ -19506,7 +19583,15 @@ Additionally, include a [TTS]...[/TTS] block with a spoken-friendly summary of y
     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;
@@ -19527,14 +19612,21 @@ Additionally, include a [TTS]...[/TTS] block with a spoken-friendly summary of y
       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 || nanoid3(12);
+        this.id = opts.id || nanoid4(12);
         this.channelId = opts.channelId;
+        this.attachedAdapters = [opts.channelId];
         this.agentName = opts.agentName;
         this.firstAgent = opts.agentName;
         this.workingDirectory = opts.workingDirectory;
@@ -19544,7 +19636,7 @@ Additionally, include a [TTS]...[/TTS] block with a spoken-friendly summary of y
         this.log = createSessionLogger(this.id, moduleLog);
         this.log.info({ agentName: this.agentName }, "Session created");
         this.queue = new PromptQueue(
-          (text6, attachments) => this.processPrompt(text6, attachments),
+          (text6, attachments, routing) => this.processPrompt(text6, attachments, routing),
           (err) => {
             this.log.error({ err }, "Prompt execution failed");
             const message = err instanceof Error ? err.message : String(err);
@@ -19552,11 +19644,20 @@ Additionally, include a [TTS]...[/TTS] block with a spoken-friendly summary of y
             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() {
@@ -19610,7 +19711,7 @@ Additionally, include a [TTS]...[/TTS] block with a spoken-friendly summary of y
         this.log.info({ voiceMode: mode }, "TTS mode changed");
       }
       // --- Public API ---
-      async enqueuePrompt(text6, attachments) {
+      async enqueuePrompt(text6, attachments, routing) {
         if (this.middlewareChain) {
           const payload = { text: text6, attachments, sessionId: this.id };
           const result = await this.middlewareChain.execute("agent:beforePrompt", payload, async (p2) => p2);
@@ -19618,10 +19719,14 @@ Additionally, include a [TTS]...[/TTS] block with a spoken-friendly summary of y
           text6 = result.text;
           attachments = result.attachments;
         }
-        await this.queue.enqueue(text6, attachments);
+        await this.queue.enqueue(text6, attachments, routing);
       }
-      async processPrompt(text6, attachments) {
+      async processPrompt(text6, attachments, routing) {
         if (this._status === "finished") return;
+        this.activeTurnContext = createTurnContext(
+          routing?.sourceAdapterId ?? this.channelId,
+          routing?.responseAdapterId
+        );
         this.promptCount++;
         this.emit("prompt_count_changed", this.promptCount);
         if (this._status === "initializing" || this._status === "cancelled" || this._status === "error") {
@@ -19688,6 +19793,7 @@ ${text6}`;
             this.log.warn({ err }, "TTS post-processing failed");
           });
         }
+        this.activeTurnContext = null;
         if (!this.name) {
           await this.autoName();
         }
@@ -19930,6 +20036,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() {
@@ -19994,6 +20101,8 @@ var init_session_manager = __esm({
       }
       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;
           }
@@ -20061,6 +20170,67 @@ var init_session_manager = __esm({
         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();
@@ -20083,7 +20253,14 @@ var init_session_manager = __esm({
           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();
@@ -20093,6 +20270,8 @@ var init_session_manager = __esm({
       /**
        * 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) {
@@ -20127,15 +20306,18 @@ var init_session_bridge = __esm({
     "use strict";
     init_log();
     init_bypass_detection();
+    init_turn_context();
     log30 = createChildLogger({ module: "session-bridge" });
     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;
       }
@@ -20166,6 +20348,15 @@ var init_session_bridge = __esm({
           log30.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;
@@ -20173,11 +20364,29 @@ var init_session_bridge = __esm({
           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) {
+            log30.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,
@@ -20218,7 +20427,10 @@ var init_session_bridge = __esm({
         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) {
@@ -20349,8 +20561,10 @@ var init_session_bridge = __esm({
             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;
@@ -20394,19 +20608,27 @@ var init_session_bridge = __esm({
             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;
       }
@@ -20906,6 +21128,9 @@ var init_session_store = __esm({
       }
       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;
           }
@@ -20972,7 +21197,7 @@ var init_session_store = __esm({
             return;
           }
           for (const [id, record] of Object.entries(raw.sessions)) {
-            this.records.set(id, record);
+            this.records.set(id, this.migrateRecord(record));
           }
           log32.debug({ count: this.records.size }, "Loaded session records");
         } catch (err) {
@@ -20983,6 +21208,19 @@ var init_session_store = __esm({
           }
         }
       }
+      /** 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;
@@ -21171,6 +21409,65 @@ var init_session_factory = __esm({
         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 p2 = record.platform;
+            const existingThreadId = p2?.topicId ? String(p2.topicId) : p2?.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);
+              }
+            }
+            log33.info({ sessionId }, "Lazy resume by ID successful");
+            return session;
+          } catch (err) {
+            log33.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;
@@ -21179,7 +21476,7 @@ var init_session_factory = __esm({
         if (existing) return existing;
         const record = store.findByPlatform(
           channelId,
-          (p2) => String(p2.topicId) === threadId
+          (p2) => String(p2.topicId) === threadId || String(p2.threadId ?? "") === threadId
         );
         if (!record) {
           log33.debug({ threadId, channelId }, "No session record found for thread");
@@ -21214,11 +21511,21 @@ var init_session_factory = __esm({
             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);
               }
             }
@@ -21401,8 +21708,15 @@ var init_agent_switch_handler = __esm({
           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, []);
@@ -21479,9 +21793,11 @@ var init_agent_switch_handler = __esm({
             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();
+              }
             }
             log34.warn({ sessionId, fromAgent, toAgent, err }, "Agent switch failed, rolled back to previous agent");
           } catch (rollbackErr) {
@@ -21490,10 +21806,14 @@ var init_agent_switch_handler = __esm({
           }
           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 {
+              log34.warn({ sessionId, adapterId }, "Adapter not available during switch reconnect, skipping bridge");
+            }
           }
         }
         await sessionManager.patchRecord(sessionId, {
@@ -23105,7 +23425,7 @@ var init_core = __esm({
       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;
@@ -23201,7 +23521,8 @@ var init_core = __esm({
           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)
         });
@@ -23381,7 +23702,7 @@ User message:
 ${text6}`;
           }
         }
-        await session.enqueuePrompt(text6, message.attachments);
+        await session.enqueuePrompt(text6, message.attachments, message.routing);
       }
       // --- Unified Session Creation Pipeline ---
       async createSession(params) {
@@ -23408,6 +23729,12 @@ ${text6}`;
             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,
@@ -23419,6 +23746,7 @@ ${text6}`;
           lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
           name: session.name,
           platform: platform2,
+          platforms,
           firstAgent: session.firstAgent,
           currentPromptCount: session.promptCount,
           agentSwitchHistory: session.agentSwitchHistory,
@@ -23426,7 +23754,7 @@ ${text6}`;
           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) => {
             log40.warn({ err, sessionId: session.id }, "Failed to flush pending skill commands");
@@ -23565,9 +23893,14 @@ ${text6}`;
         } 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,
@@ -23589,18 +23922,101 @@ ${text6}`;
       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();
         }
@@ -23611,8 +24027,8 @@ ${text6}`;
           eventBus: this.eventBus,
           fileService: this.fileService,
           middlewareChain: this.lifecycleManager?.middlewareChain
-        });
-        this.bridges.set(session.id, bridge);
+        }, id);
+        this.bridges.set(key, bridge);
         return bridge;
       }
     };
@@ -24257,13 +24673,15 @@ function registerSwitchCommands(registry, _core) {
         return { type: "error", message: "No active session in this topic." };
       }
       if (raw) {
+        const droppedCount = session.queueDepth;
         if (session.promptRunning) {
           await session.abortPrompt();
         }
         try {
           const { resumed } = await core.switchSessionAgent(session.id, raw);
           const status = resumed ? "resumed" : "new session";
-          return { type: "text", text: `\u2705 Switched to ${raw} (${status})` };
+          const droppedNote = droppedCount > 0 ? ` (${droppedCount} queued prompt${droppedCount > 1 ? "s" : ""} cleared)` : "";
+          return { type: "text", text: `\u2705 Switched to ${raw} (${status})${droppedNote}` };
         } catch (err) {
           return { type: "error", message: `Failed to switch agent: ${err.message || err}` };
         }
@@ -24356,27 +24774,8 @@ function registerCategoryCommand(registry, core, category, commandName) {
       if (configOption.currentValue === raw) {
         return { type: "text", text: `Already using **${match.name}**.` };
       }
-      if (session.middlewareChain) {
-        const result = await session.middlewareChain.execute("config:beforeChange", {
-          sessionId: session.id,
-          configId: configOption.id,
-          oldValue: configOption.currentValue,
-          newValue: raw
-        }, async (p2) => p2);
-        if (!result) return { type: "error", message: `This change was blocked by a plugin.` };
-      }
       try {
-        const response = await session.agentInstance.setConfigOption(
-          configOption.id,
-          { type: "select", value: raw }
-        );
-        if (response.configOptions && response.configOptions.length > 0) {
-          session.configOptions = response.configOptions;
-        } else {
-          session.configOptions = session.configOptions.map(
-            (o) => o.id === configOption.id && o.type === "select" ? { ...o, currentValue: raw } : o
-          );
-        }
+        await session.setConfigOption(configOption.id, { type: "select", value: raw });
         core.eventBus.emit("session:configChanged", { sessionId: session.id });
         return { type: "text", text: labels.successMsg(match.name, configOption.name) };
       } catch (err) {
@@ -24438,17 +24837,7 @@ function registerDangerousCommand(registry, core) {
       if (bypassValue && modeConfig) {
         try {
           const targetValue = wantOn ? bypassValue : nonBypassDefault;
-          const response = await session.agentInstance.setConfigOption(
-            modeConfig.id,
-            { type: "select", value: targetValue }
-          );
-          if (response.configOptions && response.configOptions.length > 0) {
-            session.configOptions = response.configOptions;
-          } else {
-            session.configOptions = session.configOptions.map(
-              (o) => o.id === modeConfig.id && o.type === "select" ? { ...o, currentValue: targetValue } : o
-            );
-          }
+          await session.setConfigOption(modeConfig.id, { type: "select", value: targetValue });
           core.eventBus.emit("session:configChanged", { sessionId: session.id });
           return {
             type: "text",
@@ -26438,7 +26827,10 @@ async function startServer(opts) {
       const tunnelErr = tunnelSvc.getStartError();
       const url = tunnelSvc.getPublicUrl();
       const isPublic = url && !url.startsWith("http://localhost") && !url.startsWith("http://127.0.0.1");
-      if (tunnelErr) {
+      if (tunnelErr && isPublic) {
+        warn3(`Primary tunnel failed \u2014 using fallback: ${tunnelErr}`);
+        tunnelUrl = url;
+      } else if (tunnelErr) {
         warn3(`Tunnel failed (${tunnelErr}) \u2014 retrying in background`);
       } else if (isPublic) {
         ok3("Tunnel ready");