@qwen-code/qwen-code 0.23.2-preview.0 → 0.23.3-nightly.20260910.c46cb85cf2

package/chunks/{chunk-XVTCSVBK.js → chunk-C4NLHK7X.js}

@@ -4,7 +4,7 @@ import {
   ClientSideConnection,
   PROTOCOL_VERSION,
   ndJsonStream
-} from "./chunk-IW6RQPQB.js";
+} from "./chunk-IJOS26LH.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1245,118 +1245,6 @@ init_esbuild_shims();
 import { basename as basename3, join as join5 } from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 
-// packages/channels/base/dist/BlockStreamer.js
-init_esbuild_shims();
-var BlockStreamer = class {
-  static {
-    __name(this, "BlockStreamer");
-  }
-  buffer = "";
-  idleTimer = null;
-  sending = Promise.resolve();
-  opts;
-  /** Number of blocks emitted so far. */
-  blockCount = 0;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  /** Feed a new text chunk from the agent stream. */
-  push(chunk) {
-    this.buffer += chunk;
-    this.clearIdleTimer();
-    this.checkEmit();
-    if (this.buffer.length > 0 && this.opts.idleMs > 0) {
-      this.idleTimer = setTimeout(() => this.onIdle(), this.opts.idleMs);
-    }
-  }
-  /** Flush all remaining buffered text. Awaits all pending sends. */
-  async flush() {
-    this.clearIdleTimer();
-    if (this.buffer.length > 0) {
-      this.emitBlock(this.buffer);
-      this.buffer = "";
-    }
-    await this.sending;
-  }
-  /** Drop buffered text and cancel future idle emission. */
-  stop() {
-    this.clearIdleTimer();
-    this.buffer = "";
-  }
-  /** Await already-queued sends without emitting the buffered text. */
-  async drain() {
-    await this.sending;
-  }
-  // ---------------------------------------------------------------------------
-  // Internal
-  // ---------------------------------------------------------------------------
-  checkEmit() {
-    while (this.buffer.length >= this.opts.maxChars) {
-      const bp = this.findBreakPoint(this.buffer, this.opts.maxChars);
-      this.emitBlock(this.buffer.slice(0, bp));
-      this.buffer = this.buffer.slice(bp);
-    }
-    if (this.buffer.length >= this.opts.minChars) {
-      const bp = this.findBlockBoundary(this.buffer);
-      if (bp > 0) {
-        this.emitBlock(this.buffer.slice(0, bp));
-        this.buffer = this.buffer.slice(bp);
-      }
-    }
-  }
-  onIdle() {
-    this.idleTimer = null;
-    if (this.buffer.length >= this.opts.minChars) {
-      this.emitBlock(this.buffer);
-      this.buffer = "";
-    }
-  }
-  emitBlock(text) {
-    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(block)).catch(() => {
-    });
-  }
-  /**
-   * Find the last paragraph boundary (\n\n) in the buffer.
-   * Returns the position after the boundary, or -1 if no suitable boundary
-   * exists at or after minChars.
-   */
-  findBlockBoundary(text) {
-    const last = text.lastIndexOf("\n\n");
-    if (last < 0 || last < this.opts.minChars)
-      return -1;
-    return last + 2;
-  }
-  /**
-   * Find the best break point at or before maxPos.
-   * Prefers paragraph break > newline > space > maxPos.
-   */
-  findBreakPoint(text, maxPos) {
-    const sub = text.slice(0, maxPos);
-    const para = sub.lastIndexOf("\n\n");
-    if (para > 0)
-      return para + 2;
-    const nl = sub.lastIndexOf("\n");
-    if (nl > 0)
-      return nl + 1;
-    const sp = sub.lastIndexOf(" ");
-    if (sp > 0)
-      return sp + 1;
-    return maxPos;
-  }
-  clearIdleTimer() {
-    if (this.idleTimer !== null) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = null;
-    }
-  }
-};
-
 // packages/channels/base/dist/ChannelProactiveDeliveryError.js
 init_esbuild_shims();
 var CHANNEL_PROACTIVE_DELIVERY_ERROR_CODE = "channel_proactive_delivery_error";
@@ -3931,71 +3819,6 @@ function truncateError(message) {
 }
 __name(truncateError, "truncateError");
 
