@qwen-code/qwen-code 0.20.0 → 0.20.1-nightly.20260724.7d17c44a3

package/chunks/{chunk-AKX4WPPP.js → chunk-SWBJRDYC.js}

@@ -1,28 +1,5 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  DEFAULT_RING_SIZE,
-  EVENT_SCHEMA_VERSION,
-  EventBus,
-  serializedBridgeEventByteLength
-} from "./chunk-6RLROE6G.js";
-import {
-  normalizeCompactedReplayMaxBytes
-} from "./chunk-COH43MRJ.js";
-import {
-  CHANNEL_STARTUP_PROFILE_META_KEY,
-  CHANNEL_STARTUP_PROFILE_VERSION,
-  LOAD_REPLAY_BULK_MODE,
-  LOAD_REPLAY_META_KEY,
-  LOAD_REPLAY_MODE_META_KEY,
-  LOAD_REPLAY_PAGE_SIZE_META_KEY,
-  LOAD_REPLAY_VERSION,
-  MID_TURN_QUEUE_DRAIN_METHOD,
-  TODO_STOP_GUARD_QUEUE_RELEASE_METHOD
-} from "./chunk-QR6U5QPP.js";
-import {
-  defaultSpawnChannelFactory
-} from "./chunk-CV63PP6U.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -34,6 +11,7 @@ import {
   InvalidSessionScopeError,
   MCP_RESTART_SERVER_DEADLINE_MS,
   PermissionForbiddenError,
+  PromptDeadlineExceededError,
   PromptQueueFullError,
   RestoreInProgressError,
   SessionBusyError,
@@ -43,7 +21,32 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-X6YQWCIJ.js";
+} from "./chunk-UH3WSE5L.js";
+import {
+  CHANNEL_STARTUP_PROFILE_META_KEY,
+  CHANNEL_STARTUP_PROFILE_VERSION,
+  DAEMON_CHANNEL_DELIVERY_META_KEY,
+  LOAD_REPLAY_BULK_MODE,
+  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";
+import {
+  DEFAULT_RING_SIZE,
+  EVENT_SCHEMA_VERSION,
+  EventBus,
+  serializedBridgeEventByteLength
+} from "./chunk-BLFVGB7D.js";
+import {
+  normalizeCompactedReplayMaxBytes
+} from "./chunk-COH43MRJ.js";
+import {
+  defaultSpawnChannelFactory
+} from "./chunk-YCIM6O3I.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -52,10 +55,16 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-VDWBQ5AW.js";
+} from "./chunk-CUPAVLRY.js";
 import {
-  canonicalizeWorkspace
-} from "./chunk-W7FJ3N32.js";
+  canonicalizeWorkspace,
+  translateAndCheckAbsoluteWorkspacePath
+} from "./chunk-2RFKHEXL.js";
+import {
+  CHANNEL_DELIVERY_ERROR_CODES,
+  MAX_SUB_SESSION_NAME_CHARS,
+  MAX_SUB_SESSION_PROMPT_CHARS
+} from "./chunk-BK2UNYWD.js";
 import {
   ClientSideConnection,
   PROTOCOL_VERSION,
@@ -72,11 +81,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-KX6UK4VJ.js";
+} from "./chunk-LI4I37W4.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-ZFKNWQGQ.js";
+} from "./chunk-AXUW635Q.js";
+import {
+  INVOCATION_CONTEXT_META_KEY,
+  PRIVATE_ACP_CAPABILITY_ENV,
+  PRIVATE_PARENT_CAPABILITY_META_KEY
+} from "./chunk-IFG6TYJ2.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -86,7 +100,7 @@ import {
 
 // packages/acp-bridge/src/bridge.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomBytes, randomUUID as randomUUID2 } from "node:crypto";
 import * as path3 from "node:path";
 
 // packages/acp-bridge/src/compactionEngine.ts
@@ -310,6 +324,8 @@ var TurnBoundaryCompactionEngine = class {
         if (event.id !== void 0) slot.lastEventId = event.id;
         slot.lastMeta = meta ?? slot.lastMeta;
         slot.lastEnvelopeMeta = event._meta ?? slot.lastEnvelopeMeta;
+        slot.lastTurn = captureTurnFields(event, slot.lastTurn);
+        slot.lastSessionId = captureSessionId(event) ?? slot.lastSessionId;
       } else {
         entries.push({ sourceRecordIds, index: this.slots.length });
         this.textSlotIndex[kind].set(parentToolCallId, entries);
@@ -320,7 +336,9 @@ var TurnBoundaryCompactionEngine = class {
           sourceRecordIds,
           lastEventId: event.id ?? 0,
           lastMeta: meta,
-          lastEnvelopeMeta: event._meta
+          lastEnvelopeMeta: event._meta,
+          lastTurn: captureTurnFields(event),
+          lastSessionId: captureSessionId(event)
         });
       }
     } else {
@@ -330,6 +348,8 @@ var TurnBoundaryCompactionEngine = class {
         if (event.id !== void 0) lastSlot.lastEventId = event.id;
         lastSlot.lastMeta = meta ?? lastSlot.lastMeta;
         lastSlot.lastEnvelopeMeta = event._meta ?? lastSlot.lastEnvelopeMeta;
+        lastSlot.lastTurn = captureTurnFields(event, lastSlot.lastTurn);
+        lastSlot.lastSessionId = captureSessionId(event) ?? lastSlot.lastSessionId;
       } else {
         this.slots.push({
           kind,
@@ -338,7 +358,9 @@ var TurnBoundaryCompactionEngine = class {
           sourceRecordIds,
           lastEventId: event.id ?? 0,
           lastMeta: meta,
-          lastEnvelopeMeta: event._meta
+          lastEnvelopeMeta: event._meta,
+          lastTurn: captureTurnFields(event),
+          lastSessionId: captureSessionId(event)
         });
       }
     }
@@ -355,7 +377,9 @@ var TurnBoundaryCompactionEngine = class {
               slot.chunks.join(""),
               slot.lastEventId,
               slot.lastMeta,
-              slot.lastEnvelopeMeta
+              slot.lastEnvelopeMeta,
+              slot.lastTurn,
+              slot.lastSessionId
             )
           );
           break;
@@ -462,13 +486,20 @@ var TurnBoundaryCompactionEngine = class {
     this.textSlotIndex.thought.clear();
   }
 };
