fix: address multi-model code review findings on PR #35

- Fix text-end overwriting time.start (processor.ts) — use spread to
  preserve original start timestamp, matching reasoning-end handler
- Guard negative usable in isOverflow (compaction.ts) — return false
  when headroom exceeds base instead of producing negative usable that
  would trigger compaction on every turn
- Remove dead "manual" trigger type from telemetry union
- Add tests for negative usable edge cases

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: anandgupta42

packages/altimate-code/src/session/compaction.ts

@@ -85,8 +85,9 @@ export namespace SessionCompaction {
     const maxOutput = ProviderTransform.maxOutputTokens(input.model)
     const reserved = config.compaction?.reserved ?? COMPACTION_BUFFER
     const headroom = Math.max(reserved, maxOutput)
-    const usable = (input.model.limit.input ?? context) - headroom
-    return count >= usable
+    const base = input.model.limit.input ?? context
+    if (base <= headroom) return false
+    return count >= base - headroom
   }
 
   export const PRUNE_MINIMUM = 20_000

packages/altimate-code/src/session/processor.ts

@@ -374,7 +374,7 @@ export namespace SessionProcessor {
                     )
                     currentText.text = textOutput.text
                     currentText.time = {
-                      start: Date.now(),
+                      ...currentText.time,
                       end: Date.now(),
                     }
                     if (value.providerMetadata) currentText.metadata = value.providerMetadata

packages/altimate-code/src/telemetry/index.ts

@@ -97,7 +97,7 @@ export namespace Telemetry {
         type: "compaction_triggered"
         timestamp: number
         session_id: string
-        trigger: "overflow_detection" | "error_recovery" | "manual"
+        trigger: "overflow_detection" | "error_recovery"
         attempt: number
       }
     | {

packages/altimate-code/test/session/compaction-loop.test.ts

@@ -534,6 +534,33 @@ describe("session.compaction.isOverflow boundary conditions", () => {
     })
   })
 
+  test("returns false when headroom exceeds base (negative usable guard)", async () => {
+    await using tmp = await tmpdir()
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        // Tiny model: input=32K, output=128K → headroom=128K > base=32K
+        // Without guard this would produce negative usable and always trigger
+        const model = createModel({ context: 200_000, input: 32_000, output: 128_000 })
+        const tokens = { input: 1_000, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
+        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(false)
+      },
+    })
+  })
+
+  test("returns false when headroom equals base exactly", async () => {
+    await using tmp = await tmpdir()
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        // headroom = max(20K, 32K) = 32K, base = 32K → usable = 0
+        const model = createModel({ context: 32_000, output: 32_000 })
+        const tokens = { input: 1_000, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
+        expect(await SessionCompaction.isOverflow({ tokens, model })).toBe(false)
+      },
+    })
+  })
+
   test("compaction disabled via prune config still allows isOverflow", async () => {
     await using tmp = await tmpdir({
       init: async (dir) => {