@ponythewhite/base-context 1.0.10 → 1.0.12

package/dist/core/agent-session.js

@@ -15,9 +15,9 @@ import { addLoginGuidanceToAuthError, formatAuthenticationFailedMessage, formatN
 import { addAutonomousContinuation, addAutonomousUsage, autonomousStatus, createAutonomousRuntimeState, nextAutonomousContinuation, refreshAutonomousQualityGates, setAutonomousEnabled, } from "./autonomous.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { stringifyBoundedJson } from "./bounded-json.js";
-import { CanonicalContextCompiler, canonicalRecoveryBoundary, getCanonicalEpochContext, getCanonicalMessageSource, getCanonicalViewUnits, prepareCanonicalEpoch, prepareContextModeEpoch, prepareRecoveryCompaction, readCanonicalContextMode, } from "./canonical-context.js";
-import { COMPACT_SKILL_NAME, calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, prepareViewCompaction, serializeConversation, shouldCompact, takeNativeBranchSummaryWrite, } from "./compaction/index.js";
-import { appendContextEpoch, assertContextRequestContract, CONTEXT_EPOCH_DETAIL, CONTEXT_SKILL_EPOCH_RENDERER, contextEpochMode, contextEpochRepresentation, contextRequestContract, retainedContextRequestContract, snapshotContextEpoch, } from "./context-epoch.js";
+import { CanonicalContextCompiler, canonicalRecoveryBoundary, getCanonicalEpochContext, getCanonicalMessageSource, getCanonicalViewSelectionSource, getCanonicalViewUnits, MissingRecoveryReplayContractError, prepareCanonicalEpoch, prepareContextModeEpoch, prepareRecoveryCompaction, readCanonicalContextMode, } from "./canonical-context.js";
+import { COMPACT_SKILL_NAME, calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateFixedCompactionTokens, generateBranchSummary, prepareCompaction, prepareViewCompaction, serializeConversation, shouldCompact, takeNativeBranchSummaryWrite, } from "./compaction/index.js";
+import { appendContextEpoch, assertContextRequestContract, CONTEXT_EPOCH_DETAIL, CONTEXT_SKILL_EPOCH_RENDERER, contextEpochMode, contextEpochRepresentation, contextRequestContract, readContextEpoch, retainedContextRequestContract, snapshotContextEpoch, UnsupportedContextEpochConfigurationError, } from "./context-epoch.js";
 import { ContextTreeRequest, computeOwnAndTotalUsage, loadContextTreeChildFromDisk, loadContextTreeChildrenFromDisk, readContextTreeUsage, readResidentContextTreeUsage, } from "./context-tree.js";
 import { normalizeHeartbeatDeliveryMode } from "./cron-jobs.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
@@ -28,11 +28,11 @@ import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { createGoalContextMessage, emptyGoalState, GOAL_CONTEXT_CUSTOM_TYPE, GOAL_CONTEXT_PREVIEW_LABEL, GOAL_SKILL_NAME, GOAL_STATE_CUSTOM_TYPE, goalHostResponse, goalTokenDeltaForUsage, isPersistedGoalState, normalizeGoalState, validateGoalBudget, validateGoalObjective, } from "./goals.js";
 import { captureNativeBranchRequests, captureNativeCompactionRequests, captureNativePlannerRequests, captureNativeReviewerRequests, InferenceCoordinator, takeNativeInferenceAuthSource, } from "./inference-coordinator.js";
 import { snapshotPathIn } from "./kernel/state-snapshot.js";
-import { convertToLlm, createCompactionOutcomeMessage, createHeartbeatPromptMessage, createRefinementOutcomeMessage, createRlmChildFailureMessage, createRlmChildTerminalNoticeMessage, createSessionSlashCommandMessage, createSessionSlashCommandResultMessage, HEARTBEAT_PROMPT_CUSTOM_TYPE, HEARTBEAT_PROMPT_PREVIEW_LABEL, IPYTHON_STATE_RESTORED_CUSTOM_TYPE, isSessionSlashCommandMessage, RLM_CHILD_FAILURE_CUSTOM_TYPE, RLM_CHILD_TERMINAL_NOTICE_CUSTOM_TYPE, } from "./messages.js";
+import { convertToLlm, createCompactionOutcomeMessage, createHeartbeatPromptMessage, createRefinementOutcomeMessage, createRlmChildFailureMessage, createRlmChildTerminalNoticeMessage, createSessionSlashCommandMessage, createSessionSlashCommandResultMessage, HARNESS_SNAPSHOT_CUSTOM_TYPE, HEARTBEAT_PROMPT_CUSTOM_TYPE, HEARTBEAT_PROMPT_PREVIEW_LABEL, IPYTHON_STATE_RESTORED_CUSTOM_TYPE, isSessionSlashCommandMessage, RLM_CHILD_FAILURE_CUSTOM_TYPE, RLM_CHILD_TERMINAL_NOTICE_CUSTOM_TYPE, } from "./messages.js";
 import { throwIfPromptAdmissionCancelled } from "./prompt-admission.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
-import { appendGlobalRefinement, applyRefinementProposal, generateRefinementId, getGlobalHarnessStateDir, getLocalHarnessStateDir, getRefinementHistory, getWorkspaceHarnessStateDir, inferRefinementResultScope, loadGlobalRefinementHistory, loadHarnessState, mergeHarnessStates, mergeRefinementHistory, normalizeRefinementProposal, planRefinement, prepareRefinementApplication, REFINE_SKILL_NAME, reviewAutoRefine, saveHarnessState, takeNativePlannerRequestWrite, withRefinementBaseline, } from "./refinement/index.js";
-import { PublicContextBudgetError } from "./request-view-selection.js";
+import { appendGlobalRefinement, applyRefinementProposal, formatHarnessStateForPrompt, generateRefinementId, getGlobalHarnessStateDir, getLocalHarnessStateDir, getRefinementHistory, getWorkspaceHarnessStateDir, inferRefinementResultScope, loadGlobalRefinementHistory, loadHarnessState, mergeHarnessStates, mergeRefinementHistory, normalizeRefinementProposal, planRefinement, prepareRefinementApplication, REFINE_SKILL_NAME, reviewAutoRefine, saveHarnessState, takeNativePlannerRequestWrite, withRefinementBaseline, } from "./refinement/index.js";
+import { getRecoveryCompactionAuthorization, PublicContextBudgetError } from "./request-view-selection.js";
 import { resolveConfigValue } from "./resolve-config-value.js";
 import { assertResourceCurrent } from "./resource-view.js";
 import { createDefaultRlmSubagentSessionName, createRlmDeleteSubagentHostHandler, createRlmFindModelsHostHandler, createRlmListSubagentsHostHandler, createRlmRunHostHandler, findRlmModelMatches, normalizeRequestedRlmSubagentModel, normalizeRequestedRlmSubagentSessionName, normalizeRequestedRlmSubagentThinkingLevel, } from "./rlm-runtime.js";
@@ -45,8 +45,9 @@ import { appendSentAgentMessageToToolResult, IPYTHON_SENT_AGENT_MESSAGE_CUSTOM_E
 import { ContextUsageReader } from "./session-context-usage.js";
 import { bindNativeEntryWriter, } from "./session-entry-origin.js";
 import { readUserMessagesForForking } from "./session-fork-messages.js";
+import { hydrateCapturedHistoryEntry, } from "./session-history-index.js";
 import { exportSessionBranchToJsonl } from "./session-jsonl-export.js";
-import { applyChildUsageAttributions, getLatestCompactionEntry, SessionManager, } from "./session-manager.js";
+import { getLatestCompactionEntry, SessionManager, } from "./session-manager.js";
 import { getPythonSkillRuntimeInfo } from "./skills.js";
 import { parseRefineCommandOptions, parseSessionSlashCommand, parseSlashCommand, } from "./slash-commands.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
@@ -191,6 +192,7 @@ function createPostCompactionContinuationSettlement(resume) {
     return { ...createAgentMessageDeferred(), resume, settled: false };
 }
 import { LocalRlmSubagentCapacity, } from "./rlm-max-subagents.js";
+const RLM_PARENT_USAGE_CUSTOM_TYPE = "rlm_parent_usage";
 const KERNEL_STATE_LISTING_TIMEOUT_MS = 5000;
 const RLM_MAX_DEPTH_STATE_CUSTOM_TYPE = "rlm_max_depth_state";
 function noopRlmChildAbort() { }
@@ -435,6 +437,8 @@ export 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 = new Map();
+    _rlmChildUsageSources = new Map();
+    _rlmParentUsageAttribution;
     /** Latest recap for this session, written by the daemon summarizer; read by a parent to label its child snapshots. */
     _currentRecap;
     _initialGoal;
@@ -559,11 +563,13 @@ export class AgentSession {
             await this._goalResumeOperation;
             await this._waitForAgentEventsBeforeContext();
             await this._waitForChildUsageWrites();
+            const assertHarnessSourceCurrent = await this._appendHarnessSnapshotIfChanged();
             await this.sessionManager.flushNow();
+            assertHarnessSourceCurrent();
             // In-memory sessions have no canonical archive. This is an explicit mode, not an index-error fallback.
             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 = undefined;
                 return { messages: rebuilt.context.messages, adoptMessages: true };
@@ -616,7 +622,10 @@ export class AgentSession {
                 if (epochContext)
                     this._contextMode = epochContext.mode;
                 const unbudgetedPublic = !contextEpochsEnabled &&
-                    Boolean(epochContext?.toolContinuations?.length || epochContext?.taskFrameRebased || epochContext?.checkpoint);
+                    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") : undefined;
                 if (this._baseSystemPromptOptions.nativeSkillSelection !== skillPolicy) {
@@ -663,7 +672,37 @@ export class AgentSession {
                                 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))) {
+                                    // Optional capture only. Keep the unchanged full-native offer; grant no epoch or omission.
+                                    return;
+                                }
+                            }
+                            throw error;
+                        }
                         const replayContract = "replayContract" in candidate.projection &&
                             candidate.projection.replayContract === "message-groups"
                             ? "message-groups"
@@ -2916,7 +2955,8 @@ export class AgentSession {
         if (compactionTimestamp !== undefined && context.message.timestamp <= compactionTimestamp)
             return false;
         const contextTokens = this._getThresholdContextTokens(context.message, compactionTimestamp);
-        if (contextTokens === undefined || !shouldCompact(contextTokens, contextWindow, settings))
+        if (contextTokens === undefined ||
+            !shouldCompact(contextTokens, contextWindow, settings, estimateFixedCompactionTokens(this.systemPrompt, this.agent.state.tools, this.messages)))
             return false;
         if (this._hasFailedThresholdCompaction())
             return false;
@@ -3280,7 +3320,7 @@ export 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:
@@ -4348,6 +4388,7 @@ export 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();
             // Stop kernel-backed tools before waiting for their terminal agent events.
@@ -4443,6 +4484,7 @@ export class AgentSession {
                 session.dispose();
             }
             this._rlmChildSessions.clear();
+            this._rlmChildUsageSources.clear();
             this._rlmChildCleanupFailures.clear();
             this._deletedRlmChildIds.clear();
             this._pendingNextTurnMessages = [];
@@ -4687,6 +4729,7 @@ export class AgentSession {
             rlmDepth: this._rlmDepth,
             rlmParentAgent: this._rlmParentAgent,
             harnessState: this._loadMergedHarnessState(),
+            harnessSection: "instructions",
             errorFixSelection: {
                 enabled: this.settingsManager.getLearningEnabled(),
                 tools: validToolNames,
@@ -4699,6 +4742,118 @@ export 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 ?? undefined;
+        } while (cursor);
+        const read = 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 = (entry) => entry.type === "custom_message" &&
+            entry.customType === HARNESS_SNAPSHOT_CUSTOM_TYPE &&
+            typeof entry.content === "string"
+            ? entry.content
+            : undefined;
+        for (const ref of refs.reverse()) {
+            const snapshot = content(await read(ref));
+            if (snapshot !== undefined)
+                return snapshot;
+        }
+        if (!summary)
+            return;
+        const entry = await read(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 read(pinned.ref, await view.atSnapshot(pinned.source)));
+            if (snapshot !== undefined)
+                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((message) => message.role === "custom" && message.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() }
+                : undefined,
+        });
+        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;
@@ -4755,7 +4910,7 @@ export class AgentSession {
     async _runPreTurnCompaction() {
         const lastAssistant = this._findLastAssistantMessage();
         if (lastAssistant)
-            await this._checkCompaction(lastAssistant, false, false);
+            await this._checkCompaction(lastAssistant, false, false, undefined, true);
     }
     async _prepareForCommit(policy, steps) {
         if (policy.initialRefineBarrier === "always" ||
@@ -7727,7 +7882,7 @@ export class AgentSession {
         }
     }
     /** 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();
@@ -7744,13 +7899,14 @@ export class AgentSession {
             const context = getCanonicalEpochContext(messages);
             if (context.checkpoint?.includeSummary && pathEntries.at(-1)?.type === "compaction")
                 return { preparation: undefined, 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);
             // Refuse unsupported public data or open groups before starting the summary model call.
             if (preparation)
-                prepareRecoveryCompaction(messages, preparation.firstKeptEntryId, limits.maxSourceBytes);
+                prepareRecoveryCompaction(messages, preparation.firstKeptEntryId, limits.maxSourceBytes, authorization);
             return {
                 preparation,
                 messages,
@@ -7766,7 +7922,7 @@ export class AgentSession {
      */
     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);
@@ -7864,7 +8020,7 @@ export class AgentSession {
             this._assertCompactionOwner(owner);
             const result = JSON.parse(JSON.stringify({ summary, firstKeptEntryId, tokensBefore, details }));
             const recovery = prepared.messages
-                ? prepareRecoveryCompaction(prepared.messages, firstKeptEntryId, prepared.maxSourceBytes)
+                ? prepareRecoveryCompaction(prepared.messages, firstKeptEntryId, prepared.maxSourceBytes, getRecoveryCompactionAuthorization(options.capacity))
                 : undefined;
             if (prepared.resource)
                 assertResourceCurrent(prepared.resource);
@@ -8557,7 +8713,31 @@ export class AgentSession {
         const sessionHistory = (async () => {
             if (residentEntries !== undefined)
                 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;
+                        // Refinement consumes custom records, not archived conversation or request bodies.
+                        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") {
@@ -8869,8 +9049,12 @@ export class AgentSession {
             }
             if (refinementAuditAppendError)
                 throw refinementAuditAppendError.error;
-            this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
-            this.agent.state.systemPrompt = this._baseSystemPrompt;
+            // Keep extension-facing state fresh, but do not rewrite the cached system prefix.
+            this._baseSystemPromptOptions = {
+                ...this._baseSystemPromptOptions,
+                harnessState: this._loadMergedHarnessState(),
+            };
+            // The next owned request appends the new advice before capturing its source.
             try {
                 this._emit({ type: "refine_complete", result });
             }
@@ -8935,7 +9119,7 @@ export class AgentSession {
             return undefined;
         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))
@@ -9036,7 +9220,7 @@ export class AgentSession {
             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, undefined, beforeNextTurn);
         }
         if (this._pendingRequestedCompaction !== undefined) {
             return await this._runAutoCompaction("requested", false, owner);
@@ -9052,7 +9236,7 @@ export class AgentSession {
         const contextTokens = this._getThresholdContextTokens(assistantMessage, compactionTimestamp);
         if (contextTokens === undefined)
             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) {
@@ -9063,7 +9247,7 @@ export class AgentSession {
             }
             if (!this._isCompactionOwnerCurrent(owner) || !this._contextOptimizationAllowed())
                 return false;
-            return await this._runAutoCompaction("threshold", false, owner);
+            return await this._runAutoCompaction("threshold", false, owner, false, undefined, beforeNextTurn);
         }
         return false;
     }
@@ -9109,7 +9293,7 @@ export class AgentSession {
         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();
@@ -9245,6 +9429,13 @@ export class AgentSession {
             if (!this._isCompactionSourceOwnerCurrent(owner))
                 throw failure;
             this._clearQueuedAutonomousContinuationsAfterSkippedThresholdCompaction(reason === "threshold" && shouldContinueAfterCompaction, queuedAutonomousContinuationsForThisCompaction);
+            if (beforeNextTurn && error instanceof MissingRecoveryReplayContractError) {
+                // Let the imminent MAIN obtain its own actual projection/ACK. This was not a recovery attempt.
+                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 errorMessage = error instanceof Error ? error.message : "compaction failed";
             const aborted = errorMessage === "Compaction cancelled" ||
                 (error instanceof Error && error.name === "AbortError") ||
@@ -10625,6 +10816,7 @@ export class AgentSession {
         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 (!run || this._activeRlmChildRuns.get(childId) === run) {
@@ -10710,6 +10902,170 @@ export class AgentSession {
         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 record = await history.hydrateEntry(ref.id, 16 * 1024);
+                        const source = record && readSource(record.entry);
+                        if (source)
+                            return source;
+                    }
+                    if (page.nextAfter === null)
+                        return;
+                    after = page.nextAfter;
+                }
+            })
+            : child.sessionManager
+                .getBranch()
+                .map(readSource)
+                .find((source) => source !== undefined);
+        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, run, onUsageWrite) {
+        let runningToolCount = 0;
+        const emitChildUpdate = () => {
+            if (run)
+                run.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((message) => message.role === "assistant" && this._findAssistantEntryIdForMessage(message) === source.entryId);
+            const refreshOutput = this._refreshInvocationOutput;
+            const forwardUsage = this._rlmParentUsageAttribution;
+            const write = this.sessionManager
+                .appendChildUsageAttributionWithAggregate(source.entryId, delta, undefined, origin)
+                .then(async ({ aggregateUsage }) => {
+                if (target) {
+                    target.usage = structuredClone(aggregateUsage);
+                    refreshOutput?.(target);
+                }
+                // Ancestors receive only this newly acknowledged delta, never the aggregate again.
+                await forwardUsage?.(delta, origin);
+            });
+            this._childUsageWrites.add(write);
+            onUsageWrite?.(write);
+            void write.then(() => this._childUsageWrites.delete(write), (error) => {
+                this._childUsageWrites.delete(write);
+                if (run)
+                    run.error = `Child usage attribution was not acknowledged: ${this._asError(error).message}`;
+                this._surfaceSessionInputError(error);
+            });
+            return write;
+        };
+        child._rlmParentUsageAttribution = attributeUsage;
+        const unsubscribe = child.subscribe((event) => {
+            if (event.type === "rlm_child_update") {
+                this._emit(event);
+                return;
+            }
+            if (event.type === "agent_start") {
+                if (run)
+                    run.activity = { kind: "waiting" };
+                emitChildUpdate();
+            }
+            else if (event.type === "agent_end") {
+                if (run)
+                    run.activity = undefined;
+                emitChildUpdate();
+            }
+            else if (event.type === "message_end" && event.message.role === "assistant") {
+                const assistant = event.message;
+                if (run) {
+                    run.terminalAssistantOutcome = {
+                        stopReason: assistant.stopReason,
+                        errorMessage: assistant.errorMessage,
+                    };
+                }
+                const update = () => {
+                    const text = compactRlmText(readAssistantText(assistant));
+                    if (run && text)
+                        run.answerPreview = text;
+                    emitChildUpdate();
+                };
+                if (assistant.stopReason !== "error" && assistant.stopReason !== "aborted") {
+                    const messages = child.messages;
+                    const precedingPrompt = messages
+                        .slice(0, messages.lastIndexOf(assistant))
+                        .reverse()
+                        .find((message) => message.role === "user" ||
+                        (message.role === "custom" && message.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 (run) {
+                        const text = compactRlmText(readAssistantText(event.message));
+                        if (text)
+                            run.answerPreview = text;
+                        run.activity = { kind: "writing" };
+                    }
+                    emitChildUpdate();
+                }
+            }
+            else if (event.type === "tool_execution_start") {
+                if (run) {
+                    run.toolUseCount++;
+                    runningToolCount++;
+                    run.activity = { kind: "executing", toolName: event.toolName };
+                }
+                emitChildUpdate();
+            }
+            else if (event.type === "tool_execution_end") {
+                if (run) {
+                    runningToolCount = Math.max(0, runningToolCount - 1);
+                    if (runningToolCount === 0)
+                        run.activity = { kind: "waiting" };
+                }
+                emitChildUpdate();
+            }
+            else if (event.type === "session_info_changed" || event.type === "recap_update")
+                emitChildUpdate();
+        });
+        return () => {
+            unsubscribe();
+            if (child._rlmParentUsageAttribution === attributeUsage)
+                child._rlmParentUsageAttribution = undefined;
+        };
+    }
     /**
      * Retain a finished child session for the parent lifetime so inspectors and
      * daemon-hosted agent messaging can keep addressing it. Returns false (and disposes
@@ -10742,10 +11098,24 @@ export class AgentSession {
                 }
             }
         }
-        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 run = this._activeRlmChildRuns.get(childId);
+        if (!run?.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 });
         return true;
     }
     releaseRlmChildSession(childId, session) {
@@ -10753,8 +11123,10 @@ export class AgentSession {
         if (run?.session === session && run.status === "done") {
             const unsubscribe = run.unsubscribe ?? noopRlmChildEventUnsubscribe;
             return () => {
-                run.unsubscribe = undefined;
-                this._activeRlmChildRuns.delete(childId);
+                if (run.unsubscribe === unsubscribe)
+                    run.unsubscribe = undefined;
+                if (this._activeRlmChildRuns.get(childId) === run)
+                    this._activeRlmChildRuns.delete(childId);
                 unsubscribe();
             };
         }
@@ -10762,8 +11134,11 @@ export class AgentSession {
             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();
         };
     }
@@ -10890,7 +11265,7 @@ export class AgentSession {
         return [...sessions];
     }
     _hasUnsettledRlmQuiescenceWork() {
-        if (this.requests.hasPending)
+        if (this.requests.hasPending || this._childUsageWrites.size > 0)
             return true;
         if (this._hasDeferredRlmTerminalNotices())
             return true;
@@ -10934,6 +11309,7 @@ export class AgentSession {
                     return;
                 await wait(Promise.all([
                     ...unsettledRuns.map((run) => run.settlement.promise),
+                    ...this._childUsageWrites,
                     ...childSessions.map((child) => child.waitForRlmQuiescence(cancellation.signal)),
                 ]));
                 // Always loop through the self-active/deferred checks again. Work may
@@ -11101,6 +11477,14 @@ export class AgentSession {
         // firing while the parent is idle) has no such turn; an absent edge beats a wrong one.
         const spawnedByRequestId = this.isStreaming ? this._semanticEdges.lastTurnRequestId : undefined;
         const parentAssistantForUsage = this._findLastAssistantMessage();
+        const parentEntryId = parentAssistantForUsage && this._findAssistantEntryIdForMessage(parentAssistantForUsage);
+        const usageSource = parentEntryId
+            ? {
+                sessionId: this.sessionId,
+                sessionFile: this.sessionFile,
+                entryId: parentEntryId,
+            }
+            : undefined;
         const { name: rawName, model: rawModel, thinking: rawThinking, ...unsupported } = kwargs;
         const unsupportedKwargs = Object.keys(unsupported);
         if (unsupportedKwargs.length > 0) {
@@ -11146,7 +11530,6 @@ export class AgentSession {
             await this._assertRlmSubagentSessionNameAvailable(sessionName);
         admission.assertCurrent();
         const startedAt = Date.now();
-        let runningToolCount = 0;
         let childSession;
         let usageSettlement = Promise.resolve();
         const run = {
@@ -11168,6 +11551,8 @@ export class AgentSession {
                 throw new Error(run.error ?? "RLM child cancelled");
         };
         this._activeRlmChildRuns.set(run.id, run);
+        if (usageSource)
+            this._rlmChildUsageSources.set(run.id, usageSource);
         this._unsettledRlmChildRuns.add(run);
         const emitChildUpdate = () => {
             const child = this._rlmChildSnapshotForRun(run);
@@ -11258,88 +11643,12 @@ export class AgentSession {
                 throwIfCancelled();
                 run.status = "running";
                 emitChildUpdate();
-                const unsubscribeChildEvents = child.subscribe((event) => {
-                    if (event.type === "rlm_child_update") {
-                        this._emit(event);
-                        return;
-                    }
-                    if (event.type === "agent_start") {
-                        run.activity = { kind: "waiting" };
-                        emitChildUpdate();
-                    }
-                    else if (event.type === "agent_end") {
-                        run.activity = undefined;
-                        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((message) => message.role === "user" || message.role === "custom");
-                                    const origin = precedingPrompt?.role === "custom" && isAgentSessionMessage(precedingPrompt)
-                                        ? precedingPrompt.details.id.startsWith("spawn:")
-                                            ? "spawn_task"
-                                            : "agent_message"
-                                        : "direct_user";
-                                    const text = compactRlmText(readAssistantText(assistant));
-                                    const refreshOutput = this._refreshInvocationOutput;
-                                    const write = this.sessionManager
-                                        .appendChildUsageAttributionWithAggregate(parentEntryId, assistant.usage, undefined, origin)
-                                        .then(({ aggregateUsage }) => {
-                                        parentAssistantForUsage.usage = structuredClone(aggregateUsage);
-                                        refreshOutput?.(parentAssistantForUsage);
-                                        if (text)
-                                            run.answerPreview = text;
-                                        emitChildUpdate();
-                                    });
-                                    this._childUsageWrites.add(write);
-                                    usageSettlement = Promise.all([usageSettlement, write]).then(() => undefined);
-                                    void usageSettlement.catch(() => undefined);
-                                    void write.then(() => this._childUsageWrites.delete(write), (error) => {
-                                        this._childUsageWrites.delete(write);
-                                        run.error = `Child usage attribution was not acknowledged: ${this._asError(error).message}`;
-                                        this._surfaceSessionInputError(error);
-                                    });
-                                    return;
-                                }
-                            }
-                        }
-                        const text = compactRlmText(readAssistantText(assistant));
-                        if (text)
-                            run.answerPreview = text;
-                        emitChildUpdate();
-                    }
-                    else if (event.type === "message_start" || event.type === "message_update") {
-                        if (event.message.role === "assistant") {
-                            const text = compactRlmText(readAssistantText(event.message));
-                            if (text)
-                                run.answerPreview = text;
-                            run.activity = { kind: "writing" };
-                            emitChildUpdate();
-                        }
-                    }
-                    else if (event.type === "tool_execution_start") {
-                        run.toolUseCount += 1;
-                        runningToolCount += 1;
-                        run.activity = { kind: "executing", toolName: event.toolName };
-                        emitChildUpdate();
-                    }
-                    else if (event.type === "tool_execution_end") {
-                        runningToolCount = Math.max(0, runningToolCount - 1);
-                        if (runningToolCount === 0)
-                            run.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(run.id, child, run, (write) => {
+                    usageSettlement = Promise.all([usageSettlement, write]).then(() => undefined);
+                    void usageSettlement.catch(() => undefined);
                 });
                 run.unsubscribe = unsubscribeChildEvents;
                 const content = `[task from parent]\n\n${prompt}`;
@@ -11367,8 +11676,19 @@ export class AgentSession {
                     source: "extension",
                     customMessage: spawnMessage,
                 });
+                // promptAndWait can resolve after a provider error or abort. Only outcomes
+                // emitted during this run count; a recovered intermediate error is not terminal.
+                const terminal = run.terminalAssistantOutcome;
+                if (terminal?.stopReason === "aborted") {
+                    run.status = "cancelled";
+                    run.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 (run.error)
                     throw new Error(run.error);
                 run.status = "done";
@@ -12282,39 +12602,13 @@ export class AgentSession {
     _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: 16_384, 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 } : undefined;
-            }
-            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 } : undefined;
-        });
+        return this.sessionManager.readOwnUsageSummary();
     }
     /**
      * Build the agent context overview for /context: this session as the root
@@ -12384,7 +12678,12 @@ export class AgentSession {
                 ? { tokens: estimate.tokens, contextWindow, percent: (estimate.tokens / contextWindow) * 100 }
                 : { tokens: null, contextWindow, percent: null }
             : undefined;
-        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,