Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
fix(compaction): align native lifecycle and reconcile replay notices
chengyongrube43d2a5f8bf
diff --git a/nanobot/agent/context_governance.py b/nanobot/agent/context_governance.pyindex a50b0ebf3..cfb2c7622 100644--- a/nanobot/agent/context_governance.py+++ b/nanobot/agent/context_governance.py@@ -43,6 +43,7 @@ from nanobot.session.summary import (SUMMARY_CONTINUATION_TEXT,SessionSummaryCheckpoint,)+from nanobot.utils.cancellation import shield_and_drainfrom nanobot.utils.helpers import (estimate_prompt_tokens_chain,maybe_persist_tool_result,@@ -529,6 +530,11 @@ class ContextGovernor:if message.get("role") == "tool"and isinstance(message.get("tool_call_id"), str))+ if response.provider_compaction_event_id is None:+ response.provider_compaction_event_id = uuid4().hex+ await shield_and_drain(state.events.emit(ContextCompactionEvent(+ response.provider_compaction_event_id, "succeeded",+ )))if (not response.provider_compaction_appliedor response.provider_compaction_state is None@@ -553,40 +559,18 @@ class ContextGovernor:)return- compaction_id = uuid4().hex- await state.events.emit(- ContextCompactionEvent(compaction_id=compaction_id, phase="started"),+ summary = await compaction.consolidate_provider_compaction(+ response.provider_compaction_state,+ await self.prepare_in_background(deepcopy, accepted_messages),+ compaction.active_summary,)- try:- summary = await compaction.consolidate_provider_compaction(- response.provider_compaction_state,- await self.prepare_in_background(deepcopy, accepted_messages),- compaction.active_summary,- )- except (Exception, asyncio.CancelledError) as exc:- await state.events.emit(- ContextCompactionEvent(- compaction_id=compaction_id,- phase="cancelled" if isinstance(exc, asyncio.CancelledError) else "failed",- ),- )- raiseif not summary:- await state.events.emit(- ContextCompactionEvent(compaction_id=compaction_id, phase="failed"),- )returncompaction.active_summary = summarycompaction.summary_checkpoint = SessionSummaryCheckpoint(summary=summary,transcript_boundary=transcript_boundary,)- await state.events.emit(- ContextCompactionEvent(- compaction_id=compaction_id,- phase="succeeded",- ),- )async def _compact_request_history(self,diff --git a/nanobot/providers/base.py b/nanobot/providers/base.pyindex da8bbbc32..de886f772 100644--- a/nanobot/providers/base.py+++ b/nanobot/providers/base.py@@ -301,6 +301,8 @@ class LLMResponse:# True only when this response installed a new provider-native compaction# boundary. Replaying an older compaction item does not set this flag.provider_compaction_applied: bool = field(default=False, repr=False)+ # Identity of the native lifecycle already reported by its operation owner.+ provider_compaction_event_id: str | None = field(default=None, repr=False)# State immediately after native compaction, before the normal response# continues. An archive prompt can resume this state without replaying H.provider_compaction_state: ProviderConversationState | None = field(diff --git a/nanobot/providers/openai_codex_provider.py b/nanobot/providers/openai_codex_provider.pyindex a65052943..e23632b3e 100644--- a/nanobot/providers/openai_codex_provider.py+++ b/nanobot/providers/openai_codex_provider.py@@ -13,6 +13,7 @@ import reimport sslfrom collections.abc import Awaitable, Callablefrom typing import Any, cast+from uuid import uuid4import httpxfrom loguru import logger@@ -21,6 +22,7 @@ from oauth_cli_kit.providers import OPENAI_CODEX_PROVIDERfrom oauth_cli_kit.storage import FileTokenStoragefrom nanobot import __version__+from nanobot.events import NO_EVENTS, ContextCompactionEventfrom nanobot.providers.base import (CONTEXT_SAFETY_BUFFER,LLMProvider,@@ -47,6 +49,7 @@ from nanobot.providers.openai_responses.state import ()from nanobot.providers.openai_responses.websocket import ResponsesWebSocketErrorfrom nanobot.providers.registry import ProviderModelSpec, find_by_name+from nanobot.utils.cancellation import shield_and_drainfrom nanobot.utils.helpers import estimate_prompt_tokensDEFAULT_CODEX_URL = "https://chatgpt.com/backend-api/codex/responses"@@ -258,8 +261,18 @@ class OpenAICodexProvider(LLMProvider):)stage = "oauth_token"- native_compaction_applied = Falsenative_compaction_state: ProviderConversationState | None = None+ native_compaction_event_id: str | None = None+ events = provider_context.events if provider_context is not None else NO_EVENTS++ def finish_compaction(result: LLMResponse) -> LLMResponse:+ if native_compaction_state is not None and not result.provider_compaction_applied:+ result.provider_compaction_applied = True+ result.provider_compaction_state = native_compaction_state+ result.provider_compaction_scope = "prior_context"+ result.provider_compaction_event_id = native_compaction_event_id+ return result+input_budget = (provider_context.compaction_input_budget if provider_context is not None else None)@@ -353,12 +366,25 @@ class OpenAICodexProvider(LLMProvider):stage = "codex_compaction"async def send_compaction(request: dict[str, Any]) -> LLMResponse:- return await _send(- request,- emit_deltas=False,- trace_name="codex_compaction",- validate=responses_compaction_items,- )+ nonlocal native_compaction_event_id+ compaction_id = uuid4().hex+ try:+ await events.emit(ContextCompactionEvent(compaction_id, "started"))+ compacted = await _send(+ request,+ emit_deltas=False,+ trace_name="codex_compaction",+ validate=responses_compaction_items,+ )+ except (Exception, asyncio.CancelledError) as exc:+ await shield_and_drain(events.emit(ContextCompactionEvent(+ compaction_id,+ "cancelled" if isinstance(exc, asyncio.CancelledError) else "failed",+ )))+ raise+ native_compaction_event_id = compaction_id+ await shield_and_drain(events.emit(ContextCompactionEvent(compaction_id, "succeeded")))+ return compactednative_compaction_state = await self._responses.compact_before_request(body, state=sanitized_state,@@ -369,14 +395,13 @@ class OpenAICodexProvider(LLMProvider):max_output_tokens=max_tokens, input_budget=input_budget,send=send_compaction,)- native_compaction_applied = native_compaction_state is not Noneif input_budget is not None:estimated = estimate_prompt_tokens([{"role": "user", "content": json.dumps(body, ensure_ascii=False),}])if input_budget <= 0 or estimated > input_budget:- return LLMResponse(+ return finish_compaction(LLMResponse(content=("Codex input still exceeds the local budget after native compaction "f"({estimated}/{input_budget} estimated tokens); request not sent."@@ -384,16 +409,10 @@ class OpenAICodexProvider(LLMProvider):finish_reason="error", error_kind="context_window_exceeded",error_should_retry=False,preserve_provider_state_on_error=True,- )+ ))stage = "codex_request"result = await _send(body, emit_deltas=True, trace_name="codex_request")- result.provider_compaction_applied = (- result.provider_compaction_applied or native_compaction_applied- )- if native_compaction_state is not None:- result.provider_compaction_state = native_compaction_state- result.provider_compaction_scope = "prior_context"- return result+ return finish_compaction(result)except Exception as e:response = _codex_error_response(e)if input_budget is not None and stage != "codex_request":@@ -416,12 +435,12 @@ class OpenAICodexProvider(LLMProvider):request_model,request_effort,replayed,- native_compaction_applied,+ native_compaction_state is not None,getattr(e, "error_param", None),getattr(e, "error_message", None),getattr(e, "request_id", None),)- return response+ return finish_compaction(response)async def chat(self,diff --git a/tests/agent/test_runner_governance.py b/tests/agent/test_runner_governance.pyindex d8c1844ce..e3ffeadd6 100644--- a/tests/agent/test_runner_governance.py+++ b/tests/agent/test_runner_governance.py@@ -2,6 +2,7 @@from __future__ import annotations+import asynciofrom unittest.mock import AsyncMock, MagicMock, patchimport pytest@@ -346,6 +347,7 @@ async def test_native_compaction_uses_provider_request_boundary(provider_compaction_applied=True,provider_compaction_state=compacted_state,provider_compaction_scope=scope,+ provider_compaction_event_id="native-already-reported" if scope == "prior_context" else None,),LLMResponse(content="done"),])@@ -399,10 +401,44 @@ async def test_native_compaction_uses_provider_request_boundary(assert result.provider_compaction_applied is Trueassert any(message.get("content") == "inspect the project" for message in result.messages)assert any(message.get("content") == "complete tool result" for message in result.messages)- assert [event.phase for event in compaction_events] == ["started", "succeeded"]- assert {event.compaction_id for event in compaction_events} == {- compaction_events[0].compaction_id- }+ assert [event.phase for event in compaction_events] == ([] if scope == "prior_context" else ["succeeded"])++[email protected]("error", [RuntimeError("checkpoint failed"), asyncio.CancelledError()])+async def test_native_checkpoint_failure_does_not_relabel_completed_compaction(monkeypatch, error):+ provider = MagicMock(spec=LLMProvider)+ provider.can_resume_conversation_state.return_value = False+ compacted = ProviderConversationState(+ kind="openai_responses", provider="openai:test", model="test-model", version=1,+ payload={"items": [{"type": "compaction", "encrypted_content": "opaque"}]},+ )+ provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(+ content="done", provider_compaction_applied=True,+ provider_compaction_state=compacted, provider_compaction_scope="current_request",+ ))+ tools = MagicMock()+ tools.get_definitions.return_value = []+ monkeypatch.setattr("nanobot.agent.context_governance.estimate_prompt_tokens_chain", lambda *_args: (100, "test-counter"))+ notices: list[ContextCompactionEvent] = []++ async def observe(event) -> None:+ if isinstance(event, ContextCompactionEvent):+ notices.append(event)++ async def consolidate(*_args):+ assert [notice.phase for notice in notices] == ["succeeded"]+ raise error++ with pytest.raises(type(error)):+ await AgentRunner().run(make_run_spec(+ provider, initial_messages=None,+ transcript_input=TranscriptInput(history=[], current_message="question"),+ transcript_builder=_build_transcript, consolidate_provider_compaction=consolidate,+ tools=tools, model="test-model", context_window_tokens=1_624,+ max_tokens=100, max_iterations=1, max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,+ events=EventSink(observe),+ ))+ assert [notice.phase for notice in notices] == ["succeeded"]async def test_runner_keeps_current_tool_exchange_outside_summary(monkeypatch):diff --git a/tests/providers/test_openai_codex_provider.py b/tests/providers/test_openai_codex_provider.pyindex 580334dd5..7d0bb16c5 100644--- a/tests/providers/test_openai_codex_provider.py+++ b/tests/providers/test_openai_codex_provider.py@@ -12,6 +12,7 @@ from loguru import loggerimport nanobot.providers.base as provider_basefrom nanobot.config.schema import Config+from nanobot.events import ContextCompactionEvent, EventSinkfrom nanobot.providers.factory import make_providerfrom nanobot.providers.openai_codex_provider import (OpenAICodexProvider,@@ -930,8 +931,9 @@ async def test_codex_replayed_tool_turn_omits_server_item_ids(monkeypatch) -> No@pytest.mark.asyncio[email protected]("inline_compaction", [False, True])async def test_codex_compacts_state_at_ninety_percent_before_next_request(- monkeypatch,+ monkeypatch, inline_compaction,) -> None:_mock_codex_token(monkeypatch)provider = OpenAICodexProvider(default_model="openai-codex/gpt-5.6-sol")@@ -951,6 +953,16 @@ async def test_codex_compacts_state_at_ninety_percent_before_next_request(usage=provider_base.LLMUsage.reported(input_tokens=90, output_tokens=5),)bodies: list[dict[str, Any]] = []+ timeline: list[str] = []+ notices: list[ContextCompactionEvent] = []++ async def observe(event) -> None:+ if isinstance(event, ContextCompactionEvent):+ timeline.append(event.phase)+ notices.append(event)++ async def answer_delta(text: str) -> None:+ timeline.append(f"answer:{text}")async def fake_request(url,@@ -962,62 +974,67 @@ async def test_codex_compacts_state_at_ninety_percent_before_next_request(on_thinking_delta=None,on_tool_call_delta=None,):- _ = (- url,- headers,- verify,- proxy,- on_content_delta,- on_thinking_delta,- on_tool_call_delta,- )+ _ = (url, headers, verify, proxy, on_thinking_delta, on_tool_call_delta)bodies.append(body)if body["input"][-1].get("type") == "compaction_trigger":+ timeline.append("compact-request")compact_item = {"type": "compaction","encrypted_content": "compacted opaque state",}- return provider_base.LLMResponse(- content=None,- provider_state=build_responses_state(- provider=state_provider,- model="gpt-5.6-sol",- input_items=body["input"],- output_items=[compact_item],- usage=provider_base.LLMUsage.reported(- input_tokens=95,- output_tokens=2,- ),- ),- )- return provider_base.LLMResponse(content="done")+ async def compact_events():+ yield {"type": "response.completed", "response": {+ "status": "completed", "output": [compact_item],+ "usage": {"input_tokens": 95, "output_tokens": 2},+ }}++ return await provider._responses.consume(compact_events(), provider=state_provider, body=body)+ timeline.append("generation-request")++ async def answer_events():+ yield {"type": "response.output_text.delta", "delta": "done"}+ yield {"type": "response.completed", "response": {+ "status": "completed", "output": [+ *([{"type": "compaction", "encrypted_content": "new inline state"}] if inline_compaction else []),+ {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "done"}]},+ ],+ }}++ return await provider._responses.consume(+ answer_events(), provider=state_provider, body=body, on_content_delta=on_content_delta,+ )monkeypatch.setattr("nanobot.providers.openai_codex_provider._request_codex",fake_request,)- response = await provider.chat_with_retry(+ response = await provider.chat_stream_with_retry([{"role": "system", "content": "system"},{"role": "user", "content": "new question"},],max_tokens=5,+ on_content_delta=answer_delta,provider_context=provider_base.ProviderCallContext(conversation_state=state.with_pending_messages([{"role": "user", "content": "new question"},]),context_window_tokens=100,+ events=EventSink(observe),),)+ assert timeline == ["started", "compact-request", "succeeded", "generation-request", "answer:done"]+ assert len({notice.compaction_id for notice in notices}) == 1+ assert response.provider_compaction_event_id == (None if inline_compaction else notices[0].compaction_id)assert response.content == "done"assert response.provider_compaction_applied is Trueassert response.provider_compaction_state is not None- assert response.provider_compaction_scope == "prior_context"+ assert response.provider_compaction_scope == ("current_request" if inline_compaction else "prior_context")assert responses_state_items(response.provider_compaction_state) == [{"type": "compaction",- "encrypted_content": "compacted opaque state",+ "encrypted_content": "new inline state" if inline_compaction else "compacted opaque state",}]assert len(bodies) == 2assert bodies[0]["input"][-1] == {"type": "compaction_trigger"}@@ -1065,6 +1082,11 @@ async def test_codex_disables_unsupported_native_compaction_and_continues(usage=provider_base.LLMUsage.reported(input_tokens=90, output_tokens=5),)bodies: list[dict[str, Any]] = []+ notices: list[ContextCompactionEvent] = []++ async def observe(event) -> None:+ if isinstance(event, ContextCompactionEvent):+ notices.append(event)async def fake_request(url,@@ -1107,16 +1129,73 @@ async def test_codex_disables_unsupported_native_compaction_and_continues({"role": "user", "content": "new"},]),context_window_tokens=100,+ events=EventSink(observe),),)assert response.content == "done"+ assert [notice.phase for notice in notices] == ["started", "failed"]+ assert len({notice.compaction_id for notice in notices}) == 1assert len(bodies) == 2assert bodies[0]["input"][-1] == {"type": "compaction_trigger"}assert bodies[1]["input"][-1] != {"type": "compaction_trigger"}assert provider.supports_native_compaction() is False[email protected]("cancel_during", ["compaction", "terminal", "generation"])+async def test_codex_native_compaction_terminal_survives_cancellation(monkeypatch, cancel_during) -> None:+ _mock_codex_token(monkeypatch)+ provider = OpenAICodexProvider(default_model="openai-codex/gpt-5.6-sol")+ state_provider = provider._responses_state_provider()+ state = build_responses_state(+ provider=state_provider, model="gpt-5.6-sol",+ input_items=[{"type": "message", "role": "user", "content": "old"}],+ output_items=[{"type": "reasoning", "encrypted_content": "opaque"}],+ usage=provider_base.LLMUsage.reported(input_tokens=90, output_tokens=5),+ )+ entered = asyncio.Event()+ settle = asyncio.Event()+ notices: list[ContextCompactionEvent] = []+ requests: list[str] = []++ async def observe(event) -> None:+ if isinstance(event, ContextCompactionEvent):+ notices.append(event)+ if cancel_during == "terminal" and event.phase == "succeeded":+ entered.set()+ await settle.wait()++ async def fake_request(_url, _headers, body, **_kwargs):+ stage = "compaction" if body["input"][-1].get("type") == "compaction_trigger" else "generation"+ requests.append(stage)+ if stage == cancel_during:+ entered.set()+ await asyncio.Future()+ return provider_base.LLMResponse(content=None, provider_state=build_responses_state(+ provider=state_provider, model="gpt-5.6-sol", input_items=body["input"],+ output_items=[{"type": "compaction", "encrypted_content": "compacted"}],+ ))++ monkeypatch.setattr("nanobot.providers.openai_codex_provider._request_codex", fake_request)+ task = asyncio.create_task(provider.chat(+ [{"role": "user", "content": "new"}], max_tokens=5,+ provider_context=provider_base.ProviderCallContext(+ conversation_state=state.with_pending_messages([{"role": "user", "content": "new"}]),+ context_window_tokens=100, events=EventSink(observe),+ ),+ ))+ await asyncio.wait_for(entered.wait(), timeout=2)+ task.cancel()+ settle.set()+ with pytest.raises(asyncio.CancelledError):+ await task+ terminal = "cancelled" if cancel_during == "compaction" else "succeeded"+ assert [notice.phase for notice in notices] == ["started", terminal]+ assert len({notice.compaction_id for notice in notices}) == 1+ assert requests == (["compaction", "generation"] if cancel_during == "generation" else ["compaction"])++@pytest.mark.asyncioasync def test_codex_stream_surfaces_reasoning_summary(monkeypatch) -> None:def fake_token(**_kwargs):diff --git a/webui/browser/history-hydration.spec.ts b/webui/browser/history-hydration.spec.tsindex 007a84b3b..c9bd39dfe 100644--- a/webui/browser/history-hydration.spec.ts+++ b/webui/browser/history-hydration.spec.ts@@ -112,6 +112,10 @@ async function installBackend(page: Page) {// The fixture's non-consuming observer acknowledges client dispatch, not a model installation.await expect(page.getByLabel("Synthetic frame receipt")).toHaveText(`${"chat_id" in event ? event.chat_id : "-"}/${turn}/${event.event}/${sequence}`);},+ refreshThread() {+ expect(socket, "The fixture must establish its WebSocket before refresh").toBeDefined();+ socket!.send(JSON.stringify({ event: "session_updated", chat_id: A, scope: "thread" }));+ },async ready() {await expect(page.getByLabel("Synthetic transport status")).toHaveText("open");await expect.poll(() => attached.includes(A)).toBe(true);@@ -156,6 +160,52 @@ async function expectBefore(body: Locator, first: string, second: string) {expect(text.indexOf(second), `${second} must follow ${first}`).toBeGreaterThan(text.indexOf(first));}+test("idle compaction stays singular across live updates, thread refresh and cold replay", async ({ page }) => {+ const { backend, body } = await openFixture(page);+ const base = closedTurn("idle-completed", "Before idle compression", "Completed answer before idle compression.");+ await backend.release(await backend.read(), history(base));+ await expect(body.getByText("Completed answer before idle compression.", { exact: true })).toBeVisible();+ const compaction = { event: "context_compaction" as const, chat_id: A, compaction_id: "idle-once" };+ await backend.send({ ...compaction, phase: "started" });+ await expect(body.locator('[data-context-compaction="started"]')).toHaveCount(1);+ await backend.send({ ...compaction, phase: "succeeded" });+ await expect(body.locator('[data-context-compaction="succeeded"]')).toHaveCount(1);++ const completed = history([...base, { ...compaction, phase: "succeeded" }]);+ backend.refreshThread();+ await backend.release(await backend.read(A, null, 1), completed);+ await expect(body.locator('[data-context-compaction="succeeded"]')).toHaveCount(1);+ await expectBefore(body, "Completed answer before idle compression.", "Context compacted");+ await page.reload();+ await backend.ready();+ await backend.release(await backend.read(A, null, 2), completed);+ await expect(body.locator('[data-context-compaction="succeeded"]')).toHaveCount(1);+ await expectBefore(body, "Completed answer before idle compression.", "Context compacted");+ backend.healthy();+});++test("pre-request compaction precedes the answer in live output and history replay", async ({ page }) => {+ const { backend, body } = await openFixture(page);+ const base = closedTurn("before-native", "Previous question", "Previous answer.");+ await backend.release(await backend.read(), history(base));+ await expect(body.getByText("Previous answer.", { exact: true })).toBeVisible();+ const question = input(TURN, "Question requiring native compression");+ const compact: ThreadProjectionEvent = { ...at(TURN, 2, "activity"), event: "context_compaction", compaction_id: "native-before-answer", phase: "succeeded" };+ await backend.send(question);+ await backend.send({ event: "context_compaction", chat_id: A, compaction_id: "native-before-answer", phase: "started" });+ await backend.send(compact);+ await backend.send(delta(3, LIVE));+ await backend.send(end(4, LIVE, "live-wire"));+ const complete: ThreadProjectionEvent = { ...at(TURN, 5, "complete"), event: "turn_end" };+ await backend.send(complete);+ await expectBefore(body, "Context compacted", LIVE);+ backend.refreshThread();+ await backend.release(await backend.read(A, null, 1), history([...base, question, compact, end(4, LIVE, "live-wire"), complete]));+ await expect(body.locator('[data-context-compaction="succeeded"]')).toHaveCount(1);+ await expectBefore(body, "Context compacted", LIVE);+ backend.healthy();+});+for (const width of [1440, 390]) {test(`synthetic live-first latest admits its prefix without refresh, then prepends two cursor pages (${width}px)`, async ({ page }) => {const { backend, body } = await openFixture(page, width);diff --git a/webui/src/lib/thread-transcript.ts b/webui/src/lib/thread-transcript.tsindex 61dd20127..741c1dbbc 100644--- a/webui/src/lib/thread-transcript.ts+++ b/webui/src/lib/thread-transcript.ts@@ -178,8 +178,9 @@ export class ThreadTranscript {registerInput(row: UIMessage, received = true): void {if (row.role === "user" && row.turnId) this.knownTurns.add(row.turnId);- const identity = row.sessionMessage?.message_id- ? `input:${row.sessionMessage.message_id}` : row.role === "user" && row.turnId+ const identity = row.kind === "compaction" && row.compaction+ ? `compaction:${row.compaction.id}` : row.sessionMessage?.message_id+ ? `input:${row.sessionMessage.message_id}` : row.role === "user" && row.turnId? `user:${row.turnId}` : row.turnId && row.turnSeq !== undefined? `fact:${row.turnId}:${row.turnSeq}` : `replay:${row.id}`;if (this.bySource.has(identity)) return;@@ -200,6 +201,9 @@ export class ThreadTranscript {for (const [first, last] of receipt.ranges) addRange(ranges, first, last);members.set(receipt.turn_id, ranges);}+ if (event.event === "context_compaction") {+ return { source: `compaction:${event.compaction_id}`, members, text: null };+ }if (event.event === "user_message") {return { source: event.provenance?.session_message?.message_id? `input:${event.provenance.session_message.message_id}` : turn ? `user:${turn}` : `replay:${event.projection_id}`,diff --git a/webui/src/tests/thread-transcript.test.ts b/webui/src/tests/thread-transcript.test.tsindex b7dc9bf3f..5657ba5c8 100644--- a/webui/src/tests/thread-transcript.test.ts+++ b/webui/src/tests/thread-transcript.test.ts@@ -41,6 +41,52 @@ function receive(thread: ThreadTranscript, ...events: ThreadProjectionEvent[]):}describe("ThreadTranscript admission", () => {+ it.each(["succeeded", "failed", "cancelled"] as const)("reconciles one idle compaction across live phases and history (%s)", (phase) => {+ const thread = new ThreadTranscript();+ const base = [+ input("turn-before-idle", "Question"),+ { ...at("turn-before-idle", 2), event: "stream_end" as const, stream_id: "answer-before-idle", text: "Answer" },+ { ...at("turn-before-idle", 3), event: "turn_end" as const },+ ];+ const completed = { completed_turn_ids: ["turn-before-idle"] };+ expect(thread.accept(history(base, completed), thread.begin("initial"))).toBe(true);+ const compaction = { event: "context_compaction" as const, chat_id: "hydration-chat", compaction_id: "idle-one" };+ receive(thread, { ...compaction, phase: "started" });+ const staleRead = thread.begin("latest");+ receive(thread, { ...compaction, phase });+ expect(thread.accept(history(base, completed), staleRead)).toBe(true);+ expect(thread.messages.map((row) => row.id).filter((id) => id === "compaction-idle-one")).toHaveLength(1);+ expect(thread.messages.at(-1)?.compaction?.phase).toBe(phase);++ const body = history([...base, { ...compaction, phase }], completed);+ expect(thread.accept(body, thread.begin("latest"))).toBe(true);+ expect(thread.messages.map((row) => row.content)).toEqual(["Question", "Answer", ""]);+ expect(thread.messages[2]).toMatchObject({ id: "compaction-idle-one", compaction: { phase } });+ const owners = thread.save().units.filter((unit) => unit.rows.has("compaction-idle-one"));+ expect(owners).toHaveLength(1);+ expect(thread.accept(body, thread.begin("latest"))).toBe(true);+ const restored = new ThreadTranscript([], thread.save());+ receive(restored, { ...compaction, phase });+ expect(restored.accept(body, restored.begin("latest"))).toBe(true);+ expect(restored.messages.map((row) => row.id).filter((id) => id === "compaction-idle-one")).toHaveLength(1);+ });++ it("keeps distinct native and idle compactions when history refreshes a live idle notice", () => {+ const thread = new ThreadTranscript();+ const native: ThreadProjectionEvent = { ...at("turn-native", 2), event: "context_compaction", compaction_id: "native", phase: "succeeded" };+ const base: ThreadProjectionEvent[] = [+ input("turn-native", "Question"), native,+ { ...at("turn-native", 3), event: "stream_end", stream_id: "answer-native", text: "Answer" },+ { ...at("turn-native", 4), event: "turn_end" },+ ];+ const completed = { completed_turn_ids: ["turn-native"] };+ expect(thread.accept(history(base, completed), thread.begin("initial"))).toBe(true);+ const idle: ThreadProjectionEvent = { event: "context_compaction", chat_id: "hydration-chat", compaction_id: "idle", phase: "succeeded" };+ receive(thread, idle);+ expect(thread.accept(history([...base, idle], completed), thread.begin("latest"))).toBe(true);+ expect(thread.messages.map((row) => row.compaction?.id ?? row.content)).toEqual(["Question", "native", "Answer", "idle"]);+ });+it("installs an older safe prefix without replacing or redirecting the received foreground", () => {const thread = new ThreadTranscript();const read = thread.begin("initial");