-// packages/channels/base/dist/message-prefix.js
-init_esbuild_shims();
-function startsWithMessagePrefix(text, prefix) {
-  return text.startsWith(prefix) && (text.length === prefix.length || /\s/u.test(text.charAt(prefix.length)));
-}
-__name(startsWithMessagePrefix, "startsWithMessagePrefix");
-function stripMessagePrefix(text, prefix) {
-  if (!prefix)
-    return text;
-  let candidate = text.trim();
-  while (!startsWithMessagePrefix(candidate, prefix) && (candidate.startsWith("@") || candidate.startsWith("<@"))) {
-    const mention = candidate.match(/^(?:@[^@\s]+|<@[^>]{1,64}>)\s+/u)?.[0];
-    if (!mention)
-      return void 0;
-    candidate = candidate.slice(mention.length);
-  }
-  if (!startsWithMessagePrefix(candidate, prefix))
-    return void 0;
-  const suffix = candidate.slice(prefix.length);
-  if (!/^\s+\S[\s\S]*$/u.test(suffix))
-    return void 0;
-  return suffix.trim();
-}
-__name(stripMessagePrefix, "stripMessagePrefix");
-function locateDisplayText(envelope, displayText) {
-  const offset = envelope.displayTextOffset;
-  if (offset !== void 0 && envelope.text.startsWith(displayText, offset)) {
-    return offset;
-  }
-  if (offset === void 0 && envelope.text.endsWith(displayText)) {
-    return envelope.text.length - displayText.length;
-  }
-  const first = envelope.text.indexOf(displayText);
-  if (first === -1)
-    return -1;
-  return envelope.text.indexOf(displayText, first + 1) === -1 ? first : "ambiguous";
-}
-__name(locateDisplayText, "locateDisplayText");
-function applyMessagePrefix(envelope, prefix) {
-  if (!prefix || envelope.bypassMessagePrefix || envelope.syntheticText) {
-    return true;
-  }
-  const displayText = envelope.displayText;
-  const prefixText = envelope.messagePrefixText;
-  const sourceText = prefixText ?? displayText ?? envelope.text;
-  const stripped = stripMessagePrefix(sourceText, prefix);
-  if (stripped === void 0)
-    return false;
-  if (displayText === void 0) {
-    if (prefixText !== void 0)
-      envelope.messagePrefixText = stripped;
-    envelope.text = stripped;
-    return true;
-  }
-  const at = locateDisplayText(envelope, displayText);
-  if (at === "ambiguous" || at === -1)
-    return false;
-  if (prefixText !== void 0)
-    envelope.messagePrefixText = stripped;
-  envelope.displayText = stripped;
-  envelope.text = envelope.text.slice(0, at) + stripped + envelope.text.slice(at + displayText.length);
-  return true;
-}
-__name(applyMessagePrefix, "applyMessagePrefix");
-
 // packages/channels/base/dist/ChannelWebhookTask.js
 init_esbuild_shims();
 var MAX_WEBHOOK_PROMPT_CHARS = 8500;
@@ -4330,6 +4153,45 @@ function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 __name(isRecord2, "isRecord");
+var PERMISSION_COPY = {
+  en: {
+    toolUse: "Tool use",
+    allowOnce: "Allow once",
+    allowAlwaysProject: "always allow for this project",
+    allowAlwaysUser: "always allow for this user",
+    allowAlways: "always allow",
+    deny: "Deny",
+    required: "Permission required to run a tool",
+    request: "Request:",
+    tool: "Tool:",
+    action: "Action:",
+    parameters: "Parameters:",
+    replyWith: "Reply with:"
+  },
+  zh: {
+    toolUse: "\u5DE5\u5177\u8C03\u7528",
+    allowOnce: "\u4EC5\u5141\u8BB8\u672C\u6B21",
+    allowAlwaysProject: "\u59CB\u7EC8\u5141\u8BB8\u6B64\u9879\u76EE",
+    allowAlwaysUser: "\u59CB\u7EC8\u5141\u8BB8\u6B64\u7528\u6237",
+    allowAlways: "\u59CB\u7EC8\u5141\u8BB8",
+    deny: "\u62D2\u7EDD",
+    required: "\u8FD0\u884C\u5DE5\u5177\u9700\u8981\u6388\u6743",
+    request: "\u8BF7\u6C42\uFF1A",
+    tool: "\u5DE5\u5177\uFF1A",
+    action: "\u64CD\u4F5C\uFF1A",
+    parameters: "\u53C2\u6570\uFF1A",
+    replyWith: "\u56DE\u590D\u4EE5\u4E0B\u547D\u4EE4\uFF1A"
+  }
+};
+function localizedScopedAlwaysLabel(label, stockLabel, localizedLabel) {
+  if (label === stockLabel)
+    return localizedLabel;
+  const scopeSeparator = ": ";
+  if (!label.startsWith(stockLabel + scopeSeparator))
+    return void 0;
+  return `${localizedLabel}\uFF1A${label.slice(stockLabel.length + scopeSeparator.length)}`;
+}
+__name(localizedScopedAlwaysLabel, "localizedScopedAlwaysLabel");
 var COMMAND_TOKEN_CHARS = "a-zA-Z0-9_:-";
 var PARSE_COMMAND_RE = new RegExp(`^\\/([${COMMAND_TOKEN_CHARS}]+)(?:@\\S+)?\\s*(.*)`, "s");
 var COMMAND_TOKEN_RE = new RegExp(`^[${COMMAND_TOKEN_CHARS}]+(?:@\\S+)?$`);
