[BUG] deadlocks when surface exceeds the model window — the summarization LLM call itself fails with "context overflow", so the session can never compress (nor converse) again

[ashuai]

Summary

会话 surface 超过窗口后,自动压缩无法恢复——压缩要用 LLM 摘要历史,但那次摘要请求要把已经超窗的上下文塞进窗口,provider 直接报 context overflow 拒绝;失败的压缩被记为 compaction/end { error },没有 shadow 任何 surface 节点,surface 永远超窗。结果:既不能压缩(摘要调用超窗)、也不能对话(新 turn 超窗)的死锁。

Repro / Evidence

surfaceTokens=291,025 vs contextWindow=262,144(glm-5.3-flash);22 次压缩尝试,最后一次以 "error":"pi-ai detected context overflow for model "glm-5.3-flash"" 收尾;compaction/summary 与替换 user/message 从未追加,surface 不缩。

Root cause

dsh-compaction-basic 通过 ctx.llm.stream() 把当前(已超窗)surface 送给模型生成摘要 → 摘要请求本身超窗被拒 → 压缩是唯一能缩 surface 的机制,而它在超窗时跑不起来 → 死锁。

Expected

超窗时压缩应能「不先把整个 surface 喂给模型」就缩容(只摘要能塞进窗口的前缀 / 非 LLM 截断兜底 / 预留 headroom 保证摘要请求本身总能塞下)。

Impact / Workaround

会话一旦超窗就不可逆砖

Version: @deepseek-ai/dsh 0.1.1-rc.2; model glm-5.3-flash(262144)。

[argszero]

Confirmed — the deadlock is real, and the source shows the summary call is never bounded to the window.

The summarizer sends the entire over-window surface to ctx.llm.stream(). In packages/compaction/compaction-basic/src/summarizer.ts:146-164:

const messages: Message[] = [
  ...input.messages,                                  // ← the whole shadowed region
  createUserMessage({ content: [{ type: 'text', text: COMPACTION_INSTRUCTION }], ... }),
]
const options: GenerateOptions = { ..., messages, ... }
for await (const chunk of ctx.llm.stream(options)) assembler.push(chunk)

input.messages is the full surface being condensed (see SummarizationInput.messages at :83-85). So when surfaceTokens > contextWindow, the summarization request itself exceeds the window and the provider rejects it with context overflow — exactly your compaction/end { error } with no shadow. The only mechanism that shrinks the surface can't run because it needs the surface to fit first.

What makes this specific: the context-overflow trigger path in packages/compaction/compaction-basic/src/index.ts:284-291 selects the range with retainTokens=0 (shadow everything but the tail), but selectCompactableRange (region.ts:100-136) with retainTokens=0 only decides which nodes to shadow — it never bounds how much of that shadowed region is fed to the summarizer. Both overflow and pressure paths route to compactSurfaceRegion → summarizeCompaction → summarizeWithLlm, which unconditionally replays [shadowed messages + instruction]. There is no headroom reservation anywhere in that request construction.

Note the contrast: the pressure path (index.ts:294-327) does resolve contextWindow and compute spec (threshold/retain via resolveCompactSpec, config.ts:133-167). But retainTokens = how much to KEEP after compaction, not how much headroom to reserve for the summarization call's own input. So even the pressure path doesn't guarantee the summary call fits.

Your three expected-fix directions are all correct, and I'd rank them by fit to the current architecture:

• ① Summarize only a bounded prefix that fits the window — the summarizer should bound input.messages to contextWindow - reserved headroom instead of unconditionally replaying the whole region. This fits the existing prefix-cache-reuse design (summarizer.ts:26-30 deliberately replays the last routed request's prefix as a warm prefix); you'd just trim the trailing part of the replay so the novel instruction plus a bounded window always fits.
• ② Reserve headroom for the summary call itself — resolveCompactSpec is where contextWindow is already resolved; adding a summarization-headroom budget there (and passing it into summarizeWithLlm) would make the overflow path window-aware rather than replaying unbounded. This is the smaller surgical change.
• ③ Non-LLM truncation fallback — when the summary call can't fit even a bounded prefix, fall back to a non-destructive token-floor trim.

One concrete edge worth pinning in a regression test: the failed compaction/end {error} is already recorded as a durable event, but it doesn't shadow any surface node (compaction-basic/index.ts:220-230 appends the error close with no surface change). So the invariant to test is: after a failed compaction, the surface is unchanged but the session is still able to run the next summarization — i.e., the summary call itself must never be the thing that overflows. A test that seeds a surface over contextWindow and asserts the summarizer bounds its own input (rather than replaying everything) would pin this.

Good find — this is a genuine load-bearing deadlock, and the fix belongs in summarizeWithLlm/resolveCompactSpec (core, not a plugin seam). Happy to sketch the bounded-replay diff once a patch direction is chosen.