@qwen-code/qwen-code 0.21.9 → 0.21.10

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

@@ -50,6 +50,7 @@ import {
   LOAD_REPLAY_PAGE_SIZE_META_KEY,
   LOAD_REPLAY_VERSION,
   MID_TURN_QUEUE_DRAIN_METHOD,
+  MID_TURN_RECONCILIATION_RING_SIZE,
   PROMPT_CANCEL_METHOD,
   REQUESTED_SESSION_ID_META_KEY,
   TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD,
@@ -57,7 +58,7 @@ import {
   WORKTREE_MCP_DEFER_META_KEY,
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt
-} from "./chunk-M2PNLYGY.js";
+} from "./chunk-W5UC37EE.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -79,7 +80,7 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-LP2QGNSP.js";
+} from "./chunk-624NHDGB.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
@@ -113,7 +114,7 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-XX7QFP34.js";
+} from "./chunk-EI3NWELG.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
@@ -2414,34 +2415,36 @@ var BridgeClient = class {
     const entry = this.resolveEntry(sessionId);
     if (!entry) return { messages: [], hasQueuedPrompt: false };
     const drained = entry.midTurnMessageQueue.splice(0);
-    const messages = drained.map((item) => item.text);
-    const hasQueuedPrompt = entry.pendingPromptList.some(
-      (prompt) => prompt.state === "queued" && !prompt.abortController.signal.aborted
-    );
     if (drained.length > 0) {
-      const byOriginator = /* @__PURE__ */ new Map();
       for (const item of drained) {
-        const group = byOriginator.get(item.originatorClientId);
-        if (group) group.push(item);
-        else byOriginator.set(item.originatorClientId, [item]);
-      }
-      for (const [originatorClientId, items] of byOriginator) {
-        const texts = items.map((item) => item.text);
-        const published = entry.events.publish({
-          type: MID_TURN_MESSAGE_INJECTED_EVENT,
-          ...entry.activePromptId ? { promptId: entry.activePromptId } : {},
-          data: {
-            sessionId: entry.sessionId,
-            messages: texts,
-            messageIds: items.map((item) => item.messageId)
-          },
-          ...originatorClientId ? { originatorClientId } : {}
-        });
-        writeStderrLine(
-          published ? `[mid-turn] session=${entry.sessionId} drained=${texts.length}${originatorClientId ? ` originator=${originatorClientId}` : ""} injected into running turn` : `[mid-turn] session=${entry.sessionId} drained=${texts.length} echo frame dropped (bus closed); browser may resend next turn`
+        entry.settledMidTurnMessageIds.push(item.messageId);
+      }
+      if (entry.settledMidTurnMessageIds.length > MID_TURN_RECONCILIATION_RING_SIZE) {
+        entry.settledMidTurnMessageIds.splice(
+          0,
+          entry.settledMidTurnMessageIds.length - MID_TURN_RECONCILIATION_RING_SIZE
         );
       }
     }
+    const echoed = drained.filter((item) => !item.queueOnly);
+    const messages = drained.map((item) => item.text);
+    const hasQueuedPrompt = entry.pendingPromptList.some(
+      (prompt) => prompt.state === "queued" && !prompt.abortController.signal.aborted
+    );
+    if (echoed.length > 0) {
+      const published = entry.events.publish({
+        type: MID_TURN_MESSAGE_INJECTED_EVENT,
+        ...entry.activePromptId ? { promptId: entry.activePromptId } : {},
+        data: {
+          sessionId: entry.sessionId,
+          messages: echoed.map((item) => item.text),
+          messageIds: echoed.map((item) => item.messageId)
+        }
+      });
+      writeStderrLine(
+        published ? `[mid-turn] session=${entry.sessionId} drained=${messages.length} echoed=${echoed.length} injected into running turn` : `[mid-turn] session=${entry.sessionId} drained=${messages.length} echoed=${echoed.length} echo frame dropped (bus closed); reconciliation required`
+      );
+    }
     return { messages, hasQueuedPrompt };
   }
   async handleExternalToolGuardPrepare(params) {
@@ -6385,6 +6388,7 @@ var SESSION_GENERATION_TIMEOUT_MS = 65e3;
 var GENERATION_STREAM_QUEUE_CAPACITY = 128;
 var SESSION_BTW_TIMEOUT_MS = 6e4;
 var SESSION_TRANSCRIPT_TIMEOUT_MS = 6e4;
+var MAX_EMPTY_TRANSCRIPT_PAGES = 20;
 var SHELL_COMMAND_TIMEOUT_MS = 12e4;
 var MAX_SHELL_OUTPUT_FOR_HISTORY = 1e4;
 var MAX_MID_TURN_QUEUE_DEPTH = 20;
@@ -8236,6 +8240,8 @@ function createAcpSessionBridge(opts) {
       pendingAgentNotificationCount: 0,
       pendingPromptList: [],
       midTurnMessageQueue: [],
+      settledMidTurnMessageIds: [],
+      promotedMidTurnMessageIds: [],
       modelChangeQueue: Promise.resolve(),
       approvalModeQueue: Promise.resolve(),
       modelPublishGeneration: 0,
@@ -8486,11 +8492,26 @@ function createAcpSessionBridge(opts) {
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
         const lastEventId = entry.events.lastEventId;
-        const page = await requestSessionTranscriptPage({
-          sessionId: entry.sessionId,
-          direction: "backward",
-          limit: historyPageSize
-        });
+        const seenCursors = /* @__PURE__ */ new Set();
+        let emptyPageCount = 0;
+        let cursor;
+        let page;
+        do {
+          page = await requestSessionTranscriptPage({
+            sessionId: entry.sessionId,
+            ...cursor ? { cursor } : { direction: "backward" },
+            limit: historyPageSize
+          });
+          const nextCursor = page.nextCursor;
+          if (page.events.length === 0 && page.hasMore && (nextCursor === void 0 || seenCursors.has(nextCursor))) {
+            throw new Error("Transcript cursor did not advance");
+          }
+          if (page.events.length === 0 && page.hasMore && ++emptyPageCount >= MAX_EMPTY_TRANSCRIPT_PAGES) {
+            throw new Error("Transcript empty-page limit exceeded");
+          }
+          cursor = nextCursor;
+          if (cursor !== void 0) seenCursors.add(cursor);
+        } while (page.events.length === 0 && page.hasMore && cursor !== void 0 && page.partial !== true && page.replayError === void 0);
         if (byId.get(entry.sessionId) === entry && !entry.promptActive && entry.events.lastEventId === lastEventId) {
           return {
             compactedReplay: page.events,
@@ -8565,14 +8586,22 @@ function createAcpSessionBridge(opts) {
       if (isClosingOrAuthorizingClose(existing)) {
         throw new SessionNotFoundError(
           req.sessionId,
-          "The session is closing; retry after close completes"
+          "The session is closing; retry after close completes",
+          "session_closing"
         );
       }
       const replayFields = action === "load" && req.historyPageSize !== void 0 ? await refreshedReplayFieldsFor(existing, req.historyPageSize) : replayFieldsFor(existing, action);
       const historyAnchorRecordId = action === "load" ? await resolveHistoryAnchorRecordId(existing, replayFields) : void 0;
-      if (byId.get(req.sessionId) !== existing || isClosingOrAuthorizingClose(existing)) {
+      if (byId.get(req.sessionId) !== existing) {
         throw new SessionNotFoundError(req.sessionId);
       }
+      if (isClosingOrAuthorizingClose(existing)) {
+        throw new SessionNotFoundError(
+          req.sessionId,
+          "The session is closing; retry after close completes",
+          "session_closing"
+        );
+      }
       existing.attachCount++;
       const clientId = registerClient(existing, req.clientId);
       recordAttachRef(existing, clientId);
@@ -8950,7 +8979,8 @@ function createAcpSessionBridge(opts) {
         if (isClosingOrAuthorizingClose(racedEntry)) {
           throw new SessionNotFoundError(
             req.sessionId,
-            "The session is closing; retry after close completes"
+            "The session is closing; retry after close completes",
+            "session_closing"
           );
         }
         racedEntry.attachCount += 1 + coalesceState.count;
@@ -9138,7 +9168,8 @@ function createAcpSessionBridge(opts) {
     if (entry.closing) {
       throw new SessionNotFoundError(
         sessionId,
-        "The session is already closing"
+        "The session is already closing",
+        "session_closing"
       );
     }
     let originatorClientId;
@@ -9243,6 +9274,36 @@ function createAcpSessionBridge(opts) {
   }
   __name(closeSessionImpl, "closeSessionImpl");
   startSessionReaper();
+  const rememberMidTurnId = /* @__PURE__ */ __name((ring, messageId) => {
+    ring.push(messageId);
+    if (ring.length > MID_TURN_RECONCILIATION_RING_SIZE) {
+      ring.splice(0, ring.length - MID_TURN_RECONCILIATION_RING_SIZE);
+    }
+  }, "rememberMidTurnId");
+  const promoteMidTurnMessage = /* @__PURE__ */ __name((entry, messageId, text, originatorClientId) => {
+    void bridgeApi.sendPrompt(
+      entry.sessionId,
+      {
+        sessionId: entry.sessionId,
+        prompt: [{ type: "text", text }]
+      },
+      void 0,
+      {
+        promptId: messageId,
+        promotedMidTurn: { originatorClientId },
+        // Record the id only once sendPrompt owns its FIFO slot: an
+        // admission failure must not land the id in the reconciliation
+        // ring, or retries would be acked for a message that never runs.
+        onPromptAdmitted: /* @__PURE__ */ __name(() => {
+          rememberMidTurnId(entry.promotedMidTurnMessageIds, messageId);
+        }, "onPromptAdmitted")
+      }
+    ).catch((error) => {
+      writeStderrLine(
+        `[mid-turn] session=${JSON.stringify(entry.sessionId)} failed to run promoted message ${JSON.stringify(messageId)}: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
+      );
+    });
+  }, "promoteMidTurnMessage");
   const bridgeApi = {
     setLiveScreenContextCaptureHandler(handler) {
       liveScreenContextCaptureHandler = handler;
@@ -9389,7 +9450,8 @@ function createAcpSessionBridge(opts) {
           if (isClosingOrAuthorizingClose(existing)) {
             throw new SessionNotFoundError(
               existing.sessionId,
-              "The session is closing; retry after close completes"
+              "The session is closing; retry after close completes",
+              "session_closing"
             );
           }
           existing.attachCount++;
@@ -9549,14 +9611,14 @@ function createAcpSessionBridge(opts) {
         return Promise.reject(
           new SessionNotFoundError(
             sessionId,
-            "The session is closing; retry after close completes"
+            "The session is closing; retry after close completes",
+            "session_closing"
           )
         );
       }
-      const originatorClientId = resolveTrustedClientId(
-        entry,
-        context?.clientId
-      );
+      const promotedMidTurn = context?.promotedMidTurn;
+      const isPromotedMidTurn = promotedMidTurn !== void 0;
+      const originatorClientId = promotedMidTurn ? promotedMidTurn.originatorClientId : resolveTrustedClientId(entry, context?.clientId);
       const modelPrompt = context?.modelPrompt;
       if (modelPrompt !== void 0 && !isValidTrustedModelPrompt(modelPrompt)) {
         throw new TypeError(
@@ -9566,7 +9628,7 @@ function createAcpSessionBridge(opts) {
       if (signal?.aborted) {
         throw new DOMException("Prompt aborted", "AbortError");
       }
-      if (entry.pendingPromptCount >= maxPendingPromptsPerSession) {
+      if (!isPromotedMidTurn && entry.pendingPromptCount >= maxPendingPromptsPerSession) {
         throw new PromptQueueFullError(
           maxPendingPromptsPerSession,
           entry.pendingPromptCount,
@@ -9604,6 +9666,7 @@ function createAcpSessionBridge(opts) {
         promptId,
         queuedAt,
         ...originatorClientId !== void 0 ? { originatorClientId } : {},
+        ...isPromotedMidTurn ? { promotedMidTurn: true } : {},
         text: extractPromptText(req.prompt),
         abortController: pendingAbort,
         state: isQueued ? "queued" : "running"
@@ -9697,9 +9760,11 @@ function createAcpSessionBridge(opts) {
             }
             throw new DOMException("Prompt aborted", "AbortError");
           }
-          if (pendingEntry.state === "queued") {
-            delete entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId;
-            pendingEntry.state = "running";
+          if (pendingEntry.state === "queued" || isPromotedMidTurn) {
+            if (pendingEntry.state === "queued") {
+              delete entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId;
+              pendingEntry.state = "running";
+            }
             entry.events.publish({
               type: "pending_prompt_started",
               promptId: pendingEntry.promptId,
@@ -9915,12 +9980,26 @@ function createAcpSessionBridge(opts) {
             }
           }
         }
+        const shouldSettleMidTurnQueue = entry.pendingPromptCount === 1 && !entry.closing && byId.get(entry.sessionId) === entry;
+        const undrainedMessages = shouldSettleMidTurnQueue ? entry.midTurnMessageQueue.splice(0) : [];
         releasePromptSlot();
-        if (entry.pendingPromptCount === 0 && entry.midTurnMessageQueue.length > 0) {
-          writeStderrLine(
-            `[mid-turn] session=${entry.sessionId} dropped ${entry.midTurnMessageQueue.length} undrained message(s) at idle; browser resends next turn`
+        for (const message of undrainedMessages) {
+          if (message.queueOnly) {
+            try {
+              message.onSettledWithoutDrain?.();
+            } catch (error) {
+              writeStderrLine(
+                `[mid-turn] session=${JSON.stringify(entry.sessionId)} failed to hand undrained queue-only message ${JSON.stringify(message.messageId)} back to its caller: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`
+              );
+            }
+            continue;
+          }
+          promoteMidTurnMessage(
+            entry,
+            message.messageId,
+            message.text,
+            message.originatorClientId
           );
-          entry.midTurnMessageQueue.length = 0;
         }
         void maybeCloseIdleSession(entry, "prompt_settled");
       }).catch(() => {
@@ -11192,7 +11271,7 @@ function createAcpSessionBridge(opts) {
       }
       return { removed: true };
     },
-    enqueueMidTurnMessage(sessionId, message, context) {
+    enqueueMidTurnMessage(sessionId, message, context, requestedMessageId, options) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
       const originatorClientId = resolveTrustedClientId(
@@ -11200,43 +11279,139 @@ function createAcpSessionBridge(opts) {
         context?.clientId
       );
       const trimmed = message.trim();
-      if (trimmed.length === 0 || entry.pendingPromptCount === 0) {
+      if (trimmed.length === 0) {
+        writeStderrLine(
+          `[mid-turn] session=${entry.sessionId} rejected: empty`
+        );
+        return { accepted: false };
+      }
+      if (requestedMessageId !== void 0) {
+        const existing = entry.midTurnMessageQueue.find(
+          (queued) => queued.messageId === requestedMessageId
+        );
+        if (existing) {
+          if (existing.text === trimmed) {
+            return { accepted: true, messageId: requestedMessageId };
+          }
+          writeStderrLine(
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected id ${JSON.stringify(requestedMessageId)}: text mismatch`
+          );
+          return { accepted: false };
+        }
+        const promoted = entry.pendingPromptList.find(
+          (pending) => pending.promptId === requestedMessageId
+        );
+        if (promoted) {
+          if (promoted.text === trimmed) {
+            return { accepted: true, messageId: requestedMessageId };
+          }
+          writeStderrLine(
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected promoted id ${JSON.stringify(requestedMessageId)}: text mismatch`
+          );
+          return { accepted: false };
+        }
+        if (entry.settledMidTurnMessageIds.includes(requestedMessageId)) {
+          return { accepted: true, messageId: requestedMessageId };
+        }
+        if (entry.promotedMidTurnMessageIds.includes(requestedMessageId)) {
+          return { accepted: true, messageId: requestedMessageId };
+        }
+      }
+      if (isClosingOrAuthorizingClose(entry)) {
         writeStderrLine(
-          `[mid-turn] session=${entry.sessionId} rejected: ${trimmed.length === 0 ? "empty message" : "session idle"}; browser keeps it for next turn`
+          `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected: session closing`
         );
         return { accepted: false };
       }
+      const messageId = requestedMessageId ?? randomUUID2();
+      if (entry.pendingPromptCount === 0) {
+        if (options?.queueOnly) {
+          writeStderrLine(
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} rejected id ${JSON.stringify(messageId)}: session idle`
+          );
+          return { accepted: false };
+        }
+        promoteMidTurnMessage(entry, messageId, trimmed, originatorClientId);
+        return { accepted: true, messageId };
+      }
       if (entry.midTurnMessageQueue.length >= MAX_MID_TURN_QUEUE_DEPTH) {
         writeStderrLine(
-          `[mid-turn] session=${entry.sessionId} rejected: queue full (depth ${entry.midTurnMessageQueue.length} >= ${MAX_MID_TURN_QUEUE_DEPTH}); browser keeps it for next turn`
+          `[mid-turn] session=${entry.sessionId} rejected: queue full (depth ${entry.midTurnMessageQueue.length} >= ${MAX_MID_TURN_QUEUE_DEPTH})`
         );
         return { accepted: false };
       }
-      const messageId = randomUUID2();
-      entry.midTurnMessageQueue.push({
+      const queuedMessage = {
         messageId,
         text: trimmed,
-        originatorClientId
-      });
+        originatorClientId,
+        ...options?.queueOnly ? {
+          queueOnly: true,
+          onSettledWithoutDrain: options.onSettledWithoutDrain
+        } : {}
+      };
+      entry.midTurnMessageQueue.push(queuedMessage);
+      if (originatorClientId) {
+        try {
+          entry.events.publish({
+            type: "pending_prompt_added",
+            promptId: messageId,
+            data: {
+              sessionId,
+              promptId: messageId,
+              text: trimmed,
+              queuedAt: Date.now()
+            },
+            originatorClientId
+          });
+        } catch {
+        }
+      }
       return { accepted: true, messageId };
     },
     removeMidTurnMessage(sessionId, messageId, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
-      const originatorClientId = resolveTrustedClientId(
-        entry,
-        context?.clientId
-      );
+      resolveTrustedClientId(entry, context?.clientId);
       const index = entry.midTurnMessageQueue.findIndex(
-        (message) => message.messageId === messageId && message.originatorClientId === originatorClientId
+        (message) => message.messageId === messageId
       );
       if (index === -1) {
+        const isPromoted = entry.pendingPromptList.some(
+          (pending) => pending.promptId === messageId && pending.promotedMidTurn === true
+        );
+        if (!isPromoted) {
+          writeStderrLine(
+            `[mid-turn] session=${JSON.stringify(entry.sessionId)} remove missed messageId=${JSON.stringify(messageId)} (already drained or completed)`
+          );
+          return { removed: false };
+        }
+        const promoted = bridgeApi.removePendingPrompt(
+          sessionId,
+          messageId,
+          context
+        );
+        if (promoted.removed) {
+          rememberMidTurnId(entry.settledMidTurnMessageIds, messageId);
+          return promoted;
+        }
         writeStderrLine(
-          `[mid-turn] session=${JSON.stringify(entry.sessionId)} remove missed messageId=${JSON.stringify(messageId)} (already drained or originator mismatch)`
+          `[mid-turn] session=${JSON.stringify(entry.sessionId)} remove missed messageId=${JSON.stringify(messageId)} (already drained or completed)`
         );
         return { removed: false };
       }
-      entry.midTurnMessageQueue.splice(index, 1);
+      const [removed] = entry.midTurnMessageQueue.splice(index, 1);
+      rememberMidTurnId(entry.settledMidTurnMessageIds, messageId);
+      if (removed) {
+        try {
+          entry.events.publish({
+            type: "pending_prompt_completed",
+            promptId: messageId,
+            data: { sessionId, promptId: messageId, state: "removed" },
+            ...removed.originatorClientId ? { originatorClientId: removed.originatorClientId } : {}
+          });
+        } catch {
+        }
+      }
       return { removed: true };
     },
     async enqueueBackgroundNotification(sessionId, notification) {
@@ -11266,6 +11441,22 @@ function createAcpSessionBridge(opts) {
         void maybeCloseIdleSession(entry, "agent_notification_settled");
       }
     },
+    getMidTurnMessages(sessionId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      return {
+        // Anonymous enqueues (live steering) stay off the shared surface:
+        // their delegation text is not a user message other attached clients
+        // should restore into their queue views.
+        messages: entry.midTurnMessageQueue.filter((message) => message.originatorClientId !== void 0).map((message) => ({
+          messageId: message.messageId,
+          text: message.text
+        })),
+        settledMessageIds: [...entry.settledMidTurnMessageIds],
+        promotedMessageIds: [...entry.promotedMidTurnMessageIds]
+      };
+    },
     async generateSessionBtw(sessionId, question, signal, _context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -11506,7 +11697,11 @@ function createAcpSessionBridge(opts) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
       if (isClosingOrAuthorizingClose(entry)) {
-        throw new SessionNotFoundError(sessionId, "The session is closing");
+        throw new SessionNotFoundError(
+          sessionId,
+          "The session is closing; retry after close completes",
+          "session_closing"
+        );
       }
       const info = channelInfoForEntry(entry);
       if (!info || info.isDying) throw new SessionNotFoundError(sessionId);

package/chunks/{chunk-DH5YXSIF.js → chunk-F6WDTQ3M.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   t
-} from "./chunk-WP5VOXF7.js";
+} from "./chunk-UEOKWYGY.js";
 import {
   computeThresholds,
   getCoreSystemPrompt,
   resolveInteractionMode
-} from "./chunk-XX7QFP34.js";
+} from "./chunk-EI3NWELG.js";
 import {
   buildSkillLlmContent
 } from "./chunk-K623ENWT.js";

package/chunks/{chunk-ZOSTTOUJ.js → chunk-GWVUR3QZ.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-MR3PXB6E.js";
 import {
   ideContextStore
-} from "./chunk-XX7QFP34.js";
+} from "./chunk-EI3NWELG.js";
 import {
   require_proper_lockfile
 } from "./chunk-KRXPRVGL.js";

package/chunks/{chunk-BZP4QPNK.js → chunk-IBUGFUXC.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-II6G3EY6.js";
+} from "./chunk-7GTMV7UE.js";
 import {
   CUSTOM_SANDBOX_IMAGE_ENV_VAR,
   HOST_UPDATE_RELAUNCH_ENV_VAR,
   SKIP_UPDATE_CHECK_ENV_VAR,
   requestUpdateOnExit
-} from "./chunk-TZ6KJ44L.js";
+} from "./chunk-KONVMRK7.js";
 import {
   loadUndici
 } from "./chunk-3Z43GZUQ.js";
 import {
   IdeClient,
   getAllProviderBaseUrls
-} from "./chunk-XX7QFP34.js";
+} from "./chunk-EI3NWELG.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
@@ -231,11 +231,11 @@ function startPostRenderPrefetches(config, settings, options = {}) {
         { updateEventEmitter },
         { t }
       ] = await Promise.all([
-        import("./updateCheck-AXWSO7KA.js"),
-        import("./handleAutoUpdate-WV6SPZQB.js"),
-        import("./installationInfo-3YUGIP36.js"),
+        import("./updateCheck-LOS5GYFC.js"),
+        import("./handleAutoUpdate-NHFSGYTF.js"),
+        import("./installationInfo-XXB75T7O.js"),
         import("./updateEventEmitter-5MKC7BLQ.js"),
-        import("./i18n-YWJWPQKD.js")
+        import("./i18n-Q27KKNDL.js")
       ]);
       const updateCheckSkippedMessage = /* @__PURE__ */ __name((error) => t("Update check skipped ({{reason}}) \u2014 run /update to retry.", {
         reason: describeUpdateCheckFailure(error)
@@ -308,7 +308,7 @@ ${t(
         state: "connecting"
       });
       try {
-        const { connectIdeForStartup } = await import("./initializer-66OAD6GO.js");
+        const { connectIdeForStartup } = await import("./initializer-Y5DJLT43.js");
         await withTimeout(
           connectIdeForStartup(config),
           "ide_connect",
@@ -332,7 +332,7 @@ ${t(
   }
   if (config.isInteractive()) {
     runDeferredTask("background_housekeeping", async () => {
-      const { startBackgroundHousekeeping } = await import("./scheduler-YNQNOU2E.js");
+      const { startBackgroundHousekeeping } = await import("./scheduler-K3D5Z655.js");
       startBackgroundHousekeeping(config, settings);
     });
   }

package/chunks/{chunk-SCAZZ3Q4.js → chunk-IRZ2ZH72.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   getErrorMessage
-} from "./chunk-P2FK2HBV.js";
+} from "./chunk-DCZEPFB4.js";
 import {
   extensionToOutputString,
   getExtensionManager
-} from "./chunk-HADWBW5R.js";
+} from "./chunk-UMD7WQTR.js";
 import {
   loadSettings
-} from "./chunk-JUWS2Z5K.js";
+} from "./chunk-ABVRJU3D.js";
 import {
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-WP5VOXF7.js";
+} from "./chunk-UEOKWYGY.js";
 import {
   writeStderrLine,
   writeStdoutLine

package/chunks/{chunk-OGNFHGIG.js → chunk-IWTMYQ32.js}

@@ -21,7 +21,7 @@ import {
 import {
   formatHistoryGapNotice,
   indexGapsByChild
-} from "./chunk-UYAUA63Q.js";
+} from "./chunk-ZRBMO3C7.js";
 import {
   stringWidth
 } from "./chunk-2MIN6GRR.js";
@@ -33,11 +33,11 @@ import {
 } from "./chunk-3SH53ANB.js";
 import {
   t
-} from "./chunk-WP5VOXF7.js";
+} from "./chunk-UEOKWYGY.js";
 import {
   getToolResponseDisplayText,
   isGoalCheckpointBookkeepingRecord
-} from "./chunk-XX7QFP34.js";
+} from "./chunk-EI3NWELG.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
@@ -45,7 +45,7 @@ import {
   GoalPersistenceUnavailableError,
   parseGoalStateRecordPayloadV2,
   projectUserTranscriptForDisplay
-} from "./chunk-67N6HB5H.js";
+} from "./chunk-QUI267ZP.js";
 import {
   ToolDisplayNames
 } from "./chunk-PYQADEFD.js";

package/chunks/{chunk-CG3WBKJK.js → chunk-JT7XS4YW.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   CHANNEL_STARTUP_PROFILE_VERSION
-} from "./chunk-M2PNLYGY.js";
+} from "./chunk-W5UC37EE.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";