@@ -4373,6 +4235,7 @@ var ChannelBase = class {
   proxy;
   /** Adapter-owned persistent state directory, when supplied by the runtime. */
   stateDir;
+  locale;
   channelMemory;
   memoryIntentClassifier;
   channelMemoryRecallObserver;
@@ -4386,9 +4249,6 @@ var ChannelBase = class {
   observedContacts;
   namedSessions;
   observedContactEnvelopes = /* @__PURE__ */ new WeakSet();
-  messagePrefix;
-  messagePrefixCheckedEnvelopes = /* @__PURE__ */ new WeakSet();
-  messagePrefixRejectedEnvelopes = /* @__PURE__ */ new WeakSet();
   instructedSessions = /* @__PURE__ */ new Set();
   unattendedMemorySessions = /* @__PURE__ */ new Set();
   channelMemoryReads = /* @__PURE__ */ new Map();
@@ -4524,7 +4384,7 @@ var ChannelBase = class {
   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 ${this.prefixedCommand("/btw")}.`, sourceLabel);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Could not resolve the current task for /btw.`, sourceLabel);
       return;
     }
     const running = this.activeBtw.get(sessionId);
@@ -4706,6 +4566,10 @@ No answer is available from the current conversation context.`;
       if (presentation && await presentation) {
         return;
       }
+      const permissionPresentation = this.tryPresentPermission(pending);
+      if (permissionPresentation && await permissionPresentation) {
+        return;
+      }
       const text = this.formatPermissionRequest(pending);
       if (target.threadId !== void 0 && this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
         await this.pushProactive(target, text, pending.sourceLabel);
@@ -4786,6 +4650,103 @@ No answer is available from the current conversation context.`;
       }
     })();
   }
+  tryPresentPermission(pending) {
+    const active = this.activePrompts.get(pending.sessionId);
+    const toolCall = pending.request.toolCall;
+    const meta = isRecord2(toolCall["_meta"]) ? toolCall["_meta"] : void 0;
+    const isUserQuestion = meta?.["qwenInteractionKind"] === "user_question" || meta?.["toolName"] === "ask_user_question" || toolCall["kind"] === "ask_user_question";
+    const decisions = this.permissionPresentationDecisions(pending);
+    if (!active || active.loopPrompt || !active.owner || isUserQuestion || !decisions) {
+      return void 0;
+    }
+    const precedingSegment = this.closeOutputSegment(pending.sessionId, active, pending.target);
+    let respondInvoked = false;
+    const context = {
+      requestId: pending.requestId,
+      sessionId: pending.sessionId,
+      runId: active.runId,
+      owner: active.owner,
+      target: pending.target,
+      ...precedingSegment ? { precedingSegmentId: precedingSegment.segmentId } : {},
+      title: this.permissionTitle(pending.request.toolCall),
+      decisions,
+      onSettled: /* @__PURE__ */ __name((listener) => {
+        if (pending.settled) {
+          listener(pending.settled);
+          return () => {
+          };
+        }
+        pending.settlementListeners.add(listener);
+        return () => {
+          pending.settlementListeners.delete(listener);
+        };
+      }, "onSettled"),
+      respond: /* @__PURE__ */ __name((decision) => {
+        const response = this.permissionPresentationResponse(pending, decision);
+        if (!response)
+          return Promise.resolve(false);
+        respondInvoked = true;
+        return this.respondToUserInput(pending, response);
+      }, "respond")
+    };
+    pending.permissionPresented = true;
+    return (async () => {
+      try {
+        if (precedingSegment) {
+          await this.notifyOutputSegmentEnd(pending.target.chatId, pending.sessionId, precedingSegment, "input_requested");
+        }
+        if (this.pendingPermissions.get(pending.requestId) !== pending) {
+          return true;
+        }
+        const result = await this.presentPermissionRequest(context);
+        if (this.pendingPermissions.get(pending.requestId) !== pending) {
+          return true;
+        }
+        if (result.kind === "presented" || result.kind === "handled" && respondInvoked) {
+          return true;
+        }
+        pending.permissionPresented = false;
+        return false;
+      } catch (err) {
+        process.stderr.write(`[${this.name}] permission presentation failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}
+`);
+        if (this.pendingPermissions.get(pending.requestId) !== pending) {
+          return true;
+        }
+        pending.permissionPresented = false;
+        return false;
+      }
+    })();
+  }
+  permissionPresentationDecisions(pending) {
+    const allowOnce = this.approvalOption(pending);
+    if (!allowOnce)
+      return void 0;
+    const copy = PERMISSION_COPY[this.locale];
+    const allowAlways = this.approvalAlwaysOption(pending);
+    return [
+      {
+        kind: "allow_once",
+        label: sanitizeQuotedText(this.permissionOptionLabel(allowOnce, copy.allowOnce), 80)
+      },
+      ...allowAlways ? [
+        {
+          kind: "allow_always",
+          label: sanitizeQuotedText(allowAlways.label, 80)
+        }
+      ] : [],
+      {
+        kind: "deny",
+        label: sanitizeQuotedText(this.permissionOptionLabel(this.denialOption(pending), copy.deny), 80)
+      }
+    ];
+  }
+  permissionPresentationResponse(pending, decision) {
+    if (decision === "deny")
+      return this.denialResponse(pending);
+    const optionId = decision === "allow_once" ? this.approvalOptionId(pending) : this.approvalAlwaysOption(pending)?.optionId;
+    return optionId ? { outcome: { outcome: "selected", optionId } } : void 0;
+  }
   normalizeUserQuestions(pending) {
     const toolCall = pending.request.toolCall;
     const meta = isRecord2(toolCall["_meta"]) ? toolCall["_meta"] : void 0;
@@ -4830,7 +4791,8 @@ No answer is available from the current conversation context.`;
   }
   async respondToUserInput(pending, response) {
     if (pending.responsePromise) {
-      return pending.responsePromise;
+      await pending.responsePromise;
+      return false;
     }
     if (this.pendingPermissions.get(pending.requestId) !== pending || !this.bridge.respondToPermission) {
       return false;
@@ -4876,13 +4838,10 @@ No answer is available from the current conversation context.`;
     this.removePendingPermission(event.requestId, this.userInputSettlementReason(pending, event.outcome));
   }
   constructor(name, config, bridge, options) {
-    if (config.messagePrefix !== void 0 && typeof config.messagePrefix !== "string") {
-      throw new Error(`Channel "${name}" field "messagePrefix" must be a string.`);
-    }
     this.name = name;
     this.config = config;
-    this.messagePrefix = config.messagePrefix?.trim() || void 0;
     this.bridge = bridge;
+    this.locale = options?.locale ?? "en";
     this.proxy = options?.proxy;
     this.stateDir = options?.stateDir;
     this.identity = Object.freeze(this.resolveIdentity(name, config));
@@ -4945,6 +4904,9 @@ No answer is available from the current conversation context.`;
   async presentUserInputRequest(_context) {
     return { kind: "unsupported" };
   }
+  async presentPermissionRequest(_context) {
+    return { kind: "unsupported" };
+  }
   emitTaskLifecycle(event) {
     try {
       const result = this.onTaskLifecycle(event);
@@ -5837,7 +5799,6 @@ ${promptText}` : promptText;
         return false;
       }
       active.cancelled = true;
