@qwen-code/qwen-code 0.21.7-nightly.20260808.4ec0371e6 → 0.21.8

package/chunks/{chunk-764F335K.js → chunk-FYAXKJK7.js}

@@ -28,6 +28,16 @@ import {
   createIdleWorkspaceHooksStatus
 } from "./chunk-NLREQJFK.js";
 import {
+  ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
+  ACTIVE_WORK_CLOSE_TIMEOUT_MS,
+  ACTIVE_WORK_HEARTBEAT_INTERVAL_MS,
+  ACTIVE_WORK_HEARTBEAT_META_KEY,
+  ACTIVE_WORK_HEARTBEAT_VERSION,
+  ACTIVE_WORK_HOLD_CATEGORIES,
+  ACTIVE_WORK_MAX_SESSION_HOLDS,
+  ACTIVE_WORK_MAX_SNAPSHOT_SESSIONS,
+  ACTIVE_WORK_NOTIFICATION_METHOD,
+  ACTIVE_WORK_STALE_INTERVALS,
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
   DAEMON_CHANNEL_DELIVERY_META_KEY,
@@ -44,8 +54,9 @@ import {
   TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD,
   TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
   WORKTREE_MCP_DEFER_META_KEY,
+  clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt
-} from "./chunk-R574ATRM.js";
+} from "./chunk-M2PNLYGY.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -100,7 +111,7 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-BFSQBXHV.js";
+} from "./chunk-GXSNGY5M.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
@@ -109,7 +120,7 @@ import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-XCG76UE6.js";
+} from "./chunk-3PY4LPJF.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1580,6 +1591,42 @@ var MultiClientPermissionMediator = class {
 };
 
 // packages/acp-bridge/src/bridgeClient.ts
+function parseActiveWorkSnapshot(params) {
+  const seq = params["seq"];
+  const sessions = params["sessions"];
+  if (params["v"] !== ACTIVE_WORK_HEARTBEAT_VERSION || typeof seq !== "number" || !Number.isSafeInteger(seq) || seq <= 0 || !Array.isArray(sessions) || sessions.length > ACTIVE_WORK_MAX_SNAPSHOT_SESSIONS) {
+    return void 0;
+  }
+  const parsed = [];
+  for (const raw of sessions) {
+    if (typeof raw !== "object" || raw === null) return void 0;
+    const entry = raw;
+    const sessionId = entry["sessionId"];
+    const holds = entry["holds"];
+    if (typeof sessionId !== "string" || !Array.isArray(holds) || holds.length > ACTIVE_WORK_MAX_SESSION_HOLDS) {
+      return void 0;
+    }
+    const parsedHolds = [];
+    for (const rawHold of holds) {
+      if (typeof rawHold !== "object" || rawHold === null) return void 0;
+      const hold = rawHold;
+      const category = hold["category"];
+      const id = hold["id"];
+      if (typeof id !== "string" || typeof category !== "string" || !ACTIVE_WORK_HOLD_CATEGORIES.includes(
+        category
+      )) {
+        return void 0;
+      }
+      parsedHolds.push({
+        category,
+        id
+      });
+    }
+    parsed.push({ sessionId, holds: parsedHolds });
+  }
+  return { v: ACTIVE_WORK_HEARTBEAT_VERSION, seq, sessions: parsed };
+}
+__name(parseActiveWorkSnapshot, "parseActiveWorkSnapshot");
 var PUBLISH_ARTIFACT_TOOL_NAME = "artifact";
 var MAX_CHANNEL_DELIVERY_TEXT_CHARS = 1e5;
 var MAX_CHANNEL_DELIVERY_FIELD_CHARS = 2048;
