@openacp/cli 2026.403.7 → 2026.404.1

package/dist/index.js

@@ -1078,7 +1078,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"];
   }
 });
 
@@ -8362,7 +8362,7 @@ var init_commands = __esm({
 
 // src/plugins/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard11 } from "grammy";
-import { nanoid as nanoid2 } from "nanoid";
+import { nanoid as nanoid3 } from "nanoid";
 var log30, PermissionHandler;
 var init_permissions = __esm({
   "src/plugins/telegram/permissions.ts"() {
@@ -8381,7 +8381,7 @@ var init_permissions = __esm({
       pending = /* @__PURE__ */ new Map();
       async sendPermissionRequest(session, request) {
         const threadId = Number(session.threadId);
-        const callbackKey = nanoid2(8);
+        const callbackKey = nanoid3(8);
         this.pending.set(callbackKey, {
           sessionId: session.id,
           requestId: request.id,
@@ -11182,6 +11182,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
         { sessionId: this.sessionId, exitCode: code, signal },
         "Agent process exited"
       );
+      if (signal === "SIGINT" || signal === "SIGTERM") return;
       if (code !== 0 && code !== null || signal) {
         const stderr = this.stderrCapture.getLastLines();
         this.emit("agent_event", {
@@ -11211,12 +11212,18 @@ ${stderr}`
       cwd: workingDirectory,
       mcpServers: resolvedMcp
     });
+    log4.info(response, "newSession response");
     instance.sessionId = response.sessionId;
     instance.initialSessionResponse = response;
     instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
     instance.setupCrashDetection();
     log4.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;
@@ -11228,24 +11235,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);
-      log4.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);
+        log4.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);
+        log4.info(
+          {
+            sessionId: response.sessionId,
+            durationMs: Date.now() - spawnStart,
+            agentCapabilities: instance.agentCapabilities ?? null
+          },
+          "Agent resume complete"
+        );
+      }
     } catch (err) {
       log4.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
@@ -11476,11 +11506,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({
@@ -11608,7 +11658,7 @@ var AgentManager = class {
 };
 
 // src/core/sessions/session.ts
-import { nanoid } from "nanoid";
+import { nanoid as nanoid2 } from "nanoid";
 
 // src/core/sessions/prompt-queue.ts
 var PromptQueue = class {
@@ -11619,21 +11669,21 @@ var PromptQueue = class {
   queue = [];
   processing = false;
   abortController = null;
-  async enqueue(text3, attachments) {
+  async enqueue(text3, attachments, routing) {
     if (this.processing) {
       return new Promise((resolve6) => {
-        this.queue.push({ text: text3, attachments, resolve: resolve6 });
+        this.queue.push({ text: text3, attachments, routing, resolve: resolve6 });
       });
     }
-    await this.process(text3, attachments);
+    await this.process(text3, attachments, routing);
   }
-  async process(text3, attachments) {
+  async process(text3, attachments, routing) {
     this.processing = true;
     this.abortController = new AbortController();
     const { signal } = this.abortController;
     try {
       await Promise.race([
-        this.processor(text3, attachments),
+        this.processor(text3, attachments, routing),
         new Promise((_, reject) => {
           signal.addEventListener("abort", () => reject(new Error("Prompt aborted")), { once: true });
         })
@@ -11651,7 +11701,7 @@ var PromptQueue = class {
   drainNext() {
     const next = this.queue.shift();
     if (next) {
-      this.process(next.text, next.attachments).then(next.resolve);
+      this.process(next.text, next.attachments, next.routing).then(next.resolve);
     }
   }
   clear() {
@@ -11741,6 +11791,33 @@ var PermissionGate = class {
 // src/core/sessions/session.ts
 init_log();
 import * as fs10 from "fs";
+
+// src/core/sessions/turn-context.ts
+import { nanoid } from "nanoid";
+function createTurnContext(sourceAdapterId, responseAdapterId) {
+  return {
+    turnId: nanoid(8),
+    sourceAdapterId,
+    responseAdapterId
+  };
+}
+function getEffectiveTarget(ctx) {
+  if (ctx.responseAdapterId === null) return null;
+  return ctx.responseAdapterId ?? ctx.sourceAdapterId;
+}
+var SYSTEM_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "session_end",
+  "system_message",
+  "session_info_update",
+  "config_option_update",
+  "commands_update",
+  "tts_strip"
+]);
+function isSystemEvent(event) {
+  return SYSTEM_EVENT_TYPES.has(event.type);
+}
+
+// src/core/sessions/session.ts
 var moduleLog = createChildLogger({ module: "session" });
 var TTS_PROMPT_INSTRUCTION = `
 
@@ -11758,7 +11835,15 @@ var VALID_TRANSITIONS = {
 var Session = class extends TypedEmitter {
   id;
   channelId;
-  threadId = "";
+  /** @deprecated Use threadIds map directly. Getter returns primary adapter's threadId. */
+  get threadId() {
+    return this.threadIds.get(this.channelId) ?? "";
+  }
+  set threadId(value) {
+    if (value) {
+      this.threadIds.set(this.channelId, value);
+    }
+  }
   agentName;
   workingDirectory;
   agentInstance;
@@ -11779,14 +11864,21 @@ var Session = class extends TypedEmitter {
   middlewareChain;
   /** Latest commands emitted by the agent — buffered before bridge connects so they're not lost */
   latestCommands = null;
+  /** Adapters currently attached to this session (including primary) */
+  attachedAdapters = [];
+  /** Per-adapter thread IDs: adapterId → threadId */
+  threadIds = /* @__PURE__ */ new Map();
+  /** Active turn context — sealed on prompt dequeue, cleared on turn end */
+  activeTurnContext = null;
   permissionGate = new PermissionGate();
   queue;
   speechService;
   pendingContext = null;
   constructor(opts) {
     super();
-    this.id = opts.id || nanoid(12);
+    this.id = opts.id || nanoid2(12);
     this.channelId = opts.channelId;
+    this.attachedAdapters = [opts.channelId];
     this.agentName = opts.agentName;
     this.firstAgent = opts.agentName;
     this.workingDirectory = opts.workingDirectory;
@@ -11796,18 +11888,28 @@ var Session = class extends TypedEmitter {
     this.log = createSessionLogger(this.id, moduleLog);
     this.log.info({ agentName: this.agentName }, "Session created");
     this.queue = new PromptQueue(
-      (text3, attachments) => this.processPrompt(text3, attachments),
+      (text3, attachments, routing) => this.processPrompt(text3, 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() {
@@ -11861,7 +11963,7 @@ var Session = class extends TypedEmitter {
     this.log.info({ voiceMode: mode }, "TTS mode changed");
   }
   // --- Public API ---
-  async enqueuePrompt(text3, attachments) {
+  async enqueuePrompt(text3, attachments, routing) {
     if (this.middlewareChain) {
       const payload = { text: text3, attachments, sessionId: this.id };
       const result = await this.middlewareChain.execute("agent:beforePrompt", payload, async (p) => p);
@@ -11869,10 +11971,14 @@ var Session = class extends TypedEmitter {
       text3 = result.text;
       attachments = result.attachments;
     }
-    await this.queue.enqueue(text3, attachments);
+    await this.queue.enqueue(text3, attachments, routing);
   }
-  async processPrompt(text3, attachments) {
+  async processPrompt(text3, 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") {
@@ -11939,6 +12045,7 @@ ${text3}`;
         this.log.warn({ err }, "TTS post-processing failed");
       });
     }
+    this.activeTurnContext = null;
     if (!this.name) {
       await this.autoName();
     }
@@ -12054,6 +12161,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);
   }
@@ -12073,8 +12216,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) {
@@ -12138,6 +12286,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() {
@@ -12605,6 +12756,8 @@ var SessionManager = class {
   }
   getSessionByThread(channelId, threadId) {
     for (const session of this.sessions.values()) {
+      const adapterThread = session.threadIds.get(channelId);
+      if (adapterThread === threadId) return session;
       if (session.channelId === channelId && session.threadId === threadId) {
         return session;
       }
@@ -12672,6 +12825,67 @@ var SessionManager = class {
     if (channelId) return all.filter((s) => s.channelId === channelId);
     return all;
   }
+  listAllSessions(channelId) {
+    if (this.store) {
+      let records = this.store.list();
+      if (channelId) records = records.filter((r) => r.channelId === channelId);
+      return records.map((record) => {
+        const live2 = this.sessions.get(record.sessionId);
+        if (live2) {
+          return {
+            id: live2.id,
+            agent: live2.agentName,
+            status: live2.status,
+            name: live2.name ?? null,
+            workspace: live2.workingDirectory,
+            channelId: live2.channelId,
+            createdAt: live2.createdAt.toISOString(),
+            lastActiveAt: record.lastActiveAt ?? null,
+            dangerousMode: live2.clientOverrides.bypassPermissions ?? false,
+            queueDepth: live2.queueDepth,
+            promptRunning: live2.promptRunning,
+            configOptions: live2.configOptions?.length ? live2.configOptions : void 0,
+            capabilities: live2.agentCapabilities ?? null,
+            isLive: true
+          };
+        }
+        return {
+          id: record.sessionId,
+          agent: record.agentName,
+          status: record.status,
+          name: record.name ?? null,
+          workspace: record.workingDir,
+          channelId: record.channelId,
+          createdAt: record.createdAt,
+          lastActiveAt: record.lastActiveAt ?? null,
+          dangerousMode: record.clientOverrides?.bypassPermissions ?? false,
+          queueDepth: 0,
+          promptRunning: false,
+          configOptions: record.acpState?.configOptions,
+          capabilities: record.acpState?.agentCapabilities ?? null,
+          isLive: false
+        };
+      });
+    }
+    let live = Array.from(this.sessions.values());
+    if (channelId) live = live.filter((s) => s.channelId === channelId);
+    return live.map((s) => ({
+      id: s.id,
+      agent: s.agentName,
+      status: s.status,
+      name: s.name ?? null,
+      workspace: s.workingDirectory,
+      channelId: s.channelId,
+      createdAt: s.createdAt.toISOString(),
+      lastActiveAt: null,
+      dangerousMode: s.clientOverrides.bypassPermissions ?? false,
+      queueDepth: s.queueDepth,
+      promptRunning: s.promptRunning,
+      configOptions: s.configOptions?.length ? s.configOptions : void 0,
+      capabilities: s.agentCapabilities ?? null,
+      isLive: true
+    }));
+  }
   listRecords(filter) {
     if (!this.store) return [];
     let records = this.store.list();
@@ -12694,7 +12908,14 @@ var SessionManager = class {
       for (const session of this.sessions.values()) {
         const record = this.store.get(session.id);
         if (record) {
-          await this.store.save({ ...record, status: "finished" });
+          await this.store.save({
+            ...record,
+            status: "finished",
+            acpState: session.toAcpStateSnapshot(),
+            clientOverrides: session.clientOverrides,
+            currentPromptCount: session.promptCount,
+            agentSwitchHistory: session.agentSwitchHistory
+          });
         }
       }
       this.store.flush();
@@ -12704,6 +12925,8 @@ var SessionManager = class {
   /**
    * Forcefully destroy all sessions (kill agent subprocesses).
    * Use only when sessions must be fully torn down (e.g. archive).
+   * Unlike shutdownAll(), this does NOT snapshot live session state (acpState, etc.)
+   * because destroyed sessions are terminal and will not be resumed.
    */
   async destroyAll() {
     if (this.store) {
@@ -12734,13 +12957,15 @@ init_log();
 init_bypass_detection();
 var log6 = createChildLogger({ module: "session-bridge" });
 var SessionBridge = class {
-  constructor(session, adapter, deps) {
+  constructor(session, adapter, deps, adapterId) {
     this.session = session;
     this.adapter = adapter;
     this.deps = deps;
+    this.adapterId = adapterId ?? adapter.name;
   }
   connected = false;
   cleanupFns = [];
+  adapterId;
   get tracer() {
     return this.session.agentInstance.debugTracer ?? null;
   }
@@ -12771,6 +12996,15 @@ var SessionBridge = class {
       log6.error({ err, sessionId }, "Error in sendMessage middleware");
     }
   }
+  /** Determine if this bridge should forward the given event based on turn routing. */
+  shouldForward(event) {
+    if (isSystemEvent(event)) return true;
+    const ctx = this.session.activeTurnContext;
+    if (!ctx) return true;
+    const target = getEffectiveTarget(ctx);
+    if (target === null) return false;
+    return this.adapterId === target;
+  }
   connect() {
     if (this.connected) return;
     this.connected = true;
@@ -12778,11 +13012,29 @@ var SessionBridge = class {
       this.session.emit("agent_event", event);
     });
     this.listen(this.session, "agent_event", (event) => {
-      this.dispatchAgentEvent(event);
+      if (this.shouldForward(event)) {
+        this.dispatchAgentEvent(event);
+      } else {
+        this.deps.eventBus?.emit("agent:event", { sessionId: this.session.id, event });
+      }
+    });
+    if (!this.session.agentInstance.onPermissionRequest || this.session.agentInstance.onPermissionRequest.__bridgeId === void 0) {
+      const handler = async (request) => {
+        return this.resolvePermission(request);
+      };
+      handler.__bridgeId = this.adapterId;
+      this.session.agentInstance.onPermissionRequest = handler;
+    }
+    this.listen(this.session, "permission_request", async (request) => {
+      const current = this.session.agentInstance.onPermissionRequest;
+      if (current?.__bridgeId === this.adapterId) return;
+      if (!this.session.permissionGate.isPending) return;
+      try {
+        await this.adapter.sendPermissionRequest(this.session.id, request);
+      } catch (err) {
+        log6.error({ err, sessionId: this.session.id, adapterId: this.adapterId }, "Failed to send permission request to adapter");
+      }
     });
-    this.session.agentInstance.onPermissionRequest = async (request) => {
-      return this.resolvePermission(request);
-    };
     this.listen(this.session, "status_change", (from, to) => {
       this.deps.sessionManager.patchRecord(this.session.id, {
         status: to,
@@ -12814,13 +13066,19 @@ var SessionBridge = class {
     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) {
@@ -12951,8 +13209,10 @@ var SessionBridge = class {
         this.sendMessage(this.session.id, outgoing);
         break;
       case "config_option_update":
-        this.session.updateConfigOptions(event.options);
-        this.persistAcpState();
+        this.session.updateConfigOptions(event.options).then(() => {
+          this.persistAcpState();
+        }).catch(() => {
+        });
         outgoing = this.deps.messageTransformer.transform(event);
         this.sendMessage(this.session.id, outgoing);
         break;
@@ -12996,19 +13256,27 @@ var SessionBridge = class {
         return result.autoResolve;
       }
     }
-    this.session.emit("permission_request", permReq);
     this.deps.eventBus?.emit("permission:request", {
       sessionId: this.session.id,
       permission: permReq
     });
     const autoDecision = this.checkAutoApprove(permReq);
     if (autoDecision) {
+      this.session.emit("permission_request", permReq);
       this.emitAfterResolve(mw, permReq.id, autoDecision, "system", startTime);
       return autoDecision;
     }
     const promise = this.session.permissionGate.setPending(permReq);
+    this.session.emit("permission_request", permReq);
     await this.adapter.sendPermissionRequest(this.session.id, permReq);
     const optionId = await promise;
+    this.deps.eventBus?.emit("permission:resolved", {
+      sessionId: this.session.id,
+      requestId: permReq.id,
+      decision: optionId,
+      optionId,
+      resolvedBy: this.adapterId
+    });
     this.emitAfterResolve(mw, permReq.id, optionId, "user", startTime);
     return optionId;
   }
@@ -13184,17 +13452,7 @@ var SessionFactory = class {
     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,
@@ -13212,6 +13470,65 @@ var SessionFactory = class {
     if (session) return session;
     return this.lazyResume(channelId, threadId);
   }
+  async getOrResumeById(sessionId) {
+    const live = this.sessionManager.getSession(sessionId);
+    if (live) return live;
+    if (!this.sessionStore || !this.createFullSession) return null;
+    const record = this.sessionStore.get(sessionId);
+    if (!record) return null;
+    if (record.status === "error" || record.status === "cancelled") return null;
+    const existing = this.resumeLocks.get(sessionId);
+    if (existing) return existing;
+    const resumePromise = (async () => {
+      try {
+        const p = record.platform;
+        const existingThreadId = p?.topicId ? String(p.topicId) : p?.threadId;
+        const session = await this.createFullSession({
+          channelId: record.channelId,
+          agentName: record.agentName,
+          workingDirectory: record.workingDir,
+          resumeAgentSessionId: record.agentSessionId,
+          existingSessionId: record.sessionId,
+          initialName: record.name,
+          threadId: existingThreadId
+        });
+        session.activate();
+        if (record.clientOverrides) {
+          session.clientOverrides = record.clientOverrides;
+        } else if (record.dangerousMode) {
+          session.clientOverrides = { bypassPermissions: true };
+        }
+        if (record.firstAgent) session.firstAgent = record.firstAgent;
+        if (record.agentSwitchHistory) session.agentSwitchHistory = record.agentSwitchHistory;
+        if (record.currentPromptCount != null) session.promptCount = record.currentPromptCount;
+        if (record.attachedAdapters) session.attachedAdapters = record.attachedAdapters;
+        if (record.platforms) {
+          for (const [adapterId, platformData] of Object.entries(record.platforms)) {
+            const data = platformData;
+            const tid = adapterId === "telegram" ? String(data.topicId ?? "") : String(data.threadId ?? "");
+            if (tid) session.threadIds.set(adapterId, tid);
+          }
+        }
+        if (record.acpState) {
+          if (record.acpState.configOptions && session.configOptions.length === 0) {
+            session.setInitialConfigOptions(record.acpState.configOptions);
+          }
+          if (record.acpState.agentCapabilities && !session.agentCapabilities) {
+            session.setAgentCapabilities(record.acpState.agentCapabilities);
+          }
+        }
+        log7.info({ sessionId }, "Lazy resume by ID successful");
+        return session;
+      } catch (err) {
+        log7.error({ err, sessionId }, "Lazy resume by ID failed");
+        return null;
+      } finally {
+        this.resumeLocks.delete(sessionId);
+      }
+    })();
+    this.resumeLocks.set(sessionId, resumePromise);
+    return resumePromise;
+  }
   async lazyResume(channelId, threadId) {
     const store = this.sessionStore;
     if (!store || !this.createFullSession) return null;
@@ -13220,7 +13537,7 @@ var SessionFactory = class {
     if (existing) return existing;
     const record = store.findByPlatform(
       channelId,
-      (p) => String(p.topicId) === threadId
+      (p) => String(p.topicId) === threadId || String(p.threadId ?? "") === threadId
     );
     if (!record) {
       log7.debug({ threadId, channelId }, "No session record found for thread");
@@ -13255,11 +13572,21 @@ var SessionFactory = class {
         if (record.firstAgent) session.firstAgent = record.firstAgent;
         if (record.agentSwitchHistory) session.agentSwitchHistory = record.agentSwitchHistory;
         if (record.currentPromptCount != null) session.promptCount = record.currentPromptCount;
+        if (record.attachedAdapters) {
+          session.attachedAdapters = record.attachedAdapters;
+        }
+        if (record.platforms) {
+          for (const [adapterId, platformData] of Object.entries(record.platforms)) {
+            const data = platformData;
+            const tid = adapterId === "telegram" ? String(data.topicId ?? "") : String(data.threadId ?? "");
+            if (tid) session.threadIds.set(adapterId, tid);
+          }
+        }
         if (record.acpState) {
-          if (record.acpState.configOptions) {
+          if (record.acpState.configOptions && session.configOptions.length === 0) {
             session.setInitialConfigOptions(record.acpState.configOptions);
           }
-          if (record.acpState.agentCapabilities) {
+          if (record.acpState.agentCapabilities && !session.agentCapabilities) {
             session.setAgentCapabilities(record.acpState.agentCapabilities);
           }
         }
@@ -13426,6 +13753,9 @@ var JsonFileSessionStore = class {
   }
   findByPlatform(channelId, predicate) {
     for (const record of this.records.values()) {
+      if (record.platforms?.[channelId]) {
+        if (predicate(record.platforms[channelId])) return record;
+      }
       if (record.channelId === channelId && predicate(record.platform)) {
         return record;
       }
@@ -13492,7 +13822,7 @@ var JsonFileSessionStore = class {
         return;
       }
       for (const [id, record] of Object.entries(raw.sessions)) {
-        this.records.set(id, record);
+        this.records.set(id, this.migrateRecord(record));
       }
       log8.debug({ count: this.records.size }, "Loaded session records");
     } catch (err) {
@@ -13503,6 +13833,19 @@ var JsonFileSessionStore = class {
       }
     }
   }
+  /** Migrate old SessionRecord format to new multi-adapter format. */
+  migrateRecord(record) {
+    if (!record.platforms && record.platform && typeof record.platform === "object") {
+      const platformData = record.platform;
+      if (Object.keys(platformData).length > 0) {
+        record.platforms = { [record.channelId]: platformData };
+      }
+    }
+    if (!record.attachedAdapters) {
+      record.attachedAdapters = [record.channelId];
+    }
+    return record;
+  }
   cleanup() {
     const cutoff = Date.now() - this.ttlDays * 24 * 60 * 60 * 1e3;
     let removed = 0;
@@ -13581,8 +13924,15 @@ var AgentSwitchHandler = class {
       toAgent,
       status: "starting"
     });
-    const bridge = bridges.get(sessionId);
-    if (bridge) bridge.disconnect();
+    const sessionBridgeKeys = this.deps.getSessionBridgeKeys(sessionId);
+    const hadBridges = sessionBridgeKeys.length > 0;
+    for (const key of sessionBridgeKeys) {
+      const bridge = bridges.get(key);
+      if (bridge) {
+        bridges.delete(key);
+        bridge.disconnect();
+      }
+    }
     const switchAdapter = adapters.get(session.channelId);
     if (switchAdapter?.sendSkillCommands) {
       await switchAdapter.sendSkillCommands(session.id, []);
@@ -13659,9 +14009,11 @@ var AgentSwitchHandler = class {
         session.agentInstance = oldInstance;
         session.agentName = fromAgent;
         session.agentSessionId = oldInstance.sessionId;
-        const adapter = adapters.get(session.channelId);
-        if (adapter) {
-          createBridge(session, adapter).connect();
+        for (const adapterId of session.attachedAdapters) {
+          const adapter = adapters.get(adapterId);
+          if (adapter) {
+            createBridge(session, adapter, adapterId).connect();
+          }
         }
         log9.warn({ sessionId, fromAgent, toAgent, err }, "Agent switch failed, rolled back to previous agent");
       } catch (rollbackErr) {
@@ -13670,10 +14022,14 @@ var AgentSwitchHandler = class {
       }
       throw err;
     }
-    if (bridge) {
-      const adapter = adapters.get(session.channelId);
-      if (adapter) {
-        createBridge(session, adapter).connect();
+    if (hadBridges) {
+      for (const adapterId of session.attachedAdapters) {
+        const adapter = adapters.get(adapterId);
+        if (adapter) {
+          createBridge(session, adapter, adapterId).connect();
+        } else {
+          log9.warn({ sessionId, adapterId }, "Adapter not available during switch reconnect, skipping bridge");
+        }
       }
     }
     await sessionManager.patchRecord(sessionId, {
@@ -15126,7 +15482,7 @@ var OpenACPCore = class {
   sessionManager;
   messageTransformer;
   adapters = /* @__PURE__ */ new Map();
-  /** sessionId → SessionBridge — tracks active bridges for disconnect/reconnect during agent switch */
+  /** "adapterId:sessionId" → SessionBridge — tracks active bridges for disconnect/reconnect */
   bridges = /* @__PURE__ */ new Map();
   /** Set by main.ts — triggers graceful shutdown with restart exit code */
   requestRestart = null;
@@ -15222,7 +15578,8 @@ var OpenACPCore = class {
       eventBus: this.eventBus,
       adapters: this.adapters,
       bridges: this.bridges,
-      createBridge: (session, adapter) => this.createBridge(session, adapter),
+      createBridge: (session, adapter, adapterId) => this.createBridge(session, adapter, adapterId),
+      getSessionBridgeKeys: (sessionId) => this.getSessionBridgeKeys(sessionId),
       getMiddlewareChain: () => this.lifecycleManager?.middlewareChain,
       getService: (name) => this.lifecycleManager.serviceRegistry.get(name)
     });
@@ -15402,7 +15759,7 @@ User message:
 ${text3}`;
       }
     }
-    await session.enqueuePrompt(text3, message.attachments);
+    await session.enqueuePrompt(text3, message.attachments, message.routing);
   }
   // --- Unified Session Creation Pipeline ---
   async createSession(params) {
@@ -15429,6 +15786,12 @@ ${text3}`;
         platform2.threadId = session.threadId;
       }
     }
+    const platforms = {
+      ...existingRecord?.platforms ?? {}
+    };
+    if (session.threadId) {
+      platforms[params.channelId] = params.channelId === "telegram" ? { topicId: Number(session.threadId) || session.threadId } : { threadId: session.threadId };
+    }
     await this.sessionManager.patchRecord(session.id, {
       sessionId: session.id,
       agentSessionId: session.agentSessionId,
@@ -15440,6 +15803,7 @@ ${text3}`;
       lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
       name: session.name,
       platform: platform2,
+      platforms,
       firstAgent: session.firstAgent,
       currentPromptCount: session.promptCount,
       agentSwitchHistory: session.agentSwitchHistory,
@@ -15447,7 +15811,7 @@ ${text3}`;
       acpState: session.toAcpStateSnapshot()
     }, { immediate: true });
     if (adapter) {
-      const bridge = this.createBridge(session, adapter);
+      const bridge = this.createBridge(session, adapter, session.channelId);
       bridge.connect();
       adapter.flushPendingSkillCommands?.(session.id).catch((err) => {
         log16.warn({ err, sessionId: session.id }, "Failed to flush pending skill commands");
@@ -15586,9 +15950,14 @@ ${text3}`;
     } else {
       adoptPlatform.threadId = session.threadId;
     }
+    const adoptPlatforms = {};
+    if (session.threadId) {
+      adoptPlatforms[adapterChannelId] = adapterChannelId === "telegram" ? { topicId: Number(session.threadId) || session.threadId } : { threadId: session.threadId };
+    }
     await this.sessionManager.patchRecord(session.id, {
       originalAgentSessionId: agentSessionId,
-      platform: adoptPlatform
+      platform: adoptPlatform,
+      platforms: adoptPlatforms
     });
     return {
       ok: true,
@@ -15610,18 +15979,101 @@ ${text3}`;
   async getOrResumeSession(channelId, threadId) {
     return this.sessionFactory.getOrResume(channelId, threadId);
   }
+  async getOrResumeSessionById(sessionId) {
+    return this.sessionFactory.getOrResumeById(sessionId);
+  }
+  async attachAdapter(sessionId, adapterId) {
+    const session = this.sessionManager.getSession(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    const adapter = this.adapters.get(adapterId);
+    if (!adapter) throw new Error(`Adapter "${adapterId}" not found or not running`);
+    if (session.attachedAdapters.includes(adapterId)) {
+      const existingThread = session.threadIds.get(adapterId) ?? session.id;
+      return { threadId: existingThread };
+    }
+    const threadId = await adapter.createSessionThread(
+      session.id,
+      session.name ?? `Session ${session.id.slice(0, 6)}`
+    );
+    session.threadIds.set(adapterId, threadId);
+    session.attachedAdapters.push(adapterId);
+    const bridge = this.createBridge(session, adapter, adapterId);
+    bridge.connect();
+    await this.sessionManager.patchRecord(session.id, {
+      attachedAdapters: session.attachedAdapters,
+      platforms: this.buildPlatformsFromSession(session)
+    });
+    return { threadId };
+  }
+  async detachAdapter(sessionId, adapterId) {
+    const session = this.sessionManager.getSession(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    if (adapterId === session.channelId) {
+      throw new Error("Cannot detach primary adapter (channelId)");
+    }
+    if (!session.attachedAdapters.includes(adapterId)) {
+      return;
+    }
+    const adapter = this.adapters.get(adapterId);
+    if (adapter) {
+      try {
+        await adapter.sendMessage(session.id, {
+          type: "system_message",
+          text: "Session detached from this adapter."
+        });
+      } catch {
+      }
+    }
+    const key = this.bridgeKey(adapterId, session.id);
+    const bridge = this.bridges.get(key);
+    if (bridge) {
+      bridge.disconnect();
+      this.bridges.delete(key);
+    }
+    session.attachedAdapters = session.attachedAdapters.filter((a) => a !== adapterId);
+    session.threadIds.delete(adapterId);
+    await this.sessionManager.patchRecord(session.id, {
+      attachedAdapters: session.attachedAdapters,
+      platforms: this.buildPlatformsFromSession(session)
+    });
+  }
+  buildPlatformsFromSession(session) {
+    const platforms = {};
+    for (const [adapterId, threadId] of session.threadIds) {
+      if (adapterId === "telegram") {
+        platforms.telegram = { topicId: Number(threadId) || threadId };
+      } else {
+        platforms[adapterId] = { threadId };
+      }
+    }
+    return platforms;
+  }
   // --- Event Wiring ---
+  /** Composite bridge key: "adapterId:sessionId" */
+  bridgeKey(adapterId, sessionId) {
+    return `${adapterId}:${sessionId}`;
+  }
+  /** Get all bridge keys for a session (regardless of adapter) */
+  getSessionBridgeKeys(sessionId) {
+    const keys = [];
+    for (const key of this.bridges.keys()) {
+      if (key.endsWith(`:${sessionId}`)) keys.push(key);
+    }
+    return keys;
+  }
   /** Connect a session bridge for the given session (used by AssistantManager) */
   connectSessionBridge(session) {
     const adapter = this.adapters.get(session.channelId);
     if (!adapter) return;
-    const bridge = this.createBridge(session, adapter);
+    const bridge = this.createBridge(session, adapter, session.channelId);
     bridge.connect();
   }
   /** Create a SessionBridge for the given session and adapter.
-   *  Disconnects any existing bridge for the same session first. */
-  createBridge(session, adapter) {
-    const existing = this.bridges.get(session.id);
+   *  Disconnects any existing bridge for the same adapter+session first. */
+  createBridge(session, adapter, adapterId) {
+    const id = adapterId ?? adapter.name;
+    const key = this.bridgeKey(id, session.id);
+    const existing = this.bridges.get(key);
     if (existing) {
       existing.disconnect();
     }
@@ -15632,8 +16084,8 @@ ${text3}`;
       eventBus: this.eventBus,
       fileService: this.fileService,
       middlewareChain: this.lifecycleManager?.middlewareChain
-    });
-    this.bridges.set(session.id, bridge);
+    }, id);
+    this.bridges.set(key, bridge);
     return bridge;
   }
 };
@@ -17668,12 +18120,14 @@ export {
   createApiServerService,
   createChildLogger,
   createSessionLogger,
+  createTurnContext,
   expandHome3 as expandHome,
   extractContentText,
   formatTokens,
   formatToolSummary,
   formatToolTitle,
   getConfigValue,
+  getEffectiveTarget,
   getFieldDef,
   getPidPath,
   getSafeFields,
@@ -17683,6 +18137,7 @@ export {
   isAutoStartInstalled,
   isAutoStartSupported,
   isHotReloadable,
+  isSystemEvent,
   log,
   nodeToWebReadable,
   nodeToWebWritable,