-      this.stopActiveStreaming(active, sessionId, reason);
       this.dropCollectBuffer(sessionId);
       this.removePendingPermissionsForSession(sessionId, "run_cancelled");
       this.emitTaskCancellation(active, sessionId, reason);
@@ -6144,44 +6105,39 @@ ${promptText}` : promptText;
     return { kind: "found", pending: matching[0] };
   }
   canEnvelopeAnswerPendingPermission(envelope, pending) {
-    return pending.target.chatId === envelope.chatId && pending.target.threadId === envelope.threadId && (!pending.userInputPresented || pending.target.senderId === envelope.senderId) && (this.isSharedSessionTarget(pending.target) || pending.target.senderId === envelope.senderId);
+    return pending.target.chatId === envelope.chatId && pending.target.threadId === envelope.threadId && (!pending.userInputPresented && !pending.permissionPresented || pending.target.senderId === envelope.senderId) && (this.isSharedSessionTarget(pending.target) || pending.target.senderId === envelope.senderId);
   }
   formatPermissionRequest(pending) {
     const { toolCall } = pending.request;
+    const copy = PERMISSION_COPY[this.locale];
     const parameters = this.permissionParameterSummary(toolCall);
-    const approveLabel = this.permissionOptionLabel(this.approvalOption(pending), "allow once");
+    const approveLabel = this.permissionOptionLabel(this.approvalOption(pending), copy.allowOnce.toLocaleLowerCase(this.locale));
     const alwaysOption = this.approvalAlwaysOption(pending);
-    const denyLabel = this.permissionOptionLabel(this.denialOption(pending), "deny");
+    const denyLabel = this.permissionOptionLabel(this.denialOption(pending), copy.deny.toLocaleLowerCase(this.locale));
     const requestSuffix = pending.taskName ? ` ${pending.requestId}` : "";
     const replyPadding = pending.taskName ? { approve: "          ", always: "   ", deny: "             " } : { approve: "        ", always: " ", deny: "           " };
     const replies = [
-      `${this.prefixedCommand(`/approve${requestSuffix}`)}${replyPadding.approve}${approveLabel}`,
+      `/approve${requestSuffix}${replyPadding.approve}${approveLabel}`,
       ...alwaysOption ? [
-        `${this.prefixedCommand(`/approve-always${requestSuffix}`)}${replyPadding.always}${alwaysOption.label}`
+        `/approve-always${requestSuffix}${replyPadding.always}${alwaysOption.label}`
       ] : [],
-      `${this.prefixedCommand(`/deny${requestSuffix}`)}${replyPadding.deny}${denyLabel}`
+      `/deny${requestSuffix}${replyPadding.deny}${denyLabel}`
     ];
     return [
-      "Permission required to run a tool",
-      ...pending.taskName ? [`Request: ${pending.requestId}`] : [],
+      copy.required,
+      ...pending.taskName ? [`${copy.request} ${pending.requestId}`] : [],
       "",
-      `Tool: ${this.permissionToolName(toolCall)}`,
-      `Action: ${this.permissionTitle(toolCall)}`,
-      ...parameters ? [`Parameters: ${parameters}`] : [],
+      `${copy.tool} ${this.permissionToolName(toolCall)}`,
+      `${copy.action} ${this.permissionTitle(toolCall)}`,
+      ...parameters ? [`${copy.parameters} ${parameters}`] : [],
       "",
-      "Reply with:",
+      copy.replyWith,
       ...replies
     ].join("\n");
   }
-  prefixedCommand(command) {
-    return this.messagePrefix ? `${this.messagePrefix} ${command}` : command;
-  }
-  configuredMessagePrefix() {
-    return this.messagePrefix;
-  }
   permissionTitle(toolCall) {
     const rawTitle = typeof toolCall.title === "string" ? toolCall.title : void 0;
-    return sanitizeQuotedText(rawTitle || "", 160).trim() || "Tool use";
+    return sanitizeQuotedText(rawTitle || "", 160).trim() || PERMISSION_COPY[this.locale].toolUse;
   }
   permissionToolName(toolCall) {
     const rawToolCall = toolCall;
@@ -6221,7 +6177,31 @@ ${promptText}` : promptText;
   permissionOptionLabel(option, fallback) {
     const rawLabel = typeof option?.name === "string" ? option.name : "";
     const label = sanitizeQuotedText(rawLabel, 160).trim();
-    return label || fallback;
+    if (!label)
+      return fallback;
+    return this.localizedPermissionOptionLabel(option, label) ?? label;
+  }
+  localizedPermissionOptionLabel(option, label) {
+    if (this.locale !== "zh")
+      return void 0;
+    const copy = PERMISSION_COPY[this.locale];
+    if (option?.kind === "allow_always") {
+      if (option.optionId === "proceed_always_project") {
+        return localizedScopedAlwaysLabel(label, "Always Allow in project", copy.allowAlwaysProject);
+      }
+      if (option.optionId === "proceed_always_user") {
+        return localizedScopedAlwaysLabel(label, "Always Allow for user", copy.allowAlwaysUser);
+      }
+      if (option.optionId === "proceed_always" && label === "Allow All Edits") {
+        return copy.allowAlways;
+      }
+      return void 0;
+    }
+    if (label === "Allow" || label === "Allow once")
+      return copy.allowOnce;
+    if (label === "Deny" || label === "Reject")
+      return copy.deny;
+    return void 0;
   }
   approvalOption(pending) {
     const options = pending.request.options;
@@ -6245,13 +6225,14 @@ ${promptText}` : promptText;
     return options.find((option) => option.optionId === `proceed_always_${scope}`);
   }
   approvalAlwaysLabel(option) {
+    const copy = PERMISSION_COPY[this.locale];
     if (option.optionId === "proceed_always_project") {
-      return "always allow for this project";
+      return copy.allowAlwaysProject;
     }
     if (option.optionId === "proceed_always_user") {
-      return "always allow for this user";
+      return copy.allowAlwaysUser;
     }
-    return "always allow";
+    return copy.allowAlways;
   }
   denialResponse(pending) {
     const option = this.denialOption(pending);
@@ -6287,7 +6268,7 @@ ${promptText}` : promptText;
         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 ${this.prefixedCommand(`/${decision} <request-id>`)}.
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Multiple permission requests are pending for this chat. Reply with /${decision} <request-id>.
 ${requestList}`);
       return true;
     }
@@ -6301,7 +6282,7 @@ ${requestList}`);
       return true;
     }
     if (pending.userInputPresented && decision !== "deny") {
-      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Submit this question through its interactive card, or use ${this.prefixedCommand("/deny [request-id]")} to cancel it.`, pending.sourceLabel);
+      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 = (() => {
@@ -6317,7 +6298,7 @@ ${requestList}`);
     }
     let accepted;
     try {
-      accepted = pending.userInputPresented ? await this.respondToUserInput(pending, response) : await this.bridge.respondToPermission(pending.requestId, response);
+      accepted = pending.userInputPresented || pending.permissionPresented ? await this.respondToUserInput(pending, response) : await this.bridge.respondToPermission(pending.requestId, response);
     } catch (err) {
       this.removePendingPermission(pending.requestId);
       process.stderr.write(`[${this.name}] permission response failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}
@@ -6468,7 +6449,7 @@ ${requestList}`);
     if (safeTaskName !== void 0 && failedTaskName === await this.selectedTaskName(envelope)) {
       return `${subject} ${problem}. Its files were not changed. ${interrupted ? "Clear the task again to finish the reset." : "Clear the task to restart it in the same worktree, or close it."}`;
     }
-    const remedy = safeTaskName === void 0 ? "select this task first or close it" : `select this task first or close it with ${this.prefixedCommand(`/session close ${safeTaskName}`)}`;
+    const remedy = safeTaskName === void 0 ? "select this task first or close it" : `select this task first or close it with /session close ${safeTaskName}`;
     return `${subject} ${problem}. Its files were not changed. Clearing now would reset the selected task instead, so ${remedy}.`;
   }
   async selectedTaskName(envelope) {
@@ -6495,7 +6476,7 @@ ${requestList}`);
       return false;
     const normalized = args.trim().toLowerCase();
     if (normalized !== "" && normalized !== "all") {
-      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: ${this.prefixedCommand("/sessions [all]")}`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: /sessions [all]`);
       return true;
     }
     try {
@@ -6526,7 +6507,7 @@ ${requestList}`);
           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 ${this.prefixedCommand("/session new <name>")} or ${this.prefixedCommand("/session use <name>")}.`);
+          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": {
@@ -6585,7 +6566,7 @@ ${requestList}`);
       await this.sendNamedSessionError(envelope, error);
       return true;
     }