@@ -1840,7 +1887,7 @@ function sliceLineRange(content, startLine, endLine) {
 }
 __name(sliceLineRange, "sliceLineRange");
 var BridgeClient = class {
-  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent, onWorkspaceGenerationEvent, onChannelDelivery, hasSessionSpawnInFlight = () => false, getLiveScreenContextCaptureHandler = () => void 0, getLiveTaskToolRequestHandler = () => void 0, getLiveSpeakToUserHandler = () => void 0, externalToolGuard) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent, onWorkspaceGenerationEvent, onChannelDelivery, hasSessionSpawnInFlight = () => false, getLiveScreenContextCaptureHandler = () => void 0, getLiveTaskToolRequestHandler = () => void 0, getLiveSpeakToUserHandler = () => void 0, externalToolGuard, onActiveWork) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -1861,6 +1908,7 @@ var BridgeClient = class {
     this.getLiveTaskToolRequestHandler = getLiveTaskToolRequestHandler;
     this.getLiveSpeakToUserHandler = getLiveSpeakToUserHandler;
     this.externalToolGuard = externalToolGuard;
+    this.onActiveWork = onActiveWork;
   }
   static {
     __name(this, "BridgeClient");
@@ -2581,6 +2629,19 @@ var BridgeClient = class {
    * forward-compat.
    */
   async extNotification(method, params) {
+    if (method === ACTIVE_WORK_NOTIFICATION_METHOD) {
+      const snapshot = parseActiveWorkSnapshot(params);
+      if (snapshot) {
+        this.onActiveWork?.({
+          v: ACTIVE_WORK_HEARTBEAT_VERSION,
+          seq: snapshot.seq,
+          sessions: snapshot.sessions.filter(
+            (session) => this.ownsSession(session.sessionId)
+          )
+        });
+      }
+      return;
+    }
     if (method === "_qwencode/end_turn") {
       const sessionId2 = params["sessionId"];
       const reason = params["reason"];
@@ -6207,6 +6268,149 @@ function createAcpSessionBridge(opts) {
     lastActivityTimestamp = Date.now();
   }
   __name(touchActivity, "touchActivity");
+  function entryHasLocalWork(entry) {
+    return entry.pendingPromptCount > 0 || entry.pendingAgentNotificationCount > 0;
+  }
+  __name(entryHasLocalWork, "entryHasLocalWork");
+  function childHoldsAreFresh(entry, capability) {
+    if (entry.childHoldsAt === null) return false;
+    return Date.now() - entry.childHoldsAt <= capability.intervalMs * ACTIVE_WORK_STALE_INTERVALS;
+  }
+  __name(childHoldsAreFresh, "childHoldsAreFresh");
+  function childReportsHeldWork(entry) {
+    const owner = channelInfoForEntry(entry);
+    if (!owner?.activeWork) return false;
+    if (!childHoldsAreFresh(entry, owner.activeWork)) return false;
+    return entry.childHolds !== null && entry.childHolds.size > 0;
+  }
+  __name(childReportsHeldWork, "childReportsHeldWork");
+  function childWorkIsUnknown(entry) {
+    const owner = channelInfoForEntry(entry);
+    if (!owner?.activeWork) return false;
+    return !childHoldsAreFresh(entry, owner.activeWork);
+  }
+  __name(childWorkIsUnknown, "childWorkIsUnknown");
+  function entryHasActiveWork(entry) {
+    return entryHasLocalWork(entry) || childReportsHeldWork(entry) || childWorkIsUnknown(entry);
+  }
+  __name(entryHasActiveWork, "entryHasActiveWork");
+  function entryIsAutoCloseCandidate(entry) {
+    if (byId.get(entry.sessionId) !== entry) return false;
+    if (isClosingOrAuthorizingClose(entry)) return false;
+    if (entry.events.subscriberCount > 0) return false;
+    if (entryHasLocalWork(entry)) return false;
+    const owner = channelInfoForEntry(entry);
+    if (owner?.pendingRestoreIds.has(entry.sessionId)) return false;
+    return !childReportsHeldWork(entry);
+  }
+  __name(entryIsAutoCloseCandidate, "entryIsAutoCloseCandidate");
+  function isClosingOrAuthorizingClose(entry) {
+    return entry.closing || entry.activeWorkCloseInFlight;
+  }
+  __name(isClosingOrAuthorizingClose, "isClosingOrAuthorizingClose");
+  async function maybeCloseIdleSession(entry, reason) {
+    if (!entryIsAutoCloseCandidate(entry)) return;
+    if (entry.spawnOwnerWantedKill && entry.attachCount === 0) {
+      await bridgeApi.killSession(entry.sessionId).catch(() => {
+      });
+      return;
+    }
+    if (entry.clientIds.size > 0) return;
+    await closeIfChildUnheld(entry, {
+      trigger: reason,
+      closeReason: "last_client_detached"
+    });
+  }
+  __name(maybeCloseIdleSession, "maybeCloseIdleSession");
+  async function closeIfChildUnheld(entry, opts2) {
+    entry.activeWorkCloseInFlight = true;
+    try {
+      if (!await confirmChildUnheld(entry)) return;
+      if (byId.get(entry.sessionId) !== entry) return;
+      await closeSessionImpl(entry.sessionId, void 0, {
+        reason: opts2.closeReason
+      }).catch((err) => {
+        writeStderrLine(
+          `qwen serve: deferred close (${opts2.trigger}) failed for ${JSON.stringify(entry.sessionId)}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+        );
+      });
+    } finally {
+      entry.activeWorkCloseInFlight = false;
+    }
+  }
+  __name(closeIfChildUnheld, "closeIfChildUnheld");
+  async function confirmChildUnheld(entry) {
+    const info = channelInfoForEntry(entry);
+    if (!info?.activeWork) return true;
+    if (info.isDying) return false;
+    try {
+      const response = await withTimeout(
+        entry.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionClose, {
+          sessionId: entry.sessionId,
+          [ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM]: true
+        }),
+        ACTIVE_WORK_CLOSE_TIMEOUT_MS,
+        SERVE_CONTROL_EXT_METHODS.sessionClose
+      );
+      if (response["closed"] === true) {
+        return true;
+      }
+      const holds = response["holds"];
+      if (Array.isArray(holds)) {
+        const adopted = /* @__PURE__ */ new Map();
+        for (const hold of holds) {
+          if (typeof hold !== "object" || hold === null) continue;
+          const record = hold;
+          const id = record["id"];
+          const category = record["category"];
+          if (typeof id === "string" && typeof category === "string" && ACTIVE_WORK_HOLD_CATEGORIES.includes(
+            category
+          )) {
+            adopted.set(id, category);
+          }
+        }
+        entry.childHolds = adopted;
+        entry.childHoldsAt = Date.now();
+      }
+      return false;
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: close-if-unheld for session ${JSON.stringify(entry.sessionId)} did not resolve (${err instanceof Error ? err.message : String(err)}); leaving it in place for the next snapshot to settle`
+      );
+      return false;
+    }
+  }
+  __name(confirmChildUnheld, "confirmChildUnheld");
+  function applyActiveWorkSnapshot(info, snapshot) {
+    if (!info.activeWork || info.isDying) return;
+    if (snapshot.seq <= info.activeWork.seq) return;
+    info.activeWork.seq = snapshot.seq;
+    const now = Date.now();
+    const reported = /* @__PURE__ */ new Map();
+    for (const session of snapshot.sessions) {
+      const holds = /* @__PURE__ */ new Map();
+      for (const hold of session.holds) holds.set(hold.id, hold.category);
+      reported.set(session.sessionId, holds);
+    }
+    for (const sessionId of Array.from(info.sessionIds)) {
+      const entry = byId.get(sessionId);
+      if (!entry || entry.channel !== info.channel) continue;
+      const holds = reported.get(sessionId) ?? /* @__PURE__ */ new Map();
+      const previouslyHeld = entry.childHolds ? entry.childHolds.size > 0 : void 0;
+      entry.childHolds = holds;
+      entry.childHoldsAt = now;
+      if (previouslyHeld !== void 0 && previouslyHeld !== holds.size > 0) {
+        touchActivity();
+      }
+      if (holds.size === 0) {
+        void maybeCloseIdleSession(
+          entry,
+          reported.has(sessionId) ? "child_idle" : "child_dropped"
+        );
+      }
+    }
+  }
+  __name(applyActiveWorkSnapshot, "applyActiveWorkSnapshot");
   function settleActivePromptState(entry, promptId) {
     if (entry.activePromptId !== promptId) return;
     delete entry.activePromptId;
@@ -6335,21 +6539,17 @@ function createAcpSessionBridge(opts) {
       if (shuttingDown) return;
       const now = Date.now();
       for (const [id, entry] of byId) {
-        if (entry.pendingPromptCount > 0) continue;
-        if (entry.events.subscriberCount > 0) continue;
+        if (!entryIsAutoCloseCandidate(entry)) continue;
         const lastActive = entry.sessionLastSeenAt ?? Date.parse(entry.createdAt);
         const idle = now - lastActive;
         if (idle < sessionIdleTimeoutMs) continue;
         writeStderrLine(
           `qwen serve: reaping idle session ${JSON.stringify(id)} (idle for ${Math.round(idle / 1e3)}s, threshold ${Math.round(sessionIdleTimeoutMs / 1e3)}s)`
         );
-        void closeSessionImpl(id, void 0, { reason: "idle_timeout" }).catch(
-          (err) => {
-            writeStderrLine(
-              `qwen serve: session reaper failed to close ${JSON.stringify(id)}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
-            );
-          }
-        );
+        void closeIfChildUnheld(entry, {
+          trigger: "idle_timeout",
+          closeReason: "idle_timeout"
+        });
       }
     }, sessionReapIntervalMs);
     sessionReaper.unref();
@@ -6523,18 +6723,7 @@ function createAcpSessionBridge(opts) {
       entry.attachCount - (released + (attachCountDelta - 1))
     );
     unregisterClient(entry, clientId);
-    if (entry.spawnOwnerWantedKill && entry.attachCount === 0 && entry.events.subscriberCount === 0) {
-      await bridgeApi.killSession(entry.sessionId).catch(() => {
-      });
-    } else if (entry.clientIds.size === 0 && entry.events.subscriberCount === 0 && entry.pendingPromptCount === 0) {
-      await closeSessionImpl(entry.sessionId, void 0, {
-        reason: "last_client_detached"
-      }).catch((err) => {
-        writeStderrLine(
-          `qwen serve: close-on-attach-rollback failed for ${JSON.stringify(entry.sessionId)}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
-        );
-      });
-    }
+    await maybeCloseIdleSession(entry, "attach_rollback");
   }, "rollbackAttachRegistration");
   const resolveTrustedClientId = /* @__PURE__ */ __name((entry, clientId) => {
     if (clientId === void 0) return void 0;
@@ -6563,6 +6752,7 @@ function createAcpSessionBridge(opts) {
         })
       );
       const sessionIds = /* @__PURE__ */ new Set();
+      const infoRef = {};
       let client;
       let connection;
       try {
@@ -6664,7 +6854,12 @@ function createAcpSessionBridge(opts) {
           () => liveScreenContextCaptureHandler,
           () => liveTaskToolRequestHandler,
           () => liveSpeakToUserHandler,
-          opts.externalToolGuard
+          opts.externalToolGuard,
+          (snapshot) => {
+            const currentInfo = infoRef.current;
+            if (!currentInfo) return;
+            applyActiveWorkSnapshot(currentInfo, snapshot);
+          }
         );
         connection = new ClientSideConnection(() => client, channel.stream);
       } catch (error) {
@@ -6702,6 +6897,7 @@ function createAcpSessionBridge(opts) {
         isDying: false,
         handshakeComplete: false
       };
+      infoRef.current = info;
       aliveChannels.add(info);
       if (aliveChannels.size > 2) {
         writeStderrLine(
@@ -6789,6 +6985,10 @@ function createAcpSessionBridge(opts) {
               connection.initialize({
                 protocolVersion: PROTOCOL_VERSION,
                 _meta: {
+                  [ACTIVE_WORK_HEARTBEAT_META_KEY]: {
+                    v: ACTIVE_WORK_HEARTBEAT_VERSION,
+                    intervalMs: ACTIVE_WORK_HEARTBEAT_INTERVAL_MS
+                  },
                   [CHANNEL_STARTUP_PROFILE_META_KEY]: {
                     v: CHANNEL_STARTUP_PROFILE_VERSION
                   },
@@ -6813,6 +7013,19 @@ function createAcpSessionBridge(opts) {
                 );
               }
             }
+            const activeWorkCapability = isRecord3(response._meta) ? response._meta[ACTIVE_WORK_HEARTBEAT_META_KEY] : void 0;
+            if (isRecord3(activeWorkCapability) && activeWorkCapability["v"] === ACTIVE_WORK_HEARTBEAT_VERSION) {
+              const advertised = activeWorkCapability["categories"];
+              info.activeWork = {
+                intervalMs: clampActiveWorkIntervalMs(
+                  activeWorkCapability["intervalMs"]
+                ),
+                categories: Array.isArray(advertised) ? ACTIVE_WORK_HOLD_CATEGORIES.filter(
+                  (category) => advertised.includes(category)
+                ) : [],
+                seq: 0
+              };
+            }
             try {
               const attributes = getChannelStartupProfileAttributes(
                 response,
@@ -7697,6 +7910,7 @@ function createAcpSessionBridge(opts) {
       cwdChangeQueue: Promise.resolve(),
       promptQueue: Promise.resolve(),
       pendingPromptCount: 0,
+      pendingAgentNotificationCount: 0,
       pendingPromptList: [],
       midTurnMessageQueue: [],
       modelChangeQueue: Promise.resolve(),
@@ -7711,6 +7925,9 @@ function createAcpSessionBridge(opts) {
       attachRefs: /* @__PURE__ */ new Map(),
       spawnOwnerWantedKill: false,
       promptActive: false,
+      childHolds: null,
+      childHoldsAt: null,
+      activeWorkCloseInFlight: false,
       retryAllowed: false
     };
     ci.sessionIds.add(entry.sessionId);
@@ -8021,7 +8238,7 @@ function createAcpSessionBridge(opts) {
     const hideInheritedHistory = action === "load" && req.hideInheritedHistory === true;
     const existing = byId.get(req.sessionId);
     if (existing) {
-      if (existing.closing) {
+      if (isClosingOrAuthorizingClose(existing)) {
         throw new SessionNotFoundError(
           req.sessionId,
           "The session is closing; retry after close completes"
@@ -8029,7 +8246,7 @@ function createAcpSessionBridge(opts) {
       }
       const replayFields = action === "load" && req.historyPageSize !== void 0 ? await refreshedReplayFieldsFor(existing, req.historyPageSize) : replayFieldsFor(existing, action);
       const historyAnchorRecordId = action === "load" ? await resolveHistoryAnchorRecordId(existing, replayFields) : void 0;
-      if (byId.get(req.sessionId) !== existing || existing.closing) {
+      if (byId.get(req.sessionId) !== existing || isClosingOrAuthorizingClose(existing)) {
         throw new SessionNotFoundError(req.sessionId);
       }
       existing.attachCount++;
@@ -8216,6 +8433,12 @@ function createAcpSessionBridge(opts) {
       const racedEntry = byId.get(req.sessionId);
       if (racedEntry) {
         restoreEvents.close();
+        if (isClosingOrAuthorizingClose(racedEntry)) {
+          throw new SessionNotFoundError(
+            req.sessionId,
+            "The session is closing; retry after close completes"
+          );
+        }
         racedEntry.attachCount += 1 + coalesceState.count;
         const clientId2 = registerClient(racedEntry, req.clientId);
         recordAttachRef(racedEntry, clientId2);
@@ -8537,6 +8760,44 @@ function createAcpSessionBridge(opts) {
     get activePromptCount() {
       return activePromptCounter;
     },
+    get activeWork() {
+      for (const entry of byId.values()) {
+        if (entryHasActiveWork(entry)) return true;
+      }
+      return false;
+    },
+    /**
+     * Raw coverage counts rather than a pre-collapsed grade.
+     *
+     * The grade has to be computed over the whole daemon, not per runtime and
+     * then combined: a runtime with zero Sessions is vacuously `full`, and
+     * folding that in as evidence made a deployment whose only real Sessions
+     * were unreported aggregate to `partial`. Counts compose; grades do not.
+     */
+    get activeWorkCoverage() {
+      let covered = 0;
+      let onNegotiatedChannel = 0;
+      let total = 0;
+      let oldestCoveredReportAt = null;
+      for (const entry of byId.values()) {
+        total++;
+        const owner = channelInfoForEntry(entry);
+        const capability = owner?.activeWork;
+        if (!capability) continue;
+        onNegotiatedChannel++;
+        if (ACTIVE_WORK_HOLD_CATEGORIES.some(
+          (category) => !capability.categories.includes(category)
+        )) {
+          continue;
+        }
+        if (!childHoldsAreFresh(entry, capability)) continue;
+        covered++;
+        if (entry.childHoldsAt !== null && (oldestCoveredReportAt === null || entry.childHoldsAt < oldestCoveredReportAt)) {
+          oldestCoveredReportAt = entry.childHoldsAt;
+        }
+      }
+      return { total, covered, onNegotiatedChannel, oldestCoveredReportAt };
+    },
     get lastActivityAt() {
       return lastActivityTimestamp;
     },
@@ -8579,7 +8840,7 @@ function createAcpSessionBridge(opts) {
       if (effectiveScope === "single") {
         const existing = defaultEntry;
         if (existing) {
-          if (existing.closing) {
+          if (isClosingOrAuthorizingClose(existing)) {
             throw new SessionNotFoundError(
               existing.sessionId,
               "The session is closing; retry after close completes"
@@ -8699,7 +8960,7 @@ function createAcpSessionBridge(opts) {
       const queuedAt = Date.now();
       const entry = byId.get(sessionId);
       if (!entry) return Promise.reject(new SessionNotFoundError(sessionId));
-      if (entry.closing) {
+      if (isClosingOrAuthorizingClose(entry)) {
         return Promise.reject(
           new SessionNotFoundError(
             sessionId,
@@ -9076,15 +9337,7 @@ function createAcpSessionBridge(opts) {
           );
           entry.midTurnMessageQueue.length = 0;
         }
-        if (entry.clientIds.size === 0 && entry.events.subscriberCount === 0 && entry.pendingPromptCount === 0 && byId.get(sessionId) === entry) {
-          void closeSessionImpl(sessionId, void 0, {
-            reason: "last_client_detached"
-          }).catch((err) => {
-            writeStderrLine(
-              `qwen serve: deferred close-on-prompt-complete failed for ${JSON.stringify(sessionId)}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
-            );
-          });
-        }
+        void maybeCloseIdleSession(entry, "prompt_settled");
       }).catch(() => {
       });
       return result;
@@ -10405,18 +10658,27 @@ function createAcpSessionBridge(opts) {
       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(
-            SERVE_CONTROL_EXT_METHODS.sessionBackgroundNotification,
-            { sessionId, ...notification }
+      entry.pendingAgentNotificationCount++;
+      try {
+        const response = await Promise.race([
+          withTimeout(
+            entry.connection.extMethod(
+              SERVE_CONTROL_EXT_METHODS.sessionBackgroundNotification,
+              { sessionId, ...notification }
+            ),
+            initTimeoutMs,
+            SERVE_CONTROL_EXT_METHODS.sessionBackgroundNotification
           ),
-          initTimeoutMs,
-          SERVE_CONTROL_EXT_METHODS.sessionBackgroundNotification
-        ),
-        getTransportClosedReject(entry)
-      ]);
-      return { sessionId, accepted: response["accepted"] === true };
+          getTransportClosedReject(entry)
+        ]);
+        return { sessionId, accepted: response["accepted"] === true };
+      } finally {
+        entry.pendingAgentNotificationCount = Math.max(
+          0,
+          entry.pendingAgentNotificationCount - 1
+        );
+        void maybeCloseIdleSession(entry, "agent_notification_settled");
+      }
     },
     async generateSessionBtw(sessionId, question, signal, _context) {
       const entry = byId.get(sessionId);
@@ -10657,7 +10919,7 @@ function createAcpSessionBridge(opts) {
     async rewindSession(sessionId, req, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
-      if (entry.closing) {
+      if (isClosingOrAuthorizingClose(entry)) {
         throw new SessionNotFoundError(sessionId, "The session is closing");
       }
       const info = channelInfoForEntry(entry);
@@ -11147,18 +11409,7 @@ function createAcpSessionBridge(opts) {
         if (entry.attachCount > 0) entry.attachCount--;
       }
       unregisterClient(entry, clientId);
-      if (entry.spawnOwnerWantedKill && entry.attachCount === 0 && entry.events.subscriberCount === 0) {
-        await this.killSession(sessionId).catch(() => {
-        });
-      } else if (entry.clientIds.size === 0 && entry.events.subscriberCount === 0 && entry.pendingPromptCount === 0) {
-        await closeSessionImpl(sessionId, void 0, {
-          reason: "last_client_detached"
-        }).catch((err) => {
-          writeStderrLine(
-            `qwen serve: close-on-last-detach failed for ${JSON.stringify(sessionId)}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
-          );
-        });
-      }
+      await maybeCloseIdleSession(entry, "last_client_detached");
     },
     killAllSync() {
       shuttingDown = true;

package/chunks/{chunk-XIDHBXUI.js → chunk-GBDINRIL.js}

@@ -3,13 +3,13 @@
 import {
   resolveModelConfig,
   resolveProviderProtocol
-} from "./chunk-BFSQBXHV.js";
+} from "./chunk-GXSNGY5M.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-RGTB44BO.js";
+} from "./chunk-VXZ5HAOV.js";
 import {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort
@@ -17,7 +17,7 @@ import {
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-P7HUJDBZ.js";
+} from "./chunk-M3STHEMM.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-Z5ZAWED3.js → chunk-GOEVOFQI.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   t
-} from "./chunk-TAOSTUHI.js";
+} from "./chunk-PG62DFWD.js";
 import {
   computeThresholds,
   getCoreSystemPrompt,
   resolveInteractionMode
-} from "./chunk-BFSQBXHV.js";
+} from "./chunk-GXSNGY5M.js";
 import {
   buildSkillLlmContent
 } from "./chunk-K623ENWT.js";
 import {
   DiscoveredMCPTool,
   uiTelemetryService
-} from "./chunk-XCG76UE6.js";
+} from "./chunk-3PY4LPJF.js";
 import {
   ToolNames
 } from "./chunk-PYQADEFD.js";

package/chunks/{chunk-ZKUJ4AO7.js → chunk-GQCEQPYQ.js}

@@ -2,17 +2,17 @@
 "use strict";
 import {
   performStandaloneUpdate
-} from "./chunk-RFA6VDCR.js";
+} from "./chunk-ZHA242R4.js";
 import {
   updateEventEmitter
 } from "./chunk-YAF2MQZ6.js";
 import {
   t
-} from "./chunk-TAOSTUHI.js";
+} from "./chunk-PG62DFWD.js";
 import {
   getInstallationInfo,
   resolveUpdateCommand
-} from "./chunk-SDUDZNF4.js";
+} from "./chunk-IUQ52YJK.js";
 import {
   createDebugLogger
 } from "./chunk-OIVKILPI.js";