@qwen-code/qwen-code 0.20.2-headless-image-routing.1 → 0.21.0

package/chunks/{chunk-QOZOIPSF.js → chunk-KIM5GUMA.js}

@@ -4,22 +4,9 @@ import {
   DEFAULT_RING_SIZE,
   EVENT_SCHEMA_VERSION,
   EventBus,
+  logEventSizingFailed,
   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";
+} from "./chunk-GLWP3FDB.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -42,9 +29,25 @@ import {
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
 } from "./chunk-UH3WSE5L.js";
+import {
+  normalizeCompactedReplayMaxBytes
+} from "./chunk-COH43MRJ.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 {
   defaultSpawnChannelFactory
-} from "./chunk-FZPTCQY7.js";
+} from "./chunk-7JURR4JT.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -53,11 +56,16 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-O4BHWVUD.js";
+} from "./chunk-VIA5XA4U.js";
 import {
   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,
@@ -74,11 +82,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-OTQ6PSZC.js";
+} from "./chunk-PHOF65IG.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-ZDP2Y2AL.js";
+} from "./chunk-NIBLUX3Y.js";
+import {
+  INVOCATION_CONTEXT_META_KEY,
+  PRIVATE_ACP_CAPABILITY_ENV,
+  PRIVATE_PARENT_CAPABILITY_META_KEY
+} from "./chunk-CIKQ7KKO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -88,7 +101,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
@@ -123,16 +136,32 @@ 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`);
+  }
+  return value;
+}
+__name(normalizeJournalCap, "normalizeJournalCap");
 var TurnBoundaryCompactionEngine = class {
   static {
     __name(this, "TurnBoundaryCompactionEngine");
   }
   maxReplayBytes;
+  maxJournalEvents;
+  maxJournalBytes;
   onReplayWindowEviction;
   replaySegments = [];
   replaySegmentStart = 0;
   replayBytes = 0;
   liveJournal = [];
+  /** Serialized size of each `liveJournal` entry, index-parallel. */
+  journalEntryBytes = [];
+  journalTotalBytes = 0;
+  journalTruncatedEvents = 0;
   lastEventId = 0;
   closed = false;
   truncatedEvents = 0;
@@ -145,15 +174,33 @@ 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.onReplayWindowEviction = opts.onReplayWindowEviction;
   }
-  ingest(event) {
+  ingest(event, byteLength) {
     if (this.closed) return;
     if (event.id !== void 0) {
       this.lastEventId = event.id;
     }
     if (TRANSIENT_TYPES.has(event.type)) return;
     this.liveJournal.push(event);
+    const bytes = byteLength ?? serializedBridgeEventByteLength(event) ?? 0;
+    this.journalEntryBytes.push(bytes);
+    this.journalTotalBytes += bytes;
+    while (this.liveJournal.length > this.maxJournalEvents || this.journalTotalBytes > this.maxJournalBytes && this.liveJournal.length > 1) {
+      this.liveJournal.shift();
+      this.journalTotalBytes -= this.journalEntryBytes.shift() ?? 0;
+      this.journalTruncatedEvents += 1;
+    }
     if (TURN_BOUNDARY_TYPES.has(event.type)) {
       this.compactCurrentTurn(event);
       return;
@@ -171,9 +218,25 @@ var TurnBoundaryCompactionEngine = class {
         this.makeHistoryTruncatedEvent(compactedTurns.length)
       );
     }
+    const liveJournal = this.liveJournal.slice();
+    if (this.journalTruncatedEvents > 0) {
+      liveJournal.unshift({
+        v: EVENT_SCHEMA_VERSION,
+        type: "history_truncated",
+        data: {
+          reason: "replay_window_exceeded",
+          scope: "live_journal",
+          truncatedEvents: this.journalTruncatedEvents,
+          retainedEvents: this.liveJournal.length,
+          maxBytes: this.maxJournalBytes,
+          maxEvents: this.maxJournalEvents,
+          fullTranscriptAvailable: true
+        }
+      });
+    }
     return {
       compactedTurns,
-      liveJournal: this.liveJournal.slice(),
+      liveJournal,
       lastEventId: this.lastEventId
     };
   }
@@ -185,7 +248,7 @@ var TurnBoundaryCompactionEngine = class {
       if (TRANSIENT_TYPES.has(event.type)) continue;
       this.addReplaySegment([event], 0);
     }
-    this.liveJournal = [];
+    this.resetJournal();
     this.slots = [];
     this.toolSlotIndex.clear();
     this.clearTextSlotIndex();
@@ -216,7 +279,7 @@ var TurnBoundaryCompactionEngine = class {
       recordEvents.push(event);
     }
     flushRecord();
-    this.liveJournal = [];
+    this.resetJournal();
     this.slots = [];
     this.toolSlotIndex.clear();
     this.clearTextSlotIndex();
@@ -225,7 +288,7 @@ var TurnBoundaryCompactionEngine = class {
     if (this.closed) return;
     this.closed = true;
     this.resetReplayWindow();
-    this.liveJournal = [];
+    this.resetJournal();
     this.slots = [];
     this.toolSlotIndex.clear();
     this.clearTextSlotIndex();
@@ -312,6 +375,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);
@@ -322,7 +387,9 @@ var TurnBoundaryCompactionEngine = class {
           sourceRecordIds,
           lastEventId: event.id ?? 0,
           lastMeta: meta,
-          lastEnvelopeMeta: event._meta
+          lastEnvelopeMeta: event._meta,
+          lastTurn: captureTurnFields(event),
+          lastSessionId: captureSessionId(event)
         });
       }
     } else {
@@ -332,6 +399,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,
@@ -340,7 +409,9 @@ var TurnBoundaryCompactionEngine = class {
           sourceRecordIds,
           lastEventId: event.id ?? 0,
           lastMeta: meta,
-          lastEnvelopeMeta: event._meta
+          lastEnvelopeMeta: event._meta,
+          lastTurn: captureTurnFields(event),
+          lastSessionId: captureSessionId(event)
         });
       }
     }
@@ -357,7 +428,9 @@ var TurnBoundaryCompactionEngine = class {
               slot.chunks.join(""),
               slot.lastEventId,
               slot.lastMeta,
-              slot.lastEnvelopeMeta
+              slot.lastEnvelopeMeta,
+              slot.lastTurn,
+              slot.lastSessionId
             )
           );
           break;
@@ -372,7 +445,7 @@ var TurnBoundaryCompactionEngine = class {
     }
     compacted.push(boundaryEvent);
     this.addReplaySegment(compacted, 1);
-    this.liveJournal = [];
+    this.resetJournal();
     this.slots = [];
     this.toolSlotIndex.clear();
     this.clearTextSlotIndex();
@@ -382,10 +455,27 @@ var TurnBoundaryCompactionEngine = class {
       this.lastEventId = event.id;
     }
   }
+  resetJournal() {
+    this.liveJournal = [];
+    this.journalEntryBytes = [];
+    this.journalTotalBytes = 0;
+    this.journalTruncatedEvents = 0;
+  }
   addReplaySegment(events, turnCount) {
     if (events.length === 0) return;
     const bytes = events.reduce(
-      (sum, event) => sum + serializedBridgeEventByteLength(event),
+      // Live events passed the publish-time serializability gate, but the
+      // seed paths (persisted transcripts) bypass it — log a diagnostic
+      // and count 0 so a single unserializable record can't wedge the
+      // replay-window accounting.
+      (sum, event) => {
+        const size = serializedBridgeEventByteLength(event);
+        if (size === void 0) {
+          logEventSizingFailed(event.type);
+          return sum;
+        }
+        return sum + size;
+      },
       0
     );
     this.replaySegments.push({ events: events.slice(), bytes, turnCount });
@@ -464,13 +554,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 },
@@ -480,6 +577,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") {
@@ -542,10 +656,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,
@@ -717,11 +835,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();
 
@@ -1407,6 +1520,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";
 }
@@ -1415,6 +1531,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 ?? ""),
@@ -1625,7 +1760,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;
@@ -1639,6 +1774,8 @@ var BridgeClient = class {
     this.onTokenUsage = onTokenUsage;
     this.onCreateSubSession = onCreateSubSession;
     this.onGenerationEvent = onGenerationEvent;
+    this.onWorkspaceGenerationEvent = onWorkspaceGenerationEvent;
+    this.onChannelDelivery = onChannelDelivery;
   }
   static {
     __name(this, "BridgeClient");
@@ -1916,6 +2053,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);
     }
@@ -1952,6 +2092,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
@@ -2119,6 +2351,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;
@@ -5303,13 +5576,17 @@ 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 || promptId === void 0 && entry.cancelBroadcastWithoutPrompt === true) {
     writeStderrLine(
-      `broadcastPromptCancelledOnce: suppressed duplicate cancel for session ${sessionId} (latch already set)`
+      `broadcastPromptCancelledOnce: suppressed duplicate cancel for session ${sessionId} prompt=${promptId ?? "none"}`
     );
     return;
   }
-  entry.cancelBroadcast = true;
+  if (promptId === void 0) {
+    entry.cancelBroadcastWithoutPrompt = true;
+  } else {
+    entry.cancelBroadcastPromptId = promptId;
+  }
   broadcastPromptCancelled(
     entry,
     sessionId,
@@ -5375,7 +5652,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);
@@ -5384,12 +5661,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",
@@ -5409,7 +5688,7 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId)
 __name(broadcastTurnError, "broadcastTurnError");
 function publishPromptTerminal(entry, pendingEntry, terminal) {
   if (pendingEntry.terminalPublished) {
-    writeStderrLine(
+    writeServeDebugLine(
       `publishPromptTerminal: suppressed duplicate ${terminal.kind} terminal for prompt ${pendingEntry.promptId} (session ${entry.sessionId})`
     );
     return;
@@ -5438,7 +5717,14 @@ function publishPromptTerminal(entry, pendingEntry, terminal) {
       entry.sessionId,
       terminal.err,
       pendingEntry.promptId,
-      originatorClientId
+      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"
     );
   }
 }
@@ -5775,7 +6061,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;
@@ -5803,7 +6136,8 @@ function createAcpSessionBridge(opts) {
       hasTurnError: entry.turnError !== void 0,
       ...entry.turnError !== void 0 ? { turnError: entry.turnError } : {},
       pendingInteractions: [...entry.pendingInteractions.values()],
-      ...entry.worktree ? { worktree: entry.worktree } : {}
+      ...entry.worktree ? { worktree: entry.worktree } : {},
+      ...entry.branch ? { branch: entry.branch } : {}
     };
   }, "toSessionSummary");
   const permissionConsensusQuorum = opts.permissionConsensusQuorum;
@@ -5910,6 +6244,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",
@@ -5918,7 +6253,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(
@@ -5998,7 +6336,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 = {
@@ -6107,7 +6457,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 }
@@ -6156,7 +6507,7 @@ function createAcpSessionBridge(opts) {
     }
   }
   __name(ensureChannel, "ensureChannel");
-  async function doSpawn(modelServiceId, effectiveScope, approvalMode, requestedClientId, onSessionRegistered, parentSessionId, sourceType, sourceId, worktree) {
+  async function doSpawn(modelServiceId, effectiveScope, approvalMode, requestedClientId, onSessionRegistered, parentSessionId, sourceType, sourceId, worktree, branch) {
     const channelPath = channelInfo && !channelInfo.isDying ? "reused" : inFlightChannelSpawn ? "joined" : "spawned_on_request";
     const ci = await telemetry.withSpan(
       "channel.wait",
@@ -6217,7 +6568,7 @@ function createAcpSessionBridge(opts) {
         newSessionResp.sessionId,
         boundWorkspace,
         void 0,
-        { parentSessionId, sourceType, sourceId, worktree }
+        { parentSessionId, sourceType, sourceId, worktree, branch }
       );
       initializedSessionId = entry.sessionId;
       sessionRegistered = true;
@@ -6332,7 +6683,8 @@ function createAcpSessionBridge(opts) {
         ...entry.sourceId !== void 0 ? { sourceId: entry.sourceId } : {},
         ...entry.sourceType ? { sourcePersisted: sourcePersisted === true } : {},
         ...entry.parentSessionId ? { parentSessionPersisted: parentSessionPersisted === true } : {},
-        ...entry.worktree ? { worktree: entry.worktree } : {}
+        ...entry.worktree ? { worktree: entry.worktree } : {},
+        ...entry.branch ? { branch: entry.branch } : {}
       };
     } finally {
       ci.sessionSpawnsInFlight = Math.max(0, ci.sessionSpawnsInFlight - 1);
@@ -6828,7 +7180,7 @@ function createAcpSessionBridge(opts) {
         if (published === void 0) {
           failureCount += 1;
           teeServeDebugLine(
-            `broadcastWorkspaceEvent: publish on session ${entry.sessionId} no-op (bus closed)`
+            `broadcastWorkspaceEvent: publish on session ${entry.sessionId} no-op (bus closed or unserializable)`
           );
         } else {
           successCount += 1;
@@ -6850,7 +7202,7 @@ function createAcpSessionBridge(opts) {
       );
     }
   }, "broadcastWorkspaceEvent");
-  const createSessionEventBus = /* @__PURE__ */ __name(() => new EventBus(
+  const createSessionEventBus = /* @__PURE__ */ __name((sessionId) => new EventBus(
     eventRingSize,
     void 0,
     new TurnBoundaryCompactionEngine({
@@ -6860,7 +7212,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=${JSON.stringify(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;
@@ -6944,7 +7306,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,
@@ -6953,6 +7315,7 @@ function createAcpSessionBridge(opts) {
       ...options.sourceType ? { sourceType: options.sourceType } : {},
       ...options.sourceId !== void 0 ? { sourceId: options.sourceId } : {},
       ...options.worktree ? { worktree: options.worktree } : {},
+      ...options.branch ? { branch: options.branch } : {},
       channel: ci.channel,
       connection: ci.connection,
       events,
@@ -7120,20 +7483,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;
@@ -7166,6 +7536,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");
@@ -7185,6 +7611,10 @@ function createAcpSessionBridge(opts) {
           "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);
@@ -7203,7 +7633,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);
@@ -7247,7 +7677,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 };
@@ -7797,7 +8227,8 @@ function createAcpSessionBridge(opts) {
         req.parentSessionId,
         source.sourceType,
         source.sourceId,
-        req.worktree
+        req.worktree,
+        req.branch
       );
       const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID2()}`;
       inFlightSpawns.set(tracker, promise);