-    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: ${this.prefixedCommand("/session current")} | ${this.prefixedCommand("/session new <name> [--worktree]")} | ${this.prefixedCommand("/session use <name>")} | ${this.prefixedCommand("/session close <name>")} | ${this.prefixedCommand("/session cancel [<name>]")}`);
+    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: /session current | /session new <name> [--worktree] | /session use <name> | /session close <name> | /session cancel [<name>]`);
     return true;
   }
   /** Register shared slash commands. Called from constructor. */
@@ -6678,7 +6659,7 @@ ${requestList}`);
         return true;
       }
       if (this.isSharedSession(envelope) && args.toLowerCase() !== "confirm") {
-        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `This clears the shared session for everyone who shares it. Re-send with "confirm" (e.g. ${this.prefixedCommand("/clear confirm")}) to proceed.`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `This clears the shared session for everyone who shares it. Re-send with "confirm" (e.g. /clear confirm) to proceed.`);
         return true;
       }
       await doClear(envelope);
@@ -6719,19 +6700,19 @@ ${requestList}`);
     this.registerCommand("help", async (envelope) => {
       const lines = [
         "Commands:",
-        `${this.prefixedCommand("/help")} \u2014 Show this help`,
-        this.isSharedSession(envelope) ? `${this.prefixedCommand("/clear confirm")} \u2014 Clear the shared session (aliases: ${this.prefixedCommand("/reset")}, ${this.prefixedCommand("/new")})` : `${this.prefixedCommand("/clear")} \u2014 Clear your session (aliases: ${this.prefixedCommand("/reset")}, ${this.prefixedCommand("/new")})`,
-        `${this.prefixedCommand("/who")} \u2014 Show current session & workspace`,
-        `${this.prefixedCommand("/status")} \u2014 Show session info`,
-        `${this.prefixedCommand("/approve [request-id]")} \u2014 Approve a pending permission request`,
-        `${this.prefixedCommand("/approve-always [request-id]")} \u2014 Always approve a pending permission request`,
-        `${this.prefixedCommand("/deny [request-id]")} \u2014 Deny a pending permission request`,
+        `/help \u2014 Show this help`,
+        this.isSharedSession(envelope) ? `/clear confirm \u2014 Clear the shared session (aliases: /reset, /new)` : `/clear \u2014 Clear your session (aliases: /reset, /new)`,
+        `/who \u2014 Show current session & workspace`,
+        `/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`,
         ...this.bridge.btw ? [
-          `${this.prefixedCommand("/btw <question>")} \u2014 Ask a side question without interrupting the current task`
+          `/btw <question> \u2014 Ask a side question without interrupting the current task`
         ] : [],
         ...this.namedSessions ? [
-          `${this.prefixedCommand("/sessions [all]")} \u2014 List your named tasks`,
-          `${this.prefixedCommand("/session current|new|use|close|cancel")} \u2014 Manage your named tasks`
+          `/sessions [all] \u2014 List your named tasks`,
+          `/session current|new|use|close|cancel \u2014 Manage your named tasks`
         ] : []
       ];
       const sharedCmds = /* @__PURE__ */ new Set([
@@ -6754,7 +6735,7 @@ ${requestList}`);
       const platformCmds = [...this.commands.keys()].filter((c) => !sharedCmds.has(c));
       if (platformCmds.length > 0) {
         for (const cmd of platformCmds) {
-          lines.push(this.prefixedCommand(`/${cmd}`));
+          lines.push(`/${cmd}`);
         }
       }
       const sessionId = await this.currentSessionId(envelope);
@@ -6765,10 +6746,10 @@ ${requestList}`);
       if (agentCommands.length > 0) {
         lines.push("", "Agent commands (forwarded to Qwen Code):");
         for (const cmd of agentCommands) {
-          lines.push(`${this.prefixedCommand(`/${cmd.name}`)} \u2014 ${cmd.description}`);
+          lines.push(`/${cmd.name} \u2014 ${cmd.description}`);
         }
       }
-      lines.push("", this.messagePrefix ? `Start each message with ${this.messagePrefix} to chat with the agent.` : "Send any text to chat with the agent.");
+      lines.push("", "Send any text to chat with the agent.");
       await this.sendThreadMessage(envelope.chatId, envelope.threadId, lines.join("\n"));
       return true;
     });
@@ -6813,7 +6794,7 @@ ${requestList}`);
       case "cancel":
         return this.handleLoopCancel(envelope, rest[0]);
       default:
-        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: ${this.prefixedCommand('/loop add "<cron>" <prompt>')} | ${this.prefixedCommand("/loop list")} | ${this.prefixedCommand("/loop inspect <id>")} | ${this.prefixedCommand("/loop cancel <id>")}`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: /loop add "<cron>" <prompt> | /loop list | /loop inspect <id> | /loop cancel <id>`);
         return true;
     }
   }
@@ -6830,7 +6811,7 @@ ${requestList}`);
     }
     const parsed = parseLoopAddArgs(args);
     if (!parsed) {
-      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: ${this.prefixedCommand('/loop add "<cron>" <prompt>')}`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: /loop add "<cron>" <prompt>`);
       return true;
     }
     try {
@@ -6984,7 +6965,7 @@ ${requestList}`);
     if (!this.loopController)
       return true;
     if (!id) {
-      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: ${this.prefixedCommand("/loop inspect <id>")}`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: /loop inspect <id>`);
       return true;
     }
     const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
@@ -7044,7 +7025,7 @@ ${requestList}`);
     if (!this.loopController)
       return true;
     if (!id) {
-      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: ${this.prefixedCommand("/loop cancel <id>")}`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: /loop cancel <id>`);
       return true;
     }
     const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
