@openacp/cli 2026.403.7 → 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 };
     }
   );
@@ -11411,7 +11455,7 @@ var BYPASS_KEYWORDS;
 var init_bypass_detection = __esm({
   "src/core/utils/bypass-detection.ts"() {
     "use strict";
-    BYPASS_KEYWORDS = ["bypass", "dangerous", "auto_accept"];
+    BYPASS_KEYWORDS = ["bypass", "dangerous", "auto_accept", "yolo"];
   }
 });
 
@@ -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", {
@@ -18884,12 +18929,18 @@ ${stderr}`
           cwd: workingDirectory,
           mcpServers: resolvedMcp
         });
+        log29.info(response, "newSession response");
         instance.sessionId = response.sessionId;
         instance.initialSessionResponse = response;
         instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
         instance.setupCrashDetection();
         log29.info(
-          { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
+          {
+            sessionId: response.sessionId,
+            durationMs: Date.now() - spawnStart,
+            configOptions: response.configOptions ?? [],
+            agentCapabilities: instance.agentCapabilities ?? null
+          },
           "Agent spawn complete"
         );
         return instance;
@@ -18901,24 +18952,47 @@ ${stderr}`
           agentDef,
           workingDirectory
         );
+        const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
         try {
-          const response = await instance.connection.unstable_resumeSession({
-            sessionId: agentSessionId,
-            cwd: workingDirectory
-          });
-          instance.sessionId = response.sessionId;
-          instance.initialSessionResponse = response;
-          instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
-          log29.info(
-            { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
-            "Agent resume complete"
-          );
+          if (instance.agentCapabilities?.loadSession) {
+            const response = await instance.connection.loadSession({
+              sessionId: agentSessionId,
+              cwd: workingDirectory,
+              mcpServers: resolvedMcp
+            });
+            instance.sessionId = agentSessionId;
+            instance.initialSessionResponse = response;
+            instance.debugTracer = createDebugTracer(agentSessionId, workingDirectory);
+            log29.info(
+              {
+                sessionId: agentSessionId,
+                durationMs: Date.now() - spawnStart,
+                agentCapabilities: instance.agentCapabilities ?? null
+              },
+              "Agent load complete"
+            );
+          } else {
+            const response = await instance.connection.unstable_resumeSession({
+              sessionId: agentSessionId,
+              cwd: workingDirectory
+            });
+            instance.sessionId = response.sessionId;
+            instance.initialSessionResponse = response;
+            instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
+            log29.info(
+              {
+                sessionId: response.sessionId,
+                durationMs: Date.now() - spawnStart,
+                agentCapabilities: instance.agentCapabilities ?? null
+              },
+              "Agent resume complete"
+            );
+          }
         } catch (err) {
           log29.warn(
             { err, agentSessionId },
             "Resume failed, falling back to new session"
           );
-          const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
           const response = await instance.connection.newSession({
             cwd: workingDirectory,
             mcpServers: resolvedMcp
@@ -19149,11 +19223,31 @@ ${stderr}`
       }
       // ── New ACP methods ──────────────────────────────────────────────────
       async setConfigOption(configId, value) {
-        return await this.connection.setSessionConfigOption({
-          sessionId: this.sessionId,
-          configId,
-          ...value
-        });
+        try {
+          return await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId,
+            ...value
+          });
+        } catch (err) {
+          if (typeof err === "object" && err !== null && err.code === -32601) {
+            if (configId === "mode" && value.type === "select") {
+              await this.connection.setSessionMode({
+                sessionId: this.sessionId,
+                modeId: value.value
+              });
+              return { configOptions: [] };
+            }
+            if (configId === "model" && value.type === "select") {
+              await this.connection.unstable_setSessionModel({
+                sessionId: this.sessionId,
+                modelId: value.value
+              });
+              return { configOptions: [] };
+            }
+          }
+          throw err;
+        }
       }
       async listSessions(cwd, cursor) {
         return await this.connection.listSessions({
@@ -19302,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 });
             })
@@ -19334,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() {
@@ -19429,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({
@@ -19440,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 = `
 
@@ -19457,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;
@@ -19478,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;
@@ -19495,18 +19636,28 @@ 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);
+            this.fail(message);
             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() {
@@ -19560,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);
@@ -19568,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") {
@@ -19638,6 +19793,7 @@ ${text6}`;
             this.log.warn({ err }, "TTS post-processing failed");
           });
         }
+        this.activeTurnContext = null;
         if (!this.name) {
           await this.autoName();
         }
@@ -19753,6 +19909,42 @@ ${result.text}` : result.text;
       setAgentCapabilities(caps) {
         this.agentCapabilities = caps;
       }
+      /**
+       * Hydrate configOptions and agentCapabilities from a spawn response.
+       * Handles both the native configOptions format and legacy modes/models fields.
+       */
+      applySpawnResponse(resp, caps) {
+        if (caps) this.agentCapabilities = caps;
+        if (!resp) return;
+        if (resp.configOptions) {
+          this.configOptions = resp.configOptions;
+          return;
+        }
+        const legacyOptions = [];
+        if (resp.modes) {
+          const m = resp.modes;
+          legacyOptions.push({
+            id: "mode",
+            name: "Mode",
+            category: "mode",
+            type: "select",
+            currentValue: m.currentModeId,
+            options: m.availableModes.map((x) => ({ value: x.id, name: x.name, description: x.description }))
+          });
+        }
+        if (resp.models) {
+          const m = resp.models;
+          legacyOptions.push({
+            id: "model",
+            name: "Model",
+            category: "model",
+            type: "select",
+            currentValue: m.currentModelId,
+            options: m.availableModels.map((x) => ({ value: x.modelId ?? x.id, name: x.name, description: x.description }))
+          });
+        }
+        if (legacyOptions.length > 0) this.configOptions = legacyOptions;
+      }
       getConfigOption(id) {
         return this.configOptions.find((o) => o.id === id);
       }
@@ -19772,8 +19964,13 @@ ${result.text}` : result.text;
       /** Send a config option change to the agent and update local state from the response. */
       async setConfigOption(configId, value) {
         const response = await this.agentInstance.setConfigOption(configId, value);
-        if (response.configOptions) {
+        if (response.configOptions && response.configOptions.length > 0) {
           await this.updateConfigOptions(response.configOptions);
+        } else if (value.type === "select") {
+          const updated = this.configOptions.map(
+            (o) => o.id === configId && o.type === "select" ? { ...o, currentValue: value.value } : o
+          );
+          await this.updateConfigOptions(updated);
         }
       }
       async updateConfigOptions(options) {
@@ -19837,6 +20034,9 @@ ${result.text}` : result.text;
         this.promptCount = 0;
         this.agentCapabilities = void 0;
         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() {
@@ -19901,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;
           }
@@ -19968,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();
@@ -19990,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();
@@ -20000,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) {
@@ -20034,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;
       }
@@ -20073,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;
@@ -20080,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,
@@ -20116,13 +20418,19 @@ var init_session_bridge = __esm({
         if (this.session.latestCommands !== null) {
           this.session.emit("agent_event", { type: "commands_update", commands: this.session.latestCommands });
         }
+        if (this.session.configOptions.length > 0) {
+          this.session.emit("agent_event", { type: "config_option_update", options: this.session.configOptions });
+        }
       }
       disconnect() {
         if (!this.connected) return;
         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) {
@@ -20253,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;
@@ -20298,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;
       }
@@ -20810,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;
           }
@@ -20876,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) {
@@ -20887,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;
@@ -21057,17 +21391,7 @@ var init_session_factory = __esm({
         if (createParams.initialName) {
           session.name = createParams.initialName;
         }
-        const resp = agentInstance.initialSessionResponse;
-        if (resp) {
-          if (resp.configOptions) {
-            session.setInitialConfigOptions(resp.configOptions);
-          }
-          if (agentInstance.agentCapabilities) {
-            session.setAgentCapabilities(agentInstance.agentCapabilities);
-          }
-        } else if (agentInstance.agentCapabilities) {
-          session.setAgentCapabilities(agentInstance.agentCapabilities);
-        }
+        session.applySpawnResponse(agentInstance.initialSessionResponse, agentInstance.agentCapabilities);
         this.sessionManager.registerSession(session);
         this.eventBus.emit("session:created", {
           sessionId: session.id,
@@ -21085,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;
@@ -21093,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");
@@ -21128,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);
               }
             }
@@ -21315,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, []);
@@ -21393,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) {
@@ -21404,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, {
@@ -22155,7 +22561,7 @@ function createPluginContext(opts) {
     }
   };
   const baseLog = opts.log ?? noopLog;
-  const log44 = typeof baseLog.child === "function" ? baseLog.child({ plugin: pluginName }) : baseLog;
+  const log45 = typeof baseLog.child === "function" ? baseLog.child({ plugin: pluginName }) : baseLog;
   const storageImpl = new PluginStorageImpl(storagePath);
   const storage = {
     async get(key) {
@@ -22182,7 +22588,7 @@ function createPluginContext(opts) {
   const ctx = {
     pluginName,
     pluginConfig,
-    log: log44,
+    log: log45,
     storage,
     on(event, handler) {
       requirePermission(permissions, "events:read", "on()");
@@ -22217,7 +22623,7 @@ function createPluginContext(opts) {
       const registry = serviceRegistry.get("command-registry");
       if (registry && typeof registry.register === "function") {
         registry.register(def, pluginName);
-        log44.debug(`Command '/${def.name}' registered`);
+        log45.debug(`Command '/${def.name}' registered`);
       }
     },
     async sendMessage(_sessionId, _content) {
@@ -23019,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;
@@ -23115,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)
         });
@@ -23295,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) {
@@ -23322,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,
@@ -23333,6 +23746,7 @@ ${text6}`;
           lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
           name: session.name,
           platform: platform2,
+          platforms,
           firstAgent: session.firstAgent,
           currentPromptCount: session.promptCount,
           agentSwitchHistory: session.agentSwitchHistory,
@@ -23340,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");
@@ -23479,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,
@@ -23503,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();
         }
@@ -23525,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;
       }
     };
@@ -24171,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}` };
         }
@@ -24270,27 +24774,13 @@ 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) {
-          session.configOptions = response.configOptions;
-        }
+        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) {
-        const msg = err instanceof Error ? err.message : String(err);
+        log41.error({ err, commandName, configId: configOption.id }, "setConfigOption failed");
+        const msg = err instanceof Error ? err.message : typeof err === "object" && err !== null && typeof err.message === "string" ? err.message : String(err);
         return { type: "error", message: `Could not change ${commandName}: ${msg}` };
       }
     }
