🤖 fix: clear stale usage state when history is rewritten so the next send does not auto-compact

jest.config.js

@@ -29,8 +29,9 @@ module.exports = {
     "\\.txt$": "<rootDir>/tests/__mocks__/textMock.js",
     "\\.svg$": "<rootDir>/tests/__mocks__/svgMock.js",
   },
-  // Storybook UI tests use bun:test and are run via `bun test`, so Jest must skip them.
-  testPathIgnorePatterns: ["<rootDir>/tests/ui/storybook/"],
+  // Storybook UI tests and the DOM isolation guards use bun:test and are run
+  // via `bun test`, so Jest must skip them.
+  testPathIgnorePatterns: ["<rootDir>/tests/ui/storybook/", "<rootDir>/tests/ui/domIsolation"],
   // Avoid haste module collision with vscode extension
   modulePathIgnorePatterns: ["<rootDir>/vscode/"],
   transform: {

src/node/services/agentSession.autoCompaction.test.ts

@@ -12,6 +12,7 @@ import {
   type MuxMessage,
 } from "@/common/types/message";
 import { GOAL_CONTINUATION_KIND } from "@/constants/goals";
+import type { AutoCompactionUsageState } from "@/common/utils/compaction/autoCompactionCheck";
 import { Ok, Err } from "@/common/types/result";
 import type { Config } from "@/node/config";
 import type { AIService } from "@/node/services/aiService";
@@ -854,6 +855,24 @@ describe("AgentSession on-send auto-compaction snapshot deferral", () => {
     session.dispose();
   });
 
+  test("heartbeat context reset clears stale usage before its follow-up dispatches", async () => {
+    const workspaceId = "ws-heartbeat-reset-clears-usage";
+    const { session } = await createSessionHarness({ workspaceId });
+
+    const sessionState = session as unknown as { lastUsageState?: AutoCompactionUsageState };
+    sessionState.lastUsageState = { totalTokens: 95_000 };
+
+    const result = await session.appendHeartbeatContextResetBoundary({
+      boundaryText: "Heartbeat context reset boundary",
+      pendingFollowUp: { text: "heartbeat follow-up", model: "openai:gpt-4o", agentId: "exec" },
+    });
+
+    expect(result.success).toBe(true);
+    expect(sessionState.lastUsageState).toBeUndefined();
+
+    session.dispose();
+  });
+
   test("surfaces nested dispatch failures after mid-stream compaction interrupt", async () => {
     const workspaceId = "ws-auto-compaction-mid-stream-dispatch-failure";
 

src/node/services/agentSession.ts

@@ -2737,7 +2737,9 @@ export class AgentSession {
         this.workspaceId,
         truncateTargetId
       );
-      if (!truncateResult.success) {
+      if (truncateResult.success) {
+        this.clearUsageState();
+      } else {
         const isMissingEditTarget =
           truncateResult.error.includes("Message with ID") &&
           truncateResult.error.includes("not found in history");
@@ -3418,6 +3420,16 @@ export class AgentSession {
     };
   }
 
+  /**
+   * Invalidate cached context usage after the active provider context is
+   * rewritten (boundary append, truncation, history replacement): stale usage
+   * would make the next send auto-compact the already-rewritten context. The
+   * next send re-seeds from post-rewrite history.
+   */
+  clearUsageState(): void {
+    this.lastUsageState = undefined;
+  }
+
   /**
    * Persist a manual user message + emit a stream-error chat event when a
    * pre-stream gate (e.g. the unpriced-model budget gate) rejects a send.
@@ -4596,6 +4608,8 @@ export class AgentSession {
       return false;
     }
 
+    this.clearUsageState();
+
     // This clear bypasses WorkspaceService.replaceHistory, so announce it on the chat funnel the
     // timeline already consumes: a log that cannot explain missing history defeats its purpose.
     this.emitChatEvent({
@@ -5196,7 +5210,7 @@ export class AgentSession {
 
           // Compaction collapses history to a boundary summary, so prior context-usage snapshots
           // are stale. Clear them to prevent immediate re-trigger loops on the follow-up turn.
-          this.lastUsageState = undefined;
+          this.clearUsageState();
 
           if (completedCompactionRequest?.source === "auto-compaction") {
             this.emitChatEvent({
@@ -6724,6 +6738,7 @@ export class AgentSession {
       pendingFollowUp: params.pendingFollowUp,
     });
     if (result.success) {
+      this.clearUsageState();
       this.onPostCompactionStateChange?.();
     }
     return result;

src/node/services/workspaceService.test.ts

@@ -2,6 +2,9 @@ import { describe, expect, test, mock, beforeEach, afterEach, spyOn, type Mock }
 import { WorkspaceService, generateForkBranchName, generateForkTitle } from "./workspaceService";
 import type { IdleCompactionOutcome } from "./idleCompactionService";
 import type { AgentSession } from "./agentSession";
+import { createAgentSessionHarness } from "./agentSession.testHarness";
+import type { AutoCompactionUsageState } from "@/common/utils/compaction/autoCompactionCheck";
+import { createDisplayUsage } from "@/common/utils/tokens/displayUsage";
 import { askUserQuestionManager } from "./askUserQuestionManager";
 import { WorkspaceLifecycleHooks } from "./workspaceLifecycleHooks";
 import { EventEmitter } from "events";
@@ -4273,6 +4276,184 @@ describe("WorkspaceService truncateHistory goal acknowledgment", () => {
     }
   });
 
+  test("start-here replacement clears stale usage so the next send does not auto-compact", async () => {
+    const { config, historyService, workspaceService, cleanup } = await createServices();
+    const workspaceId = "start-here-clears-usage-state";
+    const streamMessage = mock((..._args: unknown[]) => Promise.resolve(Ok(undefined)));
+    const harness = await createAgentSessionHarness({
+      workspaceId,
+      config,
+      historyService,
+      aiServiceOverrides: {
+        streamMessage: streamMessage as unknown as AIService["streamMessage"],
+      },
+    });
+    try {
+      await config.addWorkspace("/tmp/start-here-usage-project", {
+        id: workspaceId,
+        name: workspaceId,
+        projectName: "start-here-usage-project",
+        projectPath: "/tmp/start-here-usage-project",
+        runtimeConfig: { type: "local" },
+      });
+      expect(
+        (
+          await historyService.appendToHistory(
+            workspaceId,
+            createMuxMessage("pre-start-here-user", "user", "long conversation", {})
+          )
+        ).success
+      ).toBe(true);
+      expect(
+        (
+          await historyService.appendToHistory(
+            workspaceId,
+            createMuxMessage("pre-start-here-assistant", "assistant", "long reply", {
+              model: "openai:gpt-4o",
+              contextUsage: { inputTokens: 95_000, outputTokens: 200, totalTokens: 95_200 },
+            })
+          )
+        ).success
+      ).toBe(true);
+
+      (workspaceService as unknown as { sessions: Map<string, AgentSession> }).sessions.set(
+        workspaceId,
+        harness.session
+      );
+      // In-memory snapshot the previous stream left behind: 95k exceeds 70% of
+      // gpt-4o's 128k window, so a send with this state would auto-compact.
+      (harness.session as unknown as { lastUsageState?: AutoCompactionUsageState }).lastUsageState =
+        {
+          lastContextUsage: createDisplayUsage(
+            { inputTokens: 95_000, outputTokens: 200, totalTokens: 95_200 },
+            "openai:gpt-4o"
+          ),
+        };
+
+      const replaceResult = await workspaceService.replaceHistory(
+        workspaceId,
+        createMuxMessage("start-here-summary", "assistant", "Start Here summary", {
+          compacted: "user",
+        }),
+        { mode: "append-compaction-boundary" }
+      );
+      expect(replaceResult.success).toBe(true);
+
+      const sendResult = await harness.session.sendMessage("follow-up after start here", {
+        model: "openai:gpt-4o",
+        agentId: "exec",
+      });
+      expect(sendResult.success).toBe(true);
+
+      const activeWindow = await historyService.getHistoryFromLatestBoundary(workspaceId);
+      expect(activeWindow.success).toBe(true);
+      const activeMessages = activeWindow.success ? activeWindow.data : [];
+      expect(
+        activeMessages.filter(
+          (message) => message.metadata?.muxMetadata?.type === "compaction-request"
+        )
+      ).toHaveLength(0);
+      const followUp = activeMessages.find((message) => message.role === "user");
+      expect(followUp?.parts[0]).toMatchObject({
+        type: "text",
+        text: "follow-up after start here",
+      });
+      expect(streamMessage).toHaveBeenCalledTimes(1);
+    } finally {
+      harness.session.dispose();
+      await cleanup();
+    }
+  });
+
+  test("context reset clears stale session usage state", async () => {
+    const { config, historyService, workspaceService, cleanup } = await createServices();
+    const workspaceId = "context-reset-clears-usage-state";
+    try {
+      await config.addWorkspace("/tmp/context-reset-usage-project", {
+        id: workspaceId,
+        name: workspaceId,
+        projectName: "context-reset-usage-project",
+        projectPath: "/tmp/context-reset-usage-project",
+        runtimeConfig: { type: "local" },
+      });
+      expect(
+        (
+          await historyService.appendToHistory(
+            workspaceId,
+            createMuxMessage("pre-reset-user", "user", "before reset", {})
+          )
+        ).success
+      ).toBe(true);
+
+      const clearUsageState = mock(() => undefined);
+      const session = {
+        isBusy: mock(() => false),
+        hasQueuedMessages: mock(() => false),
+        isPreparingTurn: mock(() => false),
+        hasPendingAutoRetry: mock(() => false),
+        emitChatEvent: mock(() => undefined),
+        clearUsageState,
+        clearFileState: mock(() => undefined),
+      } as unknown as AgentSession;
+      (workspaceService as unknown as { sessions: Map<string, AgentSession> }).sessions.set(
+        workspaceId,
+        session
+      );
+
+      expect(await workspaceService.resetContext(workspaceId)).toEqual({
+        success: true,
+        data: "reset",
+      });
+
+      expect(clearUsageState).toHaveBeenCalledTimes(1);
+    } finally {
+      await cleanup();
+    }
+  });
+
+  test("full history clear clears stale session usage state", async () => {
+    const { config, historyService, workspaceService, cleanup } = await createServices();
+    const workspaceId = "full-clear-clears-usage-state";
+    try {
+      await config.addWorkspace("/tmp/full-clear-usage-project", {
+        id: workspaceId,
+        name: workspaceId,
+        projectName: "full-clear-usage-project",
+        projectPath: "/tmp/full-clear-usage-project",
+        runtimeConfig: { type: "local" },
+      });
+      expect(
+        (
+          await historyService.appendToHistory(
+            workspaceId,
+            createMuxMessage("pre-clear-user", "user", "before clear", {})
+          )
+        ).success
+      ).toBe(true);
+
+      const clearUsageState = mock(() => undefined);
+      const session = {
+        isBusy: mock(() => false),
+        emitChatEvent: mock(() => undefined),
+        clearUsageState,
+        clearFileState: mock(() => undefined),
+      } as unknown as AgentSession;
+      (workspaceService as unknown as { sessions: Map<string, AgentSession> }).sessions.set(
+        workspaceId,
+        session
+      );
+
+      // A zero-percentage truncation rewrites nothing, so usage must survive.
+      expect((await workspaceService.truncateHistory(workspaceId, 0)).success).toBe(true);
+      expect(clearUsageState).toHaveBeenCalledTimes(0);
+
+      expect((await workspaceService.truncateHistory(workspaceId, 1.0)).success).toBe(true);
+      expect(clearUsageState).toHaveBeenCalledTimes(1);
+    } finally {
+      await cleanup();
+    }
+  });
+
   test("context reset is a no-op when repeated without provider-eligible messages", async () => {
     const { config, historyService, workspaceService, cleanup } = await createServices();
     const workspaceId = "context-reset-noop";

src/node/services/workspaceService.ts

@@ -9677,6 +9677,10 @@ export class WorkspaceService extends EventEmitter {
       return Err(truncateResult.error);
     }
 
+    if (effectivePercentage > 0) {
+      session?.clearUsageState();
+    }
+
     const deletedSequences = truncateResult.data;
     if (deletedSequences.length > 0) {
       const deleteMessage: DeleteMessage = {
@@ -9758,6 +9762,8 @@ export class WorkspaceService extends EventEmitter {
         return Err(`Failed to append context reset boundary: ${appendResult.error}`);
       }
 
+      session?.clearUsageState();
+
       const typedBoundaryMessage = { ...boundaryMessage, type: "message" as const };
       if (session) {
         session.emitChatEvent(typedBoundaryMessage);
@@ -9868,6 +9874,8 @@ export class WorkspaceService extends EventEmitter {
         if (!clearResult.success) {
           return Err(`Failed to clear history: ${clearResult.error}`);
         }
+        // History is already gone even if the summary append below fails.
+        this.sessions.get(workspaceId)?.clearUsageState();
         this.timelineRecorder.record(workspaceId, {
           kind: "history.cleared",
           source: { system: "chat" },
@@ -9883,6 +9891,7 @@ export class WorkspaceService extends EventEmitter {
 
       // Emit through the session so ORPC subscriptions receive the events
       const session = this.sessions.get(workspaceId);
+      session?.clearUsageState();
       if (deletedSequences.length > 0) {
         const deleteMessage: DeleteMessage = {
           type: "delete",

tests/ui/dom.ts

@@ -225,6 +225,16 @@ export function installDom(): () => void {
       previous.IntersectionObserver;
     (globalThis as unknown as { ResizeObserver?: unknown }).ResizeObserver =
       previous.ResizeObserver;
+
+    // Self-heal: some test files tear down with `globalThis.document = undefined`.
+    // If that poison leaked into our snapshot, restoring it would propagate a
+    // document-less environment (with baseline observers still present) to later
+    // test files, crashing module evals that probe the DOM (e.g. @react-dnd/asap
+    // calls document.createTextNode when MutationObserver exists). Re-bootstrap a
+    // baseline instead of re-exposing the poisoned snapshot.
+    if (typeof globalThis.document === "undefined") {
+      installDom();
+    }
   };
 }
 
@@ -243,3 +253,15 @@ export function installDom(): () => void {
 if (typeof globalThis.document === "undefined") {
   installDom();
 }
+
+// Evaluate react-dnd's module graph once while the DOM baseline is healthy.
+// bun test runs every file in one process; if a poisoned environment (document
+// undefined, MutationObserver present) reaches react-dnd's first evaluation,
+// @react-dnd/asap throws at module scope and leaves the package's internal
+// exports in TDZ, so every later import (including `?real=1` re-evals) fails
+// with "Cannot access 'DragPreviewImage' before initialization". Caching the
+// healthy evaluation here makes later re-evals resolve initialized internals.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+require("react-dnd");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+require("react-dnd-html5-backend");