-function makeMergedSessionUpdateEvent(sessionUpdate, text, eventId, meta, envelopeMeta) {
+function makeMergedSessionUpdateEvent(sessionUpdate, text, eventId, meta, envelopeMeta, turn, sessionId) {
   return {
     id: eventId || void 0,
     v: EVENT_SCHEMA_VERSION,
     type: "session_update",
+    // Re-stamp prompt/originator attribution captured from the source
+    // chunks — clients rebuilding state from a compacted snapshot need
+    // them for prompt correlation and originator filtering. Present only
+    // when the source events carried them ("present only if set" style).
+    ...turn?.promptId !== void 0 ? { promptId: turn.promptId } : {},
+    ...turn?.originatorClientId !== void 0 ? { originatorClientId: turn.originatorClientId } : {},
     ...envelopeMeta !== void 0 ? { _meta: envelopeMeta } : {},
     data: {
+      ...sessionId !== void 0 ? { sessionId } : {},
       update: {
         sessionUpdate,
         content: { type: "text", text },
@@ -478,6 +509,23 @@ function makeMergedSessionUpdateEvent(sessionUpdate, text, eventId, meta, envelo
   };
 }
 __name(makeMergedSessionUpdateEvent, "makeMergedSessionUpdateEvent");
+function captureTurnFields(event, previous) {
+  const promptId = event.promptId ?? previous?.promptId;
+  const originatorClientId = event.originatorClientId ?? previous?.originatorClientId;
+  if (promptId === void 0 && originatorClientId === void 0) {
+    return void 0;
+  }
+  return {
+    ...promptId !== void 0 ? { promptId } : {},
+    ...originatorClientId !== void 0 ? { originatorClientId } : {}
+  };
+}
+__name(captureTurnFields, "captureTurnFields");
+function captureSessionId(event) {
+  const sessionId = event.data?.sessionId;
+  return typeof sessionId === "string" ? sessionId : void 0;
+}
+__name(captureSessionId, "captureSessionId");
 function normalizeToolCallType(event) {
   const data = event.data;
   if (data?.update?.sessionUpdate === "tool_call_update") {
@@ -540,10 +588,14 @@ function mergeToolCallEvent(existing, incoming) {
   if (updateMeta !== void 0) merged["_meta"] = updateMeta;
   merged["sessionUpdate"] = "tool_call";
   const mergedMeta = existing._meta || incoming._meta ? { ...existing._meta ?? {}, ...incoming._meta ?? {} } : void 0;
+  const promptId = incoming.promptId ?? existing.promptId;
+  const originatorClientId = incoming.originatorClientId ?? existing.originatorClientId;
   return {
     id: incoming.id ?? existing.id,
     v: EVENT_SCHEMA_VERSION,
     type: "session_update",
+    ...promptId !== void 0 ? { promptId } : {},
+    ...originatorClientId !== void 0 ? { originatorClientId } : {},
     ...mergedMeta ? { _meta: mergedMeta } : {},
     data: {
       ...existingData,
@@ -715,11 +767,6 @@ import * as path from "node:path";
 init_esbuild_shims();
 var MID_TURN_MESSAGE_INJECTED_EVENT = "mid_turn_message_injected";
 
-// packages/acp-bridge/src/bridgeOptions.ts
-init_esbuild_shims();
-var MAX_SUB_SESSION_PROMPT_CHARS = 1e5;
-var MAX_SUB_SESSION_NAME_CHARS = 200;
-
 // packages/acp-bridge/src/permissionMediator.ts
 init_esbuild_shims();
 
@@ -1405,6 +1452,9 @@ var MultiClientPermissionMediator = class {
 
 // packages/acp-bridge/src/bridgeClient.ts
 var PUBLISH_ARTIFACT_TOOL_NAME = "artifact";
+var MAX_CHANNEL_DELIVERY_TEXT_CHARS = 1e5;
+var MAX_CHANNEL_DELIVERY_FIELD_CHARS = 2048;
+var MAX_CHANNEL_DELIVERY_ERROR_CHARS = 500;
 function isFsErrorShape(err) {
   return err instanceof Error && err.name === "FsError" && typeof err.kind === "string";
 }
@@ -1413,6 +1463,25 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 __name(isRecord2, "isRecord");
+function isBoundedChannelDeliveryString(value) {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= MAX_CHANNEL_DELIVERY_FIELD_CHARS;
+}
+__name(isBoundedChannelDeliveryString, "isBoundedChannelDeliveryString");
+function isChannelDeliveryTarget(value) {
+  if (!isRecord2(value)) return false;
+  return isBoundedChannelDeliveryString(value["channelName"]) && (value["type"] === "user" || value["type"] === "chat") && isBoundedChannelDeliveryString(value["id"]) && Object.keys(value).every(
+    (key) => key === "channelName" || key === "type" || key === "id"
+  );
+}
+__name(isChannelDeliveryTarget, "isChannelDeliveryTarget");
+function normalizeChannelDeliveryHostResult(value) {
+  if (value.status === "delivered") return { status: "delivered" };
+  if (value.status === "skipped") return { status: "skipped" };
+  const code = CHANNEL_DELIVERY_ERROR_CODES.has(value.code) ? value.code : "channel_delivery_failed";
+  const error = typeof value.error === "string" && value.error.length > 0 ? value.error.slice(0, MAX_CHANNEL_DELIVERY_ERROR_CHARS) : "Channel delivery failed.";
+  return { status: "failed", code, error };
+}
+__name(normalizeChannelDeliveryHostResult, "normalizeChannelDeliveryHostResult");
 function pendingInteractionOptions(options) {
   return options.map((option) => ({
     optionId: String(option.optionId ?? ""),
@@ -1623,7 +1692,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) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent, onWorkspaceGenerationEvent, onChannelDelivery) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -1637,6 +1706,8 @@ var BridgeClient = class {
     this.onTokenUsage = onTokenUsage;
     this.onCreateSubSession = onCreateSubSession;
     this.onGenerationEvent = onGenerationEvent;
+    this.onWorkspaceGenerationEvent = onWorkspaceGenerationEvent;
+    this.onChannelDelivery = onChannelDelivery;
   }
   static {
     __name(this, "BridgeClient");
@@ -1914,6 +1985,9 @@ var BridgeClient = class {
     if (method === SERVE_CONTROL_EXT_METHODS.createSubSession) {
       return this.handleCreateSubSession(params);
     }
+    if (method === SERVE_CONTROL_EXT_METHODS.channelDelivery) {
+      return this.handleChannelDelivery(params);
+    }
     if (method !== MID_TURN_QUEUE_DRAIN_METHOD) {
       throw RequestError.methodNotFound(method);
     }
@@ -1950,6 +2024,98 @@ var BridgeClient = class {
     }
     return { messages, hasQueuedPrompt };
   }
+  async handleChannelDelivery(params) {
+    if (!this.onChannelDelivery) {
+      throw RequestError.methodNotFound(
+        SERVE_CONTROL_EXT_METHODS.channelDelivery
+      );
+    }
+    const sessionId = params["sessionId"];
+    if (typeof sessionId !== "string" || sessionId.length === 0 || !this.ownsSession(sessionId)) {
+      throw RequestError.invalidParams(
+        void 0,
+        "`sessionId` must name a session owned by this connection"
+      );
+    }
+    const entry = this.resolveEntry(sessionId);
+    if (!entry) {
+      throw RequestError.invalidParams(void 0, "Unknown `sessionId`");
+    }
+    const deliveryId = params["deliveryId"];
+    const source = params["source"];
+    const text = params["text"];
+    const rawTarget = params["target"];
+    if (!isBoundedChannelDeliveryString(deliveryId) || source !== "prompt" && source !== "scheduled" || typeof text !== "string" || text.length > MAX_CHANNEL_DELIVERY_TEXT_CHARS || !isChannelDeliveryTarget(rawTarget)) {
+      throw RequestError.invalidParams(
+        void 0,
+        "Invalid channel delivery request"
+      );
+    }
+    const promptId = params["promptId"];
+    const taskId = params["taskId"];
+    const firedAt = params["firedAt"];
+    const allowedKeys = source === "prompt" ? /* @__PURE__ */ new Set([
+      "sessionId",
+      "deliveryId",
+      "source",
+      "target",
+      "text",
+      "promptId"
+    ]) : /* @__PURE__ */ new Set([
+      "sessionId",
+      "deliveryId",
+      "source",
+      "target",
+      "text",
+      "taskId",
+      "firedAt"
+    ]);
+    const correlationValid = source === "prompt" ? isBoundedChannelDeliveryString(promptId) && promptId === deliveryId : isBoundedChannelDeliveryString(taskId) && typeof firedAt === "number" && Number.isFinite(firedAt) && deliveryId === `${taskId}:${firedAt}`;
+    if (!correlationValid || !Object.keys(params).every((key) => allowedKeys.has(key))) {
+      throw RequestError.invalidParams(
+        void 0,
+        "Invalid channel delivery correlation"
+      );
+    }
+    const info = {
+      sessionId,
+      deliveryId,
+      source,
+      target: rawTarget,
+      text,
+      ...source === "prompt" ? { promptId } : {},
+      ...source === "scheduled" ? { taskId, firedAt } : {}
+    };
+    let result;
+    try {
+      result = normalizeChannelDeliveryHostResult(
+        await this.onChannelDelivery(info)
+      );
+    } catch {
+      result = {
+        status: "failed",
+        code: "channel_delivery_failed",
+        error: "Channel delivery failed."
+      };
+    }
+    try {
+      entry.events.publish({
+        type: "channel_delivery_result",
+        ...source === "prompt" ? { promptId } : {},
+        data: {
+          sessionId,
+          deliveryId,
+          source,
+          status: result.status,
+          ...source === "prompt" ? { promptId } : {},
+          ...source === "scheduled" ? { taskId, firedAt } : {},
+          ...result.status === "failed" ? { code: result.code, error: result.error } : {}
+        }
+      });
+    } catch {
+    }
+    return result;
+  }
   /**
    * Reverse tool channel (issue #5626, Phase 2) — answer the child's
    * `qwen/control/client_mcp/message` ext-method. The child's session
@@ -2117,6 +2283,47 @@ var BridgeClient = class {
       }
       return;
     }
+    if (method === "qwen/notify/workspace/generation/event") {
+      const requestId = params["requestId"];
+      const event = params["event"];
+      if (params["v"] !== 1 || typeof requestId !== "string" || !event || typeof event !== "object" || Array.isArray(event)) {
+        return;
+      }
+      const record = event;
+      if (record["type"] === "started") {
+        const model = record["model"];
+        const modelSource = record["modelSource"];
+        if (typeof model !== "string" || modelSource !== "fast" && modelSource !== "main") {
+          return;
+        }
+        this.onWorkspaceGenerationEvent?.({
+          type: "started",
+          requestId,
+          model,
+          modelSource
+        });
+        return;
+      }
+      if (record["type"] === "thinking") {
+        this.onWorkspaceGenerationEvent?.({ type: "thinking", requestId });
+        return;
+      }
+      if (record["type"] === "delta") {
+        const seq = record["seq"];
+        const text = record["text"];
+        if (typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 0 || typeof text !== "string" || text.length === 0) {
+          return;
+        }
+        this.onWorkspaceGenerationEvent?.({
+          type: "delta",
+          requestId,
+          seq,
+          text
+        });
+        return;
+      }
+      return;
+    }
     if (method === "qwen/notify/session/model-update") {
       this.handleInSessionModelUpdate(params);
       return;
@@ -5040,6 +5247,12 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 __name(isRecord3, "isRecord");
+function isDefinitiveAcpRequestError(error) {
+  if (error instanceof RequestError) return true;
+  if (!isRecord3(error)) return false;
+  return typeof error["code"] === "number" && Number.isInteger(error["code"]) && typeof error["message"] === "string";
+}
+__name(isDefinitiveAcpRequestError, "isDefinitiveAcpRequestError");
 function getCanonicalModelId(response, fallback) {
   if (!isRecord3(response) || !isRecord3(response["_meta"])) return fallback;
   const modelSwitch = response["_meta"]["qwenModelSwitch"];
@@ -5295,13 +5508,15 @@ function broadcastPromptCancelled(entry, sessionId, promptId, originatorClientId
 }
 __name(broadcastPromptCancelled, "broadcastPromptCancelled");
 function broadcastPromptCancelledOnce(entry, sessionId, promptId, originatorClientId, reason) {
-  if (entry.cancelBroadcast) {
+  if (promptId !== void 0 && entry.cancelBroadcastPromptId === promptId) {
     writeStderrLine(
-      `broadcastPromptCancelledOnce: suppressed duplicate cancel for session ${sessionId} (latch already set)`
+      `broadcastPromptCancelledOnce: suppressed duplicate cancel for session ${sessionId} prompt=${promptId}`
     );
     return;
   }
-  entry.cancelBroadcast = true;
+  if (promptId !== void 0) {
+    entry.cancelBroadcastPromptId = promptId;
+  }
   broadcastPromptCancelled(
     entry,
     sessionId,
@@ -5367,7 +5582,7 @@ function classifyTurnErrorKind(message) {
   return message.trim().toLowerCase() === "terminated" ? "model_stream_interrupted" : void 0;
 }
 __name(classifyTurnErrorKind, "classifyTurnErrorKind");
-function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId) {
+function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId, mutateTurnState) {
   const message = extractErrorMessage(err);
   const code = extractErrorCode(err);
   const errorKind = classifyTurnErrorKind(message);
@@ -5376,12 +5591,14 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId)
       `turn_error classified session=${JSON.stringify(sessionId)} message=${JSON.stringify(message)} errorKind=${JSON.stringify(errorKind)}` + (code ? ` code=${JSON.stringify(code)}` : "") + (promptId ? ` promptId=${JSON.stringify(promptId)}` : "")
     );
   }
-  entry.retryAllowed = true;
-  entry.turnError = {
-    message,
-    ...code ? { code } : {},
-    ...errorKind ? { errorKind } : {}
-  };
+  if (mutateTurnState) {
+    entry.retryAllowed = true;
+    entry.turnError = {
+      message,
+      ...code ? { code } : {},
+      ...errorKind ? { errorKind } : {}
+    };
+  }
   try {
     entry.events.publish({
       type: "turn_error",
@@ -5399,6 +5616,64 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId)
   }
 }
 __name(broadcastTurnError, "broadcastTurnError");
+function publishPromptTerminal(entry, pendingEntry, terminal) {
+  if (pendingEntry.terminalPublished) {
+    writeServeDebugLine(
+      `publishPromptTerminal: suppressed duplicate ${terminal.kind} terminal for prompt ${pendingEntry.promptId} (session ${entry.sessionId})`
+    );
+    return;
+  }
+  pendingEntry.terminalPublished = true;
+  const originatorClientId = pendingEntry.originatorClientId;
+  if (terminal.kind === "complete") {
+    broadcastTurnComplete(
+      entry,
+      entry.sessionId,
+      terminal.result,
+      pendingEntry.promptId,
+      originatorClientId
+    );
+  } else if (terminal.kind === "cancelled") {
+    broadcastTurnComplete(
+      entry,
+      entry.sessionId,
+      { stopReason: "cancelled" },
+      pendingEntry.promptId,
+      originatorClientId
+    );
+  } else {
+    broadcastTurnError(
+      entry,
+      entry.sessionId,
+      terminal.err,
+      pendingEntry.promptId,
+      originatorClientId,
+      // Only a running prompt's failure is the active turn's failure. The
+      // `state === 'running'` gate (not `activePromptId`) is deliberate:
+      // on the normal settle path `settleActivePromptState` runs in
+      // `promptPromise.finally` BEFORE the terminal is published, so
+      // `activePromptId` is already cleared when a genuine active failure
+      // lands here.
+      pendingEntry.state === "running"
+    );
+  }
+}
+__name(publishPromptTerminal, "publishPromptTerminal");
+function flushPromptTerminals(entry, code, message) {
+  for (const pending of [...entry.pendingPromptList]) {
+    publishPromptTerminal(entry, pending, {
+      kind: "error",
+      err: { code, message }
+    });
+    try {
+      pending.abortController.abort(
+        new DOMException("Prompt aborted", "AbortError")
+      );
+    } catch {
+    }
+  }
+}
+__name(flushPromptTerminals, "flushPromptTerminals");
 function hasControlCharacter2(value) {
   for (let i = 0; i < value.length; i += 1) {
     const code = value.charCodeAt(i);
@@ -5558,6 +5833,18 @@ function createAcpSessionBridge(opts) {
     lastActivityTimestamp = Date.now();
   }
   __name(touchActivity, "touchActivity");
+  function settleActivePromptState(entry, promptId) {
+    if (entry.activePromptId !== promptId) return;
+    delete entry.activePromptId;
+    delete entry.activePromptOriginatorClientId;
+    if (entry.promptActive) {
+      entry.promptActive = false;
+      activePromptCounter--;
+      entry.sessionLastSeenAt = Date.now();
+      touchActivity();
+    }
+  }
+  __name(settleActivePromptState, "settleActivePromptState");
   function resolvePositiveFiniteMs(raw, fallback) {
     if (raw === void 0) return fallback;
     return raw > 0 && Number.isFinite(raw) ? Math.min(raw, 2147483647) : 0;
@@ -5674,7 +5961,7 @@ function createAcpSessionBridge(opts) {
       if (shuttingDown) return;
       const now = Date.now();
       for (const [id, entry] of byId) {
-        if (entry.promptActive) continue;
+        if (entry.pendingPromptCount > 0) continue;
         if (entry.events.subscriberCount > 0) continue;
         const lastActive = entry.sessionLastSeenAt ?? Date.parse(entry.createdAt);
         const idle = now - lastActive;
@@ -5704,7 +5991,54 @@ function createAcpSessionBridge(opts) {
   const aliveChannels = /* @__PURE__ */ new Set();
   let inFlightChannelSpawn;
   const byId = /* @__PURE__ */ new Map();
+  const forwardRunningPromptCancel = /* @__PURE__ */ __name(async (entry, pending, notification) => {
+    if (pending.cancelForwardInitial) {
+      return pending.cancelForwardInitial;
+    }
+    const initial = (async () => {
+      try {
+        const extension = entry.connection.extMethod(PROMPT_CANCEL_METHOD, notification).then((result2) => ({ kind: "result", result: result2 }));
+        const outcome = await Promise.race([
+          extension,
+          getTransportClosedReject(entry),
+          ...pending.cancelForwardDeadline ? [
+            pending.cancelForwardDeadline.then(() => ({
+              kind: "deadline"
+            }))
+          ] : []
+        ]);
+        if (outcome.kind === "deadline") return;
+        const { result } = outcome;
+        if (typeof result["cancelled"] !== "boolean") {
+          throw new Error(
+            `${PROMPT_CANCEL_METHOD} returned an invalid acknowledgement`
+          );
+        }
+      } catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === -32601 || isNotCurrentlyGeneratingCancelError(error)) {
+          await Promise.race([
+            entry.connection.cancel(notification),
+            getTransportClosedReject(entry),
+            ...pending.cancelForwardDeadline ? [pending.cancelForwardDeadline] : []
+          ]);
+          return;
+        }
+        throw error;
+      }
+    })().catch((error) => {
+      if (pending.cancelForwardInitial === initial) {
+        delete pending.cancelForwardInitial;
+      }
+      throw error;
+    });
+    pending.cancelForwardInitial = initial;
+    pending.cancelForwardDrain = initial;
+    void initial.catch(() => {
+    });
+    return initial;
+  }, "forwardRunningPromptCancel");
   const generationRequests = /* @__PURE__ */ new Map();
+  const workspaceGenerationRequests = /* @__PURE__ */ new Map();
   const inFlightExtensionRefreshes = /* @__PURE__ */ new Map();
   const toSessionSummary = /* @__PURE__ */ __name((entry) => {
     let isWaitingForPermission = false;
@@ -5731,7 +6065,8 @@ function createAcpSessionBridge(opts) {
       pendingInteractionCount: entry.pendingInteractions.size,
       hasTurnError: entry.turnError !== void 0,
       ...entry.turnError !== void 0 ? { turnError: entry.turnError } : {},
-      pendingInteractions: [...entry.pendingInteractions.values()]
+      pendingInteractions: [...entry.pendingInteractions.values()],
+      ...entry.worktree ? { worktree: entry.worktree } : {}
     };
   }, "toSessionSummary");
   const permissionConsensusQuorum = opts.permissionConsensusQuorum;
@@ -5793,13 +6128,30 @@ function createAcpSessionBridge(opts) {
       entry.clientIds.set(clientId, count - 1);
     }
   }, "unregisterClient");
+  const recordAttachRef = /* @__PURE__ */ __name((entry, clientId) => {
+    entry.attachRefs.set(clientId, (entry.attachRefs.get(clientId) ?? 0) + 1);
+  }, "recordAttachRef");
+  const releaseAttachRef = /* @__PURE__ */ __name((entry, clientId) => {
+    const refs = entry.attachRefs.get(clientId);
+    if (refs === void 0 || refs <= 0) return false;
+    if (refs === 1) {
+      entry.attachRefs.delete(clientId);
+    } else {
+      entry.attachRefs.set(clientId, refs - 1);
+    }
+    return true;
+  }, "releaseAttachRef");
   const rollbackAttachRegistration = /* @__PURE__ */ __name(async (entry, clientId, attachCountDelta = 1) => {
-    entry.attachCount = Math.max(0, entry.attachCount - attachCountDelta);
+    const released = releaseAttachRef(entry, clientId) ? 1 : 0;
+    entry.attachCount = Math.max(
+      0,
+      entry.attachCount - (released + (attachCountDelta - 1))
+    );
     unregisterClient(entry, clientId);
     if (entry.spawnOwnerWantedKill && entry.attachCount === 0 && entry.events.subscriberCount === 0) {
       await bridgeApi.killSession(entry.sessionId).catch(() => {
       });
-    } else if (entry.clientIds.size === 0 && entry.events.subscriberCount === 0 && !entry.promptActive) {
+    } else if (entry.clientIds.size === 0 && entry.events.subscriberCount === 0 && entry.pendingPromptCount === 0) {
       await closeSessionImpl(entry.sessionId, void 0, {
         reason: "last_client_detached"
       }).catch((err) => {
@@ -5821,6 +6173,7 @@ function createAcpSessionBridge(opts) {
     if (channelInfo && !channelInfo.isDying) return channelInfo;
     if (inFlightChannelSpawn) return await inFlightChannelSpawn;
     const promise = (async () => {
+      const privateParentCapability = randomBytes(32).toString("base64url");
       const acpChannelId = randomUUID2();
       const channel = await telemetry.withSpan(
         "channel.spawn",
@@ -5829,7 +6182,10 @@ function createAcpSessionBridge(opts) {
           "qwen-code.daemon.channel.reused": false,
           "qwen-code.daemon.acp_channel.id": acpChannelId
         },
-        async () => await channelFactory(boundWorkspace, childEnvOverrides)
+        async () => await channelFactory(boundWorkspace, {
+          ...childEnvOverrides,
+          [PRIVATE_ACP_CAPABILITY_ENV]: privateParentCapability
+        })
       );
       const sessionIds = /* @__PURE__ */ new Set();
       const client = new BridgeClient(
@@ -5909,7 +6265,19 @@ function createAcpSessionBridge(opts) {
             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);
       const info = {
@@ -5968,6 +6336,11 @@ function createAcpSessionBridge(opts) {
           const sessEntry = byId.get(sid);
           if (!sessEntry) continue;
           cancelPendingForSession(sid);
+          flushPromptTerminals(
+            sessEntry,
+            "channel_closed",
+            "agent channel exited before the prompt completed"
+          );
           try {
             sessEntry.events.publish({
               type: "session_died",
@@ -6013,7 +6386,8 @@ function createAcpSessionBridge(opts) {
                 _meta: {
                   [CHANNEL_STARTUP_PROFILE_META_KEY]: {
                     v: CHANNEL_STARTUP_PROFILE_VERSION
-                  }
+                  },
+                  [PRIVATE_PARENT_CAPABILITY_META_KEY]: privateParentCapability
                 },
                 clientCapabilities: {
                   fs: { readTextFile: true, writeTextFile: true }
@@ -6062,7 +6436,7 @@ function createAcpSessionBridge(opts) {
     }
   }
   __name(ensureChannel, "ensureChannel");
-  async function doSpawn(modelServiceId, effectiveScope, approvalMode, requestedClientId, onSessionRegistered, parentSessionId, sourceType, sourceId) {
+  async function doSpawn(modelServiceId, effectiveScope, approvalMode, requestedClientId, onSessionRegistered, parentSessionId, sourceType, sourceId, worktree) {
     const channelPath = channelInfo && !channelInfo.isDying ? "reused" : inFlightChannelSpawn ? "joined" : "spawned_on_request";
     const ci = await telemetry.withSpan(
       "channel.wait",
@@ -6123,7 +6497,7 @@ function createAcpSessionBridge(opts) {
         newSessionResp.sessionId,
         boundWorkspace,
         void 0,
-        { parentSessionId, sourceType, sourceId }
+        { parentSessionId, sourceType, sourceId, worktree }
       );
       initializedSessionId = entry.sessionId;
       sessionRegistered = true;
@@ -6237,7 +6611,8 @@ function createAcpSessionBridge(opts) {
         ...entry.sourceType ? { sourceType: entry.sourceType } : {},
         ...entry.sourceId !== void 0 ? { sourceId: entry.sourceId } : {},
         ...entry.sourceType ? { sourcePersisted: sourcePersisted === true } : {},
-        ...entry.parentSessionId ? { parentSessionPersisted: parentSessionPersisted === true } : {}
+        ...entry.parentSessionId ? { parentSessionPersisted: parentSessionPersisted === true } : {},
+        ...entry.worktree ? { worktree: entry.worktree } : {}
       };
     } finally {
       ci.sessionSpawnsInFlight = Math.max(0, ci.sessionSpawnsInFlight - 1);
@@ -6447,10 +6822,11 @@ function createAcpSessionBridge(opts) {
     }
     return entry.transportClosedReject;
   }, "getTransportClosedReject");
-  const resolveWorkspaceKey = /* @__PURE__ */ __name((workspaceCwd) => {
-    if (!path3.isAbsolute(workspaceCwd)) {
+  const resolveWorkspaceKey = /* @__PURE__ */ __name((rawWorkspaceCwd) => {
+    const workspaceCwd = translateAndCheckAbsoluteWorkspacePath(rawWorkspaceCwd);
+    if (workspaceCwd === null) {
       throw new Error(
-        `workspaceCwd must be an absolute path; got "${workspaceCwd}"`
+        `workspaceCwd must be an absolute path; got "${rawWorkspaceCwd}"`
       );
     }
     const workspaceKey = workspaceCwd === boundWorkspace ? boundWorkspace : canonicalizeWorkspace(workspaceCwd);
@@ -6689,12 +7065,18 @@ function createAcpSessionBridge(opts) {
       return;
     }
     try {
+      const closeRequest = entry.connection.extMethod(
+        SERVE_CONTROL_EXT_METHODS.sessionClose,
+        {
+          sessionId: entry.sessionId,
+          drainTimeoutMs: Math.max(1, Math.floor(initTimeoutMs * 0.8)),
+          ...opts2?.requireFlush === true ? { requireFlush: true } : {}
+        }
+      );
+      const observedCloseRequest = opts2?.timeoutMs ? withTimeout(closeRequest, opts2.timeoutMs, label) : closeRequest;
       await Promise.race([
-        withTimeout(
-          entry.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionClose, {
-            sessionId: entry.sessionId,
-            ...opts2?.requireFlush === true ? { requireFlush: true } : {}
-          }),
+        opts2?.throwOnFailure === true ? observedCloseRequest : withTimeout(
+          observedCloseRequest,
           initTimeoutMs,
           SERVE_CONTROL_EXT_METHODS.sessionClose
         ),
@@ -6748,7 +7130,7 @@ function createAcpSessionBridge(opts) {
       );
     }
   }, "broadcastWorkspaceEvent");
-  const createSessionEventBus = /* @__PURE__ */ __name(() => new EventBus(
+  const createSessionEventBus = /* @__PURE__ */ __name((sessionId) => new EventBus(
     eventRingSize,
     void 0,
     new TurnBoundaryCompactionEngine({
@@ -6758,7 +7140,17 @@ function createAcpSessionBridge(opts) {
           `replay window evicted ${JSON.stringify(eviction)}`
         );
       }, "onReplayWindowEviction")
-    })
+    }),
+    {
+      // Fired once, on the FIRST ingest/seed failure (the bus keeps the
+      // degraded flag set silently afterwards). The bus doesn't know its
+      // session, so the sessionId context is injected here.
+      onCompactionError: /* @__PURE__ */ __name((err) => {
+        writeStderrLine(
+          `qwen serve: compaction degraded for session=${sessionId}; replay snapshot may lag behind live events: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }, "onCompactionError")
+    }
   ), "createSessionEventBus");
   const publishModelSwitched = /* @__PURE__ */ __name((entry, modelId, originatorClientId) => {
     entry.currentModelId = modelId;
@@ -6842,7 +7234,7 @@ function createAcpSessionBridge(opts) {
       if (rerun) void reconcileAfterRoundtrip(entry, target);
     }
   }, "reconcileAfterRoundtrip");
-  const createSessionEntry = /* @__PURE__ */ __name((ci, sessionId, workspaceCwd, events = createSessionEventBus(), options = {}) => {
+  const createSessionEntry = /* @__PURE__ */ __name((ci, sessionId, workspaceCwd, events = createSessionEventBus(sessionId), options = {}) => {
     const entry = {
       sessionId,
       workspaceCwd,
@@ -6850,6 +7242,7 @@ function createAcpSessionBridge(opts) {
       ...options.parentSessionId ? { parentSessionId: options.parentSessionId } : {},
       ...options.sourceType ? { sourceType: options.sourceType } : {},
       ...options.sourceId !== void 0 ? { sourceId: options.sourceId } : {},
+      ...options.worktree ? { worktree: options.worktree } : {},
       channel: ci.channel,
       connection: ci.connection,
       events,
@@ -6859,6 +7252,7 @@ function createAcpSessionBridge(opts) {
         persistence: createSessionArtifactPersistence(ci.connection, sessionId)
       }),
       recordingDegraded: false,
+      closing: false,
       promptQueue: Promise.resolve(),
       pendingPromptCount: 0,
       pendingPromptList: [],
@@ -6872,6 +7266,7 @@ function createAcpSessionBridge(opts) {
       clientIds: /* @__PURE__ */ new Map(),
       clientLastSeenAt: /* @__PURE__ */ new Map(),
       attachCount: 0,
+      attachRefs: /* @__PURE__ */ new Map(),
       spawnOwnerWantedKill: false,
       promptActive: false,
       retryAllowed: false
@@ -7015,20 +7410,27 @@ function createAcpSessionBridge(opts) {
       partial: true,
       ...typeof entry.restoreReplayError === "string" ? { replayError: entry.restoreReplayError } : {}
     } : {};
+    const eventEpoch = entry.events.epoch;
     const snapshot = entry.events.snapshotReplay();
     if (!snapshot) {
-      return { lastEventId: entry.events.lastEventId, ...replayStatus };
+      return {
+        lastEventId: entry.events.lastEventId,
+        eventEpoch,
+        ...replayStatus
+      };
     }
     if (action === "load") {
       return {
         compactedReplay: snapshot.compactedTurns,
         liveJournal: snapshot.liveJournal,
         lastEventId: snapshot.lastEventId,
+        eventEpoch,
         ...replayStatus,
+        ...snapshot.degraded ? { replayDegraded: true } : {},
         ...entry.restoreHistoryHasMore === true ? { historyHasMore: true } : {}
       };
     }
-    return { lastEventId: snapshot.lastEventId, ...replayStatus };
+    return { lastEventId: snapshot.lastEventId, eventEpoch, ...replayStatus };
   }, "replayFieldsFor");
   const restoredArtifactSnapshotFromState = /* @__PURE__ */ __name((state) => {
     const candidate = state.artifactSnapshot;
@@ -7061,6 +7463,62 @@ function createAcpSessionBridge(opts) {
     } = state;
     return publicState;
   }, "publicRestoreState");
+  async function requestSessionTranscriptPage(req) {
+    const info = await ensureChannel();
+    try {
+      const response = await withWorkspaceControl(
+        info,
+        () => withTimeout(
+          Promise.race([
+            info.connection.extMethod(
+              SERVE_STATUS_EXT_METHODS.sessionTranscript,
+              { ...req, cwd: boundWorkspace }
+            ),
+            getChannelClosedReject(info)
+          ]),
+          Math.max(initTimeoutMs, SESSION_TRANSCRIPT_TIMEOUT_MS),
+          SERVE_STATUS_EXT_METHODS.sessionTranscript
+        )
+      );
+      return response;
+    } catch (err) {
+      if (isAcpSessionResourceNotFound(err, req.sessionId)) {
+        throw new SessionNotFoundError(req.sessionId);
+      }
+      throw err;
+    } finally {
+      if (hasNoChannelWork(info)) {
+        await startIdleTimer(info, "session transcript");
+      }
+    }
+  }
+  __name(requestSessionTranscriptPage, "requestSessionTranscriptPage");
+  async function refreshedReplayFieldsFor(entry, historyPageSize) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const lastEventId = entry.events.lastEventId;
+        const page = await requestSessionTranscriptPage({
+          sessionId: entry.sessionId,
+          direction: "backward",
+          limit: historyPageSize
+        });
+        if (byId.get(entry.sessionId) === entry && !entry.promptActive && entry.events.lastEventId === lastEventId) {
+          return {
+            compactedReplay: page.events,
+            liveJournal: [],
+            lastEventId,
+            ...page.partial === true ? { partial: true } : {},
+            ...page.replayError !== void 0 ? { replayError: page.replayError } : {},
+            ...page.hasMore ? { historyHasMore: true } : {}
+          };
+        }
+      } catch {
+        break;
+      }
+    }
+    return replayFieldsFor(entry, "load");
+  }
+  __name(refreshedReplayFieldsFor, "refreshedReplayFieldsFor");
   async function restoreSession(action, req, options = {}) {
     if (shuttingDown) {
       throw new Error("AcpSessionBridge is shutting down");
@@ -7074,8 +7532,19 @@ function createAcpSessionBridge(opts) {
     const historyReplay = action === "load" ? req.historyReplay ?? "stream" : "stream";
     const existing = byId.get(req.sessionId);
     if (existing) {
+      if (existing.closing) {
+        throw new SessionNotFoundError(
+          req.sessionId,
+          "The session is closing; retry after close completes"
+        );
+      }
+      const replayFields = action === "load" && req.historyPageSize !== void 0 ? await refreshedReplayFieldsFor(existing, req.historyPageSize) : replayFieldsFor(existing, action);
+      if (byId.get(req.sessionId) !== existing || existing.closing) {
+        throw new SessionNotFoundError(req.sessionId);
+      }
       existing.attachCount++;
       const clientId = registerClient(existing, req.clientId);
+      recordAttachRef(existing, clientId);
       if (req.approvalMode) {
         await applyApprovalModeForAttach(existing, req.approvalMode, clientId);
       }
@@ -7091,7 +7560,7 @@ function createAcpSessionBridge(opts) {
         // caller saw; spawn-only sessions don't carry a state payload.
         state: existing.restoreState ?? {},
         hasActivePrompt: existing.promptActive,
-        ...replayFieldsFor(existing, action)
+        ...replayFields
       };
     }
     const inFlight = inFlightRestores.get(req.sessionId);
@@ -7120,6 +7589,7 @@ function createAcpSessionBridge(opts) {
         );
       }
       const clientId = registerClient(entry, req.clientId);
+      recordAttachRef(entry, clientId);
       if (req.approvalMode) {
         await applyApprovalModeForAttach(entry, req.approvalMode, clientId);
       }
@@ -7134,7 +7604,7 @@ function createAcpSessionBridge(opts) {
     if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
       throw new SessionLimitExceededError(maxSessions);
     }
-    const restoreEvents = createSessionEventBus();
+    const restoreEvents = createSessionEventBus(req.sessionId);
     let registeredEntry;
     let ci;
     const coalesceState = { count: 0 };
@@ -7241,6 +7711,7 @@ function createAcpSessionBridge(opts) {
         restoreEvents.close();
         racedEntry.attachCount += 1 + coalesceState.count;
         const clientId2 = registerClient(racedEntry, req.clientId);
+        recordAttachRef(racedEntry, clientId2);
         if (req.approvalMode) {
           try {
             await applyApprovalMode(
@@ -7387,10 +7858,17 @@ function createAcpSessionBridge(opts) {
   async function closeSessionImpl(sessionId, context, closeOpts) {
     const entry = byId.get(sessionId);
     if (!entry) throw new SessionNotFoundError(sessionId);
+    if (entry.closing) {
+      throw new SessionNotFoundError(
+        sessionId,
+        "The session is already closing"
+      );
+    }
     let originatorClientId;
     if (context?.clientId !== void 0) {
       originatorClientId = resolveTrustedClientId(entry, context.clientId);
     }
+    entry.closing = true;
     const reason = closeOpts?.reason ?? "client_close";
     writeStderrLine(
       `qwen serve: closing session ${JSON.stringify(sessionId)} (reason: ${reason})` + (originatorClientId ? ` by client ${JSON.stringify(originatorClientId)}` : "")
@@ -7400,26 +7878,37 @@ function createAcpSessionBridge(opts) {
       "session.id": sessionId,
       "session.close.reason": reason
     });
-    if (defaultEntry === entry) defaultEntry = void 0;
     const ci = channelInfoForEntry(entry);
     if (!ci) {
       writeStderrLine(
         `qwen serve: closeSession channelInfoForEntry returned undefined for session ${JSON.stringify(sessionId)} \u2014 channel cleanup skipped (entry's channel already torn down)`
       );
     }
-    const requireAgentClose = closeOpts?.requireAgentClose === true;
-    if (requireAgentClose) {
+    try {
+      permissionMediator.forgetSession(sessionId);
+      entry.pendingPermissionIds.clear();
+      entry.pendingInteractions.clear();
       await notifyAgentSessionClose(entry, ci, "closeSession", {
         throwOnFailure: true,
-        requireFlush: true
+        requireFlush: closeOpts?.requireAgentClose === true
       });
+    } catch (error) {
+      if (isDefinitiveAcpRequestError(error)) {
+        entry.closing = false;
+      } else if (ci) {
+        await killChannelWithLog(
+          ci,
+          `recover unknown close outcome for session ${JSON.stringify(sessionId)}`
+        );
+      } else {
+        entry.closing = false;
+      }
+      throw error;
     }
+    if (defaultEntry === entry) defaultEntry = void 0;
     if (ci && ci.channel === entry.channel) {
       ci.sessionIds.delete(sessionId);
     }
-    permissionMediator.forgetSession(sessionId);
-    entry.pendingPermissionIds.clear();
-    entry.pendingInteractions.clear();
     if (entry.promptActive) {
       entry.promptActive = false;
       activePromptCounter--;
@@ -7434,6 +7923,11 @@ function createAcpSessionBridge(opts) {
       reason
     });
     ci?.client.markSessionClosed(sessionId);
+    flushPromptTerminals(
+      entry,
+      "session_closed",
+      "session closed before the prompt completed"
+    );
     try {
       entry.events.publish({
         type: "session_closed",
@@ -7451,9 +7945,6 @@ function createAcpSessionBridge(opts) {
     } catch {
     }
     entry.events.close();
-    if (!requireAgentClose) {
-      await notifyAgentSessionClose(entry, ci, "closeSession");
-    }
     try {
       await telemetry.withSpan(
         "session.close.cancel_active_prompt",
@@ -7568,8 +8059,15 @@ function createAcpSessionBridge(opts) {
       if (effectiveScope === "single") {
         const existing = defaultEntry;
         if (existing) {
+          if (existing.closing) {
+            throw new SessionNotFoundError(
+              existing.sessionId,
+              "The session is closing; retry after close completes"
+            );
+          }
           existing.attachCount++;
           const clientId = registerClient(existing, req.clientId);
+          recordAttachRef(existing, clientId);
           if (req.modelServiceId) {
             await applyModelServiceId(
               existing,
@@ -7609,6 +8107,7 @@ function createAcpSessionBridge(opts) {
             );
           }
           const clientId = registerClient(attachedEntry, req.clientId);
+          recordAttachRef(attachedEntry, clientId);
           if (req.modelServiceId) {
             await applyModelServiceId(
               attachedEntry,
@@ -7654,7 +8153,8 @@ function createAcpSessionBridge(opts) {
         releaseAdmissionOnce,
         req.parentSessionId,
         source.sourceType,
-        source.sourceId
+        source.sourceId,
+        req.worktree
       );
       const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID2()}`;
       inFlightSpawns.set(tracker, promise);
@@ -7676,6 +8176,14 @@ function createAcpSessionBridge(opts) {
       const queuedAt = Date.now();
       const entry = byId.get(sessionId);
       if (!entry) return Promise.reject(new SessionNotFoundError(sessionId));
+      if (entry.closing) {
+        return Promise.reject(
+          new SessionNotFoundError(
+            sessionId,
+            "The session is closing; retry after close completes"
+          )
+        );
+      }
       const originatorClientId = resolveTrustedClientId(
         entry,
         context?.clientId
@@ -7698,6 +8206,12 @@ function createAcpSessionBridge(opts) {
         entry.pendingPromptCount = Math.max(0, entry.pendingPromptCount - 1);
       }, "releasePromptSlot");
       const promptId = context?.promptId ?? randomUUID2();
+      const invocationContext = Object.freeze({
+        version: 1,
+        sessionId,
+        promptId,
+        ...originatorClientId ? { originatorClientId } : {}
+      });
       const isQueued = entry.pendingPromptCount > 1;
       const pendingAbort = new AbortController();
       if (signal) {
@@ -7720,6 +8234,41 @@ function createAcpSessionBridge(opts) {
         state: isQueued ? "queued" : "running"
       };
       entry.pendingPromptList.push(pendingEntry);
+      const deadlineMs = context?.deadlineMs;
+      const hasDeadline = typeof deadlineMs === "number" && Number.isFinite(deadlineMs) && deadlineMs > 0;
+      let deadlineReject;
+      let deadlinePromise;
+      let deadlineTimer;
+      if (hasDeadline) {
+        deadlinePromise = new Promise((_resolve, reject) => {
+          deadlineReject = reject;
+        });
+        deadlinePromise.catch(() => {
+        });
+        pendingEntry.cancelForwardDeadline = deadlinePromise.then(
+          () => void 0,
+          () => void 0
+        );
+        const onDeadline = /* @__PURE__ */ __name(() => {
+          if (pendingEntry.terminalPublished) return;
+          const deadlineErr = new PromptDeadlineExceededError(deadlineMs);
+          writeStderrLine(
+            `sendPrompt: prompt ${promptId} exceeded ${deadlineMs}ms deadline for session ${sessionId}; agent may still be executing`
+          );
+          publishPromptTerminal(entry, pendingEntry, {
+            kind: "error",
+            err: {
+              code: "prompt_deadline_exceeded",
+              message: deadlineErr.message
+            }
+          });
+          settleActivePromptState(entry, pendingEntry.promptId);
+          deadlineReject?.(deadlineErr);
+          pendingAbort.abort(deadlineErr);
+        }, "onDeadline");
+        deadlineTimer = setTimeout(onDeadline, deadlineMs);
+        deadlineTimer.unref();
+      }
       if (isQueued) {
         pendingAbort.signal.addEventListener(
           "abort",
@@ -7756,6 +8305,9 @@ function createAcpSessionBridge(opts) {
           const queueWaitMs = Date.now() - queuedAt;
           telemetry.metrics?.promptQueueWait(queueWaitMs);
           if (pendingAbort.signal.aborted) {
+            if (pendingAbort.signal.reason instanceof PromptDeadlineExceededError) {
+              throw pendingAbort.signal.reason;
+            }
             throw new DOMException("Prompt aborted", "AbortError");
           }
           if (pendingEntry.state === "queued") {
@@ -7799,15 +8351,23 @@ function createAcpSessionBridge(opts) {
                     ...normalized
                   };
                   delete copy.retry;
+                  delete copy.delivery;
                   const meta = copy._meta && typeof copy._meta === "object" ? { ...copy._meta } : {};
                   delete meta[DAEMON_RETRY_META_KEY];
+                  delete meta[INVOCATION_CONTEXT_META_KEY];
+                  delete meta[PRIVATE_PARENT_CAPABILITY_META_KEY];
                   delete meta[DAEMON_CONTINUE_META_KEY];
+                  delete meta[DAEMON_CHANNEL_DELIVERY_META_KEY];
                   if (isRetry) {
                     meta[DAEMON_RETRY_META_KEY] = true;
                   }
                   if (isContinue) {
                     meta[DAEMON_CONTINUE_META_KEY] = true;
                   }
+                  if (context?.channelDelivery) {
+                    meta[DAEMON_CHANNEL_DELIVERY_META_KEY] = context.channelDelivery;
+                  }
+                  meta[INVOCATION_CONTEXT_META_KEY] = invocationContext;
                   if (Object.keys(meta).length > 0) {
                     copy._meta = meta;
                   } else {
@@ -7827,7 +8387,6 @@ function createAcpSessionBridge(opts) {
                   entry.activePromptOriginatorClientId = originatorClientId;
                 }
                 try {
-                  entry.cancelBroadcast = false;
                   if (!isRetry && !isContinue) {
                     echoPromptToSessionBus(
                       entry,
@@ -7837,35 +8396,18 @@ function createAcpSessionBridge(opts) {
                     );
                   }
                 } catch (echoErr) {
-                  delete entry.activePromptId;
-                  delete entry.activePromptOriginatorClientId;
-                  if (entry.promptActive) {
-                    entry.promptActive = false;
-                    activePromptCounter--;
-                    touchActivity();
-                  }
+                  settleActivePromptState(entry, pendingEntry.promptId);
                   throw echoErr;
                 }
+                pendingEntry.dispatched = true;
                 const promptPromise = entry.connection.prompt(promptRequest).finally(() => {
-                  if (entry.promptActive) {
-                    entry.promptActive = false;
-                    activePromptCounter--;
-                    entry.sessionLastSeenAt = Date.now();
-                    touchActivity();
-                  }
-                  delete entry.activePromptId;
-                  delete entry.activePromptOriginatorClientId;
-                  if (entry.clientIds.size === 0 && entry.events.subscriberCount === 0 && byId.has(sessionId)) {
-                    void closeSessionImpl(sessionId, void 0, {
-                      reason: "last_client_detached"
-                    }).catch((err) => {
-                      writeStderrLine(
-                        `qwen serve: deferred close-on-prompt-complete failed for ${JSON.stringify(sessionId)}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
-                      );
-                    });
-                  }
+                  settleActivePromptState(entry, pendingEntry.promptId);
                 });
-                const racedPromise = Promise.race([
+                const racedPromise = deadlinePromise ? Promise.race([
+                  promptPromise,
+                  getTransportClosedReject(entry),
+                  deadlinePromise
+                ]) : Promise.race([
                   promptPromise,
                   getTransportClosedReject(entry)
                 ]);
@@ -7873,6 +8415,9 @@ function createAcpSessionBridge(opts) {
                   () => {
                   },
                   (err) => {
+                    if (err instanceof PromptDeadlineExceededError) {
+                      return;
+                    }
                     if (err instanceof DOMException && err.name === "AbortError" && pendingEntry.state === "queued") {
                       writeStderrLine(
                         `sendPrompt: queued prompt removed before agent forward for session ${sessionId}`
@@ -7890,11 +8435,6 @@ function createAcpSessionBridge(opts) {
                       "forward_failed"
                     );
                     cancelPendingForSession(sessionId);
-                    entry.connection.cancel({ sessionId }).catch((err2) => {
-                      writeStderrLine(
-                        `[pending-prompt] cancel forward failed after prompt abort session=${sessionId}: ${extractErrorMessage(err2)}`
-                      );
-                    });
                   }
                 ).catch(() => {
                 });
@@ -7907,11 +8447,15 @@ function createAcpSessionBridge(opts) {
                     originatorClientId
                   );
                   cancelPendingForSession(sessionId);
-                  entry.connection.cancel({ sessionId }).catch((err) => {
-                    writeStderrLine(
-                      `[pending-prompt] cancel forward failed after removePendingPrompt session=${sessionId}: ${extractErrorMessage(err)}`
-                    );
-                  });
+                  if (byId.get(sessionId) === entry) {
+                    void forwardRunningPromptCancel(entry, pendingEntry, {
+                      sessionId
+                    }).catch((err) => {
+                      writeStderrLine(
+                        `[pending-prompt] cancel forward failed after removePendingPrompt session=${sessionId}: ${extractErrorMessage(err)}`
+                      );
+                    });
+                  }
                 }, "onAbort");
                 if (abortSignal.aborted) {
                   onAbort();
@@ -7935,34 +8479,35 @@ function createAcpSessionBridge(opts) {
       );
       result.then(
         (promptResult) => {
-          broadcastTurnComplete(
-            entry,
-            sessionId,
-            promptResult,
-            pendingEntry.promptId,
-            originatorClientId
-          );
+          publishPromptTerminal(entry, pendingEntry, {
+            kind: "complete",
+            result: promptResult
+          });
         },
         (err) => {
-          if (err instanceof DOMException && err.name === "AbortError") return;
-          broadcastTurnError(
-            entry,
-            sessionId,
-            err,
-            pendingEntry.promptId,
-            originatorClientId
-          );
+          if (err instanceof DOMException && err.name === "AbortError") {
+            publishPromptTerminal(entry, pendingEntry, { kind: "cancelled" });
+            return;
+          }
+          publishPromptTerminal(entry, pendingEntry, { kind: "error", err });
         }
       );
+      const drainCancelForwarding = /* @__PURE__ */ __name(async () => {
+        try {
+          await pendingEntry.cancelForwardDrain;
+        } catch {
+        }
+      }, "drainCancelForwarding");
       entry.promptQueue = result.then(
-        () => void 0,
-        () => void 0
+        drainCancelForwarding,
+        drainCancelForwarding
       );
       result.finally(() => {
+        if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
         const listIdx = entry.pendingPromptList.indexOf(pendingEntry);
         if (listIdx !== -1) {
           entry.pendingPromptList.splice(listIdx, 1);
-          if (isQueued) {
+          if (isQueued && !pendingEntry.removed) {
             try {
               entry.events.publish({
                 type: "pending_prompt_completed",
@@ -7985,6 +8530,15 @@ function createAcpSessionBridge(opts) {
           );
           entry.midTurnMessageQueue.length = 0;
         }
+        if (entry.clientIds.size === 0 && entry.events.subscriberCount === 0 && entry.pendingPromptCount === 0 && byId.get(sessionId) === entry) {
+          void closeSessionImpl(sessionId, void 0, {
+            reason: "last_client_detached"
+          }).catch((err) => {
+            writeStderrLine(
+              `qwen serve: deferred close-on-prompt-complete failed for ${JSON.stringify(sessionId)}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+            );
+          });
+        }
       }).catch(() => {
       });
       return result;
@@ -8000,10 +8554,13 @@ function createAcpSessionBridge(opts) {
         entry,
         context?.clientId
       );
+      const runningPrompt = entry.pendingPromptList.find(
+        (pending) => pending.state === "running" && !pending.terminalPublished
+      );
       broadcastPromptCancelledOnce(
         entry,
         sessionId,
-        entry.activePromptId,
+        entry.activePromptId ?? runningPrompt?.promptId,
         cancelOriginatorClientId
       );
       cancelPendingForSession(sessionId);
@@ -8016,6 +8573,17 @@ function createAcpSessionBridge(opts) {
           "session.id": sessionId
         },
         async () => {
+          if (runningPrompt) {
+            const forwarding = runningPrompt.dispatched === true && entry.activePromptId === runningPrompt.promptId ? forwardRunningPromptCancel(entry, runningPrompt, notif) : Promise.resolve();
+            runningPrompt.abortController.abort(
+              new DOMException(
+                "Prompt cancelled before dispatch",
+                "AbortError"
+              )
+            );
+            await forwarding;
+            return;
+          }
           try {
             await entry.connection.cancel(notif);
           } catch (err) {
@@ -8062,6 +8630,11 @@ function createAcpSessionBridge(opts) {
       if (!entry) throw new SessionNotFoundError(sessionId);
       return entry.events.lastEventId;
     },
+    getSessionEventEpoch(sessionId) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      return entry.events.epoch;
+    },
     getSessionReplaySnapshot(sessionId) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -8260,7 +8833,8 @@ function createAcpSessionBridge(opts) {
           SERVE_CONTROL_EXT_METHODS.sessionCd,
           {
             sessionId,
-            path: req.path
+            path: req.path,
+            ...req.allowedRoots ? { allowedRoots: req.allowedRoots } : {}
           }
         );
         const extResult = raw;
@@ -8296,6 +8870,12 @@ function createAcpSessionBridge(opts) {
       );
       return { sessionId, ...result };
     },
+    setSessionWorktree(sessionId, worktree) {
+      const entry = byId.get(sessionId);
+      if (entry) {
+        entry.worktree = worktree;
+      }
+    },
     async closeSession(sessionId, context, closeOpts) {
       return closeSessionImpl(sessionId, context, closeOpts);
     },
@@ -8699,33 +9279,7 @@ function createAcpSessionBridge(opts) {
       );
     },
     async getSessionTranscriptPage(req) {
-      const info = await ensureChannel();
-      try {
-        const response = await withWorkspaceControl(
-          info,
-          () => withTimeout(
-            Promise.race([
-              info.connection.extMethod(
-                SERVE_STATUS_EXT_METHODS.sessionTranscript,
-                { ...req, cwd: boundWorkspace }
-              ),
-              getChannelClosedReject(info)
-            ]),
-            Math.max(initTimeoutMs, SESSION_TRANSCRIPT_TIMEOUT_MS),
-            SERVE_STATUS_EXT_METHODS.sessionTranscript
-          )
-        );
-        return response;
-      } catch (err) {
-        if (isAcpSessionResourceNotFound(err, req.sessionId)) {
-          throw new SessionNotFoundError(req.sessionId);
-        }
-        throw err;
-      } finally {
-        if (hasNoChannelWork(info)) {
-          await startIdleTimer(info, "session transcript");
-        }
-      }
+      return requestSessionTranscriptPage(req);
     },
     async cancelSessionTask(sessionId, taskId, taskKind) {
       return requestSessionStatus(
@@ -8757,6 +9311,7 @@ function createAcpSessionBridge(opts) {
       const liveEntry = byId.get(sessionId);
       if (!liveEntry) throw new SessionNotFoundError(sessionId);
       const lastEventId = liveEntry.events.lastEventId;
+      const eventEpoch = liveEntry.events.epoch;
       const promptId = context?.promptId;
       const promptPromise = bridgeApi.sendPrompt(
         sessionId,
@@ -8776,7 +9331,8 @@ function createAcpSessionBridge(opts) {
       return {
         ...decision,
         ...promptId !== void 0 ? { promptId } : {},
-        lastEventId
+        lastEventId,
+        eventEpoch
       };
     },
     async getSessionStatsStatus(sessionId) {
@@ -9093,7 +9649,7 @@ function createAcpSessionBridge(opts) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
       resolveTrustedClientId(entry, context?.clientId);
-      return entry.pendingPromptList.map((p) => ({
+      return entry.pendingPromptList.filter((p) => !p.removed).map((p) => ({
         promptId: p.promptId,
         text: p.text,
         queuedAt: p.queuedAt,
@@ -9110,13 +9666,18 @@ function createAcpSessionBridge(opts) {
       );
       if (idx === -1) return { removed: false };
       const target = entry.pendingPromptList[idx];
+      if (target.removed) return { removed: false };
       writeStderrLine(
         `[pending-prompt] session=${sessionId} removing promptId=${promptId} state=${target.state}`
       );
       target.abortController.abort(
         new DOMException("Prompt removed by user", "AbortError")
       );
-      entry.pendingPromptList.splice(idx, 1);
+      if (target.state === "queued") {
+        entry.pendingPromptList.splice(idx, 1);
+      } else {
+        target.removed = true;
+      }
       try {
         entry.events.publish({
           type: "pending_prompt_completed",
@@ -9126,6 +9687,9 @@ function createAcpSessionBridge(opts) {
         });
       } catch {
       }
+      if (target.state === "queued") {
+        publishPromptTerminal(entry, target, { kind: "cancelled" });
+      }
       return { removed: true };
     },
     enqueueMidTurnMessage(sessionId, message, context) {
@@ -9373,6 +9937,9 @@ function createAcpSessionBridge(opts) {
     async rewindSession(sessionId, req, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
+      if (entry.closing) {
+        throw new SessionNotFoundError(sessionId, "The session is closing");
+      }
       const info = channelInfoForEntry(entry);
       if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
       const originatorClientId = resolveTrustedClientId(
@@ -9564,7 +10131,7 @@ function createAcpSessionBridge(opts) {
         }
       }
     },
-    async reloadWorkspaceMcp() {
+    async reloadWorkspaceMcp(options) {
       const info = await ensureChannel();
       info.workspaceMcpDiscoveryRequested = true;
       try {
@@ -9572,7 +10139,7 @@ function createAcpSessionBridge(opts) {
           withTimeout(
             info.connection.extMethod(
               SERVE_CONTROL_EXT_METHODS.workspaceMcpReload,
-              { cwd: boundWorkspace }
+              { cwd: boundWorkspace, ...options }
             ),
             initTimeoutMs,
             SERVE_CONTROL_EXT_METHODS.workspaceMcpReload
@@ -9606,6 +10173,85 @@ function createAcpSessionBridge(opts) {
         getChannelClosedReject(info)
       ]);
     },
+    generateWorkspaceContent(prompt, signal, _originatorClientId) {
+      const requestId = randomUUID2();
+      const queue = new GenerationStreamQueue(
+        GENERATION_STREAM_QUEUE_CAPACITY
+      );
+      const request = {
+        connection: void 0,
+        queue,
+        settled: false
+      };
+      const cancel = /* @__PURE__ */ __name(() => {
+        if (request.settled) return;
+        request.settled = true;
+        workspaceGenerationRequests.delete(requestId);
+        queue.close();
+        void request.connection?.extMethod(SERVE_CONTROL_EXT_METHODS.workspaceGenerationCancel, {
+          requestId
+        }).catch(() => void 0);
+      }, "cancel");
+      signal.addEventListener("abort", cancel, { once: true });
+      if (signal.aborted) {
+        cancel();
+        return queue;
+      }
+      void (async () => {
+        let info;
+        try {
+          const channelInfo2 = await ensureChannel();
+          info = channelInfo2;
+          request.connection = channelInfo2.connection;
+          await withWorkspaceControl(channelInfo2, async () => {
+            if (request.settled) return;
+            workspaceGenerationRequests.set(requestId, request);
+            const raw = await Promise.race([
+              withTimeout(
+                channelInfo2.connection.extMethod(
+                  SERVE_CONTROL_EXT_METHODS.workspaceGenerationStart,
+                  {
+                    requestId,
+                    prompt,
+                    purpose: "text"
+                  }
+                ),
+                SESSION_GENERATION_TIMEOUT_MS,
+                SERVE_CONTROL_EXT_METHODS.workspaceGenerationStart
+              ),
+              getChannelClosedReject(channelInfo2)
+            ]);
+            if (request.settled) return;
+            const response = raw;
+            const model = response["model"];
+            const modelSource = response["modelSource"];
+            if (typeof model !== "string" || modelSource !== "fast" && modelSource !== "main") {
+              throw new Error("Malformed workspace generation completion");
+            }
+            const accepted = queue.push({
+              type: "done",
+              requestId,
+              model,
+              modelSource,
+              ...typeof response["inputTokens"] === "number" ? { inputTokens: response["inputTokens"] } : {},
+              ...typeof response["outputTokens"] === "number" ? { outputTokens: response["outputTokens"] } : {}
+            });
+            if (accepted) queue.close();
+            else queue.fail(new Error("Generation stream consumer too slow"));
+          });
+        } catch (error) {
+          if (!request.settled) queue.fail(error);
+        } finally {
+          request.settled = true;
+          signal.removeEventListener("abort", cancel);
+          workspaceGenerationRequests.delete(requestId);
+          if (info && hasNoChannelWork(info) && !info.isDying) {
+            await startIdleTimer(info, "workspace generation");
+          }
+        }
+      })().catch(() => void 0);
+      return queue;
+    },
     async addRuntimeMcpServer(name, config, originatorClientId) {
       const info = liveChannelInfo();
       if (!info) {
@@ -9684,9 +10330,41 @@ function createAcpSessionBridge(opts) {
         entry.spawnOwnerWantedKill = true;
         return false;
       }
+      if (entry.closing) {
+        const closingChannel = channelInfoForEntry(entry);
+        if (!closingChannel) return false;
+        await killChannelWithLog(
+          closingChannel,
+          `force kill closing session ${JSON.stringify(sessionId)}`
+        );
+        return true;
+      }
+      entry.closing = true;
+      const ci = channelInfoForEntry(entry);
+      if (!ci) {
+        writeStderrLine(
+          `qwen serve: killSession channelInfoForEntry returned undefined for session ${JSON.stringify(sessionId)} \u2014 channel cleanup skipped (entry's channel already torn down)`
+        );
+      }
       permissionMediator.forgetSession(sessionId);
       entry.pendingPermissionIds.clear();
       entry.pendingInteractions.clear();
+      try {
+        await notifyAgentSessionClose(entry, ci, "killSession", {
+          throwOnFailure: true,
+          timeoutMs: initTimeoutMs
+        });
+      } catch (error) {
+        if (ci) {
+          await killChannelWithLog(
+            ci,
+            `force kill session ${JSON.stringify(sessionId)}`
+          );
+          return true;
+        }
+        entry.closing = false;
+        throw error;
+      }
       if (entry.promptActive) {
         entry.promptActive = false;
         activePromptCounter--;
@@ -9701,17 +10379,15 @@ function createAcpSessionBridge(opts) {
         workspaceCwd: entry.workspaceCwd,
         reason: "killed"
       });
-      const ci = channelInfoForEntry(entry);
-      if (!ci) {
-        writeStderrLine(
-          `qwen serve: killSession channelInfoForEntry returned undefined for session ${JSON.stringify(sessionId)} \u2014 channel cleanup skipped (entry's channel already torn down)`
-        );
-      }
       if (ci && ci.channel === entry.channel) {
         ci.sessionIds.delete(sessionId);
       }
-      await notifyAgentSessionClose(entry, ci, "killSession");
       ci?.client.markSessionClosed(sessionId);
+      flushPromptTerminals(
+        entry,
+        "session_killed",
+        "session killed before the prompt completed"
+      );
       try {
         entry.events.publish({
           type: "session_died",
@@ -9731,12 +10407,14 @@ function createAcpSessionBridge(opts) {
     async detachClient(sessionId, clientId) {
       const entry = byId.get(sessionId);
       if (!entry) return;
-      if (entry.attachCount > 0) entry.attachCount--;
+      if (clientId !== void 0 && releaseAttachRef(entry, clientId)) {
+        if (entry.attachCount > 0) entry.attachCount--;
+      }
       unregisterClient(entry, clientId);
       if (entry.spawnOwnerWantedKill && entry.attachCount === 0 && entry.events.subscriberCount === 0) {
         await this.killSession(sessionId).catch(() => {
         });
-      } else if (entry.clientIds.size === 0 && entry.events.subscriberCount === 0 && !entry.promptActive) {
+      } else if (entry.clientIds.size === 0 && entry.events.subscriberCount === 0 && entry.pendingPromptCount === 0) {
         await closeSessionImpl(sessionId, void 0, {
           reason: "last_client_detached"
         }).catch((err) => {
@@ -9800,6 +10478,11 @@ function createAcpSessionBridge(opts) {
             workspaceCwd: e.workspaceCwd,
             reason: shutdownReason
           });
+          flushPromptTerminals(
+            e,
+            "daemon_shutdown",
+            "daemon shut down before the prompt completed"
+          );
           try {
             e.events.publish({
               type: "session_died",