@qwen-code/qwen-code 0.21.12-preview.1 → 0.21.12-preview.4

package/chunks/{chunk-VUTOKX6F.js → chunk-A2QIWDFO.js}

@@ -6,18 +6,20 @@ import {
   EventBus,
   logEventSizingFailed,
   serializedBridgeEventByteLength
-} from "./chunk-MZSJ43WV.js";
+} from "./chunk-JVY7FHUZ.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-TKAEODJR.js";
+} from "./chunk-2U3UCXZ3.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -27,7 +29,7 @@ import {
   SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-OPBATTFQ.js";
+} from "./chunk-NHZF4VCD.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_CLOSE_TIMEOUT_MS,
@@ -46,6 +48,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 +62,7 @@ import {
   WORKTREE_MCP_DEFER_META_KEY,
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt
-} from "./chunk-HHGQGTJQ.js";
+} from "./chunk-UFHPAMAV.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -116,16 +119,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-INQN4KIA.js";
+} from "./chunk-GHOUZ5X4.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-O5AZPHYZ.js";
+} from "./chunk-U5C2GIN2.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-HB6QW4LM.js";
+} from "./chunk-UAAWNTOC.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -155,6 +158,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 +194,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 +235,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 +256,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,33 +290,35 @@ 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(
+    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
         }
       });
@@ -297,7 +334,9 @@ var TurnBoundaryCompactionEngine = class {
     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 +350,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 +387,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,27 +419,97 @@ var TurnBoundaryCompactionEngine = class {
           lastEvent: event
         };
         entry = segment;
-        this.liveJournalTextSegment = segment;
+        journal.textSegment = segment;
       } else {
-        this.liveJournalTextSegment = void 0;
+        journal.textSegment = void 0;
       }
-      this.liveJournal.push(entry);
-      this.journalEntryBytes.push(bytes);
-      this.journalEntryEvents.push(1);
-      this.journalTotalBytes += bytes;
-      this.journalTotalEvents += 1;
+      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 (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;
+    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;
+      }
+    }
+    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;
     const updateType = data?.update?.sessionUpdate;
@@ -565,13 +677,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 +914,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 +1051,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;
@@ -5911,7 +6072,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 +6401,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 +6424,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 +6451,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 } : {}
@@ -6772,6 +6939,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;
@@ -7295,6 +7472,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)) {
@@ -8506,7 +8699,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 +9002,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 +9031,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 +9098,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;
@@ -8916,7 +9138,7 @@ function createAcpSessionBridge(opts) {
         break;
       }
     }
-    return replayFieldsFor(entry, "load");
+    return replayFieldsFor(entry, "load", liveReplayMode);
   }
   __name(refreshedReplayFieldsFor, "refreshedReplayFieldsFor");
   function transcriptEventRecordId(event) {
@@ -8971,6 +9193,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 +9209,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 +9259,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 +9294,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 +9331,8 @@ function createAcpSessionBridge(opts) {
         attached: true,
         clientId,
         createdAt: entry.createdAt,
-        hasActivePrompt: entry.promptActive
+        hasActivePrompt: entry.promptActive,
+        ...waiterReplayFields ?? {}
       };
     }
     assertFreshSessionsAvailable();
@@ -9260,6 +9506,7 @@ function createAcpSessionBridge(opts) {
       let replayPartial;
       let replayError;
       let replayHasMore;
+      let replayAnchorRecordId;
       try {
         const rawRestore = telemetry.withSpan(
           "session.restore",
@@ -9370,6 +9617,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 +9695,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 +9726,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 +9771,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 +9834,7 @@ function createAcpSessionBridge(opts) {
       action,
       historyReplay,
       ...historyPageSize !== void 0 ? { historyPageSize } : {},
+      liveReplayMode,
       hideInheritedHistory,
       publicPromise: promise,
       settlementPromise,
@@ -9767,6 +10019,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 +10030,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() {
@@ -12765,6 +13026,7 @@ function createAcpSessionBridge(opts) {
       });
       void (async () => {
         shuttingDown = true;
+        unregisterJournalGrowthSessionLimits?.();
         cancelIdleTimer();
         stopSessionReaper();
         const entries = Array.from(byId.values());