Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
patch: Separate code-session history reads from live state (#1924)
Ali Khokharaafeb4171f48
diff --git a/src/free_claude_code/application/code_sessions/models.py b/src/free_claude_code/application/code_sessions/models.pyindex 5e2bb885..c54ec741 100644--- a/src/free_claude_code/application/code_sessions/models.py+++ b/src/free_claude_code/application/code_sessions/models.py@@ -115,6 +115,27 @@ class CodeItemPage:next_before: tuple[int, int] | None = None+@dataclass(frozen=True, slots=True)+class CodeHistory:+ session: CodeSession+ run: CodeRun | None+ items: tuple[CodeItem, ...]+ prompts: tuple[CodePrompt, ...]+ runs: tuple[CodeRun, ...]+ active_prompt_ids: tuple[str, ...]+ next_before: tuple[int, int] | None+++@dataclass(frozen=True, slots=True)+class CodeExecutionSeed:+ session: CodeSession+ run: CodeRun | None+ sequence: int+ items: tuple[CodeItem, ...]+ prompts: tuple[CodePrompt, ...]+ runs: tuple[CodeRun, ...]++class CodeModel(Record):id: strdisplay_name: strdiff --git a/src/free_claude_code/application/code_sessions/ports.py b/src/free_claude_code/application/code_sessions/ports.pyindex f65ad9a8..2bf7e023 100644--- a/src/free_claude_code/application/code_sessions/ports.py+++ b/src/free_claude_code/application/code_sessions/ports.py@@ -9,6 +9,8 @@ from free_claude_code.core.json_types import JsonObjectfrom .models import (CodeCatalog,CodeDetail,+ CodeExecutionSeed,+ CodeHistory,CodeItem,CodeItemPage,CodeMode,@@ -86,6 +88,37 @@ class HarnessFactory(Protocol):class CodeStore(Protocol):+ async def execution_seed(self, session_id: str) -> CodeExecutionSeed: ...++ async def read_history(+ self,+ session_id: str,+ before: tuple[int, int] | None,+ include_item_ids: Sequence[str],+ ) -> CodeHistory: ...++ async def get_native_item(+ self,+ session_id: str,+ turn_id: str,+ item_id: str,+ ) -> CodeItem | None: ...++ async def run_items(self, session_id: str, run_id: str) -> tuple[CodeItem, ...]: ...++ async def get_prompt(+ self, session_id: str, prompt_id: str+ ) -> CodePrompt | None: ...++ async def has_prompt_request(+ self,+ session_id: str,+ generation: str,+ request_id: str | int,+ ) -> bool: ...++ async def has_native_turn(self, session_id: str, turn_id: str) -> bool: ...+async def start(self) -> None: ...async def close(self) -> None: ...diff --git a/src/free_claude_code/application/code_sessions/service.py b/src/free_claude_code/application/code_sessions/service.pyindex dc756a75..b8ec855d 100644--- a/src/free_claude_code/application/code_sessions/service.py+++ b/src/free_claude_code/application/code_sessions/service.py@@ -2,7 +2,8 @@import asyncioimport uuid-from collections.abc import Coroutine, Sequence+from collections.abc import AsyncIterator, Callable, Coroutine, Sequence+from contextlib import asynccontextmanagerfrom dataclasses import dataclass, fieldfrom pathlib import Path@@ -37,14 +38,35 @@ from .ports import CodeStore, HarnessConnection, HarnessFactory, HarnessSelectiofrom .state import SessionProgress, SessionState+@dataclass(slots=True)+class _SessionGate:+ on_idle: Callable[[], None]+ lock: asyncio.Lock = field(default_factory=asyncio.Lock)+ users: int = 0++ async def __aenter__(self) -> _SessionGate:+ self.users += 1+ try:+ await self.lock.acquire()+ except BaseException:+ self.users -= 1+ self.on_idle()+ raise+ return self++ async def __aexit__(self, *_: object) -> None:+ self.lock.release()+ self.users -= 1+ self.on_idle()++@dataclass(slots=True)class _SessionRuntime:state: SessionState- lock: asyncio.Lock = field(default_factory=asyncio.Lock)+ lock: _SessionGatefinished: asyncio.Event = field(default_factory=asyncio.Event)connection: HarnessConnection | None = Nonegeneration: str | None = None- version: int = 0job: asyncio.Task[None] | None = Noneflush_task: asyncio.Task[None] | None = Noneinterrupt_task: asyncio.Task[None] | None = None@@ -60,7 +82,8 @@ class CodeService:self._store = storeself._harness = harnessself._owners: dict[str, _SessionRuntime] = {}- self._load_lock = asyncio.Lock()+ self._gates: dict[str, _SessionGate] = {}+ self._version = 0self._events = EventPublisher()self.epoch = str(uuid.uuid4())self._commands: set[asyncio.Task] = set()@@ -168,7 +191,7 @@ class CodeService:await asyncio.wait(jobs, timeout=5)await asyncio.gather(*(self._close_connection(owner) for owner in owners))for owner in owners:- async with owner.lock:+ async with self._locked(owner):if owner.state.busy and not owner.storage_failed:try:await self._finish_locked(@@ -213,23 +236,44 @@ class CodeService:if not self._accepting:raise CodeUnavailableError(self._message or "Code sessions is unavailable.")+ def _gate(self, session_id: str) -> _SessionGate:+ if session_id not in self._gates:+ self._gates[session_id] = _SessionGate(+ lambda: self._discard_gate(session_id)+ )+ return self._gates[session_id]++ def _discard_gate(self, session_id: str) -> None:+ gate = self._gates.get(session_id)+ if gate is not None and not gate.users and session_id not in self._owners:+ del self._gates[session_id]++ @asynccontextmanager+ async def _locked(self, owner: _SessionRuntime) -> AsyncIterator[None]:+ async with owner.lock:+ try:+ yield+ finally:+ if not owner.storage_failed:+ owner.state.prune()+async def _owner(self, session_id: str) -> _SessionRuntime:await self._wait_for_store()_validate_id(session_id)- async with self._load_lock:+ async with self._gate(session_id) as gate:owner = self._owners.get(session_id)if owner is None:- session = await self._store.get_session(session_id)- items = await self._store.items(session_id, None, None)- runs = await self._store.runs(session_id)+ seed = await self._store.execution_seed(session_id)owner = _SessionRuntime(SessionState(- session,- await self._store.latest_run(session_id),- items,- await self._store.prompts(session_id),- runs,- )+ seed.session,+ seed.run,+ seed.items,+ seed.prompts,+ seed.runs,+ sequence=seed.sequence,+ ),+ gate,)if not owner.state.busy:owner.finished.set()@@ -259,7 +303,7 @@ class CodeService:))owner = await self._owner(session.id)- async with owner.lock:+ async with self._locked(owner):self._publish(owner, "session.updated")return session@@ -301,68 +345,33 @@ class CodeService:before: tuple[int, int] | None = None,include_item_ids: Sequence[str] = (),) -> CodeDetail:- owner = await self._owner(session_id)- async with owner.lock:- self._check_owner(owner)- await self._flush_locked(owner)- page_before = before- if owner.state.busy and owner.state.run:- active_start = (owner.state.run.ordinal, 0)- page_before = min(before, active_start) if before else active_start- page = await self._store.item_page(session_id, page_before, 50)- included_ids = {- *owner.state.active_review_ids(owner.generation),- *include_item_ids,- }- extra = [- item- for item in owner.state.items.values()- if (- owner.state.busy- and owner.state.run- and item.run_id == owner.state.run.id- )- or item.id in included_ids- or (- item.kind == "prompt"- and owner.state.prompts[item.id].status in {"pending", "answering"}- )- ]- selected = sorted(- {item.id: item for item in [*page.items, *extra]}.values(),- key=lambda item: (owner.state.runs[item.run_id].ordinal, item.sequence),- )- prompt_ids = {item.id for item in selected if item.kind == "prompt"}- prompts = tuple(- prompt- for prompt in owner.state.prompts.values()- if prompt.id in prompt_ids+ await self._wait_for_store()+ _validate_id(session_id)+ async with self._gate(session_id):+ owner = self._owners.get(session_id)+ active_reviews: tuple[str, ...] = ()+ if owner is not None:+ self._check_owner(owner)+ await self._flush_locked(owner)+ active_reviews = owner.state.active_review_ids(owner.generation)+ owner.state.prune()+ snapshot = await self._store.read_history(+ session_id,+ before,+ (*include_item_ids, *active_reviews),)return CodeDetail(- owner.state.session,- owner.state.run,- tuple(selected),- prompts,+ snapshot.session,+ snapshot.run,+ snapshot.items,+ snapshot.prompts,self.epoch,- owner.version,+ self._version,self.cursor,- page.next_before,- tuple(- {- run.id: run- for run in (- *page.runs,- *(owner.state.runs[item.run_id] for item in extra),- *((owner.state.run,) if owner.state.run else ()),- )- }.values()- ),- tuple(- prompt.id- for prompt in owner.state.prompts.values()- if prompt.status in {"pending", "answering"}- ),- owner.state.active_review_ids(owner.generation),+ snapshot.next_before,+ snapshot.runs,+ snapshot.active_prompt_ids,+ active_reviews,)async def update_settings(@@ -375,7 +384,7 @@ class CodeService:) -> CodeSession:SessionState.validate_settings_fields(changes)owner = await self._owner(session_id)- async with owner.lock:+ async with self._locked(owner):self._editable(owner, revision)updates = owner.state.settings_updates(changes)catalog = (@@ -417,7 +426,7 @@ class CodeService:"Enter a message of at most 1,000,000 characters.")owner = await self._owner(session_id)- async with owner.lock:+ async with self._locked(owner):previous = await self._store.get_run(session_id, operation_id)if previous:owner.state.check_receipt(previous, text)@@ -432,7 +441,7 @@ class CodeService:selection = await self._harness.prepare(selected.model, selected.reasoning_effort, selected.mode)- async with owner.lock:+ async with self._locked(owner):previous = await self._store.get_run(session_id, operation_id)if previous:owner.state.check_receipt(previous, text)@@ -465,7 +474,7 @@ class CodeService:) -> CodeRun:_validate_id(operation_id)owner = await self._owner(session_id)- async with owner.lock:+ async with self._locked(owner):receipt = await self._store.get_run(session_id, operation_id)if receipt is None or receipt.session_id != session_id:raise CodeNotFoundError("Code turn not found.")@@ -493,9 +502,13 @@ class CodeService:) -> CodePrompt:_validate_id(response_id)owner = await self._owner(session_id)- async with owner.lock:+ async with self._locked(owner):self._require_available()connection = owner.connection+ if prompt_id not in owner.state.prompts:+ saved = await self._store.get_prompt(session_id, prompt_id)+ if saved is not None:+ owner.state.accept_prompt(saved)prompt = owner.state.answerable_prompt(prompt_id,response_id,@@ -523,7 +536,7 @@ class CodeService:if await self._store.is_deleted(session_id):return Noneowner = await self._owner(session_id)- async with owner.lock:+ async with self._locked(owner):self._check_owner(owner)if owner.state.session.status != "ready":if owner.state.session.status == "delete_uncertain" and (@@ -563,7 +576,7 @@ class CodeService:owner.generation = connection.generationthread_id = owner.state.session.native_thread_idif thread_id is None:- async with owner.lock:+ async with self._locked(owner):if owner.state.run and owner.state.run.stop_requested:await self._finish_locked(owner, "interrupted")return@@ -577,7 +590,7 @@ class CodeService:native = await connection.create_thread()else:native = None- async with owner.lock:+ async with self._locked(owner):if native is not None:await self._commit_progress(owner,@@ -587,6 +600,7 @@ class CodeService:)owner.loaded_thread_id = native.idawait self._recover_locked(owner, native)+ native = Nonerun = owner.state.active_run(run_id)if run is None:return@@ -601,7 +615,7 @@ class CodeService:)assert run is not None and defaults is not Noneturn_id = await connection.start_turn(run.text, selection, run.id, defaults)- async with owner.lock:+ async with self._locked(owner):if owner.state.active_run(run_id) is None:returnawait self._commit_progress(owner, owner.state.bind_turn(turn_id))@@ -625,7 +639,12 @@ class CodeService:async def _recover_locked(self, owner: _SessionRuntime, native: NativeThread) -> None:- for turn, run in owner.state.match_history(native):+ saved_runs = await self._store.runs(owner.state.session.id)+ for turn, run in owner.state.match_history(native, saved_runs):+ owner.state.remember_items(+ await self._store.run_items(owner.state.session.id, run.id),+ (run,),+ )for item in turn.items:self._update_item(owner, item, run, historical=True)items = owner.state.pending_items@@ -639,6 +658,7 @@ class CodeService:runs=[run.model_dump(mode="json")],items=[item.model_dump(mode="json") for item in items],)+ owner.state.prune()def _schedule_interrupt(self, owner: _SessionRuntime) -> None:run, connection = owner.state.run, owner.connection@@ -671,7 +691,7 @@ class CodeService:returnexcept Exception:pass- async with owner.lock:+ async with self._locked(owner):if (owner.connection is not connectionor owner.state.run is None@@ -681,7 +701,7 @@ class CodeService:returnself._detach_connection_locked(owner)await connection.close()- async with owner.lock:+ async with self._locked(owner):if owner.state.run and owner.state.run.id == run.id and owner.state.busy:await self._finish_locked(owner,@@ -696,14 +716,14 @@ class CodeService:if connection is None:returntry:- async with owner.lock:+ async with self._locked(owner):if (owner.generation != prompt.generationor owner.state.pending_answer(prompt.id, prompt.generation) is None):returnawait connection.respond(prompt.request_id, response)- async with owner.lock:+ async with self._locked(owner):if owner.generation == prompt.generation:resolved = owner.state.resolve_answer(prompt.id, prompt.generation)if resolved is not None:@@ -713,7 +733,7 @@ class CodeService:)self._publish_prompt(owner, resolved)except CodeConflictError:- async with owner.lock:+ async with self._locked(owner):expired = owner.state.expire_answer(prompt.id)if expired is not None:await self._commit_progress(@@ -733,7 +753,7 @@ class CodeService:async def _event(self, owner: _SessionRuntime, event: HarnessEvent) -> None:try:- async with owner.lock:+ async with self._locked(owner):if (owner.deletedor event.generation != owner.generation@@ -747,7 +767,17 @@ class CodeService:self._publish(owner, "session.updated")returnrun = owner.state.run- matches = owner.state.matches_turn(event)+ known_turn = False+ if (+ event.kind == "turn_started"+ and event.turn_id is not None+ and run is not None+ and run.native_turn_id is None+ ):+ known_turn = await self._store.has_native_turn(+ owner.state.session.id, event.turn_id+ )+ matches = owner.state.matches_turn(event, known_turn=known_turn)if (event.kind in {"turn_started", "turn_completed"}and matches@@ -770,13 +800,14 @@ class CodeService:and event.item.kind == "subagent_auto_review"and run is not None):+ await self._remember_native_item(owner, event.item)item, changed = owner.state.stage_review(event.item, event.generation)if item is None:returnif changed:- owner.version += 1+ self._version += 1await self._flush_locked(owner)elif (event.kind == "item"@@ -784,6 +815,7 @@ class CodeService:and matchesand run is not None):+ await self._remember_native_item(owner, event.item)self._update_item(owner, event.item, run)if event.item.complete or owner.state.dirty_characters >= 4096:await self._flush_locked(owner)@@ -793,7 +825,13 @@ class CodeService:request = event.promptif request.turn_id is not None and not matches:return- if owner.state.has_prompt(request, event.generation):+ if owner.state.has_prompt(+ request, event.generation+ ) or await self._store.has_prompt_request(+ owner.state.session.id,+ event.generation,+ request.request_id,+ ):returnawait self._flush_locked(owner)progress = owner.state.prepare_prompt(request, event.generation)@@ -840,6 +878,21 @@ class CodeService:type(exc).__name__,)+ async def _remember_native_item(+ self, owner: _SessionRuntime, update: ItemUpdate+ ) -> None:+ if owner.state.native_item(update) is not None:+ return+ saved = await self._store.get_native_item(+ owner.state.session.id, update.turn_id, update.item_id+ )+ if saved is not None:+ run = owner.state.runs.get(saved.run_id)+ if run is None:+ run = await self._store.get_run(owner.state.session.id, saved.run_id)+ assert run is not None+ owner.state.remember_items((saved,), (run,))+def _update_item(self,owner: _SessionRuntime,@@ -850,12 +903,12 @@ class CodeService:) -> None:_, changed = owner.state.stage_item(update, run, historical=historical)if changed:- owner.version += 1+ self._version += 1async def _flush_later(self, owner: _SessionRuntime) -> None:await asyncio.sleep(0.25)try:- async with owner.lock:+ async with self._locked(owner):if not owner.deleted and not owner.storage_failed:await self._flush_locked(owner)except Exception as exc:@@ -948,11 +1001,11 @@ class CodeService:return connectionasync def _close_connection(self, owner: _SessionRuntime) -> None:- async with owner.lock:+ async with self._locked(owner):connection = self._detach_connection_locked(owner)if connection is not None:await connection.close()- async with owner.lock:+ async with self._locked(owner):if not owner.deleted and not owner.storage_failed:try:if (@@ -975,7 +1028,7 @@ class CodeService:*,interrupted: bool = False,) -> None:- async with owner.lock:+ async with self._locked(owner):if (owner.state.run is Noneor owner.state.run.id != run_id@@ -984,7 +1037,7 @@ class CodeService:returntry:await self._close_connection(owner)- async with owner.lock:+ async with self._locked(owner):if (owner.state.runand owner.state.run.id == run_id@@ -1035,12 +1088,11 @@ class CodeService:passnative_complete = Trueawait self._close_connection(owner)- async with owner.lock:+ async with self._locked(owner):await self._store.delete(owner.state.session.id)owner.deleted = Trueowner.state.discard_deleted_history()self._publish(owner, "session.deleted")- async with self._load_lock:if self._owners.get(owner.state.session.id) is owner:del self._owners[owner.state.session.id]except Exception as exc:@@ -1048,7 +1100,7 @@ class CodeService:status = ("ready" if isinstance(exc, CodeConflictError) else "delete_uncertain")- async with owner.lock:+ async with self._locked(owner):progress = owner.state.deletion_failed(status, _error_message(exc))try:await self._commit_progress(owner, progress)@@ -1080,12 +1132,12 @@ class CodeService:"session": owner.state.session.model_dump(mode="json"),"run": owner.state.run.model_dump(mode="json") if owner.state.run else None,"active_review_ids": list(owner.state.active_review_ids(owner.generation)),- "version": owner.version,+ "version": self._version,"epoch": self.epoch,}def _publish(self, owner: _SessionRuntime, event: str, **data: JsonValue) -> None:- owner.version += 1+ self._version += 1payload = self._summary(owner)for key, value in data.items():payload[key] = valuediff --git a/src/free_claude_code/application/code_sessions/state.py b/src/free_claude_code/application/code_sessions/state.pyindex cdb353a5..117350bc 100644--- a/src/free_claude_code/application/code_sessions/state.py+++ b/src/free_claude_code/application/code_sessions/state.py@@ -48,16 +48,17 @@ class SessionState:items: Sequence[CodeItem],prompts: Sequence[CodePrompt],runs: Sequence[CodeRun],+ *,+ sequence: int = 0,) -> None:self._session = sessionself._run = runself._items = {item.id: item for item in items}self._prompts = {prompt.id: prompt for prompt in prompts}self._runs = {run.id: run for run in runs}- self._sequence = max((item.sequence for item in items), default=0)- self._known_turns = {run.native_turn_id for run in runs if run.native_turn_id}- if run and run.native_turn_id:- self._known_turns.add(run.native_turn_id)+ self._sequence = max(+ sequence, max((item.sequence for item in items), default=0)+ )self._dirty: set[str] = set()self._dirty_characters = 0self._review_generations: dict[str, str] = {}@@ -134,8 +135,6 @@ class SessionState:self._runs[run.id] = runif self._run is not None and self._run.id == run.id:self._run = run- if run.native_turn_id:- self._known_turns.add(run.native_turn_id)for item in progress.items:self._items[item.id] = itemself._sequence = max(self._sequence, item.sequence)@@ -146,6 +145,34 @@ class SessionState:self._dirty.clear()self._dirty_characters = 0+ def remember_items(+ self, items: Sequence[CodeItem], runs: Sequence[CodeRun]+ ) -> None:+ """Load durable identities needed by one serialized operation."""+ for item in items:+ self._items.setdefault(item.id, item)+ for run in runs:+ self._runs.setdefault(run.id, run)++ def prune(self) -> None:+ """Release acknowledged history after its events have been published."""+ self._prompts = {+ key: prompt+ for key, prompt in self._prompts.items()+ if prompt.status in {"pending", "answering"}+ }+ pinned = self._dirty | self._prompts.keys() | self._review_generations.keys()+ self._items = {+ key: item+ for key, item in self._items.items()+ if key in pinned+ or (self.busy and self._run and item.run_id == self._run.id)+ }+ run_ids = {item.run_id for item in self._items.values()}+ if self._run is not None:+ run_ids.add(self._run.id)+ self._runs = {key: run for key, run in self._runs.items() if key in run_ids}+def discard_deleted_history(self) -> None:self._items.clear()self._prompts.clear()@@ -323,7 +350,7 @@ class SessionState:self._session.native_thread_id,}- def matches_turn(self, event: HarnessEvent) -> bool:+ def matches_turn(self, event: HarnessEvent, *, known_turn: bool) -> bool:run = self._runreturn bool(run is not None@@ -335,7 +362,7 @@ class SessionState:or (run.native_turn_id is Noneand event.kind == "turn_started"- and event.turn_id not in self._known_turns+ and not known_turn)))@@ -348,8 +375,9 @@ class SessionState:)def match_history(- self, native: NativeThread+ self, native: NativeThread, runs: Sequence[CodeRun]) -> tuple[tuple[NativeTurn, CodeRun], ...]:+ saved = {run.id: run for run in runs}mapped: dict[str, CodeRun] = {}for turn in native.turns:identities = {@@ -359,11 +387,11 @@ class SessionState:}candidates = [run- for run in self._runs.values()+ for run in saved.values()if run.native_turn_id == turn.id or run.id in identities]if len(candidates) > 1 or any(- identity not in self._runs for identity in identities+ identity not in saved for identity in identities):raise CodeUnavailableError("Codex history contains conflicting turn identities. Saved history was retained."@@ -382,7 +410,7 @@ class SessionState:unmatched = [turn for turn in native.turns if turn.id not in mapped]pending = [run- for run in self._runs.values()+ for run in saved.values()if run.submission_startedand run.native_turn_id is Noneand run.id not in {value.id for value in mapped.values()}@@ -410,7 +438,7 @@ class SessionState:for turn in native.turns)- def _native_item(self, update: ItemUpdate) -> CodeItem | None:+ def native_item(self, update: ItemUpdate) -> CodeItem | None:return next((item@@ -424,9 +452,7 @@ class SessionState:def stage_item(self, update: ItemUpdate, run: CodeRun, *, historical: bool = False) -> tuple[CodeItem, bool]:- if update.kind != "subagent_auto_review":- self._known_turns.add(update.turn_id)- existing = self._native_item(update)+ existing = self.native_item(update)if existing is None and update.kind == "user":if update.client_id is not None and update.client_id != run.id:raise CodeUnavailableError(@@ -475,7 +501,7 @@ class SessionState:) -> tuple[CodeItem | None, bool]:if self._run is None:return None, False- existing = self._native_item(update)+ existing = self.native_item(update)if existing is not None and existing.complete and not update.complete:return None, Falsetarget = self._runs[existing.run_id] if existing else self._rundiff --git a/src/free_claude_code/runtime/code_sessions_sqlite.py b/src/free_claude_code/runtime/code_sessions_sqlite.pyindex b3d52279..c9846f32 100644--- a/src/free_claude_code/runtime/code_sessions_sqlite.py+++ b/src/free_claude_code/runtime/code_sessions_sqlite.py@@ -7,7 +7,10 @@ from collections.abc import Callable, Sequencefrom contextlib import closingfrom free_claude_code.application.code_sessions.models import (+ ACTIVE_RUN_STATUSES,CodeConflictError,+ CodeExecutionSeed,+ CodeHistory,CodeItem,CodeItemPage,CodeNotFoundError,@@ -100,6 +103,80 @@ def _session(connection: sqlite3.Connection, session_id: str) -> CodeSession:return _record(CodeSession, row)+def _by_ids[T: Record](+ connection: sqlite3.Connection,+ model: type[T],+ session_id: str,+ ids: Sequence[str],+) -> tuple[T, ...]:+ tables: dict[type[Record], str] = {+ CodeItem: "code_items",+ CodeRun: "code_runs",+ CodePrompt: "code_prompts",+ }+ table = tables[model]+ records: list[T] = []+ unique = tuple(dict.fromkeys(ids))+ for start in range(0, len(unique), 500):+ batch = unique[start : start + 500]+ records.extend(+ _record(model, row)+ for row in connection.execute(+ f"SELECT * FROM {table} WHERE session_id = ? AND id IN ({','.join('?' for _ in batch)})",+ (session_id, *batch),+ )+ )+ return tuple(records)+++def _latest_run(connection: sqlite3.Connection, session_id: str) -> CodeRun | None:+ row = connection.execute(+ "SELECT * FROM code_runs WHERE session_id = ? ORDER BY ordinal DESC LIMIT 1",+ (session_id,),+ ).fetchone()+ return _record(CodeRun, row) if row else None+++def _active_prompts(+ connection: sqlite3.Connection, session_id: str+) -> tuple[CodePrompt, ...]:+ return tuple(+ _record(CodePrompt, row)+ for row in connection.execute(+ "SELECT * FROM code_prompts WHERE session_id = ? AND status IN ('pending', 'answering') ORDER BY id",+ (session_id,),+ )+ )+++def _item_page(+ connection: sqlite3.Connection,+ session_id: str,+ before: tuple[int, int] | None,+ limit: int | None,+) -> CodeItemPage:+ parameters: list[object] = [session_id]+ query = "SELECT i.*, r.ordinal AS run_ordinal FROM code_items i JOIN code_runs r ON (r.session_id, r.id) = (i.session_id, i.run_id) WHERE i.session_id = ?"+ if before:+ query += " AND (r.ordinal, i.sequence) < (?, ?)"+ parameters.extend(before)+ query += " ORDER BY r.ordinal DESC, i.sequence DESC"+ if limit is not None:+ query += " LIMIT ?"+ parameters.append(limit + 1)+ rows = connection.execute(query, parameters).fetchall()+ selected = rows if limit is None else rows[:limit]+ runs = _by_ids(connection, CodeRun, session_id, [row["run_id"] for row in selected])+ last = (+ selected[-1] if selected and limit is not None and len(rows) > limit else None+ )+ return CodeItemPage(+ tuple(_record(CodeItem, row) for row in reversed(selected)),+ tuple(sorted(runs, key=lambda run: run.ordinal)),+ (last["run_ordinal"], last["sequence"]) if last else None,+ )++def _idle(connection: sqlite3.Connection, session_id: str) -> None:if (connection.execute(@@ -470,39 +547,151 @@ class SQLiteCodeStore:) -> CodeItemPage:def operation(connection: sqlite3.Connection) -> CodeItemPage:connection.execute("BEGIN")- parameters: list[object] = [session_id]- query = "SELECT i.*, r.ordinal AS run_ordinal FROM code_items i JOIN code_runs r ON (r.session_id, r.id) = (i.session_id, i.run_id) WHERE i.session_id = ?"- if before:- query += " AND (r.ordinal, i.sequence) < (?, ?)"- parameters.extend(before)- query += " ORDER BY r.ordinal DESC, i.sequence DESC"- if limit is not None:- query += " LIMIT ?"- parameters.append(limit + 1)- rows = connection.execute(query, parameters).fetchall()- selected = rows if limit is None else rows[:limit]- run_ids = {row["run_id"] for row in selected}- runs = tuple(- _record(CodeRun, row)+ return _item_page(connection, session_id, before, limit)++ return await self._run(operation)++ async def read_history(+ self,+ session_id: str,+ before: tuple[int, int] | None,+ include_item_ids: Sequence[str],+ ) -> CodeHistory:+ def operation(connection: sqlite3.Connection) -> CodeHistory:+ connection.execute("BEGIN")+ session = _session(connection, session_id)+ run = _latest_run(connection, session_id)+ active = run is not None and run.status in ACTIVE_RUN_STATUSES+ boundary = before+ if active and run is not None:+ start = (run.ordinal, 0)+ boundary = min(before, start) if before else start+ page = _item_page(connection, session_id, boundary, 50)+ active_prompts = _active_prompts(connection, session_id)+ extras = _by_ids(+ connection,+ CodeItem,+ session_id,+ (*include_item_ids, *(prompt.id for prompt in active_prompts)),+ )+ items = {item.id: item for item in (*page.items, *extras)}+ if active and run is not None:for row in connection.execute(- "SELECT * FROM code_runs WHERE session_id = ? ORDER BY ordinal",- (session_id,),+ "SELECT * FROM code_items WHERE session_id = ? AND run_id = ?",+ (session_id, run.id),+ ):+ item = _record(CodeItem, row)+ items[item.id] = item+ run_ids = {item.run_id for item in items.values()}+ if run is not None:+ run_ids.add(run.id)+ runs = _by_ids(connection, CodeRun, session_id, tuple(run_ids))+ ordinals = {run.id: run.ordinal for run in runs}+ selected = tuple(+ sorted(+ items.values(),+ key=lambda item: (ordinals[item.run_id], item.sequence),)- if row["id"] in run_ids)- last = (- selected[-1]- if selected and limit is not None and len(rows) > limit- else None+ prompts = _by_ids(+ connection,+ CodePrompt,+ session_id,+ [item.id for item in selected if item.kind == "prompt"],+ )+ return CodeHistory(+ session,+ run,+ selected,+ prompts,+ tuple(sorted(runs, key=lambda run: run.ordinal)),+ tuple(prompt.id for prompt in active_prompts),+ page.next_before,+ )++ return await self._run(operation)++ async def execution_seed(self, session_id: str) -> CodeExecutionSeed:+ def operation(connection: sqlite3.Connection) -> CodeExecutionSeed:+ connection.execute("BEGIN")+ session = _session(connection, session_id)+ run = _latest_run(connection, session_id)+ sequence = connection.execute(+ "SELECT coalesce(max(sequence), 0) FROM code_items WHERE session_id = ?",+ (session_id,),+ ).fetchone()[0]+ prompts = _active_prompts(connection, session_id)+ items = _by_ids(+ connection, CodeItem, session_id, [prompt.id for prompt in prompts])- return CodeItemPage(- tuple(_record(CodeItem, row) for row in reversed(selected)),- runs,- (last["run_ordinal"], last["sequence"]) if last else None,+ ids = {item.run_id for item in items}+ if run is not None:+ ids.add(run.id)+ return CodeExecutionSeed(+ session,+ run,+ sequence,+ items,+ prompts,+ _by_ids(connection, CodeRun, session_id, tuple(ids)),)return await self._run(operation)+ async def get_native_item(+ self, session_id: str, turn_id: str, item_id: str+ ) -> CodeItem | None:+ def operation(connection: sqlite3.Connection) -> CodeItem | None:+ row = connection.execute(+ "SELECT * FROM code_items WHERE session_id = ? AND native_turn_id = ? AND native_item_id = ?",+ (session_id, turn_id, item_id),+ ).fetchone()+ return _record(CodeItem, row) if row else None++ return await self._run(operation)++ async def run_items(self, session_id: str, run_id: str) -> tuple[CodeItem, ...]:+ return await self._run(+ lambda connection: tuple(+ _record(CodeItem, row)+ for row in connection.execute(+ "SELECT * FROM code_items WHERE session_id = ? AND run_id = ? ORDER BY sequence",+ (session_id, run_id),+ )+ )+ )++ async def get_prompt(self, session_id: str, prompt_id: str) -> CodePrompt | None:+ return await self._run(+ lambda connection: next(+ iter(_by_ids(connection, CodePrompt, session_id, (prompt_id,))), None+ )+ )++ async def has_prompt_request(+ self, session_id: str, generation: str, request_id: str | int+ ) -> bool:+ return await self._run(+ lambda connection: (+ connection.execute(+ "SELECT 1 FROM code_prompts WHERE session_id = ? AND generation = ? AND request_id = ?",+ (session_id, generation, json.dumps(request_id)),+ ).fetchone()+ is not None+ )+ )++ async def has_native_turn(self, session_id: str, turn_id: str) -> bool:+ return await self._run(+ lambda connection: (+ connection.execute(+ "SELECT 1 FROM code_runs WHERE session_id = ? AND native_turn_id = ?",+ (session_id, turn_id),+ ).fetchone()+ is not None+ )+ )+async def prompts(self, session_id: str) -> tuple[CodePrompt, ...]:return await self._run(lambda connection: tuple(diff --git a/src/free_claude_code/runtime/codex_app_server.py b/src/free_claude_code/runtime/codex_app_server.pyindex 996dcb51..78531574 100644--- a/src/free_claude_code/runtime/codex_app_server.py+++ b/src/free_claude_code/runtime/codex_app_server.py@@ -287,6 +287,7 @@ class CodexAppServer:future.set_exception(CodeUnavailableError(message))self._pending.clear()self._requests.clear()+ self._protocol.clear()# A failed pipe does not prove the native agent has stopped working.# Keep the session reserved until its owned process is actually gone.await self._reap_owned_process()@@ -526,6 +527,7 @@ class CodexAppServer:await self._reap_owned_process()if self._reader is not None:await self._reader+ self._protocol.clear()if self._dispatcher is not None:await self._dispatcherdiff --git a/src/free_claude_code/runtime/codex_protocol.py b/src/free_claude_code/runtime/codex_protocol.pyindex 5dc7bf6f..694dda34 100644--- a/src/free_claude_code/runtime/codex_protocol.py+++ b/src/free_claude_code/runtime/codex_protocol.py@@ -46,7 +46,10 @@ class _Item:class CodexProtocol:def __init__(self, generation: str) -> None:self.generation = generation- self._items: dict[tuple[str, str], _Item] = {}+ self._items: dict[tuple[str, str, str], _Item] = {}++ def clear(self) -> None:+ self._items.clear()def notification(self, method: str, params: JsonObject) -> HarnessEvent | None:thread_id = string_value(params.get("threadId")) or None@@ -74,6 +77,12 @@ class CodexProtocol:context_used_tokens=used,)if method in {"turn/started", "turn/completed"}:+ if method == "turn/completed":+ self._items = {+ key: item+ for key, item in self._items.items()+ if key[:2] != (thread_id, turn_id)+ }status: RunStatus = "completed"if turn.get("status") == "interrupted":status = "interrupted"@@ -152,7 +161,20 @@ class CodexProtocol:item_id = string_value(params.get("itemId")) or string_value(raw.get("id"))if not item_id:return None- item = self._items.setdefault((turn_id, item_id), _Item())+ if method not in {+ "item/started",+ "item/completed",+ "item/agentMessage/delta",+ "item/reasoning/summaryTextDelta",+ "item/reasoning/textDelta",+ "item/reasoning/summaryPartAdded",+ "item/commandExecution/outputDelta",+ "item/fileChange/outputDelta",+ "item/fileChange/patchUpdated",+ "item/mcpToolCall/progress",+ }:+ return None+ item = self._items.setdefault((thread_id, turn_id, item_id), _Item())complete = method == "item/completed"delta = string_value(params.get("delta"))if method in {"item/started", "item/completed"}:@@ -209,8 +231,14 @@ class CodexProtocol:item_id = string_value(raw.get("id"))if not turn_id or not item_id:continue- accumulated = self._items.setdefault((turn_id, item_id), _Item())- accumulated.raw = {**accumulated.raw, **raw}+ live = self._items.get((thread_id, turn_id, item_id), _Item())+ accumulated = _Item(+ raw={**live.raw, **raw},+ text=live.text,+ output=live.output,+ summary=dict(live.summary),+ reasoning=dict(live.reasoning),+ )items.append(self._project(turn_id, item_id, accumulated, True))if turn_id:error = object_value(turn.get("error"))diff --git a/src/free_claude_code/runtime/sqlite_migrations/__init__.py b/src/free_claude_code/runtime/sqlite_migrations/__init__.pyindex 0dcebe48..2be3a48b 100644--- a/src/free_claude_code/runtime/sqlite_migrations/__init__.py+++ b/src/free_claude_code/runtime/sqlite_migrations/__init__.py@@ -13,6 +13,7 @@ from . import (v0002_code_permissions,v0003_code_context_usage,v0004_messaging_schema,+ v0005_active_code_prompts,)MIGRATIONS: tuple[tuple[int, Callable[[sqlite3.Connection], None]], ...] = (@@ -20,4 +21,5 @@ MIGRATIONS: tuple[tuple[int, Callable[[sqlite3.Connection], None]], ...] = ((2, v0002_code_permissions.upgrade),(3, v0003_code_context_usage.upgrade),(4, v0004_messaging_schema.upgrade),+ (5, v0005_active_code_prompts.upgrade),)diff --git a/src/free_claude_code/runtime/sqlite_migrations/v0005_active_code_prompts.py b/src/free_claude_code/runtime/sqlite_migrations/v0005_active_code_prompts.pynew file mode 100644index 00000000..16d0c0f8--- /dev/null+++ b/src/free_claude_code/runtime/sqlite_migrations/v0005_active_code_prompts.py@@ -0,0 +1,10 @@+"""Index the live prompt working set independently of saved history."""++import sqlite3+++def upgrade(connection: sqlite3.Connection) -> None:+ connection.execute(+ "CREATE INDEX code_prompts_active ON code_prompts(session_id, id) "+ "WHERE status IN ('pending', 'answering')"+ )diff --git a/tests/application/test_code_sessions.py b/tests/application/test_code_sessions.pyindex ae001fb8..caae66aa 100644--- a/tests/application/test_code_sessions.py+++ b/tests/application/test_code_sessions.py@@ -9,6 +9,9 @@ import pytest_asynciofrom free_claude_code.application.code_sessions import CodeConflictError, CodeServicefrom free_claude_code.application.code_sessions import service as service_modulefrom free_claude_code.application.code_sessions.models import (+ CodeItem,+ CodeRun,+ CodeSession,CodeUnavailableError,CodeValidationError,HarnessEvent,@@ -49,6 +52,207 @@ async def session_for(code):return await service.create_session(new_id(), str(directory))+async def test_history_pages_do_not_create_execution_owners(code, monkeypatch):+ service, harness, directory = code+ session = await service._store.create(+ CodeSession(id=new_id(), cwd=str(directory), model=harness.model)+ )+ run = CodeRun(id=new_id(), session_id=session.id, text="old", model=harness.model)+ user = CodeItem(+ id=run.id, run_id=run.id, session_id=session.id, sequence=1, kind="user"+ )+ session, run = await service._store.admit_run(session, run, user, session.revision)+ await service._store.save_progress(+ session,+ session.revision,+ run=run.model_copy(update={"status": "completed"}),+ items=tuple(+ CodeItem(+ id=new_id(),+ run_id=run.id,+ session_id=session.id,+ sequence=n,+ kind="text",+ text="saved" * 100,+ complete=True,+ )+ for n in range(2, 202)+ ),+ )+ monkeypatch.setattr(+ service._store, "items", AsyncMock(side_effect=AssertionError("full history"))+ )+ monkeypatch.setattr(+ service._store, "runs", AsyncMock(side_effect=AssertionError("all runs"))+ )+ page = await service.get_detail(session.id)+ assert len(page.items) == 50+ assert page.next_before is not None+ older = await service.get_detail(session.id, before=page.next_before)+ assert len(older.items) == 50+ assert older.items[-1].sequence < page.items[0].sequence+ assert not service._owners+ assert not service._gates+ assert not harness.connections+++async def test_completed_turn_releases_bodies_but_keeps_connection(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch+ )+ await harness.wait_inputs(1)+ connection = harness.connections[0]+ await harness.started.wait()+ await connection.text("turn-1", "answer", "saved output", complete=True)+ await connection.finish("turn-1")+ await service.wait_idle(session.id)+ owner = service._owners[session.id]+ assert not owner.state.items+ assert not owner.state.prompts+ assert len(owner.state.runs) == 1+ assert not connection.closed+ assert any(+ item.text == "saved output"+ for item in (await service.get_detail(session.id)).items+ )+++async def test_many_turns_release_history_and_preserve_prompt_receipts(code):+ service, harness, _ = code+ session = await session_for(code)+ previous_sequence = 0+ receipts = []+ for number in range(1, 13):+ harness.started.clear()+ await service.send(+ session.id,+ new_id(),+ session.revision,+ f"Work {number}",+ expected_epoch=service.epoch,+ )+ await harness.started.wait()+ connection = harness.connections[0]+ turn = f"turn-{number}"+ for kind in ("text", "tool", "reasoning"):+ await connection.text(+ turn, kind, f"{kind} output {number}", complete=True, kind=kind+ )+ await connection.prompt(number, turn)+ prompt = next(+ prompt+ for prompt in (await service.get_detail(session.id)).prompts+ if prompt.request_id == number+ )+ response_id = new_id()+ await service.answer(session.id, prompt.id, response_id, {"decision": "accept"})+ await connection.finish(turn)+ await service.wait_idle(session.id)+ receipts.append((prompt.id, response_id))+ detail = await service.get_detail(session.id)+ assert detail.items[-1].sequence > previous_sequence+ previous_sequence = detail.items[-1].sequence+ session = detail.session+ owner = service._owners[session.id]+ assert not owner.state.items and not owner.state.prompts+ assert tuple(owner.state.runs) == (detail.run.id,)+ assert len(harness.connections) == 1 and not connection.closed+ for prompt_id, response_id in receipts:+ receipt = await service.answer(+ session.id, prompt_id, response_id, {"decision": "accept"}+ )+ assert receipt.response_id == response_id+ assert not service._owners[session.id].state.prompts+ all_items = await service._store.items(session.id, None, None)+ assert [item.sequence for item in all_items] == list(range(1, 61))+++async def test_cold_history_gate_serializes_owner_creation_without_blocking_other_sessions(+ code, monkeypatch+):+ service, harness, directory = code+ sessions = [+ await service._store.create(+ CodeSession(id=new_id(), cwd=str(directory), model=harness.model)+ )+ for _ in range(2)+ ]+ entered, release = asyncio.Event(), asyncio.Event()+ read = service._store.read_history++ async def gated_read(session_id, *args):+ if session_id == sessions[0].id:+ entered.set()+ await release.wait()+ return await read(session_id, *args)++ monkeypatch.setattr(service._store, "read_history", gated_read)+ reading = asyncio.create_task(service.get_detail(sessions[0].id))+ await entered.wait()+ changing = asyncio.create_task(+ service.update_settings(+ sessions[0].id, sessions[0].revision, {"title": "Updated"}+ )+ )+ cancelled = asyncio.create_task(service.get_detail(sessions[0].id))+ try:+ other = await asyncio.wait_for(service.get_detail(sessions[1].id), 2)+ assert other.session.id == sessions[1].id+ assert not changing.done() and not service._owners+ cancelled.cancel()+ with pytest.raises(asyncio.CancelledError):+ await cancelled+ release.set()+ before = await reading+ await changing+ after = await service.get_detail(sessions[0].id)+ assert before.session.title != after.session.title == "Updated"+ assert after.version > before.version+ assert set(service._gates) == {sessions[0].id}+ assert service._gates[sessions[0].id].users == 0+ finally:+ release.set()+ await asyncio.gather(reading, changing, cancelled, return_exceptions=True)+++async def test_execution_seed_resumes_sequence_without_hydrating_old_transcript(+ code, monkeypatch+):+ service, harness, directory = code+ session = await service._store.create(+ CodeSession(id=new_id(), cwd=str(directory), model=harness.model)+ )+ run = CodeRun(id=new_id(), session_id=session.id, text="old", model=harness.model)+ item = CodeItem(+ id=run.id, run_id=run.id, session_id=session.id, sequence=900, kind="user"+ )+ session, run = await service._store.admit_run(session, run, item, session.revision)+ await service._store.save_progress(+ session, session.revision, run=run.model_copy(update={"status": "completed"})+ )+ monkeypatch.setattr(+ service._store, "items", AsyncMock(side_effect=AssertionError("full history"))+ )+ monkeypatch.setattr(+ service._store, "prompts", AsyncMock(side_effect=AssertionError("all prompts"))+ )+ await service.send(+ session.id, new_id(), session.revision, "Next", expected_epoch=service.epoch+ )+ await harness.started.wait()+ detail = await service.get_detail(session.id)+ assert detail.items[-1].sequence == 901+ assert run.id not in service._owners[session.id].state.runs+ await harness.connections[0].finish("turn-1")++@pytest.mark.asyncioasync def test_catalog_wait_releases_session_lock_and_revalidates_before_admission(code, monkeypatch@@ -2079,7 +2283,7 @@ async def test_review_liveness_flush_includes_pending_output_and_keeps_staging_vwrites, published = [], []async def observe_save(session, revision, **values):- assert service._owners[session.id].version == before.version + 1+ assert service._version == before.version + 1assert service.cursor == before.cursorwrites.append(tuple(values["items"]))if fail:diff --git a/tests/application/test_code_sessions_state.py b/tests/application/test_code_sessions_state.pyindex 4f72d8c5..627c81b4 100644--- a/tests/application/test_code_sessions_state.py+++ b/tests/application/test_code_sessions_state.py@@ -122,7 +122,7 @@ def test_recovery_updates_historical_run_without_replacing_current_run():),),)- ((turn, recovered),) = state.match_history(native)+ ((turn, recovered),) = state.match_history(native, (old, current))assert turn.id == recovered.native_turn_id == "old-turn"assert recovered.status == "failed" and recovered.finished_at == 100assert recovered.error == "Connection lost"@@ -201,16 +201,20 @@ def test_only_new_turn_started_can_bind_an_unacknowledged_submission():)state = SessionState(base.session, current, (), (), (base.run, current))assert not state.matches_turn(- HarnessEvent("generation", "native", "turn_started", turn_id="turn")+ HarnessEvent("generation", "native", "turn_started", turn_id="turn"),+ known_turn=True,)assert not state.matches_turn(- HarnessEvent("generation", "native", "item", turn_id="new-turn")+ HarnessEvent("generation", "native", "item", turn_id="new-turn"),+ known_turn=False,)assert state.matches_turn(- HarnessEvent("generation", "native", "turn_started", turn_id="new-turn")+ HarnessEvent("generation", "native", "turn_started", turn_id="new-turn"),+ known_turn=False,)state.apply_progress(state.bind_turn("new-turn"))assert state.matches_turn(- HarnessEvent("generation", "native", "item", turn_id="new-turn")+ HarnessEvent("generation", "native", "item", turn_id="new-turn"),+ known_turn=False,)assert not state.accepts_event(HarnessEvent("generation", "other-thread", "notice"))diff --git a/tests/runtime/test_code_sessions_sqlite.py b/tests/runtime/test_code_sessions_sqlite.pyindex 49ae7da4..db5ffb6b 100644--- a/tests/runtime/test_code_sessions_sqlite.py+++ b/tests/runtime/test_code_sessions_sqlite.py@@ -17,6 +17,7 @@ from free_claude_code.application.code_sessions.models import (CodeSession,CodeUnavailableError,)+from free_claude_code.runtime import code_sessions_sqlite as code_store_modulefrom free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStorefrom free_claude_code.runtime.sqlite_database import SQLiteDatabase@@ -160,6 +161,107 @@ async def _session(store):)+async def test_history_snapshot_decodes_only_selected_records_and_chunks_includes(+ store, monkeypatch+):+ session, run = await _admit(store, await _session(store))+ items = tuple(+ CodeItem(+ id=str(uuid.uuid4()),+ session_id=session.id,+ run_id=run.id,+ sequence=number,+ kind="text",+ text=str(number),+ complete=True,+ )+ for number in range(2, 1203)+ )+ await store.save_progress(+ session,+ session.revision,+ items=items,+ run=run.model_copy(update={"status": "completed"}),+ )+ for number in range(1203, 1243):+ session, later = await _admit(store, session, sequence=number)+ await store.save_progress(+ session,+ session.revision,+ run=later.model_copy(update={"status": "completed"}),+ )+ decoded = []+ record = code_store_module._record++ def observe(model, row):+ decoded.append(model)+ return record(model, row)++ monkeypatch.setattr(code_store_module, "_record", observe)+ first = await store.read_history(session.id, None, ())+ assert len(first.items) == 50+ assert decoded.count(CodeItem) == 50+ assert decoded.count(CodeRun) <= 2 * len(first.runs) + 1+ decoded.clear()+ seed = await store.execution_seed(session.id)+ assert seed.sequence == 1242 and not seed.items and not seed.prompts+ assert len(seed.runs) == 1 and decoded.count(CodeRun) == 2+ included = await store.read_history(session.id, None, [item.id for item in items])+ assert {item.id for item in items} <= {item.id for item in included.items}+ assert len({item.id for item in included.items}) == len(included.items)+++async def test_history_component_reads_share_one_sqlite_snapshot(store, monkeypatch):+ session, run = await _admit(store, await _session(store))+ await store.save_progress(+ session, session.revision, run=run.model_copy(update={"status": "completed"})+ )+ page = code_store_module._item_page++ def change_after_page(connection, session_id, before, limit):+ result = page(connection, session_id, before, limit)+ with closing(sqlite3.connect(store.database.path)) as writer, writer:+ writer.execute(+ "UPDATE code_sessions SET title = 'new' WHERE id = ?", (session.id,)+ )+ writer.execute(+ "UPDATE code_items SET text = 'changed' WHERE session_id = ?",+ (session.id,),+ )+ return result++ monkeypatch.setattr(code_store_module, "_item_page", change_after_page)+ detail = await store.read_history(session.id, None, (run.id,))+ assert detail.session.title == session.title+ assert detail.items[0].text == "message"+ assert (await store.get_session(session.id)).title == "new"+ assert (await store.run_items(session.id, run.id))[0].text == "changed"+++async def test_active_prompt_and_identity_queries_have_indexed_access(store):+ with closing(sqlite3.connect(store.database.path)) as connection:+ queries = (+ (+ "SELECT * FROM code_prompts WHERE session_id = ? AND status IN ('pending', 'answering')",+ ("session",),+ ),+ ("SELECT max(sequence) FROM code_items WHERE session_id = ?", ("session",)),+ (+ "SELECT * FROM code_items WHERE session_id = ? AND native_turn_id = ? AND native_item_id = ?",+ ("session", "turn", "item"),+ ),+ )+ for query, params in queries:+ details = [+ row[3].upper()+ for row in connection.execute("EXPLAIN QUERY PLAN " + query, params)+ ]+ assert any("SEARCH" in detail and "INDEX" in detail for detail in details)++@pytest.mark.asyncioasync def test_mode_and_original_defaults_survive_restart_and_cannot_be_rewritten(store, tmp_path@@ -251,6 +353,7 @@ async def test_version_one_database_gains_mode_without_losing_history()connection.execute("ALTER TABLE code_sessions DROP COLUMN context_used_tokens")connection.execute("ALTER TABLE code_runs DROP COLUMN mode")+ connection.execute("DROP INDEX code_prompts_active")drop_messaging_schema(connection)connection.execute("PRAGMA user_version = 1")for _ in range(2):@@ -265,7 +368,7 @@ async def test_version_one_database_gains_mode_without_losing_history(assert saved_run is not None and saved_run.mode == "config"assert await store.items(session.id, None, None) == itemswith closing(sqlite3.connect(tmp_path / "code.db")) as connection:- assert connection.execute("PRAGMA user_version").fetchone()[0] == 4+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 5with pytest.raises(sqlite3.IntegrityError):connection.execute("UPDATE code_sessions SET mode = 'unknown'")with pytest.raises(sqlite3.IntegrityError):@@ -285,6 +388,7 @@ async def test_version_two_database_gains_nullable_context_usage(await store.database.close()with closing(sqlite3.connect(tmp_path / "code.db")) as connection, connection:connection.execute("ALTER TABLE code_sessions DROP COLUMN context_used_tokens")+ connection.execute("DROP INDEX code_prompts_active")drop_messaging_schema(connection)connection.execute("PRAGMA user_version = 2")for _ in range(2):@@ -294,7 +398,7 @@ async def test_version_two_database_gains_nullable_context_usage(await store.start()assert (await store.get_session(session.id)).context_used_tokens is Nonewith closing(sqlite3.connect(tmp_path / "code.db")) as connection:- assert connection.execute("PRAGMA user_version").fetchone()[0] == 4+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 5column = next(rowfor row in connection.execute("PRAGMA table_info(code_sessions)")@@ -661,7 +765,7 @@ async def test_legacy_prompts_migrate_once_to_run_ends_without_resequencing()assert saved[prompt.id] == expectedwith closing(sqlite3.connect(path)) as connection:- assert connection.execute("PRAGMA user_version").fetchone()[0] == 4+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 5assert connection.execute("PRAGMA foreign_key_check").fetchall() == []assert any(row[2] == "code_items"diff --git a/tests/runtime/test_codex_protocol.py b/tests/runtime/test_codex_protocol.pyindex 2a407bd3..84d08155 100644--- a/tests/runtime/test_codex_protocol.py+++ b/tests/runtime/test_codex_protocol.py@@ -5,6 +5,145 @@ from free_claude_code.core.json_types import JsonObjectfrom free_claude_code.runtime.codex_protocol import CodexProtocol, NativePrompt+def test_history_projection_does_not_retain_transcript_buffers():+ protocol = CodexProtocol("generation")+ history = protocol.history(+ {+ "thread": {+ "id": "thread",+ "turns": [+ {+ "id": "turn",+ "items": [+ {"id": "answer", "type": "agentMessage", "text": "saved"}+ ],+ }+ ],+ }+ }+ )+ assert history.turns[0].items[0].text == "saved"+ assert not protocol._items+++def test_terminal_turn_releases_only_its_thread_buffers():+ protocol = CodexProtocol("generation")+ for thread in ("parent", "child"):+ protocol.notification(+ "item/agentMessage/delta",+ {+ "threadId": thread,+ "turnId": "turn",+ "itemId": "answer",+ "delta": thread,+ },+ )+ event = protocol.notification(+ "item/completed",+ {+ "threadId": "parent",+ "turnId": "turn",+ "item": {"id": "answer", "type": "agentMessage"},+ },+ )+ protocol.notification(+ "turn/completed", {"threadId": "parent", "turn": {"id": "turn"}}+ )+ assert event is not None and event.item is not None+ assert event.item.text == "parent"+ assert len(protocol._items) == 1+ child = protocol.notification(+ "item/completed",+ {+ "threadId": "child",+ "turnId": "turn",+ "item": {"id": "answer", "type": "agentMessage"},+ },+ )+ assert child is not None and child.item is not None+ assert child.item.text == "child"+ protocol.notification(+ "turn/completed", {"threadId": "child", "turn": {"id": "turn"}}+ )+ assert not protocol._items++[email protected]("status", ["completed", "failed", "interrupted"])+def test_errors_keep_partial_output_until_terminal_event(status):+ protocol = CodexProtocol("g")+ identity = {"threadId": "thread", "turnId": "turn", "itemId": "command"}+ protocol.notification(+ "item/commandExecution/outputDelta", {**identity, "delta": "captured"}+ )+ protocol.notification(+ "error", {**identity, "willRetry": False, "error": {"message": "failed"}}+ )+ projected = protocol.notification(+ "item/completed",+ {+ **identity,+ "item": {"id": "command", "type": "commandExecution"},+ },+ )+ assert projected is not None and projected.item is not None+ assert "captured" in projected.item.detail+ protocol.notification(+ "turn/completed",+ {"threadId": "thread", "turn": {"id": "turn", "status": status}},+ )+ assert not protocol._items+ assert "captured" in projected.item.detail+++def test_history_uses_live_fallback_without_modifying_accumulation():+ protocol = CodexProtocol("g")+ identity = {"threadId": "thread", "turnId": "turn", "itemId": "answer"}+ protocol.notification("item/agentMessage/delta", {**identity, "delta": "live"})+ history = protocol.history(+ {+ "thread": {+ "id": "thread",+ "turns": [+ {+ "id": "turn",+ "items": [+ {+ "id": "answer",+ "type": "agentMessage",+ "text": "historical",+ },+ {"id": "other", "type": "agentMessage", "text": "other"},+ ],+ }+ ],+ }+ }+ )+ assert history.turns[0].items[0].text == "historical"+ assert len(protocol._items) == 1+ event = protocol.notification(+ "item/agentMessage/delta", {**identity, "delta": " output"}+ )+ assert (+ event is not None+ and event.item is not None+ and event.item.text == "live output"+ )+ protocol.clear()+ assert not protocol._items+++def test_unknown_item_notifications_do_not_allocate_buffers():+ protocol = CodexProtocol("g")+ assert (+ protocol.notification(+ "item/unknown", {"threadId": "thread", "turnId": "turn", "itemId": "item"}+ )+ is None+ )+ assert not protocol._items++@pytest.mark.parametrize("status,label",[diff --git a/tests/runtime/test_sqlite_database.py b/tests/runtime/test_sqlite_database.pyindex 10a99259..e98bf2af 100644--- a/tests/runtime/test_sqlite_database.py+++ b/tests/runtime/test_sqlite_database.py@@ -116,7 +116,7 @@ def test_historical_database_moves_and_upgrades_without_losing_records(assert len(after["code_items"]) == 2assert after["code_items"][-1]["kind"] == "prompt"with closing(sqlite3.connect(target)) as connection:- assert connection.execute("PRAGMA user_version").fetchone() == (4,)+ assert connection.execute("PRAGMA user_version").fetchone() == (5,)assert connection.execute("PRAGMA journal_mode").fetchone() == ("wal",)assert connection.execute("PRAGMA foreign_key_check").fetchall() == []@@ -153,7 +153,7 @@ def test_orphan_journals_are_not_treated_as_a_fresh_database(assert not (tmp_path / "fcc.db").exists()[email protected]("version", [-1, 5])[email protected]("version", [-1, 6])def test_unsupported_version_is_not_moved_or_mutated(tmp_path, version):old, target = tmp_path / "code/code.db", tmp_path / "fcc.db"historical_database(old, 3)@@ -297,7 +297,7 @@ def test_current_schema_does_not_execute_historical_migrations(tmp_path, monkeypmonkeypatch.setattr(sqlite_database,"MIGRATIONS",- tuple((version, already_applied) for version in (1, 2, 3, 4)),+ tuple((version, already_applied) for version, _ in sqlite_database.MIGRATIONS),)initialize_database(target)@@ -311,11 +311,18 @@ def test_messaging_schema_failure_rolls_back_without_changing_code_history(migrations = sqlite_database.MIGRATIONSdef fail(connection):- migrations[-1][1](connection)+ migrations[3][1](connection)raise sqlite3.DatabaseError("interrupted messaging schema")with monkeypatch.context() as patch:- patch.setattr(sqlite_database, "MIGRATIONS", (*migrations[:-1], (4, fail)))+ patch.setattr(+ sqlite_database,+ "MIGRATIONS",+ tuple(+ (version, fail if version == 4 else upgrade)+ for version, upgrade in migrations+ ),+ )with pytest.raises(sqlite3.DatabaseError, match="interrupted"):initialize_database(target)assert snapshot(target) == before