@qwen-code/qwen-code 0.21.8 → 0.21.9

package/chunks/{chunk-FYAXKJK7.js → chunk-P4ZEZSJZ.js}

@@ -17,16 +17,17 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-RPWVIXDB.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,
@@ -59,6 +60,7 @@ import {
 } from "./chunk-M2PNLYGY.js";
 import {
   BranchWhilePromptActiveError,
+  BridgeChannelQuarantinedError,
   CancelSentinelCollisionError,
   CdWhilePromptActiveError,
   InvalidClientIdError,
@@ -77,7 +79,7 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-J26HHFI5.js";
+} from "./chunk-LP2QGNSP.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
@@ -111,16 +113,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-GXSNGY5M.js";
+} from "./chunk-XX7QFP34.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-3PY4LPJF.js";
+} from "./chunk-YGT2AUJ7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -148,6 +150,7 @@ var LATEST_WINS_UPDATES = /* @__PURE__ */ new Set([
   "current_mode_update"
 ]);
 var REPLAY_SEGMENT_COMPACT_THRESHOLD = 64;
+var LIVE_JOURNAL_TEXT_CHUNKS_PER_EVENT = 256;
 function replayRecordId(event) {
   if (event.type !== "session_update") return void 0;
   const data = event.data;
@@ -185,10 +188,14 @@ var TurnBoundaryCompactionEngine = class {
   replaySegmentStart = 0;
   replayBytes = 0;
   liveJournal = [];
-  /** Serialized size of each `liveJournal` entry, index-parallel. */
+  /** Serialized source-event size of each `liveJournal` entry, index-parallel. */
   journalEntryBytes = [];
+  /** Raw event count represented by each `liveJournal` entry. */
+  journalEntryEvents = [];
   journalTotalBytes = 0;
+  journalTotalEvents = 0;
   journalTruncatedEvents = 0;
+  liveJournalTextSegment;
   lastEventId = 0;
   closed = false;
   truncatedEvents = 0;
@@ -233,15 +240,7 @@ var TurnBoundaryCompactionEngine = class {
     if (seenRecordId !== void 0) {
       this.activeRecordId = seenRecordId;
     }
-    this.liveJournal.push(event);
-    const bytes = byteLength ?? serializedBridgeEventByteLength(event) ?? 0;
-    this.journalEntryBytes.push(bytes);
-    this.journalTotalBytes += bytes;
-    while (this.liveJournal.length > this.maxJournalEvents || this.journalTotalBytes > this.maxJournalBytes && this.liveJournal.length > 1) {
-      this.liveJournal.shift();
-      this.journalTotalBytes -= this.journalEntryBytes.shift() ?? 0;
-      this.journalTruncatedEvents += 1;
-    }
+    this.appendLiveJournal(event, byteLength);
     if (TURN_BOUNDARY_TYPES.has(event.type)) {
       this.compactCurrentTurn(event);
       return;
@@ -259,7 +258,13 @@ var TurnBoundaryCompactionEngine = class {
         this.makeHistoryTruncatedEvent(compactedTurns.length)
       );
     }
-    const liveJournal = this.liveJournal.slice();
+    const liveJournal = this.liveJournal.map(
+      (entry) => isLiveJournalTextSegment(entry) ? mergeLiveJournalTextEvent(
+        entry.firstEvent,
+        entry.lastEvent,
+        entry.chunks
+      ) : entry
+    );
     if (this.journalTruncatedEvents > 0) {
       liveJournal.unshift({
         v: EVENT_SCHEMA_VERSION,
@@ -268,7 +273,7 @@ var TurnBoundaryCompactionEngine = class {
           reason: "replay_window_exceeded",
           scope: "live_journal",
           truncatedEvents: this.journalTruncatedEvents,
-          retainedEvents: this.liveJournal.length,
+          retainedEvents: this.journalTotalEvents,
           maxBytes: this.maxJournalBytes,
           maxEvents: this.maxJournalEvents,
           // Pagination anchor — see makeHistoryTruncatedEvent.
@@ -341,6 +346,54 @@ var TurnBoundaryCompactionEngine = class {
     this.toolSlotIndex.clear();
     this.clearTextSlotIndex();
   }
+  appendLiveJournal(event, byteLength) {
+    const bytes = byteLength ?? serializedBridgeEventByteLength(event) ?? 0;
+    const textChunk = liveJournalTextChunk(event);
+    const current = this.liveJournalTextSegment;
+    const currentIndex = this.liveJournal.length - 1;
+    if (textChunk && current && this.liveJournal[currentIndex] === current && current.chunks.length < LIVE_JOURNAL_TEXT_CHUNKS_PER_EVENT && this.journalEntryBytes[currentIndex] + bytes <= this.maxJournalBytes && current.sessionUpdate === textChunk.sessionUpdate && current.parentToolCallId === textChunk.parentToolCallId && stringArraysEqual(current.sourceRecordIds, textChunk.sourceRecordIds) && current.promptId === event.promptId && current.originatorClientId === event.originatorClientId && current.sessionId === captureSessionId(event) && hasOnlyTimestampEnvelopeMeta(current.lastEvent._meta) && hasOnlyTimestampEnvelopeMeta(event._meta)) {
+      current.chunks.push(textChunk.text);
+      current.lastEvent = event;
+      this.journalEntryBytes[currentIndex] += bytes;
+      this.journalEntryEvents[currentIndex] += 1;
+      this.journalTotalBytes += bytes;
+      this.journalTotalEvents += 1;
+    } else {
+      let entry = event;
+      if (textChunk) {
+        const segment = {
+          sessionUpdate: textChunk.sessionUpdate,
+          chunks: [textChunk.text],
+          sourceRecordIds: textChunk.sourceRecordIds,
+          parentToolCallId: textChunk.parentToolCallId,
+          promptId: event.promptId,
+          originatorClientId: event.originatorClientId,
+          sessionId: captureSessionId(event),
+          firstEvent: event,
+          lastEvent: event
+        };
+        entry = segment;
+        this.liveJournalTextSegment = segment;
+      } else {
+        this.liveJournalTextSegment = void 0;
+      }
+      this.liveJournal.push(entry);
+      this.journalEntryBytes.push(bytes);
+      this.journalEntryEvents.push(1);
+      this.journalTotalBytes += bytes;
+      this.journalTotalEvents += 1;
+    }
+    while (this.liveJournal.length > this.maxJournalEvents || this.journalTotalBytes > this.maxJournalBytes && this.liveJournal.length > 1) {
+      const dropped = this.liveJournal.shift();
+      this.journalTotalBytes -= this.journalEntryBytes.shift() ?? 0;
+      const droppedEvents = this.journalEntryEvents.shift() ?? 0;
+      this.journalTotalEvents -= droppedEvents;
+      this.journalTruncatedEvents += droppedEvents;
+      if (dropped === this.liveJournalTextSegment) {
+        this.liveJournalTextSegment = void 0;
+      }
+    }
+  }
   classifySessionUpdate(event) {
     const data = event.data;
     const updateType = data?.update?.sessionUpdate;
@@ -350,7 +403,7 @@ var TurnBoundaryCompactionEngine = class {
     }
     switch (updateType) {
       case "agent_message_chunk": {
-        if (hasTodoStopGuardDiscreteMeta(data?.update?._meta)) {
+        if (hasDiscreteMessageMeta(data?.update?._meta)) {
           this.slots.push({ kind: "misc", event });
           break;
         }
@@ -358,6 +411,10 @@ var TurnBoundaryCompactionEngine = class {
         break;
       }
       case "agent_thought_chunk": {
+        if (hasDiscreteMessageMeta(data?.update?._meta)) {
+          this.slots.push({ kind: "misc", event });
+          break;
+        }
         this.mergeTextSlot("thought", event, data);
         break;
       }
@@ -506,8 +563,11 @@ var TurnBoundaryCompactionEngine = class {
   resetJournal() {
     this.liveJournal = [];
     this.journalEntryBytes = [];
+    this.journalEntryEvents = [];
     this.journalTotalBytes = 0;
+    this.journalTotalEvents = 0;
     this.journalTruncatedEvents = 0;
+    this.liveJournalTextSegment = void 0;
   }
   addReplaySegment(events, turnCount) {
     if (events.length === 0) return;
@@ -625,6 +685,61 @@ var TurnBoundaryCompactionEngine = class {
     this.textSlotIndex.thought.clear();
   }
 };
+function isLiveJournalTextSegment(entry) {
+  return "firstEvent" in entry;
+}
+__name(isLiveJournalTextSegment, "isLiveJournalTextSegment");
+function liveJournalTextChunk(event) {
+  if (event.type !== "session_update") return void 0;
+  const data = event.data;
+  const sessionUpdate = data?.update?.sessionUpdate;
+  if (sessionUpdate !== "agent_message_chunk" && sessionUpdate !== "agent_thought_chunk") {
+    return void 0;
+  }
+  if (!hasOnlyModeledChunkKeys(data)) {
+    return void 0;
+  }
+  if (hasDiscreteMessageMeta(data?.update?._meta) || hasUnmodeledTextMeta(data?.update?._meta)) {
+    return void 0;
+  }
+  const content = data?.update?.content;
+  if (content?.type !== "text" || typeof content.text !== "string") {
+    return void 0;
+  }
+  return {
+    sessionUpdate,
+    text: content.text,
+    sourceRecordIds: extractSourceRecordIdsFromMeta(data?.update?._meta),
+    parentToolCallId: extractParentToolCallIdFromMeta(data?.update?._meta)
+  };
+}
+__name(liveJournalTextChunk, "liveJournalTextChunk");
+function hasOnlyModeledChunkKeys(data) {
+  if (!data || !data.update) return false;
+  const content = data.update.content;
+  return Object.keys(data).every((key) => key === "sessionId" || key === "update") && Object.keys(data.update).every(
+    (key) => key === "sessionUpdate" || key === "content" || key === "_meta"
+  ) && (content === void 0 || typeof content === "object" && content !== null && Object.keys(content).every((key) => key === "type" || key === "text"));
+}
+__name(hasOnlyModeledChunkKeys, "hasOnlyModeledChunkKeys");
+function mergeLiveJournalTextEvent(existing, incoming, chunks) {
+  const existingData = existing.data;
+  const incomingData = incoming.data;
+  return {
+    ...existing,
+    ...incoming,
+    data: {
+      ...existingData,
+      ...incomingData,
+      update: {
+        ...existingData.update,
+        ...incomingData.update,
+        content: { type: "text", text: chunks.join("") }
+      }
+    }
+  };
+}
+__name(mergeLiveJournalTextEvent, "mergeLiveJournalTextEvent");
 function makeMergedSessionUpdateEvent(sessionUpdate, text, eventId, meta, envelopeMeta, turn, sessionId) {
   return {
     id: eventId || void 0,
@@ -705,10 +820,57 @@ function stringArraysEqual(left, right) {
   return left.every((value, index) => value === right[index]);
 }
 __name(stringArraysEqual, "stringArraysEqual");
-function hasTodoStopGuardDiscreteMeta(meta) {
-  return typeof meta === "object" && meta !== null && meta["qwenDiscreteMessage"] === true && meta["source"] === "todo_stop_guard";
+function hasDiscreteMessageMeta(meta) {
+  return typeof meta === "object" && meta !== null && meta["qwenDiscreteMessage"] === true;
+}
+__name(hasDiscreteMessageMeta, "hasDiscreteMessageMeta");
+function hasOnlyTimestampEnvelopeMeta(meta) {
+  if (meta === void 0) return true;
+  if (typeof meta !== "object" || meta === null) return false;
+  return Object.keys(meta).every(
+    (key) => key === "timestamp" || key === "serverTimestamp"
+  );
+}
+__name(hasOnlyTimestampEnvelopeMeta, "hasOnlyTimestampEnvelopeMeta");
+function hasUnmodeledTextMeta(meta) {
+  if (meta === void 0) return false;
+  if (typeof meta !== "object" || meta === null) return true;
+  const record = meta;
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "timestamp" || key === "serverTimestamp") {
+      continue;
+    }
+    if (key === "parentToolCallId") {
+      if (typeof value !== "string") return true;
+      continue;
+    }
+    if (key === "subagentType") {
+      if (typeof value !== "string") return true;
+      continue;
+    }
+    if (key === "qwenTranscript") {
+      if (typeof value !== "object" || value === null) return true;
+      const transcript = value;
+      for (const [field, fieldValue] of Object.entries(transcript)) {
+        if (field === "sourceRecordIds") {
+          if (!Array.isArray(fieldValue) || fieldValue.some((id) => typeof id !== "string")) {
+            return true;
+          }
+          continue;
+        }
+        if (field === "planToolCallId") {
+          if (typeof fieldValue !== "string") return true;
+          continue;
+        }
+        return true;
+      }
+      continue;
+    }
+    return true;
+  }
+  return false;
 }
-__name(hasTodoStopGuardDiscreteMeta, "hasTodoStopGuardDiscreteMeta");
+__name(hasUnmodeledTextMeta, "hasUnmodeledTextMeta");
 function mergeToolCallEvent(existing, incoming) {
   const existingData = existing.data;
   const incomingData = incoming.data;
@@ -762,6 +924,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";
@@ -1977,6 +2179,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`
@@ -2147,22 +2352,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:
@@ -2629,6 +2831,10 @@ 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) {
@@ -2907,6 +3113,9 @@ var BridgeClient = class {
     }
   }
   publishExtNotification(sessionId, type, data, turnScoped = false) {
+    if (this.abandonedRestoreIds.has(sessionId)) {
+      return;
+    }
     const entry = this.resolveEntry(sessionId);
     const frame = {
       type,
@@ -3052,9 +3261,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)`
       );
@@ -3116,8 +3328,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
@@ -3126,6 +3361,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`.
@@ -6172,7 +6417,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 {
@@ -6217,6 +6486,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
@@ -6327,8 +6601,11 @@ function createAcpSessionBridge(opts) {
     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
+        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)}`
@@ -6343,6 +6620,7 @@ function createAcpSessionBridge(opts) {
     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, {
@@ -6506,8 +6784,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(() => {
@@ -6677,6 +6982,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");
@@ -6894,7 +7200,11 @@ 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;
@@ -6915,6 +7225,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);
@@ -7076,6 +7390,9 @@ function createAcpSessionBridge(opts) {
       ensureChannel
     );
     ci.sessionSpawnsInFlight++;
+    if (requestedSessionId !== void 0) {
+      ci.client.markSessionRegistrationInFlight(requestedSessionId);
+    }
     let sessionRegistered = false;
     let sessionRemovedDuringInitialization = false;
     let initializedSessionId;
@@ -7260,6 +7577,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);
@@ -7932,6 +8255,7 @@ function createAcpSessionBridge(opts) {
     };
     ci.sessionIds.add(entry.sessionId);
     byId.set(entry.sessionId, entry);
+    ci.client.clearAbandonedRestoreFence(entry.sessionId);
     touchActivity();
     telemetry.metrics?.sessionLifecycle("spawn");
     emitSessionLifecycle({
@@ -8272,19 +8596,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;
@@ -8310,6 +8642,7 @@ function createAcpSessionBridge(opts) {
         hasActivePrompt: entry.promptActive
       };
     }
+    assertFreshSessionsAvailable();
     if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
       throw new SessionLimitExceededError(maxSessions);
     }
@@ -8328,12 +8661,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(() => {
@@ -8344,10 +8810,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
@@ -8356,49 +8830,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;
@@ -8408,6 +8921,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);
@@ -8544,6 +9058,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);
@@ -8573,18 +9088,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) {
@@ -8622,7 +9167,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)) {
@@ -8827,7 +9373,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);
@@ -8914,13 +9460,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;
@@ -8947,6 +9531,7 @@ function createAcpSessionBridge(opts) {
       } finally {
         releaseAdmissionOnce();
         inFlightSpawns.delete(tracker);
+        releaseRequestedSessionRegistration();
       }
     },
     // Keep this method non-async: admission failures must throw before
@@ -9528,6 +10113,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);
         }
@@ -11486,7 +12072,7 @@ function createAcpSessionBridge(opts) {
           )
         );
         const inFlightRestoreAwaits = Array.from(inFlightRestores.values()).map(
-          (restore) => restore.promise.then(
+          (restore) => restore.settlementPromise.then(
             () => void 0,
             () => void 0
           )