@qwen-code/qwen-code 0.21.7 → 0.21.8-nightly.20260810.55e20db328

package/chunks/{chunk-LA7YLSR6.js → chunk-4EOURKA4.js}

@@ -17,17 +17,28 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-E33LOKRA.js";
+} from "./chunk-I5VM3SKY.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
   SERVE_CONTROL_EXT_METHODS,
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
+  SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-NLREQJFK.js";
+} from "./chunk-DA4HRSBW.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,10 +55,12 @@ 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,
+  BridgeChannelQuarantinedError,
   CancelSentinelCollisionError,
   CdWhilePromptActiveError,
   InvalidClientIdError,
@@ -66,7 +79,7 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-J26HHFI5.js";
+} from "./chunk-LP2QGNSP.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
@@ -100,16 +113,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-47ZUMGGY.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-L4N6TIP7.js";
+} from "./chunk-4TRQPFDP.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-2U3WZGZG.js";
+} from "./chunk-YGT2AUJ7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -751,6 +764,46 @@ function mergeTranscriptUpdateMeta(existing, incoming) {
 }
 __name(mergeTranscriptUpdateMeta, "mergeTranscriptUpdateMeta");
 
+// packages/acp-bridge/src/session-restore-timeout.ts
+init_esbuild_shims();
+var DEFAULT_SESSION_RESTORE_TIMEOUT_MS = 6e4;
+var MAX_SESSION_RESTORE_TIMEOUT_MS = 2147483647;
+var MIN_RESTORE_RETRY_AFTER_SECONDS = 5;
+var MAX_RESTORE_RETRY_AFTER_SECONDS = 120;
+function restoreRetryAfterSeconds(timeoutMs) {
+  return Math.min(
+    MAX_RESTORE_RETRY_AFTER_SECONDS,
+    Math.max(MIN_RESTORE_RETRY_AFTER_SECONDS, Math.ceil(timeoutMs / 1e3))
+  );
+}
+__name(restoreRetryAfterSeconds, "restoreRetryAfterSeconds");
+function assertValidTimeoutMs(field, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || !Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_SESSION_RESTORE_TIMEOUT_MS) {
+    throw new TypeError(
+      `Invalid ${field}: ${timeoutMs}. Must be a positive integer no greater than ${MAX_SESSION_RESTORE_TIMEOUT_MS}.`
+    );
+  }
+}
+__name(assertValidTimeoutMs, "assertValidTimeoutMs");
+function resolveSessionRestoreTimeoutMs(opts) {
+  if (opts.sessionRestoreTimeoutMs !== void 0) {
+    assertValidTimeoutMs(
+      "sessionRestoreTimeoutMs",
+      opts.sessionRestoreTimeoutMs
+    );
+    return opts.sessionRestoreTimeoutMs;
+  }
+  if (opts.initializeTimeoutMs !== void 0) {
+    assertValidTimeoutMs("initializeTimeoutMs", opts.initializeTimeoutMs);
+    return Math.max(
+      opts.initializeTimeoutMs,
+      DEFAULT_SESSION_RESTORE_TIMEOUT_MS
+    );
+  }
+  return DEFAULT_SESSION_RESTORE_TIMEOUT_MS;
+}
+__name(resolveSessionRestoreTimeoutMs, "resolveSessionRestoreTimeoutMs");
+
 // packages/acp-bridge/src/session-source.ts
 init_esbuild_shims();
 var SESSION_SOURCE_META_KEY = "qwen.session.source";
