Skip to content

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.py
index 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: str
display_name: str
diff --git a/src/free_claude_code/application/code_sessions/ports.py b/src/free_claude_code/application/code_sessions/ports.py
index 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 JsonObject
from .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.py
index 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 asyncio
import uuid
-from collections.abc import Coroutine, Sequence
+from collections.abc import AsyncIterator, Callable, Coroutine, Sequence
+from contextlib import asynccontextmanager
from dataclasses import dataclass, field
from pathlib import Path
@@ -37,14 +38,35 @@ from .ports import CodeStore, HarnessConnection, HarnessFactory, HarnessSelectio
from .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: _SessionGate
finished: asyncio.Event = field(default_factory=asyncio.Event)
connection: HarnessConnection | None = None
generation: str | None = None
- version: int = 0
job: asyncio.Task[None] | None = None
flush_task: asyncio.Task[None] | None = None
interrupt_task: asyncio.Task[None] | None = None
@@ -60,7 +82,8 @@ class CodeService:
self._store = store
self._harness = harness
self._owners: dict[str, _SessionRuntime] = {}
- self._load_lock = asyncio.Lock()
+ self._gates: dict[str, _SessionGate] = {}
+ self._version = 0
self._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 None
owner = 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.generation
thread_id = owner.state.session.native_thread_id
if 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.id
await self._recover_locked(owner, native)
+ native = None
run = 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 None
turn_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:
return
await 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:
return
except Exception:
pass
- async with owner.lock:
+ async with self._locked(owner):
if (
owner.connection is not connection
or owner.state.run is None
@@ -681,7 +701,7 @@ class CodeService:
return
self._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:
return
try:
- async with owner.lock:
+ async with self._locked(owner):
if (
owner.generation != prompt.generation
or owner.state.pending_answer(prompt.id, prompt.generation) is None
):
return
await 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.deleted
or event.generation != owner.generation
@@ -747,7 +767,17 @@ class CodeService:
self._publish(owner, "session.updated")
return
run = 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:
return
if changed:
- owner.version += 1
+ self._version += 1
await self._flush_locked(owner)
elif (
event.kind == "item"
@@ -784,6 +815,7 @@ class CodeService:
and matches
and 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.prompt
if 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,
+ ):
return
await 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 += 1
async 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 connection
async 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 None
or owner.state.run.id != run_id
@@ -984,7 +1037,7 @@ class CodeService:
return
try:
await self._close_connection(owner)
- async with owner.lock:
+ async with self._locked(owner):
if (
owner.state.run
and owner.state.run.id == run_id
@@ -1035,12 +1088,11 @@ class CodeService:
pass
native_complete = True
await self._close_connection(owner)
- async with owner.lock:
+ async with self._locked(owner):
await self._store.delete(owner.state.session.id)
owner.deleted = True
owner.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 += 1
payload = self._summary(owner)
for key, value in data.items():
payload[key] = value
diff --git a/src/free_claude_code/application/code_sessions/state.py b/src/free_claude_code/application/code_sessions/state.py
index 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 = session
self._run = run
self._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 = 0
self._review_generations: dict[str, str] = {}
@@ -134,8 +135,6 @@ class SessionState:
self._runs[run.id] = run
if 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] = item
self._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._run
return bool(
run is not None
@@ -335,7 +362,7 @@ class SessionState:
or (
run.native_turn_id is None
and 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_started
and run.native_turn_id is None
and 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, False
target = self._runs[existing.run_id] if existing else self._run
diff --git a/src/free_claude_code/runtime/code_sessions_sqlite.py b/src/free_claude_code/runtime/code_sessions_sqlite.py
index 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, Sequence
from contextlib import closing
from 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.py
index 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._dispatcher
diff --git a/src/free_claude_code/runtime/codex_protocol.py b/src/free_claude_code/runtime/codex_protocol.py
index 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__.py
index 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.py
new file mode 100644
index 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.py
index ae001fb8..caae66aa 100644
--- a/tests/application/test_code_sessions.py
+++ b/tests/application/test_code_sessions.py
@@ -9,6 +9,9 @@ import pytest_asyncio
from free_claude_code.application.code_sessions import CodeConflictError, CodeService
from free_claude_code.application.code_sessions import service as service_module
from 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.asyncio
async 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_v
writes, published = [], []
async def observe_save(session, revision, **values):
- assert service._owners[session.id].version == before.version + 1
+ assert service._version == before.version + 1
assert service.cursor == before.cursor
writes.append(tuple(values["items"]))
if fail:
diff --git a/tests/application/test_code_sessions_state.py b/tests/application/test_code_sessions_state.py
index 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 == 100
assert 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.py
index 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_module
from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
from 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.asyncio
async 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) == items
with 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] == 5
with 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 None
with 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] == 5
column = next(
row
for 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] == expected
with closing(sqlite3.connect(path)) as connection:
- assert connection.execute("PRAGMA user_version").fetchone()[0] == 4
+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 5
assert 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.py
index 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 JsonObject
from 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.py
index 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"]) == 2
assert 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, monkeyp
monkeypatch.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.MIGRATIONS
def 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