@qwen-code/qwen-code 0.22.2 → 0.22.3-nightly.20260831.3a0c4c6108

package/chunks/{chunk-E55H6BZ7.js → chunk-IXEZHTDR.js}

@@ -463,6 +463,18 @@ var CHANNEL_PROMPT_AUTHORIZATION_META_KEY = "qwen.daemon.channelPromptAuthorizat
 var CHANNEL_PROMPT_META_KEY = "qwen.channel.prompt";
 var ACP_PRIVATE_PARENT_CAPABILITY_META_KEY = "qwen-code/private-parent-capability";
 var ACP_PRIVATE_PARENT_CAPABILITY_ENV = "QWEN_CODE_PRIVATE_ACP_CAPABILITY";
+function resolvePromptImages(options) {
+  const images = options?.images && options.images.length > 0 ? options.images : options?.imageBase64 && options.imageMimeType ? [{ data: options.imageBase64, mimeType: options.imageMimeType }] : [];
+  return images.filter((image) => !!image && typeof image.data === "string" && image.data.length > 0 && typeof image.mimeType === "string" && image.mimeType.length > 0).map((image) => {
+    const cleaned = image.mimeType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+    return {
+      data: image.data,
+      // Normalize the alias like the daemon attachment store's own naming.
+      mimeType: cleaned === "image/jpg" ? "image/jpeg" : cleaned
+    };
+  });
+}
+__name(resolvePromptImages, "resolvePromptImages");
 
 // packages/channels/base/dist/ChannelLoopTools.js
 init_esbuild_shims();
