core: show compaction summary in TUI to explain what context was retained

When context window overflows, users now see a summary of what was
retained instead of just a generic compaction notice. This helps users
understand why certain parts of the conversation may no longer be
immediately accessible and what key information was preserved.

Author: thdxr

packages/opencode/src/cli/cmd/tui/context/sync-v2.tsx

@@ -17,6 +17,13 @@ function activeAssistant(messages: SessionMessage[]) {
   return assistant?.type === "assistant" ? assistant : undefined
 }
 
+function activeCompaction(messages: SessionMessage[]) {
+  const index = messages.findLastIndex((message) => message.type === "compaction")
+  if (index < 0) return
+  const compaction = messages[index]
+  return compaction?.type === "compaction" ? compaction : undefined
+}
+
 function latestTool(assistant: SessionMessageAssistant | undefined, callID?: string) {
   return assistant?.content.findLast(
     (item): item is SessionMessageAssistantTool => item.type === "tool" && (callID === undefined || item.id === callID),
@@ -214,18 +221,31 @@ export const { use: useSyncV2, provider: SyncProviderV2 } = createSimpleContext(
           break
         case "session.next.retried":
           break
-        case "session.next.compacted":
+        case "session.next.compaction.started":
           update(event.properties.sessionID, (draft) => {
             draft.push({
               id: event.properties.id,
               type: "compaction",
-              sessionID: event.properties.sessionID,
-              auto: event.properties.auto,
-              overflow: event.properties.overflow,
+              reason: event.properties.reason,
+              summary: "",
               time: { created: event.properties.timestamp },
             })
           })
           break
+        case "session.next.compaction.delta":
+          update(event.properties.sessionID, (draft) => {
+            const match = activeCompaction(draft)
+            if (match) match.summary += event.properties.text
+          })
+          break
+        case "session.next.compaction.ended":
+          update(event.properties.sessionID, (draft) => {
+            const match = activeCompaction(draft)
+            if (!match) return
+            match.summary = event.properties.text
+            match.include = event.properties.include
+          })
+          break
       }
     })
 

packages/opencode/src/cli/cmd/tui/feature-plugins/system/session-v2.tsx

@@ -200,13 +200,13 @@ function CompactionMessage(props: { message: SessionMessageCompaction }) {
     <box
       marginTop={1}
       border={["top"]}
-      title={props.message.auto ? " Auto Compaction " : " Compaction "}
+      title={props.message.reason === "auto" ? " Auto Compaction " : " Compaction "}
       titleAlignment="center"
       borderColor={theme.borderActive}
       flexShrink={0}
     >
-      <Show when={props.message.overflow}>
-        <text fg={theme.textMuted}>Context overflow triggered this compaction.</text>
+      <Show when={props.message.summary}>
+        <text fg={theme.textMuted}>{props.message.summary}</text>
       </Show>
     </box>
   )

packages/opencode/src/session/compaction.ts

@@ -14,10 +14,13 @@ import { Config } from "@/config/config"
 import { NotFoundError } from "@/storage/storage"
 import { ModelID, ProviderID } from "@/provider/schema"
 import { Effect, Layer, Context, Schema } from "effect"
+import * as DateTime from "effect/DateTime"
 import { InstanceState } from "@/effect/instance-state"
 import { isOverflow as overflow, usable } from "./overflow"
 import { makeRuntime } from "@/effect/run-service"
 import { fn } from "@/util/fn"
+import { SyncEvent } from "@/sync"
+import { SessionEvent } from "@/v2/session-event"
 
 const log = Log.create({ service: "session.compaction" })
 
@@ -556,7 +559,21 @@ export const layer: Layer.Layer<
       }
 
       if (processor.message.error) return "stop"
-      if (result === "continue") yield* bus.publish(Event.Compacted, { sessionID: input.sessionID })
+      if (result === "continue") {
+        const summary = summaryText(
+          (yield* session.messages({ sessionID: input.sessionID })).find((item) => item.info.id === msg.id) ?? {
+            info: msg,
+            parts: [],
+          },
+        )
+        SyncEvent.run(SessionEvent.Compaction.Ended.Sync, {
+          sessionID: input.sessionID,
+          timestamp: DateTime.makeUnsafe(Date.now()),
+          text: summary ?? "",
+          include: selected.tail_start_id,
+        })
+        yield* bus.publish(Event.Compacted, { sessionID: input.sessionID })
+      }
       return result
     })
 
