@ponythewhite/base-context 1.0.10 → 1.0.11

package/dist/bundle/{chunk-CDXQNS5P.js → chunk-TOOVREMP.js}

@@ -27790,6 +27790,12 @@ function readContextEpoch(details, maxBytes) {
     throw new Error("Invalid committed context epoch");
   return snapshotContextEpoch(value, maxBytes);
 }
+var UnsupportedContextEpochConfigurationError = class extends Error {
+  constructor() {
+    super("Unsupported context epoch request configuration");
+    this.name = "UnsupportedContextEpochConfigurationError";
+  }
+};
 function contextEpochRepresentation(request, assessment, maxBytes, unbudgetedPublic = false, responseItemIdentity) {
   if (!assessment && !unbudgetedPublic || assessment && (!assessment.profile || assessment.limitSource !== "explicit-profile" || !assessment.route || !assessment.model) || request.body === void 0)
     throw new Error("Committed context epoch requires its explicit request profile");
@@ -27827,7 +27833,7 @@ function contextEpochRepresentation(request, assessment, maxBytes, unbudgetedPub
     if (["input", "messages", "previous_response_id", "prompt_cache_key"].includes(key2))
       continue;
     if (!fields.has(key2))
-      throw new Error("Unsupported context epoch request configuration");
+      throw new UnsupportedContextEpochConfigurationError();
     configuration[key2] = value;
   }
   const input = "input" in body ? body.input : "messages" in body ? body.messages : void 0;
@@ -29066,6 +29072,15 @@ var HistoryIndex = class _HistoryIndex {
       snapshot: target
     });
   }
+  /** Whole-source own usage for exactly the current acknowledged owner snapshot. */
+  async currentSourceUsage(sessionId, snapshot) {
+    return await this.request({
+      id: this.nextId++,
+      action: "current_source_usage",
+      sessionId,
+      snapshot
+    });
+  }
   /** Latest label control for this source target, including a clear. */
   async sourceLabel(sessionId, targetId, through) {
     return await this.request({ id: this.nextId++, action: "source_label", sessionId, targetId, through });
@@ -29080,6 +29095,17 @@ var HistoryIndex = class _HistoryIndex {
       through
     });
   }