@@ -7629,17 +7610,8 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
     const active = this.activePrompts.get(sessionId);
     return active?.senderName || active?.senderId || target.senderId || "agent";
   }
-  stopActiveStreaming(active, sessionId, reason) {
-    try {
-      active.stopStreaming?.();
-    } catch (err) {
-      process.stderr.write(`[${this.name}] stopStreaming threw during ${reason} for session ${sessionId}: ${err instanceof Error ? err.message : err}
-`);
-    }
-  }
   /**
-   * Cancel the active turn and wait (bounded) for it to wind down. Stops the
-   * BlockStreamer so buffered text can't leak via the idle timer, then fires a
+   * Cancel the active turn and wait (bounded) for it to wind down. Fires a
    * best-effort cancelSession (NOT awaited — a wedged child/daemon can leave the
    * request pending forever). Returns true if active.done settled first, false
    * if the CLEAR_CANCEL_TIMEOUT_MS bound won (the turn never wound down). Used by
@@ -7650,7 +7622,6 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
    */
   async cancelAndAwaitActive(active, sessionId) {
     active.cancelled = true;
-    this.stopActiveStreaming(active, sessionId, "cancel");
     void this.bridge.cancelSession(sessionId).catch((err) => {
       process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (clear/await): ${err instanceof Error ? err.message : err}
 `);
@@ -7853,18 +7824,6 @@ ${CURRENT_MESSAGE_MARKER}
 ${promptText}`;
   }
   preflightInbound(envelope, options = {}) {
-    if (this.messagePrefixRejectedEnvelopes.has(envelope))
-      return false;
-    if (!this.messagePrefixCheckedEnvelopes.has(envelope)) {
-      this.messagePrefixCheckedEnvelopes.add(envelope);
-      if (!applyMessagePrefix(envelope, this.messagePrefix)) {
-        this.messagePrefixRejectedEnvelopes.add(envelope);
-        if (!(envelope.isGroup && !envelope.isMentioned && !envelope.isReplyToBot)) {
-          this.logPreflightRejected("message_prefix_mismatch");
-        }
-        return false;
-      }
-    }
     const groupResult = this.groupGate.check(envelope, {
       createPairingRequest: !options.deferPairingRequests
     });
@@ -7920,9 +7879,6 @@ ${promptText}`;
     process.stderr.write(`[Channel:${this.name}] preflight rejected reason=${sanitizeLogText(reason, 80)}
 `);
   }
-  wasMessagePrefixRejected(envelope) {
-    return this.messagePrefixRejectedEnvelopes.has(envelope);
-  }
   logDebugPayload(platform, payload) {
     if (!isDebugPayloadEnabled(this.name))
       return;
@@ -8146,12 +8102,12 @@ ${text}`;
       }
       if (parsed.command === "btw" && this.bridge.btw) {
         if (!this.isAuthorizedForSharedSession(envelope)) {
-          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Only authorized members can use ${this.prefixedCommand("/btw")} in this shared session.`);
+          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: ${this.prefixedCommand("/btw <question>")}`);
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Usage: /btw <question>`);
           return;
         }
         if (btwQuestion.length > CHANNEL_BTW_MAX_INPUT_LENGTH) {
@@ -8159,7 +8115,7 @@ ${text}`;
           return;
         }
         if (envelope.imageBase64 || envelope.attachments?.length) {
-          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `${this.prefixedCommand("/btw")} supports text-only questions.`);
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `/btw supports text-only questions.`);
           return;
         }
       }
