compaction: manual compaction keeps full conversation in next request #54910

Activity

1. opencode-agent commented on Oct 12, 2026

   

   opencode-agentBot

   on Oct 12, 2026 – with OpenCode Agent

   Contributor

   More actions

   Thanks for the detailed report and the token timeline. I was able to reproduce this on 2.0.27, and it still happens on the latest dev (80fb31eb).

   Setup: a simulated model, default keep.tokens (15k), three short exchanges, then one user message followed by a single very long assistant turn (about 60k tokens) with no user message after it. Then /compact and one more message:

   • The summarization request was about 21.5k tokens and did not include the long turn.
   • The first request after compaction was about 66k tokens and included that whole turn verbatim. The conversation went from about 81k tokens before compaction to about 66k after, instead of summary + about 15k.

   The script below reproduces it and logs every request's size; the recording shows the TUI side.

   The likely cause is how compaction picks what to keep. It measures keep.tokens from the end, then walks back to the nearest earlier user message and keeps everything after it as text. When the work since your last message is long (for example a long agent run), most of the conversation is kept verbatim and only the older part is summarized. That would also explain why your recovery compaction worked: it ran right after a new message, so the last user message was near the end. The cause is most likely the same as #43250; #51818 (reasoning kept in full) can make it worse.

   Until this is fixed, two things should help:

   • Send a short message right before running /compact.
   • Keep using the larger compaction.buffer you already set up.

   recording.mp4

   Reproduction script (drive.ts)

   // Repro for anomalyco/opencode#54910: after manual /compact, the next request still carries
   // (almost) the whole conversation, because the "recent" part kept verbatim is far larger than keep.tokens.
   import { appendFileSync } from "node:fs"
   import { Effect, Stream } from "effect"
   import { Llm, OpenCodeDriver } from "opencode-drive"
   
   const LOG = "/workspace/repro/requests.log"
   const filler = (tag: string, chars: number) => {
     let s = ""
     let i = 0
     while (s.length < chars) s += `${tag} line ${i++}: the agent inspected another part of the codebase and kept working. `
     return s
   }
   const SUMMARY = [
     "## Objective", "- test", "## Requirements", "- (none)", "## Decisions", "- (none)",
     "## Work State", "### Completed", "- (none)", "### Active", "- (none)", "### Blocked", "- (none)",
     "## Next Move", "1. (none)", "## Relevant Files", "- (none)", "## Important Context", "- (none)",
   ].join("\n")
   
   export default OpenCodeDriver.use(
     {
       ...(process.env.OC_DEV ? { opencode: { dev: process.env.OC_DEV } } : {}),
       tui: { recording: true },
       config: { compaction: { auto: false } },
     },
     ({ ui, llm }) =>
       Effect.gen(function* () {
         yield* llm.serve((request, index) => {
           const body = JSON.stringify(request.body)
           const isSummary = body.includes("You MUST use this format")
           const kind = isSummary ? "SUMMARIZE" : "CHAT"
           const hasBig = body.includes("BIG-TURN")
           appendFileSync(LOG, `#${index} ${kind} bodyChars=${body.length} approxTokens=${Math.round(body.length / 4)} containsBigTurnText=${hasBig}\n`)
           if (isSummary) return Stream.make(Llm.text(SUMMARY, { chunkSize: 500, delay: 0 }))
           if (body.includes("start the long task")) return Stream.make(Llm.text(filler("BIG-TURN", 240_000), { chunkSize: 8000, delay: 0 }))
           if (body.includes("question")) return Stream.make(Llm.text(filler("early", 20_000) + "\nDONE-" + index, { chunkSize: 4000, delay: 0 }))
           return Stream.make(Llm.text("ok after compaction " + index))
         })
         for (let i = 1; i <= 3; i++) {
           yield* ui.submit(`question ${i}`)
           yield* Effect.sleep(3000)
         }
         appendFileSync(LOG, "--- long autonomous turn (~60k tokens) ---\n")
         yield* ui.submit("start the long task")
         yield* Effect.sleep(8000)
         appendFileSync(LOG, "--- /compact ---\n")
         yield* ui.submit("/compact")
         yield* Effect.sleep(8000)
         yield* ui.screenshot("after-compact")
         appendFileSync(LOG, "--- next user message after compaction ---\n")
         yield* ui.submit("continue please")
         yield* Effect.sleep(6000)
         yield* ui.screenshot("after-next-message")
       }),
   )

   Run it with opencode-drive: opencode-drive run ./drive.ts. It drives opencode from your PATH; set OC_DEV to the path of an OpenCode checkout to run that from source instead.

   👍React with 👍1Reacted by zeetkt
2. opencode-agent

   added

   reproduced

   on Oct 12, 2026
3. Finn763 commented on Oct 19, 2026

   

   Finn763

   on Oct 19, 2026

   Contributor

   More actions

   I'd like to work on this — manual compaction completes but the following request still carries the full history, while recovery compaction truncates it. I'll trace the two paths and pin the difference with a test.
4. zeetkt commented on Oct 20, 2026

   

   zeetkt

   on Oct 20, 2026

   Last edited by zeetkt

   Author

   More actions

   3. I'd like to work on this — manual compaction completes but the following request still carries the full history, while recovery compaction truncates it. I'll trace the two paths and pin the difference with a test.

   I haven't managed to replicate the problem recently (well, I haven't really TRIED to replicate it), but it hasn't occurred naturally lately, I suspect there's been some kind of fix.
5. xxwtiancai commented on Oct 25, 2026

   

   xxwtiancai

   on Oct 25, 2026

   More actions

   Re-ran the reproduction script from the bot's comment on current dev (e0b6039e1) — still reproduces. The first request after /compact is ~66k tokens and contains the long turn verbatim, instead of summary + ~15k keep:

   #4 CHAT      approxTokens=20903
   --- /compact ---
   #5 SUMMARIZE approxTokens=81629 containsBigTurnText=true
   --- next user message after compaction ---
   #6 CHAT      approxTokens=65952 containsBigTurnText=true
   

   One difference from the original repro: the summarize request now includes the whole conversation (~82k tokens, presumably after #57091), but the keep window still preserves the long autonomous run verbatim.

   @Finn763 are you still planning to work on this? If not, I'd like to take it.