feat(core): add durable compaction barrier (#35371)

packages/tui/test/cli/tui/data.test.tsx

@@ -108,6 +108,64 @@ test("refreshes resources into reactive getters", async () => {
   }
 })
 
+test("restores running manual compaction before applying live deltas", async () => {
+  const events = createEventStream()
+  const calls = createFetch((url) => {
+    if (url.pathname === "/api/session/session-compaction/message")
+      return json({
+        data: [
+          {
+            id: "message-compaction",
+            type: "compaction",
+            status: "running",
+            reason: "manual",
+            summary: "Existing ",
+            recent: "",
+            time: { created: 1 },
+          },
+        ],
+        cursor: {},
+      })
+  }, events)
+  let data!: ReturnType<typeof useData>
+
+  function Probe() {
+    data = useData()
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider client={createClient(calls.fetch)} api={createApi(calls.fetch)}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await data.session.message.refresh("session-compaction")
+    expect(data.session.compaction("session-compaction")).toBe("Existing ")
+
+    emitEvent(events, {
+      id: "evt_compaction_delta",
+      created: 2,
+      type: "session.compaction.delta",
+      data: { sessionID: "session-compaction", text: "summary" },
+    })
+
+    await wait(() => {
+      const message = data.session.message.get("session-compaction", "message-compaction")
+      return message?.type === "compaction" && message.summary === "Existing summary"
+    })
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
 test("reconnects the event stream and bootstraps fresh data", async () => {
   const events = createEventStream()
   const requests = { active: 0, event: 0, model: 0 }
@@ -402,10 +460,12 @@ test("tracks session status from active sessions and execution events", async ()
   }, events)
   let data!: ReturnType<typeof useData>
   let rows!: SessionRow[]
+  let manualRows!: SessionRow[]
 
   function Probe() {
     data = useData()
     rows = createSessionRows(() => "session-retry")
+    manualRows = createSessionRows(() => "session-manual")
     return <box />
   }
 
@@ -610,6 +670,49 @@ test("tracks session status from active sessions and execution events", async ()
     await wait(() => data.session.status("session-retry") === "idle")
     expect(data.session.message.get("session-retry", "message-retry")).not.toHaveProperty("retry")
 
+    emitEvent(events, {
+      id: "evt_compaction_admitted",
+      created: 0,
+      type: "session.compaction.admitted",
+      durable: durable("session-manual", 1),
+      data: { sessionID: "session-manual", inputID: "message-compaction" },
+    })
+    await wait(() => {
+      const message = data.session.message.get("session-manual", "message-compaction")
+      return message?.type === "compaction" && message.status === "queued"
+    })
+    emitEvent(events, {
+      id: "evt_manual_compaction_started",
+      created: 1,
+      type: "session.compaction.started",
+      durable: durable("session-manual", 2),
+      data: { sessionID: "session-manual", reason: "manual" },
+    })
+    emitEvent(events, {
+      id: "evt_manual_compaction_delta",
+      created: 2,
+      type: "session.compaction.delta",
+      data: { sessionID: "session-manual", text: "Streamed summary" },
+    })
+    await wait(() => {
+      const message = data.session.message.get("session-manual", "message-compaction")
+      return message?.type === "compaction" && message.summary === "Streamed summary"
+    })
+    emitEvent(events, {
+      id: "evt_manual_compaction_ended",
+      created: 3,
+      type: "session.compaction.ended",
+      durable: durable("session-manual", 3),
+      data: { sessionID: "session-manual", reason: "manual", text: "Streamed summary", recent: "recent" },
+    })
+    await wait(() => {
+      const message = data.session.message.get("session-manual", "message-compaction")
+      return message?.type === "compaction" && message.status === "completed"
+    })
+    expect(manualRows.filter((row) => row.type === "message")).toEqual([
+      { type: "message", messageID: "message-compaction" },
+    ])
+
     emitEvent(events, {
       id: "evt_compaction_started",
       created: 0,

packages/tui/test/cli/tui/session-rows.test.ts

@@ -209,6 +209,34 @@ test("renders a footer for a pre-output retry assistant after replay", () => {
   expect(reduceSessionRows([message])).toEqual([{ type: "assistant-footer", messageID: "assistant-retry" }])
 })
 
+test("places a pending compaction barrier before every queued user message", () => {
+  const queued = (id: string, text: string, created: number): SessionMessage => ({
+    type: "user",
+    id,
+    text,
+    time: { created },
+  })
+  const messages: SessionMessage[] = [
+    queued("user-before", "Before", 1),
+    {
+      type: "compaction",
+      id: "compaction",
+      status: "queued",
+      reason: "manual",
+      summary: "",
+      recent: "",
+      time: { created: 2 },
+    },
+    queued("user-after", "After", 3),
+  ]
+
+  expect(reduceSessionRows(messages, new Set(["user-before", "user-after"]))).toEqual([
+    { type: "message", messageID: "compaction" },
+    { type: "message", messageID: "user-before" },
+    { type: "message", messageID: "user-after" },
+  ])
+})
+
 function assistant(id: string, content: SessionMessageAssistant["content"]): SessionMessageAssistant {
   return {
     type: "assistant",