@@ -8217,7 +8173,7 @@ ${text}`;
         return;
       }
       if (!sessionId) {
-        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No task is currently selected. Use ${this.prefixedCommand("/session new <name>")} or ${this.prefixedCommand("/session use <name>")}.`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No task is currently selected. Use /session new <name> or /session use <name>.`);
         return;
       }
     } else {
@@ -8225,7 +8181,7 @@ ${text}`;
     }
     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 ${this.prefixedCommand("/sessions")}, select it again, and retry.`);
+      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) {
@@ -8340,7 +8296,6 @@ ${promptText}`;
           if (firstCancellation) {
             process.stderr.write(`[${this.name}] steer: cancelled active turn for ${envelope.senderId} in session ${sessionId}
 `);
-            this.stopActiveStreaming(active, sessionId, "steer");
             void this.bridge.cancelSession(sessionId).catch((err) => {
               process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (steer): ${err instanceof Error ? err.message : err}
 `);
@@ -8375,7 +8330,6 @@ ${promptText}`;
     }
     const prev = this.sessionQueues.get(sessionId) ?? Promise.resolve();
     const generation = namedTurn?.generation ?? this.sessionGenerations.get(sessionId) ?? 0;
-    const useBlockStreaming = this.config.blockStreaming === "on";
     if (namedTurn) {
       namedTurn.claimed = true;
     } else {
@@ -8478,18 +8432,9 @@ ${promptToSend}`;
         process.stderr.write(`[${this.name}] onPromptStart threw for session ${sessionId}: ${this.lifecycleError(err)}
 `);
       }
-      const streamer = useBlockStreaming ? new BlockStreamer({
-        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, sourceLabel), "send")
-      }) : null;
-      promptState.stopStreaming = () => streamer?.stop();
       const heldChunks = [];
-      let hasStreamedText = false;
       const releaseHeldChunks = /* @__PURE__ */ __name(() => {
         for (const held of heldChunks.splice(0)) {
-          hasStreamedText = true;
           const segment = this.ensureOutputSegment(sessionId, promptState);
           this.emitTaskLifecycle({
             ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
@@ -8497,7 +8442,6 @@ ${promptToSend}`;
             chunk: held
           });
           this.onResponseChunk(envelope.chatId, held, sessionId, segment);
-          streamer?.push(held);
         }
       }, "releaseHeldChunks");
       const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
