@qwen-code/qwen-code 0.22.3-nightly.20260831.3a0c4c6108 → 0.23.0

package/chunks/{chunk-RLSPPTWH.js → chunk-DSX7KQPM.js}

@@ -19,7 +19,7 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-JMRE4WJQ.js";
+} from "./chunk-4HVH57J3.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -29,7 +29,7 @@ import {
   SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-J4Y3QJHF.js";
+} from "./chunk-64QH2UC6.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_CLOSE_TIMEOUT_MS,
@@ -83,6 +83,7 @@ import {
   InvalidRewindTargetError,
   InvalidSessionMetadataError,
   InvalidSessionScopeError,
+  McpAuthenticationInProgressError,
   PermissionForbiddenError,
   PromptDeadlineExceededError,
   PromptQueueFullError,
@@ -95,7 +96,7 @@ import {
   StandaloneSessionSpawnError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-YPISTYEI.js";
+} from "./chunk-F47DITLZ.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
@@ -127,7 +128,7 @@ import {
   isOfficeDocumentExtension,
   isRecordableDerivedChild,
   pathHasSkippedDirectoryComponent
-} from "./chunk-W4BDHLRT.js";
+} from "./chunk-IG4W5SJR.js";
 import {
   SESSION_PR_LIST_LIMIT,
   SESSION_PR_URL_MAX_LENGTH,
@@ -137,8 +138,9 @@ import {
   TURN_RESULT_TEXT_MAX_CHARS,
   TrustGateError,
   canonicalSessionPrUrl,
-  normalizeTurnResultError
-} from "./chunk-ZBDYI7VM.js";
+  normalizeTurnResultError,
+  toSessionPrInfo
+} from "./chunk-4F7GQGXB.js";
 import {
   isUnverifiableIdentityError,
   openNoFollow
@@ -155,22 +157,22 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-DJBQCO2E.js";
+} from "./chunk-EFTPIZIC.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-UXEW7TQS.js";
+} from "./chunk-LB3WQQJK.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-FXUSWLBF.js";
+} from "./chunk-GH2S4GD5.js";
 import {
   getSpecificMimeType
-} from "./chunk-67AY5D3M.js";
+} from "./chunk-DYTW3QVG.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1616,6 +1618,23 @@ function isTextAttachment(data, mimeType) {
   return Buffer.from(data.toString("utf8"), "utf8").equals(data);
 }
 __name(isTextAttachment, "isTextAttachment");
