Summary

Moves all compaction decisions from afterTurn() to assemble() pre-assembly, using a persisted lastApiCallAt timestamp to determine whether the prompt cache has expired.

Closes #367. Supersedes #362, #363. Related: #102.

Problem

afterTurn() evaluates compaction using the cache status of the call that just completed. This is a fundamental timing inversion: after any API call, the provider has just written (or refreshed) the prompt cache — the cache is always hot in afterTurn, regardless of what the cache status reading says. Compacting at this point always destroys a live cache.

The three removed branches all suffer from this:

• hot-cache-budget-headroom: defers when hot and under budget — but "hot" at afterTurn time is meaningless since the cache is always hot after a call
• hot-cache-defer: defers when pressure is low and cache is hot — same issue
• cold-cache-catchup: triggers aggressive multi-pass on cold readings — on any provider, a cold reading at afterTurn means the provider just wrote the cache, so it's now hot

On providers that load-balance across backend instances with separate prompt caches (e.g. OpenRouter), a secondary problem compounds this: random cold readings from routing misses create a cascade of aggressive compaction → prefix rewrite → guaranteed cold → repeat. But even on direct Anthropic, the core inversion applies — afterTurn is simply the wrong time to evaluate cache state.

Fix

afterTurn() becomes telemetry-only: records lastApiCallAt = Date.now(), nothing else.

assemble() checks at pre-assembly time:

1. Budget overflow — must compact to fit, fires unconditionally
2. Cache-TTL — if cacheAwareCompaction.enabled and now - lastApiCallAt > cacheTTLSeconds and there's material to compact → compact before assembling

This is the only window where compaction is both safe and beneficial: the cache has genuinely expired, no live cache to destroy, and compacting reduces input cost on the upcoming cold call.

This approach supersedes the routing-noise guard in #362 (sticky cold counter is no longer needed when afterTurn doesn't make compaction decisions) and the deferred threshold compaction in #363 (all compaction is now off the reply path by design). It also addresses the same use case as the idle compaction trigger in #102 but with a simpler timestamp-based mechanism integrated into the assembly path.

Changes

• src/engine.ts: remove two try/catch compaction blocks from afterTurn(), add pre-assembly block to assemble(), delete dead methods (evaluateIncrementalCompaction, logIncrementalCompactionDecision, shouldApplyHotCacheHysteresis, resolveCacheAwareState, isComfortablyUnderTokenBudget)
• src/db/config.ts: add cacheTTLSeconds to CacheAwareCompactionConfig (default 300, env LCM_CACHE_TTL_SECONDS)
• src/db/migration.ts: add last_api_call_at INTEGER column
• src/store/compaction-telemetry-store.ts: add lastApiCallAt field throughout
• openclaw.plugin.json: add cacheTTLSeconds to schema
• test/engine.test.ts: remove 11 tests for deleted afterTurn compaction behavior
• test/config.test.ts: update assertions

Testing

All tests pass. Soak-tested in production: zero compactions during active use (turns 30–200s apart), compaction fires correctly after genuine cache expiry (idle > 300s), per-conversation TTL tracking confirmed working across multiple concurrent sessions.