fix(core): auto-compaction never fires because activeTokens uses single-response total

activeTokens was set to getTotalTokens(responseUsage), i.e. the token count
of only the latest response. Since each individual call stays below the
autoCompactWindow threshold, session.activeTokens never crosses it and
auto-compaction never triggers. Long sessions keep resending their full
history on every turn, causing runaway token usage.

Fix:
- activeTokens now accumulates: (entry.activeTokens ?? 0) + getTotalTokens(responseUsage)
- reset activeTokens to 0 after compaction so it does not re-trigger immediately

Add regression tests (auto-compact.test.ts) and update the two existing
session tests that asserted the old single-response behavior.

Author: raymondginger2018-sudo

packages/core/src/session.ts

@@ -1567,7 +1567,7 @@ ${agentInstructions}
               toolCalls,
               usage: accumulateUsage(entry.usage, responseUsage),
               usagePerModel: accumulateUsagePerModel(entry.usagePerModel, model, responseUsage),
-              activeTokens: getTotalTokens(responseUsage),
+              activeTokens: (entry.activeTokens ?? 0) + getTotalTokens(responseUsage),
               status: "ask_permission",
               failReason: null,
               askPermissions: permissionPlan.askPermissions,
@@ -1593,7 +1593,7 @@ ${agentInstructions}
           toolCalls,
           usage: accumulateUsage(entry.usage, responseUsage),
           usagePerModel: accumulateUsagePerModel(entry.usagePerModel, model, responseUsage),
-          activeTokens: getTotalTokens(responseUsage),
+          activeTokens: (entry.activeTokens ?? 0) + getTotalTokens(responseUsage),
           status: refusal ? "failed" : waitingForUser ? "waiting_for_user" : toolCalls ? "processing" : "completed",
           failReason: refusal ? refusal : entry.failReason,
           askPermissions: undefined,
@@ -1706,7 +1706,8 @@ ${agentInstructions}
       ...entry,
       usage: accumulateUsage(entry.usage, responseUsage),
       usagePerModel: accumulateUsagePerModel(entry.usagePerModel, model, responseUsage),
-      activeTokens: getTotalTokens(responseUsage),
+      // 压缩后上下文已精简, 重置 activeTokens 避免立即再次触发压缩
+      activeTokens: 0,
       updateTime: now,
     }));
 

packages/core/src/tests/auto-compact.test.ts

@@ -0,0 +1,65 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { getCompactPromptTokenThreshold } from "../session";
+
+/**
+ * Regression test for auto-compaction bug:
+ * activeTokens was set to the *single response* total_tokens instead of a
+ * running counter. Because each individual call stays below the threshold,
+ * auto-compaction never fired, so long sessions kept resending their full
+ * history on every turn and blew up token usage.
+ *
+ * The fix (session.ts):
+ *   activeTokens = (entry.activeTokens ?? 0) + getTotalTokens(responseUsage)
+ *   → running context counter that grows with each response
+ *   activeTokens = 0 after compaction
+ *   → reset so it does not re-trigger immediately on the next turn
+ */
+describe("auto-compact activeTokens accumulation", () => {
+  it("accumulated activeTokens eventually crosses the threshold (buggy single-response never does)", () => {
+    const threshold = getCompactPromptTokenThreshold("deepseek-v4-flash");
+    // Each single response is far below the threshold
+    const singleTotal = 30_000;
+    assert.ok(singleTotal < threshold, "single response must stay under threshold");
+
+    // Buggy behavior: activeTokens = getTotalTokens(responseUsage) — single response, never crosses
+    const buggyActive = singleTotal;
+    // Fixed behavior: activeTokens = previous + responseTotal (running counter)
+    let activeTokens = 0;
+    let fixedCrossed = false;
+
+    // Simulate many turns in one long session
+    for (let i = 0; i < 50; i += 1) {
+      activeTokens += singleTotal;
+      if (activeTokens > threshold) {
+        fixedCrossed = true;
+        activeTokens = 0; // reset after compaction
+      }
+    }
+
+    assert.equal(fixedCrossed, true, "fixed logic must trigger compaction at some point");
+    assert.ok(buggyActive < threshold, "buggy single-response activeTokens stays under threshold forever");
+  });
+
+  it("resetting activeTokens after compaction prevents immediate re-trigger", () => {
+    const threshold = getCompactPromptTokenThreshold("deepseek-v4-flash");
+    const bigTotal = 120_000;
+    let activeTokens = 0;
+    let compactions = 0;
+
+    for (let i = 0; i < 100; i += 1) {
+      activeTokens += bigTotal;
+      if (activeTokens > threshold) {
+        compactions += 1;
+        activeTokens = 0; // reset after compaction
+      }
+    }
+
+    assert.ok(compactions >= 1, "should have compacted at least once");
+    // Reset prevents runaway: with 120k/call and ~524k threshold, at least 4 calls
+    // must pass before the next compaction. 100 calls → at most ~25 compactions,
+    // and never one on every call.
+    const maxBounded = Math.ceil(100 / 4);
+    assert.ok(compactions <= maxBounded, `compactions=${compactions} should be bounded by ${maxBounded}`);
+  });
+});

packages/core/src/tests/session.test.ts

@@ -3260,7 +3260,8 @@ test("SessionManager accumulates response usage while active tokens track the la
   const session = manager.getSession(sessionId);
   const usage = session?.usage as Record<string, any>;
   const usagePerModel = session?.usagePerModel?.["test-model"] as Record<string, any>;
-  assert.equal(session?.activeTokens, 27);
+  // activeTokens 现在跟踪累计 total_tokens (修复: 之前是单次响应的 27)
+  assert.equal(session?.activeTokens, 42);
   assert.equal(usage.prompt_tokens, 30);
   assert.equal(usage.completion_tokens, 12);
   assert.equal(usage.total_tokens, 42);