@@ -791,11 +803,11 @@ var AcpBridge = class extends EventEmitter {
     this.on("slashCommandOutput", onSlashCommandOutput);
     this.on("responseBoundary", clearChunks);
     const prompt = [];
-    if (options?.imageBase64 && options.imageMimeType) {
+    for (const image of resolvePromptImages(options)) {
       prompt.push({
         type: "image",
-        data: options.imageBase64,
-        mimeType: options.imageMimeType
+        data: image.data,
+        mimeType: image.mimeType
       });
     }
     prompt.push({ type: "text", text });
@@ -1106,14 +1118,14 @@ init_esbuild_shims();
 // packages/channels/base/dist/PollingChannelBase.js
 init_esbuild_shims();
 import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join6 } from "node:path";
-import process3 from "node:process";
+import process4 from "node:process";
 
 // packages/channels/base/dist/ChannelBase.js
 init_esbuild_shims();
 import { basename as basename3, join as join5 } from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // packages/channels/base/dist/BlockStreamer.js
 init_esbuild_shims();
@@ -1153,6 +1165,10 @@ var BlockStreamer = class {
     this.clearIdleTimer();
     this.buffer = "";
   }
+  /** Await already-queued sends without emitting the buffered text. */
+  async drain() {
+    await this.sending;
+  }
   // ---------------------------------------------------------------------------
   // Internal
   // ---------------------------------------------------------------------------
@@ -1181,8 +1197,10 @@ var BlockStreamer = class {
     const trimmed = text.trim();
     if (!trimmed)
       return;
+    const block = /\n[^\S\n]*$/.test(text) ? `${trimmed}
+` : trimmed;
     this.blockCount++;
-    this.sending = this.sending.then(() => this.opts.send(trimmed)).catch(() => {
+    this.sending = this.sending.then(() => this.opts.send(block)).catch(() => {
     });
   }
   /**
@@ -1654,6 +1672,7 @@ var SessionRouter = class {
   defaultScope;
   channelScopes = /* @__PURE__ */ new Map();
   channelApprovalModes = /* @__PURE__ */ new Map();
+  channelsWithoutLoops = /* @__PURE__ */ new Set();
   persistPath;
   recoveryMode;
   constructor(bridge, defaultCwd, scope = "user", persistPath, options = {}) {
@@ -1666,6 +1685,7 @@ var SessionRouter = class {
   /** Replace the bridge instance (used after crash recovery restart). */
   setBridge(bridge) {
     this.bridge = bridge;
+    this.liveSessionIds.clear();
   }
   /** Set scope override for a specific channel. */
   setChannelScope(channelName, scope) {
@@ -1678,6 +1698,13 @@ var SessionRouter = class {
       this.channelApprovalModes.delete(channelName);
     }
   }
+  setChannelLoopsEnabled(channelName, enabled) {
+    if (enabled) {
+      this.channelsWithoutLoops.delete(channelName);
+    } else {
+      this.channelsWithoutLoops.add(channelName);
+    }
+  }
   routingKey(channelName, senderId, chatId, threadId) {
     const scope = this.channelScopes.get(channelName) || this.defaultScope;
     switch (scope) {
@@ -1694,7 +1721,12 @@ var SessionRouter = class {
   }
   sessionOptions(channelName) {
     const approvalMode = this.channelApprovalModes.get(channelName);
-    return approvalMode ? { approvalMode } : void 0;
+    const loopsDisabled = this.channelsWithoutLoops.has(channelName);
+    return {
+      ...approvalMode ? { approvalMode } : {},
+      ...loopsDisabled ? { enableChannelLoops: false } : {},
+      sourceId: channelName
+    };
   }
   async resolve(channelName, senderId, chatId, threadId, cwd, isGroup, options) {
     const key = this.routingKey(channelName, senderId, chatId, options?.routingThreadId ?? threadId);
@@ -1771,7 +1803,7 @@ var SessionRouter = class {
   async createAndStoreSession(key, input, operation) {
     const loadWindow = this.beginSessionLoad();
     try {
-      const sessionId = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation, input.channelName);
+      const sessionId = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
       try {
         this.assertOperationCurrent(operation);
       } catch (error) {
@@ -1827,7 +1859,7 @@ var SessionRouter = class {
       } catch (loadError) {
         this.assertOperationCurrent(operation);
         try {
-          const replacement = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation, input.channelName);
+          const replacement = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
           try {
             this.assertOperationCurrent(operation);
           } catch (error) {
@@ -1863,6 +1895,9 @@ var SessionRouter = class {
   getTarget(sessionId) {
     return this.toTarget.get(sessionId);
   }
+  isSessionLive(sessionId) {
+    return this.toTarget.has(sessionId) && this.isLive(sessionId);
+  }
   getSession(channelName, senderId, chatId, threadId) {
     return this.toSession.get(this.routingKey(channelName, senderId, chatId, threadId));
   }
@@ -1881,6 +1916,120 @@ var SessionRouter = class {
     }
     return false;
   }
+  getSessionCwd(sessionId) {
+    return this.toCwd.get(sessionId);
+  }
+  async createManagedSession(target, cwd) {
+    const loadWindow = this.beginSessionLoad();
+    const lifecycleGeneration = this.lifecycleGeneration;
+    const bridge = this.bridge;
+    const bindingToken = {};
+    try {
+      let lastDeadSessionId;
+      for (let attempt = 0; attempt < 2; attempt++) {
+        const sessionId = await bridge.newSession(cwd, {
+          ...this.sessionOptions(target.channelName),
+          sourceId: target.channelName
+        }, bindingToken);
+        if (lifecycleGeneration !== this.lifecycleGeneration || bridge !== this.bridge) {
+          this.scheduleManagedDiscard(bridge, sessionId, bindingToken);
+          throw new Error("Managed session creation was invalidated");
+        }
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw new Error("Invalid session ID from bridge");
+        }
+        if (loadWindow.delete(sessionId)) {
+          lastDeadSessionId = sessionId;
+          await bridge.discardSession?.(sessionId, bindingToken);
+          continue;
+        }
+        this.toTarget.set(sessionId, target);
+        this.toCwd.set(sessionId, cwd);
+        this.liveSessionIds.add(sessionId);
+        return sessionId;
+      }
+      throw new Error(`Managed session ${lastDeadSessionId ?? "unknown"} died before creation completed`);
+    } finally {
+      this.endSessionLoad(loadWindow);
+    }
+  }
+  async loadManagedSession(sessionId, target, cwd) {
+    if (this.liveSessionIds.has(sessionId)) {
+      this.toTarget.set(sessionId, target);
+      this.toCwd.set(sessionId, cwd);
+      return { loaded: false };
+    }
+    const loadWindow = this.beginSessionLoad();
+    const lifecycleGeneration = this.lifecycleGeneration;
+    const bridge = this.bridge;
+    const bindingToken = {};
+    let loadedSessionId;
+    try {
+      loadedSessionId = await bridge.loadSession(sessionId, cwd, this.sessionOptions(target.channelName), bindingToken);
+      if (lifecycleGeneration !== this.lifecycleGeneration || bridge !== this.bridge) {
+        this.scheduleManagedDiscard(bridge, loadedSessionId, bindingToken);
+        loadedSessionId = void 0;
+        throw new Error("Managed session load was invalidated");
+      }
+      if (loadedSessionId !== sessionId) {
+        const unexpectedSessionId = loadedSessionId;
+        await bridge.discardSession?.(unexpectedSessionId, bindingToken);
+        loadedSessionId = void 0;
+        throw new Error(`Bridge returned session ${unexpectedSessionId || "unknown"} while loading ${sessionId}`);
+      }
+      if (loadWindow.delete(sessionId)) {
+        throw new Error(`Managed session ${sessionId} died before loading completed`);
+      }
+      this.toTarget.set(sessionId, target);
+      this.toCwd.set(sessionId, cwd);
+      this.liveSessionIds.add(sessionId);
+      return { loaded: true };
+    } catch (error) {
+      if (loadedSessionId) {
+        await bridge.discardSession?.(loadedSessionId, bindingToken).catch(() => void 0);
+      }
+      throw error;
+    } finally {
+      this.endSessionLoad(loadWindow);
+    }
+  }
+  activateManagedSession(sessionId, target, cwd) {
+    const key = this.routingKey(target.channelName, target.senderId, target.chatId, target.threadId);
+    if (this.toSession.get(key) === sessionId)
+      return;
+    this.invalidateRouteOperation(key);
+    this.toSession.set(key, sessionId);
+    this.toTarget.set(sessionId, target);
+    this.toCwd.set(sessionId, cwd);
+    this.persist();
+  }
+  forgetManagedSession(sessionId) {
+    let changed = false;
+    for (const [key, mappedSessionId] of this.toSession) {
+      if (mappedSessionId !== sessionId)
+        continue;
+      this.invalidateRouteOperation(key);
+      this.toSession.delete(key);
+      changed = true;
+    }
+    changed = this.toTarget.delete(sessionId) || changed;
+    changed = this.toCwd.delete(sessionId) || changed;
+    changed = this.liveSessionIds.delete(sessionId) || changed;
+    if (changed)
+      this.persist();
+  }
+  async detachManagedSession(sessionId) {
+    try {
+      if (this.liveSessionIds.has(sessionId)) {
+        if (!this.bridge.discardSession) {
+          throw new Error("Managed session detach is not supported");
+        }
+        await this.bridge.discardSession(sessionId);
+      }
+    } finally {
+      this.forgetManagedSession(sessionId);
+    }
+  }
   /**
    * Remove session(s) for the given sender. Returns the removed session IDs.
    */
@@ -2055,6 +2204,7 @@ var SessionRouter = class {
           this.toSession.set(key, sessionId);
           this.toTarget.set(sessionId, entry.target);
           this.toCwd.set(sessionId, entry.cwd);
+          this.liveSessionIds.add(sessionId);
           reservation.resolve(sessionId);
           if (sessionId !== entry.sessionId) {
             changed = true;
@@ -2193,11 +2343,11 @@ var SessionRouter = class {
       }
     }
   }
-  async createLiveSession(cwd, loadWindow, routingKey, options, operation, sourceId) {
+  async createLiveSession(cwd, loadWindow, routingKey, options, operation) {
     const maxAttempts = 2;
     let lastDeadSessionId;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const sessionId = await this.bridge.newSession(cwd, { ...options, sourceId }, operation);
+      const sessionId = await this.bridge.newSession(cwd, options, operation);
       try {
         this.assertOperationCurrent(operation);
       } catch (error) {
@@ -2278,6 +2428,12 @@ var SessionRouter = class {
     } catch {
     }
   }
+  scheduleManagedDiscard(bridge, sessionId, bindingToken) {
+    try {
+      void bridge.discardSession?.(sessionId, bindingToken).catch(() => void 0);
+    } catch {
+    }
+  }
   createSessionReservation() {
     let resolveReservation;
     let rejectReservation;
@@ -2296,6 +2452,676 @@ var SessionRouter = class {
   }
 };
 
+// packages/channels/base/dist/named-session-manager.js
+init_esbuild_shims();
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { chmodSync as chmodSync3, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync4, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
+import process3 from "node:process";
+var REGISTRY_VERSION = 1;
+var MAX_OPEN_TASKS = 8;
+var TASK_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/;
+var NamedSessionManager = class {
+  static {
+    __name(this, "NamedSessionManager");
+  }
+  channelName;
+  cwd;
+  canonicalCwd;
+  filePath;
+  router;
+  isBusy;
+  now;
+  registry;
+  taskBySessionId;
+  ownerOperations = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.channelName = options.channelName;
+    this.cwd = options.cwd;
+    this.canonicalCwd = canonicalizeWorkspacePath(options.cwd);
+    this.filePath = options.filePath;
+    this.router = options.router;
+    this.isBusy = options.isBusy;
+    this.now = options.now ?? Date.now;
+    this.registry = this.readRegistry();
+    this.taskBySessionId = this.buildTaskIndex(this.registry);
+  }
+  presentation(sessionId) {
+    const reference = this.taskBySessionId.get(sessionId);
+    return reference ? this.cloneTaskReference(reference) : void 0;
+  }
+  async resolvePresentation(sessionId) {
+    const existing = this.presentation(sessionId);
+    if (existing)
+      return existing;
+    const target = this.router.getTarget(sessionId);
+    if (target?.channelName !== this.channelName || this.router.getSession(this.channelName, target.senderId, target.chatId) !== sessionId) {
+      return void 0;
+    }
+    return this.withOwnerLock(target, async () => {
+      const concurrent = this.presentation(sessionId);
+      if (concurrent)
+        return concurrent;
+      if (this.getOwner(target))
+        return void 0;
+      const routedTarget = this.router.getTarget(sessionId);
+      if (routedTarget?.channelName !== this.channelName || routedTarget.chatId !== target.chatId || routedTarget.senderId !== target.senderId || this.router.getSession(this.channelName, target.senderId, target.chatId) !== sessionId) {
+        return void 0;
+      }
+      const routedCwd = this.router.getSessionCwd(sessionId);
+      if (routedCwd !== void 0 && !this.isCurrentCwd(routedCwd)) {
+        return void 0;
+      }
+      const timestamp = this.nextTimestamp();
+      const task = {
+        name: "default",
+        sessionId,
+        cwd: routedCwd ?? this.cwd,
+        isolation: "shared",
+        status: "open",
+        target: routedTarget,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        lastSelectedAt: timestamp
+      };
+      this.commitOwner(this.createOwner(routedTarget, task.name, [task]));
+      return this.presentation(sessionId);
+    });
+  }
+  resolve(input, reserve) {
+    return this.withOwnerLock(input, () => this.resolveLocked(input, reserve));
+  }
+  resolveAfterPreparation(input, prepare, needsSession, reserve) {
+    return this.withOwnerLock(input, async () => {
+      if (await prepare() === false)
+        return { status: "aborted" };
+      if (!needsSession())
+        return { status: "bypassed" };
+      try {
+        return {
+          status: "resolved",
+          sessionId: await this.resolveLocked(input, reserve)
+        };
+      } catch (error) {
+        return { status: "resolve_error", error };
+      }
+    });
+  }
+  list(input, includeClosed) {
+    return this.withOwnerLock(input, async () => {
+      const owner = await this.ensureOwner(input, false);
+      if (!owner)
+        return [];
+      return owner.tasks.filter((task) => includeClosed || task.status === "open").map((task) => this.view(owner, task));
+    });
+  }
+  current(input) {
+    return this.withOwnerLock(input, async () => {
+      const owner = await this.ensureOwner(input, false);
+      if (!owner?.activeTaskName)
+        return void 0;
+      const task = this.findTask(owner, owner.activeTaskName);
+      return task ? this.selection(owner, task) : void 0;
+    });
+  }
+  lookup(input, name) {
+    return this.withOwnerLock(input, async () => {
+      const owner = await this.ensureOwner(input, false);
+      if (!owner)
+        return void 0;
+      const task = this.findTask(owner, name);
+      return task ? this.selection(owner, task) : void 0;
+    });
+  }
+  resumeReserved(input, sessionId) {
+    return this.withOwnerLock(input, async () => {
+      const owner = await this.ensureOwner(input, false);
+      const task = owner?.tasks.find((candidate) => candidate.sessionId === sessionId && candidate.status === "open");
+      if (!task)
+        return false;
+      await this.loadTask(task, `Could not reload reserved task "${task.name}".`);
+      return true;
+    });
+  }
+  create(input, name) {
+    return this.withOwnerLock(input, async () => {
+      this.validateName(name);
+      const existingOwner = await this.ensureOwner(input, false);
+      const owner = existingOwner ?? this.createOwner(input, null, []);
+      if (this.findTask(owner, name)) {
+        throw new Error(`Task "${name}" already exists.`);
+      }
+      if (this.openTaskCount(owner) >= MAX_OPEN_TASKS) {
+        throw new Error("You already have eight open tasks. Close one before creating another.");
+      }
+      const timestamp = this.nextTimestamp(owner);
+      const target = this.target(input);
+      const sessionId = await this.createSession(target, this.cwd, `Could not create task "${name}".`);
+      const task = {
+        name,
+        sessionId,
+        cwd: this.cwd,
+        isolation: "shared",
+        status: "open",
+        target,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        lastSelectedAt: timestamp
+      };
+      const nextOwner = {
+        ...owner,
+        activeTaskName: name,
+        tasks: [...owner.tasks, task]
+      };
+      try {
+        this.commitOwner(nextOwner);
+      } catch (error) {
+        await this.router.detachManagedSession(sessionId).catch(() => void 0);
+        throw error;
+      }
+      this.router.activateManagedSession(sessionId, target, this.cwd);
+      return this.selection(nextOwner, task);
+    });
+  }
+  use(input, name) {
+    return this.withOwnerLock(input, async () => {
+      const owner = await this.ensureOwner(input, false);
+      if (!owner)
+        throw new Error("No named tasks exist in this chat.");
+      const task = this.findTask(owner, name);
+      if (!task)
+        throw new Error(`Task "${name}" was not found.`);
+      if (task.status === "closed" && this.openTaskCount(owner) >= MAX_OPEN_TASKS) {
+        throw new Error("You already have eight open tasks. Close one before reopening another.");
+      }
+      const timestamp = this.nextTimestamp(owner);
+      const loaded = await this.loadTask(task, `Could not load task "${task.name}". The current task was not changed.`);
+      const updatedTask = {
+        ...task,
+        status: "open",
+        updatedAt: timestamp,
+        lastSelectedAt: timestamp
+      };
+      const nextOwner = this.replaceTask(owner, updatedTask, task.name);
+      try {
+        this.commitOwner(nextOwner);
+      } catch (error) {
+        if (loaded) {
+          await this.router.detachManagedSession(task.sessionId).catch(() => void 0);
+        }
+        throw error;
+      }
+      this.router.activateManagedSession(task.sessionId, task.target, task.cwd);
+      return this.selection(nextOwner, updatedTask);
+    });
+  }
+  close(input, name) {
+    return this.withOwnerLock(input, async () => {
+      const owner = await this.ensureOwner(input, false);
+      if (!owner)
+        throw new Error("No named tasks exist in this chat.");
+      const task = this.findTask(owner, name);
+      if (!task)
+        throw new Error(`Task "${name}" was not found.`);
+      if (task.status === "closed") {
+        throw new Error(`Task "${task.name}" is already closed.`);
+      }
+      if (this.isBusy(task.sessionId)) {
+        throw new Error(`Task "${task.name}" is still running or waiting for permission.`);
+      }
+      const wasActive = this.sameName(owner.activeTaskName, task.name);
+      const timestamp = this.nextTimestamp(owner);
+      const replacement = wasActive ? owner.tasks.filter((candidate) => candidate.status === "open" && !this.sameName(candidate.name, task.name)).sort((a, b) => b.lastSelectedAt - a.lastSelectedAt)[0] : void 0;
+      let replacementLoaded = false;
+      if (replacement) {
+        replacementLoaded = await this.loadTask(replacement, `Could not load fallback task "${replacement.name}". Task "${task.name}" was not closed.`);
+      }
+      const closedTask = {
+        ...task,
+        status: "closed",
+        updatedAt: timestamp
+      };
+      let nextOwner = this.replaceTask(owner, closedTask, wasActive ? replacement?.name ?? null : owner.activeTaskName);
+      const selectedReplacement = replacement ? {
+        ...replacement,
+        updatedAt: timestamp,
+        lastSelectedAt: timestamp
+      } : void 0;
+      if (selectedReplacement) {
+        nextOwner = this.replaceTask(nextOwner, selectedReplacement, selectedReplacement.name);
+      }
+      try {
+        this.commitOwner(nextOwner);
+      } catch (error) {
+        if (replacement && replacementLoaded) {
+          await this.router.detachManagedSession(replacement.sessionId).catch(() => void 0);
+        }
+        throw error;
+      }
+      if (replacement) {
+        this.router.activateManagedSession(replacement.sessionId, replacement.target, replacement.cwd);
+      }
+      try {
+        await this.router.detachManagedSession(task.sessionId);
+      } catch (error) {
+        this.commitOwner(owner);
+        this.router.forgetManagedSession(task.sessionId);
+        await this.loadTask(task, `Task "${task.name}" could not be restored after close failed.`);
+        if (wasActive) {
+          this.router.activateManagedSession(task.sessionId, task.target, task.cwd);
+        }
+        throw new Error(`Failed to close task "${task.name}".`, {
+          cause: error
+        });
+      }
+      const activeTask = nextOwner.activeTaskName ? this.findTask(nextOwner, nextOwner.activeTaskName) : void 0;
+      return {
+        closed: this.view(nextOwner, closedTask),
+        ...activeTask ? { active: this.view(nextOwner, activeTask) } : {}
+      };
+    });
+  }
+  reset(input) {
+    return this.withOwnerLock(input, async () => {
+      const owner = await this.ensureOwner(input, false);
+      if (!owner?.activeTaskName)
+        return void 0;
+      const task = this.findTask(owner, owner.activeTaskName);
+      if (!task || task.status !== "open")
+        return void 0;
+      const timestamp = this.nextTimestamp(owner);
+      const sessionId = await this.createSession(task.target, task.cwd, `Could not reset task "${task.name}".`);
+      const updatedTask = {
+        ...task,
+        sessionId,
+        updatedAt: timestamp,
+        lastSelectedAt: timestamp
+      };
+      const nextOwner = this.replaceTask(owner, updatedTask, task.name);
+      try {
+        this.commitOwner(nextOwner);
+      } catch (error) {
+        await this.router.detachManagedSession(sessionId).catch(() => void 0);
+        throw error;
+      }
+      this.router.activateManagedSession(sessionId, updatedTask.target, updatedTask.cwd);
+      this.router.forgetManagedSession(task.sessionId);
+      return {
+        name: task.name,
+        previousSessionId: task.sessionId,
+        sessionId
+      };
+    });
+  }
+  async ensureOwner(input, createDefault) {
+    const existing = this.getOwner(input);
+    if (existing)
+      return existing;
+    const sessionId = this.router.getSession(this.channelName, input.senderId, input.chatId);
+    const routedTarget = sessionId ? this.router.getTarget(sessionId) : void 0;
+    if (sessionId && routedTarget && (routedTarget.channelName !== this.channelName || routedTarget.chatId !== input.chatId || routedTarget.senderId !== input.senderId)) {
+      this.adoptForeignLegacyRoute(sessionId, routedTarget);
+    }
+    if (sessionId && routedTarget?.channelName === this.channelName && routedTarget.chatId === input.chatId && routedTarget.senderId === input.senderId) {
+      const routedCwd = this.router.getSessionCwd(sessionId);
+      if (routedCwd !== void 0 && !this.isCurrentCwd(routedCwd)) {
+        await this.router.detachManagedSession(sessionId).catch(() => void 0);
+      } else {
+        const timestamp2 = this.nextTimestamp();
+        const task2 = {
+          name: "default",
+          sessionId,
+          cwd: routedCwd ?? this.cwd,
+          isolation: "shared",
+          status: "open",
+          target: routedTarget,
+          createdAt: timestamp2,
+          updatedAt: timestamp2,
+          lastSelectedAt: timestamp2
+        };
+        const adopted = this.createOwner(input, task2.name, [task2]);
+        this.commitOwner(adopted);
+        return adopted;
+      }
+    }
+    if (!createDefault)
+      return void 0;
+    const target = this.target(input);
+    const timestamp = this.nextTimestamp();
+    const createdSessionId = await this.createSession(target, this.cwd, "Could not create the default task.");
+    const task = {
+      name: "default",
+      sessionId: createdSessionId,
+      cwd: this.cwd,
+      isolation: "shared",
+      status: "open",
+      target,
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      lastSelectedAt: timestamp
+    };
+    const created = this.createOwner(input, task.name, [task]);
+    try {
+      this.commitOwner(created);
+    } catch (error) {
+      await this.router.detachManagedSession(createdSessionId).catch(() => void 0);
+      throw error;
+    }
+    this.router.activateManagedSession(createdSessionId, target, this.cwd);
+    return created;
+  }
+  async resolveLocked(input, reserve) {
+    const owner = await this.ensureOwner(input, true);
+    if (!owner?.activeTaskName)
+      return void 0;
+    const task = this.findTask(owner, owner.activeTaskName);
+    if (!task || task.status !== "open") {
+      throw new Error("The selected Channel task is unavailable.");
+    }
+    const release = reserve?.(task.sessionId);
+    try {
+      await this.loadTask(task, `Could not load task "${task.name}". No replacement session was created.`);
+      this.router.activateManagedSession(task.sessionId, task.target, task.cwd);
+      return task.sessionId;
+    } catch (error) {
+      release?.();
+      throw error;
+    }
+  }
+  adoptForeignLegacyRoute(sessionId, target) {
+    const cwd = this.router.getSessionCwd(sessionId);
+    if (target.channelName !== this.channelName || cwd === void 0 || !this.isCurrentCwd(cwd)) {
+      this.router.forgetManagedSession(sessionId);
+      return;
+    }
+    const existing = this.getOwner(target);
+    if (existing) {
+      if (existing.tasks.some((task2) => task2.sessionId === sessionId))
+        return;
+      this.router.forgetManagedSession(sessionId);
+      return;
+    }
+    const timestamp = this.nextTimestamp();
+    const task = {
+      name: "default",
+      sessionId,
+      cwd,
+      isolation: "shared",
+      status: "open",
+      target,
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      lastSelectedAt: timestamp
+    };
+    this.commitOwner(this.createOwner(target, task.name, [task]));
+  }
+  async loadTask(task, failureMessage) {
+    try {
+      return (await this.router.loadManagedSession(task.sessionId, task.target, task.cwd)).loaded;
+    } catch (error) {
+      throw new Error(failureMessage, { cause: error });
+    }
+  }
+  async createSession(target, cwd, failureMessage) {
+    try {
+      return await this.router.createManagedSession(target, cwd);
+    } catch (error) {
+      throw new Error(failureMessage, { cause: error });
+    }
+  }
+  withOwnerLock(input, operation) {
+    const key = JSON.stringify([
+      this.channelName,
+      input.chatId,
+      input.senderId
+    ]);
+    const previous = this.ownerOperations.get(key) ?? Promise.resolve();
+    const result = previous.catch(() => void 0).then(operation);
+    const tail = result.then(() => void 0, () => void 0);
+    this.ownerOperations.set(key, tail);
+    return result.finally(() => {
+      if (this.ownerOperations.get(key) === tail) {
+        this.ownerOperations.delete(key);
+      }
+    });
+  }
+  getOwner(input) {
+    const owner = this.registry.owners.find((candidate) => candidate.channelName === this.channelName && candidate.chatId === input.chatId && candidate.senderId === input.senderId);
+    return owner ? this.cloneOwner(owner) : void 0;
+  }
+  createOwner(input, activeTaskName, tasks) {
+    return {
+      channelName: this.channelName,
+      chatId: input.chatId,
+      senderId: input.senderId,
+      activeTaskName,
+      tasks
+    };
+  }
+  target(input) {
+    return {
+      channelName: this.channelName,
+      senderId: input.senderId,
+      chatId: input.chatId,
+      ...input.threadId !== void 0 ? { threadId: input.threadId } : {},
+      ...input.isGroup !== void 0 ? { isGroup: input.isGroup } : {}
+    };
+  }
+  findTask(owner, name) {
+    const normalized = this.normalizeName(name);
+    return owner.tasks.find((task) => this.normalizeName(task.name) === normalized);
+  }
+  replaceTask(owner, task, activeTaskName) {
+    return {
+      ...owner,
+      activeTaskName,
+      tasks: owner.tasks.map((candidate) => this.sameName(candidate.name, task.name) ? task : candidate)
+    };
+  }
+  view(owner, task) {
+    return {
+      name: task.name,
+      status: task.status,
+      isolation: task.isolation,
+      active: task.status === "open" && this.sameName(owner.activeTaskName, task.name)
+    };
+  }
+  selection(owner, task) {
+    return { ...this.view(owner, task), sessionId: task.sessionId };
+  }
+  openTaskCount(owner) {
+    return owner.tasks.filter((task) => task.status === "open").length;
+  }
+  nextTimestamp(owner) {
+    const now = this.now();
+    if (!Number.isSafeInteger(now) || now < 0) {
+      throw new Error("Invalid named-session clock value.");
+    }
+    let timestamp = now;
+    for (const task of owner?.tasks ?? []) {
+      timestamp = Math.max(timestamp, task.createdAt + 1, task.updatedAt + 1, task.lastSelectedAt + 1);
+    }
+    if (!Number.isSafeInteger(timestamp)) {
+      throw new Error("Named-session timestamp limit reached.");
+    }
+    return timestamp;
+  }
+  validateName(name) {
+    if (!TASK_NAME_PATTERN.test(name)) {
+      throw new Error("Task names must be 1-32 ASCII letters, numbers, underscores, or hyphens and start with a letter or number.");
+    }
+  }
+  normalizeName(name) {
+    return name.toLowerCase();
+  }
+  sameName(a, b) {
+    return a !== null && this.normalizeName(a) === this.normalizeName(b);
+  }
+  cloneOwner(owner) {
+    return {
+      ...owner,
+      tasks: owner.tasks.map((task) => ({
+        ...task,
+        target: { ...task.target }
+      }))
+    };
+  }
+  cloneTaskReference(reference) {
+    return { ...reference, target: { ...reference.target } };
+  }
+  buildTaskIndex(registry) {
+    const index = /* @__PURE__ */ new Map();
+    for (const owner of registry.owners) {
+      for (const task of owner.tasks) {
+        index.set(task.sessionId, {
+          taskName: task.name,
+          status: task.status,
+          target: { ...task.target }
+        });
+      }
+    }
+    return index;
+  }
+  commitOwner(owner) {
+    const owners = this.registry.owners.map((candidate) => candidate.channelName === owner.channelName && candidate.chatId === owner.chatId && candidate.senderId === owner.senderId ? owner : candidate);
+    if (!owners.some((candidate) => candidate.channelName === owner.channelName && candidate.chatId === owner.chatId && candidate.senderId === owner.senderId)) {
+      owners.push(owner);
+    }
+    const next = { version: REGISTRY_VERSION, owners };
+    if (!this.isRegistry(next)) {
+      throw new Error("Invalid named-session registry update.");
+    }
+    const nextTaskBySessionId = this.buildTaskIndex(next);
+    this.writeRegistry(next);
+    this.registry = next;
+    this.taskBySessionId = nextTaskBySessionId;
+  }
+  readRegistry() {
+    if (!existsSync4(this.filePath)) {
+      return { version: REGISTRY_VERSION, owners: [] };
+    }
+    let value;
+    try {
+      value = JSON.parse(readFileSync4(this.filePath, "utf8"));
+    } catch (error) {
+      throw new Error(`Failed to read named-session registry: ${this.filePath}`, {
+        cause: error
+      });
+    }
+    if (!this.isRegistry(value)) {
+      if (this.isRegistry(value, false)) {
+        const stalePath = `${this.filePath}.stale-${randomUUID2()}`;
+        try {
+          renameSync4(this.filePath, stalePath);
+        } catch (error) {
+          throw new Error("Failed to archive stale named-session registry.", {
+            cause: error
+          });
+        }
+        process3.stderr.write("[NamedSessionManager] Archived a stale registry after the channel working directory changed.\n");
+        return { version: REGISTRY_VERSION, owners: [] };
+      }
+      throw new Error(`Invalid named-session registry: ${this.filePath}`);
+    }
+    return value;
+  }
+  writeRegistry(registry) {
+    const dir = dirname4(this.filePath);
+    const tempPath = `${this.filePath}.${process3.pid}-${randomUUID2()}.tmp`;
+    try {
+      mkdirSync4(dir, { recursive: true, mode: 448 });
+      try {
+        chmodSync3(dir, 448);
+      } catch {
+      }
+      writeFileSync4(tempPath, JSON.stringify(registry, null, 2), {
+        encoding: "utf8",
+        mode: 384
+      });
+      renameSync4(tempPath, this.filePath);
+      try {
+        chmodSync3(this.filePath, 384);
+      } catch {
+      }
+    } catch (error) {
+      throw new Error("Failed to persist named-session registry.", {
+        cause: error
+      });
+    } finally {
+      try {
+        rmSync2(tempPath, { force: true });
+      } catch {
+      }
+    }
+  }
+  isRegistry(value, requireCurrentCwd = true) {
+    if (!this.isRecord(value) || value["version"] !== REGISTRY_VERSION) {
+      return false;
+    }
+    const owners = value["owners"];
+    if (!Array.isArray(owners))
+      return false;
+    const ownerKeys = /* @__PURE__ */ new Set();
+    const sessionIds = /* @__PURE__ */ new Set();
+    for (const owner of owners) {
+      if (!this.isOwner(owner, ownerKeys, sessionIds, requireCurrentCwd)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isOwner(value, ownerKeys, sessionIds, requireCurrentCwd) {
+    if (!this.isRecord(value))
+      return false;
+    const channelName = value["channelName"];
+    const chatId = value["chatId"];
+    const senderId = value["senderId"];
+    const activeTaskName = value["activeTaskName"];
+    const tasks = value["tasks"];
+    if (channelName !== this.channelName || typeof chatId !== "string" || typeof senderId !== "string" || activeTaskName !== null && typeof activeTaskName !== "string" || !Array.isArray(tasks)) {
+      return false;
+    }
+    const ownerKey = JSON.stringify([channelName, chatId, senderId]);
+    if (ownerKeys.has(ownerKey))
+      return false;
+    ownerKeys.add(ownerKey);
+    const names = /* @__PURE__ */ new Set();
+    let openTasks = 0;
+    let activeFound = activeTaskName === null;
+    for (const task of tasks) {
+      if (!this.isTask(task, channelName, chatId, senderId, requireCurrentCwd)) {
+        return false;
+      }
+      const normalized = this.normalizeName(task.name);
+      if (names.has(normalized) || sessionIds.has(task.sessionId))
+        return false;
+      names.add(normalized);
+      sessionIds.add(task.sessionId);
+      if (task.status === "open")
+        openTasks++;
+      if (activeTaskName !== null && task.status === "open" && this.sameName(activeTaskName, task.name)) {
+        activeFound = true;
+      }
+    }
+    return openTasks <= MAX_OPEN_TASKS && activeFound;
+  }
+  isTask(value, channelName, chatId, senderId, requireCurrentCwd) {
+    if (!this.isRecord(value) || !this.isRecord(value["target"]))
+      return false;
+    const target = value["target"];
+    return typeof value["name"] === "string" && TASK_NAME_PATTERN.test(value["name"]) && typeof value["sessionId"] === "string" && value["sessionId"].length > 0 && typeof value["cwd"] === "string" && (!requireCurrentCwd || this.isCurrentCwd(value["cwd"])) && value["isolation"] === "shared" && (value["status"] === "open" || value["status"] === "closed") && this.isTimestamp(value["createdAt"]) && this.isTimestamp(value["updatedAt"]) && this.isTimestamp(value["lastSelectedAt"]) && target["channelName"] === channelName && target["chatId"] === chatId && target["senderId"] === senderId && (target["threadId"] === void 0 || typeof target["threadId"] === "string") && (target["isGroup"] === void 0 || typeof target["isGroup"] === "boolean");
+  }
+  isCurrentCwd(cwd) {
+    return canonicalizeWorkspacePath(cwd) === this.canonicalCwd;
+  }
+  isTimestamp(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+  }
+  isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+};
+
 // packages/channels/base/dist/ChannelLoopScheduler.js
 init_esbuild_shims();
 var MAX_RESULT_PREVIEW_LENGTH = 500;
@@ -2990,6 +3816,7 @@ var ChannelBase = class {
   groupPairingNotified = /* @__PURE__ */ new Map();
   loopController;
   observedContacts;
+  namedSessions;
   observedContactEnvelopes = /* @__PURE__ */ new WeakSet();
   instructedSessions = /* @__PURE__ */ new Set();
   unattendedMemorySessions = /* @__PURE__ */ new Set();
@@ -2998,6 +3825,9 @@ var ChannelBase = class {
   commands = /* @__PURE__ */ new Map();
   /** Per-session promise chain to serialize prompt + send (followup mode). */
   sessionQueues = /* @__PURE__ */ new Map();
+  queuedTurns = /* @__PURE__ */ new Map();
+  namedTurnBindings = /* @__PURE__ */ new WeakMap();
+  inboundErrorSourceLabels = /* @__PURE__ */ new WeakMap();
   registerBridgeEvents;
   bridgeRecovery;
   /**
@@ -3066,15 +3896,43 @@ var ChannelBase = class {
     this.onToolCall(chatId, event);
   }
   async dispatchBackgroundResponse(sessionId, text) {
-    const target = this.router.getTarget(sessionId);
+    let target = this.router.getTarget(sessionId);
     if (!target || target.channelName !== this.name || text.trim().length === 0) {
       return;
     }
+    let sourceLabel;
+    if (this.namedSessions) {
+      const presentation = await this.namedSessions.resolvePresentation(sessionId);
+      const currentTarget = this.router.getTarget(sessionId);
+      const currentPresentation = this.namedSessions.presentation(sessionId);
+      if (!presentation || presentation.status !== "open" || !currentTarget || !this.router.isSessionLive(sessionId) || !currentPresentation || currentPresentation.status !== "open" || currentPresentation.taskName !== presentation.taskName || !this.sameTaskOwner(target, currentTarget) || !this.sameTaskOwner(currentTarget, currentPresentation.target)) {
+        throw new Error("Named background response ownership is unavailable.");
+      }
+      target = currentTarget;
+      sourceLabel = this.createSourceLabel(presentation, target);
+    }
     if (this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
-      await this.pushProactive(target, text);
+      if (sourceLabel) {
+        await this.pushProactive(target, text, sourceLabel);
+      } else {
+        await this.pushProactive(target, text);
+      }
       return;
     }
-    await this.sendResponseMessage(target.chatId, text, sessionId);
+    if (sourceLabel) {
+      await this.deliverBackgroundReply(target.chatId, text, sessionId, sourceLabel);
+    } else {
+      await this.deliverBackgroundReply(target.chatId, text, sessionId);
+    }
+  }
+  /**
+   * Fallback delivery of a background response when proactive send is
+   * unavailable. Adapters whose turn replies bypass sendResponseMessage (to
+   * stay out of turn-scoped streaming state, for example) override only this
+   * step instead of re-implementing the whole dispatch flow.
+   */
+  async deliverBackgroundReply(chatId, text, sessionId, sourceLabel) {
+    await this.sendResponseMessage(chatId, text, sessionId, sourceLabel);
   }
   async dispatchPermissionRequest(event) {
     const target = this.permissionTargetForEvent(event);
@@ -3089,12 +3947,59 @@ var ChannelBase = class {
       }
       return;
     }
+    let sourceLabel;
+    let taskName;
+    if (this.namedSessions) {
+      let presentation;
+      try {
+        presentation = await this.namedSessions.resolvePresentation(event.sessionId);
+      } catch (err) {
+        try {
+          await this.bridge.respondToPermission?.(event.requestId, {
+            outcome: { outcome: "cancelled" }
+          });
+        } catch (respondErr) {
+          process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}
+`);
+        }
+        throw err;
+      }
+      const currentTarget = this.permissionTargetForEvent(event);
+      const currentPresentation = this.namedSessions.presentation(event.sessionId);
+      if (!presentation || presentation.status !== "open" || !currentTarget || !this.router.isSessionLive(event.sessionId) || !currentPresentation || currentPresentation.status !== "open" || currentPresentation.taskName !== presentation.taskName || !this.sameTaskOwner(target, currentTarget) || !this.sameTaskOwner(currentTarget, currentPresentation.target)) {
+        try {
+          await this.bridge.respondToPermission?.(event.requestId, {
+            outcome: { outcome: "cancelled" }
+          });
+        } catch (respondErr) {
+          process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}
+`);
+        }
+        return;
+      }
+      const active = this.activePrompts.get(event.sessionId);
+      sourceLabel = active ? active.sourceLabel : this.createSourceLabel(presentation, target);
+      if (!sourceLabel) {
+        try {
+          await this.bridge.respondToPermission?.(event.requestId, {
+            outcome: { outcome: "cancelled" }
+          });
+        } catch (respondErr) {
+          process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}
+`);
+        }
+        return;
+      }
+      taskName = presentation.taskName;
+    }
     this.removePendingPermission(event.requestId);
     const pending = {
       requestId: event.requestId,
       sessionId: event.sessionId,
       target,
       request: event.request,
+      ...sourceLabel ? { sourceLabel } : {},
+      ...taskName ? { taskName } : {},
       settlementListeners: /* @__PURE__ */ new Set()
     };
     this.pendingPermissions.set(event.requestId, pending);
@@ -3109,9 +4014,9 @@ var ChannelBase = class {
       }
       const text = this.formatPermissionRequest(pending);
       if (target.threadId !== void 0 && this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
-        await this.pushProactive(target, text);
+        await this.pushProactive(target, text, pending.sourceLabel);
       } else {
-        await this.sendThreadMessage(target.chatId, target.threadId, text);
+        await this.sendThreadMessage(target.chatId, target.threadId, text, pending.sourceLabel);
       }
     } catch (err) {
       this.removePendingPermission(event.requestId, "cancelled");
@@ -3141,6 +4046,7 @@ var ChannelBase = class {
       runId: active.runId,
       owner: active.owner,
       target: pending.target,
+      ...pending.sourceLabel ? { sourceLabel: pending.sourceLabel } : {},
       ...precedingSegment ? { precedingSegmentId: precedingSegment.segmentId } : {},
       questions,
       submitOptionId,
@@ -3295,6 +4201,21 @@ var ChannelBase = class {
     this.dmGate = new DmGate(config.dmPolicy);
     this.gate = new SenderGate(config.senderPolicy, config.allowedUsers, pairingStore);
     this.router = options?.router || new SessionRouter(bridge, config.cwd, config.sessionScope);
+    if (config.multiSession) {
+      if (config.sessionScope !== "user") {
+        throw new Error(`Channel "${name}" requires sessionScope "user" when multiSession is enabled.`);
+      }
+      if (!options?.stateDir) {
+        throw new Error(`Channel "${name}" multiSession is available only in daemon-managed mode.`);
+      }
+      this.namedSessions = new NamedSessionManager({
+        channelName: name,
+        cwd: config.cwd,
+        filePath: join5(options.stateDir, "named-sessions.json"),
+        router: this.router,
+        isBusy: /* @__PURE__ */ __name((sessionId) => this.isNamedSessionBusy(sessionId), "isBusy")
+      });
+    }
     this.registerSharedCommands();
     if (this.loopController) {
       bridge.registerChannelLoopToolHandler?.(this.channelLoopToolHandler);
@@ -3309,8 +4230,8 @@ var ChannelBase = class {
    * on a specific issue/PR. The default falls through to sendMessage(chatId,
    * text), ignoring threadId — existing IM adapters are behaviorally unchanged.
    */
-  async sendThreadMessage(chatId, _threadId, text) {
-    await this.sendMessage(chatId, text);
+  async sendThreadMessage(chatId, _threadId, text, sourceLabel) {
+    await this.sendMessage(chatId, this.formatAttributedText(text, sourceLabel));
   }
   /**
    * Adapter hook for task lifecycle events — the canonical way to track task
@@ -3452,13 +4373,14 @@ var ChannelBase = class {
       segmentId,
       owner: active.owner,
       target: resolvedTarget,
+      ...active.sourceLabel ? { sourceLabel: active.sourceLabel } : {},
       ...active.messageId ? { messageId: active.messageId } : {}
     };
   }
   ensureOutputSegment(sessionId, active) {
     if (!active.owner)
       return void 0;
-    const segmentId = active.activeSegmentId ?? randomUUID2();
+    const segmentId = active.activeSegmentId ?? randomUUID3();
     const context = this.outputSegmentContext(sessionId, active, segmentId);
     if (context)
       active.activeSegmentId = segmentId;
@@ -3493,11 +4415,11 @@ var ChannelBase = class {
   supportsProactiveWebhookTarget(target) {
     return this.supportsProactiveTarget(target);
   }
-  async pushProactive(target, text) {
+  async pushProactive(target, text, sourceLabel) {
     if (target.threadId) {
       throw new Error("Channel does not support proactive loop messages for threaded targets.");
     }
-    await this.sendThreadMessage(target.chatId, target.threadId, text);
+    await this.sendThreadMessage(target.chatId, target.threadId, text, sourceLabel);
   }
   async pushProactiveDelivery(target, text) {
     try {
@@ -3687,8 +4609,11 @@ var ChannelBase = class {
       imageBase64: void 0,
       imageMimeType: void 0
     };
+    if (this.namedSessions) {
+      this.bindNamedTurn(syntheticEnvelope, sessionId);
+    }
     this.markPreflighted(syntheticEnvelope);
-    this.processInbound(syntheticEnvelope).catch((err) => {
+    void this.processPreflightedInbound(syntheticEnvelope).catch((err) => {
       process.stderr.write(`[${this.name}] dropped ${lost} buffered message(s) after ${taskLabel} for session ${sessionId} (last sender ${lastEnvelope.senderId}): ${err instanceof Error ? err.message : String(err)}
 `);
     });
@@ -3784,7 +4709,7 @@ ${promptText}` : promptText;
         doneResolve = resolve3;
       });
       const promptState = {
-        runId: randomUUID2(),
+        runId: randomUUID3(),
         cancelled: false,
         done,
         resolve: doneResolve,
@@ -4000,7 +4925,7 @@ ${promptText}` : promptText;
         doneResolve = resolve3;
       });
       const promptState = {
-        runId: randomUUID2(),
+        runId: randomUUID3(),
         cancelled: false,
         done,
         resolve: doneResolve,
@@ -4333,11 +5258,11 @@ ${promptText}` : promptText;
    */
   onResponseBoundary(_chatId, _sessionId) {
   }
-  async sendResponseMessage(chatId, text, sessionId) {
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel) {
     const active = this.activePrompts.get(sessionId);
     const target = this.router.getTarget(sessionId);
     const threadId = active?.threadId ?? target?.threadId;
-    await this.sendThreadMessage(chatId, threadId, text);
+    await this.sendThreadMessage(chatId, threadId, text, sourceLabel ?? active?.sourceLabel);
   }
   /**
    * Adapter hook for delivery-only metadata. The response delivery path can read
@@ -4352,6 +5277,12 @@ ${promptText}` : promptText;
   getResponseMetadata(sessionId) {
     return this.activePrompts.get(sessionId)?.metadata;
   }
+  getResponseSourceLabel(sessionId) {
+    return this.activePrompts.get(sessionId)?.sourceLabel;
+  }
+  getInboundErrorSourceLabel(envelope) {
+    return this.inboundErrorSourceLabels.get(envelope);
+  }
   /**
    * Returns the active prompt's response thread while it remains available for
    * adapter delivery. Falls back to the session target after prompt cleanup.
@@ -4364,8 +5295,8 @@ ${promptText}` : promptText;
    * Override to customize delivery (e.g., finalize an AI card).
    * Default: sends the full response text.
    */
-  async onResponseComplete(chatId, fullText, sessionId, _segment) {
-    await this.sendResponseMessage(chatId, fullText, sessionId);
+  async onResponseComplete(chatId, fullText, sessionId, segment) {
+    await this.sendResponseMessage(chatId, fullText, sessionId, segment?.sourceLabel);
   }
   /**
    * Register a slash command handler. Subclasses can call this to add
@@ -4381,7 +5312,7 @@ ${promptText}` : promptText;
         await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can cancel requests in this shared session.");
         return true;
       }
-      const activeSessionId = this.findActiveSessionId(envelope);
+      const activeSessionId = this.namedSessions ? await this.findNamedActiveSessionId(envelope) : this.findActiveSessionId(envelope);
       if (!activeSessionId) {
         await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No request is currently running.");
         return true;
@@ -4470,7 +5401,7 @@ ${promptText}` : promptText;
     }
     return "resolved_outside_presenter";
   }
-  pendingPermissionForEnvelope(envelope, args) {
+  pendingPermissionForEnvelope(envelope, args, selectedSessionId) {
     const trimmed = args.trim();
     if (trimmed) {
       const explicit = this.pendingPermissions.get(trimmed);
@@ -4483,7 +5414,7 @@ ${promptText}` : promptText;
     if (requestIds.length === 0) {
       return { kind: "none", explicit: false };
     }
-    const matching = requestIds.map((id) => this.pendingPermissions.get(id)).filter((pending) => pending !== void 0 && this.canEnvelopeAnswerPendingPermission(envelope, pending));
+    const matching = requestIds.map((id) => this.pendingPermissions.get(id)).filter((pending) => pending !== void 0 && (selectedSessionId === void 0 || pending.sessionId === selectedSessionId) && this.canEnvelopeAnswerPendingPermission(envelope, pending));
     if (matching.length === 0) {
       return { kind: "none", explicit: false };
     }
@@ -4502,6 +5433,23 @@ ${promptText}` : promptText;
     const { toolCall } = pending.request;
     const title = sanitizeQuotedText(toolCall.title || "Tool use", 160);
     const alwaysOption = this.approvalAlwaysOption(pending);
+    if (pending.taskName) {
+      const replies2 = [
+        `/approve ${pending.requestId}          allow once`,
+        ...alwaysOption ? [`/approve-always ${pending.requestId}   ${alwaysOption.label}`] : [],
+        `/deny ${pending.requestId}             deny`
+      ];
+      return [
+        "Permission required to run a tool",
+        `Request: ${pending.requestId}`,
+        "",
+        "Command:",
+        title,
+        "",
+        "Reply with:",
+        ...replies2
+      ].join("\n");
+    }
     const replies = [
       "/approve        allow once",
       ...alwaysOption ? [`/approve-always ${alwaysOption.label}`] : [],
@@ -4557,28 +5505,40 @@ ${promptText}` : promptText;
       await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can answer permission requests in this shared session.");
       return true;
     }
-    const lookup = this.pendingPermissionForEnvelope(envelope, args);
+    const namedSessions = this.namedSessions;
+    const bareNamedCommand = namedSessions !== void 0 && args.trim() === "";
+    let selectedTask;
+    if (bareNamedCommand) {
+      try {
+        selectedTask = await namedSessions.current(this.namedSessionOwner(envelope));
+      } catch (error) {
+        await this.sendNamedSessionError(envelope, error);
+        return true;
+      }
+    }
+    const lookup = this.pendingPermissionForEnvelope(envelope, args, bareNamedCommand ? selectedTask?.sessionId ?? null : void 0);
     if (lookup.kind === "ambiguous") {
       const requestList = lookup.requestIds.slice(0, 6).map((id) => {
         const pending2 = this.pendingPermissions.get(id);
         const title = pending2 ? `: ${sanitizeQuotedText(pending2.request.toolCall.title || "Tool use", 160)}` : "";
-        return `- ${sanitizeQuotedText(id, 128)}${title}`;
+        const task = pending2?.taskName ? `Task ${pending2.taskName} \u2014 ` : "";
+        return `- ${task}${sanitizeQuotedText(id, 128)}${title}`;
       }).join("\n");
       await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Multiple permission requests are pending for this chat. Reply with /${decision} <request-id>.
 ${requestList}`);
       return true;
     }
     if (lookup.kind === "none") {
-      await this.sendThreadMessage(envelope.chatId, envelope.threadId, lookup.explicit ? "No pending permission request with that id for this chat." : "No pending permission request for this chat.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, lookup.explicit ? "No pending permission request with that id for this chat." : selectedTask ? `No pending permission request for selected task "${selectedTask.name}". Use an explicit request ID to answer another task.` : this.namedSessions ? "No task is currently selected. Use an explicit request ID to answer a named task." : "No pending permission request for this chat.");
       return true;
     }
+    const { pending } = lookup;
     if (!this.bridge.respondToPermission) {
-      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Permission relay is not available for this session.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Permission relay is not available for this session.", pending.sourceLabel);
       return true;
     }
-    const { pending } = lookup;
     if (pending.userInputPresented && decision !== "deny") {
-      await this.sendMessage(envelope.chatId, "Submit this question through its interactive card, or use /deny [request-id] to cancel it.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Submit this question through its interactive card, or use /deny [request-id] to cancel it.", pending.sourceLabel);
       return true;
     }
     const response = (() => {
@@ -4589,7 +5549,7 @@ ${requestList}`);
       return optionId ? { outcome: { outcome: "selected", optionId } } : void 0;
     })();
     if (!response) {
-      await this.sendThreadMessage(envelope.chatId, envelope.threadId, decision === "approve-always" ? "This permission request has no always-allow option." : "This permission request has no approvable option.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, decision === "approve-always" ? "This permission request has no always-allow option." : "This permission request has no approvable option.", pending.sourceLabel);
       return true;
     }
     let accepted;
@@ -4599,17 +5559,228 @@ ${requestList}`);
       this.removePendingPermission(pending.requestId);
       process.stderr.write(`[${this.name}] permission response failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}
 `);
-      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Failed to answer the permission request.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Failed to answer the permission request.", pending.sourceLabel);
       return true;
     }
     this.removePendingPermission(pending.requestId);
-    await this.sendThreadMessage(envelope.chatId, envelope.threadId, accepted ? decision === "approve" ? "Permission approved." : decision === "approve-always" ? "Permission approved always." : "Permission denied." : "Permission request is no longer pending.");
+    await this.sendThreadMessage(envelope.chatId, envelope.threadId, accepted ? decision === "approve" ? "Permission approved." : decision === "approve-always" ? "Permission approved always." : "Permission denied." : "Permission request is no longer pending.", pending.sourceLabel);
+    return true;
+  }
+  namedSessionOwner(envelope) {
+    return {
+      senderId: envelope.senderId,
+      chatId: envelope.chatId,
+      ...envelope.threadId !== void 0 ? { threadId: envelope.threadId } : {},
+      ...envelope.isGroup !== void 0 ? { isGroup: envelope.isGroup } : {}
+    };
+  }
+  async currentSessionId(envelope) {
+    if (this.namedSessions) {
+      return (await this.namedSessions.current(this.namedSessionOwner(envelope)))?.sessionId;
+    }
+    return this.router.getSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+  }
+  reserveQueuedTurn(sessionId) {
+    this.queuedTurns.set(sessionId, (this.queuedTurns.get(sessionId) ?? 0) + 1);
+  }
+  releaseQueuedTurn(sessionId) {
+    const remaining = (this.queuedTurns.get(sessionId) ?? 1) - 1;
+    if (remaining === 0) {
+      this.queuedTurns.delete(sessionId);
+    } else {
+      this.queuedTurns.set(sessionId, remaining);
+    }
+  }
+  bindNamedTurn(envelope, sessionId) {
+    const binding = {
+      sessionId,
+      generation: this.sessionGenerations.get(sessionId) ?? 0,
+      claimed: false,
+      released: false
+    };
+    this.namedTurnBindings.set(envelope, binding);
+    this.reserveQueuedTurn(sessionId);
+    return binding;
+  }
+  releaseNamedTurnBinding(binding) {
+    if (binding.sessionId === null || binding.claimed || binding.released) {
+      return;
+    }
+    binding.released = true;
+    this.releaseQueuedTurn(binding.sessionId);
+  }
+  finishNamedTurnBinding(envelope) {
+    const binding = this.namedTurnBindings.get(envelope);
+    if (!binding)
+      return;
+    this.releaseNamedTurnBinding(binding);
+    this.namedTurnBindings.delete(envelope);
+  }
+  bypassesNamedTurnBinding(envelope) {
+    const parsed = this.parseCommand(envelope.text);
+    if (parsed && this.commands.has(parsed.command))
+      return true;
+    const bangText = envelope.text.trimStart();
+    return bangText.startsWith("!") && (envelope.isGroup || this.isSharedSession(envelope));
+  }
+  async prepareNamedTurnBinding(envelope) {
+    const namedSessions = this.namedSessions;
+    if (!namedSessions || this.namedTurnBindings.has(envelope))
+      return true;
+    if (this.bypassesNamedTurnBinding(envelope))
+      return true;
+    try {
+      const sessionId = await namedSessions.resolve(this.namedSessionOwner(envelope), (resolvedSessionId) => {
+        const binding = this.bindNamedTurn(envelope, resolvedSessionId);
+        return () => this.releaseNamedTurnBinding(binding);
+      });
+      if (!sessionId && !this.namedTurnBindings.has(envelope)) {
+        this.namedTurnBindings.set(envelope, {
+          sessionId: null,
+          generation: 0,
+          claimed: false,
+          released: true
+        });
+      }
+      return true;
+    } catch (error) {
+      this.finishNamedTurnBinding(envelope);
+      await this.sendNamedSessionError(envelope, error);
+      return false;
+    }
+  }
+  isNamedSessionBusy(sessionId) {
+    if ((this.queuedTurns.get(sessionId) ?? 0) > 0)
+      return true;
+    if (this.activePrompts.has(sessionId))
+      return true;
+    for (const permission of this.pendingPermissions.values()) {
+      if (permission.sessionId === sessionId)
+        return true;
+    }
+    try {
+      return this.bridge.listSessions?.().some((session) => session.sessionId === sessionId && session.hasActivePrompt) ?? false;
+    } catch {
+      return true;
+    }
+  }
+  async sendNamedSessionError(envelope, error) {
+    const message = error instanceof Error ? sanitizeDisplayText(error.message, 500) : "Named-session operation failed.";
+    await this.sendThreadMessage(envelope.chatId, envelope.threadId, message || "Named-session operation failed.");
+  }
+  async handleNamedSessionsCommand(envelope, args) {
+    const namedSessions = this.namedSessions;
+    if (!namedSessions)
+      return false;
+    const normalized = args.trim().toLowerCase();
+    if (normalized !== "" && normalized !== "all") {
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Usage: /sessions [all]");
+      return true;
+    }
+    try {
+      const tasks = await namedSessions.list(this.namedSessionOwner(envelope), normalized === "all");
+      if (tasks.length === 0) {
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, normalized === "all" ? "No named tasks." : "No open named tasks.");
+        return true;
+      }
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, [
+        normalized === "all" ? "Tasks:" : "Open tasks:",
+        ...tasks.map((task) => `${task.active ? "*" : "-"} ${task.name} (${task.status}, ${task.isolation})`)
+      ].join("\n"));
+    } catch (error) {
+      await this.sendNamedSessionError(envelope, error);
+    }
+    return true;
+  }
+  async handleNamedSessionCommand(envelope, args) {
+    const namedSessions = this.namedSessions;
+    if (!namedSessions)
+      return false;
+    const parts = args.trim().split(/\s+/u).filter(Boolean);
+    const subcommand = parts.shift()?.toLowerCase() ?? "";
+    const owner = this.namedSessionOwner(envelope);
+    try {
+      switch (subcommand) {
+        case "current": {
+          if (parts.length > 0)
+            break;
+          const current = await namedSessions.current(owner);
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, current ? `Current task: ${current.name} (${current.isolation})` : "No task is currently selected. Use /session new <name> or /session use <name>.");
+          return true;
+        }
+        case "new": {
+          if (parts.includes("--worktree")) {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Worktree tasks are planned for Part 4. Create a shared task with /session new <name>.");
+            return true;
+          }
+          if (parts.length !== 1)
+            break;
+          const created = await namedSessions.create(owner, parts[0]);
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Created and selected task "${created.name}" (shared workspace).`);
+          return true;
+        }
+        case "use": {
+          if (parts.length !== 1)
+            break;
+          const selected = await namedSessions.use(owner, parts[0]);
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Selected task "${selected.name}" (${selected.isolation} workspace).`);
+          return true;
+        }
+        case "close": {
+          if (parts.length !== 1)
+            break;
+          const result = await namedSessions.close(owner, parts[0]);
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, result.active ? `Closed task "${result.closed.name}". Selected "${result.active.name}".` : `Closed task "${result.closed.name}". No task is selected.`);
+          return true;
+        }
+        case "cancel": {
+          if (parts.length > 1)
+            break;
+          const taskName = parts[0];
+          const task = taskName ? await namedSessions.lookup(owner, taskName) : await namedSessions.current(owner);
+          if (!task) {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, taskName ? `Task "${sanitizeQuotedText(taskName, 32)}" was not found.` : "No task is currently selected.");
+            return true;
+          }
+          if (task.status !== "open") {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Task "${task.name}" is closed.`);
+            return true;
+          }
+          if (!this.activePrompts.has(task.sessionId)) {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No request is currently running for task "${task.name}".`);
+            return true;
+          }
+          const cancelled = await this.requestActivePromptCancellation(task.sessionId, "cancel_command");
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, cancelled ? `Cancelled task "${task.name}".` : `Failed to cancel task "${task.name}".`);
+          return true;
+        }
+        default:
+          break;
+      }
+    } catch (error) {
+      await this.sendNamedSessionError(envelope, error);
+      return true;
+    }
+    await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Usage: /session current | /session new <name> | /session use <name> | /session close <name> | /session cancel [<name>]");
     return true;
   }
   /** Register shared slash commands. Called from constructor. */
   registerSharedCommands() {
     const doClear = /* @__PURE__ */ __name(async (envelope) => {
-      const removedIds = this.router.removeSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+      let resetTaskName;
+      let removedIds;
+      if (this.namedSessions) {
+        try {
+          const reset = await this.namedSessions.reset(this.namedSessionOwner(envelope));
+          resetTaskName = reset?.name;
+          removedIds = reset ? [reset.previousSessionId] : [];
+        } catch (error) {
+          await this.sendNamedSessionError(envelope, error);
+          return;
+        }
+      } else {
+        removedIds = this.router.removeSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+      }
       this.clearPendingGroupHistory(envelope);
       if (removedIds.length > 0) {
         for (const id of removedIds) {
@@ -4655,7 +5826,7 @@ ${requestList}`);
           }
           this.discardRetiredSession(this.bridge, id, "cleared");
         }
-        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Session cleared. The next message starts a fresh conversation.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, resetTaskName ? `Task "${resetTaskName}" reset with a fresh conversation.` : "Session cleared. The next message starts a fresh conversation.");
       } else {
         await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No active session to clear.");
       }
@@ -4675,6 +5846,10 @@ ${requestList}`);
     this.registerCommand("clear", clearHandler);
     this.registerCommand("reset", clearHandler);
     this.registerCommand("new", clearHandler);
+    if (this.namedSessions) {
+      this.registerCommand("sessions", (envelope, args) => this.handleNamedSessionsCommand(envelope, args));
+      this.registerCommand("session", (envelope, args) => this.handleNamedSessionCommand(envelope, args));
+    }
     this.registerCommand("approve", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "approve"));
     this.registerCommand("approve-always", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "approve-always"));
     this.registerCommand("deny", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "deny"));
@@ -4683,7 +5858,7 @@ ${requestList}`);
         await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can view this shared session.");
         return true;
       }
-      const active = this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+      const active = this.namedSessions ? Boolean(await this.currentSessionId(envelope)) : this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
       const scopeNote = this.config.sessionScope === "single" ? " (shared channel-wide)" : this.isSharedSession(envelope) ? envelope.isGroup ? " (shared by this group)" : "" : envelope.isGroup ? " (private to you)" : "";
       await this.sendThreadMessage(envelope.chatId, envelope.threadId, [
         `Channel: ${this.name}`,
@@ -4708,7 +5883,11 @@ ${requestList}`);
         "/status \u2014 Show session info",
         "/approve [request-id] \u2014 Approve a pending permission request",
         "/approve-always [request-id] \u2014 Always approve a pending permission request",
-        "/deny [request-id] \u2014 Deny a pending permission request"
+        "/deny [request-id] \u2014 Deny a pending permission request",
+        ...this.namedSessions ? [
+          "/sessions [all] \u2014 List your named tasks",
+          "/session current|new|use|close|cancel \u2014 Manage your named tasks"
+        ] : []
       ];
       const sharedCmds = /* @__PURE__ */ new Set([
         "help",
@@ -4722,7 +5901,9 @@ ${requestList}`);
         "channel-memory",
         "forget-channel",
         "who",
-        "status"
+        "status",
+        "sessions",
+        "session"
       ]);
       const platformCmds = [...this.commands.keys()].filter((c) => !sharedCmds.has(c));
       if (platformCmds.length > 0) {
@@ -4730,7 +5911,7 @@ ${requestList}`);
           lines.push(`/${cmd}`);
         }
       }
-      const sessionId = this.router.getSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+      const sessionId = await this.currentSessionId(envelope);
       const agentCommands = sessionId ? this.getAgentCommandsForSession(sessionId) : this.bridge.availableCommands;
       if (agentCommands.length > 0) {
         lines.push("", "Agent commands (forwarded to Qwen Code):");
@@ -4747,7 +5928,7 @@ ${requestList}`);
         await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can view this shared session.");
         return true;
       }
-      const hasSession = this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+      const hasSession = this.namedSessions ? Boolean(await this.currentSessionId(envelope)) : this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
       const policy = this.config.senderPolicy;
       const lines = [
         `Session: ${hasSession ? "active" : "none"}`,
@@ -5078,6 +6259,10 @@ ${requestList}`);
     const sessionId = this.router.getSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
     return sessionId && this.activePrompts.has(sessionId) ? sessionId : void 0;
   }
+  async findNamedActiveSessionId(envelope) {
+    const sessionId = await this.currentSessionId(envelope);
+    return sessionId && this.activePrompts.has(sessionId) ? sessionId : void 0;
+  }
   channelMemoryTarget(envelope) {
     return {
       channelName: this.name,
@@ -5805,9 +6990,12 @@ ${formatted.join("\n")}
 ${CURRENT_MESSAGE_MARKER}
 ${promptText}`;
   }
-  preflightInbound(envelope) {
-    const groupResult = this.groupGate.check(envelope);
-    if (!groupResult.allowed) {
+  preflightInbound(envelope, options = {}) {
+    const groupResult = this.groupGate.check(envelope, {
+      createPairingRequest: !options.deferPairingRequests
+    });
+    const deferredGroupPairing = options.deferPairingRequests === true && groupResult.reason === "pairing_trigger_required" && (envelope.isMentioned || envelope.isReplyToBot);
+    if (!groupResult.allowed && !deferredGroupPairing) {
       if (groupResult.pairing !== void 0) {
         this.logPreflightRejected("group_pairing_required");
         return this.onGroupPairingRequired(envelope.chatId, groupResult.pairing, envelope.threadId).then(() => false).catch((err) => {
@@ -5834,6 +7022,10 @@ ${promptText}`;
       this.markPreflighted(envelope);
       return true;
     }
+    if (options.deferPairingRequests === true && this.config.senderPolicy === "pairing" && !this.gate.isAllowed(envelope.senderId)) {
+      this.markPreflighted(envelope);
+      return true;
+    }
     const result = this.gate.check(envelope.senderId, envelope.senderName);
     if (!result.allowed) {
       if (result.pairing !== void 0) {
@@ -5870,7 +7062,50 @@ ${promptText}`;
     const preflight = this.preflightInbound(envelope);
     if (!(isPromiseLike(preflight) ? await preflight : preflight))
       return;
-    await this.processInbound(envelope);
+    await this.processPreflightedInbound(envelope);
+  }
+  async prepareThenHandleInbound(envelope, prepare, preflightOptions = {}) {
+    const preflight = this.preflightInbound(envelope, preflightOptions);
+    if (!(isPromiseLike(preflight) ? await preflight : preflight))
+      return;
+    if (this.namedSessions) {
+      const result = await this.namedSessions.resolveAfterPreparation(this.namedSessionOwner(envelope), prepare, () => !this.bypassesNamedTurnBinding(envelope), (sessionId) => {
+        const binding = this.bindNamedTurn(envelope, sessionId);
+        return () => this.releaseNamedTurnBinding(binding);
+      });
+      if (result.status === "aborted")
+        return;
+      if (result.status === "resolve_error") {
+        this.finishNamedTurnBinding(envelope);
+        await this.sendNamedSessionError(envelope, result.error);
+        return;
+      }
+      if (result.status === "resolved" && !result.sessionId && !this.namedTurnBindings.has(envelope)) {
+        this.namedTurnBindings.set(envelope, {
+          sessionId: null,
+          generation: 0,
+          claimed: false,
+          released: true
+        });
+      }
+    } else if (await prepare() === false) {
+      return;
+    }
+    try {
+      await this.handleInbound(envelope);
+    } finally {
+      this.finishNamedTurnBinding(envelope);
+    }
+  }
+  async processPreflightedInbound(envelope, process5 = () => this.processInbound(envelope)) {
+    if (this.namedSessions && !await this.prepareNamedTurnBinding(envelope)) {
+      return;
+    }
+    try {
+      await process5();
+    } finally {
+      this.finishNamedTurnBinding(envelope);
+    }
   }
   async recordObservedContact(envelope) {
     if (!this.observedContacts)
@@ -5919,6 +7154,57 @@ ${promptText}`;
       return void 0;
     }
   }
+  formatAttributedText(text, sourceLabel) {
+    if (!sourceLabel || text.trim().length === 0)
+      return text;
+    return `${sourceLabel} ${text}`;
+  }
+  formatMarkdownAttributedText(text, sourceLabel) {
+    const escapedLabel = sourceLabel?.replace(/([\\`*_[\]{}()#+\-.!|>~])/gu, "\\$1");
+    if (!escapedLabel || text.trim().length === 0)
+      return text;
+    return `${escapedLabel}
+${text}`;
+  }
+  sameTaskOwner(a, b) {
+    return a.channelName === b.channelName && a.chatId === b.chatId && a.senderId === b.senderId;
+  }
+  createSourceLabel(reference, target, active) {
+    const activeName = active?.senderName ? this.sanitizeSourceSender(active.senderName) : void 0;
+    const senderLabel = (activeName && activeName !== "unknown" ? activeName : void 0) ?? this.observedSenderLabel(target.chatId, target.senderId) ?? this.sanitizeSourceSender(target.senderId || "unknown");
+    const isGroup = active?.isGroup ?? target.isGroup ?? true;
+    return isGroup ? `[${senderLabel} \xB7 ${reference.taskName}]` : `[${reference.taskName}]`;
+  }
+  observedSenderLabel(chatId, senderId) {
+    const graph = this.persistedObservedContacts();
+    if (!graph)
+      return void 0;
+    const sources = [
+      graph.groups.filter((group) => group.id === chatId).flatMap((group) => group.users).filter((user) => user.id === senderId),
+      graph.users.filter((user) => user.id === senderId)
+    ];
+    for (const source of sources) {
+      const candidates = source.sort((a, b) => b.lastObservedAt.localeCompare(a.lastObservedAt));
+      for (const candidate of candidates) {
+        const label = this.sanitizeSourceSender(candidate.label);
+        if (label !== "unknown")
+          return label;
+      }
+    }
+    return void 0;
+  }
+  sanitizeSourceSender(value) {
+    return sanitizeSenderName(value).replace(/\s+/gu, " ").trim() || "unknown";
+  }
+  sourceLabelForTurn(sessionId, envelope) {
+    const reference = this.namedSessions?.presentation(sessionId);
+    if (!reference || reference.status !== "open")
+      return void 0;
+    return this.createSourceLabel(reference, reference.target, {
+      isGroup: envelope.isGroup,
+      senderName: envelope.senderName
+    });
+  }
   markPreflighted(envelope) {
     this.preflightedEnvelopes.add(envelope);
   }
@@ -5995,7 +7281,51 @@ ${promptText}`;
       }
     }
     await this.waitForBridgeRecovery();
-    const sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd, envelope.isGroup);
+    let sessionId;
+    let namedTurn = this.namedTurnBindings.get(envelope);
+    if (this.namedSessions && namedTurn) {
+      if (namedTurn.sessionId === null) {
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No task was selected when this message was received. Select a task and send it again.");
+        return;
+      }
+      if (this.dropQueuedTurnIfStale(namedTurn.sessionId, namedTurn.generation, envelope)) {
+        return;
+      }
+      try {
+        const resumed = await this.namedSessions.resumeReserved(this.namedSessionOwner(envelope), namedTurn.sessionId);
+        sessionId = resumed ? namedTurn.sessionId : void 0;
+      } catch (error) {
+        await this.sendNamedSessionError(envelope, error);
+        return;
+      }
+      if (!sessionId) {
+        process.stderr.write(`[${this.name}] dropped collected turn from ${envelope.senderId} for session ${namedTurn.sessionId}: reserved task is no longer available
+`);
+        return;
+      }
+    } else if (this.namedSessions) {
+      try {
+        sessionId = await this.namedSessions.resolve(this.namedSessionOwner(envelope), (resolvedSessionId) => {
+          const binding = this.bindNamedTurn(envelope, resolvedSessionId);
+          namedTurn = binding;
+          return () => this.releaseNamedTurnBinding(binding);
+        });
+      } catch (error) {
+        await this.sendNamedSessionError(envelope, error);
+        return;
+      }
+      if (!sessionId) {
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No task is currently selected. Use /session new <name> or /session use <name>.");
+        return;
+      }
+    } else {
+      sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd, envelope.isGroup);
+    }
+    const sourceLabel = this.namedSessions ? this.sourceLabelForTurn(sessionId, envelope) : void 0;
+    if (this.namedSessions && !sourceLabel) {
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Could not identify the selected task. Use /sessions, select it again, and retry.");
+      return;
+    }
     if (bangText.startsWith("!")) {
       const cmd = bangText.slice(1).trim();
       const bridgeShellCommand = this.bridge.shellCommand;
@@ -6010,9 +7340,9 @@ ${fence}` : "(no output)";
           const exitLine = result.exitCode !== null && result.exitCode !== 0 ? `
 Exit code: ${result.exitCode}` : "";
           await this.sendThreadMessage(envelope.chatId, envelope.threadId, `$ ${cmd}
-${output}${exitLine}`);
+${output}${exitLine}`, sourceLabel);
         } catch (error) {
-          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Shell command failed: ${error instanceof Error ? error.message : String(error)}`);
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Shell command failed: ${error instanceof Error ? error.message : String(error)}`, sourceLabel);
         }
         return;
       }
@@ -6040,12 +7370,19 @@ ${promptText}`;
     }
     let imageBase64 = envelope.imageBase64;
     let imageMimeType = envelope.imageMimeType;
+    const images = [];
+    if (imageBase64 && imageMimeType) {
+      images.push({ data: imageBase64, mimeType: imageMimeType });
+    }
     if (envelope.attachments?.length) {
       const filePaths = [];
       for (const att of envelope.attachments) {
-        if (att.type === "image" && att.data && !imageBase64) {
-          imageBase64 = att.data;
-          imageMimeType = att.mimeType;
+        if (att.type === "image" && att.data) {
+          images.push({ data: att.data, mimeType: att.mimeType });
+          if (!imageBase64) {
+            imageBase64 = att.data;
+            imageMimeType = att.mimeType;
+          }
         } else if (att.filePath) {
           const label = att.type === "file" ? "file" : att.type;
           const name = att.fileName ? ` "${sanitizeQuotedText(att.fileName, 128)}"` : "";
@@ -6131,8 +7468,13 @@ ${promptText}`;
       this.instructedSessions.add(sessionId);
     }
     const prev = this.sessionQueues.get(sessionId) ?? Promise.resolve();
-    const generation = this.sessionGenerations.get(sessionId) ?? 0;
+    const generation = namedTurn?.generation ?? this.sessionGenerations.get(sessionId) ?? 0;
     const useBlockStreaming = this.config.blockStreaming === "on";
+    if (namedTurn) {
+      namedTurn.claimed = true;
+    } else {
+      this.reserveQueuedTurn(sessionId);
+    }
     const current = prev.then(async () => {
       clearTimeout(steerWatchdog);
       if (this.dropQueuedTurnIfStale(sessionId, generation, envelope)) {
@@ -6199,7 +7541,7 @@ ${promptToSend}`;
         doneResolve = r;
       });
       const promptState = {
-        runId: randomUUID2(),
+        runId: randomUUID3(),
         owner: {
           kind: "channel_user",
           id: envelope.senderId
@@ -6213,7 +7555,8 @@ ${promptToSend}`;
         messageId: envelope.messageId,
         senderId: envelope.senderId,
         senderName: envelope.senderName,
-        metadata: envelope.metadata
+        metadata: envelope.metadata,
+        sourceLabel
       };
       this.activePrompts.set(sessionId, promptState);
       this.emitTaskLifecycle({
@@ -6230,7 +7573,7 @@ ${promptToSend}`;
         minChars: this.config.blockStreamingChunk?.minChars ?? 400,
         maxChars: this.config.blockStreamingChunk?.maxChars ?? 1e3,
         idleMs: this.config.blockStreamingCoalesce?.idleMs ?? 1500,
-        send: /* @__PURE__ */ __name((text) => this.sendResponseMessage(envelope.chatId, text, sessionId), "send")
+        send: /* @__PURE__ */ __name((text) => this.sendResponseMessage(envelope.chatId, text, sessionId, sourceLabel), "send")
       }) : null;
       promptState.stopStreaming = () => streamer?.stop();
       const heldChunks = [];
@@ -6273,6 +7616,7 @@ ${promptToSend}`;
       promptBridge.on("responseBoundary", onResponseBoundary);
       try {
         const response = await promptBridge.prompt(sessionId, promptToSend, {
+          ...images.length > 0 ? { images } : {},
           imageBase64,
           imageMimeType,
           displayText
@@ -6331,11 +7675,17 @@ ${promptToSend}`;
         if (promptState.cancelled) {
           return;
         }
+        if (sourceLabel) {
+          this.inboundErrorSourceLabels.set(envelope, sourceLabel);
+        }
         throw err;
       } finally {
         promptBridge.off("textChunk", onChunk);
         promptBridge.off("responseBoundary", onResponseBoundary);
-        streamer?.stop();
+        if (streamer) {
+          streamer.stop();
+          await streamer.drain();
+        }
         const stillCurrent = this.activePrompts.get(sessionId) === promptState;
         if (!promptState.clearEvicted) {
           try {
@@ -6349,39 +7699,15 @@ ${promptToSend}`;
           this.activePrompts.delete(sessionId);
         }
         promptState.resolve();
-        const buffer = this.collectBuffers.get(sessionId);
-        if (stillCurrent && buffer && buffer.length > 0) {
-          this.collectBuffers.delete(sessionId);
-          const lost = buffer.length;
-          const coalesced = buffer.map((b) => b.text).join("\n\n");
-          const coalescedDisplayText = buffer.map((b) => b.displayText).join("\n\n");
-          const lastEnvelope = buffer[buffer.length - 1].envelope;
-          this.notifyPromptBufferDrained(lastEnvelope.chatId, sessionId, buffer);
-          const syntheticEnvelope = {
-            ...lastEnvelope,
-            text: coalesced,
-            displayText: coalescedDisplayText,
-            // Coalesced text already carries each message's [sender] prefix.
-            alreadyPrefixed: true,
-            // Clear attachments/references — already resolved in original text
-            referencedText: void 0,
-            mentionedMemberIds: void 0,
-            attachments: void 0,
-            metadata: void 0,
-            imageBase64: void 0,
-            imageMimeType: void 0
-          };
-          this.markPreflighted(syntheticEnvelope);
-          this.processInbound(syntheticEnvelope).catch((err) => {
-            process.stderr.write(`[${this.name}] dropped ${lost} buffered message(s) on collect re-entry for session ${sessionId} (last sender ${lastEnvelope.senderId}): ${err instanceof Error ? err.message : String(err)}
-`);
-          });
-        }
+        this.drainCollectBufferForCurrentPrompt(sessionId, stillCurrent, "prompt completion");
       }
     });
-    this.sessionQueues.set(sessionId, current.catch(() => {
+    const tracked = current.finally(() => {
+      this.releaseQueuedTurn(sessionId);
+    });
+    this.sessionQueues.set(sessionId, tracked.catch(() => {
     }));
-    await current;
+    await tracked;
   }
   pairingRejectionMessage(rejected) {
     return rejected === "sender_pending" ? "You already have a pending pairing request. It must be approved or expire before another can be created." : "Too many pending pairing requests. Please try again later.";
@@ -6491,10 +7817,10 @@ var PollingChannelBase = class extends ChannelBase {
   }
   saveCursor() {
     const path4 = this.cursorPath();
-    mkdirSync4(join6(getGlobalQwenDir(), "channels"), { recursive: true });
+    mkdirSync5(join6(getGlobalQwenDir(), "channels"), { recursive: true });
     const tmp = `${path4}.tmp`;
-    writeFileSync4(tmp, JSON.stringify(this.cursor) + "\n", "utf-8");
-    renameSync4(tmp, path4);
+    writeFileSync5(tmp, JSON.stringify(this.cursor) + "\n", "utf-8");
+    renameSync5(tmp, path4);
   }
   startPollLoop() {
     if (this.running)
@@ -6518,7 +7844,7 @@ var PollingChannelBase = class extends ChannelBase {
       } catch (err) {
         this.consecutiveErrors++;
         const backoff = Math.min(INITIAL_BACKOFF * 2 ** (this.consecutiveErrors - 1), MAX_BACKOFF);
-        process3.stderr.write(`[Channel:${this.name}] poll error (attempt ${this.consecutiveErrors}), backing off ${backoff}ms: ${err}
+        process4.stderr.write(`[Channel:${this.name}] poll error (attempt ${this.consecutiveErrors}), backing off ${backoff}ms: ${err}
 `);
         await this.abortableSleep(backoff);
         continue;
@@ -6528,7 +7854,7 @@ var PollingChannelBase = class extends ChannelBase {
   }
   loadCursorFromDisk() {
     try {
-      const raw = readFileSync4(this.cursorPath(), "utf-8").trim();
+      const raw = readFileSync5(this.cursorPath(), "utf-8").trim();
       if (!raw)
         return null;
       return this.validateCursor(JSON.parse(raw));
@@ -6562,6 +7888,48 @@ function getTextContent(content) {
   return getString(content["text"]);
 }
 __name(getTextContent, "getTextContent");
+var CHANNEL_IMAGE_EXTENSIONS = ["bmp", "gif", "jpeg", "png", "webp"];
+var CHANNEL_IMAGE_MAX_UPLOAD_BYTES = 8 * 1024 * 1024;
+var CHANNEL_IMAGE_INLINE_MAX_BASE64_BYTES = 8 * 1024 * 1024;
+function channelImageName(mimeType, index = 0) {
+  if (!mimeType.startsWith("image/")) {
+    return void 0;
+  }
+  const extension = mimeType.slice("image/".length);
+  if (!CHANNEL_IMAGE_EXTENSIONS.includes(extension)) {
+    return void 0;
+  }
+  return index === 0 ? `image.${extension}` : `image-${index + 1}.${extension}`;
+}
+__name(channelImageName, "channelImageName");
+function decodeChannelImage(data, oversizedReason) {
+  let estimatedBytes = Math.floor(data.length * 3 / 4);
+  if (data.length % 4 === 0) {
+    if (data.endsWith("=="))
+      estimatedBytes -= 2;
+    else if (data.endsWith("="))
+      estimatedBytes -= 1;
+  }
+  if (estimatedBytes > CHANNEL_IMAGE_MAX_UPLOAD_BYTES) {
+    return { skip: oversizedReason };
+  }
+  const bytes = Buffer.from(data, "base64");
+  if (bytes.byteLength === 0) {
+    return { skip: "empty once base64-decoded" };
+  }
+  return { bytes };
+}
+__name(decodeChannelImage, "decodeChannelImage");
+function isDefinitePromptAdmissionRejection(error) {
+  if (!isRecord3(error)) {
+    return false;
+  }
+  if (error["name"] === "DaemonPendingPromptLimitError") {
+    return true;
+  }
+  return error["name"] === "DaemonHttpError" && typeof error["status"] === "number" && error["_daemonTurnError"] !== true;
+}
+__name(isDefinitePromptAdmissionRejection, "isDefinitePromptAdmissionRejection");
 function getSessionUpdate(data) {
   if (!isRecord3(data) || !isRecord3(data["update"])) {
     return void 0;
@@ -6633,8 +8001,9 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   availableCommandsBySession = /* @__PURE__ */ new Map();
   turnBarriers = /* @__PURE__ */ new Map();
   channelLoopToolHandlers = [];
+  channelLoopDisabledSessions = /* @__PURE__ */ new Set();
   registeredChannelLoopMcpSessions = /* @__PURE__ */ new Set();
-  channelLoopMcpRegistrations = /* @__PURE__ */ new Map();
+  channelLoopMcpOperations = /* @__PURE__ */ new Map();
   channelLoopMcpServer;
   connected = false;
   lifecycleGeneration = 0;
@@ -6694,7 +8063,12 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       await this.rejectStaleSession(session);
     }
     this.attachSession(session, bindingToken);
-    await this.registerChannelLoopMcpForSession(session.sessionId);
+    if (options?.enableChannelLoops === false) {
+      this.channelLoopDisabledSessions.add(session.sessionId);
+      void this.reconcileChannelLoopMcpForSession(session.sessionId);
+    } else {
+      await this.reconcileChannelLoopMcpForSession(session.sessionId);
+    }
     return session.sessionId;
   }
   async loadSession(sessionId, cwd, options, bindingToken) {
@@ -6704,7 +8078,8 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       modelServiceId: this.options.modelServiceId,
       sessionId,
       sessionScope: this.options.sessionScope ?? "thread",
-      ...options?.approvalMode ? { approvalMode: options.approvalMode } : {}
+      ...options?.approvalMode ? { approvalMode: options.approvalMode } : {},
+      ...options?.sourceId ? { sourceId: options.sourceId } : {}
     });
     if (lifecycleGeneration !== this.lifecycleGeneration) {
       await this.rejectStaleSession(session);
@@ -6716,7 +8091,12 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       throw new Error(`Daemon returned session ${session.sessionId} while loading ${sessionId}`);
     }
     this.attachSession(session, bindingToken);
-    await this.registerChannelLoopMcpForSession(session.sessionId);
+    if (options?.enableChannelLoops === false) {
+      this.channelLoopDisabledSessions.add(session.sessionId);
+      void this.reconcileChannelLoopMcpForSession(session.sessionId);
+    } else {
+      await this.reconcileChannelLoopMcpForSession(session.sessionId);
+    }
     return session.sessionId;
   }
   registerChannelLoopToolHandler(handler) {
@@ -6729,7 +8109,9 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       cancel: /* @__PURE__ */ __name((sessionId, id) => this.resolveChannelLoopToolHandler(sessionId).cancel(sessionId, id), "cancel")
     });
     for (const sessionId of this.sessions.keys()) {
-      void this.registerChannelLoopMcpForSession(sessionId);
+      if (!this.channelLoopDisabledSessions.has(sessionId)) {
+        void this.reconcileChannelLoopMcpForSession(sessionId);
+      }
     }
   }
   async prompt(sessionId, text, options) {
@@ -6773,29 +8155,101 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     this.on("responseBoundary", clearChunks);
     this.on("sessionDied", onSessionDied);
     const turnBarrier = this.createTurnBarrier(sessionId);
-    const prompt = [];
-    if (options?.imageBase64 && options.imageMimeType) {
-      prompt.push({
-        type: "image",
-        data: options.imageBase64,
-        mimeType: options.imageMimeType
-      });
-    }
-    prompt.push({ type: "text", text });
-    const promptAuthorization = this.options.promptAuthorization;
+    const uploadedAttachmentIds = [];
+    let rollbackUploadedAttachments = false;
+    const uploadAttachment = session.uploadAttachment?.bind(session);
+    const removeAttachment = session.removeAttachment?.bind(session);
     try {
-      const result = await session.prompt({
-        prompt,
-        _meta: {
-          [CHANNEL_PROMPT_META_KEY]: true,
-          ...promptAuthorization ? {
-            [CHANNEL_PROMPT_AUTHORIZATION_META_KEY]: promptAuthorization
-          } : {},
-          ...options?.displayText !== void 0 ? {
-            [CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY]: options.displayText
-          } : {}
+      const prompt = [];
+      const images = resolvePromptImages(options);
+      if (this.options.sessionAttachments && uploadAttachment && removeAttachment) {
+        try {
+          const uploads = await Promise.allSettled(images.map(async (image, index) => {
+            const name = channelImageName(image.mimeType, index);
+            if (!name) {
+              process.stderr.write(`[DaemonChannelBridge] skipped channel image with unsupported MIME type ${sanitizeLogText(image.mimeType, 128)} for session ${sanitizeLogText(sessionId, 128)}
+`);
+              return void 0;
+            }
+            const decoded = decodeChannelImage(image.data, "above the daemon attachment size limit");
+            if ("skip" in decoded) {
+              process.stderr.write(`[DaemonChannelBridge] skipped channel image ${decoded.skip} ${sanitizeLogText(image.mimeType, 128)} for session ${sanitizeLogText(sessionId, 128)}
+`);
+              return void 0;
+            }
+            const attachment = await uploadAttachment(new Blob([decoded.bytes], {
+              type: image.mimeType
+            }), name, image.mimeType, controller.signal);
+            const attachmentId = getString(attachment["attachmentId"]);
+            if (attachmentId)
+              uploadedAttachmentIds.push(attachmentId);
+            return attachment;
+          }));
+          const failure = uploads.find((upload) => upload.status === "rejected");
+          if (failure) {
+            throw failure.reason;
+          }
+          for (const upload of uploads) {
+            if (upload.status === "fulfilled" && upload.value) {
+              prompt.push(upload.value);
+            }
+          }
+        } catch (error) {
+          rollbackUploadedAttachments = true;
+          throw error;
+        }
+      } else {
+        let inlineBase64Bytes = 0;
+        for (const image of images) {
+          const decoded = decodeChannelImage(image.data, "above the inline image budget");
+          if ("skip" in decoded) {
+            process.stderr.write(`[DaemonChannelBridge] skipped channel image ${decoded.skip} ${sanitizeLogText(image.mimeType, 128)} for session ${sanitizeLogText(sessionId, 128)}
+`);
+            continue;
+          }
+          if (inlineBase64Bytes + image.data.length > CHANNEL_IMAGE_INLINE_MAX_BASE64_BYTES) {
+            process.stderr.write(`[DaemonChannelBridge] skipped channel image to keep the inline prompt under the daemon body limit ${sanitizeLogText(image.mimeType, 128)} for session ${sanitizeLogText(sessionId, 128)}
+`);
+            continue;
+          }
+          inlineBase64Bytes += image.data.length;
+          prompt.push({
+            type: "image",
+            data: image.data,
+            mimeType: image.mimeType
+          });
+        }
+      }
+      prompt.push({ type: "text", text });
+      if (controller.signal.aborted) {
+        rollbackUploadedAttachments = true;
+        controller.signal.throwIfAborted();
+      }
+      const promptAuthorization = this.options.promptAuthorization;
+      if (controller.signal.aborted) {
+        rollbackUploadedAttachments = true;
+        throw controller.signal.reason;
+      }
+      let result;
+      try {
+        result = await session.prompt({
+          prompt,
+          _meta: {
+            [CHANNEL_PROMPT_META_KEY]: true,
+            ...promptAuthorization ? {
+              [CHANNEL_PROMPT_AUTHORIZATION_META_KEY]: promptAuthorization
+            } : {},
+            ...options?.displayText !== void 0 ? {
+              [CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY]: options.displayText
+            } : {}
+          }
+        }, controller.signal);
+      } catch (error) {
+        if (isDefinitePromptAdmissionRejection(error)) {
+          rollbackUploadedAttachments = true;
         }
-      }, controller.signal);
+        throw error;
+      }
       await Promise.race([
         turnBarrier,
         new Promise((resolve3) => setTimeout(resolve3, 0))
@@ -6818,6 +8272,16 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       if (controllers.size === 0 && this.activePromptControllers.get(sessionId) === controllers) {
         this.activePromptControllers.delete(sessionId);
       }
+      if (rollbackUploadedAttachments && removeAttachment) {
+        const removals = await Promise.allSettled(uploadedAttachmentIds.map((attachmentId) => removeAttachment(attachmentId)));
+        removals.forEach((removal, index) => {
+          if (removal.status === "rejected") {
+            const reason = removal.reason instanceof Error ? removal.reason.message : String(removal.reason);
+            process.stderr.write(`[DaemonChannelBridge] failed to remove channel image ${sanitizeLogText(uploadedAttachmentIds[index] ?? "", 128)} for session ${sanitizeLogText(sessionId, 128)} during rollback: ${sanitizeLogText(reason, 256)}
+`);
+          }
+        });
+      }
     }
   }
   async shellCommand(sessionId, command, signal) {
@@ -7175,6 +8639,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     this.eventControllers.delete(sessionId);
     this.sessions.delete(sessionId);
     this.sessionBindingTokens.delete(sessionId);
+    this.channelLoopDisabledSessions.delete(sessionId);
     this.abortActivePrompts(sessionId);
     this.activePrompts.delete(sessionId);
     this.availableCommandsBySession.delete(sessionId);
@@ -7192,45 +8657,45 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       }
     }
     if (unregisterChannelLoopMcp) {
-      this.unregisterChannelLoopMcpForSession(sessionId);
+      void this.reconcileChannelLoopMcpForSession(sessionId);
     }
     return session;
   }
-  async registerChannelLoopMcpForSession(sessionId) {
-    const host = this.options.channelLoopMcpHost;
-    const server = this.channelLoopMcpServer;
-    if (!host || !server || this.registeredChannelLoopMcpSessions.has(sessionId)) {
-      return;
-    }
-    const pending = this.channelLoopMcpRegistrations.get(sessionId);
-    if (pending) {
-      await pending;
-      return;
-    }
-    const registration = host.register(sessionId, (message) => server.handleMessage(message, { sessionId })).then(async () => {
-      if (this.sessions.has(sessionId)) {
-        this.registeredChannelLoopMcpSessions.add(sessionId);
-      } else {
+  reconcileChannelLoopMcpForSession(sessionId) {
+    const previous = this.channelLoopMcpOperations.get(sessionId) ?? Promise.resolve();
+    const operation = previous.catch(() => void 0).then(async () => {
+      const host = this.options.channelLoopMcpHost;
+      const server = this.channelLoopMcpServer;
+      const shouldRegister = host !== void 0 && server !== void 0 && this.sessions.has(sessionId) && !this.channelLoopDisabledSessions.has(sessionId);
+      if (!shouldRegister) {
+        if (host && this.registeredChannelLoopMcpSessions.has(sessionId)) {
+          await host.unregister(sessionId);
+          this.registeredChannelLoopMcpSessions.delete(sessionId);
+        }
+        return;
+      }
+      if (this.registeredChannelLoopMcpSessions.has(sessionId))
+        return;
+      await host.register(sessionId, (message) => server.handleMessage(message, { sessionId }));
+      this.registeredChannelLoopMcpSessions.add(sessionId);
+      if (!this.sessions.has(sessionId) || this.channelLoopDisabledSessions.has(sessionId)) {
         await host.unregister(sessionId);
+        this.registeredChannelLoopMcpSessions.delete(sessionId);
       }
     }).catch((error) => {
       this.lastError = error;
     }).finally(() => {
-      if (this.channelLoopMcpRegistrations.get(sessionId) === registration) {
-        this.channelLoopMcpRegistrations.delete(sessionId);
+      if (this.channelLoopMcpOperations.get(sessionId) === operation) {
+        this.channelLoopMcpOperations.delete(sessionId);
       }
     });
-    this.channelLoopMcpRegistrations.set(sessionId, registration);
-    await registration;
-  }
-  unregisterChannelLoopMcpForSession(sessionId) {
-    if (!this.registeredChannelLoopMcpSessions.delete(sessionId))
-      return;
-    void this.options.channelLoopMcpHost?.unregister(sessionId).catch((error) => {
-      this.lastError = error;
-    });
+    this.channelLoopMcpOperations.set(sessionId, operation);
+    return operation;
   }
   resolveChannelLoopToolHandler(sessionId) {
+    if (!this.sessions.has(sessionId) || this.channelLoopDisabledSessions.has(sessionId)) {
+      throw new Error("Channel loop tools are unavailable for this session");
+    }
     const handler = this.channelLoopToolHandlers.find((candidate) => candidate.canHandle?.(sessionId) === true || this.channelLoopToolHandlers.length === 1 && !candidate.canHandle);
     if (handler)
       return handler;