@@ -583,6 +600,12 @@ export const layer: Layer.Layer<
         auto: input.auto,
         overflow: input.overflow,
       })
+      SyncEvent.run(SessionEvent.Compaction.Started.Sync, {
+        id: SessionEvent.ID.create(),
+        sessionID: input.sessionID,
+        timestamp: DateTime.makeUnsafe(Date.now()),
+        reason: input.auto ? "auto" : "manual",
+      })
     })
 
     return Service.of({

packages/opencode/src/session/processor.ts

@@ -433,19 +433,21 @@ export const layer: Layer.Layer<
 
           case "start-step":
             if (!ctx.snapshot) ctx.snapshot = yield* snapshot.track()
-            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
-            SyncEvent.run(SessionEvent.Step.Started.Sync, {
-              id: SessionEvent.ID.create(),
-              sessionID: ctx.sessionID,
-              agent: input.assistantMessage.agent,
-              model: {
-                id: ctx.model.id,
-                providerID: ctx.model.providerID,
-                variant: input.assistantMessage.variant,
-              },
-              snapshot: ctx.snapshot,
-              timestamp: DateTime.makeUnsafe(Date.now()),
-            })
+            if (!ctx.assistantMessage.summary) {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              SyncEvent.run(SessionEvent.Step.Started.Sync, {
+                id: SessionEvent.ID.create(),
+                sessionID: ctx.sessionID,
+                agent: input.assistantMessage.agent,
+                model: {
+                  id: ctx.model.id,
+                  providerID: ctx.model.providerID,
+                  variant: input.assistantMessage.variant,
+                },
+                snapshot: ctx.snapshot,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
             yield* session.updatePart({
               id: PartID.ascending(),
               messageID: ctx.assistantMessage.id,
@@ -462,15 +464,17 @@ export const layer: Layer.Layer<
               usage: value.usage,
               metadata: value.providerMetadata,
             })
-            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
-            SyncEvent.run(SessionEvent.Step.Ended.Sync, {
-              sessionID: ctx.sessionID,
-              finish: value.finishReason,
-              cost: usage.cost,
-              tokens: usage.tokens,
-              snapshot: completedSnapshot,
-              timestamp: DateTime.makeUnsafe(Date.now()),
-            })
+            if (!ctx.assistantMessage.summary) {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              SyncEvent.run(SessionEvent.Step.Ended.Sync, {
+                sessionID: ctx.sessionID,
+                finish: value.finishReason,
+                cost: usage.cost,
+                tokens: usage.tokens,
+                snapshot: completedSnapshot,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
             ctx.assistantMessage.finish = value.finishReason
             ctx.assistantMessage.cost += usage.cost
             ctx.assistantMessage.tokens = usage.tokens
@@ -515,11 +519,13 @@ export const layer: Layer.Layer<
           }
 
           case "text-start":
-            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
-            SyncEvent.run(SessionEvent.Text.Started.Sync, {
-              sessionID: ctx.sessionID,
-              timestamp: DateTime.makeUnsafe(Date.now()),
-            })
+            if (!ctx.assistantMessage.summary) {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              SyncEvent.run(SessionEvent.Text.Started.Sync, {
+                sessionID: ctx.sessionID,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
             ctx.currentText = {
               id: PartID.ascending(),
               messageID: ctx.assistantMessage.id,
@@ -534,6 +540,13 @@ export const layer: Layer.Layer<
 
           case "text-delta":
             if (!ctx.currentText) return
+            if (ctx.assistantMessage.summary) {
+              SyncEvent.run(SessionEvent.Compaction.Delta.Sync, {
+                sessionID: ctx.sessionID,
+                text: value.text,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
             ctx.currentText.text += value.text
             if (value.providerMetadata) ctx.currentText.metadata = value.providerMetadata
             yield* session.updatePartDelta({
@@ -558,12 +571,14 @@ export const layer: Layer.Layer<
               },
               { text: ctx.currentText.text },
             )).text
-            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
-            SyncEvent.run(SessionEvent.Text.Ended.Sync, {
-              sessionID: ctx.sessionID,
-              text: ctx.currentText.text,
-              timestamp: DateTime.makeUnsafe(Date.now()),
-            })
+            if (!ctx.assistantMessage.summary) {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              SyncEvent.run(SessionEvent.Text.Ended.Sync, {
+                sessionID: ctx.sessionID,
+                text: ctx.currentText.text,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
             {
               const end = Date.now()
               ctx.currentText.time = { start: ctx.currentText.time?.start ?? end, end }

packages/opencode/src/session/projectors-next.ts

@@ -37,6 +37,16 @@ function sqlite(db: Database.TxOrDb, sessionID: SessionID): SessionMessageUpdate
         .map((row) => decodeMessage({ ...row.data, id: row.id, type: row.type }))
         .find((message): message is SessionMessage.Assistant => message.type === "assistant" && !message.time.completed)
     },
+    getCurrentCompaction() {
+      return db
+        .select()
+        .from(SessionMessageTable)
+        .where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "compaction")))
+        .orderBy(desc(SessionMessageTable.id))
+        .all()
+        .map((row) => decodeMessage({ ...row.data, id: row.id, type: row.type }))
+        .find((message): message is SessionMessage.Compaction => message.type === "compaction")
+    },
     updateAssistant(assistant) {
       const { id, type, ...data } = assistant
       db.update(SessionMessageTable)
@@ -50,6 +60,19 @@ function sqlite(db: Database.TxOrDb, sessionID: SessionID): SessionMessageUpdate
         )
         .run()
     },
+    updateCompaction(compaction) {
+      const { id, type, ...data } = compaction
+      db.update(SessionMessageTable)
+        .set({ data: encodeMessageData(data) })
+        .where(
+          and(
+            eq(SessionMessageTable.id, id),
+            eq(SessionMessageTable.session_id, sessionID),
+            eq(SessionMessageTable.type, type),
+          ),
+        )
+        .run()
+    },
     appendMessage(message) {
       const { id, type, ...data } = message
       db.insert(SessionMessageTable)
@@ -118,7 +141,13 @@ export default [
   SyncEvent.project(SessionEvent.Retried.Sync, (db, data) => {
     update(db, { type: "session.next.retried", data })
   }),
-  SyncEvent.project(SessionEvent.Compacted.Sync, (db, data) => {
-    update(db, { type: "session.next.compacted", data })
+  SyncEvent.project(SessionEvent.Compaction.Started.Sync, (db, data) => {
+    update(db, { type: "session.next.compaction.started", data })
+  }),
+  SyncEvent.project(SessionEvent.Compaction.Delta.Sync, (db, data) => {
+    update(db, { type: "session.next.compaction.delta", data })
+  }),
+  SyncEvent.project(SessionEvent.Compaction.Ended.Sync, (db, data) => {
+    update(db, { type: "session.next.compaction.ended", data })
   }),
 ]

packages/opencode/src/v2/session-event.ts

@@ -272,17 +272,38 @@ export const Retried = Event.define({
 })
 export type Retried = Schema.Schema.Type<typeof Retried>
 
-export const Compacted = Event.define({
-  type: "session.next.compacted",
-  aggregate: "sessionID",
-  schema: {
-    ...Base,
-    id: ID,
-    auto: Schema.Boolean,
-    overflow: Schema.Boolean.pipe(Schema.optional),
-  },
-})
-export type Compacted = Schema.Schema.Type<typeof Compacted>
+export namespace Compaction {
+  export const Started = Event.define({
+    type: "session.next.compaction.started",
+    aggregate: "sessionID",
+    schema: {
+      ...Base,
+      id: ID,
+      reason: Schema.Union([Schema.Literal("auto"), Schema.Literal("manual")]),
+    },
+  })
+  export type Started = Schema.Schema.Type<typeof Started>
+
+  export const Delta = Event.define({
+    type: "session.next.compaction.delta",
+    aggregate: "sessionID",
+    schema: {
+      ...Base,
+      text: Schema.String,
+    },
+  })
+
+  export const Ended = Event.define({
+    type: "session.next.compaction.ended",
+    aggregate: "sessionID",
+    schema: {
+      ...Base,
+      text: Schema.String,
+      include: Schema.String.pipe(Schema.optional),
+    },
+  })
+  export type Ended = Schema.Schema.Type<typeof Ended>
+}
 
 export const All = Schema.Union(
   [
@@ -304,13 +325,24 @@ export const All = Schema.Union(
     Reasoning.Delta,
     Reasoning.Ended,
     Retried,
-    Compacted,
+    Compaction.Started,
+    Compaction.Delta,
+    Compaction.Ended,
   ],
   {
     mode: "oneOf",
   },
 ).pipe(Schema.toTaggedUnion("type"))
 
+// user
+// assistant
+// assistant
+// assistant
+// user
+// compaction marker
+// -> text
+// assistant
+
 export type Event = Schema.Schema.Type<typeof All>
 export type Type = Event["type"]