@qwen-code/qwen-code 0.15.12-preview.2 → 0.16.0-preview.0

package/bundled/stuck/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: stuck
+description: Diagnose frozen, stuck, or slow Qwen Code sessions on this machine. Scans for problematic processes, high CPU/memory usage, hung subprocesses, and debug logs. Use /stuck or /stuck <PID> to focus on a specific process.
+argument-hint: '[PID or symptom]'
+allowedTools:
+  - run_shell_command
+  - read_file
+---
+
+# /stuck — diagnose frozen/slow Qwen Code sessions
+
+The user thinks another Qwen Code session on this machine is frozen, stuck, or very slow. Investigate and present a diagnostic report.
+
+## What to look for
+
+Scan for other Qwen Code processes (excluding the current one — exclude the PID you see running this prompt). Since Qwen Code is a Node.js CLI (`#!/usr/bin/env node`), the process name (`comm` column) is always `node` (or `bun` if run with Bun). Identify Qwen Code sessions by looking at the `command` column for a script path inside a directory whose name starts with `qwen-code` (matches `qwen-code/`, `qwen-code-dev/`, worktree clones, etc.) — anchored to the start of the path or after `/` so unrelated names like `analyze-qwen-code/` don't false-match — or a bin invocation ending in `/qwen` (the global symlink). Avoid loose `qwen-code` substring matching: it false-positives on plugin brokers that merely pass a qwen-code path as `--cwd`.
+
+Signs of a stuck session:
+
+- **High CPU (>=90%) sustained** — likely an infinite loop. Sample twice, 1-2s apart, to confirm it's not a transient spike.
+- **Process state `D` / `U` (uninterruptible sleep)** — often an I/O hang. Linux uses `D`, macOS/BSD uses `U`. The `state` column in `ps` output; first character matters (ignore modifiers like `+`, `s`, `<`).
+- **Process state `T` (stopped)** — user probably hit Ctrl+Z by accident.
+- **Process state `Z` (zombie)** — parent isn't reaping.
+- **Very high RSS (>=4GB)** — possible memory leak making the session sluggish.
+- **State `S` with low CPU** — the most common hang signature: a hung HTTPS request to the model API. Not a process-level red flag on its own, but combined with the user reporting "stuck", treat it as a strong signal to run the network check in step 3.
+- **Stuck child process** — a hung `git`, `node`, or shell subprocess can freeze the parent. Check `pgrep -P <pid>` (then `ps -p` for state — see step 3) for each session.
+
+## Argument validation
+
+If the user gave an argument, treat it as a PID **only if it consists entirely of digits 0-9**. Anything else — letters, whitespace, punctuation — fails the check, in which case treat it as a free-text symptom description (guidance for the report only, never substituted into shell commands). The strict digit-only whitelist is safer than enumerating shell metacharacters.
+
+## Investigation steps
+
+**Preamble — resolve the runtime base directory.** Required for both paths below (sidecar enumeration in step 1, debug log lookup in step 3, and the PID fast path). The base directory is taken from (in priority order): `QWEN_RUNTIME_DIR` env var, the `advanced.runtimeOutputDir` setting, `QWEN_HOME` env var, and finally `~/.qwen`.
+
+```
+RUNTIME_DIR="${QWEN_RUNTIME_DIR:-}"
+[ -z "$RUNTIME_DIR" ] && command -v jq >/dev/null && RUNTIME_DIR=$(jq -r '.advanced.runtimeOutputDir // empty' "${QWEN_HOME:-$HOME/.qwen}/settings.json" 2>/dev/null)
+# `advanced.runtimeOutputDir` may be `~/...` or relative; mirror Storage.resolvePath() before using in globs
+[ -n "$RUNTIME_DIR" ] && RUNTIME_DIR="${RUNTIME_DIR/#\~/$HOME}"
+[ -n "$RUNTIME_DIR" ] && case "$RUNTIME_DIR" in /*) ;; *) RUNTIME_DIR="$(cd "$RUNTIME_DIR" 2>/dev/null && pwd)" || RUNTIME_DIR="" ;; esac
+RUNTIME_DIR="${RUNTIME_DIR:-${QWEN_HOME:-$HOME/.qwen}}"
+```
+
+(If `jq` isn't installed, the settings layer is silently skipped — the env-var / default fallback covers the common case.)
+
+**Fast path for targeted diagnosis** — if a digit-only PID argument was given, skip step 1 enumeration. Validate that the PID is a live current-user Qwen Code process before dumping any details:
+
+```
+kill -0 <pid> 2>/dev/null || { echo "PID <pid> is dead, or owned by another user"; exit 0; }
+ps -p <pid> -o command= -ww 2>/dev/null | grep -qE '((^|/)qwen-code[^ /]*/[^ ]*\.(js|ts|mjs|cjs)( |$)|/qwen( |$))' || { echo "PID <pid> is yours but is not a Qwen Code process — refusing to dump details"; exit 0; }
+```
+
+If either guard prints, stop the diagnostic and surface the message verbatim. Otherwise, gather stats and the sidecar mapping, then jump to step 3:
+
+```
+ps -p <pid> -o pid=,pcpu=,rss=,etime=,state=,comm=,command= -ww
+grep -El '"pid"[[:space:]]*:[[:space:]]*<pid>\b' "$RUNTIME_DIR"/projects/*/chats/*.runtime.json 2>/dev/null
+```
+
+Note: as in step 2, the `command=` column may include credentials passed as CLI args (e.g., `--openai-api-key=sk-…`). Redact such values to `***` before quoting them in the report.
+
+`-E` is required so `\b` is interpreted as word boundary (BSD `grep` without `-E` treats `\b` as a backspace character, silently returning nothing on macOS). The `-l` flag returns the matching sidecar file path; the basename (stripped of `.runtime.json`) is the session ID for step 3's debug log read. If multiple sidecars match (rare — happens only after PID reuse leaves a stale file), prefer the most recently modified one: `ls -t <matches> | head -n 1`.
+
+Otherwise (no arg, or symptom-only arg), run the general path below:
+
+1. **Enumerate live sessions via the runtime sidecar** (preferred, reliable):
+
+   Qwen Code writes a `runtime.json` sidecar for each interactive session at `"$RUNTIME_DIR"/projects/<sanitized-cwd>/chats/<sessionId>.runtime.json`. Each file contains `{schema_version, pid, session_id, work_dir, hostname, started_at, qwen_version}` — the authoritative source of `(pid, session_id, work_dir)` mappings.
+
+   Filter to live `(pid, sidecar-path)` pairs in one shot. Use Node (guaranteed available — qwen-code requires it) instead of `jq` (often missing on default macOS / minimal Linux) so this path doesn't silently degrade:
+
+   ```
+   node -e 'const fs=require("fs"); for (const f of process.argv.slice(1)) { try { const p=JSON.parse(fs.readFileSync(f,"utf8")).pid; if (p) { try { process.kill(p,0); console.log(p+" "+f); } catch {} } } catch {} }' "$RUNTIME_DIR"/projects/*/chats/*.runtime.json 2>/dev/null
+   ```
+
+   PID reuse is rare but possible — when you cross-reference with `ps` in step 2, skip pairs whose live PID's command line no longer looks like a Qwen Code process.
+
+   **If the command emits nothing** (no sidecars, or no live PIDs), fall through to step 2 — `ps` is the working fallback.
+
+2. **List Qwen Code processes via `ps`** (macOS/Linux) — used to enrich each live session with CPU/RSS/state/uptime, and to catch sessions that may have started before the sidecar feature existed:
+
+   ```
+   ps -xo pid=,pcpu=,rss=,etime=,state=,comm=,command= -u "$(id -u)" -ww | grep -E '((^|/)qwen-code[^ /]*/[^ ]*\.(js|ts|mjs|cjs)( |$)|/qwen( |$))' | grep -v grep
+   ```
+
+   `-u "$(id -u)"` restricts the scan to the current user — on shared hosts this avoids exposing other users' Qwen process paths/arguments into the chat. `-ww` disables column truncation so long "qwen" paths aren't cut off. The `comm` column will be `node` or `bun`, not `qwen`; filter to rows where the `command` column contains a qwen path (e.g., `qwen-code/dist/cli.js`, or a bin symlink ending in `/qwen`). Cross-reference with the PIDs from step 1.
+
+   Note: `ps` reports `rss` in **kilobytes** on both macOS and Linux. To report in MB, divide by 1024; to report in GB, divide by 1048576. The 4GB threshold is `4194304` KB — compare the raw `rss` value against that, or compare the GB value against 4. Do not divide once and then compare against 4; that would flag every process >4MB as "very high RSS".
+
+   Note: full command lines may contain credentials passed as CLI args (e.g., `--openai-api-key=sk-…`). Redact such values to `***` before quoting them in the report.
+
+3. **For anything suspicious**, gather more context. If the process state alone explains the problem (`T` = accidentally stopped, `Z` = parent not reaping), skip directly to the report — child / log / stack inspection adds nothing. Otherwise:
+   - Child processes (with state, so a hung `git` / `node` shows up): `CHILDREN=$(pgrep -P <pid> | tr '\n' ',' | sed 's/,$//'); [ -n "$CHILDREN" ] && ps -p "$CHILDREN" -o pid=,ppid=,pcpu=,state=,etime=,command= -ww`. Single `ps` call (avoids forking one per child) and `-ww` so long child command lines aren't truncated.
+   - If high CPU: sample again after 1-2s to confirm it's sustained
+   - **Network hang** — if CPU is low and state is `S` despite the user reporting "stuck", the most likely cause is a hung HTTPS request to the model API. macOS: `lsof -nP -i -p <pid> 2>/dev/null | head -20` (the `-nP` flags skip reverse-DNS and port lookups, which can themselves hang). If `lsof` itself feels slow, prefix with `timeout 10` (or `gtimeout 10` on macOS with Homebrew coreutils). Linux: `ss -tnp 2>/dev/null | grep "pid=<pid>,"`. Note that `ss -tnp`'s `-p` requires root or `CAP_NET_ADMIN` — without it, the PID column shows `-` and the grep returns empty. If you see no matches but `ss -t 2>/dev/null` does show ESTABLISHED sockets, fall back to `lsof -nP -i -p <pid>` rather than reporting "no connections". A long-lived `ESTABLISHED` connection to a model host (dashscope, openai, anthropic, etc.) with no recent traffic is the smoking gun.
+   - **Debug log** — start with `"$RUNTIME_DIR"/debug/latest` (symlink to the most recent session); if it matches the suspicious PID's session, that's usually the right one. Otherwise infer the session ID from the sidecar and read `"$RUNTIME_DIR"/debug/<session-id>.txt`. Bound the read with `tail -n 200 <path>` — debug logs can be GB-sized. The last few hundred lines typically show what the session was doing before hanging. Debug logs may contain prompts, file contents, or tokens from other sessions — paste only lines relevant to the hang, and never quote secrets/API keys you happen to see.
+
+4. **Consider a stack dump** for a truly frozen process (advanced, optional):
+   - macOS: `sample <pid> 3` gives a 3-second native stack sample. If `sample` itself seems to hang (the target's Mach task port may be wedged on a kernel-level freeze), wrap it: `timeout 15 sample <pid> 3` (or `gtimeout 15 ...` on Homebrew coreutils). Stack frames may include function arguments containing API keys or tokens held in memory — redact such values to `***` before including the dump in the report.
+   - Linux: `cat /proc/<pid>/stack` for kernel stack (read-only, no `ptrace` permissions needed). Avoid `strace -p` for this purpose: it requires `CAP_SYS_PTRACE` (often denied under `kernel.yama.ptrace_scope=1`), and `strace -c` blocks until the target exits — it would hang on the very kind of stuck process you are diagnosing.
+   - This is big — only grab it if the process is clearly hung and you want to know _why_
+
+## Report
+
+Present a structured diagnostic report directly to the user with these sections:
+
+**For each stuck/slow session found:**
+
+- PID, CPU%, RSS (in MB), process state, uptime, full command line
+- Child processes and their states
+- Your diagnosis of what's likely wrong
+- Relevant debug log tail if you captured it
+- Stack dump output if you captured it
+- Suggested next step for the user to decide (e.g., "user may consider `kill <pid>` if the session is unresponsive", "likely waiting on I/O — check disk", "accidentally stopped — user can resume with `kill -CONT <pid>`"). Do not execute these actions yourself — present them as options for the user.
+
+**If every session looks healthy**, tell the user directly — no diagnostic dump needed. Mention how many sessions you checked and that none showed signs of being stuck.
+
+**If no sessions are found at all** (zero sidecars and zero matching `ps` rows), say so explicitly: which `RUNTIME_DIR` you searched and that `ps` returned no qwen-related processes for the current user. Suggest the session may have already exited.
+
+## Notes
+
+- Don't kill or signal any processes — this is diagnostic only.
+- If the user gave an argument (e.g., a specific PID or symptom), focus there first.

package/chunks/{agent-UQY6A6OS.js → agent-ZNQPH67I.js}

@@ -7,32 +7,32 @@ import {
   hasRebuiltToolRegistry,
   rebuildToolRegistryOnOverride,
   resolveSubagentApprovalMode
-} from "./chunk-2WFU3IUH.js";
+} from "./chunk-MNPZ2WO6.js";
 import "./chunk-5P5XGNYH.js";
 import "./chunk-K5PGHDBN.js";
 import "./chunk-O4PICXES.js";
 import "./chunk-TW522KN6.js";
 import "./chunk-MLZQVCF3.js";
-import "./chunk-JMZQICAL.js";
-import "./chunk-SOIEFHIK.js";
-import "./chunk-B7ZL7HUA.js";
+import "./chunk-PPHYLJSS.js";
+import "./chunk-G7YTSRES.js";
+import "./chunk-XVHR7ATJ.js";
 import "./chunk-77WXWU44.js";
-import "./chunk-OCC4MZRS.js";
-import "./chunk-CAWKL3UC.js";
-import "./chunk-PCL3EJGY.js";
+import "./chunk-F23NCRJ2.js";
+import "./chunk-VTPOO6GV.js";
+import "./chunk-C3LHPHN2.js";
 import "./chunk-SYCJMSIJ.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
-import "./chunk-CM2IESUE.js";
-import "./chunk-UXW7MYAW.js";
-import "./chunk-G27O2LD2.js";
+import "./chunk-PR4T27R7.js";
+import "./chunk-CW44BRRA.js";
+import "./chunk-D5NTAHYL.js";
 import "./chunk-T4VD6OJ4.js";
 import "./chunk-RDYWTWEM.js";
-import "./chunk-TPGOGCWM.js";
-import "./chunk-FYMSCRHM.js";
-import "./chunk-SQNQIOD5.js";
-import "./chunk-FKVKVE6N.js";
-import "./chunk-GJXIKCKL.js";
+import "./chunk-JYQUJ5DS.js";
+import "./chunk-FZIUV27X.js";
+import "./chunk-2B7UBDY5.js";
+import "./chunk-KXZ4TJB4.js";
+import "./chunk-XP27SJMH.js";
 import "./chunk-E7E2MFYM.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";

package/chunks/{anthropicContentGenerator-4QE6LTVV.js → anthropicContentGenerator-ICBDZ6R2.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-KQIKOTQJ.js";
 import {
   RequestTokenizer
-} from "./chunk-BXNCPI75.js";
+} from "./chunk-NAID3ZWF.js";
 import {
   Blob,
   File,
@@ -16,7 +16,7 @@ import {
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-CAWKL3UC.js";
+} from "./chunk-VTPOO6GV.js";
 import {
   CAPPED_DEFAULT_MAX_TOKENS,
   DEFAULT_TIMEOUT,
@@ -24,7 +24,7 @@ import {
   hasExplicitOutputLimit,
   safeJsonParse,
   tokenLimit
-} from "./chunk-UXW7MYAW.js";
+} from "./chunk-CW44BRRA.js";
 import {
   FinishReason,
   GenerateContentResponse
@@ -32,7 +32,7 @@ import {
 import "./chunk-RDYWTWEM.js";
 import {
   createDebugLogger
-} from "./chunk-GJXIKCKL.js";
+} from "./chunk-XP27SJMH.js";
 import "./chunk-E7E2MFYM.js";
 import {
   require_ms

package/chunks/{askUserQuestion-QFSCBTUO.js → askUserQuestion-WQILGUSQ.js}

@@ -6,10 +6,10 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-FYMSCRHM.js";
+} from "./chunk-FZIUV27X.js";
 import {
   createDebugLogger
-} from "./chunk-GJXIKCKL.js";
+} from "./chunk-XP27SJMH.js";
 import "./chunk-QWSRH265.js";
 import {
   init_esbuild_shims

package/chunks/{ca-VQSV6JHA.js → ca-S3XJMT6P.js}

@@ -108,6 +108,32 @@ var ca_default = {
   "Generate a one-line session recap now": "Generar ara un resum de la sessi\xF3 en una sola l\xEDnia",
   "Rename the current conversation. --auto lets the fast model pick a title.": "Canviar el nom de la conversa actual. --auto permet que el model r\xE0pid tri\xEF un t\xEDtol.",
   "Rewind conversation to a previous turn": "Rebobinar la conversa fins a un torn anterior",
+  "Rewind Conversation": "Rebobinar la conversa",
+  "No user turns to rewind to.": "No hi ha torns d'usuari per rebobinar.",
+  "Rewind to: ": "Rebobinar a: ",
+  "Restore code and conversation": "Restaura el codi i la conversa",
+  "Restore conversation only": "Restaura nom\xE9s la conversa",
+  "Restore code only": "Restaura nom\xE9s el codi",
+  "Never mind": "Tant \xE9s",
+  "Computing file changes...": "S'estan calculant els canvis als fitxers...",
+  "Restoring...": "S'est\xE0 restaurant...",
+  "Restored {{count}} file(s).": "S'han restaurat {{count}} fitxer(s).",
+  "Failed to restore files: {{error}}": "Error en restaurar els fitxers: {{error}}",
+  "Rewind failed: {{error}}": "Error en retrocedir: {{error}}",
+  "Cannot rewind conversation: no active model client.": "No es pot retrocedir la conversa: cap client de model actiu.",
+  "Code restored, but conversation could not be rewound (no active client).": "Codi restaurat, per\xF2 la conversa no s\u2019ha pogut retrocedir (cap client actiu).",
+  "Conversation rewound. Edit your prompt and press Enter to continue.": "Conversa retrocedida. Edita la teva indicaci\xF3 i prem Retorn per continuar.",
+  "Rewinding does not affect files edited manually or via shell commands.": "El retroc\xE9s no afecta els fitxers editats manualment o mitjan\xE7ant comandes de shell.",
+  "Cannot rewind to a turn that was compressed. Try a more recent turn.": "No es pot retrocedir a un torn que ha estat comprimit. Prova amb un torn m\xE9s recent.",
+  "File restore is unavailable for this turn (no captured file changes, or this turn predates the current session).": "La restauraci\xF3 de fitxers no est\xE0 disponible per a aquest torn (no s\u2019han capturat canvis, o aquest torn \xE9s anterior a la sessi\xF3 actual).",
+  "(+{{insertions}} -{{deletions}} in {{count}} file)": "(+{{insertions}} -{{deletions}} en {{count}} fitxer)",
+  "(+{{insertions}} -{{deletions}} in {{count}} files)": "(+{{insertions}} -{{deletions}} en {{count}} fitxers)",
+  "Failed to restore {{count}} file(s): {{files}}": "Error en restaurar {{count}} fitxer(s): {{files}}",
+  "Cannot restore files: this turn was created before file checkpointing was enabled.": "No es poden restaurar els fitxers: aquest torn es va crear abans que el punt de control de fitxers estigu\xE9s habilitat.",
+  "No files needed to be restored.": "Cap fitxer necessitava restauraci\xF3.",
+  "\u2191\u2193 to navigate \xB7 Enter to select \xB7 Esc to go back": "\u2191\u2193 per navegar \xB7 Enter per seleccionar \xB7 Esc per tornar",
+  "\u2191\u2193 to navigate \xB7 Enter to select \xB7 Esc to cancel": "\u2191\u2193 per navegar \xB7 Enter per seleccionar \xB7 Esc per cancel\xB7lar",
+  "Enter/Y to confirm \xB7 Esc/N to go back": "Enter/Y per confirmar \xB7 Esc/N per tornar",
   "change the theme": "canviar el tema",
   "Select Theme": "Seleccionar tema",
   Preview: "Previsualitzaci\xF3",

package/chunks/{chunk-SQNQIOD5.js → chunk-2B7UBDY5.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   formatFetchErrorForUser
-} from "./chunk-FKVKVE6N.js";
+} from "./chunk-KXZ4TJB4.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-GJXIKCKL.js";
+} from "./chunk-XP27SJMH.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/chunk-3MBY4GKN.js

@@ -0,0 +1,350 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/eventBus.ts
+init_esbuild_shims();
+var EVENT_SCHEMA_VERSION = 1;
+var DEFAULT_MAX_QUEUED = 256;
+var DEFAULT_RING_SIZE = 8e3;
+var WARN_THRESHOLD_RATIO = 0.75;
+var WARN_RESET_RATIO = 0.375;
+var DEFAULT_MAX_SUBSCRIBERS = 64;
+var SubscriberLimitExceededError = class extends Error {
+  static {
+    __name(this, "SubscriberLimitExceededError");
+  }
+  limit;
+  constructor(limit) {
+    super(`EventBus subscriber limit reached (${limit})`);
+    this.name = "SubscriberLimitExceededError";
+    this.limit = limit;
+  }
+};
+var EventBus = class {
+  constructor(ringSize = DEFAULT_RING_SIZE, maxSubscribers = DEFAULT_MAX_SUBSCRIBERS) {
+    this.ringSize = ringSize;
+    this.maxSubscribers = maxSubscribers;
+  }
+  static {
+    __name(this, "EventBus");
+  }
+  nextId = 1;
+  ring = [];
+  subs = /* @__PURE__ */ new Set();
+  closed = false;
+  /** Most recent id ever assigned by `publish`. 0 if no events published. */
+  get lastEventId() {
+    return this.nextId - 1;
+  }
+  /** Snapshot of the live subscriber count. */
+  get subscriberCount() {
+    return this.subs.size;
+  }
+  /**
+   * Publish an event to the bus. Returns the constructed `BridgeEvent`
+   * (with `id` + `v` assigned) on success, or `undefined` when the
+   * bus is closed.
+   *
+   * **Never throws** (BX9_p contract). Closing the bus mid-publish
+   * is the only abnormal path and is handled as a return-undefined
+   * no-op; subscriber-enqueue failures are caught internally and
+   * translated to per-subscriber eviction. Call sites can rely on
+   * this — the historical `try { publish(...) } catch {}` blocks in
+   * `httpAcpBridge.ts` are defense-in-depth, not load-bearing, and
+   * may be removed in a future cleanup pass without changing
+   * behavior. Don't add new try/catch wrappers around `publish()`.
+   */
+  publish(input) {
+    if (this.closed) return void 0;
+    const event = {
+      id: this.nextId++,
+      v: EVENT_SCHEMA_VERSION,
+      ...input
+    };
+    this.ring.push(event);
+    if (this.ring.length > this.ringSize) this.ring.shift();
+    for (const sub of Array.from(this.subs)) {
+      if (sub.evicted) continue;
+      if (!sub.queue.push(event)) {
+        sub.evicted = true;
+        const evictionFrame = {
+          v: EVENT_SCHEMA_VERSION,
+          type: "client_evicted",
+          data: { reason: "queue_overflow", droppedAfter: event.id }
+        };
+        sub.queue.forcePush(evictionFrame);
+        sub.queue.close();
+        sub.dispose();
+        continue;
+      }
+      const liveSize = sub.queue.size;
+      if (!sub.warned && liveSize >= sub.warnThreshold) {
+        sub.warned = true;
+        const warningFrame = {
+          v: EVENT_SCHEMA_VERSION,
+          type: "slow_client_warning",
+          data: {
+            queueSize: liveSize,
+            maxQueued: sub.maxQueued,
+            // `event.id` is always defined here — the just-published
+            // `event` is constructed at the top of `publish()` with
+            // `id: this.nextId++`. No `??` fallback needed.
+            lastEventId: event.id
+          }
+        };
+        sub.queue.forcePush(warningFrame);
+      } else if (sub.warned && liveSize <= sub.warnResetThreshold) {
+        sub.warned = false;
+      }
+    }
+    return event;
+  }
+  /**
+   * Note: registration is synchronous — by the time `subscribe()` returns,
+   * the subscriber is already attached and will receive any subsequent
+   * `publish()` even if the consumer hasn't started iterating yet. (A
+   * generator-style implementation would defer registration to the first
+   * `next()` call, which races with publishes that happen before the
+   * consumer's first await.)
+   *
+   * The returned iterator is NOT safe to drive from concurrent callers —
+   * two simultaneous `.next()` calls would race for the same event from
+   * the underlying queue. Daemon usage is sequential (`for await ... of`
+   * inside the SSE route), so this is safe in production. Callers that
+   * fan an iterator out to multiple consumers must serialize themselves.
+   */
+  subscribe(opts = {}) {
+    if (this.closed) {
+      return emptyAsyncIterable();
+    }
+    if (this.subs.size >= this.maxSubscribers) {
+      throw new SubscriberLimitExceededError(this.maxSubscribers);
+    }
+    const maxQueued = opts.maxQueued ?? DEFAULT_MAX_QUEUED;
+    const queue = new BoundedAsyncQueue(maxQueued);
+    const sub = {
+      queue,
+      evicted: false,
+      maxQueued,
+      warnThreshold: WARN_THRESHOLD_RATIO * maxQueued,
+      warnResetThreshold: WARN_RESET_RATIO * maxQueued,
+      warned: false,
+      dispose: /* @__PURE__ */ __name(() => {
+      }, "dispose")
+    };
+    this.subs.add(sub);
+    if (opts.lastEventId !== void 0) {
+      for (const e of this.ring) {
+        if (e.id !== void 0 && e.id > opts.lastEventId) {
+          queue.forcePush(e);
+        }
+      }
+    }
+    let disposed = false;
+    const dispose = /* @__PURE__ */ __name(() => {
+      if (disposed) return;
+      disposed = true;
+      this.subs.delete(sub);
+      opts.signal?.removeEventListener("abort", onAbort);
+    }, "dispose");
+    sub.dispose = dispose;
+    const onAbort = /* @__PURE__ */ __name(() => {
+      queue.close({ drain: false });
+      dispose();
+    }, "onAbort");
+    if (opts.signal) {
+      if (opts.signal.aborted) {
+        onAbort();
+      } else {
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+    return {
+      [Symbol.asyncIterator]: () => ({
+        async next() {
+          const r = await queue.next();
+          if (r.done) dispose();
+          return r;
+        },
+        async return() {
+          queue.close();
+          dispose();
+          return { value: void 0, done: true };
+        }
+      })
+    };
+  }
+  /** Close all live subscribers and prevent further `publish`/`subscribe`. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const sub of this.subs) sub.queue.close();
+    this.subs.clear();
+  }
+};
+function emptyAsyncIterable() {
+  return {
+    [Symbol.asyncIterator]: () => ({
+      async next() {
+        return { value: void 0, done: true };
+      }
+    })
+  };
+}
+__name(emptyAsyncIterable, "emptyAsyncIterable");
+var BoundedAsyncQueue = class {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  static {
+    __name(this, "BoundedAsyncQueue");
+  }
+  buf = [];
+  resolvers = [];
+  closed = false;
+  /**
+   * O(1) snapshot of how many LIVE (non-forced) entries are in `buf`.
+   * Maintained directly by `push()`/`next()`: any time a forced entry
+   * is added or removed `liveCount` is untouched; any time a live entry
+   * is added or removed `liveCount` moves with it. Replaces the
+   * position-dependent `forcedInBuf` heuristic — `liveCount` is correct
+   * no matter where in the queue the forced entries are.
+   */
+  liveCount = 0;
+  /**
+   * Number of LIVE (non-force-pushed) items currently waiting in the
+   * buffer. Backpressure decisions in `EventBus.publish()` (the
+   * `slow_client_warning` threshold) read this value.
+   */
+  get size() {
+    return this.liveCount;
+  }
+  /** Returns true if accepted, false if dropped due to overflow. */
+  push(value) {
+    if (this.closed) return false;
+    const r = this.resolvers.shift();
+    if (r) {
+      r({ value, done: false });
+      return true;
+    }
+    if (this.liveCount >= this.maxSize) return false;
+    this.buf.push({ value, forced: false });
+    this.liveCount += 1;
+    return true;
+  }
+  /** Bypasses the size cap. Used for replay frames, eviction terminal,
+   * and slow-client warnings. */
+  forcePush(value) {
+    if (this.closed) return;
+    const r = this.resolvers.shift();
+    if (r) {
+      r({ value, done: false });
+      return;
+    }
+    this.buf.push({ value, forced: true });
+  }
+  /**
+   * Mark the queue closed. By default `next()` continues to drain
+   * any items already in `buf` before returning `done: true` —
+   * that's what the eviction path relies on (the synthetic
+   * `client_evicted` frame is force-pushed THEN close is called,
+   * and we want the consumer to see the terminal frame before the
+   * iterator unwinds).
+   *
+   * Pass `{ drain: false }` to drop buffered items immediately
+   * (the AbortSignal-driven unsubscribe path uses this — the
+   * subscribe docstring says abort should close the iterator
+   * promptly, but draining hundreds of queued events first
+   * contradicts that and adds post-abort work to the SSE route).
+   */
+  close(opts = {}) {
+    if (this.closed) return;
+    this.closed = true;
+    if (opts.drain === false) {
+      this.buf.length = 0;
+      this.liveCount = 0;
+    }
+    while (this.resolvers.length > 0) {
+      this.resolvers.shift()({
+        value: void 0,
+        done: true
+      });
+    }
+  }
+  next() {
+    if (this.buf.length > 0) {
+      const entry = this.buf.shift();
+      if (!entry.forced) this.liveCount -= 1;
+      return Promise.resolve({ value: entry.value, done: false });
+    }
+    if (this.closed) {
+      return Promise.resolve({
+        value: void 0,
+        done: true
+      });
+    }
+    return new Promise((resolve) => this.resolvers.push(resolve));
+  }
+};
+
+// packages/cli/src/serve/status.ts
+init_esbuild_shims();
+var STATUS_SCHEMA_VERSION = 1;
+var SERVE_STATUS_EXT_METHODS = {
+  workspaceMcp: "qwen/status/workspace/mcp",
+  workspaceSkills: "qwen/status/workspace/skills",
+  workspaceProviders: "qwen/status/workspace/providers",
+  sessionContext: "qwen/status/session/context",
+  sessionSupportedCommands: "qwen/status/session/supported_commands"
+};
+function createIdleWorkspaceMcpStatus(workspaceCwd) {
+  return {
+    v: STATUS_SCHEMA_VERSION,
+    workspaceCwd,
+    initialized: false,
+    discoveryState: "not_started",
+    servers: []
+  };
+}
+__name(createIdleWorkspaceMcpStatus, "createIdleWorkspaceMcpStatus");
+function createIdleWorkspaceSkillsStatus(workspaceCwd) {
+  return {
+    v: STATUS_SCHEMA_VERSION,
+    workspaceCwd,
+    initialized: false,
+    skills: []
+  };
+}
+__name(createIdleWorkspaceSkillsStatus, "createIdleWorkspaceSkillsStatus");
+function createIdleWorkspaceProvidersStatus(workspaceCwd) {
+  return {
+    v: STATUS_SCHEMA_VERSION,
+    workspaceCwd,
+    initialized: false,
+    providers: []
+  };
+}
+__name(createIdleWorkspaceProvidersStatus, "createIdleWorkspaceProvidersStatus");
+
+export {
+  EVENT_SCHEMA_VERSION,
+  DEFAULT_RING_SIZE,
+  SubscriberLimitExceededError,
+  EventBus,
+  STATUS_SCHEMA_VERSION,
+  SERVE_STATUS_EXT_METHODS,
+  createIdleWorkspaceMcpStatus,
+  createIdleWorkspaceSkillsStatus,
+  createIdleWorkspaceProvidersStatus
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */