@qwen-code/qwen-code 0.21.12-preview.3 → 0.21.12

package/chunks/{chunk-O5G7IQGM.js → chunk-6P5EXEBL.js}

@@ -6,18 +6,20 @@ import {
   EventBus,
   logEventSizingFailed,
   serializedBridgeEventByteLength
-} from "./chunk-MZSJ43WV.js";
+} from "./chunk-7U5G6JXI.js";
 import {
+  JOURNAL_GROWTH_HARD_CAP_BYTES,
   normalizeCompactedReplayMaxBytes,
+  normalizeJournalGrowthPoolBytes,
   normalizeMaxJournalBytes,
   normalizeMaxJournalEvents
-} from "./chunk-XCGIMOLN.js";
+} from "./chunk-WCCLLK7X.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-TYGKUOEG.js";
+} from "./chunk-DAV4QFD5.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -27,7 +29,7 @@ import {
   SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-OPBATTFQ.js";
+} from "./chunk-HTYND72J.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_CLOSE_TIMEOUT_MS,
@@ -39,6 +41,7 @@ import {
   ACTIVE_WORK_MAX_SNAPSHOT_SESSIONS,
   ACTIVE_WORK_NOTIFICATION_METHOD,
   ACTIVE_WORK_STALE_INTERVALS,
+  CHANNEL_PROMPT_META_KEY,
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
   DAEMON_CHANNEL_DELIVERY_META_KEY,
@@ -46,6 +49,7 @@ import {
   DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
   LOAD_REPLAY_BULK_MODE,
   LOAD_REPLAY_HIDE_INHERITED_META_KEY,
+  LOAD_REPLAY_MAX_UPDATES,
   LOAD_REPLAY_META_KEY,
   LOAD_REPLAY_MODE_META_KEY,
   LOAD_REPLAY_PAGE_SIZE_META_KEY,
@@ -59,7 +63,7 @@ import {
   WORKTREE_MCP_DEFER_META_KEY,
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt
-} from "./chunk-HHGQGTJQ.js";
+} from "./chunk-FQDCO3CJ.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -98,7 +102,7 @@ import {
   EXTERNAL_TOOL_GUARD_READY_META_KEY,
   EXTERNAL_TOOL_GUARD_REQUIRED_VALUE,
   isValidExternalToolGuardDenialReason
-} from "./chunk-BKHCW2BI.js";
+} from "./chunk-3VUENPWF.js";
 import {
   ClientSideConnection,
   PROTOCOL_VERSION,
@@ -116,16 +120,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-M6HXP2SG.js";
+} from "./chunk-EBPLKY6U.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-O5AZPHYZ.js";
+} from "./chunk-K34GJQOZ.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-HB6QW4LM.js";
+} from "./chunk-4KM2SYK5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -155,6 +159,17 @@ var LATEST_WINS_UPDATES = /* @__PURE__ */ new Set([
 ]);
 var REPLAY_SEGMENT_COMPACT_THRESHOLD = 64;
 var LIVE_JOURNAL_TEXT_CHUNKS_PER_EVENT = 256;
+function createLiveJournalState() {
+  return {
+    entries: [],
+    entryBytes: [],
+    entryEvents: [],
+    totalBytes: 0,
+    totalEvents: 0,
+    truncatedEvents: 0
+  };
+}
+__name(createLiveJournalState, "createLiveJournalState");
 function replayRecordId(event) {
   if (event.type !== "session_update") return void 0;
   const data = event.data;
@@ -180,26 +195,35 @@ function lastRecordIdIn(events) {
   return void 0;
 }
 __name(lastRecordIdIn, "lastRecordIdIn");
+function lastSummaryRecordIdIn(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (!isSummaryLiveJournalEvent(events[i])) continue;
+    const id = replayRecordId(events[i]);
+    if (id !== void 0) return id;
+  }
+  return void 0;
+}
+__name(lastSummaryRecordIdIn, "lastSummaryRecordIdIn");
+var JOURNAL_GROWTH_REASK_INTERVAL_MS = 1e4;
+var JOURNAL_GROWTH_MAX_GRANTS_PER_BREACH = 64;
 var TurnBoundaryCompactionEngine = class {
   static {
     __name(this, "TurnBoundaryCompactionEngine");
   }
   maxReplayBytes;
+  // Mutable: adaptive growth (see `maybeGrowJournalLimits`) raises these
+  // in place when the advisor grants headroom.
   maxJournalEvents;
   maxJournalBytes;
+  onJournalGrowth;
+  now;
+  journalGrowthDeniedAt;
   onReplayWindowEviction;
   replaySegments = [];
   replaySegmentStart = 0;
   replayBytes = 0;
-  liveJournal = [];
-  /** Serialized source-event size of each `liveJournal` entry, index-parallel. */
-  journalEntryBytes = [];
-  /** Raw event count represented by each `liveJournal` entry. */
-  journalEntryEvents = [];
-  journalTotalBytes = 0;
-  journalTotalEvents = 0;
-  journalTruncatedEvents = 0;
-  liveJournalTextSegment;
+  fullJournal = createLiveJournalState();
+  summaryJournal = createLiveJournalState();
   lastEventId = 0;
   closed = false;
   truncatedEvents = 0;
@@ -212,6 +236,7 @@ var TurnBoundaryCompactionEngine = class {
   // pagination. Undefined until at least one recordId has been observed;
   // omitted from the marker in that case.
   activeRecordId;
+  summaryRecordId;
   // Pagination anchor for the replay-path `history_truncated` marker,
   // frozen at the first replay-window eviction. Prefers the first
   // retained recordId (the eviction boundary, so `beforeRecordId`
@@ -232,19 +257,30 @@ var TurnBoundaryCompactionEngine = class {
     this.maxReplayBytes = normalizeCompactedReplayMaxBytes(opts.maxReplayBytes);
     this.maxJournalEvents = normalizeMaxJournalEvents(opts.maxJournalEvents);
     this.maxJournalBytes = normalizeMaxJournalBytes(opts.maxJournalBytes);
+    this.onJournalGrowth = opts.onJournalGrowth;
+    this.now = opts.now ?? (() => performance.now());
     this.onReplayWindowEviction = opts.onReplayWindowEviction;
   }
+  /** Current journal caps — may have grown past the configured baseline. */
+  journalLimits() {
+    return { maxEvents: this.maxJournalEvents, maxBytes: this.maxJournalBytes };
+  }
   ingest(event, byteLength) {
     if (this.closed) return;
     if (event.id !== void 0) {
       this.lastEventId = event.id;
     }
     if (TRANSIENT_TYPES.has(event.type)) return;
+    const summaryEvent = isSummaryLiveJournalEvent(event);
     const seenRecordId = replayRecordId(event);
     if (seenRecordId !== void 0) {
       this.activeRecordId = seenRecordId;
+      if (summaryEvent) this.summaryRecordId = seenRecordId;
+    }
+    this.appendLiveJournal(this.fullJournal, event, byteLength);
+    if (summaryEvent) {
+      this.appendLiveJournal(this.summaryJournal, event, byteLength);
     }
-    this.appendLiveJournal(event, byteLength);
     if (TURN_BOUNDARY_TYPES.has(event.type)) {
       this.compactCurrentTurn(event);
       return;
@@ -255,49 +291,62 @@ var TurnBoundaryCompactionEngine = class {
     }
     this.slots.push({ kind: "misc", event });
   }
-  snapshot() {
+  snapshot(liveReplayMode = "full") {
     const compactedTurns = this.flattenReplaySegments();
     if (this.truncatedEvents > 0) {
       compactedTurns.unshift(
         this.makeHistoryTruncatedEvent(compactedTurns.length)
       );
     }
-    const liveJournal = this.liveJournal.map(
+    return {
+      compactedTurns,
+      liveJournal: this.liveJournalSnapshot(liveReplayMode),
+      lastEventId: this.lastEventId
+    };
+  }
+  /**
+   * Snapshot of only the in-flight live journal — the events ingested
+   * since the last turn boundary (a boundary folds its turn into the
+   * replay window and resets the journal). Cheaper than `snapshot()`:
+   * no replay-window flatten.
+   */
+  liveJournalSnapshot(liveReplayMode = "full") {
+    const journal = liveReplayMode === "summary" ? this.summaryJournal : this.fullJournal;
+    const journalRecordId = liveReplayMode === "summary" ? this.summaryRecordId : this.activeRecordId;
+    const liveJournal = journal.entries.map(
       (entry) => isLiveJournalTextSegment(entry) ? mergeLiveJournalTextEvent(
         entry.firstEvent,
         entry.lastEvent,
         entry.chunks
       ) : entry
     );
-    if (this.journalTruncatedEvents > 0) {
+    if (journal.truncatedEvents > 0) {
       liveJournal.unshift({
         v: EVENT_SCHEMA_VERSION,
         type: "history_truncated",
         data: {
           reason: "replay_window_exceeded",
           scope: "live_journal",
-          truncatedEvents: this.journalTruncatedEvents,
-          retainedEvents: this.journalTotalEvents,
+          truncatedEvents: journal.truncatedEvents,
+          retainedEvents: journal.totalEvents,
           maxBytes: this.maxJournalBytes,
           maxEvents: this.maxJournalEvents,
           // Pagination anchor — see makeHistoryTruncatedEvent.
-          ...this.activeRecordId !== void 0 ? { recordId: this.activeRecordId } : {},
+          ...journalRecordId !== void 0 ? { recordId: journalRecordId } : {},
           fullTranscriptAvailable: true
         }
       });
     }
-    return {
-      compactedTurns,
-      liveJournal,
-      lastEventId: this.lastEventId
-    };
+    return liveJournal;
   }
   seed(snapshot) {
     if (this.closed) return;
     this.resetReplayWindow();
     this.lastEventId = snapshot.lastEventId;
     this.activeRecordId = void 0;
+    this.summaryRecordId = void 0;
     this.activeRecordId = lastRecordIdIn(snapshot.compactedTurns);
+    this.summaryRecordId = lastSummaryRecordIdIn(snapshot.compactedTurns);
     for (const event of snapshot.compactedTurns) {
       if (TRANSIENT_TYPES.has(event.type)) continue;
       this.addReplaySegment([event], 0);
@@ -311,7 +360,9 @@ var TurnBoundaryCompactionEngine = class {
     if (this.closed) return;
     this.resetReplayWindow();
     this.activeRecordId = void 0;
+    this.summaryRecordId = void 0;
     this.activeRecordId = lastRecordIdIn(events);
+    this.summaryRecordId = lastSummaryRecordIdIn(events);
     let recordEvents = [];
     let recordId;
     const flushRecord = /* @__PURE__ */ __name(() => {
@@ -346,22 +397,23 @@ var TurnBoundaryCompactionEngine = class {
     this.resetReplayWindow();
     this.resetJournal();
     this.activeRecordId = void 0;
+    this.summaryRecordId = void 0;
     this.slots = [];
     this.toolSlotIndex.clear();
     this.clearTextSlotIndex();
   }
-  appendLiveJournal(event, byteLength) {
+  appendLiveJournal(journal, event, byteLength) {
     const bytes = byteLength ?? serializedBridgeEventByteLength(event) ?? 0;
     const textChunk = liveJournalTextChunk(event);
-    const current = this.liveJournalTextSegment;
-    const currentIndex = this.liveJournal.length - 1;
-    if (textChunk && current && this.liveJournal[currentIndex] === current && current.chunks.length < LIVE_JOURNAL_TEXT_CHUNKS_PER_EVENT && this.journalEntryBytes[currentIndex] + bytes <= this.maxJournalBytes && current.sessionUpdate === textChunk.sessionUpdate && current.parentToolCallId === textChunk.parentToolCallId && stringArraysEqual(current.sourceRecordIds, textChunk.sourceRecordIds) && current.promptId === event.promptId && current.originatorClientId === event.originatorClientId && current.sessionId === captureSessionId(event) && hasOnlyTimestampEnvelopeMeta(current.lastEvent._meta) && hasOnlyTimestampEnvelopeMeta(event._meta)) {
+    const current = journal.textSegment;
+    const currentIndex = journal.entries.length - 1;
+    if (textChunk && current && journal.entries[currentIndex] === current && current.chunks.length < LIVE_JOURNAL_TEXT_CHUNKS_PER_EVENT && journal.entryBytes[currentIndex] + bytes <= this.maxJournalBytes && current.sessionUpdate === textChunk.sessionUpdate && current.parentToolCallId === textChunk.parentToolCallId && stringArraysEqual(current.sourceRecordIds, textChunk.sourceRecordIds) && current.promptId === event.promptId && current.originatorClientId === event.originatorClientId && current.sessionId === captureSessionId(event) && hasOnlyTimestampEnvelopeMeta(current.lastEvent._meta) && hasOnlyTimestampEnvelopeMeta(event._meta)) {
       current.chunks.push(textChunk.text);
       current.lastEvent = event;
-      this.journalEntryBytes[currentIndex] += bytes;
-      this.journalEntryEvents[currentIndex] += 1;
-      this.journalTotalBytes += bytes;
-      this.journalTotalEvents += 1;
+      journal.entryBytes[currentIndex] += bytes;
+      journal.entryEvents[currentIndex] += 1;
+      journal.totalBytes += bytes;
+      journal.totalEvents += 1;
     } else {
       let entry = event;
       if (textChunk) {
@@ -377,26 +429,96 @@ var TurnBoundaryCompactionEngine = class {
           lastEvent: event
         };
         entry = segment;
-        this.liveJournalTextSegment = segment;
+        journal.textSegment = segment;
       } else {
-        this.liveJournalTextSegment = void 0;
+        journal.textSegment = void 0;
+      }
+      journal.entries.push(entry);
+      journal.entryBytes.push(bytes);
+      journal.entryEvents.push(1);
+      journal.totalBytes += bytes;
+      journal.totalEvents += 1;
+    }
+    if (!TURN_BOUNDARY_TYPES.has(event.type) && (journal.entries.length > this.maxJournalEvents || journal.totalBytes > this.maxJournalBytes && journal.entries.length > 1)) {
+      this.maybeGrowJournalLimits(journal);
+    }
+    while (journal.entries.length > this.maxJournalEvents || journal.totalBytes > this.maxJournalBytes && journal.entries.length > 1) {
+      const dropped = journal.entries.shift();
+      journal.totalBytes -= journal.entryBytes.shift() ?? 0;
+      const droppedEvents = journal.entryEvents.shift() ?? 0;
+      journal.totalEvents -= droppedEvents;
+      journal.truncatedEvents += droppedEvents;
+      if (dropped === journal.textSegment) {
+        journal.textSegment = void 0;
+      }
+    }
+  }
+  /**
+   * Consults the growth advisor once the journal breaches its caps and
+   * applies a grant in place, so the eviction loop below only drops what
+   * still exceeds the (possibly raised) caps. An intermediate grant that
+   * does not yet retain an extra entry is still applied tentatively —
+   * each applied cap is what the next ask reports and is charged for —
+   * and the walk continues until a grant retains strictly more than the
+   * pre-breach caps, the advisor refuses, or the step budget runs out. A
+   * walk that never improves retention rolls back to the original caps
+   * and counts as a refusal, so the pool is never charged for growth that
+   * preserves no replay. Never throws: a misbehaving advisor degrades to
+   * plain eviction, matching the engine's best-effort contract.
+   */
+  maybeGrowJournalLimits(journal) {
+    const advisor = this.onJournalGrowth;
+    if (!advisor || this.closed) return;
+    const now = this.now();
+    if (this.journalGrowthDeniedAt !== void 0) {
+      const sinceDenialMs = now - this.journalGrowthDeniedAt;
+      if (sinceDenialMs >= 0 && sinceDenialMs < JOURNAL_GROWTH_REASK_INTERVAL_MS) {
+        return;
       }
-      this.liveJournal.push(entry);
-      this.journalEntryBytes.push(bytes);
-      this.journalEntryEvents.push(1);
-      this.journalTotalBytes += bytes;
-      this.journalTotalEvents += 1;
     }
-    while (this.liveJournal.length > this.maxJournalEvents || this.journalTotalBytes > this.maxJournalBytes && this.liveJournal.length > 1) {
-      const dropped = this.liveJournal.shift();
-      this.journalTotalBytes -= this.journalEntryBytes.shift() ?? 0;
-      const droppedEvents = this.journalEntryEvents.shift() ?? 0;
-      this.journalTotalEvents -= droppedEvents;
-      this.journalTruncatedEvents += droppedEvents;
-      if (dropped === this.liveJournalTextSegment) {
-        this.liveJournalTextSegment = void 0;
+    const originalEvents = this.maxJournalEvents;
+    const originalBytes = this.maxJournalBytes;
+    const originalRetained = this.retainedTailCount(
+      journal,
+      originalEvents,
+      originalBytes
+    );
+    for (let step = 0; step < JOURNAL_GROWTH_MAX_GRANTS_PER_BREACH; step++) {
+      let grant;
+      try {
+        grant = advisor({
+          maxEvents: this.maxJournalEvents,
+          maxBytes: this.maxJournalBytes
+        });
+      } catch {
+        grant = void 0;
+      }
+      if (!grant || !Number.isSafeInteger(grant.maxBytes) || !Number.isSafeInteger(grant.maxEvents) || grant.maxBytes <= this.maxJournalBytes || grant.maxEvents < this.maxJournalEvents) {
+        break;
+      }
+      this.maxJournalBytes = grant.maxBytes;
+      this.maxJournalEvents = grant.maxEvents;
+      if (this.retainedTailCount(journal, grant.maxEvents, grant.maxBytes) > originalRetained) {
+        this.journalGrowthDeniedAt = void 0;
+        return;
       }
     }
+    this.maxJournalEvents = originalEvents;
+    this.maxJournalBytes = originalBytes;
+    this.journalGrowthDeniedAt = now;
+  }
+  /** Entries of the newest-first tail the eviction loop would retain. */
+  retainedTailCount(journal, maxEvents, maxBytes) {
+    let count = 0;
+    let bytes = 0;
+    for (let i = journal.entries.length - 1; i >= 0; i--) {
+      const entryBytes = journal.entryBytes[i] ?? 0;
+      if (count + 1 > maxEvents) break;
+      if (count >= 1 && bytes + entryBytes > maxBytes) break;
+      count += 1;
+      bytes += entryBytes;
+    }
+    return count;
   }
   classifySessionUpdate(event) {
     const data = event.data;
@@ -565,13 +687,9 @@ var TurnBoundaryCompactionEngine = class {
     }
   }
   resetJournal() {
-    this.liveJournal = [];
-    this.journalEntryBytes = [];
-    this.journalEntryEvents = [];
-    this.journalTotalBytes = 0;
-    this.journalTotalEvents = 0;
-    this.journalTruncatedEvents = 0;
-    this.liveJournalTextSegment = void 0;
+    this.fullJournal = createLiveJournalState();
+    this.summaryJournal = createLiveJournalState();
+    this.journalGrowthDeniedAt = void 0;
   }
   addReplaySegment(events, turnCount) {
     if (events.length === 0) return;
@@ -806,6 +924,21 @@ function extractParentToolCallIdFromMeta(meta) {
   return void 0;
 }
 __name(extractParentToolCallIdFromMeta, "extractParentToolCallIdFromMeta");
+function isSummaryLiveJournalEvent(event) {
+  if (event.type !== "session_update") return true;
+  const data = event.data;
+  const meta = data?.update?._meta;
+  const parentToolCallId = extractParentToolCallIdFromMeta(meta);
+  if (parentToolCallId === void 0) return true;
+  if (parentToolCallId === data?.update?.toolCallId) return true;
+  if (data?.update?.sessionUpdate !== "agent_message_chunk") return false;
+  if (typeof meta !== "object" || meta === null) return false;
+  const usage = meta["usage"];
+  if (typeof usage !== "object" || usage === null) return false;
+  const fields = usage;
+  return typeof fields["inputTokens"] === "number" || typeof fields["outputTokens"] === "number";
+}
+__name(isSummaryLiveJournalEvent, "isSummaryLiveJournalEvent");
 function extractSourceRecordIdsFromMeta(meta) {
   if (typeof meta !== "object" || meta === null) return void 0;
   const transcript = meta["qwenTranscript"];
@@ -928,6 +1061,44 @@ function mergeTranscriptUpdateMeta(existing, incoming) {
 }
 __name(mergeTranscriptUpdateMeta, "mergeTranscriptUpdateMeta");
 
+// packages/acp-bridge/src/journalGrowthPolicy.ts
+init_esbuild_shims();
+function createJournalGrowthPolicy(opts) {
+  const hardCapEvents = Math.min(
+    Number.MAX_SAFE_INTEGER,
+    Math.max(
+      opts.baselineEvents,
+      Math.ceil(opts.hardCapBytes / opts.baselineBytes * opts.baselineEvents)
+    )
+  );
+  return {
+    grant(request) {
+      if (request.currentMaxBytes >= opts.hardCapBytes) return void 0;
+      const extraGranted = request.allSessionLimits.reduce(
+        (sum, session) => sum + Math.max(0, session.limitBytes - session.baselineBytes),
+        0
+      );
+      const available = opts.poolBytes - extraGranted;
+      if (available <= 0) return void 0;
+      const maxBytes = Math.min(
+        request.currentMaxBytes * 2,
+        request.currentMaxBytes + available,
+        opts.hardCapBytes
+      );
+      if (maxBytes <= request.currentMaxBytes) return void 0;
+      const maxEvents = Math.min(
+        Math.max(
+          request.currentMaxEvents,
+          Math.ceil(maxBytes / opts.baselineBytes * opts.baselineEvents)
+        ),
+        hardCapEvents
+      );
+      return { maxBytes, maxEvents };
+    }
+  };
+}
+__name(createJournalGrowthPolicy, "createJournalGrowthPolicy");
+
 // packages/acp-bridge/src/session-restore-timeout.ts
 init_esbuild_shims();
 var DEFAULT_SESSION_RESTORE_TIMEOUT_MS = 6e4;
@@ -2461,12 +2632,13 @@ var BridgeClient = class {
     const toolCallId = params["toolCallId"];
     const toolName = params["toolName"];
     const args = params["arguments"];
-    if (typeof sessionId !== "string" || sessionId.length === 0 || typeof promptId !== "string" || promptId.length === 0 || typeof toolCallId !== "string" || toolCallId.length === 0 || typeof toolName !== "string" || toolName.length === 0 || !isRecord2(args)) {
+    if (typeof sessionId !== "string" || sessionId.length === 0 || promptId !== void 0 && (typeof promptId !== "string" || promptId.length === 0) || typeof toolCallId !== "string" || toolCallId.length === 0 || typeof toolName !== "string" || toolName.length === 0 || !isRecord2(args)) {
       throw RequestError.invalidParams(
         void 0,
         "Invalid external tool guard request"
       );
     }
+    const promptScoped = promptId !== void 0;
     if (!this.ownsSession(sessionId)) {
       throw RequestError.invalidParams(
         void 0,
@@ -2474,21 +2646,26 @@ var BridgeClient = class {
       );
     }
     const entry = this.resolveEntry(sessionId);
-    if (!entry || !entry.promptActive || entry.activePromptId !== promptId) {
+    if (!entry || promptScoped && (!entry.promptActive || entry.activePromptId !== promptId)) {
       throw RequestError.invalidParams(
         void 0,
         "External tool guard prompt is not the active prompt"
       );
     }
+    const invocationCwd = params["invocationCwd"];
     const decision = await this.externalToolGuard({
       sessionId: entry.sessionId,
-      promptId: entry.activePromptId,
+      ...promptScoped ? { promptId } : {},
       toolCallId,
       toolName,
-      arguments: args
+      arguments: args,
+      effectiveCwd: entry.effectiveCwd,
+      // Forwarded verbatim and explicitly untrusted: the host policy decides
+      // whether it can establish this scope from state it owns.
+      ...typeof invocationCwd === "string" && invocationCwd.length > 0 ? { invocationCwd } : {}
     });
     const currentEntry = this.resolveEntry(sessionId);
-    if (!this.ownsSession(sessionId) || currentEntry !== entry || !currentEntry.promptActive || currentEntry.activePromptId !== promptId) {
+    if (!this.ownsSession(sessionId) || currentEntry !== entry || promptScoped && (!currentEntry.promptActive || currentEntry.activePromptId !== promptId)) {
       throw RequestError.invalidParams(
         void 0,
         "External tool guard prompt is no longer active"
@@ -5911,7 +6088,6 @@ var KNOWN_SESSION_UPDATE_TYPES = /* @__PURE__ */ new Set([
   "session_info_update",
   "usage_update"
 ]);
-var MAX_BULK_REPLAY_UPDATES = 1e4;
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -6241,9 +6417,9 @@ function extractLoadReplayResponse(state) {
       `Invalid qwen.session.loadReplay updates (version=${LOAD_REPLAY_VERSION}, count=not-array)`
     );
   }
-  if (rawUpdates.length > MAX_BULK_REPLAY_UPDATES) {
+  if (rawUpdates.length > LOAD_REPLAY_MAX_UPDATES) {
     throw new Error(
-      `qwen.session.loadReplay updates exceed limit (${rawUpdates.length} > ${MAX_BULK_REPLAY_UPDATES})`
+      `qwen.session.loadReplay updates exceed limit (${rawUpdates.length} > ${LOAD_REPLAY_MAX_UPDATES})`
     );
   }
   const partial = replay["partial"];
@@ -6264,6 +6440,12 @@ function extractLoadReplayResponse(state) {
       `Invalid qwen.session.loadReplay hasMore (version=${LOAD_REPLAY_VERSION}, hasMore=${describeLoadReplayValue(hasMore)})`
     );
   }
+  const anchorRecordId = replay["anchorRecordId"];
+  if (anchorRecordId !== void 0 && typeof anchorRecordId !== "string") {
+    throw new Error(
+      `Invalid qwen.session.loadReplay anchorRecordId (version=${LOAD_REPLAY_VERSION}, anchorRecordId=${describeLoadReplayValue(anchorRecordId)})`
+    );
+  }
   const invalidUpdateIndex = rawUpdates.findIndex(
     (update) => !isBulkReplayUpdate(update)
   );
@@ -6285,6 +6467,7 @@ function extractLoadReplayResponse(state) {
   return {
     state: cleanState,
     updates: rawUpdates,
+    ...typeof anchorRecordId === "string" ? { anchorRecordId } : {},
     ...partial === true ? { partial: true } : {},
     ...typeof replayError === "string" ? { replayError } : {},
     ...hasMore === true ? { hasMore: true } : {}
@@ -6493,9 +6676,9 @@ function broadcastPromptCancelledOnce(entry, sessionId, promptId, originatorClie
   );
 }
 __name(broadcastPromptCancelledOnce, "broadcastPromptCancelledOnce");
-function broadcastTurnComplete(entry, sessionId, promptResult, promptId, originatorClientId) {
+function broadcastTurnComplete(entry, sessionId, promptResult, promptId, originatorClientId, mutateTurnState) {
   try {
-    entry.events.publish({
+    const published = entry.events.publish({
       type: "turn_complete",
       ...promptId ? { promptId } : {},
       data: {
@@ -6505,6 +6688,8 @@ function broadcastTurnComplete(entry, sessionId, promptResult, promptId, origina
       },
       ...originatorClientId ? { originatorClientId } : {}
     });
+    if (mutateTurnState && published !== void 0)
+      entry.turnErrorEvent = void 0;
   } catch {
   }
 }
@@ -6536,6 +6721,14 @@ function extractJsonRpcErrorDetail(data) {
   return void 0;
 }
 __name(extractJsonRpcErrorDetail, "extractJsonRpcErrorDetail");
+function extractJsonRpcErrorField(err, field) {
+  if (typeof err !== "object" || err === null) return void 0;
+  const data = err.data;
+  if (typeof data !== "object" || data === null) return void 0;
+  const value = data[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+__name(extractJsonRpcErrorField, "extractJsonRpcErrorField");
 function extractErrorCode(err) {
   if (typeof err !== "object" || err === null || !("code" in err))
     return void 0;
@@ -6545,14 +6738,79 @@ function extractErrorCode(err) {
   return void 0;
 }
 __name(extractErrorCode, "extractErrorCode");
+var REFRESH_APPEND_BOOKKEEPING_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "pending_prompt_added",
+  "pending_prompt_completed",
+  "prompt_cancelled",
+  "model_switched",
+  "model_switch_failed",
+  "approval_mode_changed",
+  "language_changed",
+  "session_metadata_updated",
+  "session_cwd_changed",
+  "artifact_changed",
+  "settings_changed",
+  "extensions_changed",
+  "mcp_server_changed",
+  "mcp_server_added",
+  "mcp_server_removed",
+  "user_shell_command",
+  "user_shell_result",
+  // Workspace-level fan-out (workspace service, git watcher, memory /
+  // agent CRUD, device-flow registry) reaches every session bus via
+  // `publishWorkspaceEvent` while idle. The `auth_device_flow_*` members
+  // mirror the closed `DeviceFlowEventEmission` union — audit that union
+  // when it grows.
+  "tool_toggled",
+  "workspace_initialized",
+  "mcp_server_restarted",
+  "mcp_server_restart_refused",
+  "settings_reloaded",
+  "trust_change_requested",
+  "memory_changed",
+  "agent_changed",
+  "git_status_changed",
+  "git_branch_changed",
+  "github_setup_completed",
+  "auth_device_flow_started",
+  "auth_device_flow_throttled",
+  "auth_device_flow_authorized",
+  "auth_device_flow_failed",
+  "auth_device_flow_cancelled"
+]);
+function isIdleBookkeepingSessionUpdate(event) {
+  if (event.type !== "session_update") return false;
+  const data = event.data;
+  if (!data || typeof data !== "object" || Array.isArray(data)) return false;
+  const update = data["update"];
+  if (!update || typeof update !== "object" || Array.isArray(update))
+    return false;
+  const updateRecord = update;
+  const subtype = updateRecord["sessionUpdate"];
+  if (subtype === "available_commands_update" || subtype === "current_mode_update") {
+    return true;
+  }
+  const meta = updateRecord["_meta"];
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return false;
+  return meta["source"] === "user-shell";
+}
+__name(isIdleBookkeepingSessionUpdate, "isIdleBookkeepingSessionUpdate");
+function isRefreshAppendTurnContent(event) {
+  if (event.type === "history_truncated") return false;
+  if (REFRESH_APPEND_BOOKKEEPING_EVENT_TYPES.has(event.type)) return false;
+  return !isIdleBookkeepingSessionUpdate(event);
+}
+__name(isRefreshAppendTurnContent, "isRefreshAppendTurnContent");
 function classifyTurnErrorKind(message) {
   return message.trim().toLowerCase() === "terminated" ? "model_stream_interrupted" : void 0;
 }
 __name(classifyTurnErrorKind, "classifyTurnErrorKind");
 function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId, mutateTurnState) {
   const message = extractErrorMessage(err);
-  const code = extractErrorCode(err);
-  const errorKind = classifyTurnErrorKind(message);
+  const structuredErrorKind = extractJsonRpcErrorField(err, "errorKind");
+  const errorKind = structuredErrorKind ?? classifyTurnErrorKind(message);
+  const code = structuredErrorKind !== void 0 ? extractJsonRpcErrorField(err, "code") ?? extractErrorCode(err) : extractErrorCode(err);
+  const loopType = extractJsonRpcErrorField(err, "loopType");
   if (errorKind) {
     writeServeDebugLine(
       `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)}` : "")
@@ -6567,7 +6825,7 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId,
     };
   }
   try {
-    entry.events.publish({
+    const published = entry.events.publish({
       type: "turn_error",
       ...promptId ? { promptId } : {},
       data: {
@@ -6575,10 +6833,14 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId,
         message,
         ...code ? { code } : {},
         ...errorKind ? { errorKind } : {},
+        ...loopType ? { loopType } : {},
         ...promptId ? { promptId } : {}
       },
       ...originatorClientId ? { originatorClientId } : {}
     });
+    if (mutateTurnState) {
+      entry.turnErrorEvent = published;
+    }
   } catch {
   }
 }
@@ -6592,13 +6854,21 @@ function publishPromptTerminal(entry, pendingEntry, terminal) {
   }
   pendingEntry.terminalPublished = true;
   const originatorClientId = pendingEntry.originatorClientId;
+  const mutateTurnState = pendingEntry.state === "running";
+  if (!mutateTurnState && entry.turnErrorEvent) {
+    const journal = entry.events.liveJournalSnapshot() ?? [];
+    if (journal.some(isRefreshAppendTurnContent)) {
+      entry.turnErrorEvent = void 0;
+    }
+  }
   if (terminal.kind === "complete") {
     broadcastTurnComplete(
       entry,
       entry.sessionId,
       terminal.result,
       pendingEntry.promptId,
-      originatorClientId
+      originatorClientId,
+      mutateTurnState
     );
   } else if (terminal.kind === "cancelled") {
     broadcastTurnComplete(
@@ -6606,7 +6876,8 @@ function publishPromptTerminal(entry, pendingEntry, terminal) {
       entry.sessionId,
       { stopReason: "cancelled" },
       pendingEntry.promptId,
-      originatorClientId
+      originatorClientId,
+      mutateTurnState
     );
   } else {
     broadcastTurnError(
@@ -6615,13 +6886,7 @@ function publishPromptTerminal(entry, pendingEntry, terminal) {
       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"
+      mutateTurnState
     );
   }
 }
@@ -6772,6 +7037,16 @@ function createAcpSessionBridge(opts) {
   );
   const maxJournalEvents = normalizeMaxJournalEvents(opts.maxJournalEvents);
   const maxJournalBytes = normalizeMaxJournalBytes(opts.maxJournalBytes);
+  const journalGrowthPoolBytes = normalizeJournalGrowthPoolBytes(
+    opts.journalGrowthPoolBytes
+  );
+  const journalGrowthPolicy = journalGrowthPoolBytes !== void 0 ? createJournalGrowthPolicy({
+    baselineEvents: maxJournalEvents,
+    baselineBytes: maxJournalBytes,
+    poolBytes: journalGrowthPoolBytes,
+    hardCapBytes: JOURNAL_GROWTH_HARD_CAP_BYTES
+  }) : void 0;
+  const journalGrowthSessionLimits = opts.journalGrowthSessionLimits;
   const channelFactory = opts.channelFactory ?? defaultSpawnChannelFactory;
   const childEnvOverrides = opts.childEnvOverrides ? Object.freeze({ ...opts.childEnvOverrides }) : Object.freeze({});
   const initTimeoutMs = opts.initializeTimeoutMs ?? DEFAULT_INIT_TIMEOUT_MS;
@@ -6869,6 +7144,12 @@ function createAcpSessionBridge(opts) {
     if (entryHasLocalWork(entry)) return false;
     const owner = channelInfoForEntry(entry);
     if (owner?.pendingRestoreIds.has(entry.sessionId)) return false;
+    const capability = owner?.activeWork;
+    if (capability && !owner.isQuarantined && !owner.restoreSettlementOverdue && ACTIVE_WORK_HOLD_CATEGORIES.some(
+      (category) => !capability.categories.includes(category)
+    )) {
+      return false;
+    }
     return !childReportsHeldWork(entry);
   }
   __name(entryIsAutoCloseCandidate, "entryIsAutoCloseCandidate");
@@ -7295,6 +7576,22 @@ function createAcpSessionBridge(opts) {
   const inFlightRequestedSessionSpawns = /* @__PURE__ */ new Map();
   const inFlightRestores = /* @__PURE__ */ new Map();
   const pendingRestoreEvents = /* @__PURE__ */ new Map();
+  const journalSessionLimits = /* @__PURE__ */ __name(() => {
+    const limits = [...byId.values()].map((entry) => ({
+      limitBytes: entry.events.journalLimitBytes() ?? maxJournalBytes,
+      baselineBytes: maxJournalBytes
+    }));
+    for (const [restoreId, bus] of pendingRestoreEvents) {
+      if (!byId.has(restoreId)) {
+        limits.push({
+          limitBytes: bus.journalLimitBytes() ?? maxJournalBytes,
+          baselineBytes: maxJournalBytes
+        });
+      }
+    }
+    return limits;
+  }, "journalSessionLimits");
+  const unregisterJournalGrowthSessionLimits = journalGrowthPolicy !== void 0 && opts.registerJournalGrowthSessionLimits !== void 0 ? opts.registerJournalGrowthSessionLimits(journalSessionLimits) : void 0;
   const createClientId = /* @__PURE__ */ __name(() => `client_${randomUUID2()}`, "createClientId");
   const registerClient = /* @__PURE__ */ __name((entry, requestedClientId) => {
     if (requestedClientId && entry.clientIds.has(requestedClientId)) {
@@ -7640,7 +7937,8 @@ function createAcpSessionBridge(opts) {
                   _meta: {
                     [ACTIVE_WORK_HEARTBEAT_META_KEY]: {
                       v: ACTIVE_WORK_HEARTBEAT_VERSION,
-                      intervalMs: ACTIVE_WORK_HEARTBEAT_INTERVAL_MS
+                      intervalMs: ACTIVE_WORK_HEARTBEAT_INTERVAL_MS,
+                      categories: [...ACTIVE_WORK_HOLD_CATEGORIES]
                     },
                     [CHANNEL_STARTUP_PROFILE_META_KEY]: {
                       v: CHANNEL_STARTUP_PROFILE_VERSION
@@ -8506,7 +8804,34 @@ function createAcpSessionBridge(opts) {
         teeServeDebugLine(
           `replay window evicted ${JSON.stringify(eviction)}`
         );
-      }, "onReplayWindowEviction")
+      }, "onReplayWindowEviction"),
+      // Adaptive growth: the engine asks before evicting past its caps.
+      // The policy accounts growth across this bridge's live sessions
+      // from every session's CURRENT journal cap (stateless — no ledger
+      // to reconcile when a session is reaped), so granted headroom dies
+      // with its session.
+      ...journalGrowthPolicy ? {
+        onJournalGrowth: /* @__PURE__ */ __name((current) => {
+          const allSessionLimits = journalGrowthSessionLimits ? [...journalGrowthSessionLimits()] : journalSessionLimits();
+          if (!byId.has(sessionId) && !pendingRestoreEvents.has(sessionId)) {
+            allSessionLimits.push({
+              limitBytes: current.maxBytes,
+              baselineBytes: maxJournalBytes
+            });
+          }
+          const grant = journalGrowthPolicy.grant({
+            currentMaxEvents: current.maxEvents,
+            currentMaxBytes: current.maxBytes,
+            allSessionLimits
+          });
+          if (grant) {
+            teeServeDebugLine(
+              `live journal growth session=${JSON.stringify(sessionId)}: ${current.maxBytes} -> ${grant.maxBytes} bytes, ${current.maxEvents} -> ${grant.maxEvents} entries`
+            );
+          }
+          return grant;
+        }, "onJournalGrowth")
+      } : {}
     }),
     {
       // Fired once, on the FIRST ingest/seed failure (the bus keeps the
@@ -8782,18 +9107,19 @@ function createAcpSessionBridge(opts) {
     }
     return typeof maybe.message === "string" && maybe.message === `Resource not found: ${expectedUri}`;
   }, "isAcpSessionResourceNotFound");
-  const replayFieldsFor = /* @__PURE__ */ __name((entry, action) => {
+  const replayFieldsFor = /* @__PURE__ */ __name((entry, action, liveReplayMode = "full") => {
     const replayStatus = action === "load" && entry.restoreReplayPartial === true ? {
       partial: true,
       ...typeof entry.restoreReplayError === "string" ? { replayError: entry.restoreReplayError } : {}
     } : {};
     const eventEpoch = entry.events.epoch;
-    const snapshot = entry.events.snapshotReplay();
+    const snapshot = entry.events.snapshotReplay(liveReplayMode);
     if (!snapshot) {
       return {
         lastEventId: entry.events.lastEventId,
         eventEpoch,
-        ...replayStatus
+        ...replayStatus,
+        ...action === "load" && entry.restoreHistoryAnchorRecordId !== void 0 ? { historyAnchorRecordId: entry.restoreHistoryAnchorRecordId } : {}
       };
     }
     if (action === "load") {
@@ -8810,7 +9136,8 @@ function createAcpSessionBridge(opts) {
         eventEpoch,
         ...replayStatus,
         ...snapshot.degraded ? { replayDegraded: true } : {},
-        ...entry.restoreHistoryHasMore === true ? { historyHasMore: true } : {}
+        ...entry.restoreHistoryHasMore === true ? { historyHasMore: true } : {},
+        ...entry.restoreHistoryAnchorRecordId !== void 0 ? { historyAnchorRecordId: entry.restoreHistoryAnchorRecordId } : {}
       };
     }
     return { lastEventId: snapshot.lastEventId, eventEpoch, ...replayStatus };
@@ -8876,7 +9203,7 @@ function createAcpSessionBridge(opts) {
     }
   }
   __name(requestSessionTranscriptPage, "requestSessionTranscriptPage");
-  async function refreshedReplayFieldsFor(entry, historyPageSize) {
+  async function refreshedReplayFieldsFor(entry, historyPageSize, liveReplayMode) {
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
         const lastEventId = entry.events.lastEventId;
@@ -8902,8 +9229,19 @@ function createAcpSessionBridge(opts) {
           if (cursor !== void 0) seenCursors.add(cursor);
         } while (page.events.length === 0 && page.hasMore && cursor !== void 0 && page.partial !== true && page.replayError === void 0);
         if (byId.get(entry.sessionId) === entry && !entry.promptActive && entry.events.epoch === eventEpoch && entry.events.lastEventId === lastEventId) {
+          let compactedReplay = page.events;
+          const turnErrorEvent = entry.turnErrorEvent;
+          if (turnErrorEvent) {
+            const journal = entry.events.liveJournalSnapshot() ?? [];
+            const hasNewerTurnContent = journal.some(
+              isRefreshAppendTurnContent
+            );
+            if (!hasNewerTurnContent) {
+              compactedReplay = [...page.events, turnErrorEvent];
+            }
+          }
           return {
-            compactedReplay: page.events,
+            compactedReplay,
             liveJournal: [],
             lastEventId,
             eventEpoch,
@@ -8916,7 +9254,7 @@ function createAcpSessionBridge(opts) {
         break;
       }
     }
-    return replayFieldsFor(entry, "load");
+    return replayFieldsFor(entry, "load", liveReplayMode);
   }
   __name(refreshedReplayFieldsFor, "refreshedReplayFieldsFor");
   function transcriptEventRecordId(event) {
@@ -8971,6 +9309,13 @@ function createAcpSessionBridge(opts) {
     }
     const historyReplay = action === "load" ? req.historyReplay ?? "stream" : "stream";
     const historyPageSize = action === "load" && historyReplay === "response" ? req.historyPageSize : void 0;
+    const requestedLiveReplayMode = req.liveReplayMode;
+    if (requestedLiveReplayMode !== void 0 && requestedLiveReplayMode !== "full" && requestedLiveReplayMode !== "summary") {
+      throw new Error(
+        `Invalid liveReplayMode: ${JSON.stringify(requestedLiveReplayMode)}`
+      );
+    }
+    const liveReplayMode = action === "load" ? requestedLiveReplayMode ?? "full" : "full";
     if (historyPageSize !== void 0 && (!Number.isSafeInteger(historyPageSize) || historyPageSize < 1 || historyPageSize > SESSION_TRANSCRIPT_MAX_LIMIT)) {
       throw new Error(
         `Invalid historyPageSize; expected 1..${SESSION_TRANSCRIPT_MAX_LIMIT}`
@@ -8980,7 +9325,11 @@ function createAcpSessionBridge(opts) {
     const existing = byId.get(req.sessionId);
     if (existing) {
       assertAttachableSessionEntry(req.sessionId, existing);
-      const replayFields = historyPageSize !== void 0 ? await refreshedReplayFieldsFor(existing, historyPageSize) : replayFieldsFor(existing, action);
+      const replayFields = historyPageSize !== void 0 ? await refreshedReplayFieldsFor(
+        existing,
+        historyPageSize,
+        liveReplayMode
+      ) : replayFieldsFor(existing, action, liveReplayMode);
       const historyAnchorRecordId = action === "load" ? await resolveHistoryAnchorRecordId(existing, replayFields) : void 0;
       assertAttachableSessionEntry(req.sessionId, existing);
       existing.attachCount++;
@@ -9026,7 +9375,7 @@ function createAcpSessionBridge(opts) {
     }
     const inFlight = inFlightRestores.get(req.sessionId);
     if (inFlight) {
-      if (inFlight.lifecycle.phase === "abandoned" || action !== inFlight.action || historyReplay !== inFlight.historyReplay || historyPageSize !== inFlight.historyPageSize || hideInheritedHistory !== inFlight.hideInheritedHistory) {
+      if (inFlight.lifecycle.phase === "abandoned" || action !== inFlight.action || historyReplay !== inFlight.historyReplay || historyPageSize !== inFlight.historyPageSize || inFlight.liveReplayMode === "summary" && liveReplayMode === "full" || hideInheritedHistory !== inFlight.hideInheritedHistory) {
         const abandoned = inFlight.lifecycle.phase === "abandoned";
         throw new RestoreInProgressError(
           req.sessionId,
@@ -9061,6 +9410,18 @@ function createAcpSessionBridge(opts) {
         entry.attachCount = Math.max(0, entry.attachCount - 1);
         throw error;
       }
+      const waiterReplayFields = liveReplayMode !== inFlight.liveReplayMode ? historyPageSize !== void 0 ? await refreshedReplayFieldsFor(
+        entry,
+        historyPageSize,
+        liveReplayMode
+      ) : replayFieldsFor(entry, action, liveReplayMode) : void 0;
+      try {
+        assertAttachableSessionEntry(restored.sessionId, entry);
+      } catch (error) {
+        inFlight.coalesceState.count--;
+        entry.attachCount = Math.max(0, entry.attachCount - 1);
+        throw error;
+      }
       const clientId = registerClient(entry, req.clientId);
       recordAttachRef(entry, clientId);
       if (req.approvalMode) {
@@ -9086,7 +9447,8 @@ function createAcpSessionBridge(opts) {
         attached: true,
         clientId,
         createdAt: entry.createdAt,
-        hasActivePrompt: entry.promptActive
+        hasActivePrompt: entry.promptActive,
+        ...waiterReplayFields ?? {}
       };
     }
     assertFreshSessionsAvailable();
@@ -9260,6 +9622,7 @@ function createAcpSessionBridge(opts) {
       let replayPartial;
       let replayError;
       let replayHasMore;
+      let replayAnchorRecordId;
       try {
         const rawRestore = telemetry.withSpan(
           "session.restore",
@@ -9370,6 +9733,7 @@ function createAcpSessionBridge(opts) {
           replayPartial = extracted.partial;
           replayError = extracted.replayError;
           replayHasMore = extracted.hasMore === true ? true : void 0;
+          replayAnchorRecordId = extracted.anchorRecordId;
         }
       } catch (err) {
         if (err instanceof SessionRestoreTimeoutError) throw err;
@@ -9447,7 +9811,7 @@ function createAcpSessionBridge(opts) {
           ...racedEntry.sourceId !== void 0 ? { sourceId: racedEntry.sourceId } : {},
           state: racedEntry.restoreState ?? {},
           hasActivePrompt: racedEntry.promptActive,
-          ...replayFieldsFor(racedEntry, action)
+          ...replayFieldsFor(racedEntry, action, liveReplayMode)
         };
       }
       const entry = createSessionEntry(
@@ -9478,6 +9842,9 @@ function createAcpSessionBridge(opts) {
       if (replayHasMore === true) {
         entry.restoreHistoryHasMore = true;
       }
+      if (replayAnchorRecordId !== void 0) {
+        entry.restoreHistoryAnchorRecordId = replayAnchorRecordId;
+      }
       seedSnapshotCaches(entry, publicState);
       const artifactRestoreWarnings = await entry.artifacts.restore(
         restoredArtifactSnapshot
@@ -9520,7 +9887,7 @@ function createAcpSessionBridge(opts) {
         state: publicState,
         ...artifactRestoreWarnings.length > 0 ? { artifactWarnings: artifactRestoreWarnings } : {},
         hasActivePrompt: entry.promptActive,
-        ...replayFieldsFor(entry, action)
+        ...replayFieldsFor(entry, action, liveReplayMode)
       };
     })().finally(async () => {
       if (restoreLifecycle.phase === "abandoned") return;
@@ -9583,6 +9950,7 @@ function createAcpSessionBridge(opts) {
       action,
       historyReplay,
       ...historyPageSize !== void 0 ? { historyPageSize } : {},
+      liveReplayMode,
       hideInheritedHistory,
       publicPromise: promise,
       settlementPromise,
@@ -9767,6 +10135,10 @@ function createAcpSessionBridge(opts) {
           compactedReplayMaxBytes,
           maxJournalEvents,
           maxJournalBytes,
+          journalGrowth: journalGrowthPoolBytes !== void 0 ? {
+            poolBytes: journalGrowthPoolBytes,
+            hardCapBytes: JOURNAL_GROWTH_HARD_CAP_BYTES
+          } : null,
           channelIdleTimeoutMs: resolvedChannelIdleTimeoutMs(),
           sessionIdleTimeoutMs
         },
@@ -9774,22 +10146,27 @@ function createAcpSessionBridge(opts) {
         pendingPermissionCount: permissionMediator.pendingCount,
         channelLive: !!liveChannelInfo(),
         permissionPolicy: permissionMediator.policy,
-        sessions: [...byId.values()].map((entry) => ({
-          sessionId: entry.sessionId,
-          workspaceCwd: entry.workspaceCwd,
-          createdAt: entry.createdAt,
-          ...entry.displayName ? { displayName: entry.displayName } : {},
-          clientCount: entry.clientIds.size,
-          subscriberCount: entry.events.subscriberCount,
-          attachCount: entry.attachCount,
-          pendingPromptCount: entry.pendingPromptCount,
-          pendingPermissionCount: entry.pendingPermissionIds.size,
-          hasActivePrompt: entry.promptActive,
-          lastEventId: entry.events.lastEventId,
-          ...entry.sessionLastSeenAt !== void 0 ? { lastSeenAt: entry.sessionLastSeenAt } : {},
-          ...entry.currentModelId ? { currentModelId: entry.currentModelId } : {},
-          ...entry.currentApprovalMode ? { currentApprovalMode: entry.currentApprovalMode } : {}
-        }))
+        sessions: [...byId.values()].map((entry) => {
+          const journalLimits = entry.events.journalLimits();
+          return {
+            sessionId: entry.sessionId,
+            workspaceCwd: entry.workspaceCwd,
+            createdAt: entry.createdAt,
+            ...entry.displayName ? { displayName: entry.displayName } : {},
+            clientCount: entry.clientIds.size,
+            subscriberCount: entry.events.subscriberCount,
+            attachCount: entry.attachCount,
+            pendingPromptCount: entry.pendingPromptCount,
+            pendingPermissionCount: entry.pendingPermissionIds.size,
+            hasActivePrompt: entry.promptActive,
+            lastEventId: entry.events.lastEventId,
+            ...entry.sessionLastSeenAt !== void 0 ? { lastSeenAt: entry.sessionLastSeenAt } : {},
+            ...entry.currentModelId ? { currentModelId: entry.currentModelId } : {},
+            ...entry.currentApprovalMode ? { currentApprovalMode: entry.currentApprovalMode } : {},
+            maxJournalEvents: journalLimits?.maxEvents ?? maxJournalEvents,
+            maxJournalBytes: journalLimits?.maxBytes ?? maxJournalBytes
+          };
+        })
       };
     },
     get sessionCount() {
@@ -10287,6 +10664,7 @@ function createAcpSessionBridge(opts) {
                   delete meta[DAEMON_CHANNEL_DELIVERY_META_KEY];
                   delete meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
                   delete meta[DAEMON_MODEL_PROMPT_META_KEY];
+                  delete meta[CHANNEL_PROMPT_META_KEY];
                   if (isRetry) {
                     meta[DAEMON_RETRY_META_KEY] = true;
                   }
@@ -10302,6 +10680,9 @@ function createAcpSessionBridge(opts) {
                   if (modelPrompt !== void 0) {
                     meta[DAEMON_MODEL_PROMPT_META_KEY] = modelPrompt;
                   }
+                  if (context?.channelPrompt === true) {
+                    meta[CHANNEL_PROMPT_META_KEY] = true;
+                  }
                   meta[INVOCATION_CONTEXT_META_KEY] = invocationContext;
                   if (Object.keys(meta).length > 0) {
                     copy._meta = meta;
@@ -10314,6 +10695,7 @@ function createAcpSessionBridge(opts) {
                 entry.activePromptId = pendingEntry.promptId;
                 delete entry.cancelBroadcastWithoutPrompt;
                 delete entry.turnError;
+                delete entry.turnErrorEvent;
                 activePromptCounter++;
                 entry.sessionLastSeenAt = Date.now();
                 touchActivity();
@@ -10361,6 +10743,10 @@ function createAcpSessionBridge(opts) {
                       );
                       return;
                     }
+                    if (extractJsonRpcErrorField(err, "errorKind")) {
+                      cancelPendingForSession(sessionId);
+                      return;
+                    }
                     writeStderrLine(
                       `sendPrompt: forward failed for session ${sessionId}: ${extractErrorMessage(err)}`
                     );
@@ -12765,6 +13151,7 @@ function createAcpSessionBridge(opts) {
       });
       void (async () => {
         shuttingDown = true;
+        unregisterJournalGrowthSessionLimits?.();
         cancelIdleTimer();
         stopSessionReaper();
         const entries = Array.from(byId.values());