@qwen-code/qwen-code 0.19.3 → 0.19.4-nightly.20260702.46814e4f1

package/chunks/{chunk-N4EJFBN5.js → chunk-JVLP5US5.js}

@@ -1,23 +1,29 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  isLoopbackBind
+} from "./chunk-RNBYOUGV.js";
 import {
   require_lib
 } from "./chunk-3HX5LZ6R.js";
 import {
   require_mime_db
 } from "./chunk-7RYW5LQV.js";
+import {
+  CLIENT_MCP_OVER_WS_CONFIG_FLAG
+} from "./chunk-EWALXUAD.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH
-} from "./chunk-JE5FVRPC.js";
+} from "./chunk-SEZC2725.js";
 import {
   writeStderrLine
 } from "./chunk-Y6Z2O3WR.js";
 import {
   require_once
-} from "./chunk-YAINVQ3Q.js";
+} from "./chunk-5P5XGNYH.js";
 import {
   require_safer
-} from "./chunk-EJYJYJZ2.js";
+} from "./chunk-SYCJMSIJ.js";
 import {
   require_src
 } from "./chunk-QN5NZ3UQ.js";
@@ -11329,13 +11335,13 @@ var require_is_promise = __commonJS({
   }
 });
 
-// node_modules/router/node_modules/path-to-regexp/dist/index.js
+// node_modules/path-to-regexp/dist/index.js
 var require_dist2 = __commonJS({
-  "node_modules/router/node_modules/path-to-regexp/dist/index.js"(exports) {
+  "node_modules/path-to-regexp/dist/index.js"(exports) {
     "use strict";
     init_esbuild_shims();
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.TokenData = void 0;
+    exports.PathError = exports.TokenData = void 0;
     exports.parse = parse;
     exports.compile = compile;
     exports.match = match;
@@ -11345,176 +11351,129 @@ var require_dist2 = __commonJS({
     var NOOP_VALUE = /* @__PURE__ */ __name((value) => value, "NOOP_VALUE");
     var ID_START = /^[$_\p{ID_Start}]$/u;
     var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
-    var DEBUG_URL = "https://git.new/pathToRegexpError";
-    var SIMPLE_TOKENS = {
-      // Groups.
-      "{": "{",
-      "}": "}",
-      // Reserved.
-      "(": "(",
-      ")": ")",
-      "[": "[",
-      "]": "]",
-      "+": "+",
-      "?": "?",
-      "!": "!"
-    };
+    var ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
     function escapeText(str) {
-      return str.replace(/[{}()\[\]+?!:*]/g, "\\$&");
+      return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
     }
     __name(escapeText, "escapeText");
     function escape(str) {
       return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
     }
     __name(escape, "escape");
-    function* lexer(str) {
-      const chars = [...str];
-      let i = 0;
-      function name() {
-        let value = "";
-        if (ID_START.test(chars[++i])) {
-          value += chars[i];
-          while (ID_CONTINUE.test(chars[++i])) {
-            value += chars[i];
-          }
-        } else if (chars[i] === '"') {
-          let pos = i;
-          while (i < chars.length) {
-            if (chars[++i] === '"') {
-              i++;
-              pos = 0;
-              break;
-            }
-            if (chars[i] === "\\") {
-              value += chars[++i];
-            } else {
-              value += chars[i];
-            }
-          }
-          if (pos) {
-            throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);
-          }
-        }
-        if (!value) {
-          throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
-        }
-        return value;
-      }
-      __name(name, "name");
-      while (i < chars.length) {
-        const value = chars[i];
-        const type = SIMPLE_TOKENS[value];
-        if (type) {
-          yield { type, index: i++, value };
-        } else if (value === "\\") {
-          yield { type: "ESCAPED", index: i++, value: chars[i++] };
-        } else if (value === ":") {
-          const value2 = name();
-          yield { type: "PARAM", index: i, value: value2 };
-        } else if (value === "*") {
-          const value2 = name();
-          yield { type: "WILDCARD", index: i, value: value2 };
-        } else {
-          yield { type: "CHAR", index: i, value: chars[i++] };
-        }
-      }
-      return { type: "END", index: i, value: "" };
-    }
-    __name(lexer, "lexer");
-    var Iter = class {
+    var TokenData = class {
       static {
-        __name(this, "Iter");
+        __name(this, "TokenData");
       }
-      constructor(tokens) {
+      constructor(tokens, originalPath) {
         this.tokens = tokens;
-      }
-      peek() {
-        if (!this._peek) {
-          const next = this.tokens.next();
-          this._peek = next.value;
-        }
-        return this._peek;
-      }
-      tryConsume(type) {
-        const token = this.peek();
-        if (token.type !== type)
-          return;
-        this._peek = void 0;
-        return token.value;
-      }
-      consume(type) {
-        const value = this.tryConsume(type);
-        if (value !== void 0)
-          return value;
-        const { type: nextType, index } = this.peek();
-        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);
-      }
-      text() {
-        let result = "";
-        let value;
-        while (value = this.tryConsume("CHAR") || this.tryConsume("ESCAPED")) {
-          result += value;
-        }
-        return result;
+        this.originalPath = originalPath;
       }
     };
-    var TokenData = class {
+    exports.TokenData = TokenData;
+    var PathError = class extends TypeError {
       static {
-        __name(this, "TokenData");
+        __name(this, "PathError");
       }
-      constructor(tokens) {
-        this.tokens = tokens;
+      constructor(message, originalPath) {
+        let text = message;
+        if (originalPath)
+          text += `: ${originalPath}`;
+        text += `; visit https://git.new/pathToRegexpError for info`;
+        super(text);
+        this.originalPath = originalPath;
       }
     };
-    exports.TokenData = TokenData;
+    exports.PathError = PathError;
     function parse(str, options = {}) {
       const { encodePath = NOOP_VALUE } = options;
-      const it = new Iter(lexer(str));
-      function consume(endType) {
-        const tokens2 = [];
-        while (true) {
-          const path3 = it.text();
-          if (path3)
-            tokens2.push({ type: "text", value: encodePath(path3) });
-          const param = it.tryConsume("PARAM");
-          if (param) {
-            tokens2.push({
-              type: "param",
-              name: param
-            });
+      const chars = [...str];
+      let index = 0;
+      function consumeUntil(end) {
+        const output = [];
+        let path3 = "";
+        function writePath() {
+          if (!path3)
+            return;
+          output.push({
+            type: "text",
+            value: encodePath(path3)
+          });
+          path3 = "";
+        }
+        __name(writePath, "writePath");
+        while (index < chars.length) {
+          const value = chars[index++];
+          if (value === end) {
+            writePath();
+            return output;
+          }
+          if (value === "\\") {
+            if (index === chars.length) {
+              throw new PathError(`Unexpected end after \\ at index ${index}`, str);
+            }
+            path3 += chars[index++];
             continue;
           }
-          const wildcard = it.tryConsume("WILDCARD");
-          if (wildcard) {
-            tokens2.push({
-              type: "wildcard",
-              name: wildcard
-            });
+          if (value === ":" || value === "*") {
+            const type = value === ":" ? "param" : "wildcard";
+            let name = "";
+            if (ID_START.test(chars[index])) {
+              do {
+                name += chars[index++];
+              } while (ID_CONTINUE.test(chars[index]));
+            } else if (chars[index] === '"') {
+              let quoteStart = index;
+              while (index < chars.length) {
+                if (chars[++index] === '"') {
+                  index++;
+                  quoteStart = 0;
+                  break;
+                }
+                if (chars[index] === "\\")
+                  index++;
+                name += chars[index];
+              }
+              if (quoteStart) {
+                throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
+              }
+            }
+            if (!name) {
+              throw new PathError(`Missing parameter name at index ${index}`, str);
+            }
+            writePath();
+            output.push({ type, name });
             continue;
           }
-          const open = it.tryConsume("{");
-          if (open) {
-            tokens2.push({
+          if (value === "{") {
+            writePath();
+            output.push({
               type: "group",
-              tokens: consume("}")
+              tokens: consumeUntil("}")
             });
             continue;
           }
-          it.consume(endType);
-          return tokens2;
+          if (value === "}" || value === "(" || value === ")" || value === "[" || value === "]" || value === "+" || value === "?" || value === "!") {
+            throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
+          }
+          path3 += value;
+        }
+        if (end) {
+          throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
         }
+        writePath();
+        return output;
       }
-      __name(consume, "consume");
-      const tokens = consume("END");
-      return new TokenData(tokens);
+      __name(consumeUntil, "consumeUntil");
+      return new TokenData(consumeUntil(""), str);
     }
     __name(parse, "parse");
     function compile(path3, options = {}) {
       const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
-      const data = path3 instanceof TokenData ? path3 : parse(path3, options);
+      const data = typeof path3 === "object" ? path3 : parse(path3, options);
       const fn = tokensToFunction(data.tokens, delimiter, encode);
-      return /* @__PURE__ */ __name(function path4(data2 = {}) {
-        const [path5, ...missing] = fn(data2);
+      return /* @__PURE__ */ __name(function path4(params = {}) {
+        const missing = [];
+        const path5 = fn(params, missing);
         if (missing.length) {
           throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
         }
@@ -11524,12 +11483,10 @@ var require_dist2 = __commonJS({
     __name(compile, "compile");
     function tokensToFunction(tokens, delimiter, encode) {
       const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
-      return (data) => {
-        const result = [""];
+      return (data, missing) => {
+        let result = "";
         for (const encoder of encoders) {
-          const [value, ...extras] = encoder(data);
-          result[0] += value;
-          result.push(...extras);
+          result += encoder(data, missing);
         }
         return result;
       };
@@ -11537,43 +11494,51 @@ var require_dist2 = __commonJS({
     __name(tokensToFunction, "tokensToFunction");
     function tokenToFunction(token, delimiter, encode) {
       if (token.type === "text")
-        return () => [token.value];
+        return () => token.value;
       if (token.type === "group") {
         const fn = tokensToFunction(token.tokens, delimiter, encode);
-        return (data) => {
-          const [value, ...missing] = fn(data);
-          if (!missing.length)
-            return [value];
-          return [""];
+        return (data, missing) => {
+          const len = missing.length;
+          const value = fn(data, missing);
+          if (missing.length === len)
+            return value;
+          missing.length = len;
+          return "";
         };
       }
       const encodeValue = encode || NOOP_VALUE;
       if (token.type === "wildcard" && encode !== false) {
-        return (data) => {
+        return (data, missing) => {
           const value = data[token.name];
-          if (value == null)
-            return ["", token.name];
+          if (value == null) {
+            missing.push(token.name);
+            return "";
+          }
           if (!Array.isArray(value) || value.length === 0) {
             throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
           }
-          return [
-            value.map((value2, index) => {
-              if (typeof value2 !== "string") {
-                throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
-              }
-              return encodeValue(value2);
-            }).join(delimiter)
-          ];
+          let result = "";
+          for (let i = 0; i < value.length; i++) {
+            if (typeof value[i] !== "string") {
+              throw new TypeError(`Expected "${token.name}/${i}" to be a string`);
+            }
+            if (i > 0)
+              result += delimiter;
+            result += encodeValue(value[i]);
+          }
+          return result;
         };
       }
-      return (data) => {
+      return (data, missing) => {
         const value = data[token.name];
-        if (value == null)
-          return ["", token.name];
+        if (value == null) {
+          missing.push(token.name);
+          return "";
+        }
         if (typeof value !== "string") {
           throw new TypeError(`Expected "${token.name}" to be a string`);
         }
-        return [encodeValue(value)];
+        return encodeValue(value);
       };
     }
     __name(tokenToFunction, "tokenToFunction");
@@ -11607,112 +11572,161 @@ var require_dist2 = __commonJS({
     function pathToRegexp(path3, options = {}) {
       const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
       const keys = [];
-      const sources = [];
-      const flags = sensitive ? "" : "i";
-      const paths = Array.isArray(path3) ? path3 : [path3];
-      const items = paths.map((path4) => path4 instanceof TokenData ? path4 : parse(path4, options));
-      for (const { tokens } of items) {
-        for (const seq of flatten(tokens, 0, [])) {
-          const regexp2 = sequenceToRegExp(seq, delimiter, keys);
-          sources.push(regexp2);
+      let source = "";
+      let combinations = 0;
+      function process2(path4) {
+        if (Array.isArray(path4)) {
+          for (const p of path4)
+            process2(p);
+          return;
         }
+        const data = typeof path4 === "object" ? path4 : parse(path4, options);
+        flatten(data.tokens, 0, [], (tokens) => {
+          if (combinations >= 256) {
+            throw new PathError("Too many path combinations", data.originalPath);
+          }
+          if (combinations > 0)
+            source += "|";
+          source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
+          combinations++;
+        });
       }
-      let pattern = `^(?:${sources.join("|")})`;
+      __name(process2, "process");
+      process2(path3);
+      let pattern = `^(?:${source})`;
       if (trailing)
-        pattern += `(?:${escape(delimiter)}$)?`;
-      pattern += end ? "$" : `(?=${escape(delimiter)}|$)`;
-      const regexp = new RegExp(pattern, flags);
-      return { regexp, keys };
+        pattern += "(?:" + escape(delimiter) + "$)?";
+      pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
+      return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
     }
     __name(pathToRegexp, "pathToRegexp");
-    function* flatten(tokens, index, init) {
-      if (index === tokens.length) {
-        return yield init;
-      }
-      const token = tokens[index];
-      if (token.type === "group") {
-        const fork = init.slice();
-        for (const seq of flatten(token.tokens, 0, fork)) {
-          yield* flatten(tokens, index + 1, seq);
+    function flatten(tokens, index, result, callback) {
+      while (index < tokens.length) {
+        const token = tokens[index++];
+        if (token.type === "group") {
+          const len = result.length;
+          flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback));
+          result.length = len;
+          continue;
         }
-      } else {
-        init.push(token);
+        result.push(token);
       }
-      yield* flatten(tokens, index + 1, init);
+      callback(result);
     }
     __name(flatten, "flatten");
-    function sequenceToRegExp(tokens, delimiter, keys) {
+    function toRegExpSource(tokens, delimiter, keys, originalPath) {
       let result = "";
       let backtrack = "";
-      let isSafeSegmentParam = true;
-      for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
+      let wildcardBacktrack = "";
+      let prevCaptureType = 0;
+      let hasSegmentCapture = 0;
+      let index = 0;
+      function hasInSegment(index2, type) {
+        while (index2 < tokens.length) {
+          const token = tokens[index2++];
+          if (token.type === type)
+            return true;
+          if (token.type === "text") {
+            if (token.value.includes(delimiter))
+              break;
+          }
+        }
+        return false;
+      }
+      __name(hasInSegment, "hasInSegment");
+      function peekText(index2) {
+        let result2 = "";
+        while (index2 < tokens.length) {
+          const token = tokens[index2++];
+          if (token.type !== "text")
+            break;
+          result2 += token.value;
+        }
+        return result2;
+      }
+      __name(peekText, "peekText");
+      while (index < tokens.length) {
+        const token = tokens[index++];
         if (token.type === "text") {
           result += escape(token.value);
           backtrack += token.value;
-          isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+          if (prevCaptureType === 2)
+            wildcardBacktrack += token.value;
+          if (token.value.includes(delimiter))
+            hasSegmentCapture = 0;
           continue;
         }
         if (token.type === "param" || token.type === "wildcard") {
-          if (!isSafeSegmentParam && !backtrack) {
-            throw new TypeError(`Missing text after "${token.name}": ${DEBUG_URL}`);
+          if (prevCaptureType && !backtrack) {
+            throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
           }
           if (token.type === "param") {
-            result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+            result += hasSegmentCapture & 2 ? `(${negate(delimiter, backtrack)}+)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+)` : hasSegmentCapture & 1 ? `(${negate(delimiter, backtrack)}+|${escape(backtrack)})` : `(${negate(delimiter, "")}+)`;
+            hasSegmentCapture |= prevCaptureType = 1;
           } else {
-            result += `([\\s\\S]+)`;
+            result += hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)` : `([^]+)`;
+            wildcardBacktrack = "";
+            hasSegmentCapture |= prevCaptureType = 2;
           }
           keys.push(token);
           backtrack = "";
-          isSafeSegmentParam = false;
           continue;
         }
+        throw new TypeError(`Unknown token type: ${token.type}`);
       }
       return result;
     }
-    __name(sequenceToRegExp, "sequenceToRegExp");
-    function negate(delimiter, backtrack) {
-      if (backtrack.length < 2) {
-        if (delimiter.length < 2)
-          return `[^${escape(delimiter + backtrack)}]`;
-        return `(?:(?!${escape(delimiter)})[^${escape(backtrack)}])`;
-      }
-      if (delimiter.length < 2) {
-        return `(?:(?!${escape(backtrack)})[^${escape(delimiter)}])`;
-      }
-      return `(?:(?!${escape(backtrack)}|${escape(delimiter)})[\\s\\S])`;
+    __name(toRegExpSource, "toRegExpSource");
+    function negate(a, b) {
+      if (b.length > a.length)
+        return negate(b, a);
+      if (a === b)
+        b = "";
+      if (b.length > 1)
+        return `(?:(?!${escape(a)}|${escape(b)})[^])`;
+      if (a.length > 1)
+        return `(?:(?!${escape(a)})[^${escape(b)}])`;
+      return `[^${escape(a + b)}]`;
     }
     __name(negate, "negate");
-    function stringify(data) {
-      return data.tokens.map(/* @__PURE__ */ __name(function stringifyToken(token, index, tokens) {
-        if (token.type === "text")
-          return escapeText(token.value);
+    function stringifyTokens(tokens, index) {
+      let value = "";
+      while (index < tokens.length) {
+        const token = tokens[index++];
+        if (token.type === "text") {
+          value += escapeText(token.value);
+          continue;
+        }
         if (token.type === "group") {
-          return `{${token.tokens.map(stringifyToken).join("")}}`;
+          value += "{" + stringifyTokens(token.tokens, 0) + "}";
+          continue;
         }
-        const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);
-        const key = isSafe ? token.name : JSON.stringify(token.name);
-        if (token.type === "param")
-          return `:${key}`;
-        if (token.type === "wildcard")
-          return `*${key}`;
-        throw new TypeError(`Unexpected token: ${token}`);
-      }, "stringifyToken")).join("");
+        if (token.type === "param") {
+          value += ":" + stringifyName(token.name, tokens[index]);
+          continue;
+        }
+        if (token.type === "wildcard") {
+          value += "*" + stringifyName(token.name, tokens[index]);
+          continue;
+        }
+        throw new TypeError(`Unknown token type: ${token.type}`);
+      }
+      return value;
     }
-    __name(stringify, "stringify");
-    function isNameSafe(name) {
-      const [first, ...rest] = name;
-      if (!ID_START.test(first))
-        return false;
-      return rest.every((char) => ID_CONTINUE.test(char));
+    __name(stringifyTokens, "stringifyTokens");
+    function stringify(data) {
+      return stringifyTokens(data.tokens, 0);
     }
-    __name(isNameSafe, "isNameSafe");
-    function isNextNameSafe(token) {
-      if ((token === null || token === void 0 ? void 0 : token.type) !== "text")
-        return true;
-      return !ID_CONTINUE.test(token.value[0]);
+    __name(stringify, "stringify");
+    function stringifyName(name, next) {
+      if (!ID.test(name))
+        return JSON.stringify(name);
+      if ((next === null || next === void 0 ? void 0 : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
+        return JSON.stringify(name);
+      }
+      return name;
     }
-    __name(isNextNameSafe, "isNextNameSafe");
+    __name(stringifyName, "stringifyName");
   }
 });
 
@@ -16097,19 +16111,6 @@ function createBridgeFileSystemAdapter(factory) {
 }
 __name(createBridgeFileSystemAdapter, "createBridgeFileSystemAdapter");
 
-// packages/cli/src/serve/loopback-binds.ts
-init_esbuild_shims();
-var LOOPBACK_BINDS = /* @__PURE__ */ new Set([
-  "127.0.0.1",
-  "localhost",
-  "::1",
-  "[::1]"
-]);
-function isLoopbackBind(hostname) {
-  return LOOPBACK_BINDS.has(hostname.toLowerCase());
-}
-__name(isLoopbackBind, "isLoopbackBind");
-
 // packages/cli/src/serve/web-shell-resolver.ts
 init_esbuild_shims();
 import { existsSync } from "node:fs";
@@ -16179,13 +16180,14 @@ function parseAllowOriginPatterns(raw) {
     } catch {
       throw new InvalidAllowOriginPatternError(entry, "not a parseable URL");
     }
-    if (parsed.origin !== entry) {
+    const canonical = parsed.origin === "null" ? `${parsed.protocol}//${parsed.host}` : parsed.origin;
+    if (canonical !== entry) {
       throw new InvalidAllowOriginPatternError(
         entry,
-        `expected the canonical origin ${JSON.stringify(parsed.origin)} without trailing slash, path, userinfo, or query`
+        `expected the canonical origin ${JSON.stringify(canonical)} without trailing slash, path, userinfo, or query`
       );
     }
-    origins.add(parsed.origin.toLowerCase());
+    origins.add(canonical.toLowerCase());
   }
   return { allowAny, origins };
 }
@@ -16241,7 +16243,7 @@ function hostAllowlist(bind, getPort) {
       `[::1]:${port}`,
       `host.docker.internal:${port}`
     ]);
-    if (port === 80) {
+    if (port === 80 || port === 443) {
       cachedAllowed.add("localhost");
       cachedAllowed.add("127.0.0.1");
       cachedAllowed.add("[::1]");
@@ -16314,6 +16316,98 @@ function createMutationGate(deps) {
 }
 __name(createMutationGate, "createMutationGate");
 
+// packages/cli/src/serve/acp-http/client-mcp-sender-registry.ts
+init_esbuild_shims();
+var ClientMcpSenderRegistry = class {
+  static {
+    __name(this, "ClientMcpSenderRegistry");
+  }
+  senders = /* @__PURE__ */ new Map();
+  /**
+   * Record a server's WS sender, owned by `owner` (the registering
+   * connection's stable client id). Idempotent; last writer wins and takes
+   * ownership, so the new owner's `delete` is the one that takes effect.
+   */
+  set(serverName, sender, owner) {
+    this.senders.set(serverName, { sender, owner });
+  }
+  /**
+   * Forget a server's WS sender — but only when `owner` still owns the entry.
+   * Idempotent. The ownership guard stops a disconnecting connection from
+   * clobbering an entry a later connection re-registered under the same name.
+   */
+  delete(serverName, owner) {
+    if (this.senders.get(serverName)?.owner === owner) {
+      this.senders.delete(serverName);
+    }
+  }
+  /** Whether `owner` currently owns the entry for `serverName`. */
+  owns(serverName, owner) {
+    return this.senders.get(serverName)?.owner === owner;
+  }
+  /** Currently-registered server names (tests / accounting). */
+  serverNames() {
+    return [...this.senders.keys()];
+  }
+  /**
+   * The {@link ClientMcpMessageSender} the bridge consumes. Returns a
+   * `(payload) => Promise<payload>` bound to the named server, or `undefined`
+   * when no client currently hosts it. The bridge passes a `JSONRPCMessage` as
+   * `payload`; we keep the public type `unknown` to match the bridge's
+   * SDK-free contract.
+   */
+  lookup = /* @__PURE__ */ __name((serverName) => {
+    const entry = this.senders.get(serverName);
+    if (!entry) return void 0;
+    return (payload) => entry.sender(serverName, payload);
+  }, "lookup");
+};
+function createClientMcpServerProvider(registry, bridge, originatorClientId) {
+  return {
+    async registerClientMcpServer(serverName, sendSdkMcpMessage) {
+      registry.set(serverName, sendSdkMcpMessage, originatorClientId);
+      try {
+        const runtimeConfig = {
+          // SDK-type so the child binds `SdkControlClientTransport`
+          // (`isSdkMcpServerConfig`); the flag tells the child to KEEP the
+          // type and bind `sendSdkMcpMessage` to the reverse ext-method.
+          type: "sdk",
+          [CLIENT_MCP_OVER_WS_CONFIG_FLAG]: true
+        };
+        const result = await bridge.addRuntimeMcpServer(
+          serverName,
+          runtimeConfig,
+          originatorClientId
+        );
+        if (result.skipped) {
+          registry.delete(serverName, originatorClientId);
+          throw new Error(
+            `runtime MCP add skipped: ${result.reason ?? "unknown"}`
+          );
+        }
+        if (result.shadowedSettings) {
+          await bridge.removeRuntimeMcpServer(serverName, originatorClientId).catch(() => {
+          });
+          throw new Error(
+            `client MCP server '${serverName}' conflicts with a configured MCP server`
+          );
+        }
+        return { toolCount: result.toolCount };
+      } catch (err) {
+        registry.delete(serverName, originatorClientId);
+        throw err;
+      }
+    },
+    async unregisterClientMcpServer(serverName) {
+      if (!registry.owns(serverName, originatorClientId)) return;
+      registry.delete(serverName, originatorClientId);
+      await bridge.removeRuntimeMcpServer(serverName, originatorClientId).catch(() => {
+      });
+    }
+  };
+}
+__name(createClientMcpServerProvider, "createClientMcpServerProvider");
+
 // packages/cli/src/serve/capabilities.ts
 init_esbuild_shims();
 var SERVE_PROTOCOL_VERSION = "v1";
@@ -16358,6 +16452,10 @@ var SERVE_CAPABILITY_REGISTRY = {
   // hierarchical QWEN.md state and accepts append/replace writes scoped
   // to either the bound workspace or the global ~/.qwen directory.
   workspace_memory: { since: "v1" },
+  workspace_memory_remember: {
+    since: "v1",
+    modes: ["workspace", "clean"]
+  },
   // Workspace agents CRUD (`GET/POST /workspace/agents` +
   // `GET/POST/DELETE /workspace/agents/:agentType`). Wraps
   // `SubagentManager` over HTTP so remote clients can list / read /
@@ -16375,6 +16473,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_lsp: { since: "v1" },
   session_status: { since: "v1" },
   session_close: { since: "v1" },
+  session_archive: { since: "v1" },
   session_metadata: { since: "v1" },
   // Daemon supports the MCP client guardrail surface: an in-process
   // counter exposed on `GET /workspace/mcp`, a `--mcp-client-budget=N`
@@ -16539,6 +16638,22 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_branch: { since: "v1" },
   rate_limit: { since: "v1" },
   workspace_reload: { since: "v1" },
+  // Phase 2 "reverse tool channel" (issue #5626). A connected WS client (e.g.
+  // the Chrome extension) can host an MCP server that the daemon's agent
+  // calls by carrying `mcp_message` JSON-RPC frames over the daemon WS,
+  // reusing the SDK-MCP-server control-plane pattern. Inbound WS frame types:
+  // `mcp_register` { server }, `mcp_message` { id, server, payload }
+  // (bidirectional, request/response correlated by `id`), `mcp_unregister`
+  // { server }. Advertised CONDITIONALLY so clients pre-flight this tag before
+  // attempting to register a client-hosted server. `runQwenServe` enables it
+  // only when explicitly requested by option or env.
+  client_mcp_over_ws: { since: "v1" },
+  // Plan C "CDP tunnel" (issue #5626): the daemon exposes a `/cdp` WebSocket
+  // where a loopback puppeteer client (chrome-devtools-mcp) drives ONE real tab
+  // via the extension's `chrome.debugger`, tunneled over `/acp` as `cdp_*`
+  // frames. Advertised when explicitly enabled or when the daemon is serving a
+  // Chrome extension origin.
+  cdp_tunnel_over_ws: { since: "v1" },
   // Daemon hosts the `/voice/stream` WebSocket: the browser captures audio and
   // streams raw PCM, the daemon transcribes server-side via the configured
   // `voiceModel` (credentials never reach the client). Advertised
@@ -16575,6 +16690,8 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
   ],
   ["rate_limit", (toggles) => toggles.rateLimit === true],
   ["workspace_reload", (toggles) => toggles.reloadAvailable === true],
+  ["client_mcp_over_ws", (toggles) => toggles.clientMcpOverWsEnabled === true],
+  ["cdp_tunnel_over_ws", (toggles) => toggles.cdpTunnelOverWsEnabled === true],
   [
     // Advertised whenever the `/voice/stream` WS endpoint exists. A configured
     // token (or `--require-auth`) no longer suppresses it: browsers can't set
@@ -16617,9 +16734,6 @@ __name(getServeProtocolVersions, "getServeProtocolVersions");
 init_esbuild_shims();
 var CAPABILITIES_SCHEMA_VERSION = 1;
 
-// packages/cli/src/serve/acp-session-bridge.ts
-init_esbuild_shims();
-
 // packages/cli/src/serve/server/request-helpers.ts
 init_esbuild_shims();
 import * as path2 from "node:path";
@@ -17088,9 +17202,21 @@ async function buildDaemonStatusResponse(detail, input) {
   const bridgeSnapshot = input.bridge.getDaemonStatusSnapshot();
   const acpSnapshot = input.acpHandle?.registry.getSnapshot();
   const rateLimitHits = input.rateLimiter?.getHitCounts() ?? zeroRateHits();
+  const channelWorker = input.getChannelWorkerSnapshot?.() ?? {
+    enabled: false,
+    state: "disabled",
+    channels: []
+  };
   const issues = [];
   let full;
-  pushRuntimeIssues(issues, bridgeSnapshot, acpSnapshot, rateLimitHits, input);
+  pushRuntimeIssues(
+    issues,
+    bridgeSnapshot,
+    acpSnapshot,
+    rateLimitHits,
+    input,
+    channelWorker
+  );
   if (detail === "full") {
     full = await buildFullStatus(input, bridgeSnapshot, acpSnapshot);
     pushFullIssues(issues, full);
@@ -17141,6 +17267,7 @@ async function buildDaemonStatusResponse(detail, input) {
         policy: bridgeSnapshot.permissionPolicy
       },
       channel: { live: bridgeSnapshot.channelLive },
+      channelWorker,
       transport: {
         restSseActive: input.getRestSseActive(),
         acp: {
@@ -17275,7 +17402,7 @@ async function withTimeout(promise, section, timeoutMs) {
   }
 }
 __name(withTimeout, "withTimeout");
-function pushRuntimeIssues(issues, bridgeSnapshot, acpSnapshot, rateLimitHits, input) {
+function pushRuntimeIssues(issues, bridgeSnapshot, acpSnapshot, rateLimitHits, input, channelWorker) {
   if (bridgeSnapshot.limits.maxSessions !== null && bridgeSnapshot.limits.maxSessions > 0 && bridgeSnapshot.sessionCount / bridgeSnapshot.limits.maxSessions >= CAPACITY_WARNING_RATIO) {
     issues.push({
       code: "session_capacity_high",
@@ -17311,6 +17438,42 @@ function pushRuntimeIssues(issues, bridgeSnapshot, acpSnapshot, rateLimitHits, i
       message: `${sumRateHits(rateLimitHits)} request(s) have been rejected by rate limiting since start.`
     });
   }
+  if (channelWorker.enabled && (channelWorker.state === "exited" || channelWorker.state === "failed")) {
+    const detailParts = [
+      channelWorker.pid !== void 0 ? `pid=${channelWorker.pid}` : void 0,
+      channelWorker.exitCode !== void 0 ? `code=${channelWorker.exitCode ?? "null"}` : void 0,
+      channelWorker.signal ? `signal=${channelWorker.signal}` : void 0,
+      channelWorker.restartCount !== void 0 ? `restarts=${channelWorker.restartCount}` : void 0,
+      channelWorker.lastExitAt ? `lastExitAt=${channelWorker.lastExitAt}` : void 0,
+      channelWorker.lastRestartAt ? `lastRestartAt=${channelWorker.lastRestartAt}` : void 0,
+      channelWorker.nextRestartAt ? `nextRestartAt=${channelWorker.nextRestartAt}` : void 0,
+      channelWorker.lastHeartbeatAt ? `lastHeartbeatAt=${channelWorker.lastHeartbeatAt}` : void 0,
+      channelWorker.staleHeartbeatAt ? `staleHeartbeatAt=${channelWorker.staleHeartbeatAt}` : void 0
+    ].filter(Boolean);
+    const details = detailParts.length > 0 ? ` (${detailParts.join(", ")})` : "";
+    const error = channelWorker.error ? `: ${channelWorker.error}` : "";
+    const isPermanentFailure = channelWorker.state === "failed" && !channelWorker.nextRestartAt;
+    issues.push({
+      code: "channel_worker_exited",
+      severity: isPermanentFailure ? "error" : "warning",
+      message: `Channel worker is ${channelWorker.state}${details}${error}.`,
+      section: "runtime.channelWorker"
+    });
+  }
+  if (channelWorker.enabled && channelWorker.state === "running" && channelWorker.requestedChannels !== void 0) {
+    const connected = new Set(channelWorker.channels);
+    const failed = channelWorker.requestedChannels.filter(
+      (channel) => !connected.has(channel)
+    );
+    if (failed.length > 0) {
+      issues.push({
+        code: "channel_worker_partial_connect",
+        severity: "warning",
+        message: `Channel worker connected ${channelWorker.channels.length}/${channelWorker.requestedChannels.length} channel(s). Failed: ${failed.join(", ")}.`,
+        section: "runtime.channelWorker"
+      });
+    }
+  }
 }
 __name(pushRuntimeIssues, "pushRuntimeIssues");
 function pushFullIssues(issues, full) {
@@ -17520,7 +17683,6 @@ export {
   getDeviceFlowRegistry,
   DeviceFlowRegistry,
   createBridgeFileSystemAdapter,
-  isLoopbackBind,
   resolveWebShellDir,
   denyBrowserOriginCors,
   parseAllowOriginPatterns,
@@ -17528,6 +17690,8 @@ export {
   hostAllowlist,
   bearerAuth,
   createMutationGate,
+  ClientMcpSenderRegistry,
+  createClientMcpServerProvider,
   SERVE_CAPABILITY_REGISTRY,
   getAdvertisedServeFeatures,
   getServeProtocolVersions,