@qwen-code/qwen-code 0.22.3 → 0.23.0

package/chunks/{chunk-ICURCKIU.js → chunk-U4DJ5XB3.js}

@@ -461,6 +461,7 @@ init_esbuild_shims();
 var CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY = "qwen.daemon.promptDisplayText";
 var CHANNEL_PROMPT_AUTHORIZATION_META_KEY = "qwen.daemon.channelPromptAuthorization";
 var CHANNEL_PROMPT_META_KEY = "qwen.channel.prompt";
+var CHANNEL_BTW_METHOD = "qwen/control/session/btw";
 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) {
@@ -761,15 +762,29 @@ var AcpBridge = class extends EventEmitter {
     });
     void this.registerChannelLoopMcpServer();
   }
-  async newSession(cwd, _options, bindingToken) {
+  async applySessionApprovalMode(conn, sessionId, approvalMode) {
+    if (!approvalMode)
+      return;
+    try {
+      await conn.setSessionMode({ sessionId, modeId: approvalMode });
+    } catch (error) {
+      await conn.extMethod("qwen/control/session/close", { sessionId }).catch((closeError) => {
+        process.stderr.write(`[AcpBridge] Failed to close session ${sanitizeLogText(sessionId, 128)} after approval mode error: ${sanitizeLogText(closeError instanceof Error ? closeError.message : String(closeError), 512)}
+`);
+      });
+      throw error;
+    }
+  }
+  async newSession(cwd, options, bindingToken) {
     const conn = this.ensureConnection();
     await this.registerChannelLoopMcpServer();
     const response = await conn.newSession({ cwd, mcpServers: [] });
+    await this.applySessionApprovalMode(conn, response.sessionId, options?.approvalMode);
     this.knownSessionIds.add(response.sessionId);
     this.sessionBindingTokens.set(response.sessionId, bindingToken);
     return response.sessionId;
   }
-  async loadSession(sessionId, cwd, _options, bindingToken) {
+  async loadSession(sessionId, cwd, options, bindingToken) {
     const conn = this.ensureConnection();
     await this.registerChannelLoopMcpServer();
     await conn.unstable_resumeSession({
@@ -777,6 +792,7 @@ var AcpBridge = class extends EventEmitter {
       cwd,
       mcpServers: []
     });
+    await this.applySessionApprovalMode(conn, sessionId, options?.approvalMode);
     this.knownSessionIds.add(sessionId);
     this.sessionBindingTokens.set(sessionId, bindingToken);
     return sessionId;
@@ -829,6 +845,25 @@ var AcpBridge = class extends EventEmitter {
     }
     return chunks.join("") || slashCommandOutput;
   }
+  async btw(sessionId, question, signal) {
+    if (!this.knownSessionIds.has(sessionId)) {
+      throw new Error(`Unknown ACP session ${sessionId}`);
+    }
+    if (signal?.aborted) {
+      throw createAbortError();
+    }
+    const response = await withAbortSignal(this.ensureConnection().extMethod(CHANNEL_BTW_METHOD, {
+      sessionId,
+      question
+    }), signal);
+    if (response["sessionId"] !== sessionId || response["answer"] !== null && typeof response["answer"] !== "string") {
+      throw new Error("Invalid BTW response from ACP agent");
+    }
+    return {
+      sessionId,
+      answer: response["answer"]
+    };
+  }
   async cancelSession(sessionId) {
     const conn = this.ensureConnection();
     try {
@@ -1100,6 +1135,30 @@ async function withTimeout(operation, timeoutMs, message) {
   }
 }
 __name(withTimeout, "withTimeout");
+async function withAbortSignal(operation, signal) {
+  if (!signal)
+    return operation;
+  if (signal.aborted)
+    throw createAbortError();
+  let onAbort;
+  const aborted = new Promise((_, reject) => {
+    onAbort = /* @__PURE__ */ __name(() => reject(createAbortError()), "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([operation, aborted]);
+  } finally {
+    if (onAbort)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+__name(withAbortSignal, "withAbortSignal");
+function createAbortError() {
+  const error = new Error("BTW request aborted");
+  error.name = "AbortError";
+  return error;
+}
+__name(createAbortError, "createAbortError");
 function isSkippedMcpRegistration(result) {
   return typeof result === "object" && result !== null && result.skipped === true;
 }
@@ -1722,10 +1781,11 @@ var SessionRouter = class {
   sessionOptions(channelName) {
     const approvalMode = this.channelApprovalModes.get(channelName);
     const loopsDisabled = this.channelsWithoutLoops.has(channelName);
-    return approvalMode || loopsDisabled ? {
+    return {
       ...approvalMode ? { approvalMode } : {},
-      ...loopsDisabled ? { enableChannelLoops: false } : {}
-    } : void 0;
+      ...loopsDisabled ? { enableChannelLoops: false } : {},
+      sourceId: channelName
+    };
   }
   async resolve(channelName, senderId, chatId, threadId, cwd, isGroup, options) {
     const key = this.routingKey(channelName, senderId, chatId, options?.routingThreadId ?? threadId);
@@ -1802,7 +1862,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) {
@@ -1858,7 +1918,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) {
@@ -1894,6 +1954,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));
   }
@@ -2339,11 +2402,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) {
@@ -2469,6 +2532,7 @@ var NamedSessionManager = class {
   isBusy;
   now;
   registry;
+  taskBySessionId;
   ownerOperations = /* @__PURE__ */ new Map();
   constructor(options) {
     this.channelName = options.channelName;
@@ -2479,9 +2543,52 @@ var NamedSessionManager = class {
     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, expectedSessionId, reserve) {
-    return this.withOwnerLock(input, () => this.resolveLocked(input, expectedSessionId, reserve));
+  resolve(input, reserve) {
+    return this.withOwnerLock(input, () => this.resolveLocked(input, reserve));
   }
   resolveAfterPreparation(input, prepare, needsSession, reserve) {
     return this.withOwnerLock(input, async () => {
@@ -2492,7 +2599,7 @@ var NamedSessionManager = class {
       try {
         return {
           status: "resolved",
-          sessionId: await this.resolveLocked(input, void 0, reserve)
+          sessionId: await this.resolveLocked(input, reserve)
         };
       } catch (error) {
         return { status: "resolve_error", error };
@@ -2516,6 +2623,25 @@ var NamedSessionManager = class {
       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);
@@ -2527,7 +2653,6 @@ var NamedSessionManager = class {
       if (this.openTaskCount(owner) >= MAX_OPEN_TASKS) {
         throw new Error("You already have eight open tasks. Close one before creating another.");
       }
-      this.assertCanLeaveSelected(owner, void 0);
       const timestamp = this.nextTimestamp(owner);
       const target = this.target(input);
       const sessionId = await this.createSession(target, this.cwd, `Could not create task "${name}".`);
@@ -2565,10 +2690,6 @@ var NamedSessionManager = class {
       const task = this.findTask(owner, name);
       if (!task)
         throw new Error(`Task "${name}" was not found.`);
-      this.assertCanLeaveSelected(owner, task.name);
-      if (this.isBusy(task.sessionId)) {
-        throw new Error(`Task "${task.name}" is still running or waiting for permission.`);
-      }
       if (task.status === "closed" && this.openTaskCount(owner) >= MAX_OPEN_TASKS) {
         throw new Error("You already have eight open tasks. Close one before reopening another.");
       }
@@ -2612,9 +2733,6 @@ var NamedSessionManager = class {
       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) {
-        if (this.isBusy(replacement.sessionId)) {
-          throw new Error(`Task "${replacement.name}" is still running or waiting for permission.`);
-        }
         replacementLoaded = await this.loadTask(replacement, `Could not load fallback task "${replacement.name}". Task "${task.name}" was not closed.`);
       }
       const closedTask = {
@@ -2751,7 +2869,7 @@ var NamedSessionManager = class {
     this.router.activateManagedSession(createdSessionId, target, this.cwd);
     return created;
   }
-  async resolveLocked(input, expectedSessionId, reserve) {
+  async resolveLocked(input, reserve) {
     const owner = await this.ensureOwner(input, true);
     if (!owner?.activeTaskName)
       return void 0;
@@ -2759,9 +2877,6 @@ var NamedSessionManager = class {
     if (!task || task.status !== "open") {
       throw new Error("The selected Channel task is unavailable.");
     }
-    if (expectedSessionId !== void 0 && task.sessionId !== expectedSessionId) {
-      return void 0;
-    }
     const release = reserve?.(task.sessionId);
     try {
       await this.loadTask(task, `Could not load task "${task.name}". No replacement session was created.`);
@@ -2799,15 +2914,6 @@ var NamedSessionManager = class {
     };
     this.commitOwner(this.createOwner(target, task.name, [task]));
   }
-  assertCanLeaveSelected(owner, nextTaskName) {
-    if (!owner.activeTaskName || nextTaskName && this.sameName(owner.activeTaskName, nextTaskName)) {
-      return;
-    }
-    const selected = this.findTask(owner, owner.activeTaskName);
-    if (selected && this.isBusy(selected.sessionId)) {
-      throw new Error(`Task "${selected.name}" is still running or waiting for permission.`);
-    }
-  }
   async loadTask(task, failureMessage) {
     try {
       return (await this.router.loadManagedSession(task.sessionId, task.target, task.cwd)).loaded;
@@ -2919,6 +3025,22 @@ var NamedSessionManager = class {
       }))
     };
   }
+  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)) {
@@ -2928,8 +3050,10 @@ var NamedSessionManager = class {
     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)) {
@@ -3705,6 +3829,7 @@ var LOOP_ADD_RE = /^"([^"]+)"\s+(.+)$/su;
 var MAX_LOOP_JOBS_PER_TARGET = 10;
 var MAX_LOOP_PROMPT_CHARS = 4e3;
 var MAX_DISPLAY_PROJECTION_CHARS = 8e3;
+var CHANNEL_BTW_MAX_INPUT_LENGTH = 4096;
 function parseLoopAddArgs(args) {
   const match = args.trim().match(LOOP_ADD_RE);
   if (!match)
@@ -3762,6 +3887,7 @@ var ChannelBase = class {
   sessionQueues = /* @__PURE__ */ new Map();
   queuedTurns = /* @__PURE__ */ new Map();
   namedTurnBindings = /* @__PURE__ */ new WeakMap();
+  inboundErrorSourceLabels = /* @__PURE__ */ new WeakMap();
   registerBridgeEvents;
   bridgeRecovery;
   /**
@@ -3774,6 +3900,7 @@ var ChannelBase = class {
   pendingChannelMemoryMutationDeliveries = /* @__PURE__ */ new Map();
   /** Per-session active prompt tracking for dispatch modes. */
   activePrompts = /* @__PURE__ */ new Map();
+  activeBtw = /* @__PURE__ */ new Map();
   /** Per-session message buffer for collect mode. */
   collectBuffers = /* @__PURE__ */ new Map();
   preflightedEnvelopes = /* @__PURE__ */ new WeakSet();
@@ -3830,15 +3957,34 @@ 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.deliverBackgroundReply(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
@@ -3846,8 +3992,115 @@ var ChannelBase = class {
    * 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) {
-    await this.sendResponseMessage(chatId, text, sessionId);
+  async deliverBackgroundReply(chatId, text, sessionId, sourceLabel) {
+    await this.sendResponseMessage(chatId, text, sessionId, sourceLabel);
+  }
+  async handleBtw(envelope, sessionId, question, sourceLabel) {
+    const target = this.router.getTarget(sessionId);
+    if (!target || target.channelName !== this.name) {
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Could not resolve the current task for /btw.", sourceLabel);
+      return;
+    }
+    const running = this.activeBtw.get(sessionId);
+    if (running) {
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `BTW #${running.id} is still running for this task.`, sourceLabel);
+      return;
+    }
+    const reference = this.namedSessions?.presentation(sessionId);
+    const request = {
+      id: randomUUID3().slice(0, 8),
+      bridge: this.bridge,
+      controller: new AbortController(),
+      target: { ...target },
+      chatId: envelope.chatId,
+      ...envelope.threadId ? { threadId: envelope.threadId } : {},
+      ...sourceLabel ? { sourceLabel } : {},
+      ...reference?.status === "open" ? { taskName: reference.taskName } : {}
+    };
+    this.activeBtw.set(sessionId, request);
+    try {
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `BTW #${request.id} received. The main task will continue.`, sourceLabel);
+    } catch (error) {
+      if (this.activeBtw.get(sessionId) === request) {
+        this.cancelBtw(sessionId);
+      }
+      throw error;
+    }
+    if (!this.isBtwCurrent(sessionId, request)) {
+      if (this.activeBtw.get(sessionId) === request) {
+        this.cancelBtw(sessionId);
+      }
+      return;
+    }
+    void this.deliverBtw(sessionId, question, request).catch((error) => {
+      process.stderr.write(`[${this.name}] BTW delivery failed for session ${sanitizeLogText(sessionId, 128)}: ${this.lifecycleError(error)}
+`);
+    });
+  }
+  async deliverBtw(sessionId, question, request) {
+    let message;
+    try {
+      let result;
+      try {
+        result = await request.bridge.btw(sessionId, question, request.controller.signal);
+        if (result.sessionId !== sessionId) {
+          throw new Error("BTW response session did not match the request");
+        }
+        const answer = result.answer?.trim();
+        message = answer ? `BTW #${request.id}
+
+${answer}` : `BTW #${request.id}
+
+No answer is available from the current conversation context.`;
+      } catch (error) {
+        if (request.controller.signal.aborted)
+          return;
+        process.stderr.write(`[${this.name}] BTW request failed for session ${sanitizeLogText(sessionId, 128)}: ${this.lifecycleError(error)}
+`);
+        message = `BTW #${request.id} failed. Please try again.`;
+      }
+      if (!this.isBtwCurrent(sessionId, request))
+        return;
+      try {
+        await this.sendThreadMessage(request.chatId, request.threadId, message, request.sourceLabel);
+      } catch (error) {
+        try {
+          await this.sendThreadMessage(request.chatId, request.threadId, `BTW #${request.id} failed. Please try again.`, request.sourceLabel);
+        } catch {
+        }
+        throw error;
+      }
+    } finally {
+      if (this.activeBtw.get(sessionId) === request) {
+        this.activeBtw.delete(sessionId);
+      }
+    }
+  }
+  isBtwCurrent(sessionId, request) {
+    if (request.controller.signal.aborted || this.activeBtw.get(sessionId) !== request || this.bridge !== request.bridge || !this.router.isSessionLive(sessionId)) {
+      return false;
+    }
+    const currentTarget = this.router.getTarget(sessionId);
+    if (!currentTarget || !this.sameTaskOwner(request.target, currentTarget) || request.target.threadId !== currentTarget.threadId) {
+      return false;
+    }
+    if (!request.taskName)
+      return true;
+    const reference = this.namedSessions?.presentation(sessionId);
+    return reference?.status === "open" && reference.taskName === request.taskName && this.sameTaskOwner(currentTarget, reference.target) && currentTarget.threadId === reference.target.threadId;
+  }
+  cancelBtw(sessionId) {
+    const request = this.activeBtw.get(sessionId);
+    if (!request)
+      return;
+    this.activeBtw.delete(sessionId);
+    request.controller.abort();
+  }
+  cancelAllBtw() {
+    const requests = Array.from(this.activeBtw.values());
+    this.activeBtw.clear();
+    for (const request of requests)
+      request.controller.abort();
   }
   async dispatchPermissionRequest(event) {
     const target = this.permissionTargetForEvent(event);
@@ -3862,12 +4115,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);
@@ -3882,9 +4182,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");
@@ -3914,6 +4214,7 @@ var ChannelBase = class {
       runId: active.runId,
       owner: active.owner,
       target: pending.target,
+      ...pending.sourceLabel ? { sourceLabel: pending.sourceLabel } : {},
       ...precedingSegment ? { precedingSegmentId: precedingSegment.segmentId } : {},
       questions,
       submitOptionId,
@@ -4097,8 +4398,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
@@ -4240,6 +4541,7 @@ var ChannelBase = class {
       segmentId,
       owner: active.owner,
       target: resolvedTarget,
+      ...active.sourceLabel ? { sourceLabel: active.sourceLabel } : {},
       ...active.messageId ? { messageId: active.messageId } : {}
     };
   }
@@ -4281,11 +4583,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 {
@@ -4486,6 +4788,7 @@ var ChannelBase = class {
   }
   /** Replace the bridge instance (used after crash recovery restart). */
   setBridge(bridge) {
+    this.cancelAllBtw();
     if (this.registerBridgeEvents) {
       this.detachBridgeEvents(this.bridge);
     }
@@ -4946,6 +5249,7 @@ ${promptText}` : promptText;
         })
       ]);
       if (!cancelled) {
+        this.cancelBtw(sessionId);
         this.router.removeSessionId(sessionId);
         this.instructedSessions.delete(sessionId);
         this.unattendedMemorySessions.delete(sessionId);
@@ -5068,6 +5372,7 @@ ${promptText}` : promptText;
   onToolCall(_chatId, _event) {
   }
   onSessionDied(sessionId) {
+    this.cancelBtw(sessionId);
     this.router.handleSessionDied(sessionId);
     this.instructedSessions.delete(sessionId);
     this.unattendedMemorySessions.delete(sessionId);
@@ -5124,11 +5429,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
@@ -5143,6 +5448,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.
@@ -5155,8 +5466,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
@@ -5261,7 +5572,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);
@@ -5274,7 +5585,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 };
     }
@@ -5291,27 +5602,81 @@ ${promptText}` : promptText;
   }
   formatPermissionRequest(pending) {
     const { toolCall } = pending.request;
-    const title = sanitizeQuotedText(toolCall.title || "Tool use", 160);
+    const parameters = this.permissionParameterSummary(toolCall);
+    const approveLabel = this.permissionOptionLabel(this.approvalOption(pending), "allow once");
     const alwaysOption = this.approvalAlwaysOption(pending);
+    const denyLabel = this.permissionOptionLabel(this.denialOption(pending), "deny");
+    const requestSuffix = pending.taskName ? ` ${pending.requestId}` : "";
+    const replyPadding = pending.taskName ? { approve: "          ", always: "   ", deny: "             " } : { approve: "        ", always: " ", deny: "           " };
     const replies = [
-      "/approve        allow once",
-      ...alwaysOption ? [`/approve-always ${alwaysOption.label}`] : [],
-      "/deny           deny"
+      `/approve${requestSuffix}${replyPadding.approve}${approveLabel}`,
+      ...alwaysOption ? [
+        `/approve-always${requestSuffix}${replyPadding.always}${alwaysOption.label}`
+      ] : [],
+      `/deny${requestSuffix}${replyPadding.deny}${denyLabel}`
     ];
-    const lines = [
+    return [
       "Permission required to run a tool",
+      ...pending.taskName ? [`Request: ${pending.requestId}`] : [],
       "",
-      "Command:",
-      title,
+      `Tool: ${this.permissionToolName(toolCall)}`,
+      `Action: ${this.permissionTitle(toolCall)}`,
+      ...parameters ? [`Parameters: ${parameters}`] : [],
       "",
       "Reply with:",
       ...replies
-    ];
-    return lines.join("\n");
+    ].join("\n");
   }
-  approvalOptionId(pending) {
+  permissionTitle(toolCall) {
+    const rawTitle = typeof toolCall.title === "string" ? toolCall.title : void 0;
+    return sanitizeQuotedText(rawTitle || "", 160).trim() || "Tool use";
+  }
+  permissionToolName(toolCall) {
+    const rawToolCall = toolCall;
+    const meta = isRecord2(rawToolCall["_meta"]) ? rawToolCall["_meta"] : void 0;
+    for (const candidate of [meta?.["toolName"], rawToolCall["kind"]]) {
+      if (typeof candidate !== "string")
+        continue;
+      const name = sanitizeQuotedText(candidate, 120).trim();
+      if (name)
+        return name;
+    }
+    return "unknown";
+  }
+  permissionParameterSummary(toolCall) {
+    const rawToolCall = toolCall;
+    const rawInput = isRecord2(rawToolCall["rawInput"]) ? rawToolCall["rawInput"] : void 0;
+    if (!rawInput)
+      return void 0;
+    const entries = Object.entries(rawInput);
+    if (entries.length === 0)
+      return void 0;
+    const visible = entries.slice(0, 4).map(([key, value]) => {
+      const safeKey = sanitizeQuotedText(key, 48).trim() || "unknown";
+      if (Array.isArray(value)) {
+        return `${safeKey} (${value.length} ${value.length === 1 ? "item" : "items"})`;
+      }
+      if (isRecord2(value)) {
+        return `${safeKey} (object)`;
+      }
+      return safeKey;
+    });
+    if (entries.length > visible.length) {
+      visible.push(`+${entries.length - visible.length} more`);
+    }
+    return visible.join(", ");
+  }
+  permissionOptionLabel(option, fallback) {
+    const rawLabel = typeof option?.name === "string" ? option.name : "";
+    const label = sanitizeQuotedText(rawLabel, 160).trim();
+    return label || fallback;
+  }
+  approvalOption(pending) {
     const options = pending.request.options;
-    return options.find((option) => option.kind === "allow_once")?.optionId ?? options.find((option) => option.optionId === "proceed_once" && option.kind === void 0)?.optionId;
+    return options.find((option) => option.kind === "allow_once") ?? options.find((option) => option.optionId === "proceed_once" && option.kind === void 0);
+  }
+  approvalOptionId(pending) {
+    return this.approvalOption(pending)?.optionId;
   }
   approvalAlwaysOption(pending) {
     const options = pending.request.options.filter((option2) => option2.kind === "allow_always");
@@ -5321,7 +5686,7 @@ ${promptText}` : promptText;
     }
     return {
       optionId: option.optionId,
-      label: this.approvalAlwaysLabel(option)
+      label: this.permissionOptionLabel(option, this.approvalAlwaysLabel(option))
     };
   }
   findScopedAlwaysOption(options, scope) {
@@ -5337,39 +5702,54 @@ ${promptText}` : promptText;
     return "always allow";
   }
   denialResponse(pending) {
-    const option = pending.request.options.find((candidate) => candidate.kind === "reject_once") ?? pending.request.options.find((candidate) => candidate.optionId === "cancel" && candidate.kind === void 0);
+    const option = this.denialOption(pending);
     if (option) {
       return { outcome: { outcome: "selected", optionId: option.optionId } };
     }
     return { outcome: { outcome: "cancelled" } };
   }
+  denialOption(pending) {
+    return pending.request.options.find((candidate) => candidate.kind === "reject_once") ?? pending.request.options.find((candidate) => candidate.optionId === "cancel" && candidate.kind === void 0);
+  }
   async handlePermissionResponseCommand(envelope, args, decision) {
     if (!this.isAuthorizedForSharedSession(envelope)) {
       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 title = pending2 ? `: ${this.permissionTitle(pending2.request.toolCall)}` : "";
+        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 = (() => {
@@ -5380,7 +5760,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;
@@ -5390,11 +5770,11 @@ ${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) {
@@ -5461,7 +5841,7 @@ ${requestList}`);
     if (this.bypassesNamedTurnBinding(envelope))
       return true;
     try {
-      const sessionId = await namedSessions.resolve(this.namedSessionOwner(envelope), void 0, (resolvedSessionId) => {
+      const sessionId = await namedSessions.resolve(this.namedSessionOwner(envelope), (resolvedSessionId) => {
         const binding = this.bindNamedTurn(envelope, resolvedSessionId);
         return () => this.releaseNamedTurnBinding(binding);
       });
@@ -5541,7 +5921,7 @@ ${requestList}`);
         }
         case "new": {
           if (parts.includes("--worktree")) {
-            await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Worktree tasks are not available in Part 2 yet. Create a shared task with /session new <name>.");
+            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)
@@ -5560,13 +5940,34 @@ ${requestList}`);
         case "close": {
           if (parts.length !== 1)
             break;
+          const closing = await namedSessions.lookup(owner, parts[0]);
           const result = await namedSessions.close(owner, parts[0]);
+          if (closing)
+            this.cancelBtw(closing.sessionId);
           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":
-          await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Named task cancellation is not available in Part 2 yet. Wait for the selected task to finish before switching; Telegram users can use /cancel.");
+        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;
       }
@@ -5597,6 +5998,7 @@ ${requestList}`);
       this.clearPendingGroupHistory(envelope);
       if (removedIds.length > 0) {
         for (const id of removedIds) {
+          this.cancelBtw(id);
           if (this.isSharedSession(envelope)) {
             const who = sanitizeSenderName(envelope.senderName || envelope.senderId || "unknown");
             process.stderr.write(`[${this.name}] shared session ${id} cleared by ${who} (sender ${envelope.senderId})
@@ -5659,6 +6061,7 @@ ${requestList}`);
     this.registerCommand("clear", clearHandler);
     this.registerCommand("reset", clearHandler);
     this.registerCommand("new", clearHandler);
+    this.registerCommand("btw", () => Promise.resolve(false));
     if (this.namedSessions) {
       this.registerCommand("sessions", (envelope, args) => this.handleNamedSessionsCommand(envelope, args));
       this.registerCommand("session", (envelope, args) => this.handleNamedSessionCommand(envelope, args));
@@ -5697,9 +6100,12 @@ ${requestList}`);
         "/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",
+        ...this.bridge.btw ? [
+          "/btw <question> \u2014 Ask a side question without interrupting the current task"
+        ] : [],
         ...this.namedSessions ? [
           "/sessions [all] \u2014 List your named tasks",
-          "/session current|new|use|close \u2014 Manage your named tasks"
+          "/session current|new|use|close|cancel \u2014 Manage your named tasks"
         ] : []
       ];
       const sharedCmds = /* @__PURE__ */ new Set([
@@ -5710,6 +6116,7 @@ ${requestList}`);
         "approve",
         "approve-always",
         "deny",
+        "btw",
         "remember-channel",
         "channel-memory",
         "forget-channel",
@@ -5725,7 +6132,10 @@ ${requestList}`);
         }
       }
       const sessionId = await this.currentSessionId(envelope);
-      const agentCommands = sessionId ? this.getAgentCommandsForSession(sessionId) : this.bridge.availableCommands;
+      const agentCommands = (sessionId ? this.getAgentCommandsForSession(sessionId) : this.bridge.availableCommands).filter((command) => !this.commands.has(command.name) || // `btw` is registered unconditionally but only handled locally when
+      // the bridge supports it. Without that capability the agent's entry
+      // is the working one, so it must stay listed.
+      command.name === "btw" && !this.bridge.btw);
       if (agentCommands.length > 0) {
         lines.push("", "Agent commands (forwarded to Qwen Code):");
         for (const cmd of agentCommands) {
@@ -6967,6 +7377,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);
   }
@@ -6999,12 +7460,13 @@ ${promptText}`;
       this.onObservedContact(envelope);
     }
     const displayText = sanitizeDisplayText(envelope.displayText ?? envelope.text, MAX_DISPLAY_PROJECTION_CHARS);
-    let memoryIntent = parseChannelMemoryIntent(envelope.text);
+    const parsed = this.parseCommand(envelope.text);
+    let memoryIntent = parsed?.command === "btw" ? null : parseChannelMemoryIntent(envelope.text);
     let memoryIntentFromClassifier = false;
     if (memoryIntent?.kind === "update" || memoryIntent?.kind === "remove") {
       this.deletePendingChannelMemoryMutation(envelope);
     }
-    if (!memoryIntent && this.shouldClassifyChannelMemoryIntent(envelope.text)) {
+    if (!memoryIntent && parsed?.command !== "btw" && this.shouldClassifyChannelMemoryIntent(envelope.text)) {
       memoryIntent = await this.classifyChannelMemoryIntent(envelope);
       memoryIntentFromClassifier = memoryIntent !== null;
     }
@@ -7017,7 +7479,7 @@ ${promptText}`;
         return;
       }
     }
-    const parsed = this.parseCommand(envelope.text);
+    let btwQuestion;
     if (parsed) {
       const handler = this.commands.get(parsed.command);
       if (handler) {
@@ -7025,6 +7487,25 @@ ${promptText}`;
         if (handled)
           return;
       }
+      if (parsed.command === "btw" && this.bridge.btw) {
+        if (!this.isAuthorizedForSharedSession(envelope)) {
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can use /btw in this shared session.");
+          return;
+        }
+        btwQuestion = parsed.args.trim();
+        if (!btwQuestion) {
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Usage: /btw <question>");
+          return;
+        }
+        if (btwQuestion.length > CHANNEL_BTW_MAX_INPUT_LENGTH) {
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `BTW questions are limited to ${CHANNEL_BTW_MAX_INPUT_LENGTH} characters.`);
+          return;
+        }
+        if (envelope.imageBase64 || envelope.attachments?.length) {
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, "/btw supports text-only questions.");
+          return;
+        }
+      }
     }
     const bangText = envelope.text.trimStart();
     if (bangText.startsWith("!")) {
@@ -7054,19 +7535,20 @@ ${promptText}`;
         return;
       }
       try {
-        sessionId = await this.namedSessions.resolve(this.namedSessionOwner(envelope), namedTurn.sessionId);
+        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}: selected task changed before it ran
+        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), void 0, (resolvedSessionId) => {
+        sessionId = await this.namedSessions.resolve(this.namedSessionOwner(envelope), (resolvedSessionId) => {
           const binding = this.bindNamedTurn(envelope, resolvedSessionId);
           namedTurn = binding;
           return () => this.releaseNamedTurnBinding(binding);
@@ -7082,6 +7564,15 @@ ${promptText}`;
     } 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 (btwQuestion !== void 0) {
+      await this.handleBtw(envelope, sessionId, btwQuestion, sourceLabel);
+      return;
+    }
     if (bangText.startsWith("!")) {
       const cmd = bangText.slice(1).trim();
       const bridgeShellCommand = this.bridge.shellCommand;
@@ -7096,9 +7587,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;
       }
@@ -7311,7 +7802,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({
@@ -7328,7 +7820,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 = [];
@@ -7430,6 +7922,9 @@ ${promptToSend}`;
         if (promptState.cancelled) {
           return;
         }
+        if (sourceLabel) {
+          this.inboundErrorSourceLabels.set(envelope, sourceLabel);
+        }
         throw err;
       } finally {
         promptBridge.off("textChunk", onChunk);
@@ -7830,7 +8325,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);
@@ -8035,6 +8531,13 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       }
     }
   }
+  async btw(sessionId, question, signal) {
+    const session = this.ensureSession(sessionId);
+    if (!session.btw) {
+      throw new Error("BTW is not supported by this daemon session");
+    }
+    return session.btw(question, signal ? { signal } : void 0);
+  }
   async shellCommand(sessionId, command, signal) {
     const session = this.ensureSession(sessionId);
     if (!session.shellCommand) {
@@ -8083,7 +8586,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       return false;
     }
     try {
-      const accepted = await session.respondToPermission(requestId, response);
+      const accepted = this.options.sessionPermissionVote && typeof session.respondToSessionPermission === "function" ? await session.respondToSessionPermission(requestId, response) : await session.respondToPermission(requestId, response);
       this.requestToSession.delete(requestId);
       if (accepted) {
         this.rememberRespondedPermissionRequest(requestId, sessionId);