@ponythewhite/base-context 1.0.10 → 1.0.12

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

@@ -32,7 +32,7 @@ import {
   typebox_exports,
   validateToolArguments,
   waitForChildProcess
-} from "./chunk-2IPDSTDR.js";
+} from "./chunk-AEMRBMI2.js";
 import {
   cleanupSessionResources,
   registerSessionResourceCleanup
@@ -67,7 +67,7 @@ import {
   requestTokenRouteIdentity,
   supportsFastMode,
   withRequestBody
-} from "./chunk-D3KOF57W.js";
+} from "./chunk-25VYRAC6.js";
 import {
   __commonJS,
   __export,
@@ -10887,8 +10887,8 @@ var DAEMON_PROTOCOL_NAME = PRODUCT.daemonService;
 var DAEMON_PROTOCOL_VERSION = 13;
 var DAEMON_LEGACY_INSPECTION_PROTOCOL_VERSIONS = [8, 9, 10];
 var DAEMON_COMMAND_ENVELOPE_MIN_PROTOCOL_VERSION = 8;
-var DAEMON_SCHEMA_REVISION = 49;
-var DAEMON_SCHEMA_ID = "protocol-13-schema-49-subagent-capacity";
+var DAEMON_SCHEMA_REVISION = 50;
+var DAEMON_SCHEMA_ID = "protocol-13-schema-50-context-request-usage";
 var DAEMON_PROTOCOL_INFO = {
   name: DAEMON_PROTOCOL_NAME,
   version: DAEMON_PROTOCOL_VERSION
@@ -10913,6 +10913,7 @@ var DAEMON_DEFAULT_SERVER_CAPABILITIES = [
   "cron_resume",
   "agent_results",
   "model_catalog",
+  "context_request_usage",
   "side_question_transcript",
   "transient_bash",
   "session_input_admission",
@@ -27790,6 +27791,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 +27834,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;
@@ -28079,6 +28086,7 @@ var SESSION_SLASH_COMMAND_CUSTOM_TYPE = "session_slash_command";
 var SESSION_SLASH_COMMAND_RESULT_CUSTOM_TYPE = "session_slash_command_result";
 var COMPACTION_OUTCOME_CUSTOM_TYPE = "compaction_outcome";
 var REFINEMENT_OUTCOME_CUSTOM_TYPE = "refinement_outcome";
+var HARNESS_SNAPSHOT_CUSTOM_TYPE = "harness_snapshot";
 var RLM_CHILD_FAILURE_CUSTOM_TYPE = "rlm_child_failure";
 var RLM_CHILD_TERMINAL_NOTICE_CUSTOM_TYPE = "rlm_child_terminal_notice";
 function createRlmChildFailureMessage(details, timestamp = Date.now()) {
@@ -29066,6 +29074,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 +29097,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 +29430,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 +29524,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 +31609,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 +31631,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)
@@ -31676,7 +31730,7 @@ var CanonicalContextCompiler = class {
   hasActiveEntry(entryId) {
     return this.entries.has(entryId);
   }
-  async compile(view, limits, omittedAssistantIds = /* @__PURE__ */ new Set(), frameOptions = {}, resourceCapture, initialContextMode = "on", allowPendingToolPublic = false, purpose = "request") {
+  async compile(view, limits, omittedAssistantIds = /* @__PURE__ */ new Set(), frameOptions = {}, resourceCapture, initialContextMode = "on", allowPendingToolPublic = false, purpose2 = "request") {
     const generation = this.generation;
     const frameLimits = taskFrameLimits(frameOptions);
     const previousSource = this.source;
@@ -31814,7 +31868,7 @@ var CanonicalContextCompiler = class {
     const referenceFrame = resetFrame ? checkpoint?.taskFrame : previousFrame;
     if (resetFrame || referenceFrame && referenceFrame.messages.length <= 1)
       this.forceTaskFrameRebase = false;
-    const forceRebase = purpose === "request" && this.forceTaskFrameRebase;
+    const forceRebase = purpose2 === "request" && this.forceTaskFrameRebase;
     let taskFrame = tasks ? compileTaskFrame(tasks, frameLimits, forceRebase ? void 0 : referenceFrame) : void 0;
     const taskFrameRebased = Boolean(mode === "on" && referenceFrame && taskFrame !== referenceFrame && (!taskFrame || taskFrame.messages.length === 1));
     const resource = mode === "on" && resourceCapture && (resourceCapture.enabled || checkpoint) ? renderResourceView(resourceCapture) : void 0;
@@ -32146,7 +32200,7 @@ ${JSON.stringify(selections.map((skill) => ({
     });
     if (frozenGroups.length !== candidates.filter((candidate) => candidate.prior).length)
       throw new Error("Committed tool continuation lost its original group");
-    if (purpose === "request" && candidates.length && (!allowPendingToolPublic || mode === "off"))
+    if (purpose2 === "request" && candidates.length && (!allowPendingToolPublic || mode === "off"))
       throw new Error("Tool continuation requires an enabled native public request boundary");
     const readToolEvidence = async (metadata) => {
       const cached = next.get(metadata.id);
@@ -32324,11 +32378,84 @@ ${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, {
-      ...purpose === "read" ? { readOnly: true } : {},
+      ...inheritedRecoveryCoverage.length ? { inheritedRecoveryCoverage } : {},
+      ...purpose2 === "read" ? { readOnly: true } : {},
       mode,
       source: { ...view.source },
       checkpoint,
@@ -32348,7 +32475,7 @@ ${JSON.stringify(selections.map((skill) => ({
     this.source = view.source;
     this.sourceBytes = sourceBytes;
     this.messageCount = messageCount;
-    return purpose === "read" && pendingPublicMessageGroups.length ? renderToolContinuationWindow(closedMessages).messages : closedMessages;
+    return purpose2 === "read" && pendingPublicMessageGroups.length ? renderToolContinuationWindow(closedMessages).messages : closedMessages;
   }
 };
 
@@ -32381,6 +32508,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 +32610,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 +32629,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 +32716,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];
@@ -32999,6 +33145,9 @@ function wrapStreamFnWithSemanticEdges(streamFn, recorder) {
 }
 
 // dist/core/inference-coordinator.js
+function isPrimaryRequest(purpose2) {
+  return purpose2 === "main" || purpose2 === "child";
+}
 var REQUEST_STREAM_BINDING = /* @__PURE__ */ Symbol("base-context.request-stream-binding");
 var captureNativeCompactionRequests = /* @__PURE__ */ Symbol("base-context.native-compaction-requests");
 var captureNativeBranchRequests = /* @__PURE__ */ Symbol("base-context.native-branch-requests");
@@ -33230,7 +33379,7 @@ var InferenceCoordinator = class _InferenceCoordinator {
     this.notifyActivity();
     return captured;
   }
-  /** Explicit Root-owned epoch boundary, on this same captured MAIN source only. */
+  /** Explicit session-owned epoch boundary, on this same captured primary source only. */
   bindRequestViewBoundary(messages, commit, validate2, fixedPrepare, isSourceCurrent) {
     this.assertAdmission();
     if (!this.capturedSink)
@@ -33448,7 +33597,7 @@ var InferenceCoordinator = class _InferenceCoordinator {
       activeUser = true;
       this.releaseCapture();
       this.finishCapturePending?.();
-      if (this.work.budget || this.requestViewBoundary && operation.metadata.purpose === "main") {
+      if (this.work.budget || this.requestViewBoundary && isPrimaryRequest(operation.metadata.purpose)) {
         model = structuredClone(model);
         context = structuredClone({
           ...context,
@@ -33481,7 +33630,7 @@ var InferenceCoordinator = class _InferenceCoordinator {
       if (!this.work.admissionOpen)
         throw new Error("Inference owner is closing");
       const parentBudget = this.work.budget;
-      const boundary = operation.metadata.purpose === "main" ? this.requestViewBoundary : void 0;
+      const boundary = isPrimaryRequest(operation.metadata.purpose) ? this.requestViewBoundary : void 0;
       const budget = boundary ? parentBudget?.capture() : parentBudget;
       let measuredForAdmission = false;
       let countingInput = false;
@@ -33527,7 +33676,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) => {
@@ -33663,7 +33812,14 @@ var InferenceCoordinator = class _InferenceCoordinator {
         }
       };
       const signal = options?.signal ? AbortSignal.any([options.signal, this.work.cancellation.signal]) : this.work.cancellation.signal;
-      const events = await send(model, context, { ...options, signal, attempts, requireProviderAttempts: true });
+      const sessionId = options?.sessionId ?? (isPrimaryRequest(operation.metadata.purpose) ? source.sessionId : `${operation.metadata.purpose}:${source.sessionId}`);
+      const events = await send(model, context, {
+        ...options,
+        sessionId,
+        signal,
+        attempts,
+        requireProviderAttempts: true
+      });
       localSimulation = isLocalFauxStream(events);
       const settled = settle(events.result());
       events.result = async () => (await settled).message;
@@ -33782,7 +33938,7 @@ var InferenceCoordinator = class _InferenceCoordinator {
       if (captured || previous?.metadata.operationId !== operationId) {
         previous = executor.bindOperation(model, { ...request, semanticEdgeId }, operationId);
       }
-      return (await executor.execute(previous, model, context, options, inner, captured !== void 0 && request.purpose === "main")).events;
+      return (await executor.execute(previous, model, context, options, inner, captured !== void 0 && isPrimaryRequest(request.purpose))).events;
     };
     wrapped[REQUEST_STREAM_BINDING] = { coordinator: this, inner };
     return wrapped;
@@ -34034,12 +34190,31 @@ function estimateContextTokens(messages) {
     lastUsageIndex: usageInfo.index
   };
 }
-function shouldCompact(contextTokens, contextWindow, settings) {
+function shouldCompact(contextTokens, contextWindow, settings, fixedContextTokens = 0) {
   if (!settings.enabled)
     return false;
   if (contextWindow <= 0)
     return false;
-  return contextTokens > contextWindow - settings.reserveTokens;
+  const modelLimit = contextWindow - settings.reserveTokens;
+  const target = settings.targetTokens === "model-limit" ? modelLimit : Math.max(settings.targetTokens ?? Math.min(96e3, contextWindow / 2), fixedContextTokens + 4 * settings.keepRecentTokens);
+  return contextTokens > Math.min(target, modelLimit);
+}
+function estimateFixedCompactionTokens(systemPrompt, tools, messages) {
+  const toolSchemas = tools.map(({ name, description, parameters }) => ({ name, description, parameters }));
+  let tokens = Math.ceil((systemPrompt.length + (tools.length ? JSON.stringify(toolSchemas).length : 0)) / 4);
+  let hasHarnessSnapshot = false;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message2 = messages[index];
+    if (message2.role !== "custom")
+      continue;
+    if (message2.customType === TASK_FRAME_CUSTOM_TYPE)
+      tokens += estimateTokens(message2);
+    else if (message2.customType === HARNESS_SNAPSHOT_CUSTOM_TYPE && !hasHarnessSnapshot) {
+      tokens += estimateTokens(message2);
+      hasHarnessSnapshot = true;
+    }
+  }
+  return tokens;
 }
 function compactionTokenScale(messages) {
   const usageInfo = getLastAssistantUsageInfo(messages);
@@ -34627,7 +34802,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 +34831,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 +36841,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 +37369,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 +39121,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 +39234,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 +39407,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 +39800,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);
@@ -42810,6 +43116,99 @@ ${instructions}`;
 // dist/core/context-tree.js
 import { existsSync as existsSync14, opendirSync, statSync as statSync6 } from "node:fs";
 import { basename as basename6, join as join20 } from "node:path";
+
+// dist/core/request-usage.js
+function emptyRequestUsageTotals() {
+  return {
+    attempts: 0,
+    settledAttempts: 0,
+    partialUsageAttempts: 0,
+    missingUsageAttempts: 0,
+    unsettledAttempts: 0,
+    unpricedAttempts: 0,
+    input: 0,
+    inputTotal: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    processedTokens: 0,
+    catalogEstimateUsd: 0
+  };
+}
+function addRequestUsageTotals(total, usage) {
+  for (const field of Object.keys(total))
+    total[field] += usage[field];
+}
+function purpose(event) {
+  if (event.purpose === "native-control" && event.purposeDetail === "daemon-status")
+    return "status";
+  if (event.purpose === "summary" && (event.purposeDetail === "compaction" || event.purposeDetail === "compaction-turn-prefix"))
+    return "compaction";
+  return event.purpose;
+}
+function inputTotal(usage) {
+  if (usage.inputTotal !== void 0)
+    return usage.inputTotal;
+  if (usage.input !== void 0 && usage.cacheRead !== void 0 && usage.cacheWrite !== void 0)
+    return usage.input + usage.cacheRead + usage.cacheWrite;
+  if (usage.totalTokens !== void 0 && usage.output !== void 0)
+    return usage.totalTokens - usage.output;
+  return void 0;
+}
+var RequestUsageAccumulator = class {
+  sessionId;
+  attempts = /* @__PURE__ */ new Map();
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+  }
+  add(event) {
+    if (event.source.sessionId !== this.sessionId || event.purpose === "native-control" && event.purposeDetail === "input-token-count")
+      return;
+    const previous = this.attempts.get(event.attemptId);
+    if (event.type === "attempt_admitted" && previous)
+      return;
+    const totals = emptyRequestUsageTotals();
+    totals.attempts = 1;
+    if (event.type === "attempt_admitted") {
+      totals.unsettledAttempts = 1;
+    } else {
+      totals.settledAttempts = 1;
+      const { usage, usageCompleteness } = event.receipt;
+      const incompleteBuckets = [usage.input, usage.output, usage.cacheRead, usage.cacheWrite].some((value) => value === void 0);
+      totals.partialUsageAttempts = usageCompleteness === "partial" || usageCompleteness !== "none" && incompleteBuckets ? 1 : 0;
+      totals.missingUsageAttempts = usageCompleteness === "none" ? 1 : 0;
+      totals.input = usage.input ?? 0;
+      totals.inputTotal = inputTotal(usage) ?? (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+      totals.output = usage.output ?? 0;
+      totals.cacheRead = usage.cacheRead ?? 0;
+      totals.cacheWrite = usage.cacheWrite ?? 0;
+      const input = inputTotal(usage);
+      totals.processedTokens = input !== void 0 && usage.output !== void 0 ? input + usage.output : usage.totalTokens ?? totals.inputTotal + totals.output;
+      const pricing = event.modelContract.pricing;
+      const rates = pricing.status !== "unavailable" && pricing.currency === "USD" && pricing.unit === "million-tokens" ? pricing.catalogRates : void 0;
+      if (rates && usage.input !== void 0 && usage.output !== void 0 && usage.cacheRead !== void 0 && usage.cacheWrite !== void 0) {
+        totals.catalogEstimateUsd = (usage.input * rates.input + usage.output * rates.output + usage.cacheRead * rates.cacheRead + usage.cacheWrite * rates.cacheWrite) / 1e6;
+      } else {
+        totals.unpricedAttempts = 1;
+      }
+    }
+    this.attempts.set(event.attemptId, { purpose: purpose(event), totals });
+  }
+  finish() {
+    if (this.attempts.size === 0)
+      return void 0;
+    const result = { sessionId: this.sessionId, byPurpose: {}, total: emptyRequestUsageTotals() };
+    for (const attempt of this.attempts.values()) {
+      const bucket = result.byPurpose[attempt.purpose] ?? emptyRequestUsageTotals();
+      result.byPurpose[attempt.purpose] = bucket;
+      addRequestUsageTotals(bucket, attempt.totals);
+      addRequestUsageTotals(result.total, attempt.totals);
+    }
+    return result;
+  }
+};
+
+// dist/core/context-tree.js
 var ContextTreeLimitError = class extends Error {
 };
 var ContextTreeRequest = class {
@@ -42903,6 +43302,11 @@ function computeOwnAndTotalUsage(branch, allEntries) {
 }
 function readResidentContextTreeUsage(manager, limits = { maxEntries: 16384, maxSourceBytes: 64 * 1024 * 1024 }, availabilityMaxSourceBytes) {
   const snapshot = manager.materializeResidentHistory(limits);
+  const receipts = new RequestUsageAccumulator(manager.getSessionId());
+  for (const entry of snapshot.entries)
+    if (entry.type === "request")
+      receipts.add(entry.request);
+  const ownRequestUsage = receipts.finish();
   const branch = branchEntries(snapshot.entries, snapshot.leafId, availabilityMaxSourceBytes !== void 0);
   if (availabilityMaxSourceBytes !== void 0) {
     if (!Number.isSafeInteger(availabilityMaxSourceBytes) || availabilityMaxSourceBytes <= 0)
@@ -42916,19 +43320,67 @@ function readResidentContextTreeUsage(manager, limits = { maxEntries: 16384, max
   }
   return {
     ...computeOwnAndTotalUsage(branch, snapshot.entries),
+    ...ownRequestUsage ? { ownRequestUsage } : {},
     ...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 receipts = new RequestUsageAccumulator(history.source.sessionId);
+      let requestEntries = 0;
+      let requestBytes = 0;
+      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 === "request" && receipts) {
+            requestEntries++;
+            requestBytes += reference.locator.length;
+            if (requestEntries > capturedLimits.maxEntries || requestBytes > capturedLimits.maxSourceBytes) {
+              receipts = void 0;
+            } else {
+              try {
+                const hydrated2 = await history.hydrateEntry(reference.id, reference.locator.length);
+                if (hydrated2?.entry.type !== "request")
+                  receipts = void 0;
+                else
+                  receipts.add(hydrated2.entry.request);
+              } catch {
+                receipts = void 0;
+              }
+            }
+          }
+          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 +43388,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");
@@ -42962,8 +43416,10 @@ async function readContextTreeUsage(manager, limits = { maxEntries: 16384, maxSo
           available = calculateContextTokens(assistant.message.usage) > 0;
         }
       }
+      const ownRequestUsage = receipts?.finish();
       const usage = {
         ...computeOwnAndTotalUsage(branch, allEntries),
+        ...ownRequestUsage ? { ownRequestUsage } : {},
         ...available === void 0 ? {} : { hasPostCompactionUsage: available }
       };
       request?.retainMetadata(usage);
@@ -42998,7 +43454,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 +43581,77 @@ 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 receipts;
+  let requestEntries = 0;
+  let requestBytes = 0;
+  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;
+        receipts = new RequestUsageAccumulator(entry.id);
+      }
+      if (entry.type === "request" && receipts) {
+        requestEntries++;
+        requestBytes += record2.source?.locator.length ?? Buffer.byteLength(record2.json) + 1;
+        if (requestEntries > request.limits.maxEntries || requestBytes > request.limits.maxSourceBytes)
+          receipts = void 0;
+        else
+          receipts.add(entry.request);
+      }
+      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);
+    const ownRequestUsage = receipts?.finish();
+    return { entries, leafId, hasSourceLeaf, ...ownRequestUsage ? { ownRequestUsage } : {} };
+  } 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, ownRequestUsage } = await readContextTreeProjectionFromDisk(sessionFile, request);
+  const branch = branchEntries(allEntries, leafId);
+  if (branch.length === 0 && !hasSourceLeaf) {
     return void 0;
   }
   const { ownUsage, totalUsage } = computeOwnAndTotalUsage(branch, allEntries);
@@ -43157,9 +43680,10 @@ async function readContextTreeChildNodeFromDisk(childSessionDir, sessionFile, re
     model,
     ownUsage,
     totalUsage,
+    ...ownRequestUsage ? { ownRequestUsage } : {},
     contextUsage: computeContextUsageFromEntries(allEntries, branch, contextWindow)
   };
-  request.retainMetadata(identity ? { model, ownUsage, totalUsage, contextUsage: metadata.contextUsage } : metadata);
+  request.retainMetadata(identity ? { model, ownUsage, totalUsage, ownRequestUsage, contextUsage: metadata.contextUsage } : metadata);
   return { ...metadata, children: [] };
 }
 async function loadContextTreeChildFromDisk(childSessionDir, resolveContextWindow, limits = {}, identity) {
@@ -45559,7 +46083,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-WCGPZI2H.js")).VIRTUAL_MODULES, tryNative: false } : {
       alias: getAliases(),
       virtualModules: {
         "@ponythewhite/base-context-ai": src_exports,
@@ -47298,6 +47822,15 @@ function formatHarnessStateForPrompt(state, options = {}) {
     includeIpythonExamples ? "Call contract: read each installed Python skill's SKILL.md and call its documented module function in the Python REPL; do not assume a `.run` entrypoint. Use `<skill_import> ...` in shell when a CLI exists. Continual harness skill entries are Python REPL skills with an explicit Python `reference` and `arguments` contract. Spawn a continual harness subagent spec by composing a concise task prompt and calling `handle = await rlm('sub-task')`; admission returns immediately with `rlm_child_id`, `name`, `session_dir`, and `model`, never the child's answer. Results arrive only through explicit `agent_message` replies or files; children reply with `await agent_message.send(message, receiver_role='parent')`. Use `await rlm.list_subagents()` to recover direct child handles and `await agent_message.send(..., receiver_role='child', receiver_name=handle.name)` for follow-ups. Do not invent wrappers such as `call_skill(...)`, `run_subagent(...)`, or named subagent registries." : options.includeShellExamples ? "Call contract: use installed skills as shell commands when available (for example `<skill_import> ...`). Continual harness entries are routing/context hints only in sessions without the Python REPL; do not use Python `await`, `asyncio`, or `rlm` examples unless the prompt also documents a Python kernel." : "Call contract: continual harness entries are routing/context hints only in sessions without the Python REPL or shell access; do not use Python `await`, `asyncio`, `rlm`, or shell skill commands unless the prompt also documents those interfaces.",
     ""
   ];
+  if (options.section === "instructions") {
+    lines.push("The latest Continual Harness Snapshot in the conversation is the current compact state. It supersedes all earlier snapshots, including removed entries and advice. Do not revive deleted or rolled-back instructions from older snapshots or summaries.");
+    if (options.errorFixSelection?.enabled && includeIpythonExamples)
+      lines.push("", ERROR_FIX_CREATION_GUIDANCE);
+    return lines.join("\n").trim();
+  }
+  if (options.section === "entries") {
+    lines.splice(0, lines.length, "# Continual Harness Snapshot", "This is the complete current compact harness overview and selected error-fix advice. It supersedes all earlier snapshots, including deletions, rollbacks, and empty state. Treat entries as routing/context advice; system instructions and the current task take precedence. Earlier snapshots and summaries are not current harness advice.", "");
+  }
   let totalEntries = 0;
   for (const kind of Object.keys(state.entries)) {
     const entries = Object.values(state.entries[kind]).filter((entry) => !isErrorFixMemory(entry)).sort((a, b2) => [a.path, a.title, a.id].join("\0").localeCompare([b2.path, b2.title, b2.id].join("\0")));
@@ -47322,7 +47855,7 @@ function formatHarnessStateForPrompt(state, options = {}) {
     lines.push("No saved harness entries yet.", "");
   }
   if (options.errorFixSelection?.enabled) {
-    if (includeIpythonExamples)
+    if (includeIpythonExamples && options.section !== "entries")
       lines.push("", ERROR_FIX_CREATION_GUIDANCE);
     const advice = selectErrorFixAdvice(state, options.errorFixSelection);
     if (advice)
@@ -48316,6 +48849,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 +48868,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";
@@ -49394,6 +49964,8 @@ var IMPLEMENTATION_CONTRACT = [
   "Preserve earlier requirements unless later instructions replace them. Apply stated eligibility, priorities, and decision order literally, even when a different policy seems simpler or more sensible; reevaluate later decisions when earlier actions change their inputs.",
   "The required commands must implement the stated workflow from its stated starting state, without development-only state or extra steps.",
   "During tool-based inspection of large datasets, request schemas or small samples. Process full inputs in local code instead of printing entire datasets into the conversation.",
+  "Read long text in bounded pages; use a character limit as well as a line limit when lines are long. If output is truncated, page the retained result instead of repeating the original command or printing the whole file again.",
+  "Batch nonurgent child updates. Send results, blockers, or decisions that need action rather than acknowledgements and repeated status requests. Continue independent work while children run, and report meaningful milestones to the user.",
   "Do not repeat a successful check without a concrete reason, such as changed input, an edit, or an observed failure.",
   "Choose algorithms whose time and memory costs fit the stated input limits.",
   "For constrained search, prune known-impossible partial states before expanding them; do not postpone all feasibility checks until completed candidates.",
@@ -49457,7 +50029,7 @@ ${childDoctrine}`;
     if (harnessState) {
       prompt2 += `
 
-${formatHarnessStateForPrompt(harnessState, { includeIpythonExamples: hasIpython, includeShellExamples: hasBash, includeRefineExamples: hasIpython && hasRefineSkill, errorFixSelection: options.errorFixSelection })}`;
+${formatHarnessStateForPrompt(harnessState, { includeIpythonExamples: hasIpython, includeShellExamples: hasBash, includeRefineExamples: hasIpython && hasRefineSkill, errorFixSelection: options.errorFixSelection, section: options.harnessSection })}`;
     }
     if (genericMcpSection) {
       prompt2 += `
@@ -49496,7 +50068,7 @@ ${buildSubagentGuidance({
   if (harnessState) {
     prompt += `
 
-${formatHarnessStateForPrompt(harnessState, { includeIpythonExamples: hasIpython, includeShellExamples: hasBash, includeRefineExamples: hasIpython && hasRefineSkill, errorFixSelection: options.errorFixSelection })}`;
+${formatHarnessStateForPrompt(harnessState, { includeIpythonExamples: hasIpython, includeShellExamples: hasBash, includeRefineExamples: hasIpython && hasRefineSkill, errorFixSelection: options.errorFixSelection, section: options.harnessSection })}`;
   }
   if (genericMcpSection) {
     prompt += `
@@ -58610,6 +59182,7 @@ var StaleCompactionOwnerError = class extends Error {
 function createPostCompactionContinuationSettlement(resume) {
   return { ...createAgentMessageDeferred(), resume, settled: false };
 }
+var RLM_PARENT_USAGE_CUSTOM_TYPE = "rlm_parent_usage";
 var KERNEL_STATE_LISTING_TIMEOUT_MS = 5e3;
 var RLM_MAX_DEPTH_STATE_CUSTOM_TYPE = "rlm_max_depth_state";
 function noopRlmChildAbort() {
@@ -58847,6 +59420,8 @@ var AgentSession = class _AgentSession {
   // Kept alive for retained children so nested updates (e.g. a grandchild cancel)
   // still forward to root; torn down when the retained child is disposed.
   _rlmChildUnsubscribes = /* @__PURE__ */ new Map();
+  _rlmChildUsageSources = /* @__PURE__ */ new Map();
+  _rlmParentUsageAttribution;
   /** Latest recap for this session, written by the daemon summarizer; read by a parent to label its child snapshots. */
   _currentRecap;
   _initialGoal;
@@ -58962,10 +59537,12 @@ var AgentSession = class _AgentSession {
       await this._goalResumeOperation;
       await this._waitForAgentEventsBeforeContext();
       await this._waitForChildUsageWrites();
+      const assertHarnessSourceCurrent = await this._appendHarnessSnapshotIfChanged();
       await this.sessionManager.flushNow();
+      assertHarnessSourceCurrent();
       if (!this.sessionManager.isPersisted()) {
         if (!this._compactionSetupFailure)
-          return;
+          return { messages: this.agent.state.messages, adoptMessages: true };
         const rebuilt = await readSessionBootstrap(this.sessionManager, this.settingsManager.getCanonicalContextLimits());
         this._compactionSetupFailure = void 0;
         return { messages: rebuilt.context.messages, adoptMessages: true };
@@ -59019,7 +59596,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 +59632,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([
@@ -61040,7 +61629,7 @@ var AgentSession = class _AgentSession {
     if (compactionTimestamp !== void 0 && context.message.timestamp <= compactionTimestamp)
       return false;
     const contextTokens = this._getThresholdContextTokens(context.message, compactionTimestamp);
-    if (contextTokens === void 0 || !shouldCompact(contextTokens, contextWindow, settings))
+    if (contextTokens === void 0 || !shouldCompact(contextTokens, contextWindow, settings, estimateFixedCompactionTokens(this.systemPrompt, this.agent.state.tools, this.messages)))
       return false;
     if (this._hasFailedThresholdCompaction())
       return false;
@@ -61373,7 +61962,7 @@ var AgentSession = class _AgentSession {
         }
         return {
           scheduled: true,
-          note: "Refinement runs when the current turn ends; the harness rebuilds the system prompt and resumes you automatically. Continue working normally."
+          note: "Refinement runs when the current turn ends; fresh harness advice is added to the next request and you resume automatically. Continue working normally."
         };
       }
       default:
@@ -62316,6 +62905,7 @@ var AgentSession = class _AgentSession {
       for (const { session } of this._rlmChildSessions.values())
         await drain(() => session.disposeAsync());
       this._rlmChildSessions.clear();
+      this._rlmChildUsageSources.clear();
       this._rlmChildCleanupFailures.clear();
       this._deletedRlmChildIds.clear();
       await drain(() => this._ipythonKernelProvisioner?.dispose({ snapshot: kernelSnapshot }));
@@ -62405,6 +62995,7 @@ var AgentSession = class _AgentSession {
         session.dispose();
       }
       this._rlmChildSessions.clear();
+      this._rlmChildUsageSources.clear();
       this._rlmChildCleanupFailures.clear();
       this._deletedRlmChildIds.clear();
       this._pendingNextTurnMessages = [];
@@ -62639,6 +63230,7 @@ var AgentSession = class _AgentSession {
       rlmDepth: this._rlmDepth,
       rlmParentAgent: this._rlmParentAgent,
       harnessState: this._loadMergedHarnessState(),
+      harnessSection: "instructions",
       errorFixSelection: {
         enabled: this.settingsManager.getLearningEnabled(),
         tools: validToolNames,
@@ -62651,6 +63243,106 @@ var AgentSession = class _AgentSession {
     };
     return buildSystemPrompt(this._baseSystemPromptOptions);
   }
+  /** Read only snapshot candidates in the active literal tail and accepted epoch recipes. */
+  async _readHarnessSnapshot(view) {
+    const { maxMessages, maxSourceBytes } = this.settingsManager.getCanonicalContextLimits();
+    const refs = [];
+    let summary = null;
+    let cursor;
+    let count = 0;
+    let bytes = 0;
+    do {
+      const page = await view.contextManifest({ cursor, limit: 128 });
+      if (page.selection !== "known")
+        throw new Error(`Harness snapshot context selection is ${page.selection}`);
+      summary = page.summaryRef;
+      count += page.refs.length;
+      if (count + (summary ? 1 : 0) > maxMessages)
+        throw new Error("Harness snapshot context message budget exceeded");
+      refs.push(...page.refs.filter((ref) => ref.kind === "custom_message"));
+      cursor = page.nextCursor ?? void 0;
+    } while (cursor);
+    const read2 = async (ref, source = view) => {
+      bytes += ref.locator.length;
+      if (bytes > maxSourceBytes)
+        throw new Error("Harness snapshot source byte budget exceeded");
+      const metadata = await source.get(ref.entryId);
+      if (!metadata || metadata.revision !== ref.revision)
+        throw new Error("Harness snapshot source is unavailable");
+      const hydrated = await hydrateCapturedHistoryEntry(metadata, ref.locator.length, source.readPayload);
+      if (!hydrated)
+        throw new Error("Harness snapshot payload is unavailable");
+      return hydrated.entry;
+    };
+    const content = (entry2) => entry2.type === "custom_message" && entry2.customType === HARNESS_SNAPSHOT_CUSTOM_TYPE && typeof entry2.content === "string" ? entry2.content : void 0;
+    for (const ref of refs.reverse()) {
+      const snapshot = content(await read2(ref));
+      if (snapshot !== void 0)
+        return snapshot;
+    }
+    if (!summary)
+      return;
+    const entry = await read2(summary);
+    if (entry.type !== "compaction" || summary.qualification !== "native-context-epoch" || summary.retention === "retained-import")
+      return;
+    const checkpoint = readContextEpoch(entry.details, maxSourceBytes);
+    if (!checkpoint)
+      return;
+    if (count + checkpoint.views.length > maxMessages)
+      throw new Error("Harness snapshot context message budget exceeded");
+    for (const pinned of [...checkpoint.views].reverse()) {
+      if (pinned.ref.kind !== "custom_message")
+        continue;
+      if (!view.atSnapshot)
+        throw new Error("Harness snapshot epoch requires its captured source");
+      const snapshot = content(await read2(pinned.ref, await view.atSnapshot(pinned.source)));
+      if (snapshot !== void 0)
+        return snapshot;
+    }
+  }
+  /** Persist mutable advice before the request owner captures its source and epoch ACK boundary. */
+  async _appendHarnessSnapshotIfChanged() {
+    const manager = this.sessionManager;
+    let leafId = manager.getLeafId();
+    const sourceIsCurrent = manager.captureCompactionSourceOwner();
+    const assertCurrent = () => {
+      if (this._disposed || this.sessionManager !== manager || !sourceIsCurrent() || manager.getLeafId() !== leafId)
+        throw new Error("Harness snapshot source changed before request ownership");
+    };
+    let previous;
+    if (manager.isPersisted()) {
+      previous = await manager.readBranchHistory((view) => this._readHarnessSnapshot(view.branchContext));
+    } else {
+      const snapshot = manager.buildSessionContext().messages.reverse().find((message2) => message2.role === "custom" && message2.customType === HARNESS_SNAPSHOT_CUSTOM_TYPE);
+      if (snapshot?.role === "custom")
+        previous = snapshot.content;
+    }
+    assertCurrent();
+    const options = this._baseSystemPromptOptions;
+    const tools = options.selectedTools ?? [];
+    const hasIpython = tools.includes("ipython");
+    const content = formatHarnessStateForPrompt(this._loadMergedHarnessState(), {
+      section: "entries",
+      includeIpythonExamples: hasIpython,
+      includeShellExamples: tools.includes("bash"),
+      errorFixSelection: options.errorFixSelection ? { ...options.errorFixSelection, enabled: this.settingsManager.getLearningEnabled() } : void 0
+    });
+    if (previous === content)
+      return assertCurrent;
+    const entryId = await manager.appendCustomMessageEntryWithRollback(HARNESS_SNAPSHOT_CUSTOM_TYPE, content, false);
+    if (this._disposed || this.sessionManager !== manager || !sourceIsCurrent() || manager.getLeafId() !== entryId)
+      throw new Error("Harness snapshot source changed during append");
+    if (!manager.isPersisted())
+      this.agent.state.messages.push({
+        role: "custom",
+        customType: HARNESS_SNAPSHOT_CUSTOM_TYPE,
+        content,
+        display: false,
+        timestamp: Date.now()
+      });
+    leafId = entryId;
+    return assertCurrent;
+  }
   _refreshExtensionSystemPrompt(extensionPrompt, baseSnapshot) {
     if (this._baseSystemPrompt === baseSnapshot) {
       return extensionPrompt;
@@ -62704,7 +63396,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 +66076,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 +66093,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 +66113,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 +66194,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 +66817,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") {
@@ -66391,8 +67107,10 @@ ${parsed.args}` : block;
       }
       if (refinementAuditAppendError)
         throw refinementAuditAppendError.error;
-      this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
-      this.agent.state.systemPrompt = this._baseSystemPrompt;
+      this._baseSystemPromptOptions = {
+        ...this._baseSystemPromptOptions,
+        harnessState: this._loadMergedHarnessState()
+      };
       try {
         this._emit({ type: "refine_complete", result });
       } catch {
@@ -66445,7 +67163,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 +67236,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);
@@ -66530,7 +67248,7 @@ ${parsed.args}` : block;
     const contextTokens = this._getThresholdContextTokens(assistantMessage, compactionTimestamp);
     if (contextTokens === void 0)
       return false;
-    if (shouldCompact(contextTokens, contextWindow, settings)) {
+    if (shouldCompact(contextTokens, contextWindow, settings, estimateFixedCompactionTokens(this.systemPrompt, this.agent.state.tools, this.messages))) {
       if (this._hasFailedThresholdCompaction())
         return false;
       if (!this._pendingCheckpoint && queueAutonomousContinuation) {
@@ -66540,7 +67258,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 +67304,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 +67417,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) {
@@ -67947,6 +68671,7 @@ This compaction outcome could not be saved to session history: ${persistenceErro
     this._rlmChildUnsubscribes.get(childId)?.();
     this._rlmChildUnsubscribes.delete(childId);
     this._rlmChildSessions.delete(childId);
+    this._rlmChildUsageSources.delete(childId);
     this._rlmChildCleanupFailures.delete(childId);
     this._abandonedRlmQuiescenceChildIds.delete(childId);
     if (!run2 || this._activeRlmChildRuns.get(childId) === run2) {
@@ -68021,6 +68746,145 @@ This compaction outcome could not be saved to session history: ${persistenceErro
     this._removeRlmSubagentTracking(childId);
     return { subagent };
   }
+  async _restoreRlmChildUsageSource(childId, child) {
+    if (this._rlmChildUsageSources.has(childId))
+      return;
+    const readSource = (entry) => {
+      if (entry.type !== "custom" || entry.customType !== RLM_PARENT_USAGE_CUSTOM_TYPE)
+        return;
+      const data = entry.data;
+      if (!data || data.sessionId !== this.sessionId || data.sessionFile !== this.sessionFile || typeof data.entryId !== "string")
+        return;
+      return { sessionId: data.sessionId, sessionFile: data.sessionFile, entryId: data.entryId };
+    };
+    const source = child.sessionManager.supportsCapturedHistoryReads() ? await child.sessionManager.readBranchHistory(async (history) => {
+      let after = 0;
+      while (true) {
+        const page = await history.page(after, 64);
+        for (const ref of page.events) {
+          if (ref.kind !== "custom" || ref.locator.length > 16 * 1024)
+            continue;
+          const record2 = await history.hydrateEntry(ref.id, 16 * 1024);
+          const source2 = record2 && readSource(record2.entry);
+          if (source2)
+            return source2;
+        }
+        if (page.nextAfter === null)
+          return;
+        after = page.nextAfter;
+      }
+    }) : child.sessionManager.getBranch().map(readSource).find((source2) => source2 !== void 0);
+    if (!source || source.sessionId !== this.sessionId || source.sessionFile !== this.sessionFile)
+      return;
+    const target = await this.sessionManager.readEntry(source.entryId);
+    if (target?.type !== "message" || target.message.role !== "assistant")
+      return;
+    if (source.sessionId !== this.sessionId || source.sessionFile !== this.sessionFile)
+      return;
+    this._rlmChildUsageSources.set(childId, source);
+  }
+  _subscribeRlmChildEvents(childId, child, run2, onUsageWrite) {
+    let runningToolCount = 0;
+    const emitChildUpdate = () => {
+      if (run2)
+        run2.emitUpdate?.();
+      else
+        this._emit({ type: "rlm_child_update", child: this._rlmChildSnapshotForSession(childId, child) });
+    };
+    const attributeUsage = (usage, origin) => {
+      const source = this._rlmChildUsageSources.get(childId);
+      if (!source || source.sessionId !== this.sessionId || source.sessionFile !== this.sessionFile)
+        return Promise.resolve();
+      const delta = structuredClone(usage);
+      const target = this.messages.find((message2) => message2.role === "assistant" && this._findAssistantEntryIdForMessage(message2) === source.entryId);
+      const refreshOutput = this._refreshInvocationOutput;
+      const forwardUsage = this._rlmParentUsageAttribution;
+      const write2 = this.sessionManager.appendChildUsageAttributionWithAggregate(source.entryId, delta, void 0, origin).then(async ({ aggregateUsage }) => {
+        if (target) {
+          target.usage = structuredClone(aggregateUsage);
+          refreshOutput?.(target);
+        }
+        await forwardUsage?.(delta, origin);
+      });
+      this._childUsageWrites.add(write2);
+      onUsageWrite?.(write2);
+      void write2.then(() => this._childUsageWrites.delete(write2), (error) => {
+        this._childUsageWrites.delete(write2);
+        if (run2)
+          run2.error = `Child usage attribution was not acknowledged: ${this._asError(error).message}`;
+        this._surfaceSessionInputError(error);
+      });
+      return write2;
+    };
+    child._rlmParentUsageAttribution = attributeUsage;
+    const unsubscribe = child.subscribe((event) => {
+      if (event.type === "rlm_child_update") {
+        this._emit(event);
+        return;
+      }
+      if (event.type === "agent_start") {
+        if (run2)
+          run2.activity = { kind: "waiting" };
+        emitChildUpdate();
+      } else if (event.type === "agent_end") {
+        if (run2)
+          run2.activity = void 0;
+        emitChildUpdate();
+      } else if (event.type === "message_end" && event.message.role === "assistant") {
+        const assistant = event.message;
+        if (run2) {
+          run2.terminalAssistantOutcome = {
+            stopReason: assistant.stopReason,
+            errorMessage: assistant.errorMessage
+          };
+        }
+        const update = () => {
+          const text2 = compactRlmText(readAssistantText(assistant));
+          if (run2 && text2)
+            run2.answerPreview = text2;
+          emitChildUpdate();
+        };
+        if (assistant.stopReason !== "error" && assistant.stopReason !== "aborted") {
+          const messages = child.messages;
+          const precedingPrompt = messages.slice(0, messages.lastIndexOf(assistant)).reverse().find((message2) => message2.role === "user" || message2.role === "custom" && message2.customType !== HARNESS_SNAPSHOT_CUSTOM_TYPE);
+          const origin = precedingPrompt?.role === "custom" && isAgentSessionMessage(precedingPrompt) ? precedingPrompt.details.id.startsWith("spawn:") ? "spawn_task" : "agent_message" : "direct_user";
+          void attributeUsage(assistant.usage, origin).then(update, () => {
+          });
+        } else
+          update();
+      } else if (event.type === "message_start" || event.type === "message_update") {
+        if (event.message.role === "assistant") {
+          if (run2) {
+            const text2 = compactRlmText(readAssistantText(event.message));
+            if (text2)
+              run2.answerPreview = text2;
+            run2.activity = { kind: "writing" };
+          }
+          emitChildUpdate();
+        }
+      } else if (event.type === "tool_execution_start") {
+        if (run2) {
+          run2.toolUseCount++;
+          runningToolCount++;
+          run2.activity = { kind: "executing", toolName: event.toolName };
+        }
+        emitChildUpdate();
+      } else if (event.type === "tool_execution_end") {
+        if (run2) {
+          runningToolCount = Math.max(0, runningToolCount - 1);
+          if (runningToolCount === 0)
+            run2.activity = { kind: "waiting" };
+        }
+        emitChildUpdate();
+      } else if (event.type === "session_info_changed" || event.type === "recap_update")
+        emitChildUpdate();
+    });
+    return () => {
+      unsubscribe();
+      if (child._rlmParentUsageAttribution === attributeUsage)
+        child._rlmParentUsageAttribution = void 0;
+    };
+  }
   /**
    * Retain a finished child session for the parent lifetime so inspectors and
    * daemon-hosted agent messaging can keep addressing it. Returns false (and disposes
@@ -68050,10 +68914,24 @@ This compaction outcome could not be saved to session history: ${persistenceErro
         }
       }
     }
-    this._rlmChildSessions.set(childId, { session, run: this._activeRlmChildRuns.get(childId) });
-    if (unsubscribe) {
-      this._rlmChildUnsubscribes.set(childId, unsubscribe);
+    await this._restoreRlmChildUsageSource(childId, session);
+    if (this._disposed || this._disposing) {
+      await session.disposeAsync();
+      return false;
     }
+    if (this._deletingRlmChildren.has(childId) || this._deletedRlmChildIds.has(childId))
+      return false;
+    const retained = this._rlmChildSessions.get(childId);
+    const run2 = this._activeRlmChildRuns.get(childId);
+    if (!run2?.unsubscribe && (retained?.session !== session || !this._rlmChildUnsubscribes.has(childId))) {
+      this._rlmChildUnsubscribes.get(childId)?.();
+      const ownedUnsubscribe = this._subscribeRlmChildEvents(childId, session);
+      this._rlmChildUnsubscribes.set(childId, () => {
+        ownedUnsubscribe();
+        unsubscribe?.();
+      });
+    }
+    this._rlmChildSessions.set(childId, { session, run: run2 });
     return true;
   }
   releaseRlmChildSession(childId, session) {
@@ -68061,8 +68939,10 @@ This compaction outcome could not be saved to session history: ${persistenceErro
     if (run2?.session === session && run2.status === "done") {
       const unsubscribe2 = run2.unsubscribe ?? noopRlmChildEventUnsubscribe;
       return () => {
-        run2.unsubscribe = void 0;
-        this._activeRlmChildRuns.delete(childId);
+        if (run2.unsubscribe === unsubscribe2)
+          run2.unsubscribe = void 0;
+        if (this._activeRlmChildRuns.get(childId) === run2)
+          this._activeRlmChildRuns.delete(childId);
         unsubscribe2();
       };
     }
@@ -68070,8 +68950,10 @@ This compaction outcome could not be saved to session history: ${persistenceErro
       return false;
     const unsubscribe = this._rlmChildUnsubscribes.get(childId) ?? noopRlmChildEventUnsubscribe;
     return () => {
-      this._rlmChildUnsubscribes.delete(childId);
-      this._rlmChildSessions.delete(childId);
+      if (this._rlmChildSessions.get(childId)?.session === session && this._rlmChildUnsubscribes.get(childId) === unsubscribe) {
+        this._rlmChildUnsubscribes.delete(childId);
+        this._rlmChildSessions.delete(childId);
+      }
       unsubscribe();
     };
   }
@@ -68191,7 +69073,7 @@ This compaction outcome could not be saved to session history: ${persistenceErro
     return [...sessions];
   }
   _hasUnsettledRlmQuiescenceWork() {
-    if (this.requests.hasPending)
+    if (this.requests.hasPending || this._childUsageWrites.size > 0)
       return true;
     if (this._hasDeferredRlmTerminalNotices())
       return true;
@@ -68235,6 +69117,7 @@ This compaction outcome could not be saved to session history: ${persistenceErro
           return;
         await wait(Promise.all([
           ...unsettledRuns.map((run2) => run2.settlement.promise),
+          ...this._childUsageWrites,
           ...childSessions.map((child) => child.waitForRlmQuiescence(cancellation.signal))
         ]));
       }
@@ -68389,6 +69272,12 @@ This compaction outcome could not be saved to session history: ${persistenceErro
   async _startRlmChildRun(prompt, admission, kwargs = {}, spawnCode) {
     const spawnedByRequestId = this.isStreaming ? this._semanticEdges.lastTurnRequestId : void 0;
     const parentAssistantForUsage = this._findLastAssistantMessage();
+    const parentEntryId = parentAssistantForUsage && this._findAssistantEntryIdForMessage(parentAssistantForUsage);
+    const usageSource = parentEntryId ? {
+      sessionId: this.sessionId,
+      sessionFile: this.sessionFile,
+      entryId: parentEntryId
+    } : void 0;
     const { name: rawName, model: rawModel, thinking: rawThinking, ...unsupported } = kwargs;
     const unsupportedKwargs = Object.keys(unsupported);
     if (unsupportedKwargs.length > 0) {
@@ -68433,7 +69322,6 @@ This compaction outcome could not be saved to session history: ${persistenceErro
       await this._assertRlmSubagentSessionNameAvailable(sessionName);
     admission.assertCurrent();
     const startedAt = Date.now();
-    let runningToolCount = 0;
     let childSession;
     let usageSettlement = Promise.resolve();
     const run2 = {
@@ -68455,6 +69343,8 @@ This compaction outcome could not be saved to session history: ${persistenceErro
         throw new Error(run2.error ?? "RLM child cancelled");
     };
     this._activeRlmChildRuns.set(run2.id, run2);
+    if (usageSource)
+      this._rlmChildUsageSources.set(run2.id, usageSource);
     this._unsettledRlmChildRuns.add(run2);
     const emitChildUpdate = () => {
       const child = this._rlmChildSnapshotForRun(run2);
@@ -68537,73 +69427,12 @@ This compaction outcome could not be saved to session history: ${persistenceErro
         throwIfCancelled();
         run2.status = "running";
         emitChildUpdate();
-        const unsubscribeChildEvents = child.subscribe((event) => {
-          if (event.type === "rlm_child_update") {
-            this._emit(event);
-            return;
-          }
-          if (event.type === "agent_start") {
-            run2.activity = { kind: "waiting" };
-            emitChildUpdate();
-          } else if (event.type === "agent_end") {
-            run2.activity = void 0;
-            emitChildUpdate();
-          } else if (event.type === "message_end" && event.message.role === "assistant") {
-            const assistant = event.message;
-            if (assistant.stopReason !== "error" && assistant.stopReason !== "aborted") {
-              if (parentAssistantForUsage) {
-                const parentEntryId = this._findAssistantEntryIdForMessage(parentAssistantForUsage);
-                if (parentEntryId) {
-                  const messages = child.messages;
-                  const assistantIndex = messages.lastIndexOf(assistant);
-                  const precedingPrompt = messages.slice(0, assistantIndex).reverse().find((message2) => message2.role === "user" || message2.role === "custom");
-                  const origin = precedingPrompt?.role === "custom" && isAgentSessionMessage(precedingPrompt) ? precedingPrompt.details.id.startsWith("spawn:") ? "spawn_task" : "agent_message" : "direct_user";
-                  const text3 = compactRlmText(readAssistantText(assistant));
-                  const refreshOutput = this._refreshInvocationOutput;
-                  const write2 = this.sessionManager.appendChildUsageAttributionWithAggregate(parentEntryId, assistant.usage, void 0, origin).then(({ aggregateUsage }) => {
-                    parentAssistantForUsage.usage = structuredClone(aggregateUsage);
-                    refreshOutput?.(parentAssistantForUsage);
-                    if (text3)
-                      run2.answerPreview = text3;
-                    emitChildUpdate();
-                  });
-                  this._childUsageWrites.add(write2);
-                  usageSettlement = Promise.all([usageSettlement, write2]).then(() => void 0);
-                  void usageSettlement.catch(() => void 0);
-                  void write2.then(() => this._childUsageWrites.delete(write2), (error) => {
-                    this._childUsageWrites.delete(write2);
-                    run2.error = `Child usage attribution was not acknowledged: ${this._asError(error).message}`;
-                    this._surfaceSessionInputError(error);
-                  });
-                  return;
-                }
-              }
-            }
-            const text2 = compactRlmText(readAssistantText(assistant));
-            if (text2)
-              run2.answerPreview = text2;
-            emitChildUpdate();
-          } else if (event.type === "message_start" || event.type === "message_update") {
-            if (event.message.role === "assistant") {
-              const text2 = compactRlmText(readAssistantText(event.message));
-              if (text2)
-                run2.answerPreview = text2;
-              run2.activity = { kind: "writing" };
-              emitChildUpdate();
-            }
-          } else if (event.type === "tool_execution_start") {
-            run2.toolUseCount += 1;
-            runningToolCount += 1;
-            run2.activity = { kind: "executing", toolName: event.toolName };
-            emitChildUpdate();
-          } else if (event.type === "tool_execution_end") {
-            runningToolCount = Math.max(0, runningToolCount - 1);
-            if (runningToolCount === 0)
-              run2.activity = { kind: "waiting" };
-            emitChildUpdate();
-          } else if (event.type === "session_info_changed" || event.type === "recap_update") {
-            emitChildUpdate();
-          }
+        if (usageSource) {
+          await child.sessionManager.appendCustomEntry(RLM_PARENT_USAGE_CUSTOM_TYPE, usageSource);
+        }
+        const unsubscribeChildEvents = this._subscribeRlmChildEvents(run2.id, child, run2, (write2) => {
+          usageSettlement = Promise.all([usageSettlement, write2]).then(() => void 0);
+          void usageSettlement.catch(() => void 0);
         });
         run2.unsubscribe = unsubscribeChildEvents;
         const content = `[task from parent]
@@ -68633,8 +69462,17 @@ ${prompt}`;
           source: "extension",
           customMessage: spawnMessage
         });
+        const terminal = run2.terminalAssistantOutcome;
+        if (terminal?.stopReason === "aborted") {
+          run2.status = "cancelled";
+          run2.error ??= terminal.errorMessage || "RLM child aborted";
+        }
+        throwIfCancelled();
+        if (terminal?.stopReason === "error")
+          throw new Error(terminal.errorMessage || "RLM child inference failed");
         await child.waitForRlmQuiescence();
         await usageSettlement;
+        throwIfCancelled();
         if (run2.error)
           throw new Error(run2.error);
         run2.status = "done";
@@ -69462,34 +70300,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
@@ -69544,7 +70361,12 @@ ${command}` : command;
     if (!usage)
       throw new Error("Context tree usage source is unavailable");
     const contextUsage = estimate ? usage.hasPostCompactionUsage ? { tokens: estimate.tokens, contextWindow, percent: estimate.tokens / contextWindow * 100 } : { tokens: null, contextWindow, percent: null } : void 0;
-    const usageMetadata = { ownUsage: usage.ownUsage, totalUsage: usage.totalUsage, contextUsage };
+    const usageMetadata = {
+      ownUsage: usage.ownUsage,
+      totalUsage: usage.totalUsage,
+      ...usage.ownRequestUsage ? { ownRequestUsage: usage.ownRequestUsage } : {},
+      contextUsage
+    };
     request.retainMetadata({ contextUsage });
     return {
       ...rootNode,
@@ -70090,7 +70912,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.11-2-g8a0001383";
 }
 function getDaemonRuntimeIdentity(environment = process.env) {
   const entrypoint = process.argv[1];
@@ -70795,6 +71617,8 @@ export {
   collectEntriesForBranchSummary,
   prepareBranchEntries,
   generateBranchSummary,
+  emptyRequestUsageTotals,
+  addRequestUsageTotals,
   SESSION_SCHEDULED_JOBS_FILENAME,
   DEFAULT_HEARTBEAT_SCHEDULE,
   DEFAULT_HEARTBEAT_DELIVERY_MODE,
@@ -70917,7 +71741,7 @@ export {
   passivatedWorkerRosterEntry,
   sessionSummaryFromRosterEntry,
   AgentRoster,
-  readUserMessagesForForking,
+  readVisibleUserMessagesForForking,
   SERPER_CREDENTIAL_ID,
   SERPER_CREDENTIAL_NAME,
   PromptAdmissionCancelledError,