@@ -24347,20 +24837,15 @@ 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) {
-            session.configOptions = response.configOptions;
-          }
+          await session.setConfigOption(modeConfig.id, { type: "select", value: targetValue });
           core.eventBus.emit("session:configChanged", { sessionId: session.id });
           return {
             type: "text",
             text: wantOn ? "\u2620\uFE0F **Bypass Permissions enabled** \u2014 all permission requests will be auto-approved. The agent can run any action without asking." : "\u{1F510} **Bypass Permissions disabled** \u2014 you will be asked to approve risky actions."
           };
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
+          log41.error({ err }, "setConfigOption failed (bypass toggle)");
+          const msg = err instanceof Error ? err.message : typeof err === "object" && err !== null && typeof err.message === "string" ? err.message : String(err);
           return { type: "error", message: `Could not toggle bypass: ${msg}` };
         }
       }
@@ -24383,12 +24868,14 @@ function registerConfigCommands(registry, _core) {
   registerCategoryCommand(registry, core, "thought_level", "thought");
   registerDangerousCommand(registry, core);
 }
-var CATEGORY_LABELS;
+var log41, CATEGORY_LABELS;
 var init_config6 = __esm({
   "src/core/commands/config.ts"() {
     "use strict";
+    init_log();
     init_bypass_detection();
     init_bypass_detection();
+    log41 = createChildLogger({ module: "commands/config" });
     CATEGORY_LABELS = {
       mode: {
         menuTitle: (cur) => `Choose session mode (current: ${cur})`,
@@ -24781,7 +25268,7 @@ function installAutoStart(logDir2) {
       fs46.mkdirSync(dir, { recursive: true });
       fs46.writeFileSync(LAUNCHD_PLIST_PATH, plist);
       execFileSync7("launchctl", ["load", LAUNCHD_PLIST_PATH], { stdio: "pipe" });
-      log41.info("LaunchAgent installed");
+      log42.info("LaunchAgent installed");
       return { success: true };
     }
     if (process.platform === "linux") {
@@ -24791,13 +25278,13 @@ function installAutoStart(logDir2) {
       fs46.writeFileSync(SYSTEMD_SERVICE_PATH, unit);
       execFileSync7("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
       execFileSync7("systemctl", ["--user", "enable", "openacp"], { stdio: "pipe" });
-      log41.info("systemd user service installed");
+      log42.info("systemd user service installed");
       return { success: true };
     }
     return { success: false, error: "Unsupported platform" };
   } catch (e) {
     const msg = e.message;
-    log41.error({ err: msg }, "Failed to install auto-start");
+    log42.error({ err: msg }, "Failed to install auto-start");
     return { success: false, error: msg };
   }
 }
@@ -24813,7 +25300,7 @@ function uninstallAutoStart() {
         } catch {
         }
         fs46.unlinkSync(LAUNCHD_PLIST_PATH);
-        log41.info("LaunchAgent removed");
+        log42.info("LaunchAgent removed");
       }
       return { success: true };
     }
@@ -24825,14 +25312,14 @@ function uninstallAutoStart() {
         }
         fs46.unlinkSync(SYSTEMD_SERVICE_PATH);
         execFileSync7("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
-        log41.info("systemd user service removed");
+        log42.info("systemd user service removed");
       }
       return { success: true };
     }
     return { success: false, error: "Unsupported platform" };
   } catch (e) {
     const msg = e.message;
-    log41.error({ err: msg }, "Failed to uninstall auto-start");
+    log42.error({ err: msg }, "Failed to uninstall auto-start");
     return { success: false, error: msg };
   }
 }
