@ponythewhite/base-context 1.0.7 → 1.0.8

package/dist/core/agent-session.js

@@ -5,7 +5,7 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { Agent, AgentContinueError, AgentOutputLimitError, } from "@ponythewhite/base-context-agent";
-import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, isTransientProviderFailure, modelsAreEqual, resetApiProviders, supportsFastMode, } from "@ponythewhite/base-context-ai";
+import { clampThinkingLevel, cleanupSessionResources, conservativeTextTokenCost, getSupportedThinkingLevels, isContextOverflow, isTransientProviderFailure, modelsAreEqual, resetApiProviders, supportsFastMode, } from "@ponythewhite/base-context-ai";
 import { theme } from "../modes/interactive/theme/theme.js";
 import { PRODUCT } from "../product-identity.js";
 import { sleep } from "../utils/sleep.js";
@@ -31,13 +31,13 @@ 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 { throwIfPromptAdmissionCancelled } from "./prompt-admission.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
-import { appendGlobalRefinement, applyRefinementProposal, generateRefinementId, getGlobalHarnessStateDir, getLocalHarnessStateDir, getRefinementHistory, inferRefinementResultScope, loadGlobalRefinementHistory, loadHarnessState, mergeHarnessStates, mergeRefinementHistory, normalizeRefinementProposal, planRefinement, prepareRefinementApplication, REFINE_SKILL_NAME, reviewAutoRefine, saveHarnessState, takeNativePlannerRequestWrite, withRefinementBaseline, } from "./refinement/index.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 { 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";
 import { captureSelectedSkill, captureSkillDescriptor, readSkillSelection, sameSelectedSkills, selectedSkillBlock, selectedSkillIdentity, } from "./selected-skills.js";
-import { createNativeRecoveryRefusal, DEFAULT_NATIVE_RECOVERY_LIMITS, NativeRecoveryBudgetRefusal, parseNativeRecoveryInput, recoverCapturedHistory, } from "./selective-recovery.js";
+import { createNativeRecoveryRefusal, DEFAULT_NATIVE_RECOVERY_LIMITS, NativeRecoveryBudgetRefusal, NativeRecoveryCursorStore, parseNativeRecoveryInput, recoverCapturedHistory, } from "./selective-recovery.js";
 import { modelRequestHeaders, SemanticEdgeRecorder, semanticEdgeLedgerPath, wrapStreamFnWithSemanticEdges, } from "./semantic-edges.js";
 import { ActionStore, canSelectSessionAction, queuedMessageLaneDeliveryPolicy, transitionSessionAction, } from "./session-action-store.js";
 import { readSessionBootstrap } from "./session-bootstrap.js";