+function statSize(filePath) {
+  try {
+    return statSync(filePath).size;
+  } catch {
+    return void 0;
+  }
+}
+__name(statSize, "statSize");
+function statSizeStrict(filePath) {
+  try {
+    return statSync(filePath).size;
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+__name(statSizeStrict, "statSizeStrict");
 function withAttachmentDegradationMarker(blocks) {
   for (let i = blocks.length - 1; i >= 0; i--) {
     const block = blocks[i];
@@ -1639,22 +1658,30 @@ ${SESSION_ATTACHMENT_UNAVAILABLE_TEXT}`
 }
 __name(withAttachmentDegradationMarker, "withAttachmentDegradationMarker");
 var SessionAttachmentStore = class {
-  constructor(directoryRoot, sessionId) {
+  constructor(directoryRoot, sessionId, fallbackDirectoryRoot) {
     this.directoryRoot = directoryRoot;
     if (!directoryRoot || !sessionId) return;
     this.persistentDirectory = path.join(
       directoryRoot,
       `session-${encodeURIComponent(sessionId)}`
     );
+    if (fallbackDirectoryRoot) {
+      this.persistentFallbackDirectory = path.join(
+        fallbackDirectoryRoot,
+        `session-${encodeURIComponent(sessionId)}`
+      );
+    }
   }
   static {
     __name(this, "SessionAttachmentStore");
   }
   directoryPromise;
   persistentDirectory;
+  persistentFallbackDirectory;
   activeDirectory;
   pendingItems = 0;
   pendingNames = /* @__PURE__ */ new Map();
+  removingNames = /* @__PURE__ */ new Set();
   pendingDrainWaiters = [];
   copyDrainWaiters = [];
   copying = false;
@@ -1694,6 +1721,16 @@ var SessionAttachmentStore = class {
         if (safeAttachmentName(candidateName) !== candidateName) {
           throw new TypeError("Session attachment name is invalid");
         }
+        if (this.removingNames.has(candidateName)) {
+          suffix += 1;
+          continue;
+        }
+        if (this.persistentFallbackDirectory && statSizeStrict(
+          path.join(this.persistentFallbackDirectory, candidateName)
+        ) !== void 0) {
+          suffix += 1;
+          continue;
+        }
         if (pendingName !== candidateName) {
           if (pendingName) this.releasePendingName(pendingName);
           this.reservePendingName(candidateName);
@@ -1826,16 +1863,25 @@ var SessionAttachmentStore = class {
   async read(attachmentId) {
     const name = safeAttachmentName(attachmentId);
     if (!name || name !== attachmentId) return void 0;
-    const filePath = path.join(await this.directory(), name);
+    let primary;
+    try {
+      primary = await this.tryRead(await this.peekDirectory(), name);
+    } catch (error) {
+      if (!this.persistentFallbackDirectory) throw error;
+      primary = void 0;
+    }
+    if (primary) return primary;
+    return await this.tryRead(this.persistentFallbackDirectory, name);
+  }
+  async tryRead(directory, name) {
+    if (!directory) return void 0;
     try {
       return {
-        data: await fs.readFile(filePath),
+        data: await fs.readFile(path.join(directory, name)),
         mimeType: mimeTypeForName(name)
       };
     } catch (error) {
-      if (error.code === "ENOENT") {
-        return void 0;
-      }
+      if (error.code === "ENOENT") return void 0;
       throw error;
     }
   }
@@ -1865,40 +1911,54 @@ var SessionAttachmentStore = class {
         );
       }
       if (this.closed) throw new Error("Session attachment store is closed");
-      const sourceDirectory = source.persistentDirectory ?? source.activeDirectory;
-      if (!sourceDirectory) return;
-      let entries;
-      try {
-        entries = await fs.readdir(sourceDirectory, { withFileTypes: true });
-      } catch (error) {
-        if (error.code === "ENOENT") return;
-        throw error;
-      }
+      const sourceDirectories = [
+        source.persistentDirectory ?? source.activeDirectory,
+        source.persistentFallbackDirectory
+      ].filter((directory) => Boolean(directory));
+      if (sourceDirectories.length === 0) return;
       const targetDirectory = await this.directory();
-      await Promise.all(
-        entries.filter(
-          (entry) => entry.isFile() && !source.pendingNames.has(entry.name)
-        ).map(async (entry) => {
-          const sourcePath = path.join(sourceDirectory, entry.name);
-          try {
-            await fs.copyFile(
-              sourcePath,
-              path.join(targetDirectory, entry.name)
-            );
-          } catch (error) {
-            if (error.code === "ENOENT") {
-              try {
-                await fs.stat(sourcePath);
-              } catch (sourceError) {
-                if (sourceError.code === "ENOENT") {
-                  return;
+      const copiedNames = /* @__PURE__ */ new Set();
+      let sourceDirectoryRead = false;
+      let sourceDirectoryError;
+      for (const sourceDirectory of sourceDirectories) {
+        let entries;
+        try {
+          entries = await fs.readdir(sourceDirectory, { withFileTypes: true });
+        } catch (error) {
+          if (error.code === "ENOENT") continue;
+          sourceDirectoryError ??= error;
+          continue;
+        }
+        sourceDirectoryRead = true;
+        await Promise.all(
+          entries.filter(
+            (entry) => entry.isFile() && !source.pendingNames.has(entry.name) && !source.removingNames.has(entry.name) && !copiedNames.has(entry.name)
+          ).map(async (entry) => {
+            const sourcePath = path.join(sourceDirectory, entry.name);
+            try {
+              await fs.copyFile(
+                sourcePath,
+                path.join(targetDirectory, entry.name)
+              );
+              copiedNames.add(entry.name);
+            } catch (error) {
+              if (error.code === "ENOENT") {
+                try {
+                  await fs.stat(sourcePath);
+                } catch (sourceError) {
+                  if (sourceError.code === "ENOENT") {
+                    return;
+                  }
                 }
               }
+              throw error;
             }
-            throw error;
-          }
-        })
-      );
+          })
+        );
+      }
+      if (!sourceDirectoryRead && sourceDirectoryError !== void 0) {
+        throw sourceDirectoryError;
+      }
     } finally {
       source.copying = false;
       this.copying = false;
@@ -1908,18 +1968,40 @@ var SessionAttachmentStore = class {
   }
   async remove(attachmentId) {
     const name = safeAttachmentName(attachmentId);
-    if (!name || name !== attachmentId || this.copying || this.pendingNames.has(name)) {
+    if (!name || name !== attachmentId || this.copying || this.pendingNames.has(name) || this.removingNames.has(name)) {
       return false;
     }
-    const directory = await this.directory();
-    const filePath = path.join(directory, name);
+    this.removingNames.add(name);
+    try {
+      const primaryDirectory = await this.peekDirectory();
+      const [fallbackExists, primaryExists] = await Promise.all([
+        this.hasAttachment(this.persistentFallbackDirectory, name),
+        this.hasAttachment(primaryDirectory, name)
+      ]);
+      const fallbackHit = fallbackExists && await this.tryUnlink(this.persistentFallbackDirectory, name) === true;
+      const primaryHit = primaryExists && await this.tryUnlink(primaryDirectory, name) === true;
+      return primaryHit || fallbackHit;
+    } finally {
+      this.removingNames.delete(name);
+    }
+  }
+  async hasAttachment(directory, name) {
+    if (!directory) return false;
     try {
-      await fs.unlink(filePath);
+      await fs.stat(path.join(directory, name));
       return true;
     } catch (error) {
-      if (error.code === "ENOENT") {
-        return false;
-      }
+      if (error.code === "ENOENT") return false;
+      throw error;
+    }
+  }
+  async tryUnlink(directory, name) {
+    if (!directory) return void 0;
+    try {
+      await fs.unlink(path.join(directory, name));
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
       throw error;
     }
   }
@@ -1947,62 +2029,83 @@ var SessionAttachmentStore = class {
       this.pendingNames.clear();
       this.resolvePendingDrainWaiters();
     }
+    let fallbackError;
+    if (this.persistentFallbackDirectory) {
+      try {
+        await this.removeDirectoryDurably(
+          this.persistentFallbackDirectory,
+          options.assertCanCommit
+        );
+      } catch (error) {
+        fallbackError = error;
+      }
+    }
     const directory = this.persistentDirectory ?? await this.directoryPromise?.catch(() => void 0);
     if (directory) {
-      options.assertCanCommit?.();
-      const parent = await openDurableAttachmentDirectoryIfPresent(
-        path.dirname(directory)
-      );
-      if (!parent) return;
-      const tombstone = path.join(
-        path.dirname(directory),
-        `.${path.basename(directory)}.deleting`
-      );
+      await this.removeDirectoryDurably(directory, options.assertCanCommit);
+    }
+    if (fallbackError !== void 0) throw fallbackError;
+  }
+  /**
+   * Delete `directory` through a fixed-name tombstone while holding an open
+   * handle to its parent, re-checking the parent's identity and syncing it
+   * after each mutation. The FIXED tombstone name lets a deletion interrupted
+   * between the rename and the removal resume on the next call instead of
+   * leaking the tombstone, and a successor directory recreated at the
+   * original path after the rename is never swept up by the removal.
+   */
+  async removeDirectoryDurably(directory, assertCanCommit) {
+    assertCanCommit?.();
+    const parent = await openDurableAttachmentDirectoryIfPresent(
+      path.dirname(directory)
+    );
+    if (!parent) return;
+    const tombstone = path.join(
+      path.dirname(directory),
+      `.${path.basename(directory)}.deleting`
+    );
+    try {
+      assertCanCommit?.();
+      let tombstoneExists = false;
+      try {
+        const stats = await fs.lstat(tombstone);
+        if (!stats.isDirectory() || stats.isSymbolicLink()) {
+          throw new Error("Session attachment tombstone is not a directory.");
+        }
+        tombstoneExists = true;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      if (tombstoneExists) {
+        assertCanCommit?.();
+        await fs.rm(tombstone, { recursive: true, force: true });
+        await syncDurableAttachmentDirectory(parent);
+        return;
+      }
+      assertCanCommit?.();
       try {
-        options.assertCanCommit?.();
-        let tombstoneExists = false;
+        await fs.rename(directory, tombstone);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
         try {
           const stats = await fs.lstat(tombstone);
           if (!stats.isDirectory() || stats.isSymbolicLink()) {
             throw new Error("Session attachment tombstone is not a directory.");
           }
-          tombstoneExists = true;
-        } catch (error) {
-          if (error.code !== "ENOENT") throw error;
-        }
-        if (tombstoneExists) {
-          options.assertCanCommit?.();
+          assertCanCommit?.();
           await fs.rm(tombstone, { recursive: true, force: true });
-          await syncDurableAttachmentDirectory(parent);
-          return;
-        }
-        options.assertCanCommit?.();
-        try {
-          await fs.rename(directory, tombstone);
-        } catch (error) {
-          if (error.code !== "ENOENT") throw error;
-          try {
-            const stats = await fs.lstat(tombstone);
-            if (!stats.isDirectory() || stats.isSymbolicLink()) {
-              throw new Error(
-                "Session attachment tombstone is not a directory."
-              );
-            }
-            options.assertCanCommit?.();
-            await fs.rm(tombstone, { recursive: true, force: true });
-          } catch (tombstoneError) {
-            if (tombstoneError.code !== "ENOENT") {
-              throw tombstoneError;
-            }
+        } catch (tombstoneError) {
+          if (tombstoneError.code !== "ENOENT") {
+            throw tombstoneError;
           }
-          await syncDurableAttachmentDirectory(parent);
-          return;
         }
-        await fs.rm(tombstone, { recursive: true, force: true });
         await syncDurableAttachmentDirectory(parent);
-      } finally {
-        await parent.handle.close().catch(() => void 0);
+        return;
       }
+      await fs.rm(tombstone, { recursive: true, force: true });
+      await syncDurableAttachmentDirectory(parent);
+    } finally {
+      await parent.handle.close().catch(() => void 0);
     }
   }
   assertStored(reference) {
@@ -2011,10 +2114,9 @@ var SessionAttachmentStore = class {
     let size;
     const directory = this.persistentDirectory ?? this.activeDirectory;
     if (name && name === id && directory) {
-      try {
-        size = statSync(path.join(directory, name)).size;
-      } catch {
-        size = void 0;
+      size = statSize(path.join(directory, name));
+      if (size === void 0 && this.persistentFallbackDirectory) {
+        size = statSize(path.join(this.persistentFallbackDirectory, name));
       }
     }
     const storedMimeType = name ? mimeTypeForName(name) : void 0;
@@ -2071,6 +2173,13 @@ var SessionAttachmentStore = class {
       mimeType: attachment.mimeType
     };
   }
+  // The storage directory without forcing creation: reads and removes must
+  // degrade to the fallback when the configured root is unavailable, not
+  // fail on a forced mkdir of a degraded volume.
+  async peekDirectory() {
+    const established = await this.directoryPromise?.catch(() => void 0);
+    return established ?? this.persistentDirectory;
+  }
   async directory() {
     if (!this.directoryPromise) {
       const pending = this.persistentDirectory ? fs.mkdir(this.persistentDirectory, {
@@ -4058,7 +4167,9 @@ var BridgeClient = class {
    * `qwen/notify/session/recording-degraded`,
    * `qwen/notify/session/prompt-suggestion` (followup assist),
    * `qwen/notify/session/artifact-event` (hook artifacts),
-   * `qwen/notify/session/terminal-sequence`, and
+   * `qwen/notify/session/terminal-sequence`,
+   * `qwen/notify/session/pr-binding` (shell-detected `gh pr create`
+   * bindings — catalog mark only, the child persists the sidecar), and
    * `_qwencode/end_turn` (background-notification and goal turns), and
    * `qwen/notify/session/mcp-budget-event` — each translated into a
    * session-scoped SSE frame. Unknown methods are dropped silently for
@@ -4236,6 +4347,28 @@ var BridgeClient = class {
       }
       return;
     }
+    if (method === "qwen/notify/session/pr-binding") {
+      const sessionId2 = params["sessionId"];
+      const pr = params["pr"];
+      if (params["v"] !== 1 || typeof sessionId2 !== "string" || sessionId2.length === 0 || pr === null || typeof pr !== "object" || Array.isArray(pr)) {
+        return;
+      }
+      const record = pr;
+      const number = record["number"];
+      const url = record["url"];
+      if (typeof number !== "number" || !Number.isInteger(number) || number <= 0 || typeof url !== "string" || url.length === 0 || url.length > SESSION_PR_URL_MAX_LENGTH || !/^https?:\/\//i.test(url) || // Mirrors the bridge's hasControlCharacter: the url lands in an
+      // audit line, so control characters would forge log lines.
+      Array.from(url).some((character) => {
+        const code = character.charCodeAt(0);
+        return code <= 31 || code === 127;
+      })) {
+        return;
+      }
+      const entry = this.resolveEntry(sessionId2);
+      if (!entry || !this.ownsSession(sessionId2)) return;
+      this.onSessionCatalogChanged?.();
+      return;
+    }
     if (method === "qwen/notify/session/recording-degraded") {
       const sessionId2 = params["sessionId"];
       if (params["v"] !== 1 || typeof sessionId2 !== "string" || sessionId2.length === 0 || params["reason"] !== "write_failed") {
@@ -7607,6 +7740,25 @@ function safeTransportFailureCode(error) {
   return typeof code === "string" && /^[a-z0-9_.-]{1,64}$/iu.test(code) ? code : void 0;
 }
 __name(safeTransportFailureCode, "safeTransportFailureCode");
+function safeTransportFailureDetail(error) {
+  if (!isRecord3(error) || error["code"] !== "ndjson_queue_limit_exceeded") {
+    return void 0;
+  }
+  const queueError = error;
+  const budget = typeof queueError.budget === "string" && /^[a-z0-9_.-]{1,64}$/iu.test(queueError.budget) ? queueError.budget : "unknown";
+  const numbers = [];
+  for (const value of [
+    queueError.requiredBytes,
+    queueError.availableBytes,
+    queueError.maxQueuedBytes
+  ]) {
+    numbers.push(
+      typeof value === "number" && Number.isFinite(value) ? String(Math.max(0, Math.floor(value))) : "?"
+    );
+  }
+  return `${budget}:required=${numbers[0]}:available=${numbers[1]}:cap=${numbers[2]}`;
+}
+__name(safeTransportFailureDetail, "safeTransportFailureDetail");
 function sessionSourceRequestMeta(sourceType, sourceId, daemonOwnedStandaloneCreation = false) {
   return sourceType ? {
     [SESSION_SOURCE_META_KEY]: {
@@ -9371,9 +9523,7 @@ function createAcpSessionBridge(opts) {
     });
   }
   __name(reapPendingEmptyChannel, "reapPendingEmptyChannel");
-  async function withWorkspaceControl(ci, fn, statusRead = false) {
-    const preservePreheat = statusRead && ci.preserveForFirstStatusRead && resolvedChannelIdleTimeoutMs() <= 0;
-    ci.preserveForFirstStatusRead = false;
+  async function withWorkspaceControl(ci, fn) {
     if (liveChannelInfo() === ci) cancelIdleTimer();
     ci.workspaceControlInFlight++;
     try {
@@ -9387,7 +9537,7 @@ function createAcpSessionBridge(opts) {
         ci.workspaceControlInFlight - 1
       );
       await reapPendingEmptyChannel(ci);
-      if (!preservePreheat && !ci.isDying && liveChannelInfo() === ci && hasNoChannelWork(ci)) {
+      if (!ci.isDying && liveChannelInfo() === ci && hasNoChannelWork(ci)) {
         await startIdleTimer(ci, "workspace control");
       }
     }
@@ -9404,7 +9554,7 @@ function createAcpSessionBridge(opts) {
   }
   __name(withEnsuredWorkspaceControl, "withEnsuredWorkspaceControl");
   function withWorkspaceStatusRead(ci, fn) {
-    return withWorkspaceControl(ci, fn, true);
+    return withWorkspaceControl(ci, fn);
   }
   __name(withWorkspaceStatusRead, "withWorkspaceStatusRead");
   function startSessionReaper() {
@@ -9859,11 +10009,11 @@ function createAcpSessionBridge(opts) {
         pendingRestoreIds: /* @__PURE__ */ new Set(),
         sessionSpawnsInFlight: 0,
         workspaceControlInFlight: 0,
-        preserveForFirstStatusRead: false,
         workspaceMcpDiscoveryInFlight: false,
         workspaceMcpDiscoveryRequested: false,
         workspaceMcpAuthenticationServerNames: /* @__PURE__ */ new Set(),
         workspaceMcpAuthenticationTimers: /* @__PURE__ */ new Map(),
+        workspaceMcpAuthenticationReleases: /* @__PURE__ */ new Map(),
         retireWhenSessionsDrain: false,
         emptyReapPending: false,
         unsettledAbandonedRestores: /* @__PURE__ */ new Set(),
@@ -9886,6 +10036,7 @@ function createAcpSessionBridge(opts) {
         }
         info.transportFailed = true;
         info.transportFailureCode = safeTransportFailureCode(error);
+        info.transportFailureDetail = safeTransportFailureDetail(error);
         info.isDying = true;
         info.channelLiveness?.stop();
         clearInFlightExtensionRefreshes(info.connection);
@@ -9913,6 +10064,10 @@ function createAcpSessionBridge(opts) {
         }
         info.workspaceMcpAuthenticationTimers.clear();
         info.workspaceMcpAuthenticationServerNames.clear();
+        for (const release of info.workspaceMcpAuthenticationReleases.values()) {
+          release();
+        }
+        info.workspaceMcpAuthenticationReleases.clear();
         for (const timer of info.restoreSettlementTimers.values()) {
           clearTimeout(timer);
         }
@@ -9938,10 +10093,13 @@ function createAcpSessionBridge(opts) {
             ...info.transportFailureCode ? {
               "qwen-code.daemon.channel.transport_error_code": info.transportFailureCode
             } : {},
+            ...info.transportFailureDetail ? {
+              "qwen-code.daemon.channel.transport_error_detail": info.transportFailureDetail
+            } : {},
             ...exitInfo?.signalCode ? { "qwen-code.daemon.channel.signal": exitInfo.signalCode } : {}
           });
           writeStderrLine(
-            `qwen serve: channel exited (code=${exitInfo?.exitCode ?? "none"}, signal=${exitInfo?.signalCode ?? "none"}, transport=${info.transportFailed ? info.transportFailureCode ?? "failed" : "ok"}, ${sessions.length} session(s) torn down)`
+            `qwen serve: channel exited (code=${exitInfo?.exitCode ?? "none"}, signal=${exitInfo?.signalCode ?? "none"}, transport=${info.transportFailed ? info.transportFailureCode ?? "failed" : "ok"}${info.transportFailureDetail ? `, transport_detail=${info.transportFailureDetail}` : ""}, ${sessions.length} session(s) torn down)`
           );
         }
         for (const sid of sessions) {
@@ -10318,7 +10476,6 @@ function createAcpSessionBridge(opts) {
     if (ci.isDying) {
       throw new BridgeChannelClosedError("before newSession");
     }
-    ci.preserveForFirstStatusRead = false;
     ci.sessionSpawnsInFlight++;
     if (requestedSessionId !== void 0) {
       ci.client.markSessionRegistrationInFlight(requestedSessionId);
@@ -10525,14 +10682,17 @@ function createAcpSessionBridge(opts) {
           daemonOwnedStandaloneCreation
         );
       }
+      let modelApplied;
       if (modelServiceId) {
-        await applyModelServiceId(
+        modelApplied = await applyModelServiceId(
           entry,
           modelServiceId,
           initTimeoutMs,
           clientId
-        ).catch(() => {
-        });
+        ).then(
+          () => true,
+          () => false
+        );
       }
       if (approvalMode) {
         try {
@@ -10564,6 +10724,7 @@ function createAcpSessionBridge(opts) {
         ...entry.sourceId !== void 0 ? { sourceId: entry.sourceId } : {},
         ...entry.sourceType ? { sourcePersisted: sourcePersisted === true } : {},
         ...entry.parentSessionId ? { parentSessionPersisted: parentSessionPersisted === true } : {},
+        ...modelApplied !== void 0 ? { modelApplied } : {},
         ...entry.worktree ? { worktree: entry.worktree } : {},
         ...entry.branch ? { branch: entry.branch } : {}
       };
@@ -10901,8 +11062,14 @@ function createAcpSessionBridge(opts) {
     );
   }, "cacheWorkspaceMcpDetails");
   const mergeManagedWorkspaceMcpStatus = /* @__PURE__ */ __name((serverNames, previous, current) => {
-    if (Array.isArray(current.servers) && previous?.discoveryState === "completed" && current.discoveryState === "not_started") {
-      if (current.servers.length === 0) return previous;
+    if (Array.isArray(current.servers) && previous?.discoveryState === "completed" && previous.runtimeEpoch === current.runtimeEpoch && current.discoveryState === "not_started") {
+      if (current.servers.length === 0) {
+        return {
+          ...previous,
+          runtimeEpoch: current.runtimeEpoch,
+          source: current.source
+        };
+      }
       const currentServers = new Map(
         current.servers.map((server) => [server.name, server])
       );
@@ -10919,6 +11086,8 @@ function createAcpSessionBridge(opts) {
       }
       return {
         ...previous,
+        runtimeEpoch: current.runtimeEpoch,
+        source: current.source,
         discoveryState: "completed",
         servers
       };
@@ -10929,7 +11098,10 @@ function createAcpSessionBridge(opts) {
     const info = liveChannelInfo();
     if (!info) {
       if (method === SERVE_STATUS_EXT_METHODS.workspaceMcp && workspaceMcpStatusCache) {
-        return workspaceMcpStatusCache;
+        return {
+          ...workspaceMcpStatusCache,
+          source: "cache"
+        };
       }
       return idle();
     }
@@ -10945,6 +11117,13 @@ function createAcpSessionBridge(opts) {
         initTimeoutMs,
         method
       );
+      if (isRecord3(response) && (method === SERVE_STATUS_EXT_METHODS.workspaceMcp || method === SERVE_STATUS_EXT_METHODS.workspaceMcpTools || method === SERVE_STATUS_EXT_METHODS.workspaceMcpResources)) {
+        response = {
+          ...response,
+          runtimeEpoch,
+          ...method === SERVE_STATUS_EXT_METHODS.workspaceMcp ? { source: "live" } : {}
+        };
+      }
       if (method === SERVE_STATUS_EXT_METHODS.workspaceMcp) {
         const rawStatus = response;
         if (!Array.isArray(rawStatus.servers)) {
@@ -10955,7 +11134,7 @@ function createAcpSessionBridge(opts) {
           ...info.workspaceMcpAuthenticationServerNames,
           ...managedServerNames ?? []
         ]);
-        if (effectiveManagedServerNames.size > 0 || workspaceMcpStatusCache?.discoveryState === "completed" && rawStatus.discoveryState === "not_started" && rawServers.length === 0) {
+        if (effectiveManagedServerNames.size > 0) {
           response = mergeManagedWorkspaceMcpStatus(
             effectiveManagedServerNames,
             workspaceMcpStatusCache,
@@ -10992,6 +11171,8 @@ function createAcpSessionBridge(opts) {
             const timer = info.workspaceMcpAuthenticationTimers.get(serverName);
             if (timer) clearTimeout(timer);
             info.workspaceMcpAuthenticationTimers.delete(serverName);
+            info.workspaceMcpAuthenticationReleases.get(serverName)?.();
+            info.workspaceMcpAuthenticationReleases.delete(serverName);
           }
         }
         workspaceMcpStatusCache = response;
@@ -11359,7 +11540,8 @@ function createAcpSessionBridge(opts) {
       deferredArtifactInputCount: 0,
       attachments: new SessionAttachmentStore(
         opts.sessionAttachmentsRoot,
-        sessionId
+        sessionId,
+        opts.sessionAttachmentsFallbackRoot
       ),
       recordingDegraded: false,
       closing: false,
@@ -12184,7 +12366,6 @@ function createAcpSessionBridge(opts) {
         throw new BridgeChannelClosedError(`before session/${action}`);
       }
       ci = restoreChannel;
-      restoreChannel.preserveForFirstStatusRead = false;
       restoreChannel.pendingRestoreIds.add(req.sessionId);
       restoreChannel.client.markRestoreInFlight(req.sessionId);
       const transportClosed = channelUnavailableReject(
@@ -14079,7 +14260,8 @@ function createAcpSessionBridge(opts) {
           if (opts.sessionAttachmentsRoot) {
             const branchAttachments = new SessionAttachmentStore(
               opts.sessionAttachmentsRoot,
-              result.newSessionId
+              result.newSessionId,
+              opts.sessionAttachmentsFallbackRoot
             );
             try {
               await branchAttachments.copyFrom(entry.attachments);
@@ -14463,11 +14645,17 @@ function createAcpSessionBridge(opts) {
         hasControlCharacter2(pr.url) || pr.state !== void 0 && pr.state !== "open" && pr.state !== "merged" && pr.state !== "closed") {
           throw new InvalidSessionMetadataError(
             "pr",
-            `must be an object with a positive integer \`number\` and an http(s) \`url\` of at most ${SESSION_PR_URL_MAX_LENGTH} characters, without control characters, and an optional \`state\` of \`open\`, \`merged\`, or \`closed\``
+            `must be an object with a positive integer \`number\` and an http(s) \`url\` of at most ${SESSION_PR_URL_MAX_LENGTH} characters, without control characters, and an optional \`state\` that is one of \`open\`, \`merged\`, or \`closed\``
           );
         }
       }
       if (metadata.displayName !== void 0) {
+        if (metadata.titleSource !== void 0 && metadata.titleSource !== "manual" && metadata.titleSource !== "auto") {
+          throw new InvalidSessionMetadataError(
+            "titleSource",
+            "must be either `manual` or `auto`"
+          );
+        }
         if (typeof metadata.displayName !== "string" || metadata.displayName.length > MAX_DISPLAY_NAME_LENGTH) {
           throw new InvalidSessionMetadataError(
             "displayName",
@@ -14480,7 +14668,14 @@ function createAcpSessionBridge(opts) {
             "must not contain control characters"
           );
         }
+        if (metadata.displayName.trim() === "") {
+          throw new InvalidSessionMetadataError(
+            "displayName",
+            "must not be empty"
+          );
+        }
         const nextDisplayName = metadata.displayName || void 0;
+        const titleSource = metadata.titleSource ?? "manual";
         if (entry.displayName !== nextDisplayName) {
           entry.displayName = nextDisplayName;
           markSessionCatalogChanged();
@@ -14491,7 +14686,7 @@ function createAcpSessionBridge(opts) {
             entry.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTitle, {
               sessionId,
               displayName: nextDisplayName,
-              titleSource: "manual"
+              titleSource
             }).then((res) => {
               const r = res;
               if (r && r.persisted === false) {
@@ -14508,7 +14703,11 @@ function createAcpSessionBridge(opts) {
           try {
             entry.events.publish({
               type: "session_metadata_updated",
-              data: { sessionId, displayName: entry.displayName },
+              data: {
+                sessionId,
+                displayName: entry.displayName,
+                ...entry.displayName ? { titleSource } : {}
+              },
               ...metadataOriginatorClientId ? { originatorClientId: metadataOriginatorClientId } : {}
             });
           } catch {
@@ -14533,7 +14732,9 @@ function createAcpSessionBridge(opts) {
               url: bound.url,
               ...bound.state ?? known?.state ? {
                 state: bound.state ?? known?.state
-              } : {}
+              } : {},
+              // The issue snapshot is daemon-derived, never client-bound.
+              ...known?.issues ? { issues: known.issues } : {}
             }
           ].slice(-SESSION_PR_LIST_LIMIT);
           markSessionCatalogChanged();
@@ -14564,20 +14765,33 @@ function createAcpSessionBridge(opts) {
     seedSessionPrs(sessionId, prs) {
       const entry = byId.get(sessionId);
       if (!entry || entry.prs && entry.prs.length > 0) return;
-      entry.prs = prs.map(({ number, url, state }) => ({
-        number,
-        url,
-        ...state ? { state } : {}
-      })).slice(-SESSION_PR_LIST_LIMIT);
+      entry.prs = prs.map(toSessionPrInfo).slice(-SESSION_PR_LIST_LIMIT);
     },
     setSessionPrs(sessionId, prs) {
       const entry = byId.get(sessionId);
       if (!entry) return;
-      entry.prs = prs.map(({ number, url, state }) => ({
-        number,
-        url,
-        ...state ? { state } : {}
-      })).slice(-SESSION_PR_LIST_LIMIT);
+      const next = prs.map(toSessionPrInfo).slice(-SESSION_PR_LIST_LIMIT);
+      const current = entry.prs ?? [];
+      const sameIssueList = /* @__PURE__ */ __name((left, right) => JSON.stringify(left ?? null) === JSON.stringify(right ?? null), "sameIssueList");
+      const unchanged = current.length === next.length && current.every(
+        (p, index) => p.number === next[index].number && p.url === next[index].url && p.state === next[index].state && sameIssueList(p.issues, next[index].issues)
+      );
+      entry.prs = next;
+      if (unchanged) return;
+      markSessionCatalogChanged();
+      try {
+        entry.events.publish({
+          type: "session_metadata_updated",
+          data: {
+            sessionId,
+            // Echo the current name: SDK folds treat an absent displayName
+            // as "cleared", so a pr-only event must not blank the title.
+            ...entry.displayName !== void 0 ? { displayName: entry.displayName } : {},
+            prs: entry.prs
+          }
+        });
+      } catch {
+      }
     },
     async getSessionArtifacts(sessionId, context) {
       const entry = byId.get(sessionId);
@@ -15266,6 +15480,21 @@ function createAcpSessionBridge(opts) {
         refreshed: result.refreshed ?? false
       };
     },
+    async setUserLanguage(params) {
+      const info = liveChannelInfo();
+      if (!info) throw new SessionNotFoundError("user-language");
+      return await withTimeout(
+        Promise.race([
+          info.connection.extMethod(SERVE_CONTROL_EXT_METHODS.userLanguage, {
+            language: params.language,
+            syncOutputLanguage: params.syncOutputLanguage
+          }),
+          getChannelClosedReject(info)
+        ]),
+        initTimeoutMs,
+        SERVE_CONTROL_EXT_METHODS.userLanguage
+      );
+    },
     async setSessionLiveConversationActive(sessionId, active) {
       await requestSessionStatus(
         sessionId,
@@ -15489,7 +15718,11 @@ function createAcpSessionBridge(opts) {
       return await entry.attachments.remove(attachmentId);
     },
     async deleteSessionAttachments(sessionId, options) {
-      const store = byId.get(sessionId)?.attachments ?? new SessionAttachmentStore(opts.sessionAttachmentsRoot, sessionId);
+      const store = byId.get(sessionId)?.attachments ?? new SessionAttachmentStore(
+        opts.sessionAttachmentsRoot,
+        sessionId,
+        opts.sessionAttachmentsFallbackRoot
+      );
       await store.delete(options);
     },
     removePendingPrompt(sessionId, promptId, context) {
@@ -16121,51 +16354,78 @@ function createAcpSessionBridge(opts) {
       return rewindResult;
     },
     async manageMcpServer(serverName, action, originatorClientId) {
-      return await withEnsuredWorkspaceControl(async (info) => {
-        const timeout = action === "authenticate" ? MCP_OAUTH_TIMEOUT_MS : MCP_RESTART_TIMEOUT_MS;
-        const response = await Promise.race([
-          withTimeout(
-            info.connection.extMethod(
-              SERVE_CONTROL_EXT_METHODS.workspaceMcpManage,
-              { serverName, action, originatorClientId }
-            ),
-            timeout,
-            SERVE_CONTROL_EXT_METHODS.workspaceMcpManage
-          ),
-          getChannelClosedReject(info)
-        ]);
-        if (action === "authenticate" && response.pending) {
-          info.workspaceMcpAuthenticationServerNames.add(serverName);
-          const previousTimer = info.workspaceMcpAuthenticationTimers.get(serverName);
-          if (previousTimer) clearTimeout(previousTimer);
-          const timer = setTimeout(() => {
-            void expireWorkspaceMcpAuthentication(info, serverName, timer);
-          }, MCP_OAUTH_TIMEOUT_MS);
-          timer.unref();
-          info.workspaceMcpAuthenticationTimers.set(serverName, timer);
-        }
-        invalidateWorkspaceMcpDetailCache(serverName);
-        await requestWorkspaceStatus(
-          SERVE_STATUS_EXT_METHODS.workspaceMcp,
-          () => {
-            throw new BridgeChannelClosedError(
-              "workspace MCP management status refresh"
+      let releaseAuthentication = action === "authenticate" ? opts.acquireMcpAuthentication?.(boundWorkspace, serverName) : void 0;
+      if (action === "authenticate" && opts.acquireMcpAuthentication && !releaseAuthentication) {
+        throw new McpAuthenticationInProgressError();
+      }
+      try {
+        return await withEnsuredWorkspaceControl(async (info) => {
+          if (releaseAuthentication) {
+            info.workspaceMcpAuthenticationReleases.set(
+              serverName,
+              releaseAuthentication
             );
-          },
-          {},
-          /* @__PURE__ */ new Set([serverName])
-        );
-        broadcastWorkspaceEvent({
-          type: "mcp_server_changed",
-          data: {
-            serverName: response.serverName,
-            action: response.action,
-            originatorClientId
-          },
-          ...originatorClientId ? { originatorClientId } : {}
+            releaseAuthentication = void 0;
+          }
+          const timeout = action === "authenticate" ? MCP_OAUTH_TIMEOUT_MS : MCP_RESTART_TIMEOUT_MS;
+          let response;
+          try {
+            response = await Promise.race([
+              withTimeout(
+                info.connection.extMethod(
+                  SERVE_CONTROL_EXT_METHODS.workspaceMcpManage,
+                  { serverName, action, originatorClientId }
+                ),
+                timeout,
+                SERVE_CONTROL_EXT_METHODS.workspaceMcpManage
+              ),
+              getChannelClosedReject(info)
+            ]);
+          } catch (error) {
+            if (action === "authenticate" && !(error instanceof BridgeTimeoutError) && !(error instanceof BridgeChannelClosedError)) {
+              info.workspaceMcpAuthenticationReleases.get(serverName)?.();
+              info.workspaceMcpAuthenticationReleases.delete(serverName);
+            }
+            throw error;
+          }
+          if (action === "authenticate" && response.pending) {
+            info.workspaceMcpAuthenticationServerNames.add(serverName);
+            const previousTimer = info.workspaceMcpAuthenticationTimers.get(serverName);
+            if (previousTimer) clearTimeout(previousTimer);
+            const timer = setTimeout(() => {
+              void expireWorkspaceMcpAuthentication(info, serverName, timer);
+            }, MCP_OAUTH_TIMEOUT_MS);
+            timer.unref();
+            info.workspaceMcpAuthenticationTimers.set(serverName, timer);
+          } else if (action === "authenticate") {
+            info.workspaceMcpAuthenticationReleases.get(serverName)?.();
+            info.workspaceMcpAuthenticationReleases.delete(serverName);
+          }
+          invalidateWorkspaceMcpDetailCache(serverName);
+          await requestWorkspaceStatus(
+            SERVE_STATUS_EXT_METHODS.workspaceMcp,
+            () => {
+              throw new BridgeChannelClosedError(
+                "workspace MCP management status refresh"
+              );
+            },
+            {},
+            /* @__PURE__ */ new Set([serverName])
+          );
+          broadcastWorkspaceEvent({
+            type: "mcp_server_changed",
+            data: {
+              serverName: response.serverName,
+              action: response.action,
+              originatorClientId
+            },
+            ...originatorClientId ? { originatorClientId } : {}
+          });
+          return response;
         });
-        return response;
-      });
+      } finally {
+        releaseAuthentication?.();
+      }
     },
     async initializeWorkspaceMcp() {
       return await withEnsuredWorkspaceControl(async (info) => {
@@ -16638,15 +16898,12 @@ function createAcpSessionBridge(opts) {
           "channel.preheat",
           { "qwen-code.daemon.bridge.operation": "channel.preheat" },
           async () => {
-            const existing = liveChannelInfo();
-            const info = await ensureChannel();
+            await ensureChannel();
             if (keepAliveMs !== void 0) {
               keepAliveUntil = Math.max(
                 keepAliveUntil,
                 Date.now() + keepAliveMs
               );
-            } else if (!existing && configuredChannelIdleTimeoutMs() === 0 && hasNoSessionWork(info)) {
-              info.preserveForFirstStatusRead = true;
             }
           }
         );