fix(compaction): align ttl nits with hysteresis-gap behavior

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -187,11 +187,11 @@ The agent maintains an optional **`manage_tasks`** list (create/update via the h
 
 #### Context compaction (the compaction governor)
 
-When a cycle's input tokens cross a threshold, the director compacts the inference-facing history (the full run is always retained in the context store). The threshold is **model-aware** — roughly 60% of the active model's real context window — so small-window models compact early enough to avoid provider context-overflow while large-window models do not compact prematurely. The compacted prefix is **append-only across passes**: the existing compacted user turn stays byte-identical; new folds become later summary turns with a harness-inserted assistant spacer (identified by reserved `model: "harness"`, plus a visible sentinel; persisted `[compaction]` tokens without a producer still freeze) between them so the prompt head can remain in the provider KV cache. Model-emitted copies of the spacer are not frozen. Spacer-only model replies are incomplete: ChatDirector nudges, then falls through loop-protection, workflow-idle, and open-task rails rather than empty-settling with work still open. The governor covers three cases:
+When a cycle's input tokens cross a threshold, the director compacts the inference-facing history (the full run is always retained in the context store). The threshold is **model-aware** — roughly 60% of the active model's real context window — so small-window models compact early enough to avoid provider context-overflow while large-window models do not compact prematurely. The compacted prefix is **append-only across passes**: the existing compacted user turn stays byte-identical; new folds become later summary turns with a harness-inserted assistant spacer (identified by reserved `model: "harness"`, plus a visible sentinel; persisted `[compaction]` tokens without a producer still freeze) between them so the prompt head can remain in the provider KV cache. Model-emitted copies of the spacer are not frozen. Spacer-only model replies are incomplete: ChatDirector nudges, then falls through loop-protection, workflow-idle, and open-task rails rather than empty-settling with work still open. The governor covers four cases:
 
 - **Threshold at a tool pause** — Once over threshold, the follow-up `infer` after a tool batch is swapped for a `compact` cycle, and inference resumes via a host continuation message. After a compact that remains over the high watermark, the governor uses **growth hysteresis** (wait for usage to grow by ~10% of the window) instead of re-arming on every cycle; dropping under 60% is not required.
 - **Idle (end-of-turn)** — An interactive turn can end with a reply and then sit idle with no tool batch to intercept; the governor requests a continuation at that pause and compacts when it arrives. An operator message that races the continuation still compacts first, then re-enters inference to answer it.
-- **Idle recompress past the provider TTL** — The fold is a re-compress, not a cache play: provider KV caches expire on their own schedule, so an under-threshold session compresses _after_ that expiry (the next turn is a cheaper write and later reads compound on the shrunk context) instead of only at 60% tokens. Any live re-entry past the window fires it — an empty stall ping re-enters meter-only, a raced operator message re-infers — under reason `cache-ttl-recompress` through the same compactor, so the fresh tail stays raw exactly as in the threshold path. The interval follows provider cache economics (`src/provider/cache-ttl.ts`), not a global N minutes:
+- **Idle recompress past the provider TTL** — The fold is a re-compress, not a cache play: provider KV caches expire on their own schedule, so a session compresses _after_ that expiry (the next turn is a cheaper write and later reads compound on the shrunk context) instead of only at 60% tokens. It is not limited to under-threshold sessions: once growth hysteresis has cleared `pending`, an over-threshold session in that gap can fire the same fold. Any live re-entry past the window fires it — an empty stall ping re-enters meter-only, a raced operator message re-infers — under reason `cache-ttl-recompress` through the same compactor, so the fresh tail stays raw exactly as in the threshold path. The interval follows provider cache economics (`src/provider/cache-ttl.ts`), not a global N minutes.
 - **Overflow recovery** — A `context_overflow` inference error would otherwise become a terminal error reply; the governor compacts and retries instead, bounded so a history the compactor cannot shrink does not loop forever. Overflow ignores hysteresis for the compact itself.
 
 | Provider segment                                                  | Idle recompress allowed after | Why                                                                                  |

src/agent/compaction.test.ts

@@ -950,6 +950,50 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     ).toEqual(ttlCompact);
   });
 
+  test("after threshold compact and gap TTL, growth-armed compact stays blocked until a tool_call", () => {
+    // Threshold compact (consecutive=1) plus TTL fire in the hysteresis gap
+    // (consecutive=2) fills the shared cap. Later growth that would re-arm
+    // the threshold path stays blocked until a tool_call occupancy resets it.
+    let nowMs = 80_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);
+    nowMs += 11 * MINUTE_MS;
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toEqual(ttlCompact);
+    expect(governor.resumeAfterCompact(emptyMessage())).toBe("meter");
+
+    // Post-TTL snapshot, then growth past resumeDelta — pending re-arms,
+    // but the cap is full so interceptActions stays null.
+    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
+    governor.noteInferenceDone(
+      inferenceDone(overThreshold + resumeDelta),
+      tenTurns,
+    );
+    expect(
+      governor.interceptActions(toolDone(), inferAction, capabilities),
+    ).toBeNull();
+
+    governor.noteInferenceDone(
+      inferenceDoneWithTools(overThreshold + 2 * resumeDelta),
+      tenTurns,
+    );
+    expect(
+      governor.interceptActions(toolDone(), inferAction, capabilities),
+    ).not.toBeNull();
+  });
+
   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