@@ -7849,6 +8280,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) {
@@ -7882,6 +8319,10 @@ function createAcpSessionBridge(opts) {
         });
         deadlinePromise.catch(() => {
         });
+        pendingEntry.cancelForwardDeadline = deadlinePromise.then(
+          () => void 0,
+          () => void 0
+        );
         const onDeadline = /* @__PURE__ */ __name(() => {
           if (pendingEntry.terminalPublished) return;
           const deadlineErr = new PromptDeadlineExceededError(deadlineMs);
@@ -7938,6 +8379,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") {
@@ -7981,15 +8425,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 {
@@ -7999,6 +8451,7 @@ function createAcpSessionBridge(opts) {
                 })();
                 entry.promptActive = true;
                 entry.activePromptId = pendingEntry.promptId;
+                delete entry.cancelBroadcastWithoutPrompt;
                 delete entry.turnError;
                 activePromptCounter++;
                 entry.sessionLastSeenAt = Date.now();
@@ -8009,7 +8462,6 @@ function createAcpSessionBridge(opts) {
                   entry.activePromptOriginatorClientId = originatorClientId;
                 }
                 try {
-                  entry.cancelBroadcast = false;
                   if (!isRetry && !isContinue) {
                     echoPromptToSessionBus(
                       entry,
@@ -8022,6 +8474,7 @@ function createAcpSessionBridge(opts) {
                   settleActivePromptState(entry, pendingEntry.promptId);
                   throw echoErr;
                 }
+                pendingEntry.dispatched = true;
                 const promptPromise = entry.connection.prompt(promptRequest).finally(() => {
                   settleActivePromptState(entry, pendingEntry.promptId);
                 });
@@ -8057,11 +8510,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(() => {
                 });
@@ -8074,11 +8522,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();
@@ -8115,16 +8567,22 @@ function createAcpSessionBridge(opts) {
           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",
@@ -8171,10 +8629,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);
@@ -8187,6 +8648,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) {
@@ -8233,6 +8705,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);
@@ -8608,7 +9085,7 @@ function createAcpSessionBridge(opts) {
           if (published === void 0) {
             failureCount += 1;
             teeServeDebugLine(
-              `publishWorkspaceEvent: publish on session ${entry.sessionId} no-op (bus closed)`
+              `publishWorkspaceEvent: publish on session ${entry.sessionId} no-op (bus closed or unserializable)`
             );
           } else {
             successCount += 1;
@@ -8877,33 +9354,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(
@@ -8935,6 +9386,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,
@@ -8954,7 +9406,8 @@ function createAcpSessionBridge(opts) {
       return {
         ...decision,
         ...promptId !== void 0 ? { promptId } : {},
-        lastEventId
+        lastEventId,
+        eventEpoch
       };
     },
     async getSessionStatsStatus(sessionId) {
@@ -9271,7 +9724,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,
@@ -9288,13 +9741,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",
@@ -9748,7 +10206,7 @@ function createAcpSessionBridge(opts) {
         }
       }
     },
-    async reloadWorkspaceMcp() {
+    async reloadWorkspaceMcp(options) {
       const info = await ensureChannel();
       info.workspaceMcpDiscoveryRequested = true;
       try {
@@ -9756,7 +10214,7 @@ function createAcpSessionBridge(opts) {
           withTimeout(
             info.connection.extMethod(
               SERVE_CONTROL_EXT_METHODS.workspaceMcpReload,
-              { cwd: boundWorkspace }
+              { cwd: boundWorkspace, ...options }
             ),
             initTimeoutMs,
             SERVE_CONTROL_EXT_METHODS.workspaceMcpReload
@@ -9790,6 +10248,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) {