test(compaction): characterize ttl fire in the hysteresis gap

The TTL arm only defers while threshold arming is pending. After a
compact that stays over the high watermark, growth hysteresis clears
pending, so idle past the provider TTL still folds. Comments claimed
otherwise; keep the behavior and document it.

cacheTtlMsFor returns undefined only for missing, empty, or local
models; unknown strings get the default window.

Author: TheGreatAxios

src/agent/compaction.test.ts

@@ -921,6 +921,35 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     ).toBeNull();
   });
 
+  test("fires cache-ttl-recompress in the hysteresis gap (over-threshold, no growth)", () => {
+    // Characterization, not a bug: after a threshold compact, a post-compact
+    // infer at the same usage clears `pending` via growth hysteresis, so the
+    // threshold path no longer owns the session. Idle past the provider TTL
+    // still folds — same window- and cap-bounded path as under-threshold.
+    let nowMs = 70_000_000;
+    const governor = createCompactionGovernor(
+      () => undefined,
+      "",
+      [],
+      () => nowMs,
+    );
+    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
+    expect(
+      governor.interceptActions(toolDone(), inferAction, capabilities),
+    ).not.toBeNull();
+    expect(governor.resumeAfterCompact(emptyMessage())).toBe("infer");
+
+    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
+    expect(
+      governor.interceptActions(toolDone(), inferAction, capabilities),
+    ).toBeNull();
+
+    nowMs += 11 * MINUTE_MS;
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toEqual(ttlCompact);
+  });
+
   test("does not fold under an outstanding tool batch, fires once it settles", () => {
     let continuations = 0;
     let nowMs = 40_000_000;

src/agent/compaction.ts

@@ -290,17 +290,19 @@ export function createCompactionGovernor(
   // a cache play. Provider KV caches expire on their own schedule
   // (provider/cache-ttl.ts); compressing after that expiry makes the next
   // turn a cheaper write and later reads compound on the shrunk context. This
-  // fires under threshold — the threshold path above owns over-threshold —
-  // on any live re-entry once `now - lastCacheWrite >= ttl`. Guards, in
+  // fires on any live re-entry once `now - lastCacheWrite >= ttl`, including
+  // over-threshold sessions whose threshold path has disarmed (`pending` is
+  // false via growth hysteresis — the threshold path owns only armed
+  // over-threshold; the fold is still window- and cap-bounded). Guards, in
   // order: threshold arming defers (pending), the fresh-tail floor (turns at
   // or under it are all kept, so a fold would shrink nothing), the
   // consecutive-compact cap (existing death-spiral bound, shared with the
-  // threshold path), providers with no TTL (unknown model, local inference),
-  // no observed cache write yet, the TTL window itself, and one fire per
-  // window (a fresh fold rewrites the prefix; the summary call bypasses this
-  // governor so lastCacheWriteAt cannot observe it — lastCompactAt covers
-  // that). Never fires with a tool batch outstanding: the stall ping that
-  // triggers this can arrive mid-work.
+  // threshold path), providers with no TTL (undefined/empty model, local
+  // inference), no observed cache write yet, the TTL window itself, and one
+  // fire per window (a fresh fold rewrites the prefix; the summary call
+  // bypasses this governor so lastCacheWriteAt cannot observe it —
+  // lastCompactAt covers that). Never fires with a tool batch outstanding:
+  // the stall ping that triggers this can arrive mid-work.
   function isTtlRecompressDue(nowMs: number): boolean {
     if (pending) return false;
     if (turnCount <= MIN_TURNS_TO_COMPACT) return false;

src/provider/cache-ttl.ts

@@ -80,8 +80,9 @@ function canonicalSegment(model: string): string {
 
 /**
  * Milliseconds of provider-cache idle after which a recompress is allowed,
- * or `undefined` when the model is unknown or the provider has no remote
- * cache (local inference). Never throws; unknown strings get the default.
+ * or `undefined` when the model is undefined/empty or the provider has no
+ * remote cache (local inference). Never throws; unknown strings get the
+ * default 10-minute window.
  */
 export function cacheTtlMsFor(model: string | undefined): number | undefined {
   if (model === undefined) return undefined;