@@ -1580,6 +1633,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 +1929,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 +1950,7 @@ var BridgeClient = class {
     this.getLiveTaskToolRequestHandler = getLiveTaskToolRequestHandler;
     this.getLiveSpeakToUserHandler = getLiveSpeakToUserHandler;
     this.externalToolGuard = externalToolGuard;
+    this.onActiveWork = onActiveWork;
   }
   static {
     __name(this, "BridgeClient");
@@ -1929,6 +2019,9 @@ var BridgeClient = class {
     }
   }
   async sessionUpdate(params) {
+    if (this.abandonedRestoreIds.has(params.sessionId)) {
+      return;
+    }
     if (!this.ownsSession(params.sessionId) && !this.inFlightRestoreIds.has(params.sessionId)) {
       writeStderrLine(
         `[demux] session=${params.sessionId} type=session_update action=dropped reason=session_not_owned`
@@ -2099,22 +2192,19 @@ var BridgeClient = class {
    *   stale frame for that id anywhere in the system.
    */
   tombstonedSessionIds = /* @__PURE__ */ new Map();
+  /** Restore ownership for `sessionUpdate` and artifact demultiplexing. */
+  inFlightRestoreIds = /* @__PURE__ */ new Set();
   /**
-   * Allow-list of sessionIds currently being restored via
-   * `session/load` / `session/resume`. Bypasses the tombstone check
-   * in `bufferEarlyEvent` so restore-time events for a
-   * previously-closed id flow through to the future
-   * `createSessionEntry -> drainEarlyEvents` call.
-   *
-   * Without this, the tombstone set before a future `load` can clear
-   * it via `drainEarlyEvents` would silently drop legitimate
-   * restore-time events (e.g. MCP discovery budget events firing
-   * during the ACP call window).
-   *
-   * Bridge factory enters the set before awaiting the ACP restore
-   * call and exits on settle (success or failure).
+   * Registrations allowed to buffer early extended notifications through an
+   * ordinary close tombstone. This includes restores and caller-supplied-id
+   * spawns, and lasts only until their ACP registration attempt settles.
    */
-  inFlightRestoreIds = /* @__PURE__ */ new Set();
+  inFlightSessionRegistrationIds = /* @__PURE__ */ new Set();
+  /**
+   * Restore ids whose caller timed out while the non-cancellable ACP request
+   * continues.
+   */
+  abandonedRestoreIds = /* @__PURE__ */ new Set();
   /**
    * Handle child->bridge ACP `extMethod` requests (calls that expect a
    * response, unlike `extNotification`). Served methods:
@@ -2581,6 +2671,23 @@ var BridgeClient = class {
    * forward-compat.
    */
   async extNotification(method, params) {
+    const notificationSessionId = params["sessionId"];
+    if (typeof notificationSessionId === "string" && this.abandonedRestoreIds.has(notificationSessionId)) {
+      return;
+    }
+    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"];
@@ -2846,6 +2953,9 @@ var BridgeClient = class {
     }
   }
   publishExtNotification(sessionId, type, data, turnScoped = false) {
+    if (this.abandonedRestoreIds.has(sessionId)) {
+      return;
+    }
     const entry = this.resolveEntry(sessionId);
     const frame = {
       type,
@@ -2991,9 +3101,12 @@ var BridgeClient = class {
    * dropped to bound per-session memory.
    */
   bufferEarlyEvent(sessionId, frame) {
+    if (this.abandonedRestoreIds.has(sessionId)) {
+      return;
+    }
     const now = Date.now();
     this.sweepExpiredTombstones(now);
-    if (this.tombstonedSessionIds.has(sessionId) && !this.inFlightRestoreIds.has(sessionId)) {
+    if (this.tombstonedSessionIds.has(sessionId) && !this.inFlightSessionRegistrationIds.has(sessionId)) {
       writeStderrLine(
         `qwen serve: dropping early extNotification for tombstoned session ${JSON.stringify(sessionId)} (post-close stale event)`
       );
@@ -3055,8 +3168,31 @@ var BridgeClient = class {
    * failed restore doesn't leave a dangling allow-list entry.
    */
   markRestoreInFlight(sessionId) {
+    this.markSessionRegistrationInFlight(sessionId);
     this.inFlightRestoreIds.add(sessionId);
   }
+  /**
+   * Transfer an id from closed/abandoned ownership to a new registration
+   * attempt before its ACP call starts. The in-flight allow-list is what lets
+   * legitimate early notifications bypass the ordinary close tombstone until
+   * `createSessionEntry` can drain them.
+   */
+  markSessionRegistrationInFlight(sessionId) {
+    this.clearAbandonedRestoreFence(sessionId);
+    this.inFlightSessionRegistrationIds.add(sessionId);
+  }
+  /**
+   * Drop the abandoned-restore fence for `sessionId`.
+   *
+   * The fence has no TTL and suppresses session updates, guardrail events,
+   * and child notifications, so it must not outlive the abandoned attempt it
+   * was raised for. The bridge clears it whenever a legitimate owner takes
+   * the id — a new restore, or `createSessionEntry` registering a session
+   * from any other route.
+   */
+  clearAbandonedRestoreFence(sessionId) {
+    this.abandonedRestoreIds.delete(sessionId);
+  }
   /**
    * Companion to `markRestoreInFlight`. Bridge factory calls this when
    * the restore IIFE settles — after `createSessionEntry` runs
@@ -3065,6 +3201,16 @@ var BridgeClient = class {
    */
   clearRestoreInFlight(sessionId) {
     this.inFlightRestoreIds.delete(sessionId);
+    this.clearSessionRegistrationInFlight(sessionId);
+  }
+  clearSessionRegistrationInFlight(sessionId) {
+    this.inFlightSessionRegistrationIds.delete(sessionId);
+  }
+  markRestoreAbandoned(sessionId) {
+    this.inFlightRestoreIds.delete(sessionId);
+    this.inFlightSessionRegistrationIds.delete(sessionId);
+    this.abandonedRestoreIds.add(sessionId);
+    this.earlyEvents.delete(sessionId);
   }
   /**
    * Drain any frames buffered for `sessionId` onto `entry.events`.
@@ -6094,6 +6240,7 @@ function createAcpSessionBridge(opts) {
   let liveTaskToolRequestHandler;
   let liveSpeakToUserHandler;
   const defaultSessionScope = opts.sessionScope ?? "single";
+  const delegateReadTextFileToClient = opts.delegateReadTextFileToClient ?? true;
   let maxSessions;
   if (opts.maxSessions === void 0) {
     maxSessions = DEFAULT_MAX_SESSIONS;
@@ -6110,7 +6257,31 @@ function createAcpSessionBridge(opts) {
   } else {
     maxSessions = opts.maxSessions;
   }
-  const reserveFreshSession = /* @__PURE__ */ __name((context) => opts.freshSessionAdmission?.(context), "reserveFreshSession");
+  const freshSessionBlocker = /* @__PURE__ */ __name(() => {
+    for (const ci of aliveChannels) {
+      if (ci.isDying) continue;
+      if (ci.isQuarantined) {
+        return { channel: ci, reason: "restore_cleanup_failed" };
+      }
+      if (ci.restoreSettlementOverdue) {
+        return { channel: ci, reason: "restore_settlement_overdue" };
+      }
+    }
+    return void 0;
+  }, "freshSessionBlocker");
+  const assertFreshSessionsAvailable = /* @__PURE__ */ __name(() => {
+    const blocker = freshSessionBlocker();
+    if (blocker) {
+      throw new BridgeChannelQuarantinedError(
+        blocker.reason,
+        abandonedRestoreRetryAfterSeconds
+      );
+    }
+  }, "assertFreshSessionsAvailable");
+  const reserveFreshSession = /* @__PURE__ */ __name((context) => {
+    assertFreshSessionsAvailable();
+    return opts.freshSessionAdmission?.(context);
+  }, "reserveFreshSession");
   const releaseFreshSessionReservation = /* @__PURE__ */ __name((reservation) => {
     if (!reservation) return;
     try {
@@ -6155,6 +6326,11 @@ function createAcpSessionBridge(opts) {
       `Invalid initializeTimeoutMs: ${initTimeoutMs}. Must be > 0.`
     );
   }
+  const sessionRestoreTimeoutMs = resolveSessionRestoreTimeoutMs(opts);
+  const restoreSettlementGraceMs = sessionRestoreTimeoutMs;
+  const abandonedRestoreRetryAfterSeconds = restoreRetryAfterSeconds(
+    sessionRestoreTimeoutMs
+  );
   const permissionTimeoutRaw = opts.permissionResponseTimeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
   const permissionTimeoutMs = permissionTimeoutRaw > 0 && Number.isFinite(permissionTimeoutRaw) ? (
     // Clamp to 2^31-1: Node treats setTimeout delays larger than
@@ -6206,6 +6382,153 @@ 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;
+      const condemnedOwner = channelInfoForEntry(entry);
+      const agentCloseTimeoutMs = condemnedOwner?.isQuarantined === true || condemnedOwner?.restoreSettlementOverdue === true ? ACTIVE_WORK_CLOSE_TIMEOUT_MS : void 0;
+      await closeSessionImpl(entry.sessionId, void 0, {
+        reason: opts2.closeReason,
+        ...agentCloseTimeoutMs !== void 0 ? { agentCloseTimeoutMs } : {}
+      }).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;
+    if (info.isQuarantined || info.restoreSettlementOverdue) return true;
+    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;
@@ -6301,8 +6624,35 @@ function createAcpSessionBridge(opts) {
     workspaceMcpResourcesCache.delete(serverName);
   }
   __name(invalidateWorkspaceMcpDetailCache, "invalidateWorkspaceMcpDetailCache");
+  function channelShouldReapWhenIdle(ci) {
+    return ci.emptyReapPending || ci.unsettledAbandonedRestores.size > 0 || ci.isQuarantined;
+  }
+  __name(channelShouldReapWhenIdle, "channelShouldReapWhenIdle");
+  function armRestoreSettlementGrace(ci, sessionId, action) {
+    if (ci.restoreSettlementTimers.has(sessionId)) return;
+    const timer = setTimeout(() => {
+      ci.restoreSettlementTimers.delete(sessionId);
+      if (!ci.unsettledAbandonedRestores.has(sessionId)) return;
+      if (ci.isDying || !aliveChannels.has(ci)) return;
+      ci.restoreSettlementOverdue = true;
+      writeStderrLine(
+        `qwen serve: abandoned session/${action} for ${JSON.stringify(sessionId)} has not settled ${restoreSettlementGraceMs}ms after its deadline; refusing fresh sessions on channel ${ci.id} until it drains`
+      );
+      telemetry.event("session.restore.settlement_overdue", {
+        "qwen-code.daemon.session_restore.action": action,
+        "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+        "qwen-code.daemon.session_restore.settlement_grace_ms": restoreSettlementGraceMs,
+        "qwen-code.daemon.acp_channel.id": ci.id,
+        "session.id": sessionId
+      });
+      void reapPendingEmptyChannel(ci);
+    }, restoreSettlementGraceMs);
+    timer.unref();
+    ci.restoreSettlementTimers.set(sessionId, timer);
+  }
+  __name(armRestoreSettlementGrace, "armRestoreSettlementGrace");
   async function reapPendingEmptyChannel(ci) {
-    if (!ci.emptyReapPending || !hasNoChannelWork(ci)) return;
+    if (!channelShouldReapWhenIdle(ci) || !hasNoChannelWork(ci)) return;
     ci.emptyReapPending = false;
     ci.isDying = true;
     await ci.channel.kill().catch(() => {
@@ -6334,21 +6684,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();
@@ -6476,6 +6822,7 @@ function createAcpSessionBridge(opts) {
     }
   }, "teeServeDebugLine");
   const inFlightSpawns = /* @__PURE__ */ new Map();
+  const inFlightRequestedSessionSpawns = /* @__PURE__ */ new Map();
   const inFlightRestores = /* @__PURE__ */ new Map();
   const pendingRestoreEvents = /* @__PURE__ */ new Map();
   const createClientId = /* @__PURE__ */ __name(() => `client_${randomUUID2()}`, "createClientId");
@@ -6522,18 +6869,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;
@@ -6562,6 +6898,7 @@ function createAcpSessionBridge(opts) {
         })
       );
       const sessionIds = /* @__PURE__ */ new Set();
+      const infoRef = {};
       let client;
       let connection;
       try {
@@ -6663,7 +7000,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) {
@@ -6698,9 +7040,14 @@ function createAcpSessionBridge(opts) {
         workspaceMcpAuthenticationServerNames: /* @__PURE__ */ new Set(),
         workspaceMcpAuthenticationTimers: /* @__PURE__ */ new Map(),
         emptyReapPending: false,
+        unsettledAbandonedRestores: /* @__PURE__ */ new Set(),
+        restoreSettlementOverdue: false,
+        restoreSettlementTimers: /* @__PURE__ */ new Map(),
         isDying: false,
+        isQuarantined: false,
         handshakeComplete: false
       };
+      infoRef.current = info;
       aliveChannels.add(info);
       if (aliveChannels.size > 2) {
         writeStderrLine(
@@ -6718,6 +7065,10 @@ function createAcpSessionBridge(opts) {
         }
         info.workspaceMcpAuthenticationTimers.clear();
         info.workspaceMcpAuthenticationServerNames.clear();
+        for (const timer of info.restoreSettlementTimers.values()) {
+          clearTimeout(timer);
+        }
+        info.restoreSettlementTimers.clear();
         aliveChannels.delete(info);
         if (channelInfo === info) channelInfo = void 0;
         const sessions = Array.from(info.sessionIds);
@@ -6788,13 +7139,20 @@ 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
                   },
                   [PRIVATE_PARENT_CAPABILITY_META_KEY]: privateParentCapability
                 },
                 clientCapabilities: {
-                  fs: { readTextFile: true, writeTextFile: true }
+                  fs: {
+                    readTextFile: delegateReadTextFileToClient,
+                    writeTextFile: true
+                  }
                 },
                 clientInfo: { name: "qwen-serve-bridge", version: "0" }
               }),
@@ -6809,6 +7167,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,
@@ -6859,6 +7230,9 @@ function createAcpSessionBridge(opts) {
       ensureChannel
     );
     ci.sessionSpawnsInFlight++;
+    if (requestedSessionId !== void 0) {
+      ci.client.markSessionRegistrationInFlight(requestedSessionId);
+    }
     let sessionRegistered = false;
     let sessionRemovedDuringInitialization = false;
     let initializedSessionId;
@@ -7043,6 +7417,12 @@ function createAcpSessionBridge(opts) {
         ...entry.branch ? { branch: entry.branch } : {}
       };
     } finally {
+      if (requestedSessionId !== void 0) {
+        ci.client.clearSessionRegistrationInFlight(requestedSessionId);
+        if (initializedSessionId !== requestedSessionId && !byId.has(requestedSessionId)) {
+          ci.client.markSessionClosed(requestedSessionId);
+        }
+      }
       ci.sessionSpawnsInFlight = Math.max(0, ci.sessionSpawnsInFlight - 1);
       if (!sessionRegistered) {
         await reapPendingEmptyChannel(ci);
@@ -7457,12 +7837,17 @@ function createAcpSessionBridge(opts) {
   const getChildResourceSnapshot = /* @__PURE__ */ __name(() => {
     const info = liveChannelInfo();
     if (!info || info.childResourceAt === void 0) return void 0;
-    if (Date.now() - info.childResourceAt > STALE_CHILD_RESOURCE_MS) {
+    const ageMs = Date.now() - info.childResourceAt;
+    if (ageMs > STALE_CHILD_RESOURCE_MS) {
       return void 0;
     }
     return {
       rssBytes: info.childRssBytes ?? 0,
-      cpuPercent: info.childCpuPercent ?? 0
+      cpuPercent: info.childCpuPercent ?? 0,
+      // Bounded by the guard above, so a caller summing several children's
+      // readings can say how far apart they were taken. Without it a sum of
+      // readings up to `STALE_CHILD_RESOURCE_MS` apart looks instantaneous.
+      ageMs
     };
   }, "getChildResourceSnapshot");
   const requestSessionStatus = /* @__PURE__ */ __name(async (sessionId, method, params = {}, timeoutMs = initTimeoutMs) => {
@@ -7688,6 +8073,7 @@ function createAcpSessionBridge(opts) {
       cwdChangeQueue: Promise.resolve(),
       promptQueue: Promise.resolve(),
       pendingPromptCount: 0,
+      pendingAgentNotificationCount: 0,
       pendingPromptList: [],
       midTurnMessageQueue: [],
       modelChangeQueue: Promise.resolve(),
@@ -7702,10 +8088,14 @@ function createAcpSessionBridge(opts) {
       attachRefs: /* @__PURE__ */ new Map(),
       spawnOwnerWantedKill: false,
       promptActive: false,
+      childHolds: null,
+      childHoldsAt: null,
+      activeWorkCloseInFlight: false,
       retryAllowed: false
     };
     ci.sessionIds.add(entry.sessionId);
     byId.set(entry.sessionId, entry);
+    ci.client.clearAbandonedRestoreFence(entry.sessionId);
     touchActivity();
     telemetry.metrics?.sessionLifecycle("spawn");
     emitSessionLifecycle({
@@ -8012,7 +8402,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"
@@ -8020,7 +8410,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++;
@@ -8046,19 +8436,27 @@ function createAcpSessionBridge(opts) {
         ...historyAnchorRecordId !== void 0 ? { historyAnchorRecordId } : {}
       };
     }
+    if (inFlightRequestedSessionSpawns.has(req.sessionId)) {
+      throw new RestoreInProgressError(req.sessionId, "spawn", action);
+    }
     const inFlight = inFlightRestores.get(req.sessionId);
     if (inFlight) {
-      if (action !== inFlight.action || historyReplay !== inFlight.historyReplay || hideInheritedHistory !== inFlight.hideInheritedHistory) {
+      if (inFlight.lifecycle.phase === "abandoned" || action !== inFlight.action || historyReplay !== inFlight.historyReplay || hideInheritedHistory !== inFlight.hideInheritedHistory) {
+        const abandoned = inFlight.lifecycle.phase === "abandoned";
         throw new RestoreInProgressError(
           req.sessionId,
           inFlight.action,
-          action
+          action,
+          abandoned ? {
+            reason: "awaiting_abandoned_cleanup",
+            retryAfterSeconds: abandonedRestoreRetryAfterSeconds
+          } : void 0
         );
       }
       inFlight.coalesceState.count++;
       let restored;
       try {
-        restored = await inFlight.promise;
+        restored = await inFlight.publicPromise;
       } catch (err) {
         inFlight.coalesceState.count--;
         throw err;
@@ -8084,6 +8482,7 @@ function createAcpSessionBridge(opts) {
         hasActivePrompt: entry.promptActive
       };
     }
+    assertFreshSessionsAvailable();
     if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
       throw new SessionLimitExceededError(maxSessions);
     }
@@ -8102,12 +8501,145 @@ function createAcpSessionBridge(opts) {
       admissionReleased = true;
       releaseFreshSessionReservation(admission);
     }, "releaseAdmissionOnce");
+    let resolveSettlement;
+    const settlementPromise = new Promise((resolve2) => {
+      resolveSettlement = resolve2;
+    });
+    const restoreLifecycle = {
+      phase: "active"
+    };
+    const settleAbandonedRestore = /* @__PURE__ */ __name(async (channel, lateResult) => {
+      telemetry.event("session.restore.late_result", {
+        "qwen-code.daemon.session_restore.action": action,
+        "qwen-code.daemon.session_restore.result": lateResult,
+        "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+        "qwen-code.daemon.acp_channel.id": channel.id,
+        "session.id": req.sessionId
+      });
+      const usurper = byId.get(req.sessionId);
+      if (usurper) {
+        writeStderrLine(
+          `qwen serve: skipping abandoned session/${action} cleanup for ${JSON.stringify(req.sessionId)}: the id is now owned by a live session`
+        );
+        telemetry.event("session.restore.cleanup", {
+          "qwen-code.daemon.session_restore.action": action,
+          "qwen-code.daemon.session_restore.cleanup_result": "id_reclaimed",
+          "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+          "qwen-code.daemon.acp_channel.id": channel.id,
+          "session.id": req.sessionId
+        });
+        channel.unsettledAbandonedRestores.delete(req.sessionId);
+        const reclaimedTimer = channel.restoreSettlementTimers.get(
+          req.sessionId
+        );
+        if (reclaimedTimer !== void 0) {
+          clearTimeout(reclaimedTimer);
+          channel.restoreSettlementTimers.delete(req.sessionId);
+        }
+        if (channel.unsettledAbandonedRestores.size === 0) {
+          channel.restoreSettlementOverdue = false;
+        }
+        releaseAdmissionOnce();
+        resolveSettlement();
+        return;
+      }
+      try {
+        if (channel.isDying || !aliveChannels.has(channel)) {
+          await channel.channel.exited;
+          telemetry.event("session.restore.cleanup", {
+            "qwen-code.daemon.session_restore.action": action,
+            "qwen-code.daemon.session_restore.cleanup_result": "transport_closed",
+            "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+            "qwen-code.daemon.acp_channel.id": channel.id,
+            "session.id": req.sessionId
+          });
+          return;
+        }
+        try {
+          await Promise.race([
+            withTimeout(
+              channel.connection.extMethod(
+                SERVE_CONTROL_EXT_METHODS.sessionClose,
+                {
+                  sessionId: req.sessionId,
+                  drainTimeoutMs: Math.max(1, Math.floor(initTimeoutMs * 0.8))
+                }
+              ),
+              initTimeoutMs,
+              "abandonedRestoreClose"
+            ),
+            getChannelClosedReject(channel)
+          ]);
+          telemetry.event("session.restore.cleanup", {
+            "qwen-code.daemon.session_restore.action": action,
+            "qwen-code.daemon.session_restore.cleanup_result": "closed",
+            "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+            "qwen-code.daemon.acp_channel.id": channel.id,
+            "session.id": req.sessionId
+          });
+        } catch (error) {
+          if (isAcpSessionResourceNotFound(error, req.sessionId)) {
+            telemetry.event("session.restore.cleanup", {
+              "qwen-code.daemon.session_restore.action": action,
+              "qwen-code.daemon.session_restore.cleanup_result": "not_found",
+              "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+              "qwen-code.daemon.acp_channel.id": channel.id,
+              "session.id": req.sessionId
+            });
+            return;
+          }
+          if (channel.isDying || !aliveChannels.has(channel)) {
+            await channel.channel.exited;
+            telemetry.event("session.restore.cleanup", {
+              "qwen-code.daemon.session_restore.action": action,
+              "qwen-code.daemon.session_restore.cleanup_result": "transport_closed",
+              "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+              "qwen-code.daemon.acp_channel.id": channel.id,
+              "session.id": req.sessionId
+            });
+            return;
+          }
+          channel.isQuarantined = true;
+          writeStderrLine(
+            `qwen serve: quarantining ACP channel after timed-out session/${action} cleanup failed for ${JSON.stringify(req.sessionId)}: ${extractErrorMessage(error)}`
+          );
+          telemetry.event("session.restore.cleanup", {
+            "qwen-code.daemon.session_restore.action": action,
+            "qwen-code.daemon.session_restore.cleanup_result": "quarantined",
+            "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+            "qwen-code.daemon.acp_channel.id": channel.id,
+            "session.id": req.sessionId
+          });
+          if (hasNoChannelWork(channel)) {
+            void killChannelWithLog(
+              channel,
+              `abandoned session/${action} cleanup`
+            );
+          }
+          await channel.channel.exited;
+        }
+      } finally {
+        channel.client.markSessionClosed(req.sessionId);
+        channel.unsettledAbandonedRestores.delete(req.sessionId);
+        const graceTimer = channel.restoreSettlementTimers.get(req.sessionId);
+        if (graceTimer !== void 0) {
+          clearTimeout(graceTimer);
+          channel.restoreSettlementTimers.delete(req.sessionId);
+        }
+        if (channel.unsettledAbandonedRestores.size === 0) {
+          channel.restoreSettlementOverdue = false;
+        }
+        releaseAdmissionOnce();
+        resolveSettlement();
+      }
+    }, "settleAbandonedRestore");
     const promise = (async () => {
       pendingRestoreEvents.set(req.sessionId, restoreEvents);
-      ci = await ensureChannel();
-      ci.pendingRestoreIds.add(req.sessionId);
-      ci.client.markRestoreInFlight(req.sessionId);
-      const transportClosed = ci.channel.exited.then(() => {
+      const restoreChannel = await ensureChannel();
+      ci = restoreChannel;
+      restoreChannel.pendingRestoreIds.add(req.sessionId);
+      restoreChannel.client.markRestoreInFlight(req.sessionId);
+      const transportClosed = restoreChannel.channel.exited.then(() => {
         throw new BridgeChannelClosedError(`during session/${action}`);
       });
       transportClosed.catch(() => {
@@ -8118,10 +8650,18 @@ function createAcpSessionBridge(opts) {
       let replayError;
       let replayHasMore;
       try {
-        if (action === "load") {
-          state = await Promise.race([
-            withTimeout(
-              ci.connection.loadSession({
+        const rawRestore = telemetry.withSpan(
+          "session.restore",
+          {
+            "qwen-code.daemon.bridge.operation": `session.${action}`,
+            "qwen-code.daemon.session_restore.action": action,
+            "qwen-code.daemon.acp_channel.id": restoreChannel.id,
+            "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+            "session.id": req.sessionId
+          },
+          async () => {
+            if (action === "load") {
+              const request2 = telemetry.injectPromptContext({
                 sessionId: req.sessionId,
                 cwd: workspaceKey,
                 // Restore path drops per-request `mcpServers` (matches
@@ -8130,49 +8670,88 @@ function createAcpSessionBridge(opts) {
                 // intentionally has no `mcpServers` field for the
                 // same reason.
                 mcpServers: [],
-                ...historyReplay === "response" || hideInheritedHistory || req.sourceType ? {
-                  _meta: {
-                    ...sessionSourceRequestMeta(
-                      req.sourceType,
-                      req.sourceId
-                    ),
-                    ...historyReplay === "response" ? {
-                      [LOAD_REPLAY_MODE_META_KEY]: LOAD_REPLAY_BULK_MODE,
-                      ...req.historyPageSize !== void 0 ? {
-                        [LOAD_REPLAY_PAGE_SIZE_META_KEY]: req.historyPageSize
-                      } : {}
-                    } : {},
-                    ...hideInheritedHistory ? {
-                      [LOAD_REPLAY_HIDE_INHERITED_META_KEY]: true
+                _meta: {
+                  ...sessionSourceRequestMeta(req.sourceType, req.sourceId),
+                  ...historyReplay === "response" ? {
+                    [LOAD_REPLAY_MODE_META_KEY]: LOAD_REPLAY_BULK_MODE,
+                    ...req.historyPageSize !== void 0 ? {
+                      [LOAD_REPLAY_PAGE_SIZE_META_KEY]: req.historyPageSize
                     } : {}
-                  }
-                } : {}
-              }),
-              initTimeoutMs,
-              "loadSession"
-            ),
-            transportClosed
-          ]);
-        } else {
-          state = await Promise.race([
-            withTimeout(
-              ci.connection.unstable_resumeSession({
-                sessionId: req.sessionId,
-                cwd: workspaceKey,
-                mcpServers: [],
-                ...req.sourceType ? {
-                  _meta: sessionSourceRequestMeta(
-                    req.sourceType,
-                    req.sourceId
-                  )
-                } : {}
-              }),
-              initTimeoutMs,
-              "resumeSession"
-            ),
-            transportClosed
-          ]);
-        }
+                  } : {},
+                  ...hideInheritedHistory ? { [LOAD_REPLAY_HIDE_INHERITED_META_KEY]: true } : {}
+                }
+              });
+              return await restoreChannel.connection.loadSession(request2);
+            }
+            const request = telemetry.injectPromptContext({
+              sessionId: req.sessionId,
+              cwd: workspaceKey,
+              mcpServers: [],
+              _meta: sessionSourceRequestMeta(req.sourceType, req.sourceId)
+            });
+            return await restoreChannel.connection.unstable_resumeSession(
+              request
+            );
+          }
+        );
+        const observedRestore = Promise.race([rawRestore, transportClosed]);
+        state = await new Promise((resolve2, reject) => {
+          const timer = setTimeout(() => {
+            if (restoreLifecycle.phase !== "active") return;
+            restoreLifecycle.phase = "abandoned";
+            restoreChannel.pendingRestoreIds.delete(req.sessionId);
+            restoreChannel.client.markRestoreAbandoned(req.sessionId);
+            pendingRestoreEvents.delete(req.sessionId);
+            restoreEvents.close();
+            restoreChannel.unsettledAbandonedRestores.add(req.sessionId);
+            const channelWasEmpty = hasNoChannelWork(restoreChannel);
+            telemetry.event("session.restore.public_result", {
+              "qwen-code.daemon.session_restore.action": action,
+              "qwen-code.daemon.session_restore.result": "timeout",
+              "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+              "qwen-code.daemon.acp_channel.id": restoreChannel.id,
+              "qwen-code.daemon.session_restore.channel_was_empty": channelWasEmpty,
+              "session.id": req.sessionId
+            });
+            writeStderrLine(
+              `qwen serve: session/${action} timed out after ${sessionRestoreTimeoutMs}ms for ${JSON.stringify(req.sessionId)} on channel ${restoreChannel.id}; decision=${channelWasEmpty ? "kill_empty" : "fence_shared"}`
+            );
+            if (channelWasEmpty) {
+              void killChannelWithLog(
+                restoreChannel,
+                `timed-out session/${action} on empty channel`
+              );
+            } else {
+              armRestoreSettlementGrace(restoreChannel, req.sessionId, action);
+            }
+            reject(
+              new SessionRestoreTimeoutError(
+                req.sessionId,
+                action,
+                sessionRestoreTimeoutMs
+              )
+            );
+          }, sessionRestoreTimeoutMs);
+          timer.unref();
+          void observedRestore.then(
+            (value) => {
+              if (restoreLifecycle.phase === "active") {
+                clearTimeout(timer);
+                resolve2(value);
+                return;
+              }
+              void settleAbandonedRestore(restoreChannel, "success");
+            },
+            (error) => {
+              if (restoreLifecycle.phase === "active") {
+                clearTimeout(timer);
+                reject(error);
+                return;
+              }
+              void settleAbandonedRestore(restoreChannel, "failure");
+            }
+          );
+        });
         if (action === "load" && historyReplay === "response") {
           const extracted = extractLoadReplayResponse(state);
           state = extracted.state;
@@ -8182,6 +8761,7 @@ function createAcpSessionBridge(opts) {
           replayHasMore = extracted.hasMore === true ? true : void 0;
         }
       } catch (err) {
+        if (err instanceof SessionRestoreTimeoutError) throw err;
         restoreEvents.close();
         if (isAcpSessionResourceNotFound(err, req.sessionId)) {
           throw new SessionNotFoundError(req.sessionId);
@@ -8207,6 +8787,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);
@@ -8312,6 +8898,7 @@ function createAcpSessionBridge(opts) {
         ...replayFieldsFor(entry, action)
       };
     })().finally(async () => {
+      if (restoreLifecycle.phase === "abandoned") return;
       releaseAdmissionOnce();
       ci?.pendingRestoreIds.delete(req.sessionId);
       ci?.client.clearRestoreInFlight(req.sessionId);
@@ -8341,18 +8928,48 @@ function createAcpSessionBridge(opts) {
         await reapPendingEmptyChannel(ci);
       }
     });
+    void promise.then(
+      () => {
+        if (restoreLifecycle.phase === "active") {
+          telemetry.event("session.restore.public_result", {
+            "qwen-code.daemon.session_restore.action": action,
+            "qwen-code.daemon.session_restore.result": "success",
+            "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+            ...ci ? { "qwen-code.daemon.acp_channel.id": ci.id } : {},
+            "session.id": req.sessionId
+          });
+          resolveSettlement();
+        }
+      },
+      () => {
+        if (restoreLifecycle.phase === "active") {
+          telemetry.event("session.restore.public_result", {
+            "qwen-code.daemon.session_restore.action": action,
+            "qwen-code.daemon.session_restore.result": "failure",
+            "qwen-code.daemon.session_restore.timeout_ms": sessionRestoreTimeoutMs,
+            ...ci ? { "qwen-code.daemon.acp_channel.id": ci.id } : {},
+            "session.id": req.sessionId
+          });
+          resolveSettlement();
+        }
+      }
+    );
     inFlightRestores.set(req.sessionId, {
       action,
       historyReplay,
       hideInheritedHistory,
-      promise,
+      publicPromise: promise,
+      settlementPromise,
+      lifecycle: restoreLifecycle,
       coalesceState
     });
-    try {
-      return await promise;
-    } finally {
-      inFlightRestores.delete(req.sessionId);
-    }
+    void settlementPromise.finally(() => {
+      const current = inFlightRestores.get(req.sessionId);
+      if (current?.settlementPromise === settlementPromise) {
+        inFlightRestores.delete(req.sessionId);
+      }
+    });
+    return await promise;
   }
   __name(restoreSession, "restoreSession");
   async function closeSessionImpl(sessionId, context, closeOpts) {
@@ -8390,7 +9007,8 @@ function createAcpSessionBridge(opts) {
       entry.pendingInteractions.clear();
       await notifyAgentSessionClose(entry, ci, "closeSession", {
         throwOnFailure: true,
-        requireFlush: closeOpts?.requireAgentClose === true
+        requireFlush: closeOpts?.requireAgentClose === true,
+        ...closeOpts?.agentCloseTimeoutMs !== void 0 ? { timeoutMs: closeOpts.agentCloseTimeoutMs } : {}
       });
     } catch (error) {
       if (isDefinitiveAcpRequestError(error)) {
@@ -8528,6 +9146,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;
     },
@@ -8557,7 +9213,7 @@ function createAcpSessionBridge(opts) {
       if (req.sessionScope !== void 0 && req.sessionScope !== "single" && req.sessionScope !== "thread") {
         throw new InvalidSessionScopeError(req.sessionScope);
       }
-      const effectiveScope = req.sessionScope ?? defaultSessionScope;
+      const effectiveScope = req.sessionId !== void 0 ? "thread" : req.sessionScope ?? defaultSessionScope;
       const source = parseSessionSource(req.sourceType, req.sourceId);
       if ("error" in source) {
         throw new InvalidSessionMetadataError("sourceType", source.error);
@@ -8570,7 +9226,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"
@@ -8644,13 +9300,51 @@ function createAcpSessionBridge(opts) {
           };
         }
       }
+      if (req.sessionId !== void 0) {
+        const restoreOwner = inFlightRestores.get(req.sessionId);
+        if (restoreOwner) {
+          const abandoned = restoreOwner.lifecycle.phase === "abandoned";
+          throw new RestoreInProgressError(
+            req.sessionId,
+            restoreOwner.action,
+            "spawn",
+            abandoned ? {
+              reason: "awaiting_abandoned_cleanup",
+              retryAfterSeconds: abandonedRestoreRetryAfterSeconds
+            } : void 0
+          );
+        }
+        if (inFlightRequestedSessionSpawns.has(req.sessionId)) {
+          throw new RestoreInProgressError(req.sessionId, "spawn", "spawn");
+        }
+      }
+      assertFreshSessionsAvailable();
       if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
         throw new SessionLimitExceededError(maxSessions);
       }
-      const admission = reserveFreshSession({
-        operation: "spawn",
-        workspaceCwd: workspaceKey
-      });
+      const requestedSessionRegistrationOwner = req.sessionId !== void 0 ? Symbol(req.sessionId) : void 0;
+      if (req.sessionId !== void 0 && requestedSessionRegistrationOwner !== void 0) {
+        inFlightRequestedSessionSpawns.set(
+          req.sessionId,
+          requestedSessionRegistrationOwner
+        );
+      }
+      const releaseRequestedSessionRegistration = /* @__PURE__ */ __name(() => {
+        if (req.sessionId !== void 0 && requestedSessionRegistrationOwner !== void 0 && inFlightRequestedSessionSpawns.get(req.sessionId) === requestedSessionRegistrationOwner) {
+          inFlightRequestedSessionSpawns.delete(req.sessionId);
+        }
+      }, "releaseRequestedSessionRegistration");
+      let admission;
+      try {
+        admission = reserveFreshSession({
+          operation: "spawn",
+          workspaceCwd: workspaceKey,
+          ...req.sessionId !== void 0 ? { sessionId: req.sessionId } : {}
+        });
+      } catch (error) {
+        releaseRequestedSessionRegistration();
+        throw error;
+      }
       let admissionReleased = false;
       const releaseAdmissionOnce = /* @__PURE__ */ __name(() => {
         if (admissionReleased) return;
@@ -8677,6 +9371,7 @@ function createAcpSessionBridge(opts) {
       } finally {
         releaseAdmissionOnce();
         inFlightSpawns.delete(tracker);
+        releaseRequestedSessionRegistration();
       }
     },
     // Keep this method non-async: admission failures must throw before
@@ -8690,7 +9385,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,
@@ -9067,15 +9762,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;
@@ -9266,6 +9953,7 @@ function createAcpSessionBridge(opts) {
         if (entry.promptActive && !isSideTask) {
           throw new BranchWhilePromptActiveError(sessionId);
         }
+        assertFreshSessionsAvailable();
         if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
           throw new SessionLimitExceededError(maxSessions);
         }
@@ -10396,18 +11084,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);
@@ -10648,7 +11345,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);
@@ -11138,18 +11835,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;
@@ -11226,7 +11912,7 @@ function createAcpSessionBridge(opts) {
           )
         );
         const inFlightRestoreAwaits = Array.from(inFlightRestores.values()).map(
-          (restore) => restore.promise.then(
+          (restore) => restore.settlementPromise.then(
             () => void 0,
             () => void 0
           )