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

package/chunks/{serve-27O2AFE3.js → serve-GAD2PEST.js}

@@ -6,6 +6,17 @@ import {
   require_mime_db,
   require_type
 } from "./chunk-7RYW5LQV.js";
+import {
+  DEFAULT_RING_SIZE,
+  EVENT_SCHEMA_VERSION,
+  EventBus,
+  SERVE_STATUS_EXT_METHODS,
+  STATUS_SCHEMA_VERSION,
+  SubscriberLimitExceededError,
+  createIdleWorkspaceMcpStatus,
+  createIdleWorkspaceProvidersStatus,
+  createIdleWorkspaceSkillsStatus
+} from "./chunk-3MBY4GKN.js";
 import {
   writeStderrLine,
   writeStdoutLine
@@ -13076,6 +13087,20 @@ function bearerAuth(token) {
   };
 }
 __name(bearerAuth, "bearerAuth");
+function createMutationGate(deps) {
+  const passthrough = /* @__PURE__ */ __name((_req, _res, next) => next(), "passthrough");
+  if (deps.requireAuth || deps.tokenConfigured) {
+    return () => passthrough;
+  }
+  const strictDenier = /* @__PURE__ */ __name((_req, res) => {
+    res.status(401).json({
+      error: "This route requires the daemon to be configured with a bearer token. Set QWEN_SERVER_TOKEN or pass --token to enable bearer auth.",
+      code: "token_required"
+    });
+  }, "strictDenier");
+  return (opts = {}) => opts.strict ? strictDenier : passthrough;
+}
+__name(createMutationGate, "createMutationGate");
 
 // packages/cli/src/serve/httpAcpBridge.ts
 init_esbuild_shims();
@@ -13084,276 +13109,45 @@ import { randomUUID } from "node:crypto";
 import { promises as fs, realpathSync } from "node:fs";
 import * as path from "node:path";
 import { Readable, Writable } from "node:stream";
-
-// packages/cli/src/serve/eventBus.ts
-init_esbuild_shims();
-var EVENT_SCHEMA_VERSION = 1;
-var DEFAULT_MAX_QUEUED = 256;
-var DEFAULT_RING_SIZE = 4e3;
-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;
-  }
+var SessionNotFoundError = class extends Error {
   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();
-      }
-    }
-    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 queue = new BoundedAsyncQueue(
-      opts.maxQueued ?? DEFAULT_MAX_QUEUED
-    );
-    const sub = { queue, evicted: 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 };
-        }
-      })
-    };
+    __name(this, "SessionNotFoundError");
   }
-  /** 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();
+  sessionId;
+  constructor(sessionId, extra) {
+    super(`No session with id "${sessionId}"` + (extra ? `. ${extra}` : ""));
+    this.name = "SessionNotFoundError";
+    this.sessionId = sessionId;
   }
 };
-function emptyAsyncIterable() {
-  return {
-    [Symbol.asyncIterator]: () => ({
-      async next() {
-        return { value: void 0, done: true };
-      }
-    })
-  };
-}
-__name(emptyAsyncIterable, "emptyAsyncIterable");
-var BoundedAsyncQueue = class {
-  constructor(maxSize) {
-    this.maxSize = maxSize;
-  }
+var RestoreInProgressError = class extends Error {
   static {
-    __name(this, "BoundedAsyncQueue");
-  }
-  buf = [];
-  resolvers = [];
-  closed = false;
-  /**
-   * Number of force-pushed items still in `buf`. The cap check in
-   * `push()` only applies to LIVE items; this counter tells us how
-   * many slots in `buf` are replay-injected and shouldn't count.
-   *
-   * Position invariant: under the bus's two callers,
-   *   1. subscribe-time replay (`Last-Event-ID` resume) — forcePush
-   *      fires BEFORE any live `push()`, so replay items are at the
-   *      front of `buf`;
-   *   2. eviction terminal frame — forcePush fires AFTER `push()`
-   *      rejection, then `close()` is called immediately, so the
-   *      eviction frame is at the BACK of `buf`.
-   *
-   * `next()` decrements `forcedInBuf` whenever the counter is > 0 on
-   * shift, which is correct for case (1). For case (2) it slightly
-   * misaccounts (decrements on the first live shift), but that's
-   * harmless: the queue is closed so no `push()` runs the cap check
-   * again. The counter only matters for live cap enforcement.
-   */
-  forcedInBuf = 0;
-  /** 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.buf.length - this.forcedInBuf >= this.maxSize) return false;
-    this.buf.push(value);
-    return true;
+    __name(this, "RestoreInProgressError");
   }
-  /** Bypasses the size cap. Used for replay frames and terminal eviction. */
-  forcePush(value) {
-    if (this.closed) return;
-    const r = this.resolvers.shift();
-    if (r) {
-      r({ value, done: false });
-      return;
-    }
-    this.buf.push(value);
-    this.forcedInBuf += 1;
-  }
-  /**
-   * 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.forcedInBuf = 0;
-    }
-    while (this.resolvers.length > 0) {
-      this.resolvers.shift()({
-        value: void 0,
-        done: true
-      });
-    }
-  }
-  next() {
-    if (this.buf.length > 0) {
-      const value = this.buf.shift();
-      if (this.forcedInBuf > 0) this.forcedInBuf -= 1;
-      return Promise.resolve({ value, done: false });
-    }
-    if (this.closed) {
-      return Promise.resolve({
-        value: void 0,
-        done: true
-      });
-    }
-    return new Promise((resolve2) => this.resolvers.push(resolve2));
+  sessionId;
+  activeAction;
+  requestedAction;
+  constructor(sessionId, activeAction, requestedAction) {
+    super(
+      `Session "${sessionId}" is already being restored via session/${activeAction}; retry session/${requestedAction} after it completes`
+    );
+    this.name = "RestoreInProgressError";
+    this.sessionId = sessionId;
+    this.activeAction = activeAction;
+    this.requestedAction = requestedAction;
   }
 };
-
-// packages/cli/src/serve/httpAcpBridge.ts
-var SessionNotFoundError = class extends Error {
+var InvalidSessionScopeError = class extends Error {
   static {
-    __name(this, "SessionNotFoundError");
+    __name(this, "InvalidSessionScopeError");
   }
-  sessionId;
-  constructor(sessionId, extra) {
-    super(`No session with id "${sessionId}"` + (extra ? `. ${extra}` : ""));
-    this.name = "SessionNotFoundError";
-    this.sessionId = sessionId;
+  sessionScope;
+  constructor(sessionScope) {
+    super(
+      `Invalid sessionScope: ${JSON.stringify(sessionScope)}. Expected 'single' or 'thread'.`
+    );
+    this.name = "InvalidSessionScopeError";
+    this.sessionScope = sessionScope;
   }
 };
 var SessionLimitExceededError = class extends Error {
@@ -13383,7 +13177,32 @@ var WorkspaceMismatchError = class extends Error {
     this.requested = safeRequested;
   }
 };
+var InvalidClientIdError = class extends Error {
+  static {
+    __name(this, "InvalidClientIdError");
+  }
+  sessionId;
+  clientId;
+  constructor(sessionId, clientId) {
+    super(`Client id "${clientId}" is not registered for session ${sessionId}`);
+    this.name = "InvalidClientIdError";
+    this.sessionId = sessionId;
+    this.clientId = clientId;
+  }
+};
 var MAX_WORKSPACE_PATH_LENGTH = 4096;
+var MAX_RESOLVED_PERMISSION_RECORDS = 512;
+function isServeDebugLoggingEnabled() {
+  const value = process.env["QWEN_SERVE_DEBUG"];
+  if (!value) return false;
+  return !["0", "false", "off", "no"].includes(value.trim().toLowerCase());
+}
+__name(isServeDebugLoggingEnabled, "isServeDebugLoggingEnabled");
+function writeServeDebugLine(message) {
+  if (!isServeDebugLoggingEnabled()) return;
+  writeStderrLine(`qwen serve debug: ${message}`);
+}
+__name(writeServeDebugLine, "writeServeDebugLine");
 var InvalidPermissionOptionError = class extends Error {
   static {
     __name(this, "InvalidPermissionOptionError");
@@ -13399,9 +13218,32 @@ var InvalidPermissionOptionError = class extends Error {
     this.optionId = optionId;
   }
 };
+var MAX_DISPLAY_NAME_LENGTH = 256;
+function hasControlCharacter(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code <= 31 || code === 127) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(hasControlCharacter, "hasControlCharacter");
+var InvalidSessionMetadataError = class extends Error {
+  static {
+    __name(this, "InvalidSessionMetadataError");
+  }
+  field;
+  constructor(field, reason) {
+    super(`Invalid session metadata: ${field} ${reason}`);
+    this.name = "InvalidSessionMetadataError";
+    this.field = field;
+  }
+};
 var BridgeClient = class {
-  constructor(resolveEntry, registerPending, rollbackPending, permissionTimeoutMs, maxPendingPerSession) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, registerPending, rollbackPending, permissionTimeoutMs, maxPendingPerSession) {
     this.resolveEntry = resolveEntry;
+    this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.registerPending = registerPending;
     this.rollbackPending = rollbackPending;
     this.permissionTimeoutMs = permissionTimeoutMs;
@@ -13459,7 +13301,8 @@ var BridgeClient = class {
           sessionId: entry.sessionId,
           toolCall: params.toolCall,
           options: params.options
-        }
+        },
+        ...entry.activePromptOriginatorClientId ? { originatorClientId: entry.activePromptOriginatorClientId } : {}
       });
       if (!published) {
         this.rollbackPending(requestId);
@@ -13481,8 +13324,13 @@ var BridgeClient = class {
   }
   async sessionUpdate(params) {
     const entry = this.resolveEntry(params.sessionId);
-    if (!entry) return;
-    entry.events.publish({ type: "session_update", data: params });
+    const events = entry?.events ?? this.resolvePendingRestoreEvents(params.sessionId);
+    if (!events) return;
+    events.publish({
+      type: "session_update",
+      data: params,
+      ...entry?.activePromptOriginatorClientId ? { originatorClientId: entry.activePromptOriginatorClientId } : {}
+    });
   }
   async writeTextFile(params) {
     let realTarget = params.path;
@@ -13558,10 +13406,11 @@ var BridgeClient = class {
 };
 var DEFAULT_INIT_TIMEOUT_MS = 1e4;
 var DEFAULT_MAX_SESSIONS = 20;
+var MAX_EVENT_RING_SIZE = 1e6;
 var DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX_PENDING_PER_SESSION = 64;
 function createHttpAcpBridge(opts) {
-  const sessionScope = opts.sessionScope ?? "single";
+  const defaultSessionScope = opts.sessionScope ?? "single";
   let maxSessions;
   if (opts.maxSessions === void 0) {
     maxSessions = DEFAULT_MAX_SESSIONS;
@@ -13578,9 +13427,15 @@ function createHttpAcpBridge(opts) {
   } else {
     maxSessions = opts.maxSessions;
   }
-  if (sessionScope !== "single" && sessionScope !== "thread") {
+  if (defaultSessionScope !== "single" && defaultSessionScope !== "thread") {
     throw new TypeError(
-      `Invalid sessionScope: ${JSON.stringify(sessionScope)}. Expected 'single' or 'thread'.`
+      `Invalid sessionScope: ${JSON.stringify(defaultSessionScope)}. Expected 'single' or 'thread'.`
+    );
+  }
+  const eventRingSize = opts.eventRingSize ?? DEFAULT_RING_SIZE;
+  if (!Number.isInteger(eventRingSize) || eventRingSize < 1 || eventRingSize > MAX_EVENT_RING_SIZE) {
+    throw new TypeError(
+      `Invalid eventRingSize: ${opts.eventRingSize}. Must be a positive integer in [1, ${MAX_EVENT_RING_SIZE}].`
     );
   }
   const channelFactory = opts.channelFactory ?? defaultSpawnChannelFactory;
@@ -13606,8 +13461,49 @@ function createHttpAcpBridge(opts) {
   let inFlightChannelSpawn;
   const byId = /* @__PURE__ */ new Map();
   const pendingPermissions = /* @__PURE__ */ new Map();
