@ponythewhite/base-context 1.0.10 → 1.0.11

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 { 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, } from "./context-epoch.js";
+import { appendContextEpoch, assertContextRequestContract, CONTEXT_EPOCH_DETAIL, CONTEXT_SKILL_EPOCH_RENDERER, contextEpochMode, contextEpochRepresentation, contextRequestContract, 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";
@@ -32,7 +32,7 @@ import { convertToLlm, createCompactionOutcomeMessage, createHeartbeatPromptMess
 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 { 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";
@@ -616,7 +617,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 +667,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"
@@ -4755,7 +4789,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 +7761,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 +7778,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 +7801,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 +7899,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 +8592,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") {
@@ -8935,7 +8994,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 +9095,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);
@@ -9063,7 +9122,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 +9168,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 +9304,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") ||
@@ -12282,39 +12348,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