@@ -24845,12 +25332,12 @@ function isAutoStartInstalled() {
   }
   return false;
 }
-var log41, LAUNCHD_LABEL, LAUNCHD_PLIST_PATH, SYSTEMD_SERVICE_PATH;
+var log42, LAUNCHD_LABEL, LAUNCHD_PLIST_PATH, SYSTEMD_SERVICE_PATH;
 var init_autostart = __esm({
   "src/cli/autostart.ts"() {
     "use strict";
     init_log();
-    log41 = createChildLogger({ module: "autostart" });
+    log42 = createChildLogger({ module: "autostart" });
     LAUNCHD_LABEL = "com.openacp.daemon";
     LAUNCHD_PLIST_PATH = path53.join(os24.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
     SYSTEMD_SERVICE_PATH = path53.join(os24.homedir(), ".config", "systemd", "user", "openacp.service");
@@ -24953,7 +25440,7 @@ async function setupIntegrations() {
       if (integration) {
         for (const item of integration.items) {
           const result = await item.install();
-          for (const log44 of result.logs) console.log(`  ${log44}`);
+          for (const log45 of result.logs) console.log(`  ${log45}`);
         }
       }
       console.log("Claude CLI integration installed.\n");
@@ -25911,14 +26398,14 @@ async function runPostUpgradeChecks(config) {
         const { ensureCloudflared: ensureCloudflared2 } = await Promise.resolve().then(() => (init_install_cloudflared(), install_cloudflared_exports));
         await ensureCloudflared2();
       } catch (err) {
-        log43.warn(
+        log44.warn(
           { err: err.message },
           "Could not install cloudflared. Tunnel may not work."
         );
       }
     } else {
       if (!commandExists(config.tunnel.provider)) {
-        log43.warn(
+        log44.warn(
           `Tunnel provider "${config.tunnel.provider}" is not installed. Install it or switch to cloudflare (free, auto-installed).`
         );
       }
@@ -25930,7 +26417,7 @@ async function runPostUpgradeChecks(config) {
     if (integration) {
       const allInstalled = integration.items.every((item) => item.isInstalled());
       if (!allInstalled) {
-        log43.info(
+        log44.info(
           'Claude CLI integration not installed. Run "openacp integrate claude" for session transfer + tunnel skill.'
         );
       }
@@ -25940,7 +26427,7 @@ async function runPostUpgradeChecks(config) {
           const { ensureJq: ensureJq2 } = await Promise.resolve().then(() => (init_install_jq(), install_jq_exports));
           await ensureJq2();
         } catch (err) {
-          log43.warn(
+          log44.warn(
             { err: err.message },
             "Could not install jq. Handoff hooks may not work."
           );
@@ -25950,7 +26437,7 @@ async function runPostUpgradeChecks(config) {
   } catch {
   }
   if (!commandExists("unzip")) {
-    log43.warn(
+    log44.warn(
       "unzip is not installed. Some agent installations (binary distribution) may fail. Install: brew install unzip (macOS) or apt install unzip (Linux)"
     );
   }
@@ -25963,20 +26450,20 @@ async function runPostUpgradeChecks(config) {
       (a) => a.distribution === "uvx"
     );
     if (hasUvxAgent && !commandExists("uvx")) {
-      log43.warn(
+      log44.warn(
         "uvx is not installed but you have Python-based agents. Install: pip install uv"
       );
     }
   } catch {
   }
 }
-var log43;
+var log44;
 var init_post_upgrade = __esm({
   "src/cli/post-upgrade.ts"() {
     "use strict";
     init_log();
     init_agent_dependencies();
-    log43 = createChildLogger({ module: "post-upgrade" });
+    log44 = createChildLogger({ module: "post-upgrade" });
   }
 });
 
@@ -26340,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");
@@ -29711,7 +30201,7 @@ a "Handoff" slash command to Claude Code.
     if (uninstall) {
       console.log(`Removing ${agent}/${item.id}...`);
       const result = await item.uninstall();
-      for (const log44 of result.logs) console.log(`  ${log44}`);
+      for (const log45 of result.logs) console.log(`  ${log45}`);
       if (result.success) {
         console.log(`  ${item.name} removed.`);
       } else {
@@ -29721,7 +30211,7 @@ a "Handoff" slash command to Claude Code.
     } else {
       console.log(`Installing ${agent}/${item.id}...`);
       const result = await item.install();
-      for (const log44 of result.logs) console.log(`  ${log44}`);
+      for (const log45 of result.logs) console.log(`  ${log45}`);
       if (result.success) {
         console.log(`  ${item.name} installed.`);
       } else {