@ponythewhite/base-context 1.0.11 → 1.0.13

package/dist/bundle/{chunk-TOOVREMP.js → chunk-TKOBEJ5E.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",
@@ -28085,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()) {
@@ -31728,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;
@@ -31866,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;
@@ -32198,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);
@@ -32453,7 +32455,7 @@ ${JSON.stringify(selections.map((skill) => ({
     }
     compiledEpochContexts.set(closedMessages, {
       ...inheritedRecoveryCoverage.length ? { inheritedRecoveryCoverage } : {},
-      ...purpose === "read" ? { readOnly: true } : {},
+      ...purpose2 === "read" ? { readOnly: true } : {},
       mode,
       source: { ...view.source },
       checkpoint,
@@ -32473,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;
   }
 };
 
@@ -33143,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");
@@ -33374,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)
@@ -33592,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,
@@ -33625,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;
@@ -33807,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;
@@ -33926,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;
@@ -34178,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.floor(contextWindow * 0.9), 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);
@@ -43085,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 {
@@ -43178,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)
@@ -43191,6 +43320,7 @@ function readResidentContextTreeUsage(manager, limits = { maxEntries: 16384, max
   }
   return {
     ...computeOwnAndTotalUsage(branch, snapshot.entries),
+    ...ownRequestUsage ? { ownRequestUsage } : {},
     ...availabilityMaxSourceBytes === void 0 ? {} : { hasPostCompactionUsage: hasPostCompactionUsage(branch) }
   };
 }
@@ -43208,6 +43338,9 @@ async function readContextTreeUsage(manager, limits = { maxEntries: 16384, maxSo
     request?.retainMetadata(history.source);
     const reduce = async () => {
       const allEntries = [];
+      let receipts = new RequestUsageAccumulator(history.source.sessionId);
+      let requestEntries = 0;
+      let requestBytes = 0;
       let sourceBytes = 0;
       let after = 0;
       for (; ; ) {
@@ -43215,6 +43348,23 @@ async function readContextTreeUsage(manager, limits = { maxEntries: 16384, maxSo
         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)
@@ -43266,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);
@@ -43434,6 +43586,9 @@ async function readContextTreeProjectionFromDisk(sessionFile, request) {
   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 {
@@ -43446,6 +43601,15 @@ async function readContextTreeProjectionFromDisk(sessionFile, request) {
         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;
@@ -43478,13 +43642,14 @@ async function readContextTreeProjectionFromDisk(sessionFile, request) {
     const hasSourceLeaf = leafId !== null;
     leafId = visibleParent(leafId);
     applyChildUsageAttributions(entries);
-    return { entries, leafId, hasSourceLeaf };
+    const ownRequestUsage = receipts?.finish();
+    return { entries, leafId, hasSourceLeaf, ...ownRequestUsage ? { ownRequestUsage } : {} };
   } finally {
     request.releaseMetadata(metadataBytes);
   }
 }
 async function readContextTreeChildNodeFromDisk(childSessionDir, sessionFile, resolveContextWindow, request, identity) {
-  const { entries: allEntries, leafId, hasSourceLeaf } = await readContextTreeProjectionFromDisk(sessionFile, request);
+  const { entries: allEntries, leafId, hasSourceLeaf, ownRequestUsage } = await readContextTreeProjectionFromDisk(sessionFile, request);
   const branch = branchEntries(allEntries, leafId);
   if (branch.length === 0 && !hasSourceLeaf) {
     return void 0;
@@ -43515,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) {
@@ -45917,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-PEFT72QN.js")).VIRTUAL_MODULES, tryNative: false } : {
+    ...isBunBinary || isBundledCli ? { virtualModules: (await import("./bundled-modules-URKVA3UB.js")).VIRTUAL_MODULES, tryNative: false } : {
       alias: getAliases(),
       virtualModules: {
         "@ponythewhite/base-context-ai": src_exports,
@@ -47656,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")));
@@ -47680,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)
@@ -49789,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.",
@@ -49852,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 += `
@@ -49891,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 += `
@@ -59005,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() {
@@ -59242,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;
@@ -59357,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 };
@@ -61447,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;
@@ -61780,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:
@@ -62723,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 }));
@@ -62812,6 +62995,7 @@ var AgentSession = class _AgentSession {
         session.dispose();
       }
       this._rlmChildSessions.clear();
+      this._rlmChildUsageSources.clear();
       this._rlmChildCleanupFailures.clear();
       this._deletedRlmChildIds.clear();
       this._pendingNextTurnMessages = [];
@@ -63046,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,
@@ -63058,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;
@@ -66822,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 {
@@ -66961,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) {
@@ -68384,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) {
@@ -68458,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
@@ -68487,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) {
@@ -68498,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();
       };
     }
@@ -68507,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();
     };
   }
@@ -68628,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;
@@ -68672,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))
         ]));
       }
@@ -68826,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) {
@@ -68870,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 = {
@@ -68892,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);
@@ -68974,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]
@@ -69070,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";
@@ -69960,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,
@@ -70506,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.10-1-g67d926ccc";
+  return false ? void 0 : "v1.0.12-2-gc29f87f19";
 }
 function getDaemonRuntimeIdentity(environment = process.env) {
   const entrypoint = process.argv[1];
@@ -71211,6 +71617,8 @@ export {
   collectEntriesForBranchSummary,
   prepareBranchEntries,
   generateBranchSummary,
+  emptyRequestUsageTotals,
+  addRequestUsageTotals,
   SESSION_SCHEDULED_JOBS_FILENAME,
   DEFAULT_HEARTBEAT_SCHEDULE,
   DEFAULT_HEARTBEAT_DELIVERY_MODE,