@@ -8514,10 +8458,8 @@ ${promptToSend}`;
           return;
         }
         heldChunks.length = 0;
-        hasStreamedText = false;
         const segment = this.closeOutputSegment(sessionId, promptState);
         void this.notifyOutputSegmentEnd(envelope.chatId, sessionId, segment, "response_boundary");
-        streamer?.stop();
       }, "onResponseBoundary");
       await this.waitForBridgeRecovery();
       const promptBridge = this.bridge;
@@ -8536,17 +8478,10 @@ ${promptToSend}`;
         }
         if (!promptState.cancelled && response) {
           promptState.deliveryStarted = true;
-          if (streamer) {
-            if (!hasStreamedText) {
-              streamer.push(response);
-            }
-            await streamer.flush();
-          } else {
-            const segment = this.ensureOutputSegment(sessionId, promptState);
-            await this.onResponseComplete(envelope.chatId, response, sessionId, segment);
-            if (segment && promptState.activeSegmentId === segment.segmentId) {
-              promptState.activeSegmentId = void 0;
-            }
+          const segment = this.ensureOutputSegment(sessionId, promptState);
+          await this.onResponseComplete(envelope.chatId, response, sessionId, segment);
+          if (segment && promptState.activeSegmentId === segment.segmentId) {
+            promptState.activeSegmentId = void 0;
           }
         }
         if (!promptState.deliveryStarted) {
@@ -8591,10 +8526,6 @@ ${promptToSend}`;
       } finally {
         promptBridge.off("textChunk", onChunk);
         promptBridge.off("responseBoundary", onResponseBoundary);
-        if (streamer) {
-          streamer.stop();
-          await streamer.drain();
-        }
         const stillCurrent = this.activePrompts.get(sessionId) === promptState;
         if (!promptState.clearEvicted) {
           try {
@@ -9906,8 +9837,6 @@ export {
   sanitizeLogText,
   SessionRouter,
   ChannelLoopScheduler,
-  startsWithMessagePrefix,
-  stripMessagePrefix,
   ChannelBase,
   PollingChannelBase,
   CHANNEL_PROMPT_META_KEY,