@@ -317,6 +317,29 @@ export function createCompactionGovernor(
     return true;
   }
 
+  function inboundText(event: ReactorInboundEvent): string {
+    if (event.type !== "message.received") return "";
+    return typeof event.message.content === "string"
+      ? event.message.content
+      : "";
+  }
+
+  // Idle empty compact needs a meter-only re-entry; a raced operator message
+  // needs a follow-up infer. Shared by the threshold idle path and TTL fold.
+  function issueIdleFold(
+    content: string,
+    capabilities: ReactorCapabilities,
+    reason: string,
+  ): ReactorAction[] {
+    if (content.length > 0) postCompactInfer = true;
+    else postCompactMeter = true;
+    issueThresholdCompact();
+    return [
+      capabilities.compact(COMPACTOR_NAME, reason),
+      ...continuationActions(capabilities),
+    ];
+  }
+
   function interceptIdleContinuation(
     event: ReactorInboundEvent,
     capabilities: ReactorCapabilities,
@@ -329,40 +352,26 @@ export function createCompactionGovernor(
       }
       idlePending = false;
       pending = false;
-      const content =
-        typeof event.message.content === "string" ? event.message.content : "";
       // The reactor delivers no event after compact, so always request a
       // continuation to re-enter decide against the shrunk turns:
       // - raced operator content → re-infer to answer it
       // - empty synthetic continuation → meter-only sync (no infer)
-      if (content.length > 0) {
-        postCompactInfer = true;
-      } else {
-        postCompactMeter = true;
-      }
-      issueThresholdCompact();
-      return [
-        capabilities.compact(COMPACTOR_NAME, "context-threshold"),
-        ...continuationActions(capabilities),
-      ];
+      return issueIdleFold(
+        inboundText(event),
+        capabilities,
+        "context-threshold",
+      );
     }
     // Unarmed idle re-entry past the provider TTL: same fold, same
     // keep-recent tail, same cap — but a "cache-ttl-recompress" reason so the
     // fold is attributable. No arming: every live re-entry re-checks the
     // window, so a sub-agent stall ping or operator message is the trigger.
     if (!isTtlRecompressDue(now())) return null;
-    const content =
-      typeof event.message.content === "string" ? event.message.content : "";
-    if (content.length > 0) {
-      postCompactInfer = true;
-    } else {
-      postCompactMeter = true;
-    }
-    issueThresholdCompact();
-    return [
-      capabilities.compact(COMPACTOR_NAME, "cache-ttl-recompress"),
-      ...continuationActions(capabilities),
-    ];
+    return issueIdleFold(
+      inboundText(event),
+      capabilities,
+      "cache-ttl-recompress",
+    );
   }
 
   // A context-overflow inference error would otherwise terminate the loop
@@ -396,9 +405,7 @@ export function createCompactionGovernor(
     event: ReactorInboundEvent,
   ): "infer" | "meter" | null {
     if (event.type !== "message.received") return null;
-    const content =
-      typeof event.message.content === "string" ? event.message.content : "";
-    if (content.length > 0) return null;
+    if (inboundText(event).length > 0) return null;
     if (postCompactInfer) {
       postCompactInfer = false;
       return "infer";

src/provider/cache-ttl.test.ts

@@ -21,7 +21,7 @@ describe("cacheTtlMsFor", () => {
     );
   });
 
-  test("disables idle recompress for local inference and unknown models", () => {
+  test("disables idle recompress for local inference and missing model ids", () => {
     expect(cacheTtlMsFor("ollama/llama3.1")).toBeUndefined();
     expect(cacheTtlMsFor(undefined)).toBeUndefined();
     expect(cacheTtlMsFor("")).toBeUndefined();
@@ -41,5 +41,8 @@ describe("cacheTtlMsFor", () => {
   test("assumes OpenAI-style economics for unrecognized providers", () => {
     expect(cacheTtlMsFor("bifrost/some-model")).toBe(10 * MINUTE_MS);
     expect(cacheTtlMsFor("totally-new-provider/model-x")).toBe(10 * MINUTE_MS);
+    // A truly unknown id (no provider segment, no family substring) still
+    // gets the 10-minute default — not the local-inference disable.
+    expect(cacheTtlMsFor("unknown-id")).toBe(10 * MINUTE_MS);
   });
 });