@qwen-code/qwen-code 0.21.1-simplify-system-prompt.0 → 0.21.2

package/chunks/{chunk-66RMLJHC.js → chunk-44F4LBWZ.js}

@@ -8,21 +8,41 @@ import {
   serializedBridgeEventByteLength
 } from "./chunk-GLWP3FDB.js";
 import {
-  normalizeCompactedReplayMaxBytes
-} from "./chunk-COH43MRJ.js";
+  normalizeCompactedReplayMaxBytes,
+  normalizeMaxJournalBytes,
+  normalizeMaxJournalEvents
+} from "./chunk-XCGIMOLN.js";
+import {
+  MCP_RESTART_SERVER_DEADLINE_MS
+} from "./chunk-OCPBI7J5.js";
+import {
+  defaultSpawnChannelFactory
+} from "./chunk-XUGZYLDH.js";
+import {
+  BridgeChannelClosedError,
+  BridgeTimeoutError,
+  SERVE_CONTROL_EXT_METHODS,
+  SERVE_STATUS_EXT_METHODS,
+  STATUS_SCHEMA_VERSION,
+  createIdleWorkspaceExtensionsStatus,
+  createIdleWorkspaceHooksStatus
+} from "./chunk-GURGAJTX.js";
 import {
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
   DAEMON_CHANNEL_DELIVERY_META_KEY,
   LOAD_REPLAY_BULK_MODE,
+  LOAD_REPLAY_HIDE_INHERITED_META_KEY,
   LOAD_REPLAY_META_KEY,
   LOAD_REPLAY_MODE_META_KEY,
   LOAD_REPLAY_PAGE_SIZE_META_KEY,
   LOAD_REPLAY_VERSION,
   MID_TURN_QUEUE_DRAIN_METHOD,
   PROMPT_CANCEL_METHOD,
-  TODO_STOP_GUARD_QUEUE_RELEASE_METHOD
-} from "./chunk-3SJ43L4W.js";
+  TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD,
+  TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
+  WORKTREE_MCP_DEFER_META_KEY
+} from "./chunk-CPZAH673.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -32,7 +52,6 @@ import {
   InvalidRewindTargetError,
   InvalidSessionMetadataError,
   InvalidSessionScopeError,
-  MCP_RESTART_SERVER_DEADLINE_MS,
   PermissionForbiddenError,
   PromptDeadlineExceededError,
   PromptQueueFullError,
@@ -44,19 +63,7 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-UH3WSE5L.js";
-import {
-  defaultSpawnChannelFactory
-} from "./chunk-A6UO2C7C.js";
-import {
-  BridgeChannelClosedError,
-  BridgeTimeoutError,
-  SERVE_CONTROL_EXT_METHODS,
-  SERVE_STATUS_EXT_METHODS,
-  STATUS_SCHEMA_VERSION,
-  createIdleWorkspaceExtensionsStatus,
-  createIdleWorkspaceHooksStatus
-} from "./chunk-KU5XMLDK.js";
+} from "./chunk-B4AJNNOL.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
@@ -82,16 +89,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-DM4Q4JJH.js";
+} from "./chunk-54YCNSK5.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-BO4XCS7P.js";
+} from "./chunk-Z3S5EMOW.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-RWS5VYWC.js";
+} from "./chunk-DUNI4EBW.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -136,16 +143,14 @@ function replayRecordId(event) {
   return typeof recordId === "string" ? recordId : void 0;
 }
 __name(replayRecordId, "replayRecordId");
-var DEFAULT_MAX_JOURNAL_EVENTS = 2e3;
-var DEFAULT_MAX_JOURNAL_BYTES = 2 * 1024 * 1024;
-function normalizeJournalCap(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError(`${name} must be a positive safe integer`);
+function lastRecordIdIn(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const id = replayRecordId(events[i]);
+    if (id !== void 0) return id;
   }
-  return value;
+  return void 0;
 }