+  /** All matching source update refs, including off-branch and older revisions. */
+  async sourceContextUpdates(sessionId, target, through, after = 0) {
+    return await this.request({
+      id: this.nextId++,
+      action: "source_context_updates",
+      sessionId,
+      target: target.kind === "assistant-usage" ? { kind: target.kind, targetId: target.targetId } : { kind: target.kind, toolCallId: target.toolCallId },
+      through,
+      after
+    });
+  }
   async get(sessionId, eventId, scope) {
     return await this.request({
       id: this.nextId++,
@@ -29402,6 +29428,7 @@ function createSessionHistoryReadScope(index, source, query, scope) {
     }),
     sourceLabel: (targetId) => query(() => index.sourceLabel(sessionId, targetId, source.sourceSequence)),
     sourceAssistantUsage: (targetId) => query(() => index.sourceAssistantUsage(sessionId, targetId, source.sourceSequence)),
+    sourceContextUpdates: (target, after = 0) => query(() => index.sourceContextUpdates(sessionId, target, source.sourceSequence, after)),
     ipythonSentMessages: (toolCallId, options = {}) => query(() => index.ipythonSentMessages(sessionId, branch, toolCallId, options)),
     get,
     page,
@@ -29495,6 +29522,12 @@ var SessionHistoryIndex = class {
     const index = await this.synchronize(captured);
     return index.currentSourceBootstrap(this.sessionId, captured);
   }
+  /** Caller holds the owner queue until the exact current projection is read. */
+  async currentSourceUsage(snapshot) {
+    const captured = { ...snapshot };
+    const index = await this.synchronize(captured);
+    return index.currentSourceUsage(this.sessionId, captured);
+  }
   /** Finish accepted indexing, then wait for the external worker to close. */
   close() {
     this.closing ??= (async () => {
@@ -31574,7 +31607,19 @@ function prepareCanonicalEpoch(messages, selectedUnitIds, representation, maxByt
     messages: chosen
   };
 }
-function canonicalRecoveryBoundary(messages) {
+var MissingRecoveryReplayContractError = class extends Error {
+  constructor() {
+    super("Recovery compaction requires an accepted replay contract for its selected results");
+    this.name = "MissingRecoveryReplayContractError";
+  }
+};
+function sameRecoverySource(left, right, ownerStillCurrent = false) {
+  return JSON.stringify(left) === JSON.stringify(right) || ownerStillCurrent && left.sessionId === right.sessionId && left.sessionFile === right.sessionFile && left.persistent === right.persistent;
+}
+function sameRecoveryReference(left, right, ownerStillCurrent = false) {
+  return sameRecoverySource(left.source, right.source, ownerStillCurrent) && JSON.stringify(left.ref) === JSON.stringify(right.ref) && left.sourceRevision === right.sourceRevision;
+}
+function canonicalRecoveryBoundary(messages, authorization) {
   const context = compiledEpochContexts.get(messages);
   const units = getCanonicalViewUnits(messages);
   if (!context || !units)
@@ -31584,15 +31629,22 @@ function canonicalRecoveryBoundary(messages) {
   const recoveries = units.flatMap((unit, index) => unit.kind === "recovery" ? [context.references[index]] : []);
   if (!recoveries.length)
     return;
+  if (authorization) {
+    const ownerStillCurrent = authorization.isSourceCurrent?.();
+    if (ownerStillCurrent === false || !sameRecoverySource(context.source, authorization.source, ownerStillCurrent === true) || context.resourceRevision !== authorization.resourceRevision || recoveries.length !== authorization.recoveries.length || recoveries.some((reference) => !reference || !authorization.recoveries.some((covered) => sameRecoveryReference(reference, covered, ownerStillCurrent === true))))
+      throw new Error("Recovery compaction authorization no longer matches its captured source");
+    return latestLiteralReference(context.references)?.ref.entryId;
+  }
   const checkpoint = context.checkpoint;
-  if (!checkpoint?.representation || checkpoint.replayContract !== "message-groups" || recoveries.some((reference) => !reference || reference.ref.sequence > checkpoint.source.sourceSequence))
-    throw new Error("Recovery compaction requires an accepted replay contract for its selected results");
+  const inherited = checkpoint?.includeSummary === true && checkpoint.replayContract === "message-groups";
+  if (checkpoint?.replayContract !== "message-groups" || recoveries.some((reference) => !reference || (checkpoint.representation ? reference.ref.sequence > checkpoint.source.sourceSequence : !inherited || !context.inheritedRecoveryCoverage?.some((covered) => sameRecoveryReference(reference, covered)))))
+    throw new MissingRecoveryReplayContractError();
   return checkpoint.literalTailId;
 }
-function prepareRecoveryCompaction(messages, firstKeptEntryId, maxBytes) {
-  const boundary = canonicalRecoveryBoundary(messages);
+function prepareRecoveryCompaction(messages, firstKeptEntryId, maxBytes, authorization) {
+  const boundary = canonicalRecoveryBoundary(messages, authorization);
   const context = compiledEpochContexts.get(messages);
-  const publicWindow = context?.checkpoint?.publicWindow === true && context.checkpoint.replayContract === "message-groups";
+  const publicWindow = authorization ? authorization.publicWindow : context?.checkpoint?.publicWindow === true && context.checkpoint.replayContract === "message-groups";
   if (!boundary && !publicWindow && !context?.selectedSkills?.length && !context?.toolContinuations?.length)
     return;
   if (!context)
@@ -32324,10 +32376,83 @@ ${JSON.stringify(selections.map((skill) => ({
         units: selectionUnits,
         limits: unitLimits,
         ...mode === "on" && (taskFrameRebased || checkpoint) ? { requiresEpoch: true } : {},
+        ...mode === "on" && sourceUnits.some((unit) => unit.kind === "recovery") ? { recoveryContractRequested: true } : {},
         ...pendingPublicMessageGroups.length ? { pendingPublicMessageGroups } : {}
       }
     });
+    const inheritedRecoveryCoverage = [];
+    if (checkpoint?.includeSummary && checkpoint.replayContract === "message-groups" && closedUnits.some((unit) => unit.kind === "recovery")) {
+      const prefix = await view.atSnapshot(checkpoint.source);
+      const suffix = /* @__PURE__ */ new Map();
+      const frozenViews = /* @__PURE__ */ new Map();
+      let capturedMessages = 0;
+      let retained = false;
+      let cursor2;
+      for (; ; ) {
+        const page = await prefix.contextManifest({ cursor: cursor2, limit: 128 });
+        if (page.selection !== "known")
+          throw new Error("Summary recovery source is unavailable");
+        if (!cursor2 && page.summaryRef) {
+          const entry = await hydrate(page.summaryRef, void 0, prefix);
+          const metadata = await prefix.get(page.summaryRef.entryId);
+          const prior = entry.type === "compaction" && metadata?.qualification === "native-context-epoch" && metadata.retention !== "retained-import" ? readContextEpoch(entry.details, maxSourceBytes) : void 0;
+          if ((!prior || prior.includeSummary) && page.summaryRef.entryId === checkpoint.literalTailId)
+            retained = true;
+          capturedMessages += prior?.views.length ?? 0;
+          for (const pinned of prior?.views ?? []) {
+            if (pinned.ref.entryId === checkpoint.literalTailId)
+              retained = true;
+            if (retained) {
+              suffix.set(pinned.ref.entryId, pinned.ref);
+              frozenViews.set(pinned.ref.entryId, pinned);
+            }
+          }
+        }
+        for (const ref of page.refs) {
+          if (ref.entryId === checkpoint.literalTailId)
+            retained = true;
+          if (retained)
+            suffix.set(ref.entryId, ref);
+        }
+        capturedMessages += page.refs.length;
+        if (capturedMessages > maxMessages)
+          throw new Error("Summary recovery source exceeds its message budget");
+        if (!page.nextCursor)
+          break;
+        cursor2 = page.nextCursor;
+      }
+      for (const [index, message2] of closedMessages.entries()) {
+        if (closedUnits[index].kind !== "recovery")
+          continue;
+        const reference = epochReferences.get(message2);
+        if (checkpoint.views.some((covered) => sameRecoveryReference(reference, covered))) {
+          inheritedRecoveryCoverage.push(reference);
+          continue;
+        }
+        const frozen = suffix.get(reference.ref.entryId);
+        if (!frozen || JSON.stringify(frozen) !== JSON.stringify(reference.ref))
+          continue;
+        const pinned = frozenViews.get(frozen.entryId);
+        if (pinned) {
+          if (reference.sourceRevision === pinned.sourceRevision)
+            inheritedRecoveryCoverage.push(reference);
+          continue;
+        }
+        const revisions = [frozen.revision];
+        const entry = next.get(frozen.entryId)?.entry;
+        if (entry?.type === "message" && entry.message.role === "toolResult" && entry.message.toolName === "ipython") {
+          const updates = await prefix.contextUpdates({
+            kind: "ipython-sent-message",
+            toolCallId: entry.message.toolCallId
+          });
+          revisions.push(...updates.refs.map((update) => update.revision));
+        }
+        if (reference.sourceRevision === JSON.stringify(revisions))
+          inheritedRecoveryCoverage.push(reference);
+      }
+    }
     compiledEpochContexts.set(closedMessages, {
+      ...inheritedRecoveryCoverage.length ? { inheritedRecoveryCoverage } : {},
       ...purpose === "read" ? { readOnly: true } : {},
       mode,
       source: { ...view.source },
@@ -32381,6 +32506,10 @@ var PublicContextBudgetError = class extends RequestTokenBudgetError {
     this.#summaryCapacity = summaryCapacity;
   }
 };
+var recoveryCompactionAuthorizations = /* @__PURE__ */ new WeakMap();
+function getRecoveryCompactionAuthorization(error) {
+  return error ? recoveryCompactionAuthorizations.get(error) : void 0;
+}
 function captureRequestViewBoundary(messages, commit, validate2, fixedPrepare, isSourceCurrent) {
   const source = getCanonicalViewSelectionSource(messages);
   if (!source)
@@ -32479,7 +32608,7 @@ function publicBudgetFailure(boundary, messages, request, projection, budget, as
     });
   };
   const minimum = withRequestBody(request, JSON.stringify({ ...body, [inputKey]: retainedInput(/* @__PURE__ */ new Set()) }));
-  return new PublicContextBudgetError(boundary.source, assessment, original, budget.measure(minimum), (context.taskFrame?.messages.length ?? 0) > 1, JSON.stringify([
+  const error = new PublicContextBudgetError(boundary.source, assessment, original, budget.measure(minimum), (context.taskFrame?.messages.length ?? 0) > 1, JSON.stringify([
     boundary.source.sessionId,
     boundary.source.sessionFile,
     source.units.map((unit) => [unit.id, unit.sourceRevision]),
@@ -32498,6 +32627,21 @@ function publicBudgetFailure(boundary, messages, request, projection, budget, as
     const measured = budget.measure(withRequestBody(request, JSON.stringify({ ...body, [inputKey]: kept })));
     return measured.status === "unknown" || measured.availableInputTokens === null || measured.estimatedInputTokens === null ? void 0 : Math.floor(measured.availableInputTokens - measured.estimatedInputTokens);
   }, boundary.isSourceCurrent);
+  if (projection.replayContract === "message-groups") {
+    const originalContext = getCanonicalEpochContext(boundary.messages);
+    const recoveries = boundary.units.flatMap((unit, index) => unit.kind === "recovery" && originalContext.references[index] ? [originalContext.references[index]] : []);
+    if (recoveries.length) {
+      recoveryCompactionAuthorizations.set(error, {
+        source: originalContext.source,
+        recoveries,
+        resourceRevision: originalContext.resourceRevision,
+        // Do not extend a partial public conversion to native groups the encoder did not replace.
+        publicWindow: messages !== boundary.messages && projection.publicWindow === true && boundary.units.every((unit, index) => !["recovery", "replay-group"].includes(unit.kind) || context.references[index]?.rendering !== void 0),
+        isSourceCurrent: boundary.isSourceCurrent
+      });
+    }
+  }
+  return error;
 }
 async function prepareFixedRequestView(boundary, request, projection, assessment) {
   projection = canonicalRequestProjection(boundary, projection);
@@ -32570,7 +32714,7 @@ async function selectRequestView(boundary, request, projection, budget, allowShr
   const inputKey = requestInputKey(request, projection);
   if (budget && full?.limitSource !== "explicit-profile" || !inputKey)
     return;
-  if (!budget && !boundary.requiresEpoch && !boundary.pendingPublicMessageGroups?.length)
+  if (!budget && !boundary.requiresEpoch && !boundary.recoveryContractRequested && !boundary.pendingPublicMessageGroups?.length)
     return;
   const payload = JSON.parse(request.body);
   const input = payload[inputKey];
@@ -33527,7 +33671,7 @@ var InferenceCoordinator = class _InferenceCoordinator {
       } : void 0;
       const requiredPublic = Boolean(boundary?.pendingPublicMessageGroups?.length);
       const requiredEpoch = boundary?.requiresEpoch === true;
-      const canSelect = (budget || boundary?.fixedPrepare || requiredPublic || requiredEpoch) && boundary && matchesRequestView(boundary, source, context);
+      const canSelect = (budget || boundary?.fixedPrepare || requiredPublic || requiredEpoch || boundary?.recoveryContractRequested) && boundary && matchesRequestView(boundary, source, context);
       if (requiredPublic && (!canSelect || boundary?.fixedPrepare))
         throw new Error("Tool continuation requires a selectable native public request boundary");
       const responsesMessageIds = canSelect && !boundary.fixedPrepare && (model.api === "openai-responses" || model.api === "openai-codex-responses") ? boundary.providerMessageIndices.map((index) => {
@@ -34627,7 +34771,7 @@ function captureEpochCopyEntry(entry, source) {
     ...updateTarget ? { updateTarget } : {}
   };
 }
-async function rebuildCopiedContextEpoch(history, copied, limits) {
+async function rebuildCopiedContextEpoch(history, copied, limits, metadataMaxBytes = limits.maxSourceBytes) {
   const view = history.branchContext;
   const manifest = await view.contextManifest({ limit: 1 });
   if (manifest.selection !== "known")
@@ -34656,15 +34800,26 @@ async function rebuildCopiedContextEpoch(history, copied, limits) {
     throw new Error("Tool continuation recipes require their original native execution source");
   if (!checkpoint || checkpoint.literalTailId !== entry.firstKeptEntryId || !view.atSnapshot)
     throw new Error("Copied context epoch boundary is unavailable");
-  if (copied.entries.length > limits.maxEntries || checkpoint.views.length > limits.maxEntries)
+  if (checkpoint.views.length > limits.maxEntries)
     throw new Error("Copied context epoch item budget exceeded");
-  stringifyBoundedJson(copied, limits.maxSourceBytes);
+  stringifyBoundedJson(copied, metadataMaxBytes);
   const oldByRevision = new Map([...oldById.values()].map((source) => [source.revision, source]));
   const destination = /* @__PURE__ */ new Map();
-  for (const source of oldById.values()) {
-    const actual = await history.get(source.id);
-    if (actual)
-      destination.set(source.id, actual);
+  let after = 0;
+  for (; ; ) {
+    const page = await history.page(after, 128);
+    if (page.indexedThrough < history.source.sourceSequence)
+      throw new Error("Copied context destination has incomplete index coverage");
+    for (const actual of page.events) {
+      if (!oldById.has(actual.id))
+        continue;
+      if (destination.size >= limits.maxEntries)
+        throw new Error("Copied context epoch item budget exceeded");
+      destination.set(actual.id, actual);
+    }
+    if (page.nextAfter === null)
+      break;
+    after = page.nextAfter;
   }
   const prefixViews = /* @__PURE__ */ new Map();
   const prefix = async (source) => {
@@ -36655,6 +36810,7 @@ var DEFAULT_MANAGER_HISTORY_LIMITS = {
   maxEntries: 16384,
   maxSourceBytes: 64 * 1024 * 1024
 };
+var FORK_SOURCE_METADATA_MAX_BYTES = 64 * 1024 * 1024;
 async function readOwnedSessionHeader(snapshot) {
   const handle = await openFile(snapshot.journalPath, "r");
   let capturedHeader;
@@ -37182,6 +37338,19 @@ var SessionManager = class _SessionManager {
   readSourceHistory(read2) {
     return this._runHistoryRead(this._bindHistorySource((index, source, query) => createSessionHistoryReadScope(index, source, query, "source")), read2);
   }
+  /** Read the owner-maintained own-spend projection without hydrating the source. */
+  async readOwnUsageSummary() {
+    this._assertMutable();
+    if (!this.supportsCapturedHistoryReads())
+      throw new Error("Own usage projection requires an owned native source");
+    const state = this.writeState;
+    return this._enqueue(state, 0, async () => {
+      await state.owner.flush();
+      const snapshot = state.owner.getSnapshot();
+      await this._acknowledgedHistory(state, snapshot);
+      return state.history.currentSourceUsage(snapshot);
+    });
+  }
   /** Complete bounded structured task reduction on one captured native branch. */
   async readTaskState(limits = {}) {
     const captured = taskStateReadLimits(limits);
@@ -38921,6 +39090,8 @@ var SessionManager = class _SessionManager {
   }
   async _captureForkInput(target, options) {
     const limits = { ...options.limits ?? DEFAULT_MANAGER_HISTORY_LIMITS };
+    if (!Number.isSafeInteger(limits.maxEntries) || limits.maxEntries <= 0 || !Number.isSafeInteger(limits.maxSourceBytes) || limits.maxSourceBytes <= 0)
+      throw new Error("Invalid fork source limits");
     const sourceFile = this.sessionFile;
     const header = JSON.parse(stringifyBoundedJson(this.getHeader(), limits.maxSourceBytes));
     const settings = {
@@ -39032,32 +39203,143 @@ var SessionManager = class _SessionManager {
     if (headerBytes >= limits.maxSourceBytes)
       throw new Error("Fork source byte budget exceeded");
     return this.readSourceHistory(async (history) => {
-      const materialized = await history.materialize({
-        ...limits,
-        maxSourceBytes: limits.maxSourceBytes - headerBytes
-      });
-      const entries = materialized.entries.map(({ entry, source }) => withEntryRetention(entry, source.retention, source.qualification));
-      const sourceEntries = materialized.entries.map(({ entry, source }) => captureEpochCopyEntry(entry, source));
-      const hasEpoch = sourceEntries.some((entry) => entry.kind === "compaction" && entry.qualification === "native-context-epoch");
+      const metadata = /* @__PURE__ */ new Map();
+      let metadataBytes = 0;
+      let after = 0;
+      for (; ; ) {
+        const page2 = await history.page(after, 128);
+        if (page2.indexedThrough < history.source.sourceSequence)
+          throw new Error("Captured fork history has incomplete index coverage");
+        for (const reference of page2.events) {
+          const source = {
+            id: reference.id,
+            parentId: reference.parentId,
+            kind: reference.kind,
+            sequence: reference.sequence,
+            revision: reference.revision,
+            locator: { ...reference.locator },
+            retention: reference.retention,
+            qualification: reference.qualification
+          };
+          metadataBytes += Buffer.byteLength(JSON.stringify(source)) + 1;
+          if (metadataBytes > FORK_SOURCE_METADATA_MAX_BYTES)
+            throw new Error("Fork source metadata byte budget exceeded");
+          metadata.set(source.id, source);
+        }
+        if (page2.nextAfter === null)
+          break;
+        after = page2.nextAfter;
+      }
+      const hasEpoch = [...metadata.values()].some((entry) => entry.kind === "compaction" && entry.qualification === "native-context-epoch");
+      const loaded = /* @__PURE__ */ new Map();
+      let sourceBytes = headerBytes;
+      const load = async (id) => {
+        const existing = loaded.get(id);
+        if (existing)
+          return existing;
+        const reference = metadata.get(id);
+        if (!reference)
+          throw new Error("Fork selected source is unavailable");
+        if (loaded.size >= limits.maxEntries)
+          throw new Error("Fork entry budget exceeded");
+        const remaining = limits.maxSourceBytes - sourceBytes;
+        if (reference.locator.length > remaining)
+          throw new Error("Fork source byte budget exceeded");
+        const hydrated = await history.hydrateEntry(id, remaining);
+        if (!hydrated)
+          throw new Error("Fork selected source is unavailable");
+        const entry = withEntryRetention(hydrated.entry, hydrated.source.retention, hydrated.source.qualification);
+        loaded.set(id, entry);
+        metadata.set(id, captureEpochCopyEntry(entry, hydrated.source));
+        sourceBytes += reference.locator.length;
+        return entry;
+      };
+      if ("entryId" in target && !metadata.has(target.entryId))
+        throw new Error("Invalid entry ID for forking");
+      const selected = "entryId" in target ? await load(target.entryId) : void 0;
+      if ("entryId" in target && target.position === "before" && (selected?.type !== "message" || selected.message.role !== "user"))
+        throw new Error("Invalid entry ID for forking");
+      const leafId = "entryId" in target ? target.position === "at" ? selected.id : selected.parentId : target.leafId;
+      const path6 = [];
+      let page = await history.parentPathFrom(leafId);
+      for (; ; ) {
+        if (page.totalEntries > limits.maxEntries)
+          throw new Error("Fork entry budget exceeded");
+        for (const reference of page.events)
+          path6.push(await load(reference.id));
+        if (!page.nextCursor)
+          break;
+        page = await history.parentPathFrom(leafId, { cursor: page.nextCursor });
+      }
+      const copied = path6.filter((entry) => entry.type !== "label");
+      const ids = new Set(copied.map((entry) => entry.id));
+      if (hasEpoch) {
+        for (const entry of copied) {
+          if (entry.type !== "message")
+            continue;
+          if (entry.execution && "invocationId" in entry.execution)
+            ids.add(entry.execution.invocationId);
+          const updateTarget = entry.message.role === "assistant" ? { kind: "assistant-usage", targetId: entry.id } : entry.message.role === "toolResult" ? { kind: "ipython-sent-message", toolCallId: entry.message.toolCallId } : void 0;
+          if (!updateTarget)
+            continue;
+          let after2 = 0;
+          for (; ; ) {
+            const updates = await history.sourceContextUpdates(updateTarget, after2);
+            if (updates.indexedThrough < history.source.sourceSequence)
+              throw new Error("Captured fork updates have incomplete index coverage");
+            for (const reference of updates.events)
+              ids.add(reference.id);
+            if (updates.nextAfter === null)
+              break;
+            after2 = updates.nextAfter;
+          }
+        }
+        for (const id of ids) {
+          const reference = metadata.get(id);
+          if (!reference)
+            throw new Error("Fork related source is unavailable");
+          if (reference.parentId !== null)
+            ids.add(reference.parentId);
+        }
+        for (const id of ids)
+          await load(id);
+      } else {
+        for (const entry of copied) {
+          if (entry.type !== "message" || entry.message.role !== "assistant")
+            continue;
+          const latest = await history.sourceAssistantUsage(entry.id);
+          if (latest)
+            await load(latest.id);
+        }
+      }
+      for (const id of ids) {
+        const label = await history.sourceLabel(id);
+        if (label)
+          await load(label.id);
+      }
+      const entries = [...loaded.values()].sort((left, right) => metadata.get(left.id).sequence - metadata.get(right.id).sequence);
       if (!hasEpoch)
         applyChildUsageAttributions(entries);
-      return finish(entries, history, hasEpoch ? {
+      const epochCopy = hasEpoch ? {
         sessionId: history.source.sessionId,
         sessionFile: history.source.sessionFile,
         through: history.source.sourceSequence,
-        entries: sourceEntries,
+        entries: [...metadata.values()],
         retained: false
-      } : void 0);
+      } : void 0;
+      if (epochCopy)
+        stringifyBoundedJson(epochCopy, FORK_SOURCE_METADATA_MAX_BYTES);
+      return finish(entries, history, epochCopy);
     });
   }
-  async _rebuildCopiedEpoch(copied, limits) {
+  async _rebuildCopiedEpoch(copied, limits, metadataMaxBytes = limits.maxSourceBytes) {
     if (!copied.entries.some((entry) => entry.kind === "compaction" && entry.qualification === "native-context-epoch"))
       return;
     if (!this.supportsCapturedHistoryReads())
       throw new Error("Copied context epochs require an owned persistent source");
     const sink = this.bindCompactionSink(limits);
     await this._runHistoryRead({ ...sink, readHistory: (read2) => sink[readCopiedEpochSource](read2) }, async (history) => {
-      const rebuilt = await rebuildCopiedContextEpoch(history, copied, limits);
+      const rebuilt = await rebuildCopiedContextEpoch(history, copied, limits, metadataMaxBytes);
       if (rebuilt)
         await sink[appendContextEpoch](rebuilt.checkpoint, rebuilt.tokensBefore, rebuilt.summary);
     });
@@ -39094,7 +39376,7 @@ var SessionManager = class _SessionManager {
     if (input.epochCopy) {
       try {
         await next.branchTo(input.leafId ?? null);
-        await next._rebuildCopiedEpoch(input.epochCopy, input.limits);
+        await next._rebuildCopiedEpoch(input.epochCopy, input.limits, FORK_SOURCE_METADATA_MAX_BYTES);
       } catch (error) {
         try {
           await next.close();
@@ -39487,13 +39769,6 @@ function parseBoundedSessionEntries(text2, maxEntries) {
   }
   return parseSessionEntries(text2);
 }
-async function readSessionHistoryFile(inputPath, limits) {
-  limits = { ...limits };
-  const captured = await readSessionHistoryImage(inputPath, limits.maxSourceBytes);
-  const complete = captured.subarray(0, captured.lastIndexOf(10) + 1);
-  const text2 = new TextDecoder3("utf-8", { fatal: true, ignoreBOM: true }).decode(complete);
-  return parseBoundedSessionEntries(text2, limits.maxEntries);
-}
 async function readExportHistory(inputPath, limits) {
   limits = { ...limits };
   const captured = await readSessionHistoryImage(inputPath, limits.maxSourceBytes);
@@ -42919,16 +43194,43 @@ function readResidentContextTreeUsage(manager, limits = { maxEntries: 16384, max
     ...availabilityMaxSourceBytes === void 0 ? {} : { hasPostCompactionUsage: hasPostCompactionUsage(branch) }
   };
 }
+function isContextTreeUsageReference(reference) {
+  return reference.kind === "message" && reference.authority === "assistant" || reference.kind === "compaction" || reference.kind === "branch_summary" || reference.kind === "child_usage_attributed";
+}
 async function readContextTreeUsage(manager, limits = { maxEntries: 16384, maxSourceBytes: 64 * 1024 * 1024 }, request, availabilityMaxSourceBytes) {
   if (!manager.supportsCapturedHistoryReads())
     return void 0;
   const sourceLimits = request?.limits ?? limits;
   const capturedLimits = { maxEntries: sourceLimits.maxEntries, maxSourceBytes: sourceLimits.maxSourceBytes };
+  if (!Object.values(capturedLimits).every((value) => Number.isSafeInteger(value) && value > 0))
+    throw new Error("Invalid history materialization limits");
   return manager.readSourceHistory((history) => {
     request?.retainMetadata(history.source);
     const reduce = async () => {
-      const materialized = await history.materialize(capturedLimits);
-      const allEntries = materialized.entries.map(({ entry }) => entry);
+      const allEntries = [];
+      let sourceBytes = 0;
+      let after = 0;
+      for (; ; ) {
+        const page = await history.page(after);
+        if (page.indexedThrough < history.source.sourceSequence)
+          throw new Error("Captured history has incomplete index coverage");
+        for (const reference of page.events) {
+          if (!isContextTreeUsageReference(reference))
+            continue;
+          if (allEntries.length >= capturedLimits.maxEntries)
+            throw new Error("History entry budget exceeded");
+          if (sourceBytes + reference.locator.length > capturedLimits.maxSourceBytes)
+            throw new Error("History source byte budget exceeded");
+          const hydrated = await history.hydrateEntry(reference.id, capturedLimits.maxSourceBytes - sourceBytes);
+          if (!hydrated)
+            throw new Error("Context-tree usage entry source is unavailable");
+          allEntries.push(hydrated.entry);
+          sourceBytes += reference.locator.length;
+        }
+        if (page.nextAfter === null)
+          break;
+        after = page.nextAfter;
+      }
       applyChildUsageAttributions(allEntries);
       const byId = new Map(allEntries.map((entry) => [entry.id, entry]));
       const branch = [];
@@ -42936,6 +43238,8 @@ async function readContextTreeUsage(manager, limits = { maxEntries: 16384, maxSo
       do {
         const page = await history.parentPath({ cursor });
         for (const reference of page.events) {
+          if (!isContextTreeUsageReference(reference))
+            continue;
           const entry = byId.get(reference.id);
           if (!entry)
             throw new Error("Context-tree parent-path entry source is unavailable");
@@ -42998,7 +43302,7 @@ function computeContextUsageFromEntries(allEntries, branch, contextWindow) {
   if (!hasPostCompactionUsage(branch)) {
     return { tokens: null, contextWindow, percent: null };
   }
-  const estimate = estimateContextTokens(buildSessionContext(allEntries).messages);
+  const estimate = estimateContextTokens(buildSessionContext(allEntries, branch.at(-1)?.id ?? null).messages);
   if (estimate.tokens <= 0) {
     return void 0;
   }
@@ -43125,10 +43429,64 @@ function listChildSessionDirs(rlmSessionDir, request) {
   });
   return { paths, bytes };
 }
+async function readContextTreeProjectionFromDisk(sessionFile, request) {
+  const entries = [];
+  const hiddenParents = /* @__PURE__ */ new Map();
+  let leafId = null;
+  let hasHeader = false;
+  let sourceBytes = 0;
+  let metadataBytes = 0;
+  try {
+    await readCapturedSessionJournal(sessionFile, (record2) => {
+      const value = record2.entry;
+      if (!value || typeof value !== "object" || !("type" in value) || typeof value.type !== "string")
+        throw new Error("Invalid session journal entry");
+      const entry = value;
+      if (!hasHeader) {
+        if (entry.type !== "session" || typeof entry.id !== "string")
+          throw new Error("Session source has no valid header");
+        hasHeader = true;
+      }
+      if (entry.type !== "session")
+        leafId = entry.id;
+      if (entry.type === "request" || entry.type === "tool_intent") {
+        metadataBytes += request.retainMetadata([entry.id, entry.parentId]);
+        hiddenParents.set(entry.id, entry.parentId);
+        return;
+      }
+      const bytes = record2.source?.locator.length ?? Buffer.byteLength(record2.json) + 1;
+      if (sourceBytes + bytes > request.limits.maxSourceBytes)
+        throw new ContextTreeLimitError("Context tree source byte budget exceeded");
+      sourceBytes += bytes;
+      if (entry.type === "session")
+        return;
+      if (entries.length >= request.limits.maxEntries)
+        throw new ContextTreeLimitError("Context tree entry budget exceeded");
+      entries.push(entry);
+    });
+    const visibleParent = (id) => {
+      let remaining = hiddenParents.size;
+      while (id !== null && hiddenParents.has(id)) {
+        if (remaining-- === 0)
+          throw new Error("Parent path lineage is unresolved");
+        id = hiddenParents.get(id);
+      }
+      return id;
+    };
+    for (const entry of entries)
+      entry.parentId = visibleParent(entry.parentId);
+    const hasSourceLeaf = leafId !== null;
+    leafId = visibleParent(leafId);
+    applyChildUsageAttributions(entries);
+    return { entries, leafId, hasSourceLeaf };
+  } finally {
+    request.releaseMetadata(metadataBytes);
+  }
+}
 async function readContextTreeChildNodeFromDisk(childSessionDir, sessionFile, resolveContextWindow, request, identity) {
-  const allEntries = (await readSessionHistoryFile(sessionFile, request.limits)).filter((entry) => entry.type !== "session");
-  const branch = branchEntries(allEntries);
-  if (branch.length === 0) {
+  const { entries: allEntries, leafId, hasSourceLeaf } = await readContextTreeProjectionFromDisk(sessionFile, request);
+  const branch = branchEntries(allEntries, leafId);
+  if (branch.length === 0 && !hasSourceLeaf) {
     return void 0;
   }
   const { ownUsage, totalUsage } = computeOwnAndTotalUsage(branch, allEntries);
@@ -45559,7 +45917,7 @@ async function loadExtensionModule(extensionPath) {
     // (file-path aliases would load a second, divergent copy of each package).
     // Also disable tryNative so jiti handles ALL imports (not just the entry point)
     // Node/dev must also share the native AI registry and implementation identities.
-    ...isBunBinary || isBundledCli ? { virtualModules: (await import("./bundled-modules-MX6YNAM2.js")).VIRTUAL_MODULES, tryNative: false } : {
+    ...isBunBinary || isBundledCli ? { virtualModules: (await import("./bundled-modules-PEFT72QN.js")).VIRTUAL_MODULES, tryNative: false } : {
       alias: getAliases(),
       virtualModules: {
         "@ponythewhite/base-context-ai": src_exports,
@@ -48316,6 +48674,9 @@ var DEFAULT_FORK_MESSAGE_LIMITS = Object.freeze({
 async function readUserMessagesForForking(manager, limits = DEFAULT_FORK_MESSAGE_LIMITS) {
   const capturedLimits = { ...limits };
   const entries = manager.supportsCapturedHistoryReads() ? (await manager.materializeSourceHistory(capturedLimits)).entries.map(({ entry }) => entry) : manager.materializeResidentHistory(capturedLimits).entries;
+  return projectUserMessages(entries);
+}
+function projectUserMessages(entries) {
   const result = [];
   for (const entry of entries) {
     if (entry.type !== "message" || entry.message.role !== "user")
@@ -48332,6 +48693,40 @@ async function readUserMessagesForForking(manager, limits = DEFAULT_FORK_MESSAGE
   }
   return result;
 }
+async function readVisibleUserMessagesForForking(manager, limits = DEFAULT_FORK_MESSAGE_LIMITS) {
+  const { maxEntries, maxSourceBytes } = limits;
+  if (!Number.isSafeInteger(maxEntries) || maxEntries <= 0 || !Number.isSafeInteger(maxSourceBytes) || maxSourceBytes <= 0)
+    throw new Error("Invalid history materialization limits");
+  if (!manager.supportsCapturedHistoryReads())
+    return readUserMessagesForForking(manager, { maxEntries, maxSourceBytes });
+  return manager.readSourceHistory(async (history) => {
+    const entries = [];
+    let sourceBytes = 0;
+    let after = 0;
+    for (; ; ) {
+      const page = await history.page(after);
+      if (page.indexedThrough < history.source.sourceSequence)
+        throw new Error("Captured history has incomplete index coverage");
+      for (const reference of page.events) {
+        if (reference.kind !== "message" || reference.authority === "assistant" || reference.authority === "runtime")
+          continue;
+        if (entries.length >= maxEntries)
+          throw new Error("History entry budget exceeded");
+        if (sourceBytes + reference.locator.length > maxSourceBytes)
+          throw new Error("History source byte budget exceeded");
+        const hydrated = await history.hydrateEntry(reference.id, maxSourceBytes - sourceBytes);
+        if (!hydrated)
+          throw new Error("Fork message source is unavailable");
+        sourceBytes += reference.locator.length;
+        entries.push(hydrated.entry);
+      }
+      if (page.nextAfter === null)
+        break;
+      after = page.nextAfter;
+    }
+    return projectUserMessages(entries);
+  });
+}
 
 // dist/core/session-jsonl-export.js
 import { mkdir as mkdir3, open as open4, unlink } from "node:fs/promises";
@@ -59019,7 +59414,7 @@ var AgentSession = class _AgentSession {
         const epochContext = getCanonicalEpochContext(messages);
         if (epochContext)
           this._contextMode = epochContext.mode;
-        const unbudgetedPublic = !contextEpochsEnabled && Boolean(epochContext?.toolContinuations?.length || epochContext?.taskFrameRebased || epochContext?.checkpoint);
+        const unbudgetedPublic = !contextEpochsEnabled && Boolean(epochContext?.toolContinuations?.length || epochContext?.taskFrameRebased || epochContext?.checkpoint || getCanonicalViewSelectionSource(messages)?.recoveryContractRequested);
         const nativeSkills = Boolean(contextEpochsEnabled || epochContext?.checkpoint || unbudgetedPublic);
         const skillPolicy = nativeSkills ? this._nativeRecoveryEnabled() ? "enabled" : "unavailable" : void 0;
         if (this._baseSystemPromptOptions.nativeSkillSelection !== skillPolicy) {
@@ -59055,7 +59450,19 @@ var AgentSession = class _AgentSession {
             if (epochContext.toolContinuations?.length && (!candidate.publicMessages || JSON.stringify(getCanonicalEpochContext(candidate.publicMessages)?.toolContinuations) !== JSON.stringify(epochContext.toolContinuations) || candidate.projection.pendingPublicMessageGroups?.length))
               throw new Error("Tool continuation requires its exact public candidate before epoch ACK");
             assertResourceCurrent(resource);
-            const representation = contextEpochRepresentation(candidate.request, candidate.assessment, limits.maxSourceBytes, unbudgetedPublic, candidate.responseItemIdentity);
+            let representation;
+            try {
+              representation = contextEpochRepresentation(candidate.request, candidate.assessment, limits.maxSourceBytes, unbudgetedPublic, candidate.responseItemIdentity);
+            } catch (error) {
+              if (error instanceof UnsupportedContextEpochConfigurationError && !contextEpochsEnabled && !candidate.assessment && !committed && !acknowledged && !epochContext.taskFrameRebased && !epochContext.selectedSkills?.length && !epochContext.toolContinuations?.length && !candidate.publicMessages) {
+                const source = getCanonicalViewSelectionSource(messages);
+                const selected = new Set(candidate.selectedUnitIds);
+                if (source.recoveryContractRequested && !source.requiresEpoch && !source.pendingPublicMessageGroups?.length && this.sessionManager === epochManager && compaction.isCurrent() && JSON.stringify(candidate.source) === JSON.stringify(source.source) && candidate.selectedUnitIds.length === source.units.length && selected.size === source.units.length && source.units.every((unit) => selected.has(unit.id))) {
+                  return;
+                }
+              }
+              throw error;
+            }
             const replayContract = "replayContract" in candidate.projection && candidate.projection.replayContract === "message-groups" ? "message-groups" : "complete-context";
             const publicWindow = "publicWindow" in candidate.projection && candidate.projection.publicWindow === true;
             const selection = JSON.stringify([
@@ -62704,7 +63111,7 @@ var AgentSession = class _AgentSession {
   async _runPreTurnCompaction() {
     const lastAssistant = this._findLastAssistantMessage();
     if (lastAssistant)
-      await this._checkCompaction(lastAssistant, false, false);
+      await this._checkCompaction(lastAssistant, false, false, void 0, true);
   }
   async _prepareForCommit(policy, steps) {
     if (policy.initialRefineBarrier === "always" || policy.initialRefineBarrier === "ifInFlight" && this._refineInFlight) {
@@ -65384,7 +65791,7 @@ ${parsed.args}` : block;
     }
   }
   /** A private compiled context keeps extension summary edits separate from retained source recipes. */
-  async _prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false) {
+  async _prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, capacity) {
     this._assertCompactionOwner(owner);
     const limits = this.settingsManager.getCanonicalContextLimits();
     const resource = this._captureKernelResource();
@@ -65401,10 +65808,11 @@ ${parsed.args}` : block;
       const context = getCanonicalEpochContext(messages);
       if (context.checkpoint?.includeSummary && pathEntries.at(-1)?.type === "compaction")
         return { preparation: void 0, maxSourceBytes: limits.maxSourceBytes };
-      const boundary = canonicalRecoveryBoundary(messages);
+      const authorization = getRecoveryCompactionAuthorization(capacity);
+      const boundary = canonicalRecoveryBoundary(messages, authorization);
       const preparation = budgetPressure || context.checkpoint || boundary ? prepareViewCompaction(messages, context.references.map((ref) => ref?.ref.entryId), pathEntries, settings, boundary, allowShortSession, budgetPressure) : prepareCompaction(pathEntries, settings, allowShortSession);
       if (preparation)
-        prepareRecoveryCompaction(messages, preparation.firstKeptEntryId, limits.maxSourceBytes);
+        prepareRecoveryCompaction(messages, preparation.firstKeptEntryId, limits.maxSourceBytes, authorization);
       return {
         preparation,
         messages,
@@ -65420,7 +65828,7 @@ ${parsed.args}` : block;
    */
   async _performCompaction(options) {
     const { model, apiKey, headers, customInstructions, signal, thinkingLevel, requests, compaction, semanticEdges, pathEntries, settings, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false } = options;
-    const prepared = await this._prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner, allowShortSession, budgetPressure);
+    const prepared = await this._prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner, allowShortSession, budgetPressure, options.capacity);
     this._assertCompactionOwner(owner);
     if (prepared.resource)
       assertResourceCurrent(prepared.resource);
@@ -65501,7 +65909,7 @@ ${parsed.args}` : block;
       }
       this._assertCompactionOwner(owner);
       const result = JSON.parse(JSON.stringify({ summary, firstKeptEntryId, tokensBefore, details }));
-      const recovery = prepared.messages ? prepareRecoveryCompaction(prepared.messages, firstKeptEntryId, prepared.maxSourceBytes) : void 0;
+      const recovery = prepared.messages ? prepareRecoveryCompaction(prepared.messages, firstKeptEntryId, prepared.maxSourceBytes, getRecoveryCompactionAuthorization(options.capacity)) : void 0;
       if (prepared.resource)
         assertResourceCurrent(prepared.resource);
       if (recovery) {
@@ -66124,7 +66532,30 @@ ${parsed.args}` : block;
     const sessionHistory = (async () => {
       if (residentEntries !== void 0)
         return residentEntries;
-      return (await this.sessionManager.materializeSourceHistory(limits)).entries.map(({ entry }) => entry);
+      return this.sessionManager.readSourceHistory(async (history) => {
+        const entries = [];
+        let sourceBytes = 0;
+        let after = 0;
+        for (; ; ) {
+          const page = await history.page(after, 128);
+          if (page.indexedThrough < history.source.sourceSequence)
+            throw new Error("Captured refinement history has incomplete index coverage");
+          for (const reference of page.events) {
+            if (reference.kind !== "custom")
+              continue;
+            if (entries.length >= limits.maxEntries)
+              throw new Error("Refinement history entry budget exceeded");
+            if (sourceBytes + reference.locator.length > limits.maxSourceBytes)
+              throw new Error("Refinement history source byte budget exceeded");
+            const hydrated = await hydrateCapturedHistoryEntry(reference, limits.maxSourceBytes - sourceBytes, history.readPayload);
+            entries.push(hydrated.entry);
+            sourceBytes += reference.locator.length;
+          }
+          if (page.nextAfter === null)
+            return entries;
+          after = page.nextAfter;
+        }
+      });
     })();
     const [globalResult, sessionResult] = await Promise.allSettled([globalHistory, sessionHistory]);
     if (globalResult.status === "rejected") {
@@ -66445,7 +66876,7 @@ ${parsed.args}` : block;
       return void 0;
     return calculateContextTokens(assistantMessage.usage);
   }
-  async _checkCompaction(assistantMessage, skipAbortedCheck = true, queueAutonomousContinuation = true, invocationOwner) {
+  async _checkCompaction(assistantMessage, skipAbortedCheck = true, queueAutonomousContinuation = true, invocationOwner, beforeNextTurn = false) {
     if (this._compactionSetupFailure)
       return false;
     if (invocationOwner && !this._isCompactionSourceOwnerCurrent(invocationOwner))
@@ -66518,7 +66949,7 @@ ${parsed.args}` : block;
       if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
         this._removeLastAssistantFromContext();
       }
-      return await this._runAutoCompaction("overflow", true, owner);
+      return await this._runAutoCompaction("overflow", true, owner, false, void 0, beforeNextTurn);
     }
     if (this._pendingRequestedCompaction !== void 0) {
       return await this._runAutoCompaction("requested", false, owner);
@@ -66540,7 +66971,7 @@ ${parsed.args}` : block;
       }
       if (!this._isCompactionOwnerCurrent(owner) || !this._contextOptimizationAllowed())
         return false;
-      return await this._runAutoCompaction("threshold", false, owner);
+      return await this._runAutoCompaction("threshold", false, owner, false, void 0, beforeNextTurn);
     }
     return false;
   }
@@ -66586,7 +67017,7 @@ This compaction outcome could not be saved to session history: ${persistenceErro
     this._emit({ type: "message_start", message: outcomeMessage });
     this._emit({ type: "message_end", message: outcomeMessage });
   }
-  async _runAutoCompaction(reason, willRetry, capturedOwner, resumeInPlace = false, capacity) {
+  async _runAutoCompaction(reason, willRetry, capturedOwner, resumeInPlace = false, capacity, beforeNextTurn = false) {
     const checkpoint = this._pendingCheckpoint;
     const pending = this._pendingRequestedCompaction;
     const owner = checkpoint?.owner ?? pending?.owner ?? capturedOwner ?? this._captureCompactionOwner();
@@ -66699,6 +67130,12 @@ This compaction outcome could not be saved to session history: ${persistenceErro
       if (!this._isCompactionSourceOwnerCurrent(owner))
         throw failure2;
       this._clearQueuedAutonomousContinuationsAfterSkippedThresholdCompaction(reason === "threshold" && shouldContinueAfterCompaction, queuedAutonomousContinuationsForThisCompaction);
+      if (beforeNextTurn && error instanceof MissingRecoveryReplayContractError) {
+        if (reason === "overflow")
+          this._overflowRecovery = "idle";
+        await this._endCompactionUnsuccessfully(reason, "skipped", "Compaction deferred until the next native request establishes recovery replay coverage.", { errorSeverity: "warning", customInstructions, owner });
+        return false;
+      }
       const errorMessage4 = error instanceof Error ? error.message : "compaction failed";
       const aborted = errorMessage4 === "Compaction cancelled" || error instanceof Error && error.name === "AbortError" || abort.signal.aborted;
       if (aborted) {
@@ -69462,34 +69899,13 @@ ${command}` : command;
   _contextWindowResolver() {
     return (provider, modelId) => this._modelRegistry.find(provider, modelId)?.contextWindow;
   }
-  _ownUsageMemo;
   // Whole-source own spend, identical to the catalog reduction at passivation.
   async getOwnUsageSummary() {
     if (!this.sessionManager.supportsCapturedHistoryReads()) {
-      const entries = await this.sessionManager.readEntries();
+      const entries = this.sessionManager.getEntries();
       return sessionUsageSummaryFrom(computeOwnAndTotalUsage(entries, entries).ownUsage);
     }
-    const limits = { maxEntries: 16384, maxSourceBytes: 64 * 1024 * 1024 };
-    return this.sessionManager.readSourceHistory(async (history) => {
-      const { sessionId, sessionFile, sourceSequence } = history.source;
-      const memo = this._ownUsageMemo;
-      if (memo && memo.sessionId === sessionId && memo.sessionFile === sessionFile && memo.sourceSequence === sourceSequence && memo.count <= limits.maxEntries && memo.sourceBytes <= limits.maxSourceBytes) {
-        return memo.usage ? { ...memo.usage } : void 0;
-      }
-      const materialized = await history.materialize(limits);
-      const entries = materialized.entries.map(({ entry }) => entry);
-      applyChildUsageAttributions(entries);
-      const usage = sessionUsageSummaryFrom(computeOwnAndTotalUsage(entries, entries).ownUsage);
-      this._ownUsageMemo = {
-        sessionId,
-        sessionFile,
-        sourceSequence,
-        count: entries.length,
-        sourceBytes: materialized.sourceBytes,
-        usage
-      };
-      return usage ? { ...usage } : void 0;
-    });
+    return this.sessionManager.readOwnUsageSummary();
   }
   /**
    * Build the agent context overview for /context: this session as the root
@@ -70090,7 +70506,7 @@ import { resolve as resolve15 } from "node:path";
 var BASE_CONTEXT_BUILD_ID_ENV = "BASE_CONTEXT_BUILD_ID";
 var BASE_CONTEXT_LAUNCHER_PATH_ENV = "BASE_CONTEXT_LAUNCHER_PATH";
 function bundledBuildId() {
-  return false ? void 0 : "v1.0.9-1-ge86dce7cb";
+  return false ? void 0 : "v1.0.10-1-g67d926ccc";
 }
 function getDaemonRuntimeIdentity(environment = process.env) {
   const entrypoint = process.argv[1];
@@ -70917,7 +71333,7 @@ export {
   passivatedWorkerRosterEntry,
   sessionSummaryFromRosterEntry,
   AgentRoster,
-  readUserMessagesForForking,
+  readVisibleUserMessagesForForking,
   SERPER_CREDENTIAL_ID,
   SERPER_CREDENTIAL_NAME,
   PromptAdmissionCancelledError,