Make compact budget trimming linear

src/index.mjs

@@ -107,23 +107,29 @@ export function compact(payload, opts = {}) {
     m.content = kept;
   }
 
+  // Measure the transformed payload once, then keep the total additive while
+  // trimming so each dropped message is counted only once.
+  let after = analyzePayload(out, { counter }).totalTokens;
+
   // trim oldest non-system messages to fit a hard budget
   if (maxTokens != null) {
     const isSystem = (m) => (m.role || "") === "system";
     let i = 0;
-    while (analyzePayload(out, { counter }).totalTokens > maxTokens) {
+    while (after > maxTokens) {
       const list = Array.isArray(out) ? out : out.messages;
       const trimmableEnd = list.length - keepLastTurns;
       // find the oldest non-system, trimmable message
       let idx = -1;
       for (let j = 0; j < Math.max(0, trimmableEnd); j++) { if (!isSystem(list[j])) { idx = j; break; } }
       if (idx < 0) break; // nothing left safe to drop
+      const removed = list[idx];
+      after -= blocksOf(removed.content, removed.role || "user")
+        .reduce((total, unit) => total + counter(unit.text), 0);
       list.splice(idx, 1);
       actions.push("drop:oldest-message");
       if (++i > 1000) break;
     }
   }
 
-  const after = analyzePayload(out, { counter }).totalTokens;
   return { payload: out, report: { beforeTokens: before, afterTokens: after, savedTokens: before - after, savedPct: before ? Math.round(((before - after) / before) * 100) : 0, actions } };
 }

test/basic.test.mjs

@@ -50,3 +50,27 @@ test("compact trims oldest messages to a hard budget, keeps system", () => {
   assert.ok(report.afterTokens <= 300 || report.savedTokens > 0);
   assert.equal(out.messages[0].role, "system");
 });
+
+test("compact trims a large payload with linear token counting", () => {
+  const messages = Array.from({ length: 500 }, (_, i) => ({
+    role: "user",
+    content: `message-${i}`,
+  }));
+  let counterCalls = 0;
+  const counter = () => {
+    counterCalls++;
+    return 1;
+  };
+
+  const { payload: out, report } = compact(
+    { messages },
+    { maxTokens: 4, keepLastTurns: 4, dropDuplicates: false, counter },
+  );
+
+  assert.deepEqual(out.messages, messages.slice(-4));
+  assert.equal(report.beforeTokens, 500);
+  assert.equal(report.afterTokens, 4);
+  assert.equal(report.savedTokens, 496);
+  assert.equal(report.actions.length, 496);
+  assert.ok(counterCalls <= messages.length * 3, `counter called ${counterCalls} times`);
+});