@ponythewhite/base-context 1.0.11 → 1.0.12

package/dist/core/agent-session.js

@@ -16,8 +16,8 @@ import { addAutonomousContinuation, addAutonomousUsage, autonomousStatus, create
 import { executeBashWithOperations } from "./bash-executor.js";
 import { stringifyBoundedJson } from "./bounded-json.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, 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, UnsupportedContextEpochConfigurationError, } from "./context-epoch.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,10 +28,10 @@ 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 { 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";
@@ -45,7 +45,7 @@ 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 { hydrateCapturedHistoryEntry, } from "./session-history-index.js";
 import { exportSessionBranchToJsonl } from "./session-jsonl-export.js";
 import { getLatestCompactionEntry, SessionManager, } from "./session-manager.js";
 import { getPythonSkillRuntimeInfo } from "./skills.js";
@@ -192,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() { }
@@ -436,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;
@@ -560,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 };
@@ -2950,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;
@@ -3314,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:
@@ -4382,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.
@@ -4477,6 +4484,7 @@ export class AgentSession {
                 session.dispose();
             }
             this._rlmChildSessions.clear();
+            this._rlmChildUsageSources.clear();
             this._rlmChildCleanupFailures.clear();
             this._deletedRlmChildIds.clear();
             this._pendingNextTurnMessages = [];
@@ -4721,6 +4729,7 @@ export class AgentSession {
             rlmDepth: this._rlmDepth,
             rlmParentAgent: this._rlmParentAgent,
             harnessState: this._loadMergedHarnessState(),
+            harnessSection: "instructions",
             errorFixSelection: {
                 enabled: this.settingsManager.getLearningEnabled(),
                 tools: validToolNames,
@@ -4733,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;
@@ -8928,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 });
             }
@@ -9111,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) {
@@ -10691,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) {
@@ -10776,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
@@ -10808,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) {
@@ -10819,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();
             };
         }
@@ -10828,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();
         };
     }
@@ -10956,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;
@@ -11000,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
@@ -11167,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) {
@@ -11212,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 = {
@@ -11234,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);
@@ -11324,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}`;
@@ -11433,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";
@@ -12424,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,