-__name(normalizeJournalCap, "normalizeJournalCap");
+__name(lastRecordIdIn, "lastRecordIdIn");
 var TurnBoundaryCompactionEngine = class {
   static {
     __name(this, "TurnBoundaryCompactionEngine");
@@ -166,6 +171,24 @@ var TurnBoundaryCompactionEngine = class {
   closed = false;
   truncatedEvents = 0;
   truncatedTurns = 0;
+  // Most recent `qwen.session.recordId` observed on an ingested or seeded
+  // `session_update`. Surfaced on the `history_truncated` marker emitted by
+  // `snapshot()` so clients that lost every turn-boundary event from their
+  // retained window (e.g. a live-journal truncation during a single long
+  // in-flight turn) still have an anchor for `beforeRecordId` transcript
+  // pagination. Undefined until at least one recordId has been observed;
+  // omitted from the marker in that case.
+  activeRecordId;
+  // Pagination anchor for the replay-path `history_truncated` marker,
+  // frozen at the first replay-window eviction. Prefers the first
+  // retained recordId (the eviction boundary, so `beforeRecordId`
+  // fetches exactly the dropped records with no overlap); falls back to
+  // the last dropped recordId when the retained window carries no
+  // recordId. Deliberately NOT `activeRecordId` — that one is advanced
+  // by `ingest()` on every turn boundary and, when a retained segment
+  // carries the last seed recordId, would place the anchor inside the
+  // retained window and re-fetch records the client already displays.
+  replayAnchorRecordId;
   slots = [];
   toolSlotIndex = /* @__PURE__ */ new Map();
   textSlotIndex = {
@@ -174,16 +197,8 @@ var TurnBoundaryCompactionEngine = class {
   };
   constructor(opts = {}) {
     this.maxReplayBytes = normalizeCompactedReplayMaxBytes(opts.maxReplayBytes);
-    this.maxJournalEvents = normalizeJournalCap(
-      opts.maxJournalEvents,
-      DEFAULT_MAX_JOURNAL_EVENTS,
-      "maxJournalEvents"
-    );
-    this.maxJournalBytes = normalizeJournalCap(
-      opts.maxJournalBytes,
-      DEFAULT_MAX_JOURNAL_BYTES,
-      "maxJournalBytes"
-    );
+    this.maxJournalEvents = normalizeMaxJournalEvents(opts.maxJournalEvents);
+    this.maxJournalBytes = normalizeMaxJournalBytes(opts.maxJournalBytes);
     this.onReplayWindowEviction = opts.onReplayWindowEviction;
   }
   ingest(event, byteLength) {
@@ -192,6 +207,10 @@ var TurnBoundaryCompactionEngine = class {
       this.lastEventId = event.id;
     }
     if (TRANSIENT_TYPES.has(event.type)) return;
+    const seenRecordId = replayRecordId(event);
+    if (seenRecordId !== void 0) {
+      this.activeRecordId = seenRecordId;
+    }
     this.liveJournal.push(event);
     const bytes = byteLength ?? serializedBridgeEventByteLength(event) ?? 0;
     this.journalEntryBytes.push(bytes);
@@ -230,6 +249,8 @@ var TurnBoundaryCompactionEngine = class {
           retainedEvents: this.liveJournal.length,
           maxBytes: this.maxJournalBytes,
           maxEvents: this.maxJournalEvents,
+          // Pagination anchor — see makeHistoryTruncatedEvent.
+          ...this.activeRecordId !== void 0 ? { recordId: this.activeRecordId } : {},
           fullTranscriptAvailable: true
         }
       });
@@ -244,6 +265,8 @@ var TurnBoundaryCompactionEngine = class {
     if (this.closed) return;
     this.resetReplayWindow();
     this.lastEventId = snapshot.lastEventId;
+    this.activeRecordId = void 0;
+    this.activeRecordId = lastRecordIdIn(snapshot.compactedTurns);
     for (const event of snapshot.compactedTurns) {
       if (TRANSIENT_TYPES.has(event.type)) continue;
       this.addReplaySegment([event], 0);
@@ -256,6 +279,8 @@ var TurnBoundaryCompactionEngine = class {
   seedReplayEvents(events) {
     if (this.closed) return;
     this.resetReplayWindow();
+    this.activeRecordId = void 0;
+    this.activeRecordId = lastRecordIdIn(events);
     let recordEvents = [];
     let recordId;
     const flushRecord = /* @__PURE__ */ __name(() => {
@@ -289,6 +314,7 @@ var TurnBoundaryCompactionEngine = class {
     this.closed = true;
     this.resetReplayWindow();
     this.resetJournal();
+    this.activeRecordId = void 0;
     this.slots = [];
     this.toolSlotIndex.clear();
     this.clearTextSlotIndex();
@@ -487,6 +513,7 @@ var TurnBoundaryCompactionEngine = class {
     let droppedBytes = 0;
     let droppedEvents = 0;
     let droppedTurns = 0;
+    let lastDroppedRecordId;
     while (this.replayBytes > this.maxReplayBytes && this.activeReplaySegmentCount() > 1) {
       const dropped = this.replaySegments[this.replaySegmentStart];
       this.replaySegmentStart += 1;
@@ -497,8 +524,13 @@ var TurnBoundaryCompactionEngine = class {
       this.replayBytes -= dropped.bytes;
       this.truncatedEvents += dropped.events.length;
       this.truncatedTurns += dropped.turnCount;
+      const droppedRecordId = lastRecordIdIn(dropped.events);
+      if (droppedRecordId !== void 0) {
+        lastDroppedRecordId = droppedRecordId;
+      }
     }
     if (droppedSegmentCount > 0) {
+      this.replayAnchorRecordId ??= this.firstRetainedReplayRecordId() ?? lastDroppedRecordId;
       this.compactReplaySegmentQueueIfNeeded();
       this.notifyReplayWindowEviction({
         droppedBytes,
@@ -511,6 +543,13 @@ var TurnBoundaryCompactionEngine = class {
       });
     }
   }
+  firstRetainedReplayRecordId() {
+    for (let i = this.replaySegmentStart; i < this.replaySegments.length; i++) {
+      const recordId = lastRecordIdIn(this.replaySegments[i].events);
+      if (recordId !== void 0) return recordId;
+    }
+    return void 0;
+  }
   flattenReplaySegments() {
     return this.replaySegments.slice(this.replaySegmentStart).flatMap((segment) => segment.events);
   }
@@ -538,6 +577,15 @@ var TurnBoundaryCompactionEngine = class {
         retainedEvents,
         maxBytes: this.maxReplayBytes,
         ...this.truncatedTurns > 0 ? { truncatedTurns: this.truncatedTurns } : {},
+        // Pagination anchor for clients whose retained window lost every
+        // turn-boundary event (e.g. live-journal truncation during one
+        // long in-flight turn). Uses the eviction-time anchor, not
+        // `activeRecordId`, so a post-seed `ingest()` can't push it past
+        // records the client already displays. Undefined when no recordId
+        // was observed before the first eviction — the field is
+        // intentionally omitted in that case so old clients continue to
+        // validate the marker shape.
+        ...this.replayAnchorRecordId !== void 0 ? { recordId: this.replayAnchorRecordId } : {},
         fullTranscriptAvailable: true
       }
     };
@@ -548,6 +596,7 @@ var TurnBoundaryCompactionEngine = class {
     this.replayBytes = 0;
     this.truncatedEvents = 0;
     this.truncatedTurns = 0;
+    this.replayAnchorRecordId = void 0;
   }
   clearTextSlotIndex() {
     this.textSlotIndex.text.clear();
@@ -693,6 +742,7 @@ __name(mergeTranscriptUpdateMeta, "mergeTranscriptUpdateMeta");
 
 // packages/acp-bridge/src/session-source.ts
 init_esbuild_shims();
+var SESSION_SOURCE_META_KEY = "qwen.session.source";
 var SESSION_SOURCE_TYPE_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
 var MAX_SESSION_SOURCE_ID_LENGTH = 256;
 function parseSessionSource(sourceType, sourceId) {
@@ -1760,7 +1810,7 @@ function sliceLineRange(content, startLine, endLine) {
 }
 __name(sliceLineRange, "sliceLineRange");
 var BridgeClient = class {
-  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent, onWorkspaceGenerationEvent, onChannelDelivery) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent, onWorkspaceGenerationEvent, onChannelDelivery, hasSessionSpawnInFlight = () => false) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -1776,6 +1826,7 @@ var BridgeClient = class {
     this.onGenerationEvent = onGenerationEvent;
     this.onWorkspaceGenerationEvent = onWorkspaceGenerationEvent;
     this.onChannelDelivery = onChannelDelivery;
+    this.hasSessionSpawnInFlight = hasSessionSpawnInFlight;
   }
   static {
     __name(this, "BridgeClient");
@@ -2056,6 +2107,9 @@ var BridgeClient = class {
     if (method === SERVE_CONTROL_EXT_METHODS.channelDelivery) {
       return this.handleChannelDelivery(params);
     }
+    if (method === TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD) {
+      return this.handleTodoStopGuardContinuationClaim(params);
+    }
     if (method !== MID_TURN_QUEUE_DRAIN_METHOD) {
       throw RequestError.methodNotFound(method);
     }
@@ -2068,9 +2122,6 @@ var BridgeClient = class {
     const hasQueuedPrompt = entry.pendingPromptList.some(
       (prompt) => prompt.state === "queued" && !prompt.abortController.signal.aborted
     );
-    if (params["todoStopGuardWatchQueuedPrompt"] === true) {
-      entry.todoStopGuardAwaitingQueuedPrompt = hasQueuedPrompt;
-    }
     if (drained.length > 0) {
       const byOriginator = /* @__PURE__ */ new Map();
       for (const item of drained) {
@@ -2092,6 +2143,45 @@ var BridgeClient = class {
     }
     return { messages, hasQueuedPrompt };
   }
+  handleTodoStopGuardContinuationClaim(params) {
+    const sessionId = typeof params["sessionId"] === "string" && params["sessionId"].length > 0 ? params["sessionId"] : void 0;
+    if (!sessionId) return { claimed: false, hasQueuedPrompt: false };
+    if (!this.ownsSession(sessionId)) {
+      return { claimed: false, hasQueuedPrompt: false };
+    }
+    const entry = this.resolveEntry(sessionId);
+    if (!entry) return { claimed: false, hasQueuedPrompt: false };
+    const livePrompts = entry.pendingPromptList.filter(
+      (prompt) => !prompt.abortController.signal.aborted
+    );
+    const promptId = typeof params["promptId"] === "string" && params["promptId"].length > 0 ? params["promptId"] : void 0;
+    if (promptId) {
+      const ownsRunningPrompt = entry.activePromptId === promptId && livePrompts.some(
+        (prompt) => prompt.promptId === promptId && prompt.state === "running"
+      );
+      const hasCompetingRunningPrompt = livePrompts.some(
+        (prompt) => prompt.promptId !== promptId && prompt.state === "running"
+      );
+      if (!ownsRunningPrompt || hasCompetingRunningPrompt) {
+        return { claimed: false, hasQueuedPrompt: false };
+      }
+      const hasQueuedPrompt = livePrompts.some(
+        (prompt) => prompt.state === "queued"
+      );
+      if (hasQueuedPrompt) {
+        entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId = promptId;
+        return { claimed: false, hasQueuedPrompt: true };
+      }
+      if (entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId === promptId) {
+        delete entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId;
+      }
+      return { claimed: true, hasQueuedPrompt: false };
+    }
+    if (entry.promptActive || livePrompts.length > 0) {
+      return { claimed: false, hasQueuedPrompt: false };
+    }
+    return { claimed: true, hasQueuedPrompt: false };
+  }
   async handleChannelDelivery(params) {
     if (!this.onChannelDelivery) {
       throw RequestError.methodNotFound(
@@ -2227,7 +2317,29 @@ var BridgeClient = class {
         `client-hosted MCP server '${server}' is not currently connected`
       );
     }
-    const response = await send(payload);
+    const sessionId = params["sessionId"];
+    if (sessionId !== void 0 && (typeof sessionId !== "string" || sessionId.length === 0)) {
+      throw RequestError.invalidParams(
+        void 0,
+        "`sessionId` must be a non-empty string when provided"
+      );
+    }
+    const ownsSession = typeof sessionId === "string" && this.ownsSession(sessionId);
+    if (typeof sessionId === "string" && !ownsSession && !this.hasSessionSpawnInFlight()) {
+      throw RequestError.invalidParams(
+        void 0,
+        `Session not owned by this channel: ${sessionId}`
+      );
+    }
+    if (typeof sessionId === "string" && !ownsSession) {
+      writeStderrLine(
+        `[demux] session=${sessionId} type=client_mcp_message action=forwarded_without_session reason=session_registration_pending`
+      );
+    }
+    const response = await send(
+      payload,
+      typeof sessionId === "string" && ownsSession ? { sessionId } : void 0
+    );
     return { payload: response };
   }
   /**
@@ -5315,6 +5427,15 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 __name(isRecord3, "isRecord");
+function sessionSourceRequestMeta(sourceType, sourceId) {
+  return sourceType ? {
+    [SESSION_SOURCE_META_KEY]: {
+      sourceType,
+      ...sourceId !== void 0 ? { sourceId } : {}
+    }
+  } : {};
+}
+__name(sessionSourceRequestMeta, "sessionSourceRequestMeta");
 function isDefinitiveAcpRequestError(error) {
   if (error instanceof RequestError) return true;
   if (!isRecord3(error)) return false;
@@ -5844,6 +5965,8 @@ function createAcpSessionBridge(opts) {
   const compactedReplayMaxBytes = normalizeCompactedReplayMaxBytes(
     opts.compactedReplayMaxBytes
   );
+  const maxJournalEvents = normalizeMaxJournalEvents(opts.maxJournalEvents);
+  const maxJournalBytes = normalizeMaxJournalBytes(opts.maxJournalBytes);
   const channelFactory = opts.channelFactory ?? defaultSpawnChannelFactory;
   const childEnvOverrides = opts.childEnvOverrides ? Object.freeze({ ...opts.childEnvOverrides }) : Object.freeze({});
   const initTimeoutMs = opts.initializeTimeoutMs ?? DEFAULT_INIT_TIMEOUT_MS;
@@ -6259,98 +6382,124 @@ function createAcpSessionBridge(opts) {
         })
       );
       const sessionIds = /* @__PURE__ */ new Set();
-      const client = new BridgeClient(
-        // BfFut: ACP today carries a sessionId on every per-session
-        // notification / request, so the no-sessionId branch is
-        // technically unreachable. But the channel is multi-session
-        // (Stage 1.5 multiplex), so if ACP ever grows a no-sessionId
-        // call we'd silently drop it on a multi-session channel
-        // instead of throwing. Surface that ambiguity loudly.
-        (sessionId) => {
-          if (sessionId) return byId.get(sessionId);
-          if (channelInfo && channelInfo.sessionIds.size > 1) {
-            throw new Error(
-              "BridgeClient: ACP call without sessionId on a multi-session channel cannot be routed \u2014 workspace=" + boundWorkspace
+      let client;
+      let connection;
+      try {
+        client = new BridgeClient(
+          // BfFut: ACP today carries a sessionId on every per-session
+          // notification / request, so the no-sessionId branch is
+          // technically unreachable. But the channel is multi-session
+          // (Stage 1.5 multiplex), so if ACP ever grows a no-sessionId
+          // call we'd silently drop it on a multi-session channel
+          // instead of throwing. Surface that ambiguity loudly.
+          (sessionId) => {
+            if (sessionId) return byId.get(sessionId);
+            if (channelInfo && channelInfo.sessionIds.size > 1) {
+              throw new Error(
+                "BridgeClient: ACP call without sessionId on a multi-session channel cannot be routed \u2014 workspace=" + boundWorkspace
+              );
+            }
+            return void 0;
+          },
+          (sessionId) => sessionId ? pendingRestoreEvents.get(sessionId) : void 0,
+          permissionMediator,
+          permissionTimeoutMs,
+          maxPendingPerSession,
+          // Forward the optional `BridgeFileSystem` injection so
+          // production `qwen serve` can wire the `WorkspaceFileSystem`
+          // adapter into BridgeClient's fs proxy methods. Tests + Mode A
+          // consumers + channels / IDE companion omit it; BridgeClient
+          // falls back to its inline fs proxy.
+          opts.fileSystem,
+          // §2.3: centralised model_switched publish — keeps cache + generation
+          // update atomic. BridgeClient calls this instead of inlining publish.
+          (entry, modelId, originator) => publishModelSwitched(entry, modelId, originator),
+          // A2: centralised approval_mode_changed publish on in-session mode
+          // promotion. `previous` is read from the bridge state cache.
+          (entry, modeId, originator) => {
+            const se = entry;
+            publishApprovalModeChanged(
+              se,
+              {
+                previous: se.currentApprovalMode ?? "default",
+                next: modeId,
+                persisted: false
+              },
+              originator
             );
-          }
-          return void 0;
-        },
-        (sessionId) => sessionId ? pendingRestoreEvents.get(sessionId) : void 0,
-        permissionMediator,
-        permissionTimeoutMs,
-        maxPendingPerSession,
-        // Forward the optional `BridgeFileSystem` injection so
-        // production `qwen serve` can wire the `WorkspaceFileSystem`
-        // adapter into BridgeClient's fs proxy methods. Tests + Mode A
-        // consumers + channels / IDE companion omit it; BridgeClient
-        // falls back to its inline fs proxy.
-        opts.fileSystem,
-        // §2.3: centralised model_switched publish — keeps cache + generation
-        // update atomic. BridgeClient calls this instead of inlining publish.
-        (entry, modelId, originator) => publishModelSwitched(entry, modelId, originator),
-        // A2: centralised approval_mode_changed publish on in-session mode
-        // promotion. `previous` is read from the bridge state cache.
-        (entry, modeId, originator) => {
-          const se = entry;
-          publishApprovalModeChanged(
-            se,
-            {
-              previous: se.currentApprovalMode ?? "default",
-              next: modeId,
-              persisted: false
-            },
-            originator
+          },
+          // Reverse tool channel (issue #5626, Phase 2): forward the optional
+          // client-hosted-MCP sender lookup so `BridgeClient.extMethod` can
+          // answer `qwen/control/client_mcp/message` from the child by reaching
+          // the per-WS-connection `ClientMcpRegistrar`. Omitted callers (tests,
+          // Mode A) never host a client MCP server, so the method stays
+          // unreachable.
+          opts.clientMcpSender,
+          (sessionId) => sessionIds.has(sessionId),
+          // Daemon token-burn accounting: forward per-round token usage observed
+          // at the session/update fan-in to the daemon host's metrics ring via
+          // the telemetry seam. Optional-chained so non-daemon callers (tests,
+          // Mode A) that wire no `tokenUsage` metric are a silent no-op.
+          (inputTokens, outputTokens, durationMs, apiErrors, apiRetries) => telemetry.metrics?.tokenUsage?.(
+            inputTokens,
+            outputTokens,
+            durationMs,
+            apiErrors,
+            apiRetries
+          ),
+          // `create_sub_session` tool: forward the request/response hook so a child
+          // tool can ask the daemon to spawn a sub-session and (for 'first-turn')
+          // return its result. Omitted → the method reports daemon-only.
+          opts.onCreateSubSession,
+          (sessionId, event) => {
+            const request = generationRequests.get(event.requestId);
+            if (!request || request.sessionId !== sessionId) return;
+            if (request.queue.push(event)) return;
+            request.settled = true;
+            generationRequests.delete(event.requestId);
+            request.queue.fail(
+              new Error("Generation stream consumer too slow")
+            );
+            void request.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionGenerationCancel, {
+              sessionId,
+              requestId: event.requestId
+            }).catch(() => void 0);
+          },
+          (event) => {
+            const request = workspaceGenerationRequests.get(event.requestId);
+            if (!request) return;
+            if (request.queue.push(event)) return;
+            request.settled = true;
+            workspaceGenerationRequests.delete(event.requestId);
+            request.queue.fail(
+              new Error("Generation stream consumer too slow")
+            );
+            void request.connection?.extMethod(SERVE_CONTROL_EXT_METHODS.workspaceGenerationCancel, {
+              requestId: event.requestId
+            }).catch(() => void 0);
+          },
+          opts.onChannelDelivery,
+          () => channelInfo?.sessionIds === sessionIds && channelInfo.sessionSpawnsInFlight > 0
+        );
+        connection = new ClientSideConnection(() => client, channel.stream);
+      } catch (error) {
+        try {
+          channel.killSync();
+        } catch {
+        }
+        try {
+          await Promise.race([
+            channel.exited.then(() => void 0),
+            channel.kill()
+          ]);
+        } catch (teardownError) {
+          throw new AggregateError(
+            [error, teardownError],
+            "ACP channel construction and teardown failed"
           );
-        },
-        // Reverse tool channel (issue #5626, Phase 2): forward the optional
-        // client-hosted-MCP sender lookup so `BridgeClient.extMethod` can
-        // answer `qwen/control/client_mcp/message` from the child by reaching
-        // the per-WS-connection `ClientMcpRegistrar`. Omitted callers (tests,
-        // Mode A) never host a client MCP server, so the method stays
-        // unreachable.
-        opts.clientMcpSender,
-        (sessionId) => sessionIds.has(sessionId),
-        // Daemon token-burn accounting: forward per-round token usage observed
-        // at the session/update fan-in to the daemon host's metrics ring via
-        // the telemetry seam. Optional-chained so non-daemon callers (tests,
-        // Mode A) that wire no `tokenUsage` metric are a silent no-op.
-        (inputTokens, outputTokens, durationMs, apiErrors, apiRetries) => telemetry.metrics?.tokenUsage?.(
-          inputTokens,
-          outputTokens,
-          durationMs,
-          apiErrors,
-          apiRetries
-        ),
-        // `create_sub_session` tool: forward the request/response hook so a child
-        // tool can ask the daemon to spawn a sub-session and (for 'first-turn')
-        // return its result. Omitted → the method reports daemon-only.
-        opts.onCreateSubSession,
-        (sessionId, event) => {
-          const request = generationRequests.get(event.requestId);
-          if (!request || request.sessionId !== sessionId) return;
-          if (request.queue.push(event)) return;
-          request.settled = true;
-          generationRequests.delete(event.requestId);
-          request.queue.fail(new Error("Generation stream consumer too slow"));
-          void request.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionGenerationCancel, {
-            sessionId,
-            requestId: event.requestId
-          }).catch(() => void 0);
-        },
-        (event) => {
-          const request = workspaceGenerationRequests.get(event.requestId);
-          if (!request) return;
-          if (request.queue.push(event)) return;
-          request.settled = true;
-          workspaceGenerationRequests.delete(event.requestId);
-          request.queue.fail(new Error("Generation stream consumer too slow"));
-          void request.connection?.extMethod(SERVE_CONTROL_EXT_METHODS.workspaceGenerationCancel, {
-            requestId: event.requestId
-          }).catch(() => void 0);
-        },
-        opts.onChannelDelivery
-      );
-      const connection = new ClientSideConnection(() => client, channel.stream);
+        }
+        throw error;
+      }
       const info = {
         id: acpChannelId,
         channel,
@@ -6533,12 +6682,20 @@ function createAcpSessionBridge(opts) {
             "qwen-code.daemon.acp_channel.id": ci.id
           },
           async () => {
+            const request = telemetry.injectPromptContext({
+              cwd: boundWorkspace,
+              mcpServers: [],
+              ...sourceType ? { _meta: sessionSourceRequestMeta(sourceType, sourceId) } : {}
+            });
             const response = await withTimeout(
               ci.connection.newSession(
-                telemetry.injectPromptContext({
-                  cwd: boundWorkspace,
-                  mcpServers: []
-                })
+                worktree ? {
+                  ...request,
+                  _meta: {
+                    ...isRecord3(request._meta) ? request._meta : {},
+                    [WORKTREE_MCP_DEFER_META_KEY]: true
+                  }
+                } : request
               ),
               initTimeoutMs,
               "newSession"
@@ -7109,7 +7266,7 @@ function createAcpSessionBridge(opts) {
       cpuPercent: info.childCpuPercent ?? 0
     };
   }, "getChildResourceSnapshot");
-  const requestSessionStatus = /* @__PURE__ */ __name(async (sessionId, method, params = {}) => {
+  const requestSessionStatus = /* @__PURE__ */ __name(async (sessionId, method, params = {}, timeoutMs = initTimeoutMs) => {
     const entry = byId.get(sessionId);
     if (!entry) throw new SessionNotFoundError(sessionId);
     const info = channelInfoForEntry(entry);
@@ -7117,7 +7274,7 @@ function createAcpSessionBridge(opts) {
     const response = await Promise.race([
       withTimeout(
         entry.connection.extMethod(method, { ...params, sessionId }),
-        initTimeoutMs,
+        timeoutMs,
         method
       ),
       getTransportClosedReject(entry)
@@ -7207,6 +7364,8 @@ function createAcpSessionBridge(opts) {
     void 0,
     new TurnBoundaryCompactionEngine({
       maxReplayBytes: compactedReplayMaxBytes,
+      maxJournalEvents,
+      maxJournalBytes,
       onReplayWindowEviction: /* @__PURE__ */ __name((eviction) => {
         teeServeDebugLine(
           `replay window evicted ${JSON.stringify(eviction)}`
@@ -7310,6 +7469,7 @@ function createAcpSessionBridge(opts) {
     const entry = {
       sessionId,
       workspaceCwd,
+      effectiveCwd: workspaceCwd,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...options.parentSessionId ? { parentSessionId: options.parentSessionId } : {},
       ...options.sourceType ? { sourceType: options.sourceType } : {},
@@ -7326,6 +7486,7 @@ function createAcpSessionBridge(opts) {
       }),
       recordingDegraded: false,
       closing: false,
+      cwdChangeQueue: Promise.resolve(),
       promptQueue: Promise.resolve(),
       pendingPromptCount: 0,
       pendingPromptList: [],
@@ -7592,6 +7753,46 @@ function createAcpSessionBridge(opts) {
     return replayFieldsFor(entry, "load");
   }
   __name(refreshedReplayFieldsFor, "refreshedReplayFieldsFor");
+  function transcriptEventRecordId(event) {
+    if (event.type !== "session_update") return void 0;
+    const data = event.data;
+    if (!data || typeof data !== "object" || Array.isArray(data))
+      return void 0;
+    const rec = data;
+    const update = rec["update"];
+    const meta = update && typeof update === "object" && !Array.isArray(update) ? update["_meta"] : rec["_meta"];
+    if (!meta || typeof meta !== "object" || Array.isArray(meta))
+      return void 0;
+    const recordId = meta["qwen.session.recordId"];
+    return typeof recordId === "string" ? recordId : void 0;
+  }
+  __name(transcriptEventRecordId, "transcriptEventRecordId");
+  async function resolveHistoryAnchorRecordId(entry, replayFields) {
+    const events = [
+      ...replayFields.compactedReplay ?? [],
+      ...replayFields.liveJournal ?? []
+    ];
+    const hasMarker = events.some((e) => e.type === "history_truncated");
+    if (!hasMarker) return void 0;
+    const hasRecordId = events.some(
+      (e) => transcriptEventRecordId(e) !== void 0 || e.type === "history_truncated" && isRecord3(e.data) && typeof e.data["recordId"] === "string"
+    );
+    if (hasRecordId) return void 0;
+    try {
+      const page = await requestSessionTranscriptPage({
+        sessionId: entry.sessionId,
+        direction: "backward",
+        limit: 50
+      });
+      for (const event of page.events) {
+        const recordId = transcriptEventRecordId(event);
+        if (recordId !== void 0) return recordId;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  __name(resolveHistoryAnchorRecordId, "resolveHistoryAnchorRecordId");
   async function restoreSession(action, req, options = {}) {
     if (shuttingDown) {
       throw new Error("AcpSessionBridge is shutting down");
@@ -7603,6 +7804,7 @@ function createAcpSessionBridge(opts) {
       );
     }
     const historyReplay = action === "load" ? req.historyReplay ?? "stream" : "stream";
+    const hideInheritedHistory = action === "load" && req.hideInheritedHistory === true;
     const existing = byId.get(req.sessionId);
     if (existing) {
       if (existing.closing) {
@@ -7612,6 +7814,7 @@ function createAcpSessionBridge(opts) {
         );
       }
       const replayFields = action === "load" && req.historyPageSize !== void 0 ? await refreshedReplayFieldsFor(existing, req.historyPageSize) : replayFieldsFor(existing, action);
+      const historyAnchorRecordId = action === "load" ? await resolveHistoryAnchorRecordId(existing, replayFields) : void 0;
       if (byId.get(req.sessionId) !== existing || existing.closing) {
         throw new SessionNotFoundError(req.sessionId);
       }
@@ -7633,12 +7836,13 @@ function createAcpSessionBridge(opts) {
         // caller saw; spawn-only sessions don't carry a state payload.
         state: existing.restoreState ?? {},
         hasActivePrompt: existing.promptActive,
-        ...replayFields
+        ...replayFields,
+        ...historyAnchorRecordId !== void 0 ? { historyAnchorRecordId } : {}
       };
     }
     const inFlight = inFlightRestores.get(req.sessionId);
     if (inFlight) {
-      if (action !== inFlight.action || historyReplay !== inFlight.historyReplay) {
+      if (action !== inFlight.action || historyReplay !== inFlight.historyReplay || hideInheritedHistory !== inFlight.hideInheritedHistory) {
         throw new RestoreInProgressError(
           req.sessionId,
           inFlight.action,
@@ -7720,11 +7924,20 @@ function createAcpSessionBridge(opts) {
                 // intentionally has no `mcpServers` field for the
                 // same reason.
                 mcpServers: [],
-                ...historyReplay === "response" ? {
+                ...historyReplay === "response" || hideInheritedHistory || req.sourceType ? {
                   _meta: {
-                    [LOAD_REPLAY_MODE_META_KEY]: LOAD_REPLAY_BULK_MODE,
-                    ...req.historyPageSize !== void 0 ? {
-                      [LOAD_REPLAY_PAGE_SIZE_META_KEY]: req.historyPageSize
+                    ...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
                     } : {}
                   }
                 } : {}
@@ -7740,7 +7953,13 @@ function createAcpSessionBridge(opts) {
               ci.connection.unstable_resumeSession({
                 sessionId: req.sessionId,
                 cwd: workspaceKey,
-                mcpServers: []
+                mcpServers: [],
+                ...req.sourceType ? {
+                  _meta: sessionSourceRequestMeta(
+                    req.sourceType,
+                    req.sourceId
+                  )
+                } : {}
               }),
               initTimeoutMs,
               "resumeSession"
@@ -7918,6 +8137,7 @@ function createAcpSessionBridge(opts) {
     inFlightRestores.set(req.sessionId, {
       action,
       historyReplay,
+      hideInheritedHistory,
       promise,
       coalesceState
     });
@@ -8046,6 +8266,8 @@ function createAcpSessionBridge(opts) {
           maxPendingPromptsPerSession: maxPendingPromptsPerSession === Infinity ? null : maxPendingPromptsPerSession,
           eventRingSize,
           compactedReplayMaxBytes,
+          maxJournalEvents,
+          maxJournalBytes,
           channelIdleTimeoutMs: resolvedChannelIdleTimeoutMs(),
           sessionIdleTimeoutMs
         },
@@ -8348,13 +8570,17 @@ function createAcpSessionBridge(opts) {
           "abort",
           () => {
             if (pendingEntry.state !== "queued") return;
-            if (!entry.todoStopGuardAwaitingQueuedPrompt) return;
+            const waitingOwnerPromptId = entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId;
+            if (!waitingOwnerPromptId) return;
             const hasAnotherQueuedPrompt = entry.pendingPromptList.some(
               (candidate) => candidate !== pendingEntry && candidate.state === "queued" && !candidate.abortController.signal.aborted
             );
             if (hasAnotherQueuedPrompt) return;
-            entry.todoStopGuardAwaitingQueuedPrompt = false;
-            void entry.connection.extMethod(TODO_STOP_GUARD_QUEUE_RELEASE_METHOD, { sessionId }).catch((error) => {
+            delete entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId;
+            void entry.connection.extMethod(TODO_STOP_GUARD_QUEUE_RELEASE_METHOD, {
+              sessionId,
+              promptId: waitingOwnerPromptId
+            }).catch((error) => {
               writeStderrLine(
                 `qwen serve: Todo Stop Guard queued-prompt release failed for ${JSON.stringify(sessionId)}: ${error instanceof Error ? error.message : String(error)}`
               );
@@ -8385,7 +8611,7 @@ function createAcpSessionBridge(opts) {
             throw new DOMException("Prompt aborted", "AbortError");
           }
           if (pendingEntry.state === "queued") {
-            entry.todoStopGuardAwaitingQueuedPrompt = false;
+            delete entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId;
             pendingEntry.state = "running";
             entry.events.publish({
               type: "pending_prompt_started",
@@ -8790,12 +9016,18 @@ function createAcpSessionBridge(opts) {
       if (shuttingDown) throw new Error("AcpSessionBridge is shutting down");
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
+      const source = parseSessionSource(req.sourceType, req.sourceId);
+      if ("error" in source) {
+        throw new InvalidSessionMetadataError("sourceType", source.error);
+      }
+      const isSideTask = source.sourceType === "side_task";
       let originatorClientId;
       if (context?.clientId !== void 0) {
         originatorClientId = resolveTrustedClientId(entry, context.clientId);
       }
-      const branchResult = entry.promptQueue.then(async () => {
-        if (entry.promptActive) {
+      const concurrentSideTask = isSideTask && entry.promptActive;
+      const branchResult = (concurrentSideTask ? Promise.resolve() : entry.promptQueue).then(async () => {
+        if (entry.promptActive && !isSideTask) {
           throw new BranchWhilePromptActiveError(sessionId);
         }
         if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
@@ -8815,13 +9047,16 @@ function createAcpSessionBridge(opts) {
         try {
           const ci = await ensureChannel();
           const result = await withTimeout(
-            ci.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionBranch, {
-              sessionId,
-              cwd: boundWorkspace,
-              name: req.name
-            }),
+            ci.connection.extMethod(
+              isSideTask ? SERVE_CONTROL_EXT_METHODS.sessionSideTask : SERVE_CONTROL_EXT_METHODS.sessionBranch,
+              {
+                sessionId,
+                cwd: boundWorkspace,
+                name: req.name
+              }
+            ),
             initTimeoutMs,
-            "branchSession"
+            isSideTask ? "createSideTaskSession" : "branchSession"
           );
           if (!result || typeof result.newSessionId !== "string") {
             throw new Error(
@@ -8832,12 +9067,18 @@ function createAcpSessionBridge(opts) {
           const branchDisplayName = typeof rawBranchName === "string" ? rawBranchName : result.newSessionId.slice(0, 8);
           let restored;
           try {
+            const hideInheritedHistory = req.replayInheritedHistory === false;
             restored = await restoreSession(
               "load",
               {
                 sessionId: result.newSessionId,
                 workspaceCwd: boundWorkspace,
-                clientId: context?.clientId
+                clientId: context?.clientId,
+                ...hideInheritedHistory ? {
+                  historyReplay: "response",
+                  hideInheritedHistory: true
+                } : {},
+                ...source
               },
               {
                 skipFreshSessionAdmission: true
@@ -8862,35 +9103,80 @@ function createAcpSessionBridge(opts) {
           }
           const newEntry = byId.get(result.newSessionId);
           if (newEntry) newEntry.displayName = branchDisplayName;
-          const eventData = {
-            sourceSessionId: sessionId,
-            newSessionId: result.newSessionId,
-            displayName: branchDisplayName
-          };
-          const branchEnvelope = {
-            type: "session_branched",
-            data: eventData,
-            ...originatorClientId ? { originatorClientId } : {}
-          };
-          newEntry?.events.publish(branchEnvelope);
+          let sourcePersisted;
+          if (newEntry?.sourceType) {
+            try {
+              const sourceResult = await withTimeout(
+                newEntry.connection.extMethod(
+                  SERVE_CONTROL_EXT_METHODS.sessionSource,
+                  {
+                    sessionId: newEntry.sessionId,
+                    sourceType: newEntry.sourceType,
+                    ...newEntry.sourceId !== void 0 ? { sourceId: newEntry.sourceId } : {}
+                  }
+                ),
+                initTimeoutMs,
+                "sessionSource"
+              );
+              sourcePersisted = sourceResult?.persisted === true;
+            } catch (error) {
+              sourcePersisted = false;
+              writeStderrLine(
+                `qwen serve: source metadata for branched session ${result.newSessionId} was not persisted: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+          }
+          if (!isSideTask) {
+            const eventData = {
+              sourceSessionId: sessionId,
+              newSessionId: result.newSessionId,
+              displayName: branchDisplayName
+            };
+            const branchEnvelope = {
+              type: "session_branched",
+              data: eventData,
+              ...originatorClientId ? { originatorClientId } : {}
+            };
+            newEntry?.events.publish(branchEnvelope);
+          }
           return {
             ...restored,
             displayName: branchDisplayName,
             forkedFrom: {
               sessionId,
               displayName: entry.displayName ?? sessionId.slice(0, 8)
-            }
+            },
+            ...sourcePersisted !== void 0 ? { sourcePersisted } : {}
           };
         } finally {
           releaseAdmissionOnce();
         }
       });
-      entry.promptQueue = branchResult.then(
-        () => void 0,
-        () => void 0
-      );
+      if (!concurrentSideTask) {
+        entry.promptQueue = branchResult.then(
+          () => void 0,
+          () => void 0
+        );
+      }
       return branchResult;
     },
+    async createSideTaskSession(sessionId, req, context) {
+      const result = await this.branchSession(
+        sessionId,
+        {
+          name: req.name,
+          sourceType: "side_task",
+          sourceId: sessionId,
+          replayInheritedHistory: false
+        },
+        context
+      );
+      const { forkedFrom: _forkedFrom, ...sideTask } = result;
+      return {
+        ...sideTask,
+        parentSessionId: sessionId
+      };
+    },
     async changeSessionCwd(sessionId, req, context) {
       if (shuttingDown) throw new Error("AcpSessionBridge is shutting down");
       const entry = byId.get(sessionId);
@@ -8918,6 +9204,7 @@ function createAcpSessionBridge(opts) {
             `changeSessionCwd: unexpected response shape from agent: ${JSON.stringify(raw)}`
           );
         }
+        entry.effectiveCwd = extResult.newCwd;
         if (extResult.previousCwd !== extResult.newCwd) {
           entry.events.publish({
             type: "session_cwd_changed",
@@ -8935,6 +9222,10 @@ function createAcpSessionBridge(opts) {
         () => void 0,
         () => void 0
       );
+      entry.cwdChangeQueue = cdPromise.then(
+        () => void 0,
+        () => void 0
+      );
       const result = await withTimeout(
         cdPromise,
         Math.max(initTimeoutMs, 3e4),
@@ -9436,44 +9727,79 @@ function createAcpSessionBridge(opts) {
     },
     async refreshExtensionsForAllSessions(data) {
       const sessions = Array.from(byId.values());
+      const bootstrapRefreshConnections = /* @__PURE__ */ new Set();
+      const refreshSession = /* @__PURE__ */ __name(async (entry, refreshBootstrap) => {
+        let inFlight = inFlightExtensionRefreshes.get(entry.sessionId);
+        if (!inFlight || inFlight.connection !== entry.connection || refreshBootstrap && !inFlight.refreshBootstrap) {
+          const promise = (async () => {
+            await entry.connection.extMethod(
+              SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh,
+              {
+                sessionId: entry.sessionId,
+                ...refreshBootstrap ? {} : { refreshBootstrap: false }
+              }
+            );
+          })();
+          inFlight = {
+            connection: entry.connection,
+            promise,
+            refreshBootstrap
+          };
+          inFlightExtensionRefreshes.set(entry.sessionId, inFlight);
+          const clear = /* @__PURE__ */ __name(() => {
+            if (inFlightExtensionRefreshes.get(entry.sessionId) === inFlight) {
+              inFlightExtensionRefreshes.delete(entry.sessionId);
+            }
+          }, "clear");
+          void promise.then(clear, clear);
+        }
+        await Promise.race([
+          withTimeout(
+            inFlight.promise,
+            3e4,
+            SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh
+          ),
+          getTransportClosedReject(entry)
+        ]);
+      }, "refreshSession");
       const results = await Promise.all(
         sessions.map(async (entry) => {
           const info = channelInfoForEntry(entry);
           if (!info || info.isDying) {
-            return { refreshed: 0, failed: 0 };
+            return {
+              refreshed: 0,
+              failed: 0,
+              entry,
+              refreshBootstrap: false
+            };
           }
+          const refreshBootstrap = !bootstrapRefreshConnections.has(
+            entry.connection
+          );
+          bootstrapRefreshConnections.add(entry.connection);
           try {
-            let inFlight = inFlightExtensionRefreshes.get(entry.sessionId);
-            if (!inFlight || inFlight.connection !== entry.connection) {
-              const promise = (async () => {
-                await entry.connection.extMethod(
-                  SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh,
-                  { sessionId: entry.sessionId }
-                );
-              })();
-              inFlight = { connection: entry.connection, promise };
-              inFlightExtensionRefreshes.set(entry.sessionId, inFlight);
-              const clear = /* @__PURE__ */ __name(() => {
-                if (inFlightExtensionRefreshes.get(entry.sessionId) === inFlight) {
-                  inFlightExtensionRefreshes.delete(entry.sessionId);
-                }
-              }, "clear");
-              void promise.then(clear, clear);
-            }
-            await Promise.race([
-              withTimeout(
-                inFlight.promise,
-                3e4,
-                SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh
-              ),
-              getTransportClosedReject(entry)
-            ]);
-            return { refreshed: 1, failed: 0 };
+            await refreshSession(entry, refreshBootstrap);
+            return { refreshed: 1, failed: 0, entry, refreshBootstrap };
           } catch (err) {
             writeServeDebugLine(
               `refreshExtensions: session ${entry.sessionId} failed: ${err instanceof Error ? err.message : String(err)}`
             );
-            return { refreshed: 0, failed: 1 };
+            return { refreshed: 0, failed: 1, entry, refreshBootstrap };
+          }
+        })
+      );
+      await Promise.all(
+        results.filter((result) => result.failed > 0 && result.refreshBootstrap).map(async (failedBootstrap) => {
+          const retry = results.find(
+            (result) => result.refreshed > 0 && result.entry.connection === failedBootstrap.entry.connection
+          );
+          if (!retry) return;
+          try {
+            await refreshSession(retry.entry, true);
+          } catch (err) {
+            writeServeDebugLine(
+              `refreshExtensions: bootstrap retry via session ${retry.entry.sessionId} failed: ${err instanceof Error ? err.message : String(err)}`
+            );
           }
         })
       );
@@ -9910,7 +10236,24 @@ function createAcpSessionBridge(opts) {
       if (signal?.aborted) {
         return { exitCode: null, output: "", aborted: true };
       }
-      const cwd = entry.workspaceCwd;
+      let abortResolve;
+      const onAbort = /* @__PURE__ */ __name(() => abortResolve?.(), "onAbort");
+      try {
+        await Promise.race([
+          entry.cwdChangeQueue,
+          new Promise((resolve2) => {
+            abortResolve = resolve2;
+            if (signal?.aborted) return resolve2();
+            signal?.addEventListener("abort", onAbort, { once: true });
+          })
+        ]);
+      } finally {
+        signal?.removeEventListener("abort", onAbort);
+      }
+      if (signal?.aborted) {
+        return { exitCode: null, output: "", aborted: true };
+      }
+      const cwd = entry.effectiveCwd;
       entry.events.publish({
         type: "user_shell_command",
         data: { sessionId, command, cwd },
@@ -10398,6 +10741,22 @@ function createAcpSessionBridge(opts) {
       }
       return response;
     },
+    async addSessionRuntimeMcpServer(sessionId, name, config, originatorClientId) {
+      return requestSessionStatus(
+        sessionId,
+        SERVE_CONTROL_EXT_METHODS.sessionMcpRuntimeAdd,
+        { name, config, originatorClientId },
+        MCP_RESTART_SERVER_DEADLINE_MS
+      );
+    },
+    async removeSessionRuntimeMcpServer(sessionId, name, originatorClientId) {
+      return requestSessionStatus(
+        sessionId,
+        SERVE_CONTROL_EXT_METHODS.sessionMcpRuntimeRemove,
+        { name, originatorClientId },
+        MCP_RESTART_SERVER_DEADLINE_MS
+      );
+    },
     async killSession(sessionId, opts2) {
       const entry = byId.get(sessionId);
       if (!entry) return false;
@@ -10583,13 +10942,22 @@ function createAcpSessionBridge(opts) {
           () => void 0,
           () => void 0
         ) : Promise.resolve();
-        await Promise.all([
-          ...channels.map((ci) => ci.channel.kill().catch(() => {
-          })),
+        const teardownResults = await Promise.allSettled([
+          ...channels.map((ci) => ci.channel.kill()),
           ...inFlightSessionAwaits,
           ...inFlightRestoreAwaits,
           inFlightChannelAwait
         ]);
+        const teardownFailures = teardownResults.flatMap(
+          (result) => result.status === "rejected" ? [result.reason] : []
+        );
+        if (teardownFailures.length === 1) throw teardownFailures[0];
+        if (teardownFailures.length > 1) {
+          throw new AggregateError(
+            teardownFailures,
+            "ACP bridge shutdown failed"
+          );
+        }
       })().then(resolveShutdown, rejectShutdown);
       return shutdownPromise;
     },
@@ -10628,6 +10996,7 @@ var createHttpAcpBridge = createAcpSessionBridge;
 export {
   SessionArtifactValidationError,
   SessionArtifactAuthorizationError,
+  SESSION_SOURCE_META_KEY,
   parseSessionSource,
   extractErrorMessage,
   extractErrorCode,