@qwen-code/qwen-code 0.19.3-nightly.20260701.a974594d7 → 0.19.4

package/chunks/{chunk-MTJVHQDP.js → chunk-B7KGXIPZ.js}

@@ -1,5 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  isLoopbackBind
+} from "./chunk-RNBYOUGV.js";
 import {
   require_lib
 } from "./chunk-3HX5LZ6R.js";
@@ -11332,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;
@@ -11348,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(", ")}`);
         }
@@ -11527,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;
       };
@@ -11540,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");
@@ -11610,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");
   }
 });
 
@@ -16100,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";
@@ -16454,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 /
@@ -16471,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`
@@ -16641,14 +16644,15 @@ var SERVE_CAPABILITY_REGISTRY = {
   // 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 — only when the operator opts in
-  // (the public contract is still settling per #5626), so clients pre-flight
-  // this tag before attempting to register a client-hosted server.
+  // { 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 only when the operator opts in (contract still settling).
+  // 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
@@ -17198,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);
@@ -17251,6 +17267,7 @@ async function buildDaemonStatusResponse(detail, input) {
         policy: bridgeSnapshot.permissionPolicy
       },
       channel: { live: bridgeSnapshot.channelLive },
+      channelWorker,
       transport: {
         restSseActive: input.getRestSseActive(),
         acp: {
@@ -17385,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",
@@ -17421,6 +17438,35 @@ 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
+    ].filter(Boolean);
+    const details = detailParts.length > 0 ? ` (${detailParts.join(", ")})` : "";
+    const error = channelWorker.error ? `: ${channelWorker.error}` : "";
+    issues.push({
+      code: "channel_worker_exited",
+      severity: "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) {
@@ -17630,7 +17676,6 @@ export {
   getDeviceFlowRegistry,
   DeviceFlowRegistry,
   createBridgeFileSystemAdapter,
-  isLoopbackBind,
   resolveWebShellDir,
   denyBrowserOriginCors,
   parseAllowOriginPatterns,