@@ -281,6 +281,7 @@ export class AgentSession {
     requests;
     runtimeServices;
     _contextCompiler = new CanonicalContextCompiler();
+    _failedAutomaticCompaction;
     _contextEpochsEnabled;
     _initialContextMode;
     _contextMode;
@@ -444,6 +445,8 @@ export class AgentSession {
     _modelRegistry;
     _toolRegistry = new Map();
     _nativeRecoveryTools = new WeakMap();
+    _nativeRecoveryCursors = new NativeRecoveryCursorStore();
+    _nativeRecoveryCursorSource;
     _nativeRecoveryProducer = new AsyncLocalStorage();
     _toolDefinitions = new Map();
     _toolPromptSnippets = new Map();
@@ -452,6 +455,7 @@ export class AgentSession {
     _baseSystemPromptOptions;
     _assistantTurnsSinceAutoRefine = 0;
     _lastAutoRefineReviewAt = 0;
+    _lastAutoRefineEvidence;
     _autoRefineInProgress = false;
     _autoRefineAdmissionClosed = false;
     _autoRefineOperations = new Set();
@@ -610,7 +614,8 @@ export class AgentSession {
                 const epochContext = getCanonicalEpochContext(messages);
                 if (epochContext)
                     this._contextMode = epochContext.mode;
-                const unbudgetedPublic = !contextEpochsEnabled && Boolean(epochContext?.toolContinuations?.length);
+                const unbudgetedPublic = !contextEpochsEnabled &&
+                    Boolean(epochContext?.toolContinuations?.length || epochContext?.taskFrameRebased || epochContext?.checkpoint);
                 const nativeSkills = Boolean(contextEpochsEnabled || epochContext?.checkpoint || unbudgetedPublic);
                 const skillPolicy = nativeSkills ? (this._nativeRecoveryEnabled() ? "enabled" : "unavailable") : undefined;
                 if (this._baseSystemPromptOptions.nativeSkillSelection !== skillPolicy) {
@@ -637,6 +642,7 @@ export class AgentSession {
                             message.content.some((part) => part.type !== "text" || part.textSignature !== undefined)));
                     let accepted;
                     let acceptedBody;
+                    let acceptedResponseIdentity;
                     let acceptedReplayContract;
                     let acknowledged;
                     const commitFailure = (cause) => {
@@ -656,7 +662,7 @@ 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);
+                        const representation = contextEpochRepresentation(candidate.request, candidate.assessment, limits.maxSourceBytes, unbudgetedPublic, candidate.responseItemIdentity);
                         const replayContract = "replayContract" in candidate.projection &&
                             candidate.projection.replayContract === "message-groups"
                             ? "message-groups"
@@ -669,6 +675,7 @@ export class AgentSession {
                             candidate.publicMessages !== undefined,
                             candidate.selectedUnitIds,
                         ]);
+                        acceptedResponseIdentity = candidate.responseItemIdentity;
                         if (accepted !== undefined) {
                             if (accepted !== selection)
                                 throw new Error("Captured epoch request selection changed after acceptance");
@@ -738,12 +745,13 @@ export class AgentSession {
                                 }
                                 return;
                             }
+                            if (epochContext.taskFrameRebased && acceptedBody === undefined)
+                                throw new Error("Task frame rebase requires a committed epoch boundary");
                             if (!committed)
                                 return;
                             if (acceptedBody === undefined || request.body !== acceptedBody)
                                 throw new Error("Committed context epoch requires a compatible final provider projection");
-                            if (contextEpochRepresentation(request, assessment, limits.maxSourceBytes, unbudgetedPublic) !==
-                                committed.representation)
+                            if (contextEpochRepresentation(request, assessment, limits.maxSourceBytes, unbudgetedPublic, acceptedResponseIdentity) !== committed.representation)
                                 throw new Error("Context epoch representation changed without a committed boundary");
                             if (committed.resourceRevision !== epochContext.resourceRevision)
                                 throw new Error("Context epoch resource revision requires a committed boundary");
@@ -844,9 +852,41 @@ export class AgentSession {
                 error.source.sessionFile !== owner.sessionFile ||
                 error.source.leafId !== owner.manager.getLeafId())
                 return false;
+            // Rebase this captured frame before paying for a summary. The replacement still
+            // needs the normal full provider projection and epoch ACK before MAIN can send.
+            if (error.taskFrameRebaseAvailable) {
+                this._contextCompiler.requestTaskFrameRebase();
+                return "reprepare";
+            }
+            if (error.mandatoryAssessment?.status === "over-budget")
+                return false;
             // The loop released its unsent inference and captured projection before this handoff.
             // Continue in-place only after the real summary ACK and canonical owner adoption.
-            return this._runAutoCompaction("threshold", false, owner, true);
+            const key = error.getCompactionKey();
+            const current = {
+                key: key ?? "",
+                systemPrompt: this.agent.state.systemPrompt,
+                tools: this.agent.state.tools,
+                settings: JSON.stringify(this.settingsManager.getCompactionSettings()),
+            };
+            const failed = this._failedAutomaticCompaction;
+            if (key &&
+                failed &&
+                failed.key === key &&
+                failed.systemPrompt === current.systemPrompt &&
+                failed.tools === current.tools &&
+                failed.settings === current.settings)
+                return false;
+            this._failedAutomaticCompaction = undefined;
+            let succeeded = false;
+            try {
+                succeeded = await this._runAutoCompaction("threshold", false, owner, true, error);
+                return succeeded;
+            }
+            finally {
+                if (!succeeded && key && this._isCompactionSourceOwnerCurrent(owner))
+                    this._failedAutomaticCompaction = current;
+            }
         });
         this.agent.bindProviderFailureRecoveryOwner({
             recover: (message, signal) => this._handleRetryableError(message, signal),
@@ -4107,6 +4147,9 @@ export class AgentSession {
      * the latest state reaches disk instead of racing process exit.
      */
     async disposeAsync(options) {
+        this._failedAutomaticCompaction = undefined;
+        this._contextCompiler.clear();
+        this._nativeRecoveryCursors.clear();
         for (const admission of this._rlmChildAdmissions)
             admission.cancel("Parent session disposed");
         if (this._disposeAsyncPromise)
@@ -4340,6 +4383,9 @@ export class AgentSession {
         return this._disposeCallbacksPromise;
     }
     dispose() {
+        this._failedAutomaticCompaction = undefined;
+        this._contextCompiler.clear();
+        this._nativeRecoveryCursors.clear();
         if (this._disposed) {
             return;
         }
@@ -4583,7 +4629,7 @@ export class AgentSession {
         }
         return Array.from(unique);
     }
-    _rebuildSystemPrompt(toolNames, nativeEpoch = this.sessionManager.isPersisted() && this._contextEpochsEnabled) {
+    _rebuildSystemPrompt(toolNames, nativeEpoch = this.sessionManager.isPersisted() && this._contextEpochsEnabled, operation = this._baseSystemPromptOptions?.errorFixSelection?.operation) {
         const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));
         const toolSnippets = {};
         const promptGuidelines = [];
@@ -4617,6 +4663,14 @@ export class AgentSession {
             rlmDepth: this._rlmDepth,
             rlmParentAgent: this._rlmParentAgent,
             harnessState: this._loadMergedHarnessState(),
+            errorFixSelection: {
+                enabled: this.settingsManager.getLearningEnabled(),
+                tools: validToolNames,
+                operation,
+                goal: this._goalState.objective,
+                environment: { cwd: this._cwd, platform: process.platform },
+                countTokens: conservativeTextTokenCost,
+            },
             genericMcpServers: this._mcpManager?.getEnabledPersistentGenericServers(),
         };
         return buildSystemPrompt(this._baseSystemPromptOptions);
@@ -6099,6 +6153,12 @@ export class AgentSession {
                         const preparationAction = activeTurns().at(-1);
                         if (!preparationAction)
                             return undefined;
+                        if (this.settingsManager.getLearningEnabled() ||
+                            this._baseSystemPromptOptions.errorFixSelection?.enabled) {
+                            // Capture advice for this task before extensions and provider preparation.
+                            // Tool continuations keep the same prompt until the next task boundary.
+                            this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames(), this._baseSystemPromptOptions.nativeSkillSelection !== undefined, preparationAction.payload.text);
+                        }
                         const basePromptSnapshot = this._baseSystemPrompt;
                         const result = await this._extensionRunner.emitBeforeAgentStart(preparationAction.payload.text, preparationAction.payload.images, basePromptSnapshot, this._baseSystemPromptOptions);
                         if (activeTurns().at(-1) !== preparationAction)
@@ -7759,7 +7819,11 @@ export class AgentSession {
                 const summaryRequests = requests[captureNativeCompactionRequests]();
                 let summaryFailure;
                 try {
-                    nativeCompaction = await compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel, summaryCall, summaryRequests);
+                    nativeCompaction = await compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel, summaryCall, summaryRequests, options.capacity
+                        ? (wrapper) => options.capacity.remainingSummaryTokens(new Set(pathEntries
+                            .slice(pathEntries.findIndex((entry) => entry.id === preparation.firstKeptEntryId))
+                            .map((entry) => entry.id)), wrapper)
+                        : undefined);
                     ({ summary, firstKeptEntryId, tokensBefore, details, usage } = nativeCompaction);
                 }
                 catch (error) {
@@ -8320,9 +8384,9 @@ export class AgentSession {
             }
         }
         catch (error) {
-            // Auto-refine is opportunistic; manual /refine remains available.
-            // Stamp the cooldown so a persistently failing refine doesn't retry
-            // (via a retained pending review) on every agent end.
+            // Consume this exact automatic proposal after failure. New evidence can
+            // request a new review; manual /refine remains independent.
+            this._pendingAutoRefineReview = undefined;
             this._lastAutoRefineReviewAt = Date.now();
             if (error instanceof RefineSkippedError) {
                 // A skipped round is consumed like a reviewer decline, not retained for retry.
@@ -8362,7 +8426,78 @@ export class AgentSession {
             throw new Error(`autoRefine.model thinkingLevel ${selection.thinkingLevel} is not supported by ${selection.provider}/${selection.modelId}`);
         return { model: { ...model, cost: { ...model.cost } }, thinkingLevel: selection.thinkingLevel, explicit: true };
     }
+    async _autoRefineEvidence(harnessState) {
+        const manager = this.sessionManager;
+        const goalEvidence = ({ active, status, goalId, objective, tokenBudget, lastError }) => ({
+            active,
+            status,
+            goalId,
+            objective,
+            tokenBudget,
+            lastError,
+        });
+        const frontier = manager.supportsCapturedHistoryReads()
+            ? await manager.readBranchHistory(async (history) => {
+                const goal = (await history.branchBootstrap()).goalState;
+                const limits = this.settingsManager.getCanonicalContextLimits();
+                let goalState = emptyGoalState();
+                if (goal) {
+                    const hydrated = await history.hydrateEntry(goal.id, limits.maxSourceBytes);
+                    if (!hydrated ||
+                        hydrated.source.retention === "retained-import" ||
+                        hydrated.entry.type !== "custom" ||
+                        hydrated.entry.customType !== GOAL_STATE_CUSTOM_TYPE ||
+                        !isPersistedGoalState(hydrated.entry.data))
+                        throw new RefineSkippedError("Automatic refinement goal source is unavailable or ineligible");
+                    goalState = normalizeGoalState(hydrated.entry.data);
+                }
+                let id = history.source.leafId;
+                const maxEntries = limits.maxMessages;
+                for (let scanned = 0; scanned < maxEntries; scanned++) {
+                    const entry = id ? await history.get(id) : undefined;
+                    if (id && !entry)
+                        throw new RefineSkippedError("Automatic refinement task frontier is unavailable");
+                    const message = entry?.kind === "message" ? entry : undefined;
+                    if (message || !entry)
+                        return {
+                            sessionId: history.source.sessionId,
+                            sessionFile: history.source.sessionFile,
+                            message: message ? [message.id, message.revision] : undefined,
+                            goal: goalEvidence(goalState),
+                        };
+                    id = entry.parentId;
+                }
+                throw new RefineSkippedError("Automatic refinement task frontier exceeds the context read limit");
+            })
+            : (() => {
+                const branch = manager.getBranch().slice().reverse();
+                const message = branch.find((entry) => entry.type === "message");
+                return {
+                    sessionId: manager.getSessionId(),
+                    sessionFile: manager.getSessionFile(),
+                    message: message ? [message.id, message.timestamp] : undefined,
+                    goal: goalEvidence(this._loadPersistedGoalState()),
+                };
+            })();
+        return {
+            ...frontier,
+            systemPrompt: this.agent.state.systemPrompt,
+            model: JSON.stringify([this.model?.provider, this.model?.id, this.settingsManager.getAutoRefineModel()]),
+            harnessEntries: Object.fromEntries(Object.entries(harnessState.entries).map(([kind, entries]) => [
+                kind,
+                Object.fromEntries(Object.entries(entries).map(([id, { version: _version, created_at: _created, updated_at: _updated, ...entry }]) => [id, entry])),
+            ])),
+        };
+    }
     async _reviewAutoRefine(context, signal) {
+        const harnessState = this._loadMergedHarnessState();
+        const evidence = await this._autoRefineEvidence(harnessState);
+        signal?.throwIfAborted();
+        if (isDeepStrictEqual(evidence, this._lastAutoRefineEvidence))
+            return { shouldRefine: false, rationale: "No new task evidence since the previous automatic review." };
+        // Reserve before any inference wait. Equivalent running, declined or failed
+        // automatic reviews do not buy another call; explicit /refine stays independent.
+        this._lastAutoRefineEvidence = evidence;
         if (this._autoRefineReviewer)
             return this._autoRefineReviewer(context, signal);
         const selected = this._resolveRefinementModel();
@@ -8370,7 +8505,6 @@ export class AgentSession {
             return { shouldRefine: false, rationale: "No model selected." };
         const { model, thinkingLevel, explicit } = selected;
         const messages = structuredClone(this.agent.state.messages);
-        const harnessState = this._loadMergedHarnessState();
         const reviewContext = { ...context };
         const requests = this.requests[captureNativeReviewerRequests]();
         try {
@@ -8382,10 +8516,10 @@ export class AgentSession {
             await requests.dispose();
         }
     }
-    /** Global harness state overlaid with this session's local state, when persisted. */
+    /** Merge existing session/global memory with the selected project's workspace memory. */
     _loadMergedHarnessState() {
         const localHarnessStateDir = this._localHarnessStateDir();
-        return mergeHarnessStates(loadHarnessState(getGlobalHarnessStateDir(), "global"), localHarnessStateDir ? loadHarnessState(localHarnessStateDir, "local") : undefined);
+        return mergeHarnessStates(loadHarnessState(getGlobalHarnessStateDir(), "global"), localHarnessStateDir ? loadHarnessState(localHarnessStateDir, "local") : undefined, loadHarnessState(getWorkspaceHarnessStateDir(this._cwd), "workspace"));
     }
     async _loadRefinementHistory() {
         const limits = {
@@ -8843,7 +8977,21 @@ export class AgentSession {
         }
         if (!this._isCompactionOwnerCurrent(owner))
             return false;
-        const assistantIsFromBeforeCompaction = compactionTimestamp !== undefined && assistantMessage.timestamp <= compactionTimestamp;
+        let assistantIsFromBeforeCompaction = compactionTimestamp !== undefined && assistantMessage.timestamp <= compactionTimestamp;
+        const assistantEntryId = this._findAssistantEntryIdForMessage(assistantMessage);
+        if (assistantEntryId && owner.manager.supportsCapturedHistoryReads()) {
+            const ordered = await owner.manager.readBranchHistory(async (history) => {
+                const assistant = await history.get(assistantEntryId);
+                const boundary = (await history.branchBootstrap()).latestCompaction;
+                return assistant && boundary ? assistant.sequence <= boundary.sequence : undefined;
+            });
+            if (!this._isCompactionOwnerCurrent(owner))
+                return false;
+            // Provider messages are timestamped before request preparation, which may
+            // commit an epoch. Canonical append order, not that start time, owns staleness.
+            if (ordered !== undefined)
+                assistantIsFromBeforeCompaction = ordered;
+        }
         // Case 1: Overflow - takes priority over a pending model request so the error
         // strip + retry still happen; the compaction it runs consumes the request.
         if (!assistantIsFromBeforeCompaction &&
@@ -8935,7 +9083,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) {
+    async _runAutoCompaction(reason, willRetry, capturedOwner, resumeInPlace = false, capacity) {
         const checkpoint = this._pendingCheckpoint;
         const pending = this._pendingRequestedCompaction;
         const owner = checkpoint?.owner ?? pending?.owner ?? capturedOwner ?? this._captureCompactionOwner();
@@ -9018,6 +9166,7 @@ export class AgentSession {
                 signal: abort.signal,
                 // Only confirmed public-budget recovery resumes within the same invocation.
                 budgetPressure: resumeInPlace,
+                capacity,
             });
             const result = committed.result;
             // Release this captured source before arming success. A later release failure still carries the ACK.
@@ -9613,7 +9762,12 @@ export class AgentSession {
             producer?.skillOwner?.writer.assertCurrent();
             if (this.sessionManager !== manager)
                 throw new Error("Native recovery source changed");
-            return await manager.readBranchHistory((history) => recoverCapturedHistory(history.branchContext, request, { ...DEFAULT_NATIVE_RECOVERY_LIMITS, maxBytes: responseBytes }, signal));
+            const cursorSource = JSON.stringify([manager.getSessionId(), manager.getSessionFile()]);
+            if (this._nativeRecoveryCursorSource !== cursorSource) {
+                this._nativeRecoveryCursors.clear();
+                this._nativeRecoveryCursorSource = cursorSource;
+            }
+            return await manager.readBranchHistory((history) => recoverCapturedHistory(history.branchContext, request, { ...DEFAULT_NATIVE_RECOVERY_LIMITS, maxBytes: responseBytes }, signal, this._nativeRecoveryCursors));
         }
         catch (error) {
             signal?.throwIfAborted();
@@ -9762,6 +9916,7 @@ export class AgentSession {
             BASE_CONTEXT_RLM_DEPTH: String(this._rlmDepth),
             BASE_CONTEXT_RLM_MAX_DEPTH: String(this._rlmMaxDepth),
             BASE_CONTEXT_GLOBAL_HARNESS_STATE_DIR: getGlobalHarnessStateDir(),
+            BASE_CONTEXT_WORKSPACE_HARNESS_STATE_DIR: getWorkspaceHarnessStateDir(this._cwd),
         };
         const rlmSessionDir = this._ensureRlmSessionDir();
         if (rlmSessionDir) {
@@ -9854,15 +10009,13 @@ export class AgentSession {
         if (message?.role !== "assistant")
             return;
         if (this.sessionManager.isPersisted()) {
-            const acknowledged = this._assistantEntryIds.get(message);
-            if (!acknowledged ||
-                acknowledged.sessionId !== this.sessionId ||
-                acknowledged.sessionFile !== this.sessionFile)
+            const entryId = this._findAssistantEntryIdForMessage(message);
+            if (!entryId)
                 throw new Error("Cannot identify the acknowledged assistant response removed by retry control");
             if (this._contextOmissions?.sessionId !== this.sessionId ||
                 this._contextOmissions?.sessionFile !== this.sessionFile)
                 this._contextOmissions = { sessionId: this.sessionId, sessionFile: this.sessionFile, ids: new Set() };
-            this._contextOmissions.ids.add(acknowledged.entryId);
+            this._contextOmissions.ids.add(entryId);
         }
         this.agent.state.messages = messages.slice(0, -1);
     }