+  const resolvedPermissions = /* @__PURE__ */ new Map();
+  const resolvedPermissionOrder = [];
   let shuttingDown = false;
   const inFlightSpawns = /* @__PURE__ */ new Map();
+  const inFlightRestores = /* @__PURE__ */ new Map();
+  const pendingRestoreEvents = /* @__PURE__ */ new Map();
+  const createClientId = /* @__PURE__ */ __name(() => `client_${randomUUID()}`, "createClientId");
+  const registerClient = /* @__PURE__ */ __name((entry, requestedClientId) => {
+    if (requestedClientId && entry.clientIds.has(requestedClientId)) {
+      entry.clientIds.set(
+        requestedClientId,
+        (entry.clientIds.get(requestedClientId) ?? 0) + 1
+      );
+      return requestedClientId;
+    }
+    const clientId = createClientId();
+    entry.clientIds.set(clientId, 1);
+    return clientId;
+  }, "registerClient");
+  const unregisterClient = /* @__PURE__ */ __name((entry, clientId) => {
+    if (clientId === void 0) return;
+    const count = entry.clientIds.get(clientId);
+    if (count === void 0) return;
+    if (count <= 1) {
+      entry.clientIds.delete(clientId);
+      entry.clientLastSeenAt.delete(clientId);
+    } else {
+      entry.clientIds.set(clientId, count - 1);
+    }
+  }, "unregisterClient");
+  const resolveTrustedClientId = /* @__PURE__ */ __name((entry, clientId) => {
+    if (clientId === void 0) return void 0;
+    if (!entry.clientIds.has(clientId)) {
+      throw new InvalidClientIdError(entry.sessionId, clientId);
+    }
+    return clientId;
+  }, "resolveTrustedClientId");
+  const resolveAnyTrustedClientId = /* @__PURE__ */ __name((clientId) => {
+    for (const entry of byId.values()) {
+      if (entry.clientIds.has(clientId)) return clientId;
+    }
+    throw new InvalidClientIdError("unknown", clientId);
+  }, "resolveAnyTrustedClientId");
   const registerPending = /* @__PURE__ */ __name((p) => {
     const entry = byId.get(p.sessionId);
     if (!entry) {
@@ -13617,7 +13513,38 @@ function createHttpAcpBridge(opts) {
     pendingPermissions.set(p.requestId, p);
     entry.pendingPermissionIds.add(p.requestId);
   }, "registerPending");
-  const resolvePending = /* @__PURE__ */ __name((requestId, response) => {
+  const rememberResolvedPermission = /* @__PURE__ */ __name((record) => {
+    if (!resolvedPermissions.has(record.requestId)) {
+      resolvedPermissionOrder.push(record.requestId);
+    }
+    resolvedPermissions.set(record.requestId, record);
+    while (resolvedPermissionOrder.length > MAX_RESOLVED_PERMISSION_RECORDS) {
+      const oldest = resolvedPermissionOrder.shift();
+      if (oldest !== void 0) resolvedPermissions.delete(oldest);
+    }
+  }, "rememberResolvedPermission");
+  const publishPermissionAlreadyResolved = /* @__PURE__ */ __name((record) => {
+    const entry = byId.get(record.sessionId);
+    if (!entry) return;
+    try {
+      writeServeDebugLine(
+        `permission ${JSON.stringify(record.requestId)} for session ${JSON.stringify(record.sessionId)} was already resolved; publishing duplicate-vote notification.`
+      );
+      entry.events.publish({
+        type: "permission_already_resolved",
+        data: {
+          requestId: record.requestId,
+          sessionId: record.sessionId,
+          outcome: record.outcome
+        }
+      });
+    } catch {
+      writeServeDebugLine(
+        `skipped duplicate-vote notification for permission ${JSON.stringify(record.requestId)} during shutdown.`
+      );
+    }
+  }, "publishPermissionAlreadyResolved");
+  const resolvePending = /* @__PURE__ */ __name((requestId, response, originatorClientId) => {
     const pending = pendingPermissions.get(requestId);
     if (!pending) return false;
     pendingPermissions.delete(requestId);
@@ -13627,11 +13554,17 @@ function createHttpAcpBridge(opts) {
       try {
         entry.events.publish({
           type: "permission_resolved",
-          data: { requestId, outcome: response.outcome }
+          data: { requestId, outcome: response.outcome },
+          ...originatorClientId ? { originatorClientId } : {}
         });
       } catch {
       }
     }
+    rememberResolvedPermission({
+      requestId,
+      sessionId: pending.sessionId,
+      outcome: response.outcome
+    });
     pending.resolve(response);
     return true;
   }, "resolvePending");
@@ -13656,6 +13589,7 @@ function createHttpAcpBridge(opts) {
           }
           return void 0;
         },
+        (sessionId) => sessionId ? pendingRestoreEvents.get(sessionId) : void 0,
         registerPending,
         (rid) => (
           // Roll back a register-then-publish-failed pending so the agent
@@ -13671,6 +13605,7 @@ function createHttpAcpBridge(opts) {
         connection,
         client,
         sessionIds: /* @__PURE__ */ new Set(),
+        pendingRestoreIds: /* @__PURE__ */ new Set(),
         isDying: false
       };
       aliveChannels.add(info);
@@ -13746,7 +13681,7 @@ function createHttpAcpBridge(opts) {
     }
   }
   __name(ensureChannel, "ensureChannel");
-  async function doSpawn(modelServiceId) {
+  async function doSpawn(modelServiceId, effectiveScope, requestedClientId) {
     const ci = await ensureChannel();
     let newSessionResp;
     try {
@@ -13769,26 +13704,21 @@ function createHttpAcpBridge(opts) {
     if (shuttingDown) {
       throw new Error("HttpAcpBridge is shutting down");
     }
-    const entry = {
-      sessionId: newSessionResp.sessionId,
-      workspaceCwd: boundWorkspace,
-      channel: ci.channel,
-      connection: ci.connection,
-      events: new EventBus(),
-      promptQueue: Promise.resolve(),
-      modelChangeQueue: Promise.resolve(),
-      pendingPermissionIds: /* @__PURE__ */ new Set(),
-      attachCount: 0,
-      spawnOwnerWantedKill: false
-    };
-    ci.sessionIds.add(entry.sessionId);
-    byId.set(entry.sessionId, entry);
-    if (!defaultEntry) defaultEntry = entry;
+    const entry = createSessionEntry(
+      ci,
+      newSessionResp.sessionId,
+      boundWorkspace
+    );
+    const clientId = registerClient(entry, requestedClientId);
+    if (effectiveScope === "single" && !defaultEntry) defaultEntry = entry;
     if (modelServiceId) {
-      await applyModelServiceId(entry, modelServiceId, initTimeoutMs).catch(
-        () => {
-        }
-      );
+      await applyModelServiceId(
+        entry,
+        modelServiceId,
+        initTimeoutMs,
+        clientId
+      ).catch(() => {
+      });
     }
     if (!byId.has(entry.sessionId)) {
       throw new Error(
@@ -13798,11 +13728,13 @@ function createHttpAcpBridge(opts) {
     return {
       sessionId: entry.sessionId,
       workspaceCwd: entry.workspaceCwd,
-      attached: false
+      attached: false,
+      clientId,
+      createdAt: entry.createdAt
     };
   }
   __name(doSpawn, "doSpawn");
-  async function applyModelServiceId(entry, modelId, timeoutMs) {
+  async function applyModelServiceId(entry, modelId, timeoutMs, originatorClientId) {
     const conn = entry.connection;
     const transportClosed = getTransportClosedReject(entry);
     const work = entry.modelChangeQueue.then(async () => {
@@ -13820,7 +13752,8 @@ function createHttpAcpBridge(opts) {
         ]);
         entry.events.publish({
           type: "model_switched",
-          data: { sessionId: entry.sessionId, modelId }
+          data: { sessionId: entry.sessionId, modelId },
+          ...originatorClientId ? { originatorClientId } : {}
         });
       } catch (err) {
         entry.events.publish({
@@ -13829,7 +13762,8 @@ function createHttpAcpBridge(opts) {
             sessionId: entry.sessionId,
             requestedModelId: modelId,
             error: err instanceof Error ? err.message : String(err)
-          }
+          },
+          ...originatorClientId ? { originatorClientId } : {}
         });
         throw err;
       }
@@ -13859,6 +13793,266 @@ function createHttpAcpBridge(opts) {
     }
     return entry.transportClosedReject;
   }, "getTransportClosedReject");
+  const resolveWorkspaceKey = /* @__PURE__ */ __name((workspaceCwd) => {
+    if (!path.isAbsolute(workspaceCwd)) {
+      throw new Error(
+        `workspaceCwd must be an absolute path; got "${workspaceCwd}"`
+      );
+    }
+    const workspaceKey = workspaceCwd === boundWorkspace ? boundWorkspace : canonicalizeWorkspace(workspaceCwd);
+    if (workspaceKey !== boundWorkspace) {
+      throw new WorkspaceMismatchError(boundWorkspace, workspaceKey);
+    }
+    return workspaceKey;
+  }, "resolveWorkspaceKey");
+  const liveChannelInfo = /* @__PURE__ */ __name(() => {
+    if (!channelInfo || channelInfo.isDying) return void 0;
+    return channelInfo;
+  }, "liveChannelInfo");
+  const channelInfoForEntry = /* @__PURE__ */ __name((entry) => {
+    if (channelInfo?.channel === entry.channel) return channelInfo;
+    for (const info of aliveChannels) {
+      if (info.channel === entry.channel) return info;
+    }
+    return void 0;
+  }, "channelInfoForEntry");
+  const getChannelClosedReject = /* @__PURE__ */ __name((info) => {
+    if (!info.statusClosedReject) {
+      info.statusClosedReject = info.channel.exited.then(() => {
+        throw new Error("agent channel closed mid-request (workspace status)");
+      });
+    }
+    return info.statusClosedReject;
+  }, "getChannelClosedReject");
+  const requestWorkspaceStatus = /* @__PURE__ */ __name(async (method, idle) => {
+    const info = liveChannelInfo();
+    if (!info) return idle();
+    const response = await withTimeout(
+      Promise.race([
+        info.connection.extMethod(method, { cwd: boundWorkspace }),
+        getChannelClosedReject(info)
+      ]),
+      initTimeoutMs,
+      method
+    );
+    return response;
+  }, "requestWorkspaceStatus");
+  const requestSessionStatus = /* @__PURE__ */ __name(async (sessionId, method) => {
+    const entry = byId.get(sessionId);
+    if (!entry) throw new SessionNotFoundError(sessionId);
+    const info = channelInfoForEntry(entry);
+    if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
+    const response = await Promise.race([
+      withTimeout(
+        entry.connection.extMethod(method, { sessionId }),
+        initTimeoutMs,
+        method
+      ),
+      getTransportClosedReject(entry)
+    ]);
+    return response;
+  }, "requestSessionStatus");
+  const createSessionEntry = /* @__PURE__ */ __name((ci, sessionId, workspaceCwd, events = new EventBus(eventRingSize)) => {
+    const entry = {
+      sessionId,
+      workspaceCwd,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      channel: ci.channel,
+      connection: ci.connection,
+      events,
+      promptQueue: Promise.resolve(),
+      modelChangeQueue: Promise.resolve(),
+      pendingPermissionIds: /* @__PURE__ */ new Set(),
+      clientIds: /* @__PURE__ */ new Map(),
+      clientLastSeenAt: /* @__PURE__ */ new Map(),
+      attachCount: 0,
+      spawnOwnerWantedKill: false
+    };
+    ci.sessionIds.add(entry.sessionId);
+    byId.set(entry.sessionId, entry);
+    return entry;
+  }, "createSessionEntry");
+  const isAcpSessionResourceNotFound = /* @__PURE__ */ __name((err, sessionId) => {
+    if (!err || typeof err !== "object") return false;
+    const maybe = err;
+    if (maybe.code !== -32002) return false;
+    const expectedUri = `session:${sessionId}`;
+    if (maybe.data && typeof maybe.data === "object" && maybe.data.uri === expectedUri) {
+      return true;
+    }
+    return typeof maybe.message === "string" && maybe.message === `Resource not found: ${expectedUri}`;
+  }, "isAcpSessionResourceNotFound");
+  async function restoreSession(action, req) {
+    if (shuttingDown) {
+      throw new Error("HttpAcpBridge is shutting down");
+    }
+    const workspaceKey = resolveWorkspaceKey(req.workspaceCwd);
+    const existing = byId.get(req.sessionId);
+    if (existing) {
+      existing.attachCount++;
+      const clientId = registerClient(existing, req.clientId);
+      return {
+        sessionId: existing.sessionId,
+        workspaceCwd: existing.workspaceCwd,
+        attached: true,
+        clientId,
+        createdAt: existing.createdAt,
+        // Late attachers get the same ACP state the original restore
+        // caller saw; spawn-only sessions don't carry a state payload.
+        state: existing.restoreState ?? {}
+      };
+    }
+    const inFlight = inFlightRestores.get(req.sessionId);
+    if (inFlight) {
+      if (action !== inFlight.action) {
+        throw new RestoreInProgressError(
+          req.sessionId,
+          inFlight.action,
+          action
+        );
+      }
+      inFlight.coalesceState.count++;
+      let restored;
+      try {
+        restored = await inFlight.promise;
+      } catch (err) {
+        inFlight.coalesceState.count--;
+        throw err;
+      }
+      const entry = byId.get(restored.sessionId);
+      if (!entry) {
+        inFlight.coalesceState.count--;
+        throw new SessionNotFoundError(
+          restored.sessionId,
+          "the agent child likely crashed during session restore \u2014 retry to restore the session"
+        );
+      }
+      return {
+        ...restored,
+        attached: true,
+        clientId: registerClient(entry, req.clientId),
+        createdAt: entry.createdAt
+      };
+    }
+    if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
+      throw new SessionLimitExceededError(maxSessions);
+    }
+    const restoreEvents = new EventBus(eventRingSize);
+    let registeredEntry;
+    let ci;
+    const coalesceState = { count: 0 };
+    const promise = (async () => {
+      pendingRestoreEvents.set(req.sessionId, restoreEvents);
+      ci = await ensureChannel();
+      ci.pendingRestoreIds.add(req.sessionId);
+      const transportClosed = ci.channel.exited.then(() => {
+        throw new Error(`agent channel closed during session/${action}`);
+      });
+      transportClosed.catch(() => {
+      });
+      let state;
+      try {
+        if (action === "load") {
+          state = await Promise.race([
+            withTimeout(
+              ci.connection.loadSession({
+                sessionId: req.sessionId,
+                cwd: workspaceKey,
+                // Restore path drops per-request `mcpServers` (matches
+                // `doSpawn`); daemon-wide MCP comes from settings on
+                // the agent side. The SDK's `RestoreSessionRequest`
+                // intentionally has no `mcpServers` field for the
+                // same reason.
+                mcpServers: []
+              }),
+              initTimeoutMs,
+              "loadSession"
+            ),
+            transportClosed
+          ]);
+        } else {
+          state = await Promise.race([
+            withTimeout(
+              ci.connection.unstable_resumeSession({
+                sessionId: req.sessionId,
+                cwd: workspaceKey,
+                mcpServers: []
+              }),
+              initTimeoutMs,
+              "resumeSession"
+            ),
+            transportClosed
+          ]);
+        }
+      } catch (err) {
+        restoreEvents.close();
+        if (isAcpSessionResourceNotFound(err, req.sessionId)) {
+          throw new SessionNotFoundError(req.sessionId);
+        }
+        if (ci.sessionIds.size === 0 && ci.pendingRestoreIds.size === 1 && ci.pendingRestoreIds.has(req.sessionId)) {
+          ci.isDying = true;
+          await ci.channel.kill().catch(() => {
+          });
+        }
+        throw err;
+      }
+      if (shuttingDown) {
+        restoreEvents.close();
+        throw new Error("HttpAcpBridge is shutting down");
+      }
+      if (ci.isDying || !aliveChannels.has(ci)) {
+        restoreEvents.close();
+        throw new Error(
+          `Session ${req.sessionId} restored on a closed agent channel`
+        );
+      }
+      const racedEntry = byId.get(req.sessionId);
+      if (racedEntry) {
+        restoreEvents.close();
+        racedEntry.attachCount += 1 + coalesceState.count;
+        const clientId2 = registerClient(racedEntry, req.clientId);
+        return {
+          sessionId: racedEntry.sessionId,
+          workspaceCwd: racedEntry.workspaceCwd,
+          attached: true,
+          clientId: clientId2,
+          createdAt: racedEntry.createdAt,
+          state: racedEntry.restoreState ?? {}
+        };
+      }
+      const entry = createSessionEntry(
+        ci,
+        req.sessionId,
+        workspaceKey,
+        restoreEvents
+      );
+      entry.restoreState = state;
+      const clientId = registerClient(entry, req.clientId);
+      entry.attachCount = coalesceState.count;
+      registeredEntry = entry;
+      return {
+        sessionId: entry.sessionId,
+        workspaceCwd: entry.workspaceCwd,
+        attached: false,
+        clientId,
+        createdAt: entry.createdAt,
+        state
+      };
+    })().finally(() => {
+      ci?.pendingRestoreIds.delete(req.sessionId);
+      pendingRestoreEvents.delete(req.sessionId);
+      if (!registeredEntry) {
+        restoreEvents.close();
+      }
+    });
+    inFlightRestores.set(req.sessionId, { action, promise, coalesceState });
+    try {
+      return await promise;
+    } finally {
+      inFlightRestores.delete(req.sessionId);
+    }
+  }
+  __name(restoreSession, "restoreSession");
   return {
     get sessionCount() {
       return byId.size;
@@ -13866,35 +14060,41 @@ function createHttpAcpBridge(opts) {
     get pendingPermissionCount() {
       return pendingPermissions.size;
     },
+    async loadSession(req) {
+      return restoreSession("load", req);
+    },
+    async resumeSession(req) {
+      return restoreSession("resume", req);
+    },
     async spawnOrAttach(req) {
       if (shuttingDown) {
         throw new Error("HttpAcpBridge is shutting down");
       }
-      if (!path.isAbsolute(req.workspaceCwd)) {
-        throw new Error(
-          `workspaceCwd must be an absolute path; got "${req.workspaceCwd}"`
-        );
-      }
-      const workspaceKey = req.workspaceCwd === boundWorkspace ? boundWorkspace : canonicalizeWorkspace(req.workspaceCwd);
-      if (workspaceKey !== boundWorkspace) {
-        throw new WorkspaceMismatchError(boundWorkspace, workspaceKey);
+      const workspaceKey = resolveWorkspaceKey(req.workspaceCwd);
+      if (req.sessionScope !== void 0 && req.sessionScope !== "single" && req.sessionScope !== "thread") {
+        throw new InvalidSessionScopeError(req.sessionScope);
       }
-      if (sessionScope === "single") {
+      const effectiveScope = req.sessionScope ?? defaultSessionScope;
+      if (effectiveScope === "single") {
         const existing = defaultEntry;
         if (existing) {
           existing.attachCount++;
+          const clientId = registerClient(existing, req.clientId);
           if (req.modelServiceId) {
             await applyModelServiceId(
               existing,
               req.modelServiceId,
-              initTimeoutMs
+              initTimeoutMs,
+              clientId
             ).catch(() => {
             });
           }
           return {
             sessionId: existing.sessionId,
             workspaceCwd: existing.workspaceCwd,
-            attached: true
+            attached: true,
+            clientId,
+            createdAt: existing.createdAt
           };
         }
         const inFlight = inFlightSpawns.get(workspaceKey);
@@ -13908,22 +14108,24 @@ function createHttpAcpBridge(opts) {
               "the agent child likely crashed during initialization \u2014 retry to spawn a new session"
             );
           }
+          const clientId = registerClient(attachedEntry, req.clientId);
           if (req.modelServiceId) {
             await applyModelServiceId(
               attachedEntry,
               req.modelServiceId,
-              initTimeoutMs
+              initTimeoutMs,
+              clientId
             ).catch(() => {
             });
           }
-          return { ...session, attached: true };
+          return { ...session, attached: true, clientId };
         }
       }
-      if (byId.size + inFlightSpawns.size >= maxSessions) {
+      if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
         throw new SessionLimitExceededError(maxSessions);
       }
-      const promise = doSpawn(req.modelServiceId);
-      const tracker = sessionScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID()}`;
+      const promise = doSpawn(req.modelServiceId, effectiveScope, req.clientId);
+      const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID()}`;
       inFlightSpawns.set(tracker, promise);
       try {
         return await promise;
@@ -13931,9 +14133,13 @@ function createHttpAcpBridge(opts) {
         inFlightSpawns.delete(tracker);
       }
     },
-    async sendPrompt(sessionId, req, signal) {
+    async sendPrompt(sessionId, req, signal, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
+      const originatorClientId = resolveTrustedClientId(
+        entry,
+        context?.clientId
+      );
       if (signal?.aborted) {
         throw new DOMException("Prompt aborted", "AbortError");
       }
@@ -13942,7 +14148,14 @@ function createHttpAcpBridge(opts) {
         if (signal?.aborted) {
           throw new DOMException("Prompt aborted", "AbortError");
         }
-        const promptPromise = entry.connection.prompt(normalized);
+        if (originatorClientId === void 0) {
+          delete entry.activePromptOriginatorClientId;
+        } else {
+          entry.activePromptOriginatorClientId = originatorClientId;
+        }
+        const promptPromise = entry.connection.prompt(normalized).finally(() => {
+          delete entry.activePromptOriginatorClientId;
+        });
         const racedPromise = Promise.race([
           promptPromise,
           getTransportClosedReject(entry)
@@ -13969,9 +14182,10 @@ function createHttpAcpBridge(opts) {
       );
       return result;
     },
-    async cancelSession(sessionId, req) {
+    async cancelSession(sessionId, req, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
       cancelPendingForSession(sessionId);
       const notif = req ? { ...req, sessionId } : { sessionId };
       await entry.connection.cancel(notif);
@@ -13981,65 +14195,259 @@ function createHttpAcpBridge(opts) {
       if (!entry) throw new SessionNotFoundError(sessionId);
       return entry.events.subscribe(subOpts);
     },
-    respondToPermission(requestId, response) {
+    respondToPermission(requestId, response, context) {
+      const pending = pendingPermissions.get(requestId);
+      let originatorClientId;
+      if (context?.clientId !== void 0 && !pending) {
+        resolveAnyTrustedClientId(context.clientId);
+      } else if (pending && context?.clientId !== void 0) {
+        const entry = byId.get(pending.sessionId);
+        if (entry) {
+          originatorClientId = resolveTrustedClientId(entry, context.clientId);
+        } else {
+          resolveAnyTrustedClientId(context.clientId);
+        }
+      }
+      if (!pending) {
+        const record = resolvedPermissions.get(requestId);
+        if (record) {
+          publishPermissionAlreadyResolved(record);
+        }
+        return false;
+      }
       if (response.outcome.outcome === "selected") {
-        const pending = pendingPermissions.get(requestId);
-        if (pending && !pending.allowedOptionIds.has(response.outcome.optionId)) {
+        if (!pending.allowedOptionIds.has(response.outcome.optionId)) {
           throw new InvalidPermissionOptionError(
             requestId,
             response.outcome.optionId
           );
         }
       }
-      return resolvePending(requestId, response);
+      return resolvePending(requestId, response, originatorClientId);
     },
-    listWorkspaceSessions(workspaceCwd) {
-      if (!path.isAbsolute(workspaceCwd)) return [];
-      const key = workspaceCwd === boundWorkspace ? boundWorkspace : canonicalizeWorkspace(workspaceCwd);
-      if (key !== boundWorkspace) return [];
-      const out = [];
-      for (const entry of byId.values()) {
-        if (entry.workspaceCwd === key) {
-          out.push({
-            sessionId: entry.sessionId,
-            workspaceCwd: entry.workspaceCwd
-          });
+    respondToSessionPermission(sessionId, requestId, response, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const pending = pendingPermissions.get(requestId);
+      if (!pending) {
+        const record = resolvedPermissions.get(requestId);
+        if (record?.sessionId === sessionId) {
+          resolveTrustedClientId(entry, context?.clientId);
+          publishPermissionAlreadyResolved(record);
+        } else if (record) {
+          writeServeDebugLine(
+            `rejected permission vote ${JSON.stringify(requestId)} for session ${JSON.stringify(sessionId)}; request belongs to session ${JSON.stringify(record.sessionId)}.`
+          );
         }
+        return false;
       }
-      return out;
+      if (pending.sessionId !== sessionId) {
+        writeServeDebugLine(
+          `rejected permission vote ${JSON.stringify(requestId)} for session ${JSON.stringify(sessionId)}; request belongs to session ${JSON.stringify(pending.sessionId)}.`
+        );
+        return false;
+      }
+      const originatorClientId = resolveTrustedClientId(
+        entry,
+        context?.clientId
+      );
+      if (response.outcome.outcome === "selected" && !pending.allowedOptionIds.has(response.outcome.optionId)) {
+        throw new InvalidPermissionOptionError(
+          requestId,
+          response.outcome.optionId
+        );
+      }
+      return resolvePending(requestId, response, originatorClientId);
     },
-    async setSessionModel(sessionId, req) {
+    async closeSession(sessionId, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
-      const normalized = { ...req, sessionId };
-      const conn = entry.connection;
-      const transportClosed = getTransportClosedReject(entry);
-      const work = entry.modelChangeQueue.then(
-        () => Promise.race([
-          withTimeout(
-            conn.unstable_setSessionModel(normalized),
-            initTimeoutMs,
-            "setSessionModel"
-          ),
-          transportClosed
-        ])
-      );
-      entry.modelChangeQueue = work.then(
-        () => void 0,
-        () => void 0
+      let originatorClientId;
+      if (context?.clientId !== void 0) {
+        originatorClientId = resolveTrustedClientId(entry, context.clientId);
+      }
+      writeStderrLine(
+        `qwen serve: closing session ${JSON.stringify(sessionId)}` + (originatorClientId ? ` by client ${JSON.stringify(originatorClientId)}` : "")
       );
-      let response;
-      try {
-        response = await work;
-      } catch (err) {
-        try {
-          entry.events.publish({
-            type: "model_switch_failed",
-            data: {
+      if (defaultEntry === entry) defaultEntry = void 0;
+      const ci = channelInfo;
+      if (ci && ci.channel === entry.channel) {
+        ci.sessionIds.delete(sessionId);
+      }
+      for (const id of Array.from(entry.pendingPermissionIds)) {
+        resolvePending(id, { outcome: { outcome: "cancelled" } });
+      }
+      byId.delete(sessionId);
+      try {
+        entry.events.publish({
+          type: "session_closed",
+          data: {
+            sessionId,
+            reason: "client_close",
+            ...originatorClientId ? { closedBy: originatorClientId } : {}
+          }
+        });
+      } catch {
+      }
+      entry.events.close();
+      try {
+        await entry.connection.cancel({ sessionId });
+      } catch {
+      }
+      if (ci && ci.sessionIds.size === 0 && ci.pendingRestoreIds.size === 0) {
+        ci.isDying = true;
+        await ci.channel.kill().catch((err) => {
+          writeStderrLine(
+            `qwen serve: closeSession channel kill failed for session ${JSON.stringify(sessionId)}: ${String(err)}`
+          );
+        });
+      }
+    },
+    updateSessionMetadata(sessionId, metadata, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      if (context?.clientId !== void 0) {
+        resolveTrustedClientId(entry, context.clientId);
+      }
+      if (metadata.displayName !== void 0) {
+        if (typeof metadata.displayName !== "string" || metadata.displayName.length > MAX_DISPLAY_NAME_LENGTH) {
+          throw new InvalidSessionMetadataError(
+            "displayName",
+            `must be a string of at most ${MAX_DISPLAY_NAME_LENGTH} characters`
+          );
+        }
+        if (hasControlCharacter(metadata.displayName)) {
+          throw new InvalidSessionMetadataError(
+            "displayName",
+            "must not contain control characters"
+          );
+        }
+        const nextDisplayName = metadata.displayName || void 0;
+        if (entry.displayName !== nextDisplayName) {
+          entry.displayName = nextDisplayName;
+          writeStderrLine(
+            `qwen serve: updated session metadata ${JSON.stringify(sessionId)} displayName=${entry.displayName === void 0 ? "cleared" : "set"}` + (context?.clientId ? ` by client ${JSON.stringify(context.clientId)}` : "")
+          );
+          try {
+            entry.events.publish({
+              type: "session_metadata_updated",
+              data: { sessionId, displayName: entry.displayName }
+            });
+          } catch {
+          }
+        }
+      }
+      return { displayName: entry.displayName };
+    },
+    listWorkspaceSessions(workspaceCwd) {
+      if (!path.isAbsolute(workspaceCwd)) return [];
+      const key = workspaceCwd === boundWorkspace ? boundWorkspace : canonicalizeWorkspace(workspaceCwd);
+      if (key !== boundWorkspace) return [];
+      const out = [];
+      for (const entry of byId.values()) {
+        if (entry.workspaceCwd === key) {
+          out.push({
+            sessionId: entry.sessionId,
+            workspaceCwd: entry.workspaceCwd,
+            createdAt: entry.createdAt,
+            displayName: entry.displayName,
+            clientCount: entry.clientIds.size,
+            hasActivePrompt: entry.activePromptOriginatorClientId !== void 0
+          });
+        }
+      }
+      return out;
+    },
+    recordHeartbeat(sessionId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const clientId = resolveTrustedClientId(entry, context?.clientId);
+      const lastSeenAt = Date.now();
+      entry.sessionLastSeenAt = lastSeenAt;
+      if (clientId !== void 0) {
+        entry.clientLastSeenAt.set(clientId, lastSeenAt);
+      }
+      return {
+        sessionId: entry.sessionId,
+        ...clientId !== void 0 ? { clientId } : {},
+        lastSeenAt
+      };
+    },
+    getHeartbeatState(sessionId) {
+      const entry = byId.get(sessionId);
+      if (!entry) return void 0;
+      return {
+        ...entry.sessionLastSeenAt !== void 0 ? { sessionLastSeenAt: entry.sessionLastSeenAt } : {},
+        clientLastSeenAt: new Map(entry.clientLastSeenAt)
+      };
+    },
+    async getWorkspaceMcpStatus() {
+      return requestWorkspaceStatus(
+        SERVE_STATUS_EXT_METHODS.workspaceMcp,
+        () => createIdleWorkspaceMcpStatus(boundWorkspace)
+      );
+    },
+    async getWorkspaceSkillsStatus() {
+      return requestWorkspaceStatus(
+        SERVE_STATUS_EXT_METHODS.workspaceSkills,
+        () => createIdleWorkspaceSkillsStatus(boundWorkspace)
+      );
+    },
+    async getWorkspaceProvidersStatus() {
+      return requestWorkspaceStatus(
+        SERVE_STATUS_EXT_METHODS.workspaceProviders,
+        () => createIdleWorkspaceProvidersStatus(boundWorkspace)
+      );
+    },
+    async getSessionContextStatus(sessionId) {
+      return requestSessionStatus(
+        sessionId,
+        SERVE_STATUS_EXT_METHODS.sessionContext
+      );
+    },
+    async getSessionSupportedCommandsStatus(sessionId) {
+      return requestSessionStatus(
+        sessionId,
+        SERVE_STATUS_EXT_METHODS.sessionSupportedCommands
+      );
+    },
+    async setSessionModel(sessionId, req, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const originatorClientId = resolveTrustedClientId(
+        entry,
+        context?.clientId
+      );
+      const normalized = { ...req, sessionId };
+      const conn = entry.connection;
+      const transportClosed = getTransportClosedReject(entry);
+      const work = entry.modelChangeQueue.then(
+        () => Promise.race([
+          withTimeout(
+            conn.unstable_setSessionModel(normalized),
+            initTimeoutMs,
+            "setSessionModel"
+          ),
+          transportClosed
+        ])
+      );
+      entry.modelChangeQueue = work.then(
+        () => void 0,
+        () => void 0
+      );
+      let response;
+      try {
+        response = await work;
+      } catch (err) {
+        try {
+          entry.events.publish({
+            type: "model_switch_failed",
+            data: {
               sessionId: entry.sessionId,
               requestedModelId: req.modelId,
               error: err instanceof Error ? err.message : String(err)
-            }
+            },
+            ...originatorClientId ? { originatorClientId } : {}
           });
         } catch {
         }
@@ -14048,7 +14456,8 @@ function createHttpAcpBridge(opts) {
       try {
         entry.events.publish({
           type: "model_switched",
-          data: { sessionId: entry.sessionId, modelId: req.modelId }
+          data: { sessionId: entry.sessionId, modelId: req.modelId },
+          ...originatorClientId ? { originatorClientId } : {}
         });
       } catch {
       }
@@ -14078,16 +14487,17 @@ function createHttpAcpBridge(opts) {
       } catch {
       }
       entry.events.close();
-      if (ci && ci.sessionIds.size === 0) {
+      if (ci && ci.sessionIds.size === 0 && ci.pendingRestoreIds.size === 0) {
         ci.isDying = true;
         await ci.channel.kill().catch(() => {
         });
       }
     },
-    async detachClient(sessionId) {
+    async detachClient(sessionId, clientId) {
       const entry = byId.get(sessionId);
       if (!entry) return;
       if (entry.attachCount > 0) entry.attachCount--;
+      unregisterClient(entry, clientId);
       if (entry.spawnOwnerWantedKill && entry.attachCount === 0 && entry.events.subscriberCount === 0) {
         await this.killSession(sessionId).catch(() => {
         });
@@ -14135,6 +14545,12 @@ function createHttpAcpBridge(opts) {
           () => void 0
         )
       );
+      const inFlightRestoreAwaits = Array.from(inFlightRestores.values()).map(
+        (restore) => restore.promise.then(
+          () => void 0,
+          () => void 0
+        )
+      );
       const inFlightChannelAwait = inFlightChannelSpawn ? inFlightChannelSpawn.then(
         () => void 0,
         () => void 0
@@ -14143,6 +14559,7 @@ function createHttpAcpBridge(opts) {
         ...channels.map((ci) => ci.channel.kill().catch(() => {
         })),
         ...inFlightSessionAwaits,
+        ...inFlightRestoreAwaits,
         inFlightChannelAwait
       ]);
     }
@@ -14328,20 +14745,101 @@ function killChild(child) {
 }
 __name(killChild, "killChild");
 
+// packages/cli/src/serve/capabilities.ts
+init_esbuild_shims();
+var SERVE_PROTOCOL_VERSION = "v1";
+var SUPPORTED_SERVE_PROTOCOL_VERSIONS = [
+  SERVE_PROTOCOL_VERSION
+];
+var SERVE_CAPABILITY_REGISTRY = {
+  health: { since: "v1" },
+  capabilities: { since: "v1" },
+  session_create: { since: "v1" },
+  session_scope_override: { since: "v1" },
+  session_load: { since: "v1" },
+  // ACP backs this with `connection.unstable_resumeSession`. Surface
+  // the unstable prefix so clients don't pin against a `v1` shape that
+  // the underlying ACP method may still change.
+  unstable_session_resume: { since: "v1" },
+  session_list: { since: "v1" },
+  session_prompt: { since: "v1" },
+  session_cancel: { since: "v1" },
+  session_events: { since: "v1" },
+  // Daemon emits `slow_client_warning` synthetic frames at 75% queue
+  // fill and honors `?maxQueued=N` (range [16, 2048]) on
+  // `GET /session/:id/events`. Old daemons silently lack both — SDK
+  // clients pre-flight this tag before opting in.
+  slow_client_warning: { since: "v1" },
+  // SDK consumers can detect `KnownDaemonEvent` schema support without
+  // pinning against this SDK release — `narrowDaemonEvent` falls back
+  // to `kind: 'unknown'` for daemons that don't advertise the tag,
+  // so the tag is purely informational.
+  typed_event_schema: { since: "v1" },
+  session_set_model: { since: "v1" },
+  client_identity: { since: "v1" },
+  client_heartbeat: { since: "v1" },
+  session_permission_vote: { since: "v1" },
+  permission_vote: { since: "v1" },
+  workspace_mcp: { since: "v1" },
+  workspace_skills: { since: "v1" },
+  workspace_providers: { since: "v1" },
+  session_context: { since: "v1" },
+  session_supported_commands: { since: "v1" },
+  session_close: { since: "v1" },
+  session_metadata: { since: "v1" },
+  // Issue #4175 PR 15. Daemon was booted with `--require-auth` (or
+  // `requireAuth: true`), so even loopback callers must carry a bearer
+  // token. Advertised CONDITIONALLY — only when the flag is on — so
+  // SDK clients can branch on its presence to surface a clear "this
+  // deployment requires auth" hint instead of speculatively trying
+  // requests and parsing the resulting 401 body. Loopback developer
+  // defaults (no flag) omit the tag, preserving the bit-for-bit shape
+  // older clients expect.
+  require_auth: { since: "v1" }
+};
+var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
+  ["require_auth", (toggles) => toggles.requireAuth === true]
+]);
+var SERVE_FEATURES = Object.freeze(
+  Object.keys(SERVE_CAPABILITY_REGISTRY)
+);
+function serveProtocolVersionIndex(version) {
+  return SUPPORTED_SERVE_PROTOCOL_VERSIONS.indexOf(version);
+}
+__name(serveProtocolVersionIndex, "serveProtocolVersionIndex");
+function isFeatureAvailableInProtocol(feature, protocolVersion) {
+  return serveProtocolVersionIndex(SERVE_CAPABILITY_REGISTRY[feature].since) <= serveProtocolVersionIndex(protocolVersion);
+}
+__name(isFeatureAvailableInProtocol, "isFeatureAvailableInProtocol");
+function getRegisteredServeFeatures() {
+  return [...SERVE_FEATURES];
+}
+__name(getRegisteredServeFeatures, "getRegisteredServeFeatures");
+function getAdvertisedServeFeatures(protocolVersion = SERVE_PROTOCOL_VERSION, toggles = {}) {
+  return SERVE_FEATURES.filter((feature) => {
+    if (!isFeatureAvailableInProtocol(feature, protocolVersion)) return false;
+    const predicate = CONDITIONAL_SERVE_FEATURES.get(feature);
+    if (predicate !== void 0) return predicate(toggles);
+    return true;
+  });
+}
+__name(getAdvertisedServeFeatures, "getAdvertisedServeFeatures");
+function getServeFeatures() {
+  return getAdvertisedServeFeatures();
+}
+__name(getServeFeatures, "getServeFeatures");
+function getServeProtocolVersions() {
+  return {
+    current: SERVE_PROTOCOL_VERSION,
+    supported: [...SUPPORTED_SERVE_PROTOCOL_VERSIONS]
+  };
+}
+__name(getServeProtocolVersions, "getServeProtocolVersions");
+
 // packages/cli/src/serve/types.ts
 init_esbuild_shims();
 var CAPABILITIES_SCHEMA_VERSION = 1;
-var STAGE1_FEATURES = [
-  "health",
-  "capabilities",
-  "session_create",
-  "session_list",
-  "session_prompt",
-  "session_cancel",
-  "session_events",
-  "session_set_model",
-  "permission_vote"
-];
+var STAGE1_FEATURES = SERVE_FEATURES;
 
 // packages/cli/src/serve/server.ts
 function createServeApp(opts, getPort = () => opts.port, deps = {}) {
@@ -14349,6 +14847,11 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   const boundWorkspace = deps.boundWorkspace ?? canonicalizeWorkspace(opts.workspace ?? process.cwd());
   const bridge = deps.bridge ?? createHttpAcpBridge({
     maxSessions: opts.maxSessions,
+    // Symmetric with `runQwenServe.ts` — direct embeds / tests that
+    // call `createServeApp` without supplying their own bridge and
+    // pass `ServeOptions.eventRingSize` would otherwise silently
+    // get the default 8000 ring instead of their configured value.
+    ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
     boundWorkspace
   });
   app.use(denyBrowserOriginCors);
@@ -14374,19 +14877,31 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     }
   }, "healthHandler");
   const loopback = isLoopbackBind(opts.hostname);
-  if (loopback) {
+  const exposeHealthPreAuth = loopback && !opts.requireAuth;
+  if (exposeHealthPreAuth) {
     app.get("/health", healthHandler);
   }
   app.use(bearerAuth(opts.token));
   app.use(import_express.default.json({ limit: "10mb" }));
-  if (!loopback) {
+  if (!exposeHealthPreAuth) {
     app.get("/health", healthHandler);
   }
+  const mutate = createMutationGate({
+    tokenConfigured: opts.token !== void 0,
+    requireAuth: opts.requireAuth === true
+  });
   app.get("/capabilities", (_req, res) => {
     const envelope = {
       v: CAPABILITIES_SCHEMA_VERSION,
+      protocolVersions: getServeProtocolVersions(),
       mode: opts.mode,
-      features: [...STAGE1_FEATURES],
+      // PR 15. Pass `requireAuth` so the `require_auth` tag appears
+      // ONLY when the operator opted in. Tag presence = behavior is
+      // on; older daemons without this PR omit the tag and SDKs that
+      // post-PR feature-detect on it stay backward compatible.
+      features: getAdvertisedServeFeatures(void 0, {
+        requireAuth: opts.requireAuth === true
+      }),
       modelServices: [],
       // #3803 §02: surface the bound workspace so clients can detect
       // mismatch pre-flight and omit `cwd` on `POST /session`.
@@ -14394,7 +14909,28 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     };
     res.status(200).json(envelope);
   });
-  app.post("/session", async (req, res) => {
+  app.get("/workspace/mcp", async (_req, res) => {
+    try {
+      res.status(200).json(await bridge.getWorkspaceMcpStatus());
+    } catch (err) {
+      sendBridgeError(res, err, { route: "GET /workspace/mcp" });
+    }
+  });
+  app.get("/workspace/skills", async (_req, res) => {
+    try {
+      res.status(200).json(await bridge.getWorkspaceSkillsStatus());
+    } catch (err) {
+      sendBridgeError(res, err, { route: "GET /workspace/skills" });
+    }
+  });
+  app.get("/workspace/providers", async (_req, res) => {
+    try {
+      res.status(200).json(await bridge.getWorkspaceProvidersStatus());
+    } catch (err) {
+      sendBridgeError(res, err, { route: "GET /workspace/providers" });
+    }
+  });
+  app.post("/session", mutate(), async (req, res) => {
     const body = safeBody(req);
     const hasCwd = "cwd" in body;
     if (hasCwd && typeof body["cwd"] !== "string") {
@@ -14413,17 +14949,33 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       return;
     }
     const modelServiceId = typeof body["modelServiceId"] === "string" ? body["modelServiceId"] : void 0;
+    const rawSessionScope = body["sessionScope"];
+    let sessionScope;
+    if (rawSessionScope !== void 0) {
+      if (rawSessionScope !== "single" && rawSessionScope !== "thread") {
+        res.status(400).json({
+          error: '`sessionScope` must be "single" or "thread" when provided',
+          code: "invalid_session_scope"
+        });
+        return;
+      }
+      sessionScope = rawSessionScope;
+    }
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
     try {
       const session = await bridge.spawnOrAttach({
         workspaceCwd: cwd,
-        modelServiceId
+        modelServiceId,
+        ...clientId !== void 0 ? { clientId } : {},
+        ...sessionScope !== void 0 ? { sessionScope } : {}
       });
       if (!res.writable) {
         if (!session.attached) {
           bridge.killSession(session.sessionId, { requireZeroAttaches: true }).catch(() => {
           });
         } else {
-          bridge.detachClient(session.sessionId).catch(() => {
+          bridge.detachClient(session.sessionId, session.clientId).catch(() => {
           });
         }
         return;
@@ -14433,7 +14985,78 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       sendBridgeError(res, err, { route: "POST /session" });
     }
   });
-  app.post("/session/:id/prompt", async (req, res) => {
+  const restoreSessionHandler = /* @__PURE__ */ __name((action) => async (req, res) => {
+    const sessionId = req.params["id"];
+    if (!sessionId) {
+      res.status(400).json({ error: "`sessionId` route parameter is required" });
+      return;
+    }
+    const body = safeBody(req);
+    const cwd = parseOptionalWorkspaceCwd(body, boundWorkspace, res);
+    if (cwd === void 0) return;
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    try {
+      const session = action === "load" ? await bridge.loadSession({
+        sessionId,
+        workspaceCwd: cwd,
+        ...clientId !== void 0 ? { clientId } : {}
+      }) : await bridge.resumeSession({
+        sessionId,
+        workspaceCwd: cwd,
+        ...clientId !== void 0 ? { clientId } : {}
+      });
+      if (!res.writable) {
+        if (!session.attached) {
+          bridge.killSession(session.sessionId, { requireZeroAttaches: true }).catch(() => {
+          });
+        } else {
+          bridge.detachClient(session.sessionId, session.clientId).catch(() => {
+          });
+        }
+        return;
+      }
+      res.status(200).json(session);
+    } catch (err) {
+      sendBridgeError(res, err, {
+        route: `POST /session/:id/${action}`,
+        sessionId
+      });
+    }
+  }, "restoreSessionHandler");
+  app.post("/session/:id/load", mutate(), restoreSessionHandler("load"));
+  app.post("/session/:id/resume", mutate(), restoreSessionHandler("resume"));
+  app.get("/session/:id/context", async (req, res) => {
+    const sessionId = req.params["id"];
+    if (!sessionId) {
+      res.status(400).json({ error: "`sessionId` route parameter is required" });
+      return;
+    }
+    try {
+      res.status(200).json(await bridge.getSessionContextStatus(sessionId));
+    } catch (err) {
+      sendBridgeError(res, err, {
+        route: "GET /session/:id/context",
+        sessionId
+      });
+    }
+  });
+  app.get("/session/:id/supported-commands", async (req, res) => {
+    const sessionId = req.params["id"];
+    if (!sessionId) {
+      res.status(400).json({ error: "`sessionId` route parameter is required" });
+      return;
+    }
+    try {
+      res.status(200).json(await bridge.getSessionSupportedCommandsStatus(sessionId));
+    } catch (err) {
+      sendBridgeError(res, err, {
+        route: "GET /session/:id/supported-commands",
+        sessionId
+      });
+    }
+  });
+  app.post("/session/:id/prompt", mutate(), async (req, res) => {
     const sessionId = req.params["id"];
     const body = safeBody(req);
     const prompt = body["prompt"];
@@ -14464,6 +15087,11 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       if (!res.writableEnded) abort.abort();
     }, "onResClose");
     res.once("close", onResClose);
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) {
+      res.off("close", onResClose);
+      return;
+    }
     try {
       const result = await bridge.sendPrompt(
         sessionId,
@@ -14472,7 +15100,8 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
           sessionId,
           prompt
         },
-        abort.signal
+        abort.signal,
+        clientId !== void 0 ? { clientId } : void 0
       );
       res.status(200).json(result);
     } catch (err) {
@@ -14487,14 +15116,41 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       res.off("close", onResClose);
     }
   });
-  app.post("/session/:id/cancel", async (req, res) => {
+  app.post("/session/:id/heartbeat", mutate(), (req, res) => {
     const sessionId = req.params["id"];
-    const body = safeBody(req);
+    if (!sessionId) {
+      res.status(400).json({ error: "`sessionId` route parameter is required" });
+      return;
+    }
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
     try {
-      await bridge.cancelSession(sessionId, {
-        ...body,
+      const result = bridge.recordHeartbeat(
+        sessionId,
+        clientId !== void 0 ? { clientId } : void 0
+      );
+      res.status(200).json(result);
+    } catch (err) {
+      sendBridgeError(res, err, {
+        route: "POST /session/:id/heartbeat",
         sessionId
       });
+    }
+  });
+  app.post("/session/:id/cancel", mutate(), async (req, res) => {
+    const sessionId = req.params["id"];
+    const body = safeBody(req);
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    try {
+      await bridge.cancelSession(
+        sessionId,
+        {
+          ...body,
+          sessionId
+        },
+        clientId !== void 0 ? { clientId } : void 0
+      );
       res.status(204).end();
     } catch (err) {
       sendBridgeError(res, err, {
@@ -14503,6 +15159,51 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       });
     }
   });
+  app.delete("/session/:id", async (req, res) => {
+    const sessionId = req.params["id"];
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    try {
+      await bridge.closeSession(
+        sessionId,
+        clientId !== void 0 ? { clientId } : void 0
+      );
+      res.status(204).end();
+    } catch (err) {
+      sendBridgeError(res, err, {
+        route: "DELETE /session/:id",
+        sessionId
+      });
+    }
+  });
+  app.patch("/session/:id/metadata", (req, res) => {
+    const sessionId = req.params["id"];
+    const body = safeBody(req);
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    const displayName = body["displayName"];
+    if (displayName !== void 0 && typeof displayName !== "string") {
+      res.status(400).json({
+        error: "`displayName` must be a string",
+        code: "invalid_metadata",
+        field: "displayName"
+      });
+      return;
+    }
+    try {
+      const effective = bridge.updateSessionMetadata(
+        sessionId,
+        { displayName },
+        clientId !== void 0 ? { clientId } : void 0
+      );
+      res.status(200).json({ sessionId, ...effective });
+    } catch (err) {
+      sendBridgeError(res, err, {
+        route: "PATCH /session/:id/metadata",
+        sessionId
+      });
+    }
+  });
   app.get("/workspace/:id/sessions", (req, res) => {
     const workspaceCwd = req.params["id"] ?? "";
     if (!path2.isAbsolute(workspaceCwd)) {
@@ -14522,7 +15223,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     const sessions = bridge.listWorkspaceSessions(workspaceCwd);
     res.status(200).json({ sessions });
   });
-  app.post("/session/:id/model", async (req, res) => {
+  app.post("/session/:id/model", mutate(), async (req, res) => {
     const sessionId = req.params["id"];
     const body = safeBody(req);
     const modelId = body["modelId"];
@@ -14532,12 +15233,18 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       });
       return;
     }
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
     try {
-      const response = await bridge.setSessionModel(sessionId, {
-        ...body,
+      const response = await bridge.setSessionModel(
         sessionId,
-        modelId
-      });
+        {
+          ...body,
+          sessionId,
+          modelId
+        },
+        clientId !== void 0 ? { clientId } : void 0
+      );
       res.status(200).json(response);
     } catch (err) {
       sendBridgeError(res, err, {
@@ -14546,33 +15253,56 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       });
     }
   });
-  app.post("/permission/:requestId", (req, res) => {
+  app.post("/session/:id/permission/:requestId", mutate(), (req, res) => {
+    const sessionId = req.params["id"];
     const requestId = req.params["requestId"];
-    const body = safeBody(req);
-    const outcome = body["outcome"];
-    if (!isValidOutcome(outcome)) {
-      res.status(400).json({
-        error: '`outcome` must be `{ outcome: "cancelled" }` or `{ outcome: "selected", optionId: string }`'
+    const response = parsePermissionVoteBody(req, res);
+    if (response === void 0) return;
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    let accepted;
+    try {
+      accepted = bridge.respondToSessionPermission(
+        sessionId,
+        requestId,
+        response,
+        clientId !== void 0 ? { clientId } : void 0
+      );
+    } catch (err) {
+      sendPermissionVoteError(res, err, {
+        route: "POST /session/:id/permission/:requestId",
+        sessionId
+      });
+      return;
+    }
+    if (!accepted) {
+      res.status(404).json({
+        error: "No pending permission request for session",
+        sessionId,
+        requestId
       });
       return;
     }
+    res.status(200).json({});
+  });
+  app.post("/permission/:requestId", mutate(), (req, res) => {
+    const requestId = req.params["requestId"];
+    const response = parsePermissionVoteBody(req, res);
+    if (response === void 0) return;
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
     let accepted;
     try {
-      accepted = bridge.respondToPermission(requestId, {
-        ...body,
-        outcome
-      });
+      accepted = bridge.respondToPermission(
+        requestId,
+        response,
+        clientId !== void 0 ? { clientId } : void 0
+      );
     } catch (err) {
-      if (err instanceof InvalidPermissionOptionError) {
-        res.status(400).json({
-          error: err.message,
-          code: "invalid_option_id",
-          requestId: err.requestId,
-          optionId: err.optionId
-        });
-        return;
-      }
-      throw err;
+      sendPermissionVoteError(res, err, {
+        route: "POST /permission/:requestId"
+      });
+      return;
     }
     if (!accepted) {
       res.status(404).json({ error: "No pending permission request", requestId });
@@ -14583,12 +15313,15 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   app.get("/session/:id/events", (req, res) => {
     const sessionId = req.params["id"];
     const lastEventId = parseLastEventId(req.headers["last-event-id"]);
+    const maxQueued = parseMaxQueuedQuery(req.query["maxQueued"], res);
+    if (maxQueued === null) return;
     let iter;
     const abort = new AbortController();
     try {
       const iterable = bridge.subscribeEvents(sessionId, {
         signal: abort.signal,
-        lastEventId
+        lastEventId,
+        ...maxQueued !== void 0 ? { maxQueued } : {}
       });
       iter = iterable[Symbol.asyncIterator]();
     } catch (err) {
@@ -14728,6 +15461,10 @@ var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
   "constructor",
   "prototype"
 ]);
+var CLIENT_ID_HEADER = "x-qwen-client-id";
+var MAX_CLIENT_ID_LENGTH = 128;
+var CLIENT_ID_RE = /^[A-Za-z0-9._:-]+$/;
+var INVALID_PERMISSION_OUTCOME_ERROR = '`outcome` must be `{ outcome: "cancelled" }` or `{ outcome: "selected", optionId: string }`';
 function safeBody(req) {
   const raw = req.body;
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
@@ -14741,6 +15478,52 @@ function safeBody(req) {
   return out;
 }
 __name(safeBody, "safeBody");
+function parseOptionalWorkspaceCwd(body, boundWorkspace, res) {
+  const hasCwd = "cwd" in body;
+  if (hasCwd && typeof body["cwd"] !== "string") {
+    res.status(400).json({ error: "`cwd` must be a string absolute path when provided" });
+    return void 0;
+  }
+  if (hasCwd && body["cwd"].length > MAX_WORKSPACE_PATH_LENGTH) {
+    res.status(400).json({
+      error: `\`cwd\` exceeds the ${MAX_WORKSPACE_PATH_LENGTH}-character limit`
+    });
+    return void 0;
+  }
+  const cwd = hasCwd ? body["cwd"] : boundWorkspace;
+  if (!path2.isAbsolute(cwd)) {
+    res.status(400).json({ error: "`cwd` must be an absolute path when provided" });
+    return void 0;
+  }
+  return cwd;
+}
+__name(parseOptionalWorkspaceCwd, "parseOptionalWorkspaceCwd");
+function parseClientIdHeader(req, res) {
+  const raw = req.get(CLIENT_ID_HEADER);
+  if (raw === void 0 || raw === "") return void 0;
+  if (raw.length > MAX_CLIENT_ID_LENGTH || !CLIENT_ID_RE.test(raw)) {
+    res.status(400).json({
+      error: "`X-Qwen-Client-Id` must be a non-empty token of 128 characters or fewer",
+      code: "invalid_client_id"
+    });
+    return null;
+  }
+  return raw;
+}
+__name(parseClientIdHeader, "parseClientIdHeader");
+function parsePermissionVoteBody(req, res) {
+  const body = safeBody(req);
+  const outcome = body["outcome"];
+  if (!isValidOutcome(outcome)) {
+    res.status(400).json({ error: INVALID_PERMISSION_OUTCOME_ERROR });
+    return void 0;
+  }
+  return {
+    ...body,
+    outcome
+  };
+}
+__name(parsePermissionVoteBody, "parsePermissionVoteBody");
 function isValidOutcome(raw) {
   if (typeof raw !== "object" || raw === null) return false;
   const obj = raw;
@@ -14748,11 +15531,43 @@ function isValidOutcome(raw) {
   return obj["outcome"] === "selected" && typeof obj["optionId"] === "string" && obj["optionId"].length > 0;
 }
 __name(isValidOutcome, "isValidOutcome");
+var MIN_QUERY_MAX_QUEUED = 16;
+var MAX_QUERY_MAX_QUEUED = 2048;
+function parseMaxQueuedQuery(raw, res) {
+  if (raw === void 0) return void 0;
+  if (typeof raw !== "string" || !/^\d+$/.test(raw)) {
+    writeStderrLine(
+      `qwen serve: rejected ?maxQueued ${safeLogValue(raw)} (not a decimal integer)`
+    );
+    res.status(400).json({
+      error: "`maxQueued` must be a decimal integer",
+      code: "invalid_max_queued"
+    });
+    return null;
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < MIN_QUERY_MAX_QUEUED || n > MAX_QUERY_MAX_QUEUED) {
+    writeStderrLine(
+      `qwen serve: rejected ?maxQueued ${safeLogValue(raw)} (outside [${MIN_QUERY_MAX_QUEUED}, ${MAX_QUERY_MAX_QUEUED}])`
+    );
+    res.status(400).json({
+      error: `\`maxQueued\` must be in [${MIN_QUERY_MAX_QUEUED}, ${MAX_QUERY_MAX_QUEUED}]`,
+      code: "invalid_max_queued"
+    });
+    return null;
+  }
+  return n;
+}
+__name(parseMaxQueuedQuery, "parseMaxQueuedQuery");
+function safeLogValue(raw) {
+  return JSON.stringify(String(raw)).slice(0, 82);
+}
+__name(safeLogValue, "safeLogValue");
 function parseLastEventId(raw) {
   if (typeof raw !== "string" || !/^\d+$/.test(raw)) {
     if (typeof raw === "string" && raw.length > 0) {
       writeStderrLine(
-        `qwen serve: rejected Last-Event-ID "${raw.slice(0, 80)}" (not a decimal integer)`
+        `qwen serve: rejected Last-Event-ID ${safeLogValue(raw)} (not a decimal integer)`
       );
     }
     return void 0;
@@ -14760,13 +15575,26 @@ function parseLastEventId(raw) {
   const n = Number.parseInt(raw, 10);
   if (!Number.isFinite(n) || n > Number.MAX_SAFE_INTEGER) {
     writeStderrLine(
-      `qwen serve: rejected Last-Event-ID "${raw.slice(0, 80)}" (exceeds Number.MAX_SAFE_INTEGER)`
+      `qwen serve: rejected Last-Event-ID ${safeLogValue(raw)} (exceeds Number.MAX_SAFE_INTEGER)`
     );
     return void 0;
   }
   return n;
 }
 __name(parseLastEventId, "parseLastEventId");
+function sendPermissionVoteError(res, err, ctx) {
+  if (err instanceof InvalidPermissionOptionError) {
+    res.status(400).json({
+      error: err.message,
+      code: "invalid_option_id",
+      requestId: err.requestId,
+      optionId: err.optionId
+    });
+    return;
+  }
+  sendBridgeError(res, err, ctx);
+}
+__name(sendPermissionVoteError, "sendPermissionVoteError");
 function formatSseFrame(event) {
   const dataJson = JSON.stringify(event);
   const idLine = "id" in event && event.id !== void 0 ? `id: ${event.id}
@@ -14782,6 +15610,15 @@ function sendBridgeError(res, err, ctx) {
     res.status(404).json({ error: err.message, sessionId: err.sessionId });
     return;
   }
+  if (err instanceof InvalidClientIdError) {
+    res.status(400).json({
+      error: err.message,
+      code: "invalid_client_id",
+      sessionId: err.sessionId,
+      clientId: err.clientId
+    });
+    return;
+  }
   if (err instanceof WorkspaceMismatchError) {
     writeStderrLine(
       `qwen serve: workspace_mismatch (POST /session): daemon bound to ${JSON.stringify(err.bound)}, rejected ${JSON.stringify(err.requested)}`
@@ -14794,6 +15631,21 @@ function sendBridgeError(res, err, ctx) {
     });
     return;
   }
+  if (err instanceof InvalidSessionScopeError) {
+    res.status(400).json({
+      error: err.message,
+      code: "invalid_session_scope"
+    });
+    return;
+  }
+  if (err instanceof InvalidSessionMetadataError) {
+    res.status(400).json({
+      error: err.message,
+      code: "invalid_metadata",
+      field: err.field
+    });
+    return;
+  }
   if (err instanceof SessionLimitExceededError) {
     res.set("Retry-After", "5");
     res.status(503).json({
@@ -14803,6 +15655,17 @@ function sendBridgeError(res, err, ctx) {
     });
     return;
   }
+  if (err instanceof RestoreInProgressError) {
+    res.set("Retry-After", "5");
+    res.status(409).json({
+      error: err.message,
+      code: "restore_in_progress",
+      sessionId: err.sessionId,
+      activeAction: err.activeAction,
+      requestedAction: err.requestedAction
+    });
+    return;
+  }
   const ctxParts = [
     ctx?.route,
     ctx?.sessionId ? `session=${ctx.sessionId}` : void 0
@@ -14870,6 +15733,11 @@ async function runQwenServe(optsIn, deps = {}) {
       `Refusing to bind ${opts.hostname}:${opts.port} without a bearer token. Set ${QWEN_SERVER_TOKEN_ENV} or pass --token, or rebind to loopback (127.0.0.1, localhost, ::1, or [::1]).`
     );
   }
+  if (opts.requireAuth && !token) {
+    throw new Error(
+      `Refusing to start with --require-auth set but no bearer token configured. Set ${QWEN_SERVER_TOKEN_ENV} or pass --token, or omit --require-auth to keep the loopback developer default.`
+    );
+  }
   const rawWorkspace = opts.workspace ?? process.cwd();
   if (!path3.isAbsolute(rawWorkspace)) {
     throw new Error(
@@ -14902,6 +15770,7 @@ async function runQwenServe(optsIn, deps = {}) {
   const boundWorkspace = canonicalizeWorkspace(rawWorkspace);
   const bridge = deps.bridge ?? createHttpAcpBridge({
     maxSessions: opts.maxSessions,
+    ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
     boundWorkspace
   });
   let actualPort = opts.port;
@@ -14950,6 +15819,10 @@ async function runQwenServe(optsIn, deps = {}) {
         writeStderrLine(
           `qwen serve: bearer auth disabled (loopback default). Set ${QWEN_SERVER_TOKEN_ENV} to enable.`
         );
+      } else if (opts.requireAuth) {
+        writeStderrLine(
+          "qwen serve: --require-auth enabled (bearer token mandatory on every route, including loopback /health)."
+        );
       }
       let shuttingDown = false;
       let closePromise;
@@ -15064,14 +15937,32 @@ function createInMemoryChannel() {
 __name(createInMemoryChannel, "createInMemoryChannel");
 export {
   CAPABILITIES_SCHEMA_VERSION,
+  CONDITIONAL_SERVE_FEATURES,
   EVENT_SCHEMA_VERSION,
   EventBus,
+  SERVE_CAPABILITY_REGISTRY,
+  SERVE_FEATURES,
+  SERVE_PROTOCOL_VERSION,
+  SERVE_STATUS_EXT_METHODS,
   STAGE1_FEATURES,
+  STATUS_SCHEMA_VERSION,
+  SUPPORTED_SERVE_PROTOCOL_VERSIONS,
   SessionNotFoundError,
+  bearerAuth,
   createHttpAcpBridge,
+  createIdleWorkspaceMcpStatus,
+  createIdleWorkspaceProvidersStatus,
+  createIdleWorkspaceSkillsStatus,
   createInMemoryChannel,
+  createMutationGate,
   createServeApp,
   defaultSpawnChannelFactory,
+  denyBrowserOriginCors,
+  getAdvertisedServeFeatures,
+  getRegisteredServeFeatures,
+  getServeFeatures,
+  getServeProtocolVersions,
+  hostAllowlist,
   runQwenServe
 };
 /**