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
Add Code sessions powered by Codex (#1695)
Ali Khokhard601599b0af9
diff --git a/e2e/__init__.py b/e2e/__init__.pynew file mode 100644index 00000000..02fcf9b0--- /dev/null+++ b/e2e/__init__.py@@ -0,0 +1 @@+"""Browser tests for the local Admin application."""diff --git a/e2e/code_support.py b/e2e/code_support.pynew file mode 100644index 00000000..e82eb088--- /dev/null+++ b/e2e/code_support.py@@ -0,0 +1,42 @@+"""Explicit barriers for Code browser tests, on the application's own loop."""++import asyncio+from collections.abc import Coroutine+from unittest.mock import patch++from free_claude_code.application.code_sessions import CodeService+from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore+from tests.code_sessions_support import FakeHarness+++class CodeControl:+ def __init__(self, directory):+ self.harness = FakeHarness()+ self.service = CodeService(+ SQLiteCodeStore(directory / "code.db", directory / "code.lock"),+ self.harness,+ )+ self.loop: asyncio.AbstractEventLoop | None = None++ def run[T](self, work: Coroutine[object, object, T]) -> T:+ assert self.loop is not None+ return asyncio.run_coroutine_threadsafe(work, self.loop).result(timeout=10)++ def connection(self):+ self.run(self.harness.started.wait())+ return self.harness.connections[-1]++ async def hold_send(self):+ self.admission = asyncio.Event()+ original = self.service._store.admit_run++ async def admit(session, run, item, expected_revision):+ await self.admission.wait()+ return await original(session, run, item, expected_revision)++ self.admission_patch = patch.object(self.service._store, "admit_run", admit)+ self.admission_patch.start()++ async def release_send(self):+ self.admission.set()+ self.admission_patch.stop()diff --git a/e2e/conftest.py b/e2e/conftest.pyindex 53a65a1b..340a480f 100644--- a/e2e/conftest.py+++ b/e2e/conftest.py@@ -13,6 +13,7 @@ import pytestimport uvicornfrom playwright.sync_api import Page+from e2e.code_support import CodeControlfrom free_claude_code.api.app import create_appfrom free_claude_code.api.ports import ApiServicesfrom free_claude_code.application.chat import (@@ -228,11 +229,17 @@ class _ModelListingProvider(BaseProvider):yield ""+def code_control(tmp_path):+ return CodeControl(tmp_path / "code")++@pytest.fixturedef admin_base_url(request: pytest.FixtureRequest,monkeypatch: pytest.MonkeyPatch,tmp_path: Path,+ code_control: CodeControl,) -> Iterator[str]:"""Serve one fully isolated Admin application on an OS-assigned port."""@@ -397,6 +404,7 @@ def admin_base_url(configuration=ConfigurationService(ManagedConfigStore()),transcriber=None,chat_service=chat,+ code_service=code_control.service,)app = RuntimeASGIApp(create_app(@@ -405,6 +413,7 @@ def admin_base_url(admin=runtime,tasks=runtime,chat=chat,+ code=code_control.service,)),runtime,@@ -441,17 +450,21 @@ def admin_base_url())+ async def serve() -> None:+ code_control.loop = asyncio.get_running_loop()+ await server.serve(sockets=[listener])+def run_server() -> None:if sys.platform == "win32":# This HTTP-only fixture owns no subprocess transports. A browser# reset can interrupt Proactor socket cleanup on Python 3.14.0;# use the selector loop here, leaving Playwright's loop unchanged.asyncio.run(- server.serve(sockets=[listener]),+ serve(),loop_factory=asyncio.SelectorEventLoop,)else:- server.run(sockets=[listener])+ asyncio.run(serve())thread = threading.Thread(target=run_server,diff --git a/e2e/test_chat_sessions.py b/e2e/test_chat_sessions.pyindex ce010756..65380978 100644--- a/e2e/test_chat_sessions.py+++ b/e2e/test_chat_sessions.py@@ -78,7 +78,7 @@ def test_chat_navigation_create_and_browser_history(expect(page.locator(".action-bar")).to_be_hidden()page.get_by_role("button", name="Chats", exact=False).click()expect(page).to_have_url(f"{admin_base_url}/admin/chat")- expect(page.locator(".chat-session-card")).to_have_count(1)+ expect(page.locator(".session-card")).to_have_count(1)page.go_back()expect(page.get_by_role("textbox", name="Message", exact=True)).to_be_visible()page.go_forward()@@ -163,7 +163,7 @@ def test_model_refresh_updates_chat_bootstrap(card.get_by_role("button", name="Refresh models", exact=True).click()expect(card.locator(".provider-check-result")).to_have_text("3 models available")page.get_by_role("button", name="Chat Sessions").click()- page.locator(".chat-session-card").click()+ page.locator(".session-card").click()expect(page.get_by_role("combobox", name="Selected model")).to_have_value(target)page.get_by_role("textbox", name="Message", exact=True).fill("still available")@@ -259,14 +259,14 @@ def test_delayed_older_page_cannot_cross_into_another_chat(expect(page.get_by_text("B only", exact=True)).to_be_visible()page.get_by_role("button", name="Chats", exact=False).click()- page.locator(".chat-session-card", has_text="[delay-older-page] Chat A").click()+ page.locator(".session-card", has_text="[delay-older-page] Chat A").click()load_older = page.get_by_role("button", name="Load older messages")expect(load_older).to_be_visible()with page.expect_request(lambda request: "/turns?before=" in request.url):load_older.click()page.get_by_role("button", name="Chats", exact=False).click()- page.locator(".chat-session-card", has_text="B only").click()+ page.locator(".session-card", has_text="B only").click()expect(page.get_by_text("B only", exact=True)).to_be_visible()page.wait_for_timeout(1_000)expect(page.get_by_text("A OLD LEAK", exact=True)).to_have_count(0)@@ -288,7 +288,7 @@ def test_out_of_order_library_search_keeps_latest_results()assert renamed.okpage.get_by_role("button", name="Chat Sessions").click()- expect(page.locator(".chat-session-card")).to_have_count(2)+ expect(page.locator(".session-card")).to_have_count(2)search = page.get_by_role("searchbox", name="Search chats")with page.expect_request(lambda request: "query=race-old" in request.url):@@ -296,16 +296,10 @@ def test_out_of_order_library_search_keeps_latest_results(with page.expect_response(lambda response: "query=race-new" in response.url):search.fill("race-new")- expect(- page.locator(".chat-session-card", has_text="race-new result")- ).to_be_visible()+ expect(page.locator(".session-card", has_text="race-new result")).to_be_visible()page.wait_for_timeout(1_000)- expect(- page.locator(".chat-session-card", has_text="race-new result")- ).to_be_visible()- expect(- page.locator(".chat-session-card", has_text="race-old result")- ).to_have_count(0)+ expect(page.locator(".session-card", has_text="race-new result")).to_be_visible()+ expect(page.locator(".session-card", has_text="race-old result")).to_have_count(0)def test_double_load_more_appends_each_session_once(@@ -320,15 +314,15 @@ def test_double_load_more_appends_each_session_once()assert created.okpage.get_by_role("button", name="Chat Sessions").click()- expect(page.locator(".chat-session-card")).to_have_count(25)+ expect(page.locator(".session-card")).to_have_count(25)more = page.get_by_role("button", name="Load more")expect(more).to_be_visible()more.evaluate("button => { button.click(); button.click(); }")- expect(page.locator(".chat-session-card")).to_have_count(26, timeout=3_000)+ expect(page.locator(".session-card")).to_have_count(26, timeout=3_000)page.wait_for_timeout(750)- expect(page.locator(".chat-session-card")).to_have_count(26)+ expect(page.locator(".session-card")).to_have_count(26)def test_chat_streams_thinking_and_persists_answer(@@ -340,7 +334,9 @@ def test_chat_streams_thinking_and_persists_answer(page.get_by_role("textbox", name="Message", exact=True).fill("hello")page.get_by_role("button", name="Send").click()expect(page.get_by_text("E2E answer")).to_be_visible()- expect(page.locator(".chat-thinking summary", has_text="Thinking")).to_be_visible()+ expect(+ page.locator(".session-thinking summary", has_text="Thinking")+ ).to_be_visible()expect(page.get_by_role("button", name="Regenerate")).to_be_visible()expect(page.locator("#chatContextMeter")).to_contain_text("Context:")@@ -405,7 +401,7 @@ def test_fragmented_stream_does_not_rebuild_transcript_per_delta(page.get_by_role("button", name="Send").click()expect(page.get_by_role("button", name="Regenerate")).to_be_visible(timeout=10_000)- expect(page.locator(".assistant-message .chat-markdown").last).to_contain_text(+ expect(page.locator(".assistant-message .session-markdown").last).to_contain_text("abcd" * 20)render_count = page.evaluate("window.__chatTranscriptRenderCount")@@ -445,7 +441,7 @@ def test_provider_failure_appears_only_in_assistant_reply(expect(page.get_by_role("button", name="Retry")).to_be_visible()expect(- page.locator(".assistant-message .chat-generation-status.failed")+ page.locator(".assistant-message .session-generation-status.failed")).to_have_text("E2E provider failed")expect(page.locator("#chatNotice")).to_be_hidden()expect(page.get_by_text("E2E provider failed", exact=True)).to_have_count(1)@@ -619,7 +615,7 @@ def test_two_sessions_run_concurrently_across_navigation(expect(page.get_by_role("button", name="Stop")).to_be_visible()page.get_by_role("button", name="Chats", exact=False).click()- expect(page.locator(".chat-session-status", has_text="Thinking…")).to_have_count(2)+ expect(page.locator(".session-status", has_text="Thinking…")).to_have_count(2)page.goto(first_url)expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()@@ -648,14 +644,14 @@ def test_library_card_tracks_background_operation_and_durable_summary(message.fill("[slow] live library preview")message.press("Enter")- card = other.locator(".chat-session-card", has_text="Library observer")+ card = other.locator(".session-card", has_text="Library observer")expect(card).to_be_visible(timeout=3_000)expect(card.locator("p")).to_have_text("[slow] live library preview")- expect(card.locator(".chat-session-status")).to_have_text("Thinking…")+ expect(card.locator(".session-status")).to_have_text("Thinking…")page.get_by_role("button", name="Stop").click()expect(page.get_by_role("button", name="Retry")).to_be_visible()- expect(card.locator(".chat-session-status")).to_have_count(0, timeout=3_000)+ expect(card.locator(".session-status")).to_have_count(0, timeout=3_000)expect(card.locator("p")).to_have_text("[slow] live library preview")expect(card.locator("span").first).to_contain_text("just now")finally:@@ -888,7 +884,7 @@ def test_failed_regeneration_replaces_the_reply_without_a_page_notice(expect(page.get_by_text("E2E answer", exact=True)).to_have_count(0)expect(page.get_by_text("Partial replacement", exact=True)).to_be_visible()expect(- page.locator(".assistant-message .chat-generation-status.failed")+ page.locator(".assistant-message .session-generation-status.failed")).to_have_text("E2E provider failed")expect(page.locator("#chatNotice")).to_be_hidden()expect(page.get_by_text("E2E provider failed", exact=True)).to_have_count(1)@@ -1002,7 +998,7 @@ def test_chat_composer_is_one_compact_surface_and_grows_to_six_lines() -> None:page.set_viewport_size({"width": 1_258, "height": 566})_new_chat(page, admin_base_url)- composer = page.locator(".chat-composer")+ composer = page.locator(".session-composer")message = page.get_by_role("textbox", name="Message", exact=True)surface = composer.evaluate(@@ -1063,12 +1059,12 @@ def test_chat_uses_desktop_width_with_one_responsive_gutter(page.reload()expect(page.get_by_text("E2E answer")).to_be_visible()- layout = page.locator(".chat-session-shell").evaluate(+ layout = page.locator(".session-shell").evaluate("""shell => {const main = document.querySelector(".main").getBoundingClientRect();const shellBox = shell.getBoundingClientRect();- const composer = shell.querySelector(".chat-composer").getBoundingClientRect();- const transcript = shell.querySelector(".chat-transcript").getBoundingClientRect();+ const composer = shell.querySelector(".session-composer").getBoundingClientRect();+ const transcript = shell.querySelector(".session-transcript").getBoundingClientRect();const user = shell.querySelector(".user-message").getBoundingClientRect();const assistant = shell.querySelector(".assistant-message").getBoundingClientRect();return {@@ -1115,7 +1111,7 @@ def test_chat_rename_prompt_and_delete(page.on("dialog", lambda dialog: dialog.accept())page.get_by_role("button", name="Delete").click()expect(page).to_have_url(f"{admin_base_url}/admin/chat")- expect(page.locator(".chat-session-card")).to_have_count(0)+ expect(page.locator(".session-card")).to_have_count(0)def test_delayed_title_save_cannot_restore_chat_after_back_navigation(diff --git a/e2e/test_code_sessions.py b/e2e/test_code_sessions.pynew file mode 100644index 00000000..2d3ffb71--- /dev/null+++ b/e2e/test_code_sessions.py@@ -0,0 +1,944 @@+import re+import uuid++import pytest+from playwright.sync_api import expect++from e2e.test_chat_sessions import _new_chat+from free_claude_code.application.code_sessions.models import (+ HarnessEvent,+ PromptRequest,+)+++def create_session(page, base_url, directory):+ page.goto(f"{base_url}/admin/code")+ page.get_by_role("button", name="New code session", exact=True).click()+ page.get_by_role("textbox", name="Folder", exact=True).fill(str(directory))+ expect(page.get_by_role("combobox", name="Harness", exact=True)).to_have_value(+ "codex"+ )+ page.get_by_role("button", name="Create session", exact=True).click()+ expect(page).to_have_url(re.compile(r"/admin/code/[0-9a-f-]+$"))+ expect(page.get_by_role("textbox", name="Message", exact=True)).to_be_enabled()+ return page.url+++def send(page, text):+ page.get_by_role("textbox", name="Message", exact=True).fill(text)+ page.get_by_role("button", name="Send", exact=True).click()+ expect(page.get_by_role("button", name="Stop", exact=True)).to_be_visible()+++def test_code_streams_survive_refresh_and_all_viewers_leaving(+ page, context, admin_base_url, tmp_path, code_control+):+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "Inspect this project")+ connection = code_control.connection()+ code_control.run(+ connection.text(+ "turn-1", "reason", "Reading the files", complete=True, kind="reasoning"+ )+ )+ code_control.run(+ connection.text(+ "turn-1", "command", "directory output", complete=True, kind="tool"+ )+ )+ code_control.run(connection.text("turn-1", "reply", "First finding", complete=True))+ expect(page.get_by_text("First finding", exact=True)).to_be_visible()+ page.locator("summary").filter(has_text="Thinking").click()+ expect(page.get_by_text("Reading the files", exact=True)).to_be_visible()+ expect(page.get_by_role("button", name="Regenerate", exact=True)).to_have_count(0)+ expect(page.get_by_role("button", name="Edit message", exact=True)).to_have_count(0)+ second = context.new_page()+ try:+ second.goto(url)+ expect(second.get_by_text("First finding", exact=True)).to_be_visible()+ page.goto("about:blank")+ second.close()+ code_control.run(+ connection.text("turn-1", "reply", "Final finding", complete=True)+ )+ code_control.run(connection.finish("turn-1"))+ page.goto(url)+ expect(page.get_by_text("Final finding", exact=True)).to_be_visible()+ page.get_by_role("textbox", name="Message", exact=True).fill("Follow up")+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_enabled()+ page.reload()+ expect(page.get_by_text("Final finding", exact=True)).to_be_visible()+ assert len(connection.inputs) == 1+ finally:+ if not second.is_closed():+ second.close()+++def test_prompt_claim_syncs_tabs_and_stop_keeps_output(+ page, context, admin_base_url, tmp_path, code_control+):+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "Run a command")+ connection = code_control.connection()+ code_control.run(+ connection.text("turn-1", "reply", "Output before approval", complete=True)+ )+ code_control.run(connection.prompt(0))+ second = context.new_page()+ try:+ second.goto(url)+ expect(second.get_by_role("button", name="Allow", exact=True)).to_be_enabled()+ page.get_by_role("button", name="Allow", exact=True).click()+ expect(second.get_by_role("button", name="Allow", exact=True)).to_be_disabled()+ page.get_by_role("button", name="Stop", exact=True).click()+ page.get_by_role("textbox", name="Message", exact=True).fill("Follow up")+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_enabled()+ expect(second.get_by_text("Output before approval", exact=True)).to_be_visible()+ assert len(connection.answers) == 1+ finally:+ second.close()+++def test_old_detail_cannot_replace_streamed_output(+ page, admin_base_url, tmp_path, code_control+):+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "Keep the latest output")+ connection = code_control.connection()+ code_control.run(connection.text("turn-1", "reply", "Old output", complete=True))+ code_control.run(connection.prompt(0))+ expect(page.get_by_text("Old output", exact=True)).to_be_visible()+ page.add_init_script("""(() => {+ const original = window.fetch;+ window.fetch = async (...args) => {+ const result = await original(...args);+ if (/\\/api\\/code\\/sessions\\/[0-9a-f-]+$/.test(String(args[0]))) {+ window.detailCaptured = true;+ await new Promise(resolve => { window.releaseDetail = resolve; });+ }+ return result;+ };+ })();""")+ page.goto(url)+ page.wait_for_function("window.detailCaptured === true")+ code_control.run(connection.text("turn-1", "reply", "Newest output", complete=True))+ code_control.run(connection.resolve(0))+ code_control.run(connection.finish("turn-1"))+ page.evaluate("window.releaseDetail()")+ expect(page.get_by_text("Newest output", exact=True)).to_be_visible()+ expect(page.get_by_text("Old output", exact=True)).to_have_count(0)+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_visible()+ expect(page.get_by_role("button", name="Allow", exact=True)).to_be_disabled()+++def test_competing_tabs_keep_the_rejected_draft(+ page, context, admin_base_url, tmp_path, code_control+):+ url = create_session(page, admin_base_url, tmp_path)+ second = context.new_page()+ try:+ second.goto(url)+ first_input = page.get_by_role("textbox", name="Message", exact=True)+ other_input = second.get_by_role("textbox", name="Message", exact=True)+ first_input.fill("First tab")+ other_input.fill("Second tab draft")+ expect(second.get_by_role("button", name="Send", exact=True)).to_be_enabled()+ code_control.run(code_control.hold_send())+ page.get_by_role("button", name="Send", exact=True).click()+ second.get_by_role("button", name="Send", exact=True).click()+ code_control.run(code_control.release_send())+ expect(page.get_by_role("button", name="Stop", exact=True)).to_be_visible()+ expect(second.get_by_role("button", name="Stop", exact=True)).to_be_visible()+ expect(first_input).to_have_value("")+ expect(other_input).to_have_value("Second tab draft")+ second.reload()+ expect(second.get_by_role("textbox", name="Message", exact=True)).to_have_value(+ "Second tab draft"+ )+ assert (+ sum(+ len(connection.inputs)+ for connection in code_control.harness.connections+ )+ == 1+ )+ finally:+ code_control.run(code_control.release_send())+ second.close()+++def test_lost_send_response_keeps_later_typing_and_does_not_replay(+ page, admin_base_url, tmp_path, code_control+):+ create_session(page, admin_base_url, tmp_path)+ page.evaluate("""() => {+ const original = window.fetch;+ window.fetch = async (...args) => {+ const result = await original(...args);+ if (String(args[0]).endsWith('/turns')) {+ window.sendCaptured = true;+ await new Promise((resolve, reject) => { window.loseSend = () => reject(new TypeError('Connection lost')); });+ }+ return result;+ };+ }""")+ send(page, "Run once")+ page.wait_for_function("window.sendCaptured === true")+ draft = page.get_by_role("textbox", name="Message", exact=True)+ draft.fill("Keep my next message")+ page.evaluate("window.loseSend()")+ connection = code_control.connection()+ code_control.run(connection.finish("turn-1"))+ page.reload()+ expect(page.get_by_role("textbox", name="Message", exact=True)).to_have_value(+ "Keep my next message"+ )+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_enabled()+ assert len(connection.inputs) == 1+++def test_rename_and_delete_sync_library_without_touching_project(+ page, context, admin_base_url, tmp_path, code_control+):+ url = create_session(page, admin_base_url, tmp_path)+ project = tmp_path / "project.txt"+ project.write_text("unchanged")+ second = context.new_page()+ try:+ second.goto(url)+ page.get_by_role("textbox", name="Code title", exact=True).fill("My project")+ page.get_by_role("textbox", name="Code title", exact=True).press("Enter")+ expect(+ second.get_by_role("textbox", name="Code title", exact=True)+ ).to_have_value("My project")+ page.get_by_role("button", name="Delete", exact=True).click()+ page.get_by_role("button", name="Delete session", exact=True).click()+ expect(page).to_have_url(f"{admin_base_url}/admin/code")+ expect(second).to_have_url(f"{admin_base_url}/admin/code")+ expect(second.locator(".session-card")).to_have_count(0)+ assert project.read_text() == "unchanged"+ finally:+ second.close()+++def test_question_input_survives_streaming_and_secret_answer_is_not_stored(+ page, admin_base_url, tmp_path, code_control+):+ control_feed(page)+ create_session(page, admin_base_url, tmp_path)+ send(page, "Ask me a question")+ connection = code_control.connection()+ prompt = PromptRequest(+ 7,+ "questions",+ {+ "title": "Codex needs your input",+ "questions": [+ {+ "id": "destination",+ "label": "Which destination?",+ "header": "Destination",+ "options": [+ {+ "label": "Default",+ "description": "Use the current destination",+ }+ ],+ "allow_other": True,+ "secret": True,+ }+ ],+ },+ {"question": "destination"},+ "turn-1",+ )++ async def ask():+ connection.requests[7] = prompt+ await connection.sink(+ HarnessEvent(+ connection.generation,+ connection.thread_id,+ "prompt",+ turn_id="turn-1",+ prompt=prompt,+ )+ )++ code_control.run(ask())+ secret = page.get_by_label("Your answer", exact=True)+ secret.fill("private-answer")+ expect(secret).to_have_attribute("type", "password")+ code_control.run(+ connection.text("turn-1", "stream", "Still checking", complete=True)+ )+ expect(page.get_by_text("Still checking", exact=True)).to_be_visible()+ expect(secret).to_have_value("private-answer")+ page.evaluate("window.codeFeed.onerror(new Event('error'))")+ expect(+ page.get_by_role("button", name="Submit answers", exact=True)+ ).to_be_enabled()+ expect(secret).to_have_value("private-answer")+ page.get_by_role("button", name="Submit answers", exact=True).click()+ expect(+ page.get_by_role("button", name="Submit answers", exact=True)+ ).to_be_disabled()+ code_control.run(code_control.harness.answered.wait())+ assert connection.answers == [(7, {"answers": {"destination": ["private-answer"]}})]+ assert "private-answer" not in page.evaluate("JSON.stringify(sessionStorage)")+ detail = code_control.run(+ code_control.service.get_detail(page.url.rsplit("/", 1)[1])+ )+ assert all(+ "private-answer" not in value.model_dump_json() for value in detail.prompts+ )+++def delete_from_other_client(code_control, session_id):+ async def remove():+ detail = await code_control.service.get_detail(session_id)+ await code_control.service.delete_session(session_id, detail.session.revision)+ await code_control.service.wait_idle(session_id)++ code_control.run(remove())+++def hold_deleted_detail(page, code_control, session_id):+ page.evaluate("window.dropCodeEvents = ['session.deleted']")+ delete_from_other_client(code_control, session_id)+ endpoint = f"/admin/api/code/sessions/{session_id}"+ hold_code_reads(page, endpoint)+ page.evaluate("window.replayCodeReady()")+ page.wait_for_function(+ "path => window.codeReadHolds.some(held => held.path === path && held.status === 404)",+ arg=endpoint,+ )++[email protected]("source", ["event", "detail404"])+def test_hidden_code_removal_preserves_chat_and_deleted_history(+ page, admin_base_url, tmp_path, code_control, source+):+ control_feed(page)+ url = create_session(page, admin_base_url, tmp_path)+ session_id = url.rsplit("/", 1)[1]+ if source == "detail404":+ hold_deleted_detail(page, code_control, session_id)+ page.get_by_role("button", name="Chat Sessions", exact=True).click()+ page.get_by_role("button", name="New chat", exact=True).click()+ expect(page).to_have_url(re.compile(r"/admin/chat/[0-9a-f-]+$"))+ chat_url = page.url+ composer = page.locator("#chatComposer")+ composer.fill("Keep this Chat draft")+ composer.evaluate("input => input.setSelectionRange(2, 7)")+ history_length = page.evaluate("history.length")+ if source == "event":+ delete_from_other_client(code_control, session_id)+ page.wait_for_function("id => window.lastCodeDeleted === id", arg=session_id)+ else:+ page.evaluate("window.releaseCodeReads()")+ expect(page.locator("#codeLibrary")).to_have_count(1)+ expect(page).to_have_url(chat_url)+ assert page.evaluate("history.length") == history_length+ expect(page.locator("#view-chat")).to_be_visible()+ expect(page.locator('.nav-link[data-view="chat"]')).to_have_attribute(+ "aria-current", "page"+ )+ expect(composer).to_be_focused()+ expect(composer).to_have_value("Keep this Chat draft")+ assert composer.evaluate("input => [input.selectionStart, input.selectionEnd]") == [+ 2,+ 7,+ ]++ # The old Code entry remains in history until it is visited and replaced.+ reads = []+ endpoint = f"/admin/api/code/sessions/{session_id}"+ page.on("request", lambda request: reads.append(request.url))+ page.go_back()+ expect(page).to_have_url(f"{admin_base_url}/admin/chat")+ page.go_back()+ expect(page).to_have_url(f"{admin_base_url}/admin/code")+ expect(page.locator("#codeNew")).to_be_enabled()+ expect(page.locator("#codeLibrary .session-card")).to_have_count(0)+ assert not any(request.endswith(endpoint) for request in reads)+ assert page.evaluate("history.length") == history_length+ page.go_forward()+ expect(page).to_have_url(f"{admin_base_url}/admin/chat")+ page.go_forward()+ expect(page).to_have_url(chat_url)+ expect(composer).to_have_value("Keep this Chat draft")+ page.reload()+ expect(page).to_have_url(chat_url)+ expect(composer).to_have_value("Keep this Chat draft")++[email protected]("source", ["event", "detail404", "returned_detail404"])+def test_visible_code_removal_replaces_history(+ page, admin_base_url, tmp_path, code_control, source+):+ control_feed(page)+ url = create_session(page, admin_base_url, tmp_path)+ session_id = url.rsplit("/", 1)[1]+ if source != "event":+ hold_deleted_detail(page, code_control, session_id)+ if source == "returned_detail404":+ page.get_by_role("button", name="Chat Sessions", exact=True).click()+ page.go_back()+ expect(page).to_have_url(url)+ expect(page.locator("#view-code")).to_be_visible()+ history_length = page.evaluate("history.length")+ if source == "event":+ delete_from_other_client(code_control, session_id)+ page.wait_for_function("id => window.lastCodeDeleted === id", arg=session_id)+ else:+ page.evaluate("window.releaseCodeReads()")+ expect(page).to_have_url(f"{admin_base_url}/admin/code")+ expect(page.locator("#codeNotice")).to_contain_text("deleted")+ expect(page.locator("#codeNew")).to_be_enabled()+ assert page.evaluate("history.length") == history_length+ if source == "returned_detail404":+ page.go_forward()+ expect(page).to_have_url(f"{admin_base_url}/admin/chat")+ page.go_back()+ expect(page).to_have_url(f"{admin_base_url}/admin/code")+ reads = []+ page.on("request", lambda request: reads.append(request.url))+ page.go_back()+ expect(page).to_have_url(f"{admin_base_url}/admin/code")+ expect(page.locator("#codeNew")).to_be_enabled()+ assert not any(request.endswith(f"/sessions/{session_id}") for request in reads)++[email protected]("source", ["event", "detail404"])+def test_code_removal_does_not_redirect_another_code_session(+ page, admin_base_url, tmp_path, code_control, source+):+ control_feed(page)+ url = create_session(page, admin_base_url, tmp_path)+ session_id = url.rsplit("/", 1)[1]+ other = code_control.run(+ code_control.service.create_session(str(uuid.uuid4()), str(tmp_path))+ )+ if source == "detail404":+ hold_deleted_detail(page, code_control, session_id)+ page.get_by_role("button", name="← Code sessions", exact=True).click()+ page.locator(f'#codeLibrary [data-id="{other.id}"]').click()+ other_url = f"{admin_base_url}/admin/code/{other.id}"+ expect(page).to_have_url(other_url)+ page.locator("#codeComposer").fill("Keep B's draft")+ history_length = page.evaluate("history.length")+ if source == "event":+ delete_from_other_client(code_control, session_id)+ page.wait_for_function("id => window.lastCodeDeleted === id", arg=session_id)+ else:+ page.evaluate("window.releaseCodeReads()")+ expect(page.locator("#codeSend")).to_be_enabled()+ expect(page).to_have_url(other_url)+ expect(page.locator("#codeComposer")).to_have_value("Keep B's draft")+ assert page.evaluate("history.length") == history_length+++def control_feed(page):+ page.add_init_script("""(() => {+ const Native = window.EventSource;+ window.EventSource = class extends Native {+ constructor(...args) {+ super(...args);+ this.isCode = String(args[0]).includes('/api/code/events');+ if (this.isCode) window.codeFeed = this;+ if (String(args[0]).includes('/api/chat/events')) window.chatFeed = this;+ }+ addEventListener(type, listener, ...options) {+ return super.addEventListener(type, event => {+ if (this.isCode && window.dropCodeEvents?.includes(type)) return;+ if (this.isCode && type === 'feed.ready')+ window.replayCodeReady = () => listener(event);+ listener(event);+ if (this.isCode && type === 'run.updated')+ window.lastCodeRun = JSON.parse(event.data).run;+ if (this.isCode && type === 'session.deleted')+ window.lastCodeDeleted = JSON.parse(event.data).session_id;+ }, ...options);+ }+ };+ })();""")+++def hold_code_reads(page, endpoint=None):+ page.evaluate(+ """endpoint => {+ const original = window.fetch;+ window.codeReadHolds = [];+ window.holdCodeReads = true;+ window.fetch = async (...args) => {+ const response = await original(...args);+ const path = new URL(String(args[0]), location.origin).pathname;+ if (window.holdCodeReads && path.startsWith('/admin/api/code/') &&+ (!endpoint || path === endpoint) &&+ (!args[1]?.method || args[1].method === 'GET'))+ await new Promise(resolve => window.codeReadHolds.push({path, status: response.status, resolve}));+ return response;+ };+ window.releaseCodeReads = () => {+ window.holdCodeReads = false;+ for (const held of window.codeReadHolds.splice(0)) held.resolve();+ };+ }""",+ endpoint,+ )+++def send_from_other_client(page, url, text):+ endpoint = url.replace("/admin/code/", "/admin/api/code/sessions/")+ detail = page.request.get(endpoint).json()+ response = page.request.post(+ f"{endpoint}/turns",+ data={+ "operation_id": str(uuid.uuid4()),+ "expected_revision": detail["session"]["revision"],+ "expected_epoch": detail["epoch"],+ "text": text,+ },+ )+ assert response.ok, response.text()+ return response.json()["id"]+++def test_hidden_chat_cannot_change_code_control_state(+ page, admin_base_url, tmp_path, code_control+):+ control_feed(page)+ _new_chat(page, admin_base_url)+ chat_id = page.url.rsplit("/", 1)[1]+ expect(page.locator("#chatModel")).to_be_enabled()+ page.get_by_role("button", name="Code sessions", exact=True).click()+ page.get_by_role("button", name="New code session", exact=True).click()+ page.get_by_role("textbox", name="Folder", exact=True).fill(str(tmp_path))+ page.get_by_role("button", name="Create session", exact=True).click()+ send(page, "Keep working")+ connection = code_control.connection()+ controls = page.locator(+ "#codeRoot .session-model-control input, "+ "#codeRoot .session-model-control button, #codeReasoning, #codeDelete"+ )+ assert controls.count() == 4+ for control in controls.all():+ expect(control).to_be_disabled()+ endpoint = f"{admin_base_url}/admin/api/chat/sessions/{chat_id}"+ session = page.request.get(endpoint).json()["session"]+ response = page.request.patch(+ endpoint,+ data={"expected_revision": session["revision"], "title": "Hidden update"},+ )+ assert response.ok+ expect(page.locator("#chatRoot .session-title")).to_have_value("Hidden update")+ for control in controls.all():+ expect(control).to_be_disabled()+ expect(page.locator("#codeRoot .session-title")).to_be_enabled()++ code_control.run(connection.finish("turn-1"))+ for control in controls.all():+ expect(control).to_be_enabled()+ page.evaluate("window.chatFeed.dispatchEvent(new Event('error'))")+ expect(page.locator("#chatModel")).to_be_disabled()+ for control in controls.all():+ expect(control).to_be_enabled()+ expect(page.locator("#codeRoot .session-title")).to_be_enabled()+++def test_model_default_clears_effort_when_all_choices_disappear(+ page, context, admin_base_url, tmp_path, code_control+):+ url = create_session(page, admin_base_url, tmp_path)+ effort = page.locator("#codeReasoning")+ effort.select_option("high")+ expect(effort).to_be_enabled()+ page.locator("#codeComposer").fill("Preserve this draft")+ code_control.harness.efforts = ()+ code_control.harness.default_effort = None+ page.evaluate("window.CodeSessions.refresh()")+ expect(page.locator("#codeComposerStatus")).to_contain_text("unavailable")+ expect(effort).to_have_value("high")+ expect(effort.locator("option:checked")).to_have_text("high (unavailable)")+ expect(page.locator("#codeSend")).to_be_disabled()+ expect(effort).to_be_enabled()+ patches = []+ page.on(+ "request",+ lambda request: (+ patches.append(request.post_data_json)+ if request.method == "PATCH" and "/api/code/sessions/" in request.url+ else None+ ),+ )+ with page.expect_response(+ lambda response: (+ response.request.method == "PATCH" and "/api/code/sessions/" in response.url+ )+ ) as reset:+ effort.select_option("")+ assert reset.value.json()["reasoning_effort"] is None+ assert len(patches) == 1 and patches[0]["reasoning_effort"] is None+ expect(effort).to_be_disabled()+ expect(page.locator("#codeComposerStatus")).not_to_contain_text("unavailable")+ expect(page.locator("#codeSend")).to_be_enabled()+ page.reload()+ expect(effort).to_have_value("")+ expect(effort).to_be_disabled()+ expect(page.locator("#codeComposer")).to_have_value("Preserve this draft")+ second = context.new_page()+ try:+ second.goto(url)+ expect(second.locator("#codeReasoning")).to_have_value("")+ expect(second.locator("#codeModel")).to_have_value("provider/model")+ page.locator("#codeSend").click()+ connection = code_control.connection()+ assert connection.efforts == [None]+ assert connection.inputs[0][1:] == ("Preserve this draft", "provider/model")+ finally:+ second.close()++[email protected]("status", ["completed", "failed"])+def test_library_reconnect_retires_missed_completion_and_loads_real_outcome(+ page, admin_base_url, tmp_path, code_control, status+):+ control_feed(page)+ create_session(page, admin_base_url, tmp_path)+ send(page, "Cached task")+ connection = code_control.connection()+ code_control.run(+ connection.text("turn-1", "reply", "Preserved output", complete=True)+ )+ expect(page.get_by_text("Preserved output", exact=True)).to_be_visible()+ page.locator("#codeComposer").fill("Next draft")+ page.get_by_role("button", name="← Code sessions", exact=True).click()+ card = page.locator("#codeLibrary .session-card")+ expect(card).to_contain_text("Running")+ page.evaluate("window.dropCodeEvents = ['run.updated', 'session.updated']")+ code_control.run(+ connection.finish(+ "turn-1", status, "Actual failure" if status == "failed" else None+ )+ )+ page.evaluate(+ "window.dropCodeEvents = []; void window.codeFeed.onerror(new Event('error'))"+ )+ expect(page.locator("#codeNew")).to_be_enabled()+ expect(card).not_to_contain_text("Running")+ hold_code_reads(page)+ card.click()+ page.wait_for_function(+ "window.codeReadHolds.some(held => /\\/sessions\\/[0-9a-f-]+$/.test(held.path))"+ )+ expect(page.locator("#codeSend")).to_be_disabled()+ expect(page.locator("#codeModel")).to_be_disabled()+ expect(page.get_by_text("Preserved output", exact=True)).to_be_visible()+ expect(page.locator("#codeComposer")).to_have_value("Next draft")+ page.evaluate("window.releaseCodeReads()")+ expect(page.locator("#codeSend")).to_be_enabled()+ expect(page.locator(".code-run")).to_have_count(1)+ outcome = page.locator(".code-outcome")+ if status == "failed":+ expect(outcome.locator(".session-generation-status")).to_have_text(+ "Actual failure"+ )+ expect(outcome).to_be_visible()+ else:+ expect(outcome).to_be_hidden()++[email protected]("snapshot_active", [False, True])+def test_new_run_survives_delayed_reconnect_reads(+ page, admin_base_url, tmp_path, code_control, snapshot_active+):+ control_feed(page)+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "First run")+ connection = code_control.connection()+ page.get_by_role("button", name="← Code sessions", exact=True).click()+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")+ if not snapshot_active:+ page.evaluate("window.dropCodeEvents = ['run.updated', 'session.updated']")+ code_control.run(connection.finish("turn-1"))+ hold_code_reads(page)+ page.evaluate(+ "window.dropCodeEvents = []; void window.codeFeed.onerror(new Event('error'))"+ )+ page.wait_for_function(+ "window.codeReadHolds.some(held => held.path === '/admin/api/code/sessions')"+ )+ if snapshot_active:+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")+ code_control.run(connection.finish("turn-1"))+ run_id = send_from_other_client(page, url, "Newer run")+ code_control.run(code_control.harness.wait_inputs(2))+ page.wait_for_function(+ "id => window.lastCodeRun?.id === id && window.lastCodeRun.status === 'running'",+ arg=run_id,+ )+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")+ page.evaluate("window.releaseCodeReads()")+ expect(page.locator("#codeNew")).to_be_enabled()+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")++[email protected]("source", ["sse", "detail"])+def test_stale_ready_snapshot_preserves_newer_activity(+ page, admin_base_url, tmp_path, code_control, source+):+ control_feed(page)+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "First run")+ connection = code_control.connection()+ code_control.run(connection.finish("turn-1"))+ expect(page.locator("#codeStop")).to_be_hidden()+ page.get_by_role("button", name="← Code sessions", exact=True).click()+ page.evaluate("window.codeFeed.onerror(new Event('error'))")+ expect(page.locator("#codeNew")).to_be_enabled()+ if source == "detail":+ page.evaluate(+ "window.dropCodeEvents = ['run.updated', 'session.updated', 'item.updated']"+ )+ run_id = send_from_other_client(page, url, "Newer run")+ code_control.run(code_control.harness.wait_inputs(2))+ if source == "detail":+ page.locator("#codeLibrary .session-card").click()+ expect(page.locator("#codeStop")).to_be_visible()+ expect(page.get_by_text("Newer run", exact=True)).to_be_visible()+ page.get_by_role("button", name="← Code sessions", exact=True).click()+ else:+ page.wait_for_function(+ "id => window.lastCodeRun?.id === id && window.lastCodeRun.status === 'running'",+ arg=run_id,+ )+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")+ hold_code_reads(page)+ page.evaluate("window.replayCodeReady()")+ page.wait_for_function("window.codeReadHolds.length >= 2")+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")+ page.evaluate("window.releaseCodeReads()")+ expect(page.locator("#codeNew")).to_be_enabled()+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")++[email protected]("endpoint", ["sessions", "bootstrap"])+def test_first_http_sync_failure_recovers_without_reloading(+ page, admin_base_url, endpoint+):+ page.add_init_script(+ """(endpoint => {+ const original = window.fetch;+ window.fetch = async (...args) => {+ if (!window.failedCodeLoad && new URL(String(args[0]), location.origin).pathname === `/admin/api/code/${endpoint}`) {+ window.failedCodeLoad = true;+ throw new TypeError('Initial snapshot failed');+ }+ return original(...args);+ };+ })("""+ + repr(endpoint)+ + ");"+ )+ page.goto(f"{admin_base_url}/admin/code")+ expect(+ page.get_by_role("button", name="New code session", exact=True)+ ).to_be_enabled()+ assert page.evaluate("window.failedCodeLoad")+ expect(page.locator("#codeNotice")).to_be_hidden()+++def test_unavailable_feed_shows_reason_and_clears_it_on_recovery(+ page, admin_base_url, code_control+):+ async def availability(available):+ code_control.service._accepting = available+ code_control.service._message = (+ None if available else "Code storage is unavailable"+ )++ code_control.run(availability(False))+ page.goto(f"{admin_base_url}/admin/code")+ expect(page.locator("#codeNotice")).to_contain_text("Code storage is unavailable")+ expect(page.locator("#codeNew")).to_be_disabled()+ code_control.run(availability(True))+ expect(page.locator("#codeNew")).to_be_enabled()+ expect(page.locator("#codeNotice")).to_be_hidden()+++def test_reconnect_retires_out_of_page_prompt_without_discarding_live_form_input(+ page, admin_base_url, tmp_path, code_control+):+ control_feed(page)+ create_session(page, admin_base_url, tmp_path)+ send(page, "Work")+ connection = code_control.connection()+ code_control.run(connection.prompt(0, turn_id=None))+ expect(page.get_by_role("button", name="Allow", exact=True)).to_be_enabled()+ page.evaluate("window.dropCodeEvents = ['prompt.updated']")+ code_control.run(connection.resolve(0))+ for index in range(55):+ code_control.run(+ connection.text("turn-1", str(index), f"Line {index}", complete=True)+ )+ code_control.run(connection.finish("turn-1"))+ page.get_by_role("textbox", name="Message", exact=True).fill("Keep draft")+ page.evaluate(+ "window.dropCodeEvents = []; void window.codeFeed.onerror(new Event('error'))"+ )+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_enabled()+ expect(page.get_by_role("button", name="Allow", exact=True)).to_be_disabled()+ expect(page.get_by_text("No longer active", exact=True)).to_be_visible()+ expect(page.get_by_role("textbox", name="Message", exact=True)).to_have_value(+ "Keep draft"+ )+++def test_failed_reply_stays_after_its_output_once_and_not_in_composer(+ page, admin_base_url, tmp_path, code_control+):+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "First")+ connection = code_control.connection()+ code_control.run(+ connection.text(+ "turn-1", "reasoning", "Reasoning so far", kind="reasoning", complete=True+ )+ )+ code_control.run(+ connection.text("turn-1", "tool", "Tool so far", kind="tool", complete=True)+ )+ code_control.run(connection.text("turn-1", "reply", "Partial reply", complete=True))+ code_control.run(+ connection.finish("turn-1", "failed", "Provider refused the request")+ )+ expect(+ page.locator(".code-outcome").filter(has_text="Provider refused the request")+ ).to_have_count(1)+ expect(page.locator("#codeComposerStatus")).not_to_contain_text("Provider refused")+ expect(page.locator("#codeNotice")).to_be_hidden()+ send(page, "Second")+ code_control.run(connection.finish("turn-2"))+ page.goto(url)+ expect(page.locator(".code-run")).to_have_count(2)+ expect(page.locator(".code-run").first).to_contain_text("Partial reply")+ expect(page.locator(".code-run").first.locator(".code-outcome")).to_contain_text(+ "Provider refused"+ )+ expect(page.locator(".code-run").last).to_contain_text("Second")++[email protected]("refresh_first", [True, False])+def test_model_effort_picker_syncs_tabs_and_keeps_missing_selection(+ page, context, admin_base_url, tmp_path, code_control, refresh_first+):+ code_control.harness.configurations["provider/other"] = "other"+ url = create_session(page, admin_base_url, tmp_path)+ second = context.new_page()+ try:+ second.goto(url)+ page.get_by_role("combobox", name="Selected model", exact=True).fill(+ "provider/other"+ )+ page.get_by_role("option", name="provider/other", exact=True).click()+ expect(second.locator("#codeModel")).to_have_value("provider/other")+ page.locator("#codeReasoning").select_option("high")+ expect(second.locator("#codeReasoning")).to_have_value("high")+ send(page, "Use choice")+ connection = code_control.connection()+ assert connection.inputs[0][2] == "provider/other"+ assert connection.efforts == ["high"]+ expect(page.locator("#codeModel")).to_be_disabled()+ expect(second.locator("#codeReasoning")).to_be_disabled()+ code_control.run(connection.finish("turn-1"))+ page.locator("#codeReasoning").select_option("")+ expect(second.locator("#codeReasoning")).to_have_value("")+ page.get_by_role("textbox", name="Message", exact=True).fill("Preserve me")+ code_control.harness.configurations.pop("provider/other")+ if refresh_first:+ page.evaluate("window.CodeSessions.refresh()")+ else:+ page.locator("#codeSend").click()+ expect(page.locator("#codeNotice")).to_contain_text("unavailable")+ expect(page.locator("#codeModel")).to_have_value("provider/other")+ expect(page.locator("#codeSend")).to_be_disabled()+ expect(page.locator("#codeComposer")).to_have_value("Preserve me")+ expect(page.locator("#codeComposerStatus")).to_contain_text("unavailable")+ finally:+ second.close()+++def test_library_reconnect_removes_missed_deletion_and_searches_beyond_first_page(+ page, admin_base_url, tmp_path, code_control+):+ control_feed(page)++ async def seed():+ first = await code_control.service.create_session(+ str(uuid.uuid4()), str(tmp_path)+ )+ await code_control.service.update_settings(+ first.id, first.revision, {"title": "Needle project"}+ )+ for _ in range(26):+ await code_control.service.create_session(str(uuid.uuid4()), str(tmp_path))+ return first.id++ # Start the isolated service before seeding it.+ page.goto(f"{admin_base_url}/admin/code")+ expect(page.locator("#codeNew")).to_be_enabled()+ session_id = code_control.run(seed())+ page.get_by_role("searchbox", name="Search titles and folders").fill("Needle")+ expect(page.locator(".session-card")).to_have_count(1)+ expect(page.locator(".session-card")).to_contain_text("Needle project")+ page.evaluate("window.dropCodeEvents = ['session.deleted']")++ async def remove_seed():+ detail = await code_control.service.get_detail(session_id)+ await code_control.service.delete_session(session_id, detail.session.revision)+ await code_control.service.wait_idle(session_id)++ code_control.run(remove_seed())+ page.evaluate(+ "window.dropCodeEvents = []; void window.codeFeed.onerror(new Event('error'))"+ )+ expect(page.locator(".session-card")).to_have_count(0)+ expect(page.get_by_text("No matching sessions.", exact=True)).to_be_visible()++[email protected]("width,height", [(1440, 1000), (390, 844)])+def test_code_composer_uses_chat_geometry_and_preserves_focus(+ page, admin_base_url, tmp_path, code_control, width, height+):+ page.set_viewport_size({"width": width, "height": height})+ create_session(page, admin_base_url, tmp_path)+ composer = page.locator("#codeComposer")+ composer.fill("a draft\nwith a second line")+ composer.evaluate("input => input.setSelectionRange(2, 6)")+ expected = composer.evaluate(+ "input => { const s=getComputedStyle(input); return [s.minHeight,s.maxHeight,s.padding,s.lineHeight,s.resize]; }"+ )+ page.locator("#codeModel").click()+ page.keyboard.press("Escape")+ composer.focus()+ composer.evaluate("input => input.setSelectionRange(2, 6)")+ page.evaluate("window.CodeSessions.refresh()")+ expect(composer).to_be_focused()+ assert composer.evaluate("input => [input.selectionStart,input.selectionEnd]") == [+ 2,+ 6,+ ]+ assert (+ page.locator("#codeComposer").bounding_box()["y"]+ + page.locator("#codeComposer").bounding_box()["height"]+ <= height+ )+ page.goto(f"{admin_base_url}/admin/chat")+ page.get_by_role("button", name="New chat", exact=True).click()+ chat = page.locator("#chatComposer")+ expect(chat).to_be_visible()+ actual = chat.evaluate(+ "input => { const s=getComputedStyle(input); return [s.minHeight,s.maxHeight,s.padding,s.lineHeight,s.resize]; }"+ )+ assert actual == expecteddiff --git a/pyproject.toml b/pyproject.tomlindex 5d4b8363..64c04730 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.22.10"+version = "5.23.2"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/src/free_claude_code/api/admin_routes.py b/src/free_claude_code/api/admin_routes.pyindex 07ad3924..64fb14da 100644--- a/src/free_claude_code/api/admin_routes.py+++ b/src/free_claude_code/api/admin_routes.py@@ -45,6 +45,10 @@ _ADMIN_ASSET_FILENAMES = frozenset("app-icon.svg","chat_sessions.css","chat_sessions.js",+ "code_sessions.css",+ "code_sessions.js",+ "session_layout.css",+ "session_ui.js","model_combobox.js",})diff --git a/src/free_claude_code/api/admin_static/admin.js b/src/free_claude_code/api/admin_static/admin.jsindex 21f7e065..447dde16 100644--- a/src/free_claude_code/api/admin_static/admin.js+++ b/src/free_claude_code/api/admin_static/admin.js@@ -6,7 +6,7 @@ const state = {modelOptions: [],modelComboboxes: new Set(),authPollers: new Map(),- activeView: window.location.pathname.startsWith("/admin/chat") ? "chat" : "providers",+ activeView: sessionViewFromPath(),};const MASKED_SECRET = "********";@@ -40,8 +40,19 @@ const VIEW_GROUPS = [sections: [],containerId: "chatRoot",},+ {+ id: "code",+ label: "Code sessions",+ title: "Code sessions",+ sections: [],+ containerId: "codeRoot",+ },];+function sessionViewFromPath() {+ return ["chat", "code"].find((id) => window.location.pathname.startsWith(`/admin/${id}`)) || "providers";+}+const byId = (id) => document.getElementById(id);function sourceLabel(source) {@@ -107,6 +118,7 @@ async function load() {hydrateModelOptions(),refreshLocalStatus(),window.ChatSessions ? window.ChatSessions.initialize(api) : Promise.resolve(),+ window.CodeSessions.initialize(api),]);updateDirtyState();showMessage("");@@ -138,10 +150,11 @@ function setActiveView(viewId, { scroll = false } = {}) {state.activeView = activeView.id;byId("pageTitle").textContent = activeView.title;const chatActive = activeView.id === "chat";- document.querySelector(".app-shell").classList.toggle("chat-active", chatActive);- document.querySelector(".main").classList.toggle("chat-main", chatActive);- document.querySelector(".topbar").hidden = chatActive;- document.querySelector(".action-bar").hidden = chatActive;+ const sessionActive = chatActive || activeView.id === "code";+ document.querySelector(".app-shell").classList.toggle("session-active", sessionActive);+ document.querySelector(".main").classList.toggle("session-main", sessionActive);+ document.querySelector(".topbar").hidden = sessionActive;+ document.querySelector(".action-bar").hidden = sessionActive;document.querySelectorAll(".nav-link").forEach((link) => {const selected = link.dataset.view === activeView.id;@@ -165,14 +178,15 @@ function setActiveView(viewId, { scroll = false } = {}) {if (chatActive && window.ChatSessions) {window.ChatSessions.activate(window.location.pathname);}+ if (activeView.id === "code") window.CodeSessions.activate(window.location.pathname);}function navigateToView(viewId) {- if (viewId === "chat") {- if (window.location.pathname !== "/admin/chat") {- window.history.pushState({}, "", "/admin/chat");+ if (["chat", "code"].includes(viewId)) {+ if (window.location.pathname !== `/admin/${viewId}`) {+ window.history.pushState({}, "", `/admin/${viewId}`);}- } else if (window.location.pathname.startsWith("/admin/chat")) {+ } else if (sessionViewFromPath() !== "providers") {window.history.pushState({}, "", "/admin");}setActiveView(viewId, { scroll: true });@@ -951,7 +965,7 @@ function showCredentialErrors(checks) {function setApplying(applying) {state.applying = applying;- VIEW_GROUPS.filter((view) => view.id !== "chat").forEach((view) => {+ VIEW_GROUPS.filter((view) => !["chat", "code"].includes(view.id)).forEach((view) => {byId(`view-${view.id}`).inert = applying || !!state.restart;});if (applying) state.modelComboboxes.forEach((combobox) => combobox.close());@@ -1167,6 +1181,7 @@ async function loadModelOptions(refresh = false) {});setModelOptions(result.models);if (refresh && window.ChatSessions) await window.ChatSessions.refresh();+ if (refresh && window.CodeSessions) await window.CodeSessions.refresh();return result;}@@ -1224,9 +1239,7 @@ document.addEventListener("pointerdown", (event) => {});window.addEventListener("popstate", () => {- const viewId = window.location.pathname.startsWith("/admin/chat")- ? "chat"- : "providers";+ const viewId = sessionViewFromPath();setActiveView(viewId, { scroll: false });});diff --git a/src/free_claude_code/api/admin_static/chat_sessions.css b/src/free_claude_code/api/admin_static/chat_sessions.cssindex fddca482..0d87e7a5 100644--- a/src/free_claude_code/api/admin_static/chat_sessions.css+++ b/src/free_claude_code/api/admin_static/chat_sessions.css@@ -1,221 +1,8 @@-.main.chat-main {- height: 100vh;- padding: 0;- overflow: hidden;-}--.chat-main .admin-views,-.chat-main .admin-view,-.chat-root,-.chat-session-shell {- height: 100%;- min-height: 0;-}--.chat-root {- padding: 36px clamp(16px, 3vw, 42px) 16px;-}--.chat-library-header,-.chat-header-row,-.chat-controls,-.chat-composer-actions,-.chat-dialog-actions,-.chat-message-label {+.chat-dialog-actions {display: flex;align-items: center;}-.chat-library-header,-.chat-header-row,-.chat-composer-actions,-.chat-message-label {- justify-content: space-between;-}--.chat-library-header {- gap: 24px;- margin: 0 auto 24px;- max-width: 920px;-}--.chat-library-header h2 {- margin: 0;- font-size: 30px;-}--.chat-library-header p,-.chat-session-card p {- color: var(--muted);-}--.chat-library-header p {- margin: 7px 0 0;-}--.chat-search,-.chat-session-list,-.chat-load-more,-.chat-notice {- width: 100%;- max-width: 920px;- margin-left: auto;- margin-right: auto;-}--.chat-search,-.chat-load-more {- display: block;-}--.chat-search {- min-height: 44px;- margin-bottom: 16px;- border: 1px solid var(--line-strong);- border-radius: var(--radius-md);- background: var(--input);- padding: 10px 14px;-}--.chat-session-list {- display: grid;- gap: 10px;-}--.chat-session-card {- display: grid;- width: 100%;- gap: 7px;- border: 1px solid var(--line);- border-radius: var(--radius-md);- background: var(--panel);- padding: 17px 19px;- text-align: left;- cursor: pointer;-}--.chat-session-card:hover {- border-color: var(--accent-border);- background: var(--card-hover);-}--.chat-session-card p {- overflow: hidden;- margin: 0;- text-overflow: ellipsis;- white-space: nowrap;-}--.chat-session-card span,-.chat-muted {- color: var(--muted);- font-size: 12px;-}--.chat-session-card .chat-session-status {- color: var(--accent);- font-weight: 700;-}--.chat-load-more {- margin-top: 18px;-}--.chat-session-shell {- display: grid;- grid-template-areas:- "header"- "notice"- "transcript"- "composer";- grid-template-rows: auto auto minmax(0, 1fr) auto;- position: relative;-}--.chat-session-header {- grid-area: header;- padding-bottom: 16px;- border-bottom: 1px solid var(--line);-}--.chat-header-row {- gap: 12px;-}--.chat-title {- flex: 1;- min-width: 0;- border: 1px solid transparent;- border-radius: var(--radius-sm);- background: transparent;- padding: 7px 10px;- color: var(--text-strong);- font-size: 19px;- font-weight: 700;-}--.chat-title:hover,-.chat-title:focus {- border-color: var(--line-strong);- background: var(--input);-}--.chat-back-button {- border: 0;- background: transparent;- color: var(--muted);- cursor: pointer;-}--.chat-back-button:hover {- color: var(--text);-}--.chat-controls {- flex-wrap: wrap;- gap: 10px;- margin-top: 14px;-}--.chat-control {- display: grid;- gap: 5px;- color: var(--muted);- font-size: 11px;- font-weight: 700;- letter-spacing: 0.04em;- text-transform: uppercase;-}--.chat-control select,-.chat-model-input {- min-height: 38px;- border: 1px solid var(--line-strong);- border-radius: var(--radius-sm);- background: var(--input);- padding: 7px 10px;- color: var(--text);- text-transform: none;-}--.chat-model-control {- flex: 1 1 360px;- max-width: 520px;-}--.chat-model-control .model-combobox input[type="text"] {- width: 100%;- padding-right: 44px;-}--.chat-model-control .model-combobox {- text-transform: none;-}--.chat-model-control .model-combobox-toggle {- height: 38px;-}-.chat-context-meter {align-self: end;min-height: 38px;@@ -231,108 +18,11 @@color: var(--warn);}-.chat-controls > button {- align-self: end;-}--.chat-notice {- grid-area: notice;- margin-top: 12px;- margin-bottom: 10px;- border: 1px solid var(--line);- border-radius: var(--radius-sm);- padding: 9px 12px;- color: var(--muted);- font-size: 13px;-}--.chat-notice.error {- border-color: var(--error-border);- background: var(--error-bg);- color: var(--error);-}--.chat-transcript {- grid-area: transcript;- min-height: 0;- overflow-y: auto;- overscroll-behavior: contain;- padding: 24px 0 30px;- scroll-behavior: auto;-}--.chat-message {- max-width: 1120px;- margin: 0 0 22px;- border-radius: var(--radius-lg);-}--.user-message {- margin-left: auto;- max-width: min(680px, 88%);- background: var(--panel-strong);- padding: 14px 17px;-}--.assistant-message {- padding: 2px 4px;-}--.chat-message-label {- gap: 12px;- margin-bottom: 8px;- color: var(--muted);- font-size: 12px;- font-weight: 700;-}-.chat-fallback-label {color: var(--info);font-weight: 500;}-.chat-message-plain,-.chat-markdown {- overflow-wrap: anywhere;- line-height: 1.65;- white-space: pre-wrap;-}--.chat-markdown {- white-space: normal;-}--.chat-markdown > :first-child {- margin-top: 0;-}--.chat-markdown > :last-child {- margin-bottom: 0;-}--.chat-markdown pre {- overflow-x: auto;- border: 1px solid var(--line);- border-radius: var(--radius-sm);- background: var(--input);- padding: 13px;-}--.chat-markdown code {- border-radius: 4px;- background: var(--input);- padding: 0.12em 0.3em;-}--.chat-markdown pre code {- padding: 0;-}--.chat-markdown a {- color: var(--info);-}--.chat-thinking,.chat-compaction {margin: 12px 0;border-left: 2px solid var(--line-strong);@@ -340,7 +30,6 @@color: var(--muted);}-.chat-thinking summary,.chat-compaction summary {cursor: pointer;font-size: 13px;@@ -355,102 +44,6 @@padding: 12px 15px;}-.chat-generation-status {- margin-top: 12px;- border: 1px solid var(--warn-border);- border-radius: var(--radius-sm);- background: var(--warn-bg);- padding: 9px 11px;- color: var(--warn);- font-size: 13px;-}--.chat-generation-status.failed {- border-color: var(--error-border);- background: var(--error-bg);- color: var(--error);-}--.chat-message-actions {- display: flex;- gap: 8px;- margin-top: 12px;-}--.chat-composer {- grid-area: composer;- margin: 8px 0 0;- border: 1px solid var(--line-strong);- border-radius: var(--radius-lg);- background: var(--input);- padding: 10px 12px 9px;-}--.chat-composer:focus-within {- border-color: var(--accent);- background: var(--input-focus);- box-shadow: 0 0 0 3px rgba(16, 185, 129, 0.15);-}--.chat-composer textarea {- display: block;- width: 100%;- min-height: calc(3em + 8px);- max-height: calc(9em + 8px);- resize: none;- overflow-y: hidden;- border: 0;- border-radius: 0;- background: transparent;- padding: 4px 2px;- line-height: 1.5;- outline: none;-}--.chat-composer-actions {- gap: 12px;- margin-top: 4px;-}--.chat-composer-status {- color: var(--muted);- font-size: 12px;-}--.chat-older {- display: block;- margin: 0 auto 24px;-}--.chat-empty {- display: grid;- place-items: center;- gap: 8px;- min-height: 220px;- color: var(--muted);- text-align: center;-}--.chat-empty h3,-.chat-empty p {- margin: 0;-}--.chat-transcript-empty {- min-height: 100%;-}--.danger-button {- min-height: 38px;- border: 1px solid var(--error-border);- border-radius: var(--radius-sm);- background: var(--error-bg);- padding: 8px 13px;- color: var(--error);- cursor: pointer;- font-weight: 700;-}-.chat-prompt-dialog {width: min(680px, calc(100vw - 32px));border: 1px solid var(--line-strong);@@ -484,118 +77,13 @@}@media (max-width: 900px) {- .app-shell.chat-active {- height: 100dvh;- min-height: 0;- overflow: hidden;- }-- .app-shell.chat-active .sidebar {- flex: 0 0 auto;- }-- .main.chat-main {- flex: 1 1 0;- height: auto;- min-height: 0;- }-- .chat-root {- padding: 24px 20px 12px;- }-- .chat-controls {- display: grid;- grid-template-columns: 1fr 1fr;- }-- .chat-model-control,.chat-context-meter {grid-column: 1 / -1;}-- .chat-model-control {- max-width: none;- }}@media (max-width: 700px) {- .chat-main .admin-views,- .chat-main .admin-view,- .chat-root,- .chat-session-shell {- height: 100%;- min-height: 0;- }-- .chat-root {- padding: 16px 12px 8px;- }-- .chat-session-shell {- grid-template-rows: auto auto minmax(0, 1fr) auto;- }-- .chat-library-header {- align-items: flex-start;- }-- .chat-header-row {- flex-wrap: wrap;- }-- .chat-title {- order: 3;- flex-basis: 100%;- }-- .chat-controls {- grid-template-columns: 1fr;- }-- .chat-model-control,.chat-context-meter {grid-column: auto;}-- .chat-transcript {- padding-left: 0;- padding-right: 0;- }-- .chat-composer {- margin-left: 0;- margin-right: 0;- }-}--@media (max-width: 600px) {- .app-shell.chat-active .sidebar {- padding: 10px 12px;- gap: 8px;- }-- .app-shell.chat-active .brand {- flex-direction: row;- justify-content: flex-start;- text-align: left;- }-- .app-shell.chat-active .brand-mark {- width: 34px;- height: 34px;- }-- .app-shell.chat-active .section-nav {- grid-template-columns: repeat(4, minmax(0, 1fr));- gap: 4px;- }-- .app-shell.chat-active .nav-link {- justify-content: center;- min-height: 34px;- padding: 6px 4px;- text-align: center;- font-size: 11px;- }}diff --git a/src/free_claude_code/api/admin_static/chat_sessions.js b/src/free_claude_code/api/admin_static/chat_sessions.jsindex c1480772..48694e14 100644--- a/src/free_claude_code/api/admin_static/chat_sessions.js+++ b/src/free_claude_code/api/admin_static/chat_sessions.js@@ -60,27 +60,21 @@"operation.failed",];+ const UI = window.SessionUI;+ const {+ node,+ button,+ nearBottom,+ resizeComposer,+ focusIsUnclaimed: composerFocusIsUnclaimed,+ } = UI;const root = () => document.getElementById("chatRoot");- function node(tag, className = "", text = "") {- const element = document.createElement(tag);- if (className) element.className = className;- if (text) element.textContent = text;- return element;- }-- function button(label, className, action) {- const element = node("button", className, label);- element.type = "button";- element.addEventListener("click", action);- return element;- }-function setNotice(message, kind = "") {const area = document.getElementById("chatNotice");if (!area) return;area.textContent = message;- area.className = `chat-notice ${kind}`.trim();+ area.className = `session-notice ${kind}`.trim();area.hidden = !message;}@@ -158,7 +152,9 @@state.feedLastId = cursor;state.feedStatus = "synchronizing";refreshFeedState();- const snapshotOperationIds = installActiveSnapshot(snapshot.active_operations);+ const snapshotOperationIds = installActiveSnapshot(+ snapshot.active_operations,+ );if (!snapshotOperationIds) {restartEventFeed();return;@@ -296,7 +292,9 @@}function upsertLibrarySummary(summary) {- state.libraryItems = state.libraryItems.filter((item) => item.id !== summary.id);+ state.libraryItems = state.libraryItems.filter(+ (item) => item.id !== summary.id,+ );if (matchesLibraryQuery(summary)) state.libraryItems.push(summary);sortLibraryItems();}@@ -417,12 +415,12 @@function validOperationSnapshot(snapshot) {return Boolean(snapshot &&- typeof snapshot.session_id === "string" &&- typeof snapshot.operation_id === "string" &&- validOperationKind(snapshot.kind) &&- ["generating", "compacting"].includes(snapshot.phase) &&- Number.isInteger(snapshot.operation_sequence) &&- Array.isArray(snapshot.segments),+ typeof snapshot.session_id === "string" &&+ typeof snapshot.operation_id === "string" &&+ validOperationKind(snapshot.kind) &&+ ["generating", "compacting"].includes(snapshot.phase) &&+ Number.isInteger(snapshot.operation_sequence) &&+ Array.isArray(snapshot.segments),);}@@ -496,7 +494,8 @@const active = state.activeOperations.get(payload.session_id);const pending = state.pendingCommands.get(payload.session_id);const matchingActive = active?.id === payload.operation_id ? active : null;- const matchingPending = pending?.id === payload.operation_id ? pending : null;+ const matchingPending =+ pending?.id === payload.operation_id ? pending : null;if (isTerminalEvent(type, payload.kind)) {if (matchingActive &&@@ -560,7 +559,10 @@} else if (type === "compaction.started") {operation.phase = "compacting";operation.status = "Compacting…";- } else if (type === "compaction.completed" && operation.action !== "compact") {+ } else if (+ type === "compaction.completed" &&+ operation.action !== "compact"+ ) {operation.phase = "generating";operation.status = "Thinking…";}@@ -647,7 +649,9 @@state.draftOperationId = null;state.draftSubmittedText = "";try {- const stored = JSON.parse(sessionStorage.getItem(draftKey(sessionId)) || "null");+ const stored = JSON.parse(+ sessionStorage.getItem(draftKey(sessionId)) || "null",+ );if (!stored || typeof stored !== "object") return;if (typeof stored.text === "string") state.draft = stored.text;if (typeof stored.operationId === "string") {@@ -809,18 +813,22 @@}function routedSessionId(path) {- return path.match(/^\/admin\/chat\/([0-9a-f-]+)$/i)?.[1].toLowerCase() || null;+ return (+ path.match(/^\/admin\/chat\/([0-9a-f-]+)$/i)?.[1].toLowerCase() || null+ );}function renderLoading() {state.modelComboboxes.clear();const container = root();- container.replaceChildren(node("div", "chat-empty", "Loading Chat Sessions…"));+ container.replaceChildren(+ node("div", "session-empty", "Loading Chat Sessions…"),+ );}function renderUnavailable() {state.modelComboboxes.clear();- const container = node("section", "chat-empty");+ const container = node("section", "session-empty");container.append(node("h3", "", "Chat Sessions unavailable"),node(@@ -845,37 +853,24 @@function renderLibraryShell() {state.modelComboboxes.clear();- const header = node("header", "chat-library-header");- const copy = node("div");- copy.append(- node("h2", "", "Chat Sessions"),- node("p", "", "Talk directly to any configured FCC model."),+ const create = button("New chat", "primary-button", createSession);+ create.dataset.testid = "chat-new";+ create.disabled = !mutationsReady();+ const header = UI.libraryHeader(+ "Chat Sessions",+ "Talk directly to any configured FCC model.",+ create,);- const newButton = button("New chat", "primary-button", createSession);- newButton.dataset.testid = "chat-new";- newButton.disabled = !mutationsReady();- header.append(copy, newButton);-- const search = node("input", "chat-search");- search.type = "search";- search.placeholder = "Search chats";- search.value = state.libraryQuery;- search.setAttribute("aria-label", "Search chats");- let timer = null;- search.addEventListener("input", () => {- window.clearTimeout(timer);- timer = window.setTimeout(() => {- state.libraryQuery = search.value;- loadLibrary(true, state.routeVersion);- }, 200);+ const search = UI.search("Search chats", state.libraryQuery, (value) => {+ state.libraryQuery = value;+ loadLibrary(true, state.routeVersion);});-- const notice = node("div", "chat-notice");+ const notice = node("div", "session-notice");notice.id = "chatNotice";notice.hidden = true;- const list = node("div", "chat-session-list");+ const list = node("div", "session-list");list.id = "chatSessionList";- const more = button("Load more", "secondary-button chat-load-more", () =>+ const more = button("Load more", "secondary-button session-load-more", () =>loadLibrary(false, state.routeVersion),);more.id = "chatLoadMore";@@ -897,7 +892,7 @@state.libraryItems = [];state.libraryCursor = null;state.libraryLoadMore = null;- list.replaceChildren(node("div", "chat-empty", "Loading chats…"));+ list.replaceChildren(node("div", "session-empty", "Loading chats…"));} else {state.libraryLoadMore = loadMore;const more = document.getElementById("chatLoadMore");@@ -920,7 +915,8 @@page.sessions.forEach((session) => {if (state.deletedSessions.has(session.id)) return;const current = reduceSessionSummary(session);- if (current && matchesLibraryQuery(current)) merged.set(current.id, current);+ if (current && matchesLibraryQuery(current))+ merged.set(current.id, current);});state.libraryItems = [...merged.values()].filter(matchesLibraryQuery);sortLibraryItems();@@ -945,23 +941,24 @@list.appendChild(node("div",- "chat-empty",+ "session-empty",state.libraryQuery ? "No matching chats." : "Start your first chat.",),);}state.libraryItems.forEach((session) => {- const item = button("", "chat-session-card", () => openSession(session.id));- const heading = node("strong", "", session.title);- const preview = node("p", "", session.preview || "No messages yet");- const meta = node("span", "", `${session.model} · ${relativeTime(session.updated_at)}`);- item.append(heading, preview, meta);+ const item = UI.card(+ session.title,+ session.preview || "No messages yet",+ `${session.model} · ${relativeTime(session.updated_at)}`,+ () => openSession(session.id),+ );const active = state.activeOperations.get(session.id);if (active) {item.appendChild(node("span",- "chat-session-status",+ "session-status",active.action === "compact" ? "Compacting…" : "Thinking…",),);@@ -1000,7 +997,8 @@return;}const refreshingVisibleSession =- state.session?.id === id && Boolean(document.getElementById("chatTranscript"));+ state.session?.id === id &&+ Boolean(document.getElementById("chatTranscript"));if (!refreshingVisibleSession) renderLoading();try {const detail = await state.api(`/admin/api/chat/sessions/${id}`);@@ -1023,7 +1021,7 @@}} catch (error) {if (version !== state.routeVersion) return;- const empty = node("section", "chat-empty");+ const empty = node("section", "session-empty");empty.append(node("h3", "", "Could not open this chat"),node("p", "", error.message),@@ -1067,22 +1065,20 @@function renderSession({ followLatest = true, scrollTop = 0 } = {}) {const session = state.session;if (!session) return;- const previousTitle = document.querySelector(".chat-title");+ const previousTitle = root().querySelector(".session-title");if (previousTitle instanceof HTMLInputElement) {state.retiredTitleInputs.add(previousTitle);}state.modelComboboxes.clear();- const shell = node("div", "chat-session-shell");const header = renderSessionHeader(session);- const notice = node("div", "chat-notice");+ const notice = node("div", "session-notice");notice.id = "chatNotice";notice.hidden = true;- const scroller = node("div", "chat-transcript");+ const scroller = node("div", "session-transcript");scroller.id = "chatTranscript";scroller.setAttribute("aria-label", "Conversation");const composer = renderComposer();- shell.append(header, notice, scroller, composer);- root().replaceChildren(shell);+ root().replaceChildren(UI.shell(header, notice, scroller, composer));renderTranscript();refreshComposerState();if (followLatest) {@@ -1102,28 +1098,7 @@}function renderSessionHeader(session) {- const header = node("header", "chat-session-header");- const top = node("div", "chat-header-row");- top.appendChild(button("← Chats", "chat-back-button", goLibrary));- const title = node("input", "chat-title");- title.value = session.title;- title.maxLength = 200;- title.setAttribute("aria-label", "Chat title");- title.addEventListener("blur", () => {- if (- title.isConnected &&- !state.retiredTitleInputs.has(title) &&- title.value !== state.session?.title- )- void updateSession({ title: title.value });- });- title.addEventListener("keydown", (event) => {- if (event.key === "Enter") title.blur();- });- top.appendChild(title);- top.appendChild(button("Delete", "danger-button", deleteSession));-- const controls = node("div", "chat-controls");+ const controls = node("div", "session-controls");const compact = button("Compact now", "secondary-button", compactSession);compact.id = "chatCompact";controls.append(@@ -1133,65 +1108,49 @@compact,button("System prompt", "secondary-button", editSystemPrompt),);- header.append(top, controls);- return header;+ return UI.header(+ "← Chats",+ goLibrary,+ session.title,+ "Chat title",+ (title) => {+ if (+ !state.retiredTitleInputs.has(title) &&+ title.value !== state.session?.title+ )+ void updateSession({ title: title.value });+ },+ [button("Delete", "danger-button", deleteSession)],+ controls,+ );}function renderModelControl(session) {- const group = node("div", "chat-control chat-model-control");- const label = node("label", "", "Model");- label.htmlFor = "chatModel";- const input = node("input", "chat-model-input");- input.id = "chatModel";- input.type = "text";- input.autocomplete = "off";- input.value = session.model;- input.setAttribute("aria-label", "Selected model");- let committedModel = session.model;- const availableModels = () =>- (state.bootstrap?.models || []).map((option) => option.model_ref);- const combobox = new window.FccModelCombobox(input, {- listboxId: "chat-model-options",- label: "model",- values: availableModels,- emptyMessage: () =>- availableModels().length ? "No matching models." : "No models available.",- registry: state.modelComboboxes,- onSelect: (model) => {- committedModel = model;+ return UI.modelControl(+ "chatModel",+ session.model,+ () => (state.bootstrap?.models || []).map((option) => option.model_ref),+ state.modelComboboxes,+ (model) => {void updateSession({ model });},- onClose: () => {- input.value = committedModel;- },- });- group.append(label, combobox.element);- return group;+ ).group;}function renderReasoningControl(session) {- const group = node("label", "chat-control");- group.appendChild(node("span", "", "Thinking"));- const select = node("select");- select.id = "chatReasoning";- [- ["off", "Off"],- ["low", "Low"],- ["medium", "Medium"],- ["high", "High"],- ["xhigh", "Extra High"],- ["max", "Max"],- ].forEach(([value, label]) => {- const option = node("option", "", label);- option.value = value;- select.appendChild(option);- });- select.value = session.reasoning;- select.addEventListener("change", () =>- updateSession({ reasoning: select.value }),- );- group.appendChild(select);- return group;+ return UI.reasoningControl(+ "chatReasoning",+ [+ ["off", "Off"],+ ["low", "Low"],+ ["medium", "Medium"],+ ["high", "High"],+ ["xhigh", "Extra High"],+ ["max", "Max"],+ ],+ session.reasoning,+ (reasoning) => updateSession({ reasoning }),+ ).group;}function renderContextMeter() {@@ -1201,7 +1160,9 @@return meter;}- function updateContextMeter(element = document.getElementById("chatContextMeter")) {+ function updateContextMeter(+ element = document.getElementById("chatContextMeter"),+ ) {if (!element) return;const context = state.context;if (!context || context.context_window_tokens === null) {@@ -1215,74 +1176,33 @@}function renderComposer() {- const wrapper = node("div", "chat-composer");- const textarea = node("textarea");- textarea.id = "chatComposer";- textarea.rows = 2;- textarea.placeholder = "Message this model";- textarea.value = state.draft;- textarea.setAttribute("aria-label", "Message");- textarea.addEventListener("input", () => {- state.draft = textarea.value;- state.draftOperationId = null;- state.draftSubmittedText = "";- saveDraft();- refreshComposerState();- scheduleEstimate();- });- textarea.addEventListener("keydown", (event) => {- if (event.key === "Enter" && !event.shiftKey) {- event.preventDefault();- if (!document.getElementById("chatSend")?.disabled) sendMessage();- }- });- const actions = node("div", "chat-composer-actions");- const status = node("span", "chat-composer-status");- status.id = "chatComposerStatus";- status.setAttribute("aria-live", "polite");- const send = button("Send", "primary-button", sendMessage);- send.id = "chatSend";- const stop = button("Stop", "danger-button", stopOperation);- stop.id = "chatStop";- stop.hidden = true;- actions.append(status, send, stop);- wrapper.append(textarea, actions);- return wrapper;- }-- function resizeComposer(textarea) {- textarea.style.height = "auto";- textarea.style.height = `${textarea.scrollHeight}px`;- textarea.style.overflowY =- textarea.scrollHeight > textarea.clientHeight ? "auto" : "hidden";- }-- function composerFocusIsUnclaimed() {- const active = document.activeElement;- return !active || active === document.body || active === document.documentElement;+ return UI.composer(+ "chat",+ state.draft,+ "Message this model",+ (value) => {+ state.draft = value;+ state.draftOperationId = null;+ state.draftSubmittedText = "";+ saveDraft();+ refreshComposerState();+ scheduleEstimate();+ },+ sendMessage,+ stopOperation,+ );}function captureComposerSelection() {- const textarea = document.getElementById("chatComposer");- if (!textarea || document.activeElement !== textarea) return null;- return {- start: textarea.selectionStart,- end: textarea.selectionEnd,- direction: textarea.selectionDirection,- };+ return UI.captureSelection(document.getElementById("chatComposer"));}function restoreComposerSelection(selection) {- const textarea = document.getElementById("chatComposer");- if (!textarea || textarea.disabled || !selection) return;- const start = Math.min(selection.start, textarea.value.length);- const end = Math.min(selection.end, textarea.value.length);- textarea.focus({ preventScroll: true });- textarea.setSelectionRange(start, end, selection.direction);+ UI.restoreSelection(document.getElementById("chatComposer"), selection);}function captureTitleEdit() {- const input = document.querySelector(".chat-title");+ const input = root().querySelector(".session-title");if (!(input instanceof HTMLInputElement) ||document.activeElement !== input ||@@ -1298,7 +1218,7 @@}function restoreTitleEdit(edit) {- const input = document.querySelector(".chat-title");+ const input = root().querySelector(".session-title");if (!(input instanceof HTMLInputElement) || !edit) return;input.value = edit.value;input.focus({ preventScroll: true });@@ -1314,12 +1234,20 @@scroller.replaceChildren();if (state.nextBefore) {scroller.appendChild(- button("Load older messages", "secondary-button chat-older", loadOlder),+ button(+ "Load older messages",+ "secondary-button session-older",+ loadOlder,+ ),);}if (!state.turns.length && !state.operation) {scroller.appendChild(- node("div", "chat-empty chat-transcript-empty", "Start the conversation."),+ node(+ "div",+ "session-empty session-transcript-empty",+ "Start the conversation.",+ ),);return;}@@ -1348,10 +1276,10 @@state.operation.userText &&!operationHasTurn) {- const pending = node("article", "chat-message user-message");+ const pending = node("article", "session-message user-message");pending.append(- node("div", "chat-message-label", "You"),- node("div", "chat-message-plain", state.operation.userText),+ node("div", "session-message-label", "You"),+ node("div", "session-message-plain", state.operation.userText),);scroller.appendChild(pending);}@@ -1364,53 +1292,59 @@}function renderUserMessage(turn) {- const message = node("article", "chat-message user-message");- message.append(node("div", "chat-message-label", "You"));- const body = node("div", "chat-message-plain", turn.user_text);+ const message = UI.message("user", "You");+ const body = node("div", "session-message-plain", turn.user_text);message.appendChild(body);return message;}function renderAssistantMessage(turn) {const generation = turn.generation;- const message = node("article", "chat-message assistant-message");- const label = node("div", "chat-message-label", "Assistant");+ const message = UI.message("assistant", "Assistant");+ const label = message.firstElementChild;if (generation.actual_model &&generation.actual_model !== generation.requested_model) {label.appendChild(- node("span", "chat-fallback-label", `Answered by ${generation.actual_model}`),+ node(+ "span",+ "chat-fallback-label",+ `Answered by ${generation.actual_model}`,+ ),);}message.appendChild(label);generation.segments.forEach((segment) => {if (segment.kind === "thinking") {- const details = document.createElement("details");- details.className = "chat-thinking";- details.appendChild(node("summary", "", "Thinking"));- const content = node("div", "chat-markdown");+ const details = UI.thinking();+ const content = node("div", "session-markdown");content.innerHTML = segment.html;details.appendChild(content);message.appendChild(details);} else {- const content = node("div", "chat-markdown");+ const content = node("div", "session-markdown");// The server renders this with raw HTML disabled and safe-link rules.content.innerHTML = segment.html;message.appendChild(content);}});if (!generation.segments.length && generation.status === "running") {- message.appendChild(node("p", "chat-muted", "Running in another tab…"));+ message.appendChild(+ node("p", "session-muted", "Running in another tab…"),+ );}if (generation.status !== "completed" && generation.status !== "running") {- const status = node("div", `chat-generation-status ${generation.status}`);+ const status = node(+ "div",+ `session-generation-status ${generation.status}`,+ );status.textContent =generation.error_message || `${capitalize(generation.status)} answer`;message.appendChild(status);}if (turn === state.turns[state.turns.length - 1]) {- const actions = node("div", "chat-message-actions");+ const actions = node("div", "session-message-actions");if (["failed", "stopped", "interrupted"].includes(generation.status)) {actions.appendChild(button("Retry", "secondary-button", retryMessage));}@@ -1425,24 +1359,27 @@}function renderLiveAssistant(operation) {- const message = node("article", "chat-message assistant-message live-message");- message.appendChild(node("div", "chat-message-label", "Assistant"));+ const message = node(+ "article",+ "session-message assistant-message live-message",+ );+ message.appendChild(node("div", "session-message-label", "Assistant"));if (!operation.segments.length || operation.status !== "Thinking…") {const status = node("p",- "chat-muted chat-operation-status",+ "session-muted chat-operation-status",operation.status,);status.setAttribute("aria-live", "polite");message.appendChild(status);}operation.segments.forEach((segment, ordinal) => {- const content = node("div", "chat-message-plain");+ const content = node("div", "session-message-plain");content.dataset.liveSegment = String(ordinal);content.appendChild(document.createTextNode(segment.text));if (segment.kind === "thinking") {const details = document.createElement("details");- details.className = "chat-thinking";+ details.className = "session-thinking";details.open = true;details.appendChild(node("summary", "", "Thinking"));details.appendChild(content);@@ -1458,7 +1395,7 @@const details = document.createElement("details");details.className = "chat-compaction";details.appendChild(node("summary", "", "Earlier conversation compacted"));- const summary = node("div", "chat-markdown");+ const summary = node("div", "session-markdown");summary.innerHTML = state.compaction.summary_html;details.appendChild(summary);return details;@@ -1478,7 +1415,7 @@return;const request = { sessionId, before };state.olderLoad = request;- const button = scroller.querySelector(".chat-older");+ const button = scroller.querySelector(".session-older");if (button) button.disabled = true;const oldHeight = scroller.scrollHeight;const isCurrent = () =>@@ -1514,16 +1451,13 @@const expectedRevision = state.session.revision;const routeVersion = state.routeVersion;try {- const session = await state.api(- `/admin/api/chat/sessions/${sessionId}`,- {- method: "PATCH",- body: JSON.stringify({- expected_revision: expectedRevision,- ...changes,- }),- },- );+ const session = await state.api(`/admin/api/chat/sessions/${sessionId}`, {+ method: "PATCH",+ body: JSON.stringify({+ expected_revision: expectedRevision,+ ...changes,+ }),+ });if (routeVersion !== state.routeVersion ||state.session?.id !== sessionId ||@@ -1536,7 +1470,10 @@renderSessionPreservingScroll();scheduleEstimate(true);} catch (error) {- if (routeVersion !== state.routeVersion || state.session?.id !== sessionId)+ if (+ routeVersion !== state.routeVersion ||+ state.session?.id !== sessionId+ )return;await reloadSession();setNotice(error.message, "error");@@ -1575,7 +1512,7 @@node("h3", "", "System prompt"),node("p",- "chat-muted",+ "session-muted","Shared by every Chat Session and applied on the next turn.",),);@@ -1638,7 +1575,8 @@async function updateEstimate(version) {const session = state.session;- if (!session || state.operation || version !== state.estimateVersion) return;+ if (!session || state.operation || version !== state.estimateVersion)+ return;const textarea = document.getElementById("chatComposer");const revision = session.revision;const draft = textarea?.value || "";@@ -1693,7 +1631,10 @@if (latest?.generation?.status === "running") return "This chat is running";const option = modelOption(state.session.model);if (!option) return "Choose an available model";- if (option.supports_reasoning === false && state.session.reasoning !== "off") {+ if (+ option.supports_reasoning === false &&+ state.session.reasoning !== "off"+ ) {return "This model requires Thinking Off";}if (state.contextError) return state.contextError;@@ -1731,15 +1672,15 @@: state.operation? "": blocked;- document+ root().querySelectorAll(- ".chat-controls button, .chat-controls input, .chat-controls select",+ ".session-controls button, .session-controls input, .session-controls select",).forEach((control) => {control.disabled = busy || !mutationsReady();});- document- .querySelectorAll(".chat-header-row .danger-button, .chat-title")+ root()+ .querySelectorAll(".session-header-row .danger-button, .session-title").forEach((control) => {control.disabled = !mutationsReady();});@@ -1807,7 +1748,9 @@acknowledgement.operation_id !== operation.id ||acknowledgement.kind !== action) {- throw new Error("The server returned an invalid operation acknowledgement.");+ throw new Error(+ "The server returned an invalid operation acknowledgement.",+ );}operation.commandPending = false;operation.serverObserved = true;@@ -1920,10 +1863,6 @@}}- function nearBottom(scroller) {- return scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight < 80;- }-function scrollLatest(smooth) {const scroller = document.getElementById("chatTranscript");if (!scroller) return;diff --git a/src/free_claude_code/api/admin_static/code_sessions.css b/src/free_claude_code/api/admin_static/code_sessions.cssnew file mode 100644index 00000000..5e67451f--- /dev/null+++ b/src/free_claude_code/api/admin_static/code_sessions.css@@ -0,0 +1,101 @@+.code-actions {+ display: flex;+ align-items: center;+ gap: 12px;+ flex-wrap: wrap;+}+.code-folder {+ color: var(--muted);+ overflow-wrap: anywhere;+ margin: 10px 0 0;+ font-size: 12px;+}+.code-notice {+ color: var(--muted);+ white-space: pre-wrap;+}+.code-notice:empty {+ display: none;+}+.code-tool,+.code-prompt {+ border: 1px solid var(--line);+ border-radius: var(--radius-md);+ padding: 12px 16px;+ background: var(--panel);+}+.code-tool summary {+ cursor: pointer;+ font-weight: 600;+}+.code-item-detail,+.code-prompt pre {+ white-space: pre-wrap;+ overflow-wrap: anywhere;+ margin: 10px 0;+}+.code-item[data-kind="tool"] .code-prose {+ white-space: pre-wrap;+ font-family: monospace;+}+.code-prompt {+ margin: 12px 0;+}+.code-prompt fieldset {+ border: 0;+ padding: 0;+ margin: 12px 0;+ min-width: 0;+}+.code-prompt legend {+ font-weight: 600;+ margin-bottom: 8px;+}+.code-field {+ display: grid;+ gap: 6px;+ margin: 12px 0;+}+.code-field small {+ color: var(--muted);+}+.code-field input:not([type="checkbox"]):not([type="radio"]),+.code-field select,+.code-dialog input,+.code-dialog select {+ width: 100%;+ min-height: 40px;+ border: 1px solid var(--line-strong);+ border-radius: var(--radius-md);+ background: var(--input);+ color: inherit;+ padding: 8px;+ font: inherit;+}+.code-choice {+ display: flex;+ gap: 8px;+ align-items: baseline;+ margin: 8px 0;+ overflow-wrap: anywhere;+}+.code-dialog {+ width: min(520px, calc(100vw - 32px));+ max-height: 90dvh;+ overflow: auto;+ border: 1px solid var(--line-strong);+ border-radius: var(--radius-lg);+ background: var(--panel);+ color: var(--text);+ padding: 24px;+}+.code-dialog::backdrop {+ background: #0008;+}+.code-dialog h3 {+ margin-top: 0;+}+.code-dialog .code-actions {+ justify-content: flex-end;+ margin-top: 20px;+}diff --git a/src/free_claude_code/api/admin_static/code_sessions.js b/src/free_claude_code/api/admin_static/code_sessions.jsnew file mode 100644index 00000000..4a0055c0--- /dev/null+++ b/src/free_claude_code/api/admin_static/code_sessions.js@@ -0,0 +1,1314 @@+(() => {+ "use strict";+ const UI = window.SessionUI;+ const modelComboboxes = new Set();+ let modelControl,+ reasoningControl,+ catalog = [],+ catalogLoaded = false,+ settingsPending = false;+ let visibleIds = [],+ query = "",+ libraryToken = 0,+ listFlight = null,+ listAgain = false,+ retryTimer = null;+ let syncNotice = "",+ availabilityNotice = "";+ const base = "/admin/api/code";+ const activeStatuses = new Set(["preparing", "running", "stopping"]);+ const records = new Map();+ const deleted = new Set();+ const sends = new Set();+ let api,+ root,+ feed,+ epoch,+ connected = false,+ synchronized = false;+ let desiredPath = null,+ selected = null,+ rendered = null,+ syncToken = 0,+ viewToken = 0;+ let nextCursor = null,+ libraryLoading = false,+ notice = "",+ available = false;++ function element(tag, text, className) {+ const node = document.createElement(tag);+ if (text !== undefined) node.textContent = text;+ if (className) node.className = className;+ return node;+ }+ function button(text, action, className = "secondary-button") {+ const node = element("button", text, className);+ node.type = "button";+ node.addEventListener("click", action);+ return node;+ }+ function saved(id) {+ try {+ return JSON.parse(sessionStorage.getItem(`fcc.code.${id}`)) || {};+ } catch {+ return {};+ }+ }+ function save(id, value) {+ try {+ sessionStorage.setItem(`fcc.code.${id}`, JSON.stringify(value));+ } catch {+ /* This tab still works when browser storage is unavailable. */+ }+ }+ function get(id) {+ if (!records.has(id))+ records.set(id, {+ id,+ session: null,+ run: null,+ version: -1,+ cursor: -1,+ items: new Map(),+ prompts: new Map(),+ activePrompts: new Map(),+ runs: new Map(),+ loaded: false,+ nextBefore: null,+ });+ return records.get(id);+ }+ function busy(record) {+ return activeStatuses.has(record?.run?.status);+ }+ function pending(record) {+ return [...(record?.activePrompts.values() || [])].some(+ (entry) => entry.active,+ );+ }++ function ready(record) {+ return synchronized && record?.loaded && record.session?.status === "ready";+ }+ function mergeEntries(target, entries, version) {+ for (const value of entries || []) {+ if ((target.get(value.id)?.version ?? -1) <= version)+ target.set(value.id, { value, version });+ }+ }+ function merge(data) {+ if (data.epoch !== epoch) return;+ const id = data.session_id || data.session?.id;+ if (!id || deleted.has(id)) return;+ const record = get(id),+ version = data.version;+ if (version >= record.version) {+ if (!record.session || data.session.revision >= record.session.revision)+ record.session = data.session;+ if (+ record.run?.id !== data.run?.id ||+ !activeStatuses.has(data.run?.status)+ )+ record.runNotice = "";+ record.run = data.run;+ record.version = version;+ record.cursor = Math.max(record.cursor, data.cursor || 0);+ if (record.run) accepted(id, record.run.id);+ }+ mergeEntries(+ record.runs,+ [...(data.runs || []), ...(data.run ? [data.run] : [])],+ version,+ );+ mergeEntries(record.items, data.item ? [data.item] : data.items, version);+ const prompts = data.prompt ? [data.prompt] : data.prompts || [];+ mergeEntries(record.prompts, prompts, version);+ for (const prompt of prompts) {+ if ((record.activePrompts.get(prompt.id)?.version ?? -1) <= version)+ record.activePrompts.set(prompt.id, {+ active: ["pending", "answering"].includes(prompt.status),+ version,+ });+ }+ if (data.active_prompt_ids) {+ const active = new Set(data.active_prompt_ids);+ for (const promptId of new Set([+ ...record.activePrompts.keys(),+ ...active,+ ])) {+ if ((record.activePrompts.get(promptId)?.version ?? -1) <= version)+ record.activePrompts.set(promptId, {+ active: active.has(promptId),+ version,+ });+ }+ }+ }++ function receive(type, event) {+ const data = JSON.parse(event.data);+ if (data.epoch !== epoch) return;+ const previousRevision = records.get(data.session_id)?.session?.revision;+ if (type === "session.deleted") {+ removeDeletedSession(data.session_id, "Session deleted.");+ } else {+ merge(data);+ if (type === "session.notice" && data.session_id === selected)+ notice = data.message;+ if (type === "run.notice") {+ const record = records.get(data.session_id);+ if (record && busy(record) && data.version >= record.version)+ record.runNotice = data.will_retry+ ? `Retrying… ${data.message}`+ : data.message;+ }+ }+ if (+ !selected &&+ (type === "session.deleted" ||+ data.session?.revision !== previousRevision)+ )+ void refreshLibrary();+ render();+ }++ async function list(cursor = null) {+ const requestEpoch = epoch,+ token = syncToken,+ route = viewToken,+ search = query,+ request = ++libraryToken;+ const params = new URLSearchParams({ query: search });+ if (cursor) params.set("cursor", cursor);+ const data = await api(`${base}/sessions?${params}`);+ if (+ requestEpoch !== epoch ||+ data.epoch !== epoch ||+ token !== syncToken ||+ route !== viewToken ||+ search !== query ||+ request !== libraryToken+ )+ return;+ const ids = cursor ? [...visibleIds] : [];+ for (const session of data.sessions) {+ if (deleted.has(session.id)) continue;+ const record = get(session.id);+ if (+ (!record.session || session.revision >= record.session.revision) &&+ record.cursor <= data.cursor+ )+ record.session = session;+ if (!ids.includes(session.id)) ids.push(session.id);+ }+ visibleIds = ids;+ nextCursor = data.next_cursor;+ render();+ }+ async function refreshLibrary() {+ listAgain = true;+ if (listFlight) return listFlight;+ listFlight = (async () => {+ while (listAgain && !selected) {+ listAgain = false;+ try {+ await list();+ } catch (error) {+ restart(error.message);+ break;+ }+ }+ })();+ try {+ await listFlight;+ } finally {+ listFlight = null;+ }+ }++ async function detail(id, before = null) {+ const requestEpoch = epoch,+ token = viewToken,+ connection = syncToken;+ let data;+ try {+ data = await api(+ `${base}/sessions/${id}${before ? `/items?before=${encodeURIComponent(before)}` : ""}`,+ );+ } catch (error) {+ if (token !== viewToken || connection !== syncToken || selected !== id)+ return;+ if (error.status === 404) {+ removeDeletedSession(id, "This session was deleted.");+ render();+ return;+ }+ throw error;+ }+ if (+ requestEpoch !== epoch ||+ data.epoch !== epoch ||+ token !== viewToken ||+ connection !== syncToken ||+ selected !== id ||+ deleted.has(id)+ )+ return;+ merge(data);+ const record = get(id);+ record.loaded = true;+ record.nextBefore = data.next_before;+ render();+ }+ async function bootstrap() {+ const token = syncToken;+ try {+ const data = await api(`${base}/bootstrap`);+ if (token !== syncToken || (epoch && data.epoch !== epoch)) return;+ available = data.available;+ catalog = data.models;+ catalogLoaded = true;+ availabilityNotice = data.message || "";+ } catch (error) {+ if (token === syncToken) catalogLoaded = false;+ throw error;+ }+ }++ async function synchronize(readyData) {+ const token = ++syncToken;+ synchronized = false;+ connected = true;+ clearTimeout(retryTimer);+ retryTimer = null;+ if (epoch !== readyData.epoch) {+ epoch = readyData.epoch;+ records.clear();+ deleted.clear();+ rendered = null;+ }+ const included = new Set(+ readyData.sessions.map((summary) => summary.session_id),+ );+ for (const record of records.values()) {+ if (+ !included.has(record.id) &&+ busy(record) &&+ record.cursor <= readyData.cursor+ ) {+ // The run is no longer active; detail supplies its actual outcome.+ record.run = null;+ record.runNotice = "";+ record.loaded = false;+ record.cursor = readyData.cursor;+ }+ }+ for (const summary of readyData.sessions)+ merge({ ...summary, cursor: readyData.cursor });+ render();+ try {+ const results = await Promise.allSettled([+ list(),+ selected ? detail(selected) : Promise.resolve(),+ bootstrap(),+ ]);+ if (token !== syncToken || !connected) return;+ for (const result of results)+ if (result.status === "rejected") throw result.reason;+ synchronized = true;+ syncNotice = "";+ for (const id of records.keys()) if (saved(id).pending) void deliver(id);+ } catch (error) {+ if (token === syncToken) restart(error.message);+ }+ render();+ }+ function restart(message = "Reconnecting…") {+ if (feed) feed.close();+ feed = null;+ connected = false;+ synchronized = false;+ ++syncToken;+ syncNotice = message;+ if (retryTimer === null)+ retryTimer = setTimeout(() => {+ retryTimer = null;+ connect();+ }, 1000);+ render();+ }++ function connect() {+ if (feed || retryTimer !== null) return;+ const source = new EventSource(`${base}/events`);+ feed = source;+ source.addEventListener("feed.ready", (event) => {+ if (feed === source) void synchronize(JSON.parse(event.data));+ });+ for (const type of [+ "session.updated",+ "session.deleted",+ "run.updated",+ "item.updated",+ "prompt.updated",+ "session.notice",+ "run.notice",+ ])+ source.addEventListener(type, (event) => {+ if (feed === source) receive(type, event);+ });+ const disconnected = async () => {+ if (feed !== source) return;+ restart();+ // A stopped store cannot open its event feed. Read its availability+ // so that the retry screen can explain why it is unavailable.+ try {+ await bootstrap();+ render();+ } catch {+ /* The scheduled connection retries the reads. */+ }+ };+ source.addEventListener("feed.resync_required", disconnected);+ source.onerror = disconnected;+ }++ function replaceDeletedRoute(id) {+ const view = root?.closest(".admin-view");+ if (+ !view ||+ view.hidden ||+ window.location.pathname !== `/admin/code/${id}`+ )+ return false;+ history.replaceState({}, "", "/admin/code");+ return true;+ }+ function removeDeletedSession(id, message) {+ deleted.add(id);+ records.delete(id);+ visibleIds = visibleIds.filter((visibleId) => visibleId !== id);+ const replaced = replaceDeletedRoute(id);+ if (selected === id || replaced) {+ activate("/admin/code");+ notice = message;+ }+ }+ function navigate(id) {+ const path = id ? `/admin/code/${id}` : "/admin/code";+ history.pushState({}, "", path);+ activate(path);+ }+ function activate(path) {+ desiredPath = path;+ if (!api) return;+ let id = /^\/admin\/code\/([0-9a-f-]+)$/.exec(path)?.[1] || null;+ const missing = id !== null && deleted.has(id);+ if (missing) {+ replaceDeletedRoute(id);+ desiredPath = "/admin/code";+ id = null;+ }+ if (id !== selected || !rendered) {+ selected = id;+ ++viewToken;+ rendered = null;+ settingsPending = false;+ notice = "";+ render();+ if (connected && epoch) {+ const reading = id ? detail(id) : refreshLibrary();+ const token = viewToken;+ void reading.catch((error) => {+ if (token === viewToken) restart(error.message);+ });+ }+ }+ if (missing) {+ notice = "This session was deleted.";+ render();+ }+ connect();+ }++ function accepted(id, operationId) {+ const state = saved(id);+ if (state.pending?.operation_id !== operationId) return;+ const oldText = state.pending.text;+ delete state.pending;+ if (state.draft === oldText) state.draft = "";+ save(id, state);+ if (+ selected === id &&+ root?.querySelector("#codeComposer")?.value === oldText+ )+ root.querySelector("#codeComposer").value = "";+ }+ async function deliver(id) {+ const command = saved(id).pending;+ if (!command || sends.has(id) || !synchronized) return;+ sends.add(id);+ render();+ try {+ const receipt = await api(`${base}/sessions/${id}/turns`, {+ method: "POST",+ body: JSON.stringify(command),+ });+ accepted(id, receipt.id);+ } catch (error) {+ const state = saved(id);+ if (state.pending?.operation_id === command.operation_id) {+ if (error.status && error.status < 500) {+ delete state.pending;+ save(id, state);+ }+ if (selected === id) notice = error.message;+ }+ if (error.status === 400 || error.status === 409) {+ try {+ await bootstrap();+ } catch (failure) {+ restart(failure.message);+ }+ }+ } finally {+ sends.delete(id);+ render();+ }+ }+ function submit() {+ const record = records.get(selected);+ if (+ !ready(record) ||+ busy(record) ||+ pending(record) ||+ !available ||+ settingsPending ||+ selectionError(record)+ )+ return;+ const state = saved(selected),+ text = root.querySelector("#codeComposer").value;+ if (!state.pending && !text.trim()) return;+ state.draft = text;+ state.pending ||= {+ operation_id: crypto.randomUUID(),+ expected_revision: record.session.revision,+ expected_epoch: epoch,+ text,+ };+ save(selected, state);+ notice = "";+ void deliver(selected);+ }+ async function stop() {+ const record = records.get(selected);+ if (!busy(record)) return;+ const id = selected,+ run = record.run.id;+ try {+ await api(`${base}/sessions/${id}/stop`, {+ method: "POST",+ body: JSON.stringify({ operation_id: run }),+ });+ } catch (error) {+ if (selected === id) notice = error.message;+ }+ render();+ }+ function dialog(title, build, actionLabel, action) {+ const node = element("dialog", undefined, "code-dialog"),+ form = element("form");+ const heading = element("h3", title),+ error = element("p", "", "code-notice");+ heading.id = `code-dialog-${crypto.randomUUID()}`;+ node.setAttribute("aria-labelledby", heading.id);+ form.append(heading);+ const value = build(form);+ const actions = element("div", undefined, "code-actions");+ const cancel = button("Cancel", () => node.close());+ const confirm = button(actionLabel, () => {}, "primary-button");+ confirm.type = "submit";+ actions.append(cancel, confirm);+ form.append(error, actions);+ node.append(form);+ node.addEventListener("close", () => node.remove());+ form.addEventListener("submit", async (event) => {+ event.preventDefault();+ confirm.disabled = true;+ try {+ await action(value);+ node.close();+ } catch (failure) {+ error.textContent = failure.message;+ confirm.disabled = false;+ }+ });+ root.append(node);+ node.showModal();+ }+ function newSession() {+ const id = crypto.randomUUID();+ dialog(+ "New code session",+ (form) => {+ const harness = element("select");+ harness.append(new Option("Codex", "codex"));+ const folder = element("input");+ folder.required = true;+ folder.autocomplete = "off";+ label(form, "Harness", harness);+ label(form, "Folder", folder);+ form.append(+ element(+ "p",+ "Choose an existing folder on the computer running FCC.",+ "code-notice",+ ),+ );+ return folder;+ },+ "Create session",+ async (folder) => {+ await api(`${base}/sessions`, {+ method: "POST",+ body: JSON.stringify({+ session_id: id,+ harness: "codex",+ cwd: folder.value,+ }),+ });+ navigate(id);+ },+ );+ }+ async function updateSettings(changes) {+ const id = selected,+ record = records.get(id);+ if (!ready(record) || settingsPending) return;+ settingsPending = true;+ notice = "";+ renderControls();+ try {+ const session = await api(`${base}/sessions/${id}`, {+ method: "PATCH",+ body: JSON.stringify({+ expected_revision: record.session.revision,+ ...changes,+ }),+ });+ if (+ !deleted.has(id) &&+ session.revision >= (records.get(id)?.session?.revision || 0)+ )+ get(id).session = session;+ } catch (error) {+ if (selected === id) {+ notice = error.message;+ try {+ await detail(id);+ } catch (failure) {+ restart(failure.message);+ }+ }+ } finally {+ if (selected === id) {+ settingsPending = false;+ render();+ }+ }+ }+ function selectionError(record) {+ if (!record?.session) return "";+ if (!catalogLoaded) return "Model list unavailable. Reconnecting…";+ const model = catalog.find((model) => model.id === record.session.model);+ if (!model) return "Selected model is unavailable. Choose another model.";+ if (+ record.session.reasoning_effort &&+ !model.reasoning_efforts.includes(record.session.reasoning_effort)+ )+ return "Selected thinking effort is unavailable. Choose another effort or Model default.";+ return "";+ }++ function remove() {+ const record = records.get(selected),+ id = selected,+ revision = record.session.revision;+ if (record.session.status === "delete_uncertain") {+ void api(`${base}/sessions/${id}?expected_revision=${revision}`, {+ method: "DELETE",+ }).catch((error) => {+ notice = error.message;+ render();+ });+ return;+ }+ dialog(+ "Delete session?",+ (form) => {+ form.append(+ element(+ "p",+ "This deletes the conversation from FCC and Codex history. Your project files stay in place.",+ ),+ );+ },+ "Delete session",+ () =>+ api(`${base}/sessions/${id}?expected_revision=${revision}`, {+ method: "DELETE",+ }),+ );+ }+ function label(parent, title, input, description) {+ const node = element("label", undefined, "code-field");+ node.append(element("span", title), input);+ if (description) node.append(element("small", description));+ parent.append(node);+ return node;+ }+ function shell() {+ root.replaceChildren();+ modelComboboxes.clear();+ modelControl = reasoningControl = null;+ const message = element("div", "", "session-notice");+ message.id = "codeNotice";+ message.setAttribute("role", "status");+ if (selected) {+ const id = selected,+ record = get(id);+ const controls = element("div", undefined, "session-controls");+ modelControl = UI.modelControl(+ "codeModel",+ record.session?.model || "",+ () => catalog.map((model) => model.id),+ modelComboboxes,+ (model) => {+ void updateSettings({ model });+ },+ );+ reasoningControl = UI.reasoningControl(+ "codeReasoning",+ [],+ "",+ (value) => {+ void updateSettings({ reasoning_effort: value || null });+ },+ );+ controls.append(modelControl.group, reasoningControl.group);+ const deletion = button("Delete", remove, "danger-button");+ deletion.id = "codeDelete";+ const header = UI.header(+ "← Code sessions",+ () => navigate(null),+ record.session?.title || "Code session",+ "Code title",+ (title) => {+ if (+ selected === id &&+ title.value !== records.get(id)?.session?.title+ )+ void updateSettings({ title: title.value });+ },+ [deletion],+ controls,+ );+ header.append(element("p", "", "code-folder"));+ const transcript = element("div", undefined, "session-transcript");+ transcript.id = "codeTranscript";+ transcript.setAttribute("aria-label", "Conversation");+ const older = button(+ "Load older messages",+ async () => {+ const oldHeight = transcript.scrollHeight,+ top = transcript.scrollTop;+ older.disabled = true;+ try {+ await detail(id, records.get(id).nextBefore);+ if (selected === id)+ transcript.scrollTop = top + transcript.scrollHeight - oldHeight;+ } catch (error) {+ restart(error.message);+ }+ older.disabled = false;+ render();+ },+ "secondary-button session-older",+ );+ older.id = "codeOlder";+ transcript.append(+ older,+ element("div", undefined, "code-items"),+ element("div", undefined, "code-prompts"),+ );+ const composer = UI.composer(+ "code",+ saved(id).draft || "",+ "Ask Codex to work on this folder…",+ (value) => {+ save(id, { ...saved(id), draft: value });+ renderControls();+ },+ submit,+ () => {+ void stop();+ },+ );+ root.append(UI.shell(header, message, transcript, composer));+ UI.resizeComposer(composer.querySelector("textarea"));+ } else {+ const create = button("New code session", newSession, "primary-button");+ create.id = "codeNew";+ const header = UI.libraryHeader(+ "Code sessions",+ "Work with Codex in a project folder.",+ create,+ );+ const search = UI.search("Search titles and folders", query, (value) => {+ query = value;+ visibleIds = [];+ nextCursor = null;+ ++libraryToken;+ render();+ void refreshLibrary();+ });+ const more = button(+ "Load more sessions",+ async () => {+ libraryLoading = true;+ render();+ try {+ await list(nextCursor);+ } catch (error) {+ restart(error.message);+ }+ libraryLoading = false;+ render();+ },+ "secondary-button session-load-more",+ );+ more.id = "codeMore";+ const library = element("div", undefined, "session-list");+ library.id = "codeLibrary";+ const wrapper = element("div", undefined, "session-library");+ wrapper.append(header, search, message, library, more);+ root.append(wrapper);+ }+ rendered = selected || "library";+ }++ function render() {+ if (!root) return;+ if (rendered !== (selected || "library")) shell();+ const message = root.querySelector("#codeNotice");+ message.textContent =+ notice ||+ availabilityNotice ||+ syncNotice ||+ (!connected ? "Connecting…" : !synchronized ? "Synchronizing…" : "");+ message.hidden = !message.textContent;+ if (!selected) {+ const library = root.querySelector("#codeLibrary");+ for (const child of [...library.children])+ if (!child.dataset.id || !visibleIds.includes(child.dataset.id))+ child.remove();+ for (const record of visibleIds+ .map((id) => records.get(id))+ .filter((record) => record?.session)+ .sort(+ (a, b) =>+ b.session.updated_at - a.session.updated_at ||+ b.id.localeCompare(a.id),+ )) {+ let card = library.querySelector(+ `[data-id="${CSS.escape(record.id)}"]`,+ );+ if (!card) {+ card = UI.card("", "", "", () => navigate(record.id));+ card.dataset.id = record.id;+ }+ card.children[0].textContent = record.session.title;+ card.children[1].textContent = record.session.cwd;+ card.children[2].textContent = busy(record)+ ? "Running"+ : record.session.error || record.session.model;+ library.append(card);+ }+ if (!library.children.length)+ library.append(+ element(+ "div",+ synchronized+ ? query+ ? "No matching sessions."+ : "Start your first code session."+ : "Loading sessions…",+ "session-empty",+ ),+ );+ root.querySelector("#codeNew").disabled = !synchronized;+ const more = root.querySelector("#codeMore");+ more.hidden = !nextCursor;+ more.disabled = !synchronized || libraryLoading;+ return;+ }+ const record = records.get(selected),+ title = root.querySelector(".session-title");+ if (record?.session) {+ if (document.activeElement !== title) title.value = record.session.title;+ root.querySelector(".code-folder").textContent = record.session.cwd;+ }+ const transcript = root.querySelector("#codeTranscript"),+ bottom = UI.nearBottom(transcript),+ items = root.querySelector(".code-items");+ const runs = [...(record?.runs.values() || [])]+ .map((entry) => entry.value)+ .sort((a, b) => a.ordinal - b.ordinal);+ for (const run of runs) {+ const source = [...record.items.values()]+ .map((entry) => entry.value)+ .filter((item) => item.run_id === run.id)+ .sort((a, b) => a.sequence - b.sequence);+ if (!source.length) continue;+ let group = items.querySelector(`[data-run-id="${CSS.escape(run.id)}"]`);+ if (!group) {+ group = element("div", undefined, "code-run");+ group.dataset.runId = run.id;+ group.dataset.ordinal = run.ordinal;+ group.append(+ element("div", undefined, "code-run-items"),+ UI.message("assistant", "Codex"),+ );+ group.lastChild.classList.add("code-outcome");+ group.lastChild.append(element("div", "", "session-generation-status"));+ const next = [...items.children].find(+ (child) => Number(child.dataset.ordinal) > run.ordinal,+ );+ items.insertBefore(group, next || null);+ }+ for (const item of source) renderItem(group.firstChild, item);+ const outcome = group.querySelector(".code-outcome");+ outcome.hidden = !["failed", "interrupted"].includes(run.status);+ const status = outcome.querySelector(".session-generation-status");+ status.className = `session-generation-status ${run.status}`;+ status.textContent =+ run.error ||+ (run.status === "interrupted" ? "Turn stopped." : "This turn failed.");+ }+ const prompts = root.querySelector(".code-prompts");+ for (const { value: prompt } of record?.prompts.values() || [])+ renderPrompt(prompts, prompt);+ if (bottom) transcript.scrollTop = transcript.scrollHeight;+ root.querySelector("#codeOlder").hidden = !record?.nextBefore;+ renderControls();+ }++ function renderControls() {+ if (!selected || !root?.querySelector("#codeComposer")) return;+ const record = records.get(selected),+ isBusy = busy(record),+ input = root.querySelector("#codeComposer");+ const send = root.querySelector("#codeSend"),+ stop = root.querySelector("#codeStop");+ send.hidden = isBusy;+ stop.hidden = !isBusy;+ stop.disabled = !connected || record?.run?.stop_requested;+ send.textContent = saved(selected).pending ? "Retry Send" : "Send";+ send.disabled =+ !ready(record) ||+ !available ||+ pending(record) ||+ sends.has(selected) ||+ settingsPending ||+ !!selectionError(record) ||+ (!input.value.trim() && !saved(selected).pending);+ input.disabled = !record?.loaded || record?.session?.status !== "ready";+ root.querySelector(".session-title").disabled =+ !ready(record) || settingsPending;+ const deletion = root.querySelector("#codeDelete");+ deletion.textContent =+ record?.session?.status === "delete_uncertain"+ ? "Check deletion"+ : "Delete";+ deletion.disabled =+ !synchronized ||+ !record?.loaded ||+ record.session?.status === "deleting" ||+ isBusy ||+ pending(record);+ const disabled =+ !ready(record) ||+ isBusy ||+ pending(record) ||+ settingsPending ||+ !catalogLoaded;+ modelControl.update(record?.session?.model || "", disabled);+ const model = catalog.find((model) => model.id === record?.session?.model),+ effort = record?.session?.reasoning_effort;+ const options = [+ [+ "",+ model?.default_reasoning_effort+ ? `Model default (${model.default_reasoning_effort})`+ : "Model default",+ ],+ ...(model?.reasoning_efforts || []).map((value) => [value, value]),+ ];+ if (effort && !model?.reasoning_efforts.includes(effort))+ options.push([effort, `${effort} (unavailable)`]);+ reasoningControl.update(options, effort || "");+ reasoningControl.select.disabled =+ disabled || !model || (!model.reasoning_efforts.length && !effort);+ root.querySelector("#codeComposerStatus").textContent =+ record?.session?.error ||+ selectionError(record) ||+ (record?.session?.status !== "ready"+ ? "Deleting…"+ : record.run?.stop_requested && isBusy+ ? "Stopping…"+ : pending(record)+ ? "Waiting for input"+ : isBusy+ ? record.runNotice || "Working…"+ : "Codex");+ for (const node of root.querySelectorAll(".code-prompt")) {+ const prompt = record?.prompts.get(node.dataset.id)?.value;+ for (const control of node.querySelectorAll("input, select, button"))+ control.disabled =+ !ready(record) ||+ !record.activePrompts.get(node.dataset.id)?.active ||+ prompt?.status !== "pending" ||+ node.dataset.claiming === "true";+ }+ UI.resizeComposer(input);+ }++ function renderItem(parent, item) {+ let node = parent.querySelector(`[data-id="${CSS.escape(item.id)}"]`);+ if (!node) {+ node = UI.message(+ item.kind === "user" ? "user" : "assistant",+ item.kind === "user" ? "You" : "Codex",+ );+ node.classList.add("code-item");+ node.dataset.id = item.id;+ node.dataset.kind = item.kind;+ let content = node;+ if (item.kind === "reasoning") {+ content = UI.thinking();+ node.append(content);+ } else if (!["text", "user"].includes(item.kind)) {+ content = element("details", undefined, "code-tool");+ content.append(element("summary", item.title || "Tool"));+ node.append(content);+ }+ content.append(+ element(+ "div",+ "",+ `code-prose ${item.kind === "user" ? "session-message-plain" : "session-markdown"}`,+ ),+ element("pre", "", "code-item-detail"),+ );+ node.dataset.sequence = item.sequence;+ const next = [...parent.children].find(+ (child) => Number(child.dataset.sequence) > item.sequence,+ );+ parent.insertBefore(node, next || null);+ }+ const content = node.querySelector(".code-prose"),+ value = item.html ?? item.text;+ if (node.codeText !== value) {+ if (item.html != null) content.innerHTML = item.html;+ else content.textContent = item.text;+ node.codeText = value;+ }+ const detail = node.querySelector(".code-item-detail");+ detail.textContent = item.detail;+ detail.hidden = !item.detail;+ }++ function renderPrompt(parent, prompt) {+ let node = parent.querySelector(`[data-id="${CSS.escape(prompt.id)}"]`);+ if (!node) {+ node = element("form", undefined, "code-prompt");+ node.dataset.id = prompt.id;+ node.append(+ element("h3", prompt.form.title),+ element("pre", prompt.form.detail || ""),+ );+ buildPrompt(node, prompt);+ node.append(element("p", "", "code-prompt-state"));+ parent.append(node);+ }+ node.querySelector(".code-prompt-state").textContent =+ prompt.error ||+ (!records.get(selected)?.activePrompts.get(prompt.id)?.active &&+ ["pending", "answering"].includes(prompt.status)+ ? "No longer active"+ : "") ||+ {+ answering: "Answer sent…",+ resolved: "Resolved",+ expired: "No longer active",+ }[prompt.status] ||+ "";+ }+ function buildPrompt(form, prompt) {+ const sessionId = selected,+ actions = element("div", undefined, "code-actions");+ let responseId = null,+ submitting = false;+ const answer = async (value) => {+ if (+ submitting ||+ !ready(records.get(sessionId)) ||+ !records.get(sessionId).activePrompts.get(prompt.id)?.active+ )+ return;+ responseId ||= crypto.randomUUID();+ submitting = true;+ form.dataset.claiming = "true";+ renderControls();+ try {+ await api(+ `${base}/sessions/${sessionId}/prompts/${prompt.id}/responses`,+ {+ method: "POST",+ body: JSON.stringify({ response_id: responseId, answer: value }),+ },+ );+ } catch (error) {+ form.querySelector(".code-prompt-state").textContent = error.message;+ } finally {+ submitting = false;+ form.dataset.claiming = "false";+ renderControls();+ }+ };+ form.addEventListener("submit", (event) => event.preventDefault());+ const choice = (text, value) =>+ actions.append(+ button(text, () => {+ void answer(value);+ }),+ );+ if (prompt.kind === "approval") {+ for (const item of prompt.form.choices)+ choice(item.label, { choice: item.id });+ } else if (prompt.kind === "permissions") {+ const checks = prompt.form.choices.map((item) => {+ const input = element("input");+ input.type = "checkbox";+ input.value = item.id;+ const label = element("label", undefined, "code-choice");+ label.append(input, document.createTextNode(item.label));+ form.append(label);+ return input;+ });+ const scope = element("select");+ scope.append(+ new Option("This turn", "turn"),+ new Option("This session", "session"),+ );+ label(form, "Allow for", scope);+ actions.append(+ button("Allow selected", () => {+ void answer({+ selected: checks+ .filter((input) => input.checked)+ .map((input) => input.value),+ scope: scope.value,+ });+ }),+ );+ choice("Decline", { selected: [], scope: "turn" });+ } else if (prompt.kind === "questions") {+ const readers = prompt.form.questions.map((question) => {+ const field = element("fieldset");+ field.append(element("legend", question.label));+ form.append(field);+ if (question.options?.length) {+ const name = `question-${crypto.randomUUID()}`,+ radios = [];+ for (const option of question.options) {+ const radio = element("input");+ radio.type = "radio";+ radio.name = name;+ radio.value = option.label;+ radio.required = true;+ const optionLabel = element("label", undefined, "code-choice");+ optionLabel.append(+ radio,+ document.createTextNode(+ option.label ++ (option.description ? ` — ${option.description}` : ""),+ ),+ );+ field.append(optionLabel);+ radios.push(radio);+ }+ let other;+ if (question.allow_other) {+ const radio = element("input");+ radio.type = "radio";+ radio.name = name;+ radio.value = "__other__";+ radios.push(radio);+ const otherLabel = element("label", undefined, "code-choice");+ otherLabel.append(radio, document.createTextNode("Other"));+ field.append(otherLabel);+ other = element("input");+ other.type = question.secret ? "password" : "text";+ other.autocomplete = "off";+ label(field, "Your answer", other);+ other.addEventListener("input", () => {+ radio.checked = true;+ });+ }+ return () => [+ question.id,+ [+ radios.find((radio) => radio.checked)?.value === "__other__"+ ? other.value+ : radios.find((radio) => radio.checked)?.value || "",+ ],+ ];+ }+ const input = element("input");+ input.type = question.secret ? "password" : "text";+ input.required = true;+ input.autocomplete = "off";+ label(field, question.header || "Your answer", input);+ return () => [question.id, [input.value]];+ });+ actions.append(+ button(+ "Submit answers",+ () => {+ if (form.reportValidity())+ void answer({+ answers: Object.fromEntries(readers.map((read) => read())),+ });+ },+ "primary-button",+ ),+ );+ } else {+ const readers = [];+ if (prompt.kind === "url") {+ try {+ const url = new URL(prompt.form.url);+ if (["https:", "http:"].includes(url.protocol)) {+ const link = element("a", "Open tool request");+ link.href = url.href;+ link.target = "_blank";+ link.rel = "noopener noreferrer";+ form.append(link);+ } else throw new Error();+ } catch {+ form.append(element("p", "This tool supplied an unsupported link."));+ }+ } else if (prompt.form.unsupported)+ form.append(+ element(+ "p",+ "This tool's form cannot be displayed. Decline or cancel this request.",+ ),+ );+ else+ for (const field of prompt.form.fields || []) {+ const input = element(field.options?.length ? "select" : "input");+ if (field.options?.length) {+ input.multiple = field.type === "array";+ if (!input.multiple) input.append(new Option("Choose…", ""));+ field.options.forEach((option, index) =>+ input.append(new Option(option.label, String(index))),+ );+ } else+ input.type =+ field.type === "boolean"+ ? "checkbox"+ : ["integer", "number"].includes(field.type)+ ? "number"+ : "text";+ if (input.type === "number")+ input.step = field.type === "integer" ? "1" : "any";+ for (const [source, target] of [+ ["minimum", "min"],+ ["maximum", "max"],+ ["minLength", "minLength"],+ ["maxLength", "maxLength"],+ ])+ if (field[source] != null) input[target] = field[source];+ input.required = field.required && field.type !== "boolean";+ input.autocomplete = "off";+ if (field.default != null && !field.options?.length) {+ if (input.type === "checkbox") input.checked = field.default;+ else input.value = field.default;+ }+ label(form, field.label, input, field.description);+ readers.push(() => {+ if (input.type === "checkbox") return [field.id, input.checked];+ if (!input.value && !field.required) return null;+ if (field.options?.length)+ return [+ field.id,+ input.multiple+ ? [...input.selectedOptions].map(+ (option) => field.options[Number(option.value)].value,+ )+ : field.options[Number(input.value)].value,+ ];+ return [+ field.id,+ input.type === "number" ? Number(input.value) : input.value,+ ];+ });+ }+ if (!prompt.form.unsupported)+ actions.append(+ button(+ "Submit",+ () => {+ if (form.reportValidity())+ void answer({+ action: "accept",+ values: Object.fromEntries(+ readers.map((read) => read()).filter(Boolean),+ ),+ });+ },+ "primary-button",+ ),+ );+ choice("Decline", { action: "decline" });+ choice("Cancel request", { action: "cancel" });+ }+ form.append(actions);+ }+ window.CodeSessions = {+ initialize(client) {+ api = client;+ root = document.getElementById("codeRoot");+ if (desiredPath) activate(desiredPath);+ },+ activate,+ async refresh() {+ if (!api || !epoch) return;+ try {+ await bootstrap();+ render();+ } catch (error) {+ restart(error.message);+ }+ },+ };+ document.addEventListener("pointerdown", (event) => {+ for (const combobox of modelComboboxes)+ if (combobox.isOpen && !combobox.element.contains(event.target))+ combobox.close();+ });+})();diff --git a/src/free_claude_code/api/admin_static/index.html b/src/free_claude_code/api/admin_static/index.htmlindex ae93ce09..ced5e042 100644--- a/src/free_claude_code/api/admin_static/index.html+++ b/src/free_claude_code/api/admin_static/index.html@@ -7,6 +7,8 @@<link rel="icon" href="data:," /><link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/admin.css" /><link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/chat_sessions.css" />+ <link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/code_sessions.css" />+ <link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/session_layout.css" /></head><body><div class="app-shell">@@ -82,7 +84,10 @@</section><section id="view-chat" class="admin-view" data-view="chat" hidden>- <div id="chatRoot" class="chat-root" aria-live="off"></div>+ <div id="chatRoot" class="chat-root session-root" aria-live="off"></div>+ </section>+ <section id="view-code" class="admin-view" data-view="code" hidden>+ <div id="codeRoot" class="code-root session-root" aria-live="off"></div></section></div></main>@@ -99,7 +104,9 @@</footer></div><script src="/admin/assets/__FCC_VERSION__/model_combobox.js"></script>+ <script src="/admin/assets/__FCC_VERSION__/session_ui.js"></script><script src="/admin/assets/__FCC_VERSION__/chat_sessions.js"></script>+ <script src="/admin/assets/__FCC_VERSION__/code_sessions.js"></script><script src="/admin/assets/__FCC_VERSION__/admin.js"></script></body></html>diff --git a/src/free_claude_code/api/admin_static/session_layout.css b/src/free_claude_code/api/admin_static/session_layout.cssnew file mode 100644index 00000000..2e196390--- /dev/null+++ b/src/free_claude_code/api/admin_static/session_layout.css@@ -0,0 +1,532 @@+.main.session-main {+ height: 100dvh;+ padding: 0;+ overflow: hidden;+}+.session-main .admin-views,+.session-main .admin-view,+.session-root {+ height: 100%;+ min-height: 0;+}+.session-root {+ padding: 36px clamp(16px, 3vw, 42px) 16px;+}+.session-library {+ height: 100%;+ overflow: auto;+}+.session-markdown table {+ display: block;+ overflow-x: auto;+}+@media (max-width: 900px) {+ .app-shell.session-active {+ height: 100dvh;+ min-height: 0;+ overflow: hidden;+ }+ .app-shell.session-active .sidebar {+ flex: 0 0 auto;+ }+ .main.session-main {+ flex: 1 1 0;+ height: auto;+ min-height: 0;+ }+ .session-root {+ padding: 24px 20px 12px;+ }+}+@media (max-width: 700px) {+ .session-root {+ padding: 16px 12px 8px;+ }+}+@media (max-width: 600px) {+ .app-shell.session-active .sidebar {+ padding: 10px 12px;+ gap: 8px;+ }+ .app-shell.session-active .brand {+ flex-direction: row;+ justify-content: flex-start;+ text-align: left;+ }+ .app-shell.session-active .brand-mark {+ width: 34px;+ height: 34px;+ }+ .app-shell.session-active .section-nav {+ grid-template-columns: repeat(5, minmax(0, 1fr));+ gap: 4px;+ }+ .app-shell.session-active .nav-link {+ justify-content: center;+ min-height: 34px;+ padding: 6px 4px;+ text-align: center;+ font-size: 11px;+ }+}++.session-shell {+ height: 100%;+ min-height: 0;+}++.session-library-header,+.session-header-row,+.session-controls,+.session-composer-actions,+.session-message-label {+ display: flex;+ align-items: center;+}++.session-library-header,+.session-header-row,+.session-composer-actions,+.session-message-label {+ justify-content: space-between;+}++.session-library-header {+ gap: 24px;+ margin: 0 auto 24px;+ max-width: 920px;+}++.session-library-header h2 {+ margin: 0;+ font-size: 30px;+}++.session-library-header p,+.session-card p {+ color: var(--muted);+}++.session-library-header p {+ margin: 7px 0 0;+}++.session-search,+.session-list,+.session-load-more,+.session-notice {+ width: 100%;+ max-width: 920px;+ margin-left: auto;+ margin-right: auto;+}++.session-search,+.session-load-more {+ display: block;+}++.session-search {+ min-height: 44px;+ margin-bottom: 16px;+ border: 1px solid var(--line-strong);+ border-radius: var(--radius-md);+ background: var(--input);+ padding: 10px 14px;+}++.session-list {+ display: grid;+ gap: 10px;+}++.session-card {+ display: grid;+ width: 100%;+ gap: 7px;+ border: 1px solid var(--line);+ border-radius: var(--radius-md);+ background: var(--panel);+ padding: 17px 19px;+ text-align: left;+ cursor: pointer;+}++.session-card:hover {+ border-color: var(--accent-border);+ background: var(--card-hover);+}++.session-card p {+ overflow: hidden;+ margin: 0;+ text-overflow: ellipsis;+ white-space: nowrap;+}++.session-card span,+.session-muted {+ color: var(--muted);+ font-size: 12px;+}++.session-card .session-status {+ color: var(--accent);+ font-weight: 700;+}++.session-load-more {+ margin-top: 18px;+}++.session-shell {+ display: grid;+ grid-template-areas:+ "header"+ "notice"+ "transcript"+ "composer";+ grid-template-rows: auto auto minmax(0, 1fr) auto;+ position: relative;+}++.session-header {+ grid-area: header;+ padding-bottom: 16px;+ border-bottom: 1px solid var(--line);+}++.session-header-row {+ gap: 12px;+}++.session-title {+ flex: 1;+ min-width: 0;+ border: 1px solid transparent;+ border-radius: var(--radius-sm);+ background: transparent;+ padding: 7px 10px;+ color: var(--text-strong);+ font-size: 19px;+ font-weight: 700;+}++.session-title:hover,+.session-title:focus {+ border-color: var(--line-strong);+ background: var(--input);+}++.session-back-button {+ border: 0;+ background: transparent;+ color: var(--muted);+ cursor: pointer;+}++.session-back-button:hover {+ color: var(--text);+}++.session-controls {+ flex-wrap: wrap;+ gap: 10px;+ margin-top: 14px;+}++.session-control {+ display: grid;+ gap: 5px;+ color: var(--muted);+ font-size: 11px;+ font-weight: 700;+ letter-spacing: 0.04em;+ text-transform: uppercase;+}++.session-control select,+.session-model-input {+ min-height: 38px;+ border: 1px solid var(--line-strong);+ border-radius: var(--radius-sm);+ background: var(--input);+ padding: 7px 10px;+ color: var(--text);+ text-transform: none;+}++.session-model-control {+ flex: 1 1 360px;+ max-width: 520px;+}++.session-model-control .model-combobox input[type="text"] {+ width: 100%;+ padding-right: 44px;+}++.session-model-control .model-combobox {+ text-transform: none;+}++.session-model-control .model-combobox-toggle {+ height: 38px;+}++.session-controls > button {+ align-self: end;+}++.session-notice {+ grid-area: notice;+ margin-top: 12px;+ margin-bottom: 10px;+ border: 1px solid var(--line);+ border-radius: var(--radius-sm);+ padding: 9px 12px;+ color: var(--muted);+ font-size: 13px;+}++.session-notice.error {+ border-color: var(--error-border);+ background: var(--error-bg);+ color: var(--error);+}++.session-transcript {+ grid-area: transcript;+ min-height: 0;+ overflow-y: auto;+ overscroll-behavior: contain;+ padding: 24px 0 30px;+ scroll-behavior: auto;+}++.session-message {+ max-width: 1120px;+ margin: 0 0 22px;+ border-radius: var(--radius-lg);+}++.user-message {+ margin-left: auto;+ max-width: min(680px, 88%);+ background: var(--panel-strong);+ padding: 14px 17px;+}++.assistant-message {+ padding: 2px 4px;+}++.session-message-label {+ gap: 12px;+ margin-bottom: 8px;+ color: var(--muted);+ font-size: 12px;+ font-weight: 700;+}++.session-message-plain,+.session-markdown {+ overflow-wrap: anywhere;+ line-height: 1.65;+ white-space: pre-wrap;+}++.session-markdown {+ white-space: normal;+}++.session-markdown > :first-child {+ margin-top: 0;+}++.session-markdown > :last-child {+ margin-bottom: 0;+}++.session-markdown pre {+ overflow-x: auto;+ border: 1px solid var(--line);+ border-radius: var(--radius-sm);+ background: var(--input);+ padding: 13px;+}++.session-markdown code {+ border-radius: 4px;+ background: var(--input);+ padding: 0.12em 0.3em;+}++.session-markdown pre code {+ padding: 0;+}++.session-markdown a {+ color: var(--info);+}++.session-thinking {+ margin: 12px 0;+ border-left: 2px solid var(--line-strong);+ padding: 4px 0 4px 14px;+ color: var(--muted);+}++.session-thinking summary {+ cursor: pointer;+ font-size: 13px;+ font-weight: 700;+}++.session-generation-status {+ margin-top: 12px;+ border: 1px solid var(--warn-border);+ border-radius: var(--radius-sm);+ background: var(--warn-bg);+ padding: 9px 11px;+ color: var(--warn);+ font-size: 13px;+}++.session-generation-status.failed {+ border-color: var(--error-border);+ background: var(--error-bg);+ color: var(--error);+}++.session-message-actions {+ display: flex;+ gap: 8px;+ margin-top: 12px;+}++.session-composer {+ grid-area: composer;+ margin: 8px 0 0;+ border: 1px solid var(--line-strong);+ border-radius: var(--radius-lg);+ background: var(--input);+ padding: 10px 12px 9px;+}++.session-composer:focus-within {+ border-color: var(--accent);+ background: var(--input-focus);+ box-shadow: 0 0 0 3px rgba(16, 185, 129, 0.15);+}++.session-composer textarea {+ display: block;+ width: 100%;+ min-height: calc(3em + 8px);+ max-height: calc(9em + 8px);+ resize: none;+ overflow-y: hidden;+ border: 0;+ border-radius: 0;+ background: transparent;+ padding: 4px 2px;+ line-height: 1.5;+ outline: none;+}++.session-composer-actions {+ gap: 12px;+ margin-top: 4px;+}++.session-composer-status {+ color: var(--muted);+ font-size: 12px;+}++.session-older {+ display: block;+ margin: 0 auto 24px;+}++.session-empty {+ display: grid;+ place-items: center;+ gap: 8px;+ min-height: 220px;+ color: var(--muted);+ text-align: center;+}++.session-empty h3,+.session-empty p {+ margin: 0;+}++.session-transcript-empty {+ min-height: 100%;+}++.danger-button {+ min-height: 38px;+ border: 1px solid var(--error-border);+ border-radius: var(--radius-sm);+ background: var(--error-bg);+ padding: 8px 13px;+ color: var(--error);+ cursor: pointer;+ font-weight: 700;+}++@media (max-width: 900px) {+ .session-controls {+ display: grid;+ grid-template-columns: 1fr 1fr;+ }++ .session-model-control {+ grid-column: 1 / -1;+ }++ .session-model-control {+ max-width: none;+ }+}++@media (max-width: 700px) {+ .session-shell {+ grid-template-rows: auto auto minmax(0, 1fr) auto;+ }++ .session-library-header {+ align-items: flex-start;+ }++ .session-header-row {+ flex-wrap: wrap;+ }++ .session-title {+ order: 3;+ flex-basis: 100%;+ }++ .session-controls {+ grid-template-columns: 1fr;+ }++ .session-model-control {+ grid-column: auto;+ }++ .session-transcript {+ padding-left: 0;+ padding-right: 0;+ }++ .session-composer {+ margin-left: 0;+ margin-right: 0;+ }+}diff --git a/src/free_claude_code/api/admin_static/session_ui.js b/src/free_claude_code/api/admin_static/session_ui.jsnew file mode 100644index 00000000..3f6effdd--- /dev/null+++ b/src/free_claude_code/api/admin_static/session_ui.js@@ -0,0 +1,233 @@+(() => {+ "use strict";+ function node(tag, className = "", text = "") {+ const element = document.createElement(tag);+ if (className) element.className = className;+ element.textContent = text;+ return element;+ }+ function button(label, className, action) {+ const element = node("button", className, label);+ element.type = "button";+ element.addEventListener("click", action);+ return element;+ }+ function libraryHeader(title, description, create) {+ const header = node("header", "session-library-header"),+ copy = node("div");+ copy.append(node("h2", "", title), node("p", "", description));+ header.append(copy, create);+ return header;+ }+ function search(label, value, onChange) {+ const input = node("input", "session-search");+ input.type = "search";+ input.placeholder = label;+ input.value = value;+ input.setAttribute("aria-label", label);+ let timer;+ input.addEventListener("input", () => {+ clearTimeout(timer);+ timer = setTimeout(() => {+ if (input.isConnected) onChange(input.value);+ }, 200);+ });+ return input;+ }+ function card(title, preview, meta, action) {+ const element = button("", "session-card", action);+ element.append(+ node("strong", "", title),+ node("p", "", preview),+ node("span", "", meta),+ );+ return element;+ }+ function shell(header, notice, transcript, composer) {+ const element = node("div", "session-shell");+ element.append(header, notice, transcript, composer);+ return element;+ }+ function header(+ backLabel,+ back,+ titleValue,+ titleLabel,+ onTitle,+ actions,+ controls,+ ) {+ const element = node("header", "session-header"),+ row = node("div", "session-header-row");+ const title = node("input", "session-title");+ title.value = titleValue;+ title.maxLength = 200;+ title.setAttribute("aria-label", titleLabel);+ title.addEventListener("blur", () => {+ if (title.isConnected) onTitle(title);+ });+ title.addEventListener("keydown", (event) => {+ if (event.key === "Enter" && !event.isComposing) title.blur();+ });+ row.append(+ button(backLabel, "session-back-button", back),+ title,+ ...actions,+ );+ element.append(row, controls);+ return element;+ }+ function modelControl(id, value, values, registry, onSelect) {+ const group = node("div", "session-control session-model-control"),+ label = node("label", "", "Model");+ label.htmlFor = id;+ const input = node("input", "session-model-input");+ input.id = id;+ input.type = "text";+ input.autocomplete = "off";+ input.value = value;+ input.setAttribute("aria-label", "Selected model");+ let committed = value;+ const combobox = new window.FccModelCombobox(input, {+ listboxId: `${id}-options`,+ label: "model",+ values,+ registry,+ emptyMessage: () =>+ values().length ? "No matching models." : "No models available.",+ onSelect: (model) => {+ committed = model;+ onSelect(model);+ },+ onClose: () => {+ input.value = committed;+ },+ });+ group.append(label, combobox.element);+ return {+ group,+ input,+ combobox,+ update(model, disabled) {+ committed = model;+ if (!combobox.isOpen) input.value = model;+ input.disabled = disabled;+ combobox.toggle.disabled = disabled;+ if (disabled) combobox.close();+ },+ };+ }+ function reasoningControl(id, options, value, onChange) {+ const group = node("label", "session-control"),+ select = node("select");+ select.id = id;+ const update = (choices, selected) => {+ const signature = JSON.stringify(choices);+ if (select.dataset.options !== signature) {+ select.replaceChildren(+ ...choices.map(([value, label]) => new Option(label, value)),+ );+ select.dataset.options = signature;+ }+ select.value = selected;+ };+ update(options, value);+ select.addEventListener("change", () => onChange(select.value));+ group.append(node("span", "", "Thinking"), select);+ return { group, select, update };+ }+ function composer(id, draft, placeholder, onInput, onSend, onStop) {+ const element = node("div", "session-composer"),+ textarea = node("textarea");+ textarea.id = `${id}Composer`;+ textarea.rows = 2;+ textarea.value = draft;+ textarea.placeholder = placeholder;+ textarea.setAttribute("aria-label", "Message");+ const actions = node("div", "session-composer-actions"),+ status = node("span", "session-composer-status");+ status.id = `${id}ComposerStatus`;+ status.setAttribute("aria-live", "polite");+ const send = button("Send", "primary-button", onSend),+ stop = button("Stop", "danger-button", onStop);+ send.id = `${id}Send`;+ stop.id = `${id}Stop`;+ stop.hidden = true;+ textarea.addEventListener("input", () => {+ resizeComposer(textarea);+ onInput(textarea.value);+ });+ textarea.addEventListener("keydown", (event) => {+ if (event.key === "Enter" && !event.shiftKey && !event.isComposing) {+ event.preventDefault();+ if (!send.disabled && !send.hidden) onSend();+ }+ });+ actions.append(status, send, stop);+ element.append(textarea, actions);+ return element;+ }+ function message(role, label) {+ const element = node("article", `session-message ${role}-message`);+ element.append(node("div", "session-message-label", label));+ return element;+ }+ function thinking() {+ const element = node("details", "session-thinking");+ element.append(node("summary", "", "Thinking"));+ return element;+ }+ function resizeComposer(textarea) {+ textarea.style.height = "auto";+ textarea.style.height = `${textarea.scrollHeight}px`;+ textarea.style.overflowY =+ textarea.scrollHeight > textarea.clientHeight ? "auto" : "hidden";+ }+ function nearBottom(scroller) {+ return (+ scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight < 80+ );+ }+ function captureSelection(input) {+ if (!input || document.activeElement !== input) return null;+ return {+ start: input.selectionStart,+ end: input.selectionEnd,+ direction: input.selectionDirection,+ };+ }+ function restoreSelection(input, selection) {+ if (!input || input.disabled || !selection) return;+ input.focus({ preventScroll: true });+ input.setSelectionRange(+ Math.min(selection.start, input.value.length),+ Math.min(selection.end, input.value.length),+ selection.direction,+ );+ }+ function focusIsUnclaimed() {+ const active = document.activeElement;+ return (+ !active || active === document.body || active === document.documentElement+ );+ }+ window.SessionUI = {+ node,+ button,+ libraryHeader,+ search,+ card,+ shell,+ header,+ modelControl,+ reasoningControl,+ composer,+ message,+ thinking,+ resizeComposer,+ nearBottom,+ captureSelection,+ restoreSelection,+ focusIsUnclaimed,+ };+})();diff --git a/src/free_claude_code/api/app.py b/src/free_claude_code/api/app.pyindex 45c16488..a61c9cb8 100644--- a/src/free_claude_code/api/app.py+++ b/src/free_claude_code/api/app.py@@ -13,6 +13,13 @@ from free_claude_code.application.chat import (ChatUnavailableError,ChatValidationError,)+from free_claude_code.application.code_sessions import (+ CodeConflictError,+ CodeError,+ CodeNotFoundError,+ CodeUnavailableError,+ CodeValidationError,+)from free_claude_code.application.errors import ApplicationErrorfrom free_claude_code.core.anthropic import anthropic_error_payloadfrom free_claude_code.core.diagnostics import (@@ -29,6 +36,7 @@ from free_claude_code.core.version import package_versionfrom .admin_cache import AdminNoStoreMiddleware, attach_admin_no_storefrom .admin_routes import router as admin_routerfrom .chat_routes import router as chat_router+from .code_sessions_routes import router as code_routerfrom .ports import ApiServicesfrom .request_errors import ordinary_application_error_responsefrom .request_ids import (@@ -51,6 +59,7 @@ def create_app(services: ApiServices) -> FastAPI:app.include_router(admin_router)app.include_router(chat_router)+ app.include_router(code_router)app.include_router(router)@app.exception_handler(ChatError)@@ -74,6 +83,25 @@ def create_app(services: ApiServices) -> FastAPI:attach_admin_no_store(response, path=request.url.path)return response+ @app.exception_handler(CodeError)+ async def code_error_handler(request: Request, exc: CodeError):+ if isinstance(exc, CodeNotFoundError):+ status_code = 404+ elif isinstance(exc, CodeConflictError):+ status_code = 409+ elif isinstance(exc, CodeValidationError):+ status_code = 400+ elif isinstance(exc, CodeUnavailableError):+ status_code = 503+ else:+ status_code = 500+ response = JSONResponse(+ status_code=status_code,+ content={"detail": str(exc), "code": type(exc).__name__},+ )+ attach_admin_no_store(response, path=request.url.path)+ return response+@app.exception_handler(RequestValidationError)async def validation_error_handler(request: Request, exc: RequestValidationError):"""Log request shape for 422 debugging without content values."""diff --git a/src/free_claude_code/api/chat_routes.py b/src/free_claude_code/api/chat_routes.pyindex 0e3e67a0..d6e3cde8 100644--- a/src/free_claude_code/api/chat_routes.py+++ b/src/free_claude_code/api/chat_routes.py@@ -13,11 +13,9 @@ from free_claude_code.application.chat import (ChatApplicationPort,ChatCompaction,ChatContextEstimate,- ChatEventOverflowError,ChatModelOption,ChatOperationAcknowledgement,ChatPreferences,- ChatPublishedEvent,ChatReasoning,ChatSession,ChatSessionSummary,@@ -25,12 +23,16 @@ from free_claude_code.application.chat import (ChatUnavailableError,ChatValidationError,)+from free_claude_code.application.session_events import (+ EventOverflowError,+ PublishedEvent,+)from free_claude_code.core.json_types import JsonObjectfrom .admin_routes import admin_page_responsefrom .admin_security import require_loopback_admin-from .chat_markdown import render_chat_markdownfrom .dependencies import get_services+from .markdown import render_markdownfrom .ports import ApiServicesrouter = APIRouter()@@ -116,7 +118,7 @@ async def chat_events(try:async for event in subscription:yield _sse_event(event)- except ChatEventOverflowError as exc:+ except EventOverflowError as exc:yield ServerSentEvent(event="feed.resync_required",id=str(exc.cursor),@@ -357,7 +359,7 @@ def _chat(services: ApiServices) -> ChatApplicationPort:return services.chat-def _sse_event(event: ChatPublishedEvent) -> ServerSentEvent:+def _sse_event(event: PublishedEvent) -> ServerSentEvent:return ServerSentEvent(event=event.event,id=str(event.id),@@ -512,7 +514,7 @@ def _turn_payload(turn: ChatTurn) -> JsonObject:"ordinal": segment.ordinal,"kind": segment.kind.value,"text": segment.text,- "html": render_chat_markdown(segment.text),+ "html": render_markdown(segment.text),}for segment in generation.segments],@@ -526,7 +528,7 @@ def _compaction_payload(compaction: ChatCompaction | None) -> JsonObject | None:return {"covered_through_sequence": compaction.covered_through_sequence,"summary": compaction.summary,- "summary_html": render_chat_markdown(compaction.summary),+ "summary_html": render_markdown(compaction.summary),"estimated_tokens": compaction.estimated_tokens,"requested_model": compaction.requested_model,"actual_model": compaction.actual_model,diff --git a/src/free_claude_code/api/code_sessions_routes.py b/src/free_claude_code/api/code_sessions_routes.pynew file mode 100644index 00000000..df5b97b2--- /dev/null+++ b/src/free_claude_code/api/code_sessions_routes.py@@ -0,0 +1,350 @@+"""Local Admin commands, snapshots and SSE for coding conversations."""++import base64+import json+from collections.abc import AsyncIterator, Mapping+from typing import Literal++from fastapi import APIRouter, Depends, Query, Request+from fastapi.sse import EventSourceResponse, ServerSentEvent+from pydantic import BaseModel, ConfigDict, Field++from free_claude_code.application.code_sessions import (+ CodeApplicationPort,+ CodeDetail,+ CodeItem,+ CodePrompt,+ CodeRun,+ CodeSession,+ CodeUnavailableError,+ CodeValidationError,+)+from free_claude_code.application.session_events import EventOverflowError+from free_claude_code.core.json_types import JsonObject, JsonValue++from .admin_routes import admin_page_response+from .admin_security import require_loopback_admin+from .dependencies import get_services+from .markdown import render_markdown+from .ports import ApiServices++router = APIRouter(dependencies=[Depends(require_loopback_admin)])+++class CommandPayload(BaseModel):+ model_config = ConfigDict(extra="forbid")+++class CreatePayload(CommandPayload):+ session_id: str+ cwd: str = Field(min_length=1, max_length=4096)+ harness: Literal["codex"] = "codex"+++class SettingsPayload(CommandPayload):+ expected_revision: int = Field(gt=0)+ title: str | None = Field(default=None, min_length=1, max_length=200)+ model: str | None = Field(default=None, min_length=1)+ reasoning_effort: str | None = None+++class SendPayload(CommandPayload):+ operation_id: str+ expected_revision: int = Field(gt=0)+ expected_epoch: str+ text: str = Field(min_length=1, max_length=1_000_000)+++class StopPayload(CommandPayload):+ operation_id: str+++class AnswerPayload(CommandPayload):+ response_id: str+ answer: JsonObject+++def _code(services: ApiServices) -> CodeApplicationPort:+ if services.code is None:+ raise CodeUnavailableError("Code sessions is unavailable in this FCC runtime.")+ return services.code++[email protected]("/admin/code", include_in_schema=False)[email protected]("/admin/code/{session_id}", include_in_schema=False)+def code_page(request: Request, session_id: str | None = None):+ return admin_page_response()++[email protected]("/admin/api/code/bootstrap")+def bootstrap(services: ApiServices = Depends(get_services)) -> JsonObject:+ code = _code(services)+ available, message = code.availability()+ catalog = code.catalog()+ return {+ "available": available,+ "message": message,+ "harnesses": [{"id": "codex", "name": "Codex"}],+ "epoch": code.epoch,+ "models": [model.model_dump(mode="json") for model in catalog.models],+ "default_model": catalog.default_model,+ }++[email protected]("/admin/api/code/events", response_class=EventSourceResponse)+async def events(+ services: ApiServices = Depends(get_services),+) -> AsyncIterator[ServerSentEvent]:+ subscription, ready = await _code(services).subscribe()+ try:+ summaries = ready.get("sessions")+ if isinstance(summaries, list):+ ready = {+ **ready,+ "sessions": [+ _event_payload(value)+ for value in summaries+ if isinstance(value, Mapping)+ ],+ }+ yield ServerSentEvent(+ event="feed.ready", id=str(subscription.cursor), retry=1000, data=ready+ )+ try:+ async for event in subscription:+ yield ServerSentEvent(+ event=event.event,+ id=str(event.id),+ data={**_event_payload(event.data), "cursor": event.id},+ )+ except EventOverflowError as exc:+ yield ServerSentEvent(+ event="feed.resync_required",+ id=str(exc.cursor),+ data={"cursor": exc.cursor},+ )+ finally:+ await subscription.aclose()++[email protected]("/admin/api/code/sessions")+async def list_sessions(+ cursor: str | None = None,+ query: str = Query(default="", max_length=4096),+ limit: int = Query(default=25, ge=1, le=25),+ services: ApiServices = Depends(get_services),+) -> JsonObject:+ code = _code(services)+ snapshot_cursor = code.cursor+ page = await code.list_sessions(_decode_cursor(cursor), limit, query)+ return {+ "sessions": [_session_payload(session) for session in page.sessions],+ "next_cursor": _encode_cursor(page.next_cursor),+ "epoch": code.epoch,+ "cursor": snapshot_cursor,+ }++[email protected]("/admin/api/code/sessions", status_code=201)+async def create(+ payload: CreatePayload, services: ApiServices = Depends(get_services)+) -> JsonObject:+ return _session_payload(+ await _code(services).create_session(payload.session_id, payload.cwd)+ )++[email protected]("/admin/api/code/sessions/{session_id}")+async def detail(+ session_id: str, services: ApiServices = Depends(get_services)+) -> JsonObject:+ return _detail_payload(await _code(services).get_detail(session_id))++[email protected]("/admin/api/code/sessions/{session_id}/items")+async def older_items(+ session_id: str,+ before: str,+ services: ApiServices = Depends(get_services),+) -> JsonObject:+ return _detail_payload(+ await _code(services).get_detail(session_id, before=_decode_item_cursor(before))+ )++[email protected]("/admin/api/code/sessions/{session_id}")+async def update_settings(+ session_id: str,+ payload: SettingsPayload,+ services: ApiServices = Depends(get_services),+) -> JsonObject:+ return _session_payload(+ await _code(services).update_settings(+ session_id,+ payload.expected_revision,+ payload.model_dump(exclude={"expected_revision"}, exclude_unset=True),+ )+ )++[email protected]("/admin/api/code/sessions/{session_id}", status_code=202)+async def delete(+ session_id: str,+ expected_revision: int = Query(gt=0),+ services: ApiServices = Depends(get_services),+) -> JsonObject:+ session = await _code(services).delete_session(session_id, expected_revision)+ return {+ "session_id": session_id,+ "deleted": session is None,+ "session": _session_payload(session) if session else None,+ }++[email protected]("/admin/api/code/sessions/{session_id}/turns", status_code=202)+async def send(+ session_id: str, payload: SendPayload, services: ApiServices = Depends(get_services)+) -> JsonObject:+ return _run_payload(+ await _code(services).send(+ session_id,+ payload.operation_id,+ payload.expected_revision,+ payload.text,+ expected_epoch=payload.expected_epoch,+ )+ )++[email protected]("/admin/api/code/sessions/{session_id}/stop", status_code=202)+async def stop(+ session_id: str, payload: StopPayload, services: ApiServices = Depends(get_services)+) -> JsonObject:+ return _run_payload(await _code(services).stop(session_id, payload.operation_id))+++ "/admin/api/code/sessions/{session_id}/prompts/{prompt_id}/responses",+ status_code=202,+)+async def answer(+ session_id: str,+ prompt_id: str,+ payload: AnswerPayload,+ services: ApiServices = Depends(get_services),+) -> JsonObject:+ return _prompt_payload(+ await _code(services).answer(+ session_id, prompt_id, payload.response_id, payload.answer+ )+ )+++def _session_payload(session: CodeSession) -> JsonObject:+ return session.model_dump(+ mode="json", exclude={"native_thread_id", "native_may_have_input", "auto_title"}+ )+++def _run_payload(run: CodeRun) -> JsonObject:+ return run.model_dump(mode="json", exclude={"native_turn_id", "submission_started"})+++def _item_payload(item: CodeItem) -> JsonObject:+ return {+ **item.model_dump(+ mode="json", exclude={"raw", "native_turn_id", "native_item_id"}+ ),+ "html": render_markdown(item.text)+ if item.kind in {"text", "reasoning"}+ else None,+ }+++def _prompt_payload(prompt: CodePrompt) -> JsonObject:+ return prompt.model_dump(+ mode="json",+ exclude={"raw", "generation", "request_id", "native_turn_id", "native_item_id"},+ )+++def _detail_payload(detail: CodeDetail) -> JsonObject:+ return {+ "session": _session_payload(detail.session),+ "run": _run_payload(detail.run) if detail.run else None,+ "runs": [_run_payload(run) for run in detail.runs],+ "active_prompt_ids": list(detail.active_prompt_ids),+ "items": [_item_payload(item) for item in detail.items],+ "prompts": [_prompt_payload(prompt) for prompt in detail.prompts],+ "epoch": detail.epoch,+ "version": detail.version,+ "cursor": detail.cursor,+ "next_before": _encode_cursor(detail.next_before),+ }+++def _event_payload(data: Mapping[str, JsonValue]) -> JsonObject:+ result = dict(data)+ if isinstance(data.get("session"), Mapping):+ result["session"] = _session_payload(+ CodeSession.model_validate(data["session"])+ )+ if isinstance(data.get("run"), Mapping):+ result["run"] = _run_payload(CodeRun.model_validate(data["run"]))+ if isinstance(data.get("item"), Mapping):+ result["item"] = _item_payload(CodeItem.model_validate(data["item"]))+ if isinstance(data.get("prompt"), Mapping):+ result["prompt"] = _prompt_payload(CodePrompt.model_validate(data["prompt"]))+ items = data.get("items")+ if isinstance(items, list):+ result["items"] = [+ _item_payload(CodeItem.model_validate(value)) for value in items+ ]+ prompts = data.get("prompts")+ runs = data.get("runs")+ if isinstance(runs, list):+ result["runs"] = [_run_payload(CodeRun.model_validate(value)) for value in runs]+ if isinstance(prompts, list):+ result["prompts"] = [+ _prompt_payload(CodePrompt.model_validate(value)) for value in prompts+ ]+ return result+++def _encode_cursor(cursor: tuple[int, str] | tuple[int, int] | None) -> str | None:+ return (+ base64.urlsafe_b64encode(json.dumps(cursor).encode()).decode()+ if cursor+ else None+ )+++def _decode_cursor(cursor: str | None) -> tuple[int, str] | None:+ if cursor is None:+ return None+ try:+ value = json.loads(base64.urlsafe_b64decode(cursor).decode())+ if (+ not isinstance(value, list)+ or len(value) != 2+ or type(value[0]) is not int+ or not isinstance(value[1], str)+ ):+ raise ValueError+ return value[0], value[1]+ except ValueError, UnicodeError:+ raise CodeValidationError("Invalid session page cursor.") from None+++def _decode_item_cursor(cursor: str) -> tuple[int, int]:+ try:+ value = json.loads(base64.urlsafe_b64decode(cursor).decode())+ if (+ not isinstance(value, list)+ or len(value) != 2+ or any(type(part) is not int or part < 1 for part in value)+ ):+ raise ValueError+ return value[0], value[1]+ except ValueError, UnicodeError:+ raise CodeValidationError("Invalid transcript page cursor.") from Nonediff --git a/src/free_claude_code/api/chat_markdown.py b/src/free_claude_code/api/markdown.pysimilarity index 90%rename from src/free_claude_code/api/chat_markdown.pyrename to src/free_claude_code/api/markdown.pyindex 8747187f..6b0d6d8b 100644--- a/src/free_claude_code/api/chat_markdown.py+++ b/src/free_claude_code/api/markdown.py@@ -1,4 +1,4 @@-"""Safe Markdown rendering for locally stored model-authored Chat text."""+"""Safe Markdown rendering for locally stored model-authored prose."""from collections.abc import Sequencefrom html import escape@@ -20,7 +20,7 @@ def _safe_http_url(value: object) -> str | None:return value-class _ChatRenderer(RendererHTML):+class _ProseRenderer(RendererHTML):def link_open(self,tokens: Sequence[Token],@@ -61,11 +61,11 @@ class _ChatRenderer(RendererHTML):_MARKDOWN = MarkdownIt("commonmark",{"html": False, "linkify": False},- renderer_cls=_ChatRenderer,+ renderer_cls=_ProseRenderer,)-def render_chat_markdown(value: str) -> str:+def render_markdown(value: str) -> str:"""Render model text without raw HTML or active remote images."""return _MARKDOWN.render(value)diff --git a/src/free_claude_code/api/ports.py b/src/free_claude_code/api/ports.pyindex 7c45a37e..a0b89c4a 100644--- a/src/free_claude_code/api/ports.py+++ b/src/free_claude_code/api/ports.py@@ -5,6 +5,7 @@ from dataclasses import dataclassfrom typing import Protocolfrom free_claude_code.application.chat import ChatApplicationPort+from free_claude_code.application.code_sessions import CodeApplicationPortfrom free_claude_code.application.connected_accounts import (ConnectedAccountLoginMode,ConnectedAccountStatus,@@ -59,3 +60,4 @@ class ApiServices:admin: AdminRuntimePorttasks: TaskControllerchat: ChatApplicationPort | None = None+ code: CodeApplicationPort | None = Nonediff --git a/src/free_claude_code/application/chat/__init__.py b/src/free_claude_code/application/chat/__init__.pyindex 184ef44f..26f94c66 100644--- a/src/free_claude_code/application/chat/__init__.py+++ b/src/free_claude_code/application/chat/__init__.py@@ -7,7 +7,6 @@ from .models import (ChatConflictError,ChatContextEstimate,ChatError,- ChatEventOverflowError,ChatGeneration,ChatModelOption,ChatNotFoundError,@@ -15,7 +14,6 @@ from .models import (ChatOperationKind,ChatOperationPhase,ChatPreferences,- ChatPublishedEvent,ChatReasoning,ChatSegment,ChatSession,@@ -40,7 +38,6 @@ __all__ = ["ChatConflictError","ChatContextEstimate","ChatError",- "ChatEventOverflowError","ChatEventSubscriptionPort","ChatGeneration","ChatModelOption",@@ -49,7 +46,6 @@ __all__ = ["ChatOperationKind","ChatOperationPhase","ChatPreferences",- "ChatPublishedEvent","ChatReasoning","ChatSegment","ChatService",diff --git a/src/free_claude_code/application/chat/models.py b/src/free_claude_code/application/chat/models.pyindex b4ea5af9..83eb9acb 100644--- a/src/free_claude_code/application/chat/models.py+++ b/src/free_claude_code/application/chat/models.py@@ -3,7 +3,6 @@from dataclasses import dataclassfrom enum import StrEnum-from free_claude_code.core.json_types import JsonObjectfrom free_claude_code.core.model_capabilities import ModelInputModalityfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy@@ -207,13 +206,6 @@ class ChatSessionDetail:context_error: str | None-@dataclass(frozen=True, slots=True)-class ChatPublishedEvent:- event: str- id: int- data: JsonObject--class ChatError(Exception):"""Base class for application-owned Chat failures."""@@ -232,11 +224,3 @@ class ChatConflictError(ChatError):class ChatValidationError(ChatError):"""The requested Chat operation cannot be executed as supplied."""---class ChatEventOverflowError(ChatError):- """One slow Chat observer must reconnect from a fresh snapshot."""-- def __init__(self, cursor: int) -> None:- super().__init__("Chat event subscription overflowed.")- self.cursor = cursordiff --git a/src/free_claude_code/application/chat/ports.py b/src/free_claude_code/application/chat/ports.pyindex fe132aaa..65b728f0 100644--- a/src/free_claude_code/application/chat/ports.py+++ b/src/free_claude_code/application/chat/ports.py@@ -3,6 +3,8 @@from collections.abc import AsyncIteratorfrom typing import Protocol+from free_claude_code.application.session_events import PublishedEvent+from .models import (ChatActiveOperation,ChatCompaction,@@ -11,7 +13,6 @@ from .models import (ChatModelOption,ChatOperationAcknowledgement,ChatPreferences,- ChatPublishedEvent,ChatReasoning,ChatSegment,ChatSession,@@ -173,7 +174,7 @@ class ChatEventSubscriptionPort(Protocol):cursor: int- def __aiter__(self) -> AsyncIterator[ChatPublishedEvent]: ...+ def __aiter__(self) -> AsyncIterator[PublishedEvent]: ...async def aclose(self) -> None: ...diff --git a/src/free_claude_code/application/chat/service.py b/src/free_claude_code/application/chat/service.pyindex 4d2cf64f..ed9090db 100644--- a/src/free_claude_code/application/chat/service.py+++ b/src/free_claude_code/application/chat/service.py@@ -13,6 +13,7 @@ from loguru import loggerfrom free_claude_code.application.execution import ProviderExecutorfrom free_claude_code.application.ports import RequestRuntimeLease, RequestRuntimePortfrom free_claude_code.application.routing import ProviderModelTarget+from free_claude_code.application.session_events import EventPublisherfrom free_claude_code.config.model_refs import (RETIRED_PROVIDER_IDS,is_retired_model_ref,@@ -33,7 +34,6 @@ from .context import (PreparedChatRequest,compaction_target_tokens,)-from .events import ChatEventPublisherfrom .models import (DEFAULT_CHAT_SYSTEM_PROMPT,ChatActiveOperation,@@ -118,7 +118,7 @@ class ChatService:self._runtime = runtimeself._store = storeself._context = ChatContextBuilder(runtime)- self._events = ChatEventPublisher()+ self._events = EventPublisher()self._active: dict[str, _ActiveOperation] = {}self._deleting: set[str] = set()self._active_lock = asyncio.Lock()diff --git a/src/free_claude_code/application/code_sessions/__init__.py b/src/free_claude_code/application/code_sessions/__init__.pynew file mode 100644index 00000000..bb6a8523--- /dev/null+++ b/src/free_claude_code/application/code_sessions/__init__.py@@ -0,0 +1,33 @@+"""Persistent native coding conversations owned by FCC."""++from .models import (+ CodeConflictError,+ CodeDetail,+ CodeError,+ CodeItem,+ CodeNotFoundError,+ CodePage,+ CodePrompt,+ CodeRun,+ CodeSession,+ CodeUnavailableError,+ CodeValidationError,+)+from .ports import CodeApplicationPort+from .service import CodeService++__all__ = [+ "CodeApplicationPort",+ "CodeConflictError",+ "CodeDetail",+ "CodeError",+ "CodeItem",+ "CodeNotFoundError",+ "CodePage",+ "CodePrompt",+ "CodeRun",+ "CodeService",+ "CodeSession",+ "CodeUnavailableError",+ "CodeValidationError",+]diff --git a/src/free_claude_code/application/code_sessions/models.py b/src/free_claude_code/application/code_sessions/models.pynew file mode 100644index 00000000..8d880285--- /dev/null+++ b/src/free_claude_code/application/code_sessions/models.py@@ -0,0 +1,211 @@+"""FCC-owned coding conversation state and harness-neutral events."""++import time+from dataclasses import dataclass, field+from typing import Literal++from pydantic import BaseModel, ConfigDict, Field++from free_claude_code.core.json_types import JsonObject++type RunStatus = Literal[+ "preparing", "running", "stopping", "completed", "interrupted", "failed"+]+ACTIVE_RUN_STATUSES = frozenset({"preparing", "running", "stopping"})+++def now_ms() -> int:+ return time.time_ns() // 1_000_000+++class Record(BaseModel):+ model_config = ConfigDict(frozen=True, extra="forbid")+++class CodeSession(Record):+ id: str+ cwd: str+ model: str+ reasoning_effort: str | None = None+ harness: Literal["codex"] = "codex"+ title: str = "New code session"+ auto_title: bool = True+ native_thread_id: str | None = None+ native_may_have_input: bool = False+ revision: int = 1+ status: Literal["ready", "deleting", "delete_uncertain"] = "ready"+ error: str | None = None+ created_at: int = Field(default_factory=now_ms)+ updated_at: int = Field(default_factory=now_ms)+++class CodeRun(Record):+ id: str+ session_id: str+ text: str+ model: str+ reasoning_effort: str | None = None+ ordinal: int = 0+ status: RunStatus = "preparing"+ submission_started: bool = False+ native_turn_id: str | None = None+ stop_requested: bool = False+ error: str | None = None+ error_details: JsonObject = Field(default_factory=dict)+ created_at: int = Field(default_factory=now_ms)+ finished_at: int | None = None+++class CodeItem(Record):+ id: str+ session_id: str+ sequence: int+ run_id: str+ native_turn_id: str | None = None+ native_item_id: str | None = None+ kind: str+ title: str = ""+ text: str = ""+ detail: str = ""+ complete: bool = False+ raw: JsonObject = Field(default_factory=dict)+++class CodePrompt(Record):+ id: str+ session_id: str+ generation: str+ request_id: str | int+ native_turn_id: str | None = None+ native_item_id: str | None = None+ kind: str+ form: JsonObject+ raw: JsonObject+ status: Literal["pending", "answering", "resolved", "expired"] = "pending"+ response_id: str | None = None+ error: str | None = None+++@dataclass(frozen=True, slots=True)+class CodeDetail:+ session: CodeSession+ run: CodeRun | None+ items: tuple[CodeItem, ...]+ prompts: tuple[CodePrompt, ...]+ epoch: str+ version: int+ cursor: int+ next_before: tuple[int, int] | None = None+ runs: tuple[CodeRun, ...] = ()+ active_prompt_ids: tuple[str, ...] = ()+++@dataclass(frozen=True, slots=True)+class CodeItemPage:+ items: tuple[CodeItem, ...]+ runs: tuple[CodeRun, ...]+ next_before: tuple[int, int] | None = None+++class CodeModel(Record):+ id: str+ display_name: str+ reasoning_efforts: tuple[str, ...] = ()+ default_reasoning_effort: str | None = None+++@dataclass(frozen=True, slots=True)+class CodeCatalog:+ default_model: str+ models: tuple[CodeModel, ...]+++@dataclass(frozen=True, slots=True)+class CodePage:+ sessions: tuple[CodeSession, ...]+ next_cursor: tuple[int, str] | None = None+++@dataclass(frozen=True, slots=True)+class ItemUpdate:+ turn_id: str+ item_id: str+ kind: str+ text: str = ""+ title: str = ""+ detail: str = ""+ raw: JsonObject = field(default_factory=dict)+ complete: bool = False+ client_id: str | None = None+++@dataclass(frozen=True, slots=True)+class PromptRequest:+ request_id: str | int+ kind: str+ form: JsonObject+ raw: JsonObject+ turn_id: str | None = None+ item_id: str | None = None+++@dataclass(frozen=True, slots=True)+class HarnessEvent:+ generation: str+ thread_id: str | None+ kind: Literal[+ "turn_started",+ "turn_completed",+ "item",+ "prompt",+ "resolved",+ "error",+ "closed",+ ]+ turn_id: str | None = None+ item: ItemUpdate | None = None+ prompt: PromptRequest | None = None+ request_id: str | int | None = None+ status: RunStatus = "completed"+ message: str | None = None+ will_retry: bool = False+ error_details: JsonObject = field(default_factory=dict)+++@dataclass(frozen=True, slots=True)+class NativeTurn:+ id: str+ items: tuple[ItemUpdate, ...] = ()+ status: RunStatus = "completed"+ error: str | None = None+ error_details: JsonObject = field(default_factory=dict)+++@dataclass(frozen=True, slots=True)+class NativeThread:+ id: str+ turns: tuple[NativeTurn, ...] = ()+++class CodeError(Exception):+ """A user-facing failure of the coding session application."""+++class CodeConflictError(CodeError):+ pass+++class CodeNotFoundError(CodeError):+ pass+++class CodeValidationError(CodeError):+ pass+++class CodeUnavailableError(CodeError):+ pass+++class NativeHistoryMissing(CodeNotFoundError):+ """The registered conversation no longer exists in native storage."""diff --git a/src/free_claude_code/application/code_sessions/ports.py b/src/free_claude_code/application/code_sessions/ports.pynew file mode 100644index 00000000..11ac946b--- /dev/null+++ b/src/free_claude_code/application/code_sessions/ports.py@@ -0,0 +1,180 @@+"""Persistence and native execution required by Code sessions."""++from collections.abc import Awaitable, Callable, Sequence+from typing import Protocol++from free_claude_code.application.session_events import EventSubscription+from free_claude_code.core.json_types import JsonObject++from .models import (+ CodeCatalog,+ CodeDetail,+ CodeItem,+ CodeItemPage,+ CodePage,+ CodePrompt,+ CodeRun,+ CodeSession,+ HarnessEvent,+ NativeThread,+)++type EventSink = Callable[[HarnessEvent], Awaitable[None]]+++class HarnessConnection(Protocol):+ generation: str+ thread_id: str | None++ def supports(self, selection: HarnessSelection) -> bool: ...++ async def create_thread(self) -> NativeThread: ...++ async def resume_thread(self, thread_id: str) -> NativeThread: ...++ async def read_thread(self, thread_id: str) -> NativeThread: ...++ async def start_turn(+ self, text: str, selection: HarnessSelection, client_id: str+ ) -> str: ...++ async def interrupt(self, turn_id: str) -> None: ...++ def prepare_answer(+ self, request_id: str | int, answer: JsonObject+ ) -> JsonObject: ...++ async def respond(self, request_id: str | int, response: JsonObject) -> None: ...++ async def delete_thread(self, thread_id: str) -> None: ...++ async def close(self) -> None: ...+++class HarnessSelection(Protocol):+ @property+ def model(self) -> str: ...++ @property+ def reasoning_effort(self) -> str | None: ...++ @property+ def configuration_key(self) -> str: ...++ async def open(self, cwd: str, sink: EventSink) -> HarnessConnection: ...+++class HarnessFactory(Protocol):+ def availability(self) -> tuple[bool, str | None]: ...++ def catalog(self) -> CodeCatalog: ...++ def prepare(self, model: str, reasoning_effort: str | None) -> HarnessSelection: ...++ async def open_history(self, cwd: str, sink: EventSink) -> HarnessConnection: ...+++class CodeStore(Protocol):+ async def start(self) -> None: ...++ async def close(self) -> None: ...++ async def create(self, session: CodeSession) -> CodeSession: ...++ async def get_session(self, session_id: str) -> CodeSession: ...++ async def list_sessions(+ self, cursor: tuple[int, str] | None, limit: int, query: str = ""+ ) -> CodePage: ...++ async def pending_deletions(self) -> tuple[CodeSession, ...]: ...++ async def is_deleted(self, session_id: str) -> bool: ...++ async def get_run(self, session_id: str, run_id: str) -> CodeRun | None: ...++ async def runs(self, session_id: str) -> tuple[CodeRun, ...]: ...++ async def latest_run(self, session_id: str) -> CodeRun | None: ...++ async def items(+ self, session_id: str, before: tuple[int, int] | None, limit: int | None+ ) -> tuple[CodeItem, ...]: ...++ async def prompts(self, session_id: str) -> tuple[CodePrompt, ...]: ...++ async def item_page(+ self, session_id: str, before: tuple[int, int] | None, limit: int | None+ ) -> CodeItemPage: ...++ async def update_settings(+ self, session: CodeSession, expected_revision: int+ ) -> CodeSession: ...++ async def admit_run(+ self, session: CodeSession, run: CodeRun, item: CodeItem, expected_revision: int+ ) -> tuple[CodeSession, CodeRun]: ...++ async def claim_prompt(+ self, session_id: str, prompt_id: str, response_id: str, generation: str+ ) -> CodePrompt: ...++ async def save_progress(+ self,+ session: CodeSession,+ expected_revision: int,+ *,+ run: CodeRun | None = None,+ items: Sequence[CodeItem] = (),+ prompts: Sequence[CodePrompt] = (),+ ) -> None: ...++ async def delete(self, session_id: str) -> None: ...+++class CodeApplicationPort(Protocol):+ @property+ def epoch(self) -> str: ...++ @property+ def cursor(self) -> int: ...++ def availability(self) -> tuple[bool, str | None]: ...++ def catalog(self) -> CodeCatalog: ...++ async def create_session(self, session_id: str, cwd: str) -> CodeSession: ...++ async def list_sessions(+ self, cursor: tuple[int, str] | None = None, limit: int = 25, query: str = ""+ ) -> CodePage: ...++ async def get_detail(+ self, session_id: str, *, before: tuple[int, int] | None = None+ ) -> CodeDetail: ...++ async def subscribe(self) -> tuple[EventSubscription, JsonObject]: ...++ async def update_settings(+ self, session_id: str, revision: int, changes: JsonObject+ ) -> CodeSession: ...++ async def send(+ self,+ session_id: str,+ operation_id: str,+ revision: int,+ text: str,+ *,+ expected_epoch: str,+ ) -> CodeRun: ...++ async def stop(self, session_id: str, operation_id: str) -> CodeRun: ...++ async def answer(+ self, session_id: str, prompt_id: str, response_id: str, answer: JsonObject+ ) -> CodePrompt: ...++ async def delete_session(+ self, session_id: str, revision: int+ ) -> CodeSession | None: ...diff --git a/src/free_claude_code/application/code_sessions/service.py b/src/free_claude_code/application/code_sessions/service.pynew file mode 100644index 00000000..3aae0609--- /dev/null+++ b/src/free_claude_code/application/code_sessions/service.py@@ -0,0 +1,1298 @@+"""Server-owned coding sessions, independent of HTTP and browser lifetimes."""++import asyncio+import uuid+from collections.abc import Coroutine, Sequence+from dataclasses import dataclass, field+from pathlib import Path++from loguru import logger++from free_claude_code.application.session_events import (+ EventPublisher,+ EventSubscription,+)+from free_claude_code.core.json_types import JsonObject, JsonValue++from .models import (+ ACTIVE_RUN_STATUSES,+ CodeCatalog,+ CodeConflictError,+ CodeDetail,+ CodeItem,+ CodeNotFoundError,+ CodePage,+ CodePrompt,+ CodeRun,+ CodeSession,+ CodeUnavailableError,+ CodeValidationError,+ HarnessEvent,+ ItemUpdate,+ NativeHistoryMissing,+ NativeThread,+ RunStatus,+ now_ms,+)+from .ports import CodeStore, HarnessConnection, HarnessFactory, HarnessSelection+++@dataclass(slots=True)+class _Owner:+ session: CodeSession+ run: CodeRun | None+ items: dict[str, CodeItem]+ prompts: dict[str, CodePrompt]+ runs: dict[str, CodeRun]+ lock: asyncio.Lock = field(default_factory=asyncio.Lock)+ finished: asyncio.Event = field(default_factory=asyncio.Event)+ connection: HarnessConnection | None = None+ generation: str | None = None+ version: int = 0+ sequence: int = 0+ job: asyncio.Task[None] | None = None+ flush_task: asyncio.Task[None] | None = None+ interrupt_task: asyncio.Task[None] | None = None+ interrupt_for: str | None = None+ loaded_thread_id: str | None = None+ dirty: set[str] = field(default_factory=set)+ known_turns: set[str] = field(default_factory=set)+ dirty_characters: int = 0+ storage_failed: bool = False+ failure_task: asyncio.Task[None] | None = None+ deleted: bool = False++ @property+ def busy(self) -> bool:+ return self.run is not None and self.run.status in ACTIVE_RUN_STATUSES++ @property+ def pending(self) -> bool:+ return any(+ prompt.status in {"pending", "answering"}+ for prompt in self.prompts.values()+ )+++class CodeService:+ def __init__(self, store: CodeStore, harness: HarnessFactory) -> None:+ self._store = store+ self._harness = harness+ self._owners: dict[str, _Owner] = {}+ self._load_lock = asyncio.Lock()+ self._events = EventPublisher()+ self.epoch = str(uuid.uuid4())+ self._commands: set[asyncio.Task] = set()+ self._jobs: set[asyncio.Task] = set()+ self._accepting = False+ self._started = False+ self._message: str | None = "Code sessions is starting."+ self._close_task: asyncio.Task[None] | None = None++ async def start(self) -> None:+ if self._started:+ return+ try:+ await self._store.start()+ self._started = True+ pending = await self._store.pending_deletions()+ except Exception as exc:+ await self._store.close()+ self._started = False+ self._message = _error_message(exc)+ return+ except BaseException:+ await self._store.close()+ raise+ self._accepting = True+ self._message = None+ for session in pending:+ owner = await self._owner(session.id)+ owner.finished = asyncio.Event()+ owner.job = self._job(self._delete_native(owner, reconcile=True))++ def availability(self) -> tuple[bool, str | None]:+ if not self._accepting:+ return False, self._message+ return self._harness.availability()++ def catalog(self) -> CodeCatalog:+ return self._harness.catalog()++ def begin_shutdown(self) -> None:+ self._accepting = False+ self._message = "Code sessions is stopping."+ self._events.disconnect_subscribers()++ async def close(self) -> None:+ self.begin_shutdown()+ if self._close_task is None:+ self._close_task = asyncio.create_task(self._close(), name="fcc-code-close")+ await asyncio.shield(self._close_task)++ async def _close(self) -> None:+ if self._commands:+ await asyncio.gather(*tuple(self._commands), return_exceptions=True)+ owners = tuple(self._owners.values())+ for owner in owners:+ if owner.busy and owner.run is not None and not owner.storage_failed:+ try:+ await self._stop(owner.session.id, owner.run.id, shutting_down=True)+ except Exception:+ await self._close_connection(owner)+ self._storage_failure(owner)+ jobs = [owner.job for owner in owners if owner.job is not None]+ if jobs:+ 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:+ if owner.busy and not owner.storage_failed:+ try:+ await self._finish_locked(+ owner,+ "interrupted",+ "FCC stopped before this turn finished.",+ )+ except Exception:+ self._storage_failure(owner)+ if self._jobs:+ await asyncio.gather(*tuple(self._jobs), return_exceptions=True)+ self._events.close()+ await self._store.close()+ self._started = False+ self._message = "Code sessions is stopped."++ async def _command[T](self, work: Coroutine[object, object, T]) -> T:+ task = asyncio.create_task(work)+ self._commands.add(task)+ task.add_done_callback(self._command_done)+ return await asyncio.shield(task)++ def _command_done(self, task: asyncio.Task) -> None:+ self._commands.discard(task)+ if not task.cancelled():+ task.exception()++ def _job(self, work: Coroutine[object, object, None]) -> asyncio.Task[None]:+ task = asyncio.create_task(work)+ self._jobs.add(task)+ task.add_done_callback(self._job_done)+ return task++ def _job_done(self, task: asyncio.Task) -> None:+ self._jobs.discard(task)+ if not task.cancelled() and (error := task.exception()) is not None:+ logger.warning(+ "Code session task failed: exc_type={}", type(error).__name__+ )++ def _require_available(self) -> None:+ if not self._accepting:+ raise CodeUnavailableError(self._message or "Code sessions is unavailable.")++ async def _owner(self, session_id: str) -> _Owner:+ _validate_id(session_id)+ async with self._load_lock:+ 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)+ owner = _Owner(+ session,+ await self._store.latest_run(session_id),+ {item.id: item for item in items},+ {+ prompt.id: prompt+ for prompt in await self._store.prompts(session_id)+ },+ {run.id: run for run in runs},+ sequence=max((item.sequence for item in items), default=0),+ known_turns={+ item.native_turn_id for item in items if item.native_turn_id+ },+ )+ if owner.run and owner.run.native_turn_id:+ owner.known_turns.add(owner.run.native_turn_id)+ if not owner.busy:+ owner.finished.set()+ self._owners[session_id] = owner+ if owner.deleted:+ raise CodeNotFoundError("Code session was deleted.")+ return owner++ async def create_session(self, session_id: str, cwd: str) -> CodeSession:+ return await self._command(self._create(session_id, cwd))++ async def _create(self, session_id: str, cwd: str) -> CodeSession:+ self._require_available()+ _validate_id(session_id)+ try:+ folder = Path(cwd).expanduser().resolve(strict=True)+ if not folder.is_dir():+ raise ValueError+ except OSError, ValueError, RuntimeError:+ raise CodeValidationError(+ "Choose an existing folder on the FCC computer."+ ) from None+ session = await self._store.create(+ CodeSession(+ id=session_id, cwd=str(folder), model=self.catalog().default_model+ )+ )+ owner = await self._owner(session.id)+ async with owner.lock:+ self._publish(owner, "session.updated")+ return session++ async def list_sessions(+ self, cursor: tuple[int, str] | None = None, limit: int = 25, query: str = ""+ ) -> CodePage:+ return await self._store.list_sessions(cursor, max(1, min(limit, 25)), query)++ async def subscribe(self) -> tuple[EventSubscription, JsonObject]:+ self._require_available()+ subscription = self._events.subscribe()+ summaries = [+ self._summary(owner)+ for owner in tuple(self._owners.values())+ if not owner.deleted+ and (owner.busy or owner.pending or owner.session.status != "ready")+ ]+ return subscription, {+ "epoch": self.epoch,+ "cursor": subscription.cursor,+ "sessions": summaries,+ }++ @property+ def cursor(self) -> int:+ return self._events.cursor++ async def get_detail(+ self, session_id: str, *, before: tuple[int, int] | None = None+ ) -> 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.busy and owner.run:+ active_start = (owner.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)+ active = [+ item+ for item in owner.items.values()+ if owner.busy and owner.run and item.run_id == owner.run.id+ ]+ selected = sorted(+ {item.id: item for item in [*page.items, *active]}.values(),+ key=lambda item: (owner.runs[item.run_id].ordinal, item.sequence),+ )+ turns = {item.native_turn_id for item in selected if item.native_turn_id}+ if owner.run and owner.run.native_turn_id:+ turns.add(owner.run.native_turn_id)+ prompts = tuple(+ prompt+ for prompt in owner.prompts.values()+ if prompt.status in {"pending", "answering"}+ or prompt.native_turn_id in turns+ )+ return CodeDetail(+ owner.session,+ owner.run,+ tuple(selected),+ prompts,+ self.epoch,+ owner.version,+ self.cursor,+ page.next_before,+ tuple(+ {+ run.id: run+ for run in (*page.runs, *((owner.run,) if owner.run else ()))+ }.values()+ ),+ tuple(+ prompt.id+ for prompt in owner.prompts.values()+ if prompt.status in {"pending", "answering"}+ ),+ )++ async def update_settings(+ self, session_id: str, revision: int, changes: JsonObject+ ) -> CodeSession:+ return await self._command(self._update_settings(session_id, revision, changes))++ async def _update_settings(+ self, session_id: str, revision: int, changes: JsonObject+ ) -> CodeSession:+ if not changes or changes.keys() - {"title", "model", "reasoning_effort"}:+ raise CodeValidationError(+ "Choose a title, model or reasoning effort to update."+ )+ owner = await self._owner(session_id)+ async with owner.lock:+ self._editable(owner, revision)+ updates: dict[str, object] = dict(changes)+ if "title" in changes:+ title = changes["title"]+ if not isinstance(title, str) or not title.strip() or len(title) > 200:+ raise CodeValidationError(+ "Enter a title of at most 200 characters."+ )+ updates.update(title=title.strip(), auto_title=False)+ if changes.keys() & {"model", "reasoning_effort"}:+ if owner.busy or owner.pending:+ raise CodeConflictError(+ "Finish this turn and its prompts before changing settings."+ )+ model = changes.get("model", owner.session.model)+ entry = next(+ (entry for entry in self.catalog().models if entry.id == model),+ None,+ )+ if entry is None:+ raise CodeValidationError(+ "This model is unavailable. Choose another model."+ )+ effort = changes.get("reasoning_effort", owner.session.reasoning_effort)+ if (+ "reasoning_effort" not in changes+ and model != owner.session.model+ and effort not in entry.reasoning_efforts+ ):+ effort = None+ if effort is not None and effort not in entry.reasoning_efforts:+ raise CodeValidationError(+ "This reasoning effort is unavailable. Choose another effort or Model default."+ )+ updates.update(model=model, reasoning_effort=effort)+ session = await self._store.update_settings(+ _revision(owner.session, **updates), revision+ )+ owner.session = session+ self._publish(owner, "session.updated")+ return session++ async def send(+ self,+ session_id: str,+ operation_id: str,+ revision: int,+ text: str,+ *,+ expected_epoch: str,+ ) -> CodeRun:+ return await self._command(+ self._send(session_id, operation_id, revision, text, expected_epoch)+ )++ async def _send(+ self,+ session_id: str,+ operation_id: str,+ revision: int,+ text: str,+ expected_epoch: str,+ ) -> CodeRun:+ _validate_id(operation_id)+ if not text.strip() or len(text) > 1_000_000:+ raise CodeValidationError(+ "Enter a message of at most 1,000,000 characters."+ )+ owner = await self._owner(session_id)+ async with owner.lock:+ previous = await self._store.get_run(session_id, operation_id)+ if previous:+ if previous.session_id != session_id or previous.text != text:+ raise CodeConflictError(+ "This Send ID was already used for a different message."+ )+ return previous+ if expected_epoch != self.epoch:+ raise CodeConflictError(+ "FCC restarted. Your draft has been kept; send it when you are ready."+ )+ self._editable(owner, revision)+ if owner.busy or owner.pending:+ raise CodeConflictError(+ "This session is busy. Your draft has been kept."+ )+ selection = self._harness.prepare(+ owner.session.model, owner.session.reasoning_effort+ )+ run = CodeRun(+ id=operation_id,+ session_id=session_id,+ text=text,+ model=selection.model,+ reasoning_effort=selection.reasoning_effort,+ )+ title = (+ " ".join(text.split())[:80]+ if owner.session.auto_title+ else owner.session.title+ )+ session = _revision(+ owner.session, title=title, auto_title=False, error=None+ )+ item = CodeItem(+ id=operation_id,+ session_id=session_id,+ sequence=owner.sequence + 1,+ run_id=operation_id,+ kind="user",+ text=text,+ complete=True,+ )+ session, run = await self._store.admit_run(session, run, item, revision)+ owner.session, owner.run = session, run+ owner.runs[run.id] = run+ owner.items[item.id] = item+ owner.sequence = item.sequence+ owner.finished = asyncio.Event()+ self._publish(owner, "run.updated", items=[item.model_dump(mode="json")])+ owner.job = self._job(self._work(owner, run.id, selection))+ return run++ async def stop(self, session_id: str, operation_id: str) -> CodeRun:+ return await self._command(self._stop(session_id, operation_id))++ async def _stop(+ self, session_id: str, operation_id: str, *, shutting_down: bool = False+ ) -> CodeRun:+ _validate_id(operation_id)+ owner = await self._owner(session_id)+ async with owner.lock:+ run = await self._store.get_run(session_id, operation_id)+ if run is None or run.session_id != session_id:+ raise CodeNotFoundError("Code turn not found.")+ if owner.run is None or owner.run.id != operation_id or not owner.busy:+ return run+ if not shutting_down:+ self._require_available()+ if not owner.run.stop_requested:+ run = owner.run.model_copy(+ update={"stop_requested": True, "status": "stopping"}+ )+ await self._persist(owner, owner.session, run=run)+ owner.run = run+ self._publish(owner, "run.updated")+ self._schedule_interrupt(owner)+ return owner.run++ async def answer(+ self, session_id: str, prompt_id: str, response_id: str, answer: JsonObject+ ) -> CodePrompt:+ return await self._command(+ self._answer(session_id, prompt_id, response_id, answer)+ )++ async def _answer(+ self, session_id: str, prompt_id: str, response_id: str, answer: JsonObject+ ) -> CodePrompt:+ _validate_id(response_id)+ owner = await self._owner(session_id)+ async with owner.lock:+ self._require_available()+ prompt = owner.prompts.get(prompt_id)+ if prompt is None:+ raise CodeNotFoundError("This prompt no longer exists.")+ if prompt.response_id == response_id:+ return prompt+ connection = owner.connection+ if (+ prompt.status != "pending"+ or connection is None+ or prompt.generation != owner.generation+ ):+ raise CodeConflictError(+ "This prompt was already answered or is no longer active."+ )+ response = connection.prepare_answer(prompt.request_id, answer)+ claimed = await self._store.claim_prompt(+ session_id, prompt_id, response_id, connection.generation+ )+ owner.prompts[prompt_id] = claimed+ self._publish(+ owner, "prompt.updated", prompt=claimed.model_dump(mode="json")+ )+ self._job(self._deliver_answer(owner, claimed, response))+ return claimed++ async def delete_session(+ self, session_id: str, revision: int+ ) -> CodeSession | None:+ return await self._command(self._delete(session_id, revision))++ async def _delete(self, session_id: str, revision: int) -> CodeSession | None:+ self._require_available()+ if await self._store.is_deleted(session_id):+ return None+ owner = await self._owner(session_id)+ async with owner.lock:+ self._check_owner(owner)+ if owner.session.status != "ready":+ if owner.session.status == "delete_uncertain" and (+ owner.job is None or owner.job.done()+ ):+ if revision != owner.session.revision:+ raise CodeConflictError(+ "This session changed. Refresh its state and try again."+ )+ owner.finished = asyncio.Event()+ owner.job = self._job(self._delete_native(owner, reconcile=True))+ return owner.session+ self._editable(owner, revision)+ if owner.busy or owner.pending:+ raise CodeConflictError(+ "Stop the session and finish its prompts before deleting it."+ )+ session = _revision(owner.session, status="deleting", error=None)+ await self._persist(owner, session)+ owner.session = session+ owner.finished = asyncio.Event()+ self._publish(owner, "session.updated")+ owner.job = self._job(self._delete_native(owner))+ return session++ async def wait_idle(self, session_id: str) -> None:+ """Wait for the currently owned operation, including its durable settlement."""+ owner = self._owners.get(session_id)+ if owner is not None:+ await owner.finished.wait()++ async def _work(+ self, owner: _Owner, run_id: str, selection: HarnessSelection+ ) -> None:+ finished = owner.finished+ try:+ connection = owner.connection+ if connection is not None and not connection.supports(selection):+ await self._close_connection(owner)+ connection = None+ if connection is None:+ connection = await selection.open(+ owner.session.cwd, lambda event: self._event(owner, event)+ )+ owner.connection = connection+ owner.generation = connection.generation+ thread_id = owner.session.native_thread_id+ if thread_id is None:+ async with owner.lock:+ if owner.run and owner.run.stop_requested:+ await self._finish_locked(owner, "interrupted")+ return+ native = await connection.create_thread()+ elif owner.loaded_thread_id != thread_id:+ try:+ native = await connection.resume_thread(thread_id)+ except NativeHistoryMissing:+ if owner.session.native_may_have_input:+ raise+ native = await connection.create_thread()+ else:+ native = None+ async with owner.lock:+ if native is not None:+ session = owner.session.model_copy(+ update={"native_thread_id": native.id}+ )+ await self._persist(owner, session)+ owner.session = session+ owner.loaded_thread_id = native.id+ await self._recover_locked(owner, native)+ run = owner.run+ if run is None or run.id != run_id or not owner.busy:+ return+ if run.stop_requested or not self._accepting:+ await self._finish_locked(owner, "interrupted")+ return+ run = run.model_copy(update={"submission_started": True})+ session = owner.session.model_copy(+ update={"native_may_have_input": True}+ )+ await self._persist(owner, session, run=run)+ owner.session, owner.run = session, run+ turn_id = await connection.start_turn(run.text, selection, run.id)+ async with owner.lock:+ if owner.run is None or owner.run.id != run_id or not owner.busy:+ return+ if owner.run.native_turn_id not in {None, turn_id}:+ raise CodeUnavailableError(+ "Codex returned a different turn identity."+ )+ updated = owner.run.model_copy(+ update={+ "native_turn_id": turn_id,+ "status": "stopping" if owner.run.stop_requested else "running",+ }+ )+ await self._persist(owner, owner.session, run=updated)+ owner.run = updated+ owner.known_turns.add(turn_id)+ self._publish(owner, "run.updated")+ self._schedule_interrupt(owner)+ await finished.wait()+ except asyncio.CancelledError:+ await self._fail(+ owner,+ run_id,+ "Code session initialization was interrupted.",+ interrupted=True,+ )+ raise+ except Exception as exc:+ await self._fail(owner, run_id, _error_message(exc))+ finally:+ if not self._accepting or owner.storage_failed:+ await self._close_connection(owner)++ async def _recover_locked(self, owner: _Owner, native: NativeThread) -> None:+ mapped: dict[str, CodeRun] = {}+ for turn in native.turns:+ identities = {+ item.client_id+ for item in turn.items+ if item.kind == "user" and item.client_id+ }+ candidates = [+ run+ for run in owner.runs.values()+ if run.native_turn_id == turn.id or run.id in identities+ ]+ if len(candidates) > 1 or any(+ identity not in owner.runs for identity in identities+ ):+ raise CodeUnavailableError(+ "Codex history contains conflicting turn identities. Saved history was retained."+ )+ if candidates:+ run = candidates[0]+ if (+ not run.submission_started+ or run.native_turn_id not in {None, turn.id}+ or run.id in {value.id for value in mapped.values()}+ ):+ raise CodeUnavailableError(+ "Codex history could not be matched to its saved turns."+ )+ mapped[turn.id] = run+ unmatched = [turn for turn in native.turns if turn.id not in mapped]+ pending = [+ run+ for run in owner.runs.values()+ if run.submission_started+ and run.native_turn_id is None+ and run.id not in {value.id for value in mapped.values()}+ ]+ if unmatched:+ if len(unmatched) != 1 or len(pending) != 1:+ raise CodeUnavailableError(+ "Codex history could not be matched to its saved turns. No input was resent."+ )+ mapped[unmatched[0].id] = pending[0]+ for turn in native.turns:+ previous = mapped[turn.id]+ # Restart/connection loss has already settled interrupted work. Recover+ # source content and missing diagnostics without rewriting that outcome.+ run = previous.model_copy(+ update={+ "native_turn_id": turn.id,+ "error": previous.error or turn.error,+ "error_details": previous.error_details or turn.error_details,+ }+ )+ for item in turn.items:+ self._update_item(owner, item, recovered_run=run)+ items = tuple(owner.items[item_id] for item_id in owner.dirty)+ await self._persist(owner, owner.session, run=run, items=items)+ owner.dirty.clear()+ owner.dirty_characters = 0+ owner.known_turns.add(turn.id)+ if owner.run and owner.run.id == run.id:+ owner.run = run+ self._publish(+ owner,+ "run.updated",+ runs=[run.model_dump(mode="json")],+ items=[item.model_dump(mode="json") for item in items],+ )++ def _schedule_interrupt(self, owner: _Owner) -> None:+ run, connection = owner.run, owner.connection+ if (+ run is None+ or connection is None+ or not run.stop_requested+ or not run.native_turn_id+ or not owner.busy+ or owner.interrupt_for == run.id+ ):+ return+ owner.interrupt_for = run.id+ owner.interrupt_task = self._job(+ self._interrupt(owner, connection, run, owner.finished)+ )++ async def _interrupt(+ self,+ owner: _Owner,+ connection: HarnessConnection,+ run: CodeRun,+ finished: asyncio.Event,+ ) -> None:+ assert run.native_turn_id is not None+ try:+ await connection.interrupt(run.native_turn_id)+ async with asyncio.timeout(5):+ await finished.wait()+ return+ except Exception:+ pass+ async with owner.lock:+ if (+ owner.connection is not connection+ or owner.run is None+ or owner.run.id != run.id+ or not owner.busy+ ):+ return+ owner.connection = None+ owner.generation = None+ owner.loaded_thread_id = None+ await connection.close()+ async with owner.lock:+ if owner.run and owner.run.id == run.id and owner.busy:+ await self._finish_locked(+ owner,+ "interrupted",+ "Codex did not stop normally; its session process was closed.",+ )++ async def _deliver_answer(+ self, owner: _Owner, prompt: CodePrompt, response: JsonObject+ ) -> None:+ connection = owner.connection+ if connection is None:+ return+ try:+ async with owner.lock:+ current = owner.prompts.get(prompt.id)+ if (+ current is None+ or current.status != "answering"+ or owner.generation != prompt.generation+ ):+ return+ await connection.respond(prompt.request_id, response)+ async with owner.lock:+ current = owner.prompts.get(prompt.id)+ if (+ current is not None+ and current.status == "answering"+ and owner.generation == prompt.generation+ ):+ resolved = current.model_copy(update={"status": "resolved"})+ await self._persist(owner, owner.session, prompts=(resolved,))+ owner.prompts[prompt.id] = resolved+ self._publish(+ owner, "prompt.updated", prompt=resolved.model_dump(mode="json")+ )+ except CodeConflictError:+ async with owner.lock:+ current = owner.prompts.get(prompt.id)+ if current and current.status == "answering":+ expired = current.model_copy(update={"status": "expired"})+ await self._persist(owner, owner.session, prompts=(expired,))+ owner.prompts[prompt.id] = expired+ self._publish(+ owner, "prompt.updated", prompt=expired.model_dump(mode="json")+ )+ except Exception as exc:+ if owner.run and owner.busy:+ await self._fail(+ owner,+ owner.run.id,+ "The native answer could not be confirmed. It was not resent. "+ + _error_message(exc),+ )+ else:+ await self._close_connection(owner)++ async def _event(self, owner: _Owner, event: HarnessEvent) -> None:+ try:+ async with owner.lock:+ if (+ owner.deleted+ or event.generation != owner.generation+ or event.thread_id not in {None, owner.session.native_thread_id}+ ):+ return+ if owner.session.status != "ready":+ return+ run = owner.run+ matches = (+ run is not None+ and owner.busy+ and run.submission_started+ and event.turn_id is not None+ and (+ run.native_turn_id == event.turn_id+ or (+ run.native_turn_id is None+ and event.kind == "turn_started"+ and event.turn_id not in owner.known_turns+ )+ )+ )+ if (+ event.kind in {"turn_started", "turn_completed"}+ and matches+ and run is not None+ ):+ updated = run.model_copy(+ update={+ "native_turn_id": event.turn_id,+ "status": "stopping" if run.stop_requested else "running",+ }+ )+ await self._persist(owner, owner.session, run=updated)+ owner.run = updated+ if event.turn_id:+ owner.known_turns.add(event.turn_id)+ if event.kind == "turn_completed":+ await self._finish_locked(+ owner, event.status, event.message, event.error_details+ )+ else:+ self._publish(owner, "run.updated")+ self._schedule_interrupt(owner)+ elif event.kind == "item" and event.item is not None and matches:+ self._update_item(owner, event.item)+ if event.item.complete or owner.dirty_characters >= 4096:+ await self._flush_locked(owner)+ elif owner.flush_task is None or owner.flush_task.done():+ owner.flush_task = self._job(self._flush_later(owner))+ elif event.kind == "prompt" and event.prompt is not None:+ request = event.prompt+ if request.turn_id is not None and not matches:+ return+ if any(+ prompt.generation == event.generation+ and prompt.request_id == request.request_id+ for prompt in owner.prompts.values()+ ):+ return+ await self._flush_locked(owner)+ prompt = CodePrompt(+ id=str(uuid.uuid4()),+ session_id=owner.session.id,+ generation=event.generation,+ request_id=request.request_id,+ native_turn_id=request.turn_id,+ native_item_id=request.item_id,+ kind=request.kind,+ form=request.form,+ raw=request.raw,+ )+ await self._persist(owner, owner.session, prompts=(prompt,))+ owner.prompts[prompt.id] = prompt+ self._publish(+ owner, "prompt.updated", prompt=prompt.model_dump(mode="json")+ )+ elif event.kind == "resolved":+ for prompt in tuple(owner.prompts.values()):+ if (+ prompt.generation == event.generation+ and prompt.request_id == event.request_id+ and prompt.status in {"pending", "answering"}+ ):+ resolved = prompt.model_copy(update={"status": "resolved"})+ await self._persist(+ owner, owner.session, prompts=(resolved,)+ )+ owner.prompts[prompt.id] = resolved+ self._publish(+ owner,+ "prompt.updated",+ prompt=resolved.model_dump(mode="json"),+ )+ elif event.kind == "error" and matches:+ self._publish(+ owner,+ "run.notice",+ message=event.message or "Codex reported an error.",+ will_retry=event.will_retry,+ )+ elif event.kind == "closed":+ owner.connection = None+ owner.generation = None+ owner.loaded_thread_id = None+ if owner.busy:+ await self._finish_locked(+ owner,+ "interrupted" if run and run.stop_requested else "failed",+ event.message or "The Codex process ended.",+ )+ await self._expire_prompts_locked(owner)+ except Exception as exc:+ if owner.run and owner.busy:+ # Never wait for process teardown from its event dispatcher.+ self._job(self._fail(owner, owner.run.id, _error_message(exc)))+ else:+ logger.warning(+ "Code event could not be saved: exc_type={}", type(exc).__name__+ )++ def _update_item(+ self, owner: _Owner, update: ItemUpdate, *, recovered_run: CodeRun | None = None+ ) -> None:+ run = recovered_run or owner.run+ if run is None:+ raise CodeUnavailableError("Codex returned output without a saved turn.")+ historical = recovered_run is not None+ owner.known_turns.add(update.turn_id)+ existing = next(+ (+ item+ for item in owner.items.values()+ if item.native_turn_id == update.turn_id+ and item.native_item_id == update.item_id+ ),+ None,+ )+ if existing is None and update.kind == "user":+ if update.client_id is not None and update.client_id != run.id:+ raise CodeUnavailableError(+ "Codex returned a different message identity."+ )+ existing = owner.items.get(run.id)+ if existing is not None and existing.run_id != run.id:+ raise CodeUnavailableError(+ "Codex returned output belonging to another turn."+ )+ if existing is None:+ owner.sequence += 1+ preserve = bool(historical and existing and existing.complete)+ raw = _merge_source(existing.raw if existing else {}, update.raw, preserve)+ text = update.text+ detail = update.detail+ if historical and existing:+ text = (existing.text or text) if preserve else (text or existing.text)+ detail = (+ (existing.detail or detail) if preserve else (detail or existing.detail)+ )+ item = CodeItem(+ id=existing.id if existing else str(uuid.uuid4()),+ session_id=owner.session.id,+ sequence=existing.sequence if existing else owner.sequence,+ run_id=run.id,+ native_turn_id=update.turn_id,+ native_item_id=update.item_id,+ kind=update.kind,+ title=update.title or (existing.title if existing else ""),+ text=text,+ detail=detail,+ raw=raw,+ complete=update.complete or bool(existing and existing.complete),+ )+ if item == existing:+ return+ owner.items[item.id] = item+ owner.dirty.add(item.id)+ owner.dirty_characters += abs(+ len(item.text) - (len(existing.text) if existing else 0)+ ) + abs(len(item.detail) - (len(existing.detail) if existing else 0))+ owner.version += 1++ async def _flush_later(self, owner: _Owner) -> None:+ await asyncio.sleep(0.25)+ try:+ async with owner.lock:+ if not owner.deleted and not owner.storage_failed:+ await self._flush_locked(owner)+ except Exception as exc:+ if owner.run:+ await self._fail(owner, owner.run.id, _error_message(exc))++ async def _flush_locked(self, owner: _Owner) -> None:+ if not owner.dirty:+ return+ items = tuple(owner.items[item_id] for item_id in owner.dirty)+ await self._persist(owner, owner.session, items=items)+ owner.dirty.clear()+ owner.dirty_characters = 0+ for item in sorted(items, key=lambda value: value.sequence):+ self._publish(owner, "item.updated", item=item.model_dump(mode="json"))++ async def _finish_locked(+ self,+ owner: _Owner,+ status: RunStatus,+ message: str | None = None,+ error_details: JsonObject | None = None,+ ) -> None:+ if owner.run is None or not owner.busy:+ return+ run = owner.run.model_copy(+ update={+ "status": status,+ "error": message,+ "error_details": error_details or {},+ "finished_at": now_ms(),+ }+ )+ session = _revision(owner.session, error=None)+ prompts = tuple(+ prompt.model_copy(update={"status": "expired"})+ for prompt in owner.prompts.values()+ if prompt.status in {"pending", "answering"}+ and prompt.native_turn_id is not None+ and prompt.native_turn_id == run.native_turn_id+ )+ items = tuple(owner.items[item_id] for item_id in owner.dirty)+ await self._persist(owner, session, run=run, items=items, prompts=prompts)+ owner.session, owner.run = session, run+ owner.prompts.update((prompt.id, prompt) for prompt in prompts)+ owner.dirty.clear()+ owner.dirty_characters = 0+ self._publish(+ owner,+ "run.updated",+ items=[item.model_dump(mode="json") for item in items],+ prompts=[prompt.model_dump(mode="json") for prompt in prompts],+ )+ owner.finished.set()++ async def _expire_prompts_locked(self, owner: _Owner) -> None:+ prompts = tuple(+ prompt.model_copy(update={"status": "expired"})+ for prompt in owner.prompts.values()+ if prompt.status in {"pending", "answering"}+ )+ if not prompts:+ return+ await self._persist(owner, owner.session, prompts=prompts)+ for prompt in prompts:+ owner.prompts[prompt.id] = prompt+ self._publish(+ owner, "prompt.updated", prompt=prompt.model_dump(mode="json")+ )++ async def _persist(+ self,+ owner: _Owner,+ session: CodeSession,+ *,+ run: CodeRun | None = None,+ items: Sequence[CodeItem] = (),+ prompts: Sequence[CodePrompt] = (),+ ) -> None:+ if owner.storage_failed:+ raise CodeUnavailableError(+ "Code storage failed. Restart FCC to restore saved history."+ )+ try:+ await self._store.save_progress(+ session, owner.session.revision, run=run, items=items, prompts=prompts+ )+ if run is not None:+ owner.runs[run.id] = run+ except CodeConflictError, CodeNotFoundError:+ raise+ except Exception:+ owner.storage_failed = True+ if owner.failure_task is None:+ owner.failure_task = self._job(self._halt_storage(owner))+ raise++ async def _halt_storage(self, owner: _Owner) -> None:+ await self._close_connection(owner)+ self._storage_failure(owner)++ async def _close_connection(self, owner: _Owner) -> None:+ async with owner.lock:+ connection = owner.connection+ owner.connection = None+ owner.generation = None+ owner.loaded_thread_id = None+ if connection is not None:+ await connection.close()+ async with owner.lock:+ if not owner.deleted and not owner.storage_failed:+ try:+ if (+ connection+ and connection.thread_id+ and owner.session.native_thread_id is None+ ):+ session = owner.session.model_copy(+ update={"native_thread_id": connection.thread_id}+ )+ await self._persist(owner, session)+ owner.session = session+ await self._expire_prompts_locked(owner)+ except Exception:+ self._storage_failure(owner)++ async def _fail(+ self, owner: _Owner, run_id: str, message: str, *, interrupted: bool = False+ ) -> None:+ async with owner.lock:+ if owner.run is None or owner.run.id != run_id or not owner.busy:+ return+ try:+ await self._close_connection(owner)+ async with owner.lock:+ if owner.run and owner.run.id == run_id and not owner.storage_failed:+ status = (+ "interrupted"+ if interrupted or owner.run.stop_requested+ else "failed"+ )+ await self._finish_locked(owner, status, message)+ except Exception:+ self._storage_failure(owner)++ def _storage_failure(self, owner: _Owner) -> None:+ owner.storage_failed = True+ owner.finished.set()+ self._publish(+ owner,+ "session.notice",+ message="Code storage failed. This session was stopped; restart FCC to restore saved history.",+ )++ async def _delete_native(self, owner: _Owner, *, reconcile: bool = False) -> None:+ thread_id = owner.session.native_thread_id+ native_complete = False+ try:+ if thread_id is not None:+ connection = owner.connection+ if connection is None:+ connection = await self._harness.open_history(+ owner.session.cwd, lambda event: self._event(owner, event)+ )+ owner.connection, owner.generation = (+ connection,+ connection.generation,+ )+ try:+ if reconcile:+ await connection.read_thread(thread_id)+ raise CodeConflictError(+ "The native conversation still exists. You can retry deletion."+ )+ await connection.delete_thread(thread_id)+ except NativeHistoryMissing:+ pass+ native_complete = True+ await self._close_connection(owner)+ async with owner.lock:+ await self._store.delete(owner.session.id)+ owner.deleted = True+ owner.items.clear()+ owner.prompts.clear()+ owner.run = None+ owner.runs.clear()+ self._publish(owner, "session.deleted")+ async with self._load_lock:+ if self._owners.get(owner.session.id) is owner:+ del self._owners[owner.session.id]+ except Exception as exc:+ await self._close_connection(owner)+ status = (+ "ready" if isinstance(exc, CodeConflictError) else "delete_uncertain"+ )+ async with owner.lock:+ session = _revision(+ owner.session, status=status, error=_error_message(exc)+ )+ try:+ await self._persist(owner, session)+ except Exception:+ self._storage_failure(owner)+ return+ owner.session = session+ self._publish(owner, "session.updated")+ if status == "delete_uncertain" and not reconcile and not native_complete:+ await self._delete_native(owner, reconcile=True)+ finally:+ owner.finished.set()++ def _check_owner(self, owner: _Owner) -> None:+ if owner.deleted:+ raise CodeNotFoundError("Code session was deleted.")+ if owner.storage_failed:+ raise CodeUnavailableError(+ "Code storage failed. Restart FCC to restore saved history."+ )++ def _editable(self, owner: _Owner, revision: int) -> None:+ self._require_available()+ self._check_owner(owner)+ if owner.session.status != "ready" or owner.session.revision != revision:+ raise CodeConflictError(+ "This session changed. Refresh its state and try again."+ )++ def _summary(self, owner: _Owner) -> JsonObject:+ return {+ "session_id": owner.session.id,+ "session": owner.session.model_dump(mode="json"),+ "run": owner.run.model_dump(mode="json") if owner.run else None,+ "version": owner.version,+ "epoch": self.epoch,+ }++ def _publish(self, owner: _Owner, event: str, **data: JsonValue) -> None:+ owner.version += 1+ payload = self._summary(owner)+ for key, value in data.items():+ payload[key] = value+ self._events.publish(event, payload)+++def _validate_id(value: str) -> None:+ try:+ parsed = uuid.UUID(value)+ if str(parsed) != value or parsed.version != 4:+ raise ValueError+ except ValueError, AttributeError:+ raise CodeValidationError("Invalid session or command ID.") from None+++def _merge_source(+ previous: JsonObject, current: JsonObject, preserve: bool+) -> JsonObject:+ merged = dict(previous)+ for key, value in current.items():+ existing = merged.get(key)+ if isinstance(existing, dict) and isinstance(value, dict):+ merged[key] = _merge_source(existing, value, preserve)+ elif not preserve or existing in (None, "", [], {}):+ merged[key] = value+ return merged+++def _revision(session: CodeSession, **updates: object) -> CodeSession:+ return session.model_copy(+ update={"revision": session.revision + 1, "updated_at": now_ms(), **updates}+ )+++def _error_message(error: Exception) -> str:+ if isinstance(+ error,+ CodeUnavailableError+ | CodeValidationError+ | CodeConflictError+ | CodeNotFoundError,+ ):+ return str(error)+ return f"The Code session could not continue ({type(error).__name__})."diff --git a/src/free_claude_code/application/chat/events.py b/src/free_claude_code/application/session_events.pysimilarity index 60%rename from src/free_claude_code/application/chat/events.pyrename to src/free_claude_code/application/session_events.pyindex feca8a4e..aa037ad6 100644--- a/src/free_claude_code/application/chat/events.py+++ b/src/free_claude_code/application/session_events.py@@ -1,11 +1,26 @@-"""Bounded in-process fan-out for observable Chat state changes."""+"""Bounded in-process fan-out for observable session state changes."""import asynciofrom collections.abc import AsyncIterator+from dataclasses import dataclassfrom free_claude_code.core.json_types import JsonObject-from .models import ChatEventOverflowError, ChatPublishedEvent++@dataclass(frozen=True, slots=True)+class PublishedEvent:+ event: str+ id: int+ data: JsonObject+++class EventOverflowError(Exception):+ """One slow observer must reconnect from an authoritative snapshot."""++ def __init__(self, cursor: int) -> None:+ super().__init__("Session event subscription overflowed.")+ self.cursor = cursor+_DEFAULT_QUEUE_SIZE = 128@@ -22,15 +37,15 @@ class _Overflow:self.cursor = cursor-type _QueueItem = ChatPublishedEvent | _Overflow | _Closed+type _QueueItem = PublishedEvent | _Overflow | _Closed-class ChatEventSubscription:- """One observer's independent view of the process-local Chat feed."""+class EventSubscription:+ """One observer's independent view of the process-local session feed."""def __init__(self,- publisher: ChatEventPublisher,+ publisher: EventPublisher,*,cursor: int,queue_size: int,@@ -40,17 +55,17 @@ class ChatEventSubscription:self.cursor = cursorself._closed = False- def __aiter__(self) -> AsyncIterator[ChatPublishedEvent]:+ def __aiter__(self) -> AsyncIterator[PublishedEvent]:return self._events()- async def _events(self) -> AsyncIterator[ChatPublishedEvent]:+ async def _events(self) -> AsyncIterator[PublishedEvent]:while True:item = await self._queue.get()if item is _CLOSED:returnif isinstance(item, _Overflow):- raise ChatEventOverflowError(item.cursor)- if isinstance(item, ChatPublishedEvent):+ raise EventOverflowError(item.cursor)+ if isinstance(item, PublishedEvent):yield itemasync def aclose(self) -> None:@@ -69,21 +84,25 @@ class ChatEventSubscription:self._queue.put_nowait(item)-class ChatEventPublisher:- """Publish without allowing one observer to backpressure Chat work."""+class EventPublisher:+ """Publish without allowing one observer to backpressure session work."""def __init__(self, *, queue_size: int = _DEFAULT_QUEUE_SIZE) -> None:if queue_size <= 0:- raise ValueError("Chat event queue size must be positive.")+ raise ValueError("session event queue size must be positive.")self._queue_size = queue_sizeself._sequence = 0- self._subscriptions: set[ChatEventSubscription] = set()+ self._subscriptions: set[EventSubscription] = set()self._closed = False- def subscribe(self) -> ChatEventSubscription:+ @property+ def cursor(self) -> int:+ return self._sequence++ def subscribe(self) -> EventSubscription:if self._closed:- raise RuntimeError("Chat event publisher is closed.")- subscription = ChatEventSubscription(+ raise RuntimeError("session event publisher is closed.")+ subscription = EventSubscription(self,cursor=self._sequence,queue_size=self._queue_size,@@ -91,11 +110,11 @@ class ChatEventPublisher:self._subscriptions.add(subscription)return subscription- def publish(self, event: str, data: JsonObject) -> ChatPublishedEvent:+ def publish(self, event: str, data: JsonObject) -> PublishedEvent:if self._closed:- raise RuntimeError("Chat event publisher is closed.")+ raise RuntimeError("session event publisher is closed.")self._sequence += 1- published = ChatPublishedEvent(event=event, id=self._sequence, data={**data})+ published = PublishedEvent(event=event, id=self._sequence, data={**data})for subscription in tuple(self._subscriptions):try:subscription._queue.put_nowait(published)@@ -104,7 +123,7 @@ class ChatEventPublisher:subscription.signal(_Overflow(self._sequence))return published- def unsubscribe(self, subscription: ChatEventSubscription) -> None:+ def unsubscribe(self, subscription: EventSubscription) -> None:self._subscriptions.discard(subscription)def close(self) -> None:diff --git a/src/free_claude_code/cli/launchers/codex.py b/src/free_claude_code/cli/launchers/codex.pyindex d26b69b2..05f87052 100644--- a/src/free_claude_code/cli/launchers/codex.py+++ b/src/free_claude_code/cli/launchers/codex.py@@ -50,7 +50,7 @@ def codex_config_args(*, api_url: str, model: str | None = None) -> list[str]:]-def _configure(+def prepare_codex_launch(ctx: LaunchContext, args: list[str], files: LaunchResources) -> PreparedLaunch:catalog_path = files.write_json(@@ -81,7 +81,7 @@ SPEC = HarnessSpec(binary_name="codex",display_name="Codex CLI",install_hint="Install Codex with: npm install -g @openai/codex",- configure=_configure,+ configure=prepare_codex_launch,catalog_view="responses",)diff --git a/src/free_claude_code/config/paths.py b/src/free_claude_code/config/paths.pyindex 6021c1b8..0b97f168 100644--- a/src/free_claude_code/config/paths.py+++ b/src/free_claude_code/config/paths.py@@ -19,6 +19,9 @@ LAUNCHER_TEMP_DIRNAME = "launchers"CHAT_STATE_DIRNAME = "chat"CHAT_DATABASE_FILENAME = "chat.db"CHAT_LOCK_FILENAME = "chat.lock"+CODE_STATE_DIRNAME = "code"+CODE_DATABASE_FILENAME = "code.db"+CODE_LOCK_FILENAME = "code.lock"def config_dir_path() -> Path:@@ -63,6 +66,16 @@ def chat_lock_path() -> Path:return chat_state_dir_path() / CHAT_LOCK_FILENAME+def code_database_path() -> Path:+ """Return the managed Code sessions database path."""+ return config_dir_path() / CODE_STATE_DIRNAME / CODE_DATABASE_FILENAME+++def code_lock_path() -> Path:+ """Return the exclusive Code sessions process-lock path."""+ return config_dir_path() / CODE_STATE_DIRNAME / CODE_LOCK_FILENAME++def legacy_env_paths() -> tuple[Path, ...]:"""Return legacy user env paths that can be migrated to ~/.fcc/.env."""diff --git a/src/free_claude_code/runtime/application.py b/src/free_claude_code/runtime/application.pyindex b4ff500d..3845b87f 100644--- a/src/free_claude_code/runtime/application.py+++ b/src/free_claude_code/runtime/application.py@@ -15,6 +15,7 @@ import free_claude_code.cli.managed as cli_managedimport free_claude_code.messaging.session as messaging_sessionimport free_claude_code.messaging.workflow as messaging_workflow_modulefrom free_claude_code.application.chat import ChatService+from free_claude_code.application.code_sessions import CodeServicefrom free_claude_code.application.connected_accounts import (ConnectedAccountLoginMode,ConnectedAccountPort,@@ -140,12 +141,14 @@ class ApplicationRuntime:configuration: ConfigurationService,transcriber: Transcriber | None,chat_service: ChatService | None = None,+ code_service: CodeService | None = None,restart_callback: RestartCallback | None = None,connected_accounts: Mapping[str, ConnectedAccountPort] | None = None,) -> None:self.provider_manager = provider_managerself._configuration = configurationself._chat_service = chat_service+ self._code_service = code_serviceself._transcriber = transcriberself._restart_callback = restart_callbackself._connected_accounts = dict(connected_accounts or {})@@ -198,6 +201,8 @@ class ApplicationRuntime:self.provider_manager.start_model_list_refresh()if self._chat_service is not None:await self._chat_service.start()+ if self._code_service is not None:+ await self._code_service.start()await self._start_messaging_if_configured()if self._draining:raise ApplicationUnavailableError(@@ -223,6 +228,8 @@ class ApplicationRuntime:self._draining = Trueif self._chat_service is not None:self._chat_service.begin_shutdown()+ if self._code_service is not None:+ self._code_service.begin_shutdown()async def close(self) -> bool:self.begin_shutdown()@@ -583,6 +590,12 @@ class ApplicationRuntime:if not await self._cleanup_messaging():return Falseverbose = self.settings.log_api_error_tracebacks+ if self._code_service is not None and not await best_effort(+ "code_service.close",+ self._code_service.close(),+ log_verbose_errors=verbose,+ ):+ return Falseif self._chat_service is not None and not await best_effort("chat_service.close",self._chat_service.close(),diff --git a/src/free_claude_code/runtime/bootstrap.py b/src/free_claude_code/runtime/bootstrap.pyindex 53ef508f..43b2d8c9 100644--- a/src/free_claude_code/runtime/bootstrap.py+++ b/src/free_claude_code/runtime/bootstrap.py@@ -7,11 +7,14 @@ from pathlib import Pathfrom free_claude_code.api.app import create_appfrom free_claude_code.api.ports import ApiServicesfrom free_claude_code.application.chat import ChatService+from free_claude_code.application.code_sessions import CodeServicefrom free_claude_code.config.loader import ManagedConfigStorefrom free_claude_code.config.logging_config import configure_loggingfrom free_claude_code.config.paths import (chat_database_path,chat_lock_path,+ code_database_path,+ code_lock_path,server_log_path,)from free_claude_code.config.settings import Settings@@ -32,6 +35,8 @@ from free_claude_code.providers.runtime.factory import create_providerfrom .application import ApplicationRuntime, RestartCallbackfrom .asgi import RuntimeASGIAppfrom .chat_sqlite import SQLiteChatStore+from .code_sessions_sqlite import SQLiteCodeStore+from .codex_app_server import CodexHarnessFactoryfrom .codex_catalog import CodexModelCatalogPublisherfrom .configuration import ConfigurationServicefrom .provider_manager import ProviderRuntimeManager@@ -76,10 +81,15 @@ def build_asgi_app(provider_manager,SQLiteChatStore(chat_database_path(), chat_lock_path()),)+ code_service = CodeService(+ SQLiteCodeStore(code_database_path(), code_lock_path()),+ CodexHarnessFactory(provider_manager),+ )runtime = ApplicationRuntime(provider_manager,configuration=ConfigurationService(ManagedConfigStore()),chat_service=chat_service,+ code_service=code_service,transcriber=_create_transcriber(settings),restart_callback=restart_callback,connected_accounts={"openai": openai_auth, "github_copilot": copilot_auth},@@ -89,6 +99,7 @@ def build_asgi_app(admin=runtime,tasks=runtime,chat=chat_service,+ code=code_service,)return RuntimeASGIApp(create_app(services), runtime)diff --git a/src/free_claude_code/runtime/code_sessions_sqlite.py b/src/free_claude_code/runtime/code_sessions_sqlite.pynew file mode 100644index 00000000..c4213598--- /dev/null+++ b/src/free_claude_code/runtime/code_sessions_sqlite.py@@ -0,0 +1,686 @@+"""Relational, transaction-owned state for FCC coding conversations."""++import asyncio+import json+import os+import sqlite3+from collections.abc import Callable, Sequence+from contextlib import closing+from pathlib import Path++import anyio.to_thread++from free_claude_code.application.code_sessions.models import (+ CodeConflictError,+ CodeItem,+ CodeItemPage,+ CodeNotFoundError,+ CodePage,+ CodePrompt,+ CodeRun,+ CodeSession,+ CodeUnavailableError,+ Record,+ now_ms,+)+from free_claude_code.core.interprocess_lock import InterprocessFileLock++_JSON_FIELDS = frozenset({"raw", "form", "error_details", "request_id"})+_RUN_TRANSITIONS = {+ "preparing": {+ "preparing",+ "running",+ "stopping",+ "completed",+ "failed",+ "interrupted",+ },+ "running": {"running", "stopping", "completed", "failed", "interrupted"},+ "stopping": {"stopping", "completed", "failed", "interrupted"},+ "completed": {"completed"},+ "failed": {"failed"},+ "interrupted": {"interrupted"},+}+_PROMPT_TRANSITIONS = {+ "pending": {"pending", "answering", "resolved", "expired"},+ "answering": {"answering", "resolved", "expired"},+ "resolved": {"resolved"},+ "expired": {"expired"},+}+++def _values(record: Record) -> dict[str, object]:+ values = record.model_dump()+ for key in values.keys() & _JSON_FIELDS:+ values[key] = json.dumps(values[key], sort_keys=True, separators=(",", ":"))+ if isinstance(record, CodeSession):+ values.update(+ title_search=record.title.casefold(), cwd_search=record.cwd.casefold()+ )+ return values+++def _record[T: Record](model: type[T], row: sqlite3.Row) -> T:+ values = {key: row[key] for key in model.model_fields}+ for key in values.keys() & _JSON_FIELDS:+ values[key] = json.loads(values[key])+ return model.model_validate(values)+++def _insert(connection: sqlite3.Connection, table: str, record: Record) -> None:+ values = _values(record)+ connection.execute(+ f"INSERT INTO {table} ({','.join(values)}) VALUES ({','.join('?' for _ in values)})",+ tuple(values.values()),+ )+++def _update(+ connection: sqlite3.Connection,+ table: str,+ values: dict[str, object],+ where: str,+ parameters: tuple[object, ...],+) -> None:+ result = connection.execute(+ f"UPDATE {table} SET {','.join(f'{key} = ?' for key in values)} WHERE {where}",+ (*values.values(), *parameters),+ )+ if result.rowcount != 1:+ raise CodeConflictError("This Code session changed. Refresh it and try again.")+++def _session(connection: sqlite3.Connection, session_id: str) -> CodeSession:+ row = connection.execute(+ "SELECT * FROM code_sessions WHERE id = ?", (session_id,)+ ).fetchone()+ if row is None:+ raise CodeNotFoundError("Code session not found.")+ return _record(CodeSession, row)+++def _idle(connection: sqlite3.Connection, session_id: str) -> None:+ if (+ connection.execute(+ "SELECT 1 FROM code_runs WHERE session_id = ? AND status IN ('preparing','running','stopping')",+ (session_id,),+ ).fetchone()+ or connection.execute(+ "SELECT 1 FROM code_prompts WHERE session_id = ? AND status IN ('pending','answering')",+ (session_id,),+ ).fetchone()+ ):+ raise CodeConflictError("This session is busy. Your draft has been kept.")+++def _write_session(+ connection: sqlite3.Connection,+ session: CodeSession,+ expected_revision: int,+ *,+ settings: bool,+) -> None:+ current = _session(connection, session.id)+ if current.revision != expected_revision or session.revision not in {+ expected_revision,+ expected_revision + 1,+ }:+ raise CodeConflictError(+ "This session changed. Refresh its state and try again."+ )+ fields = (+ {+ "title",+ "title_search",+ "auto_title",+ "model",+ "reasoning_effort",+ "revision",+ "updated_at",+ }+ if settings+ else {+ "native_thread_id",+ "native_may_have_input",+ "revision",+ "updated_at",+ "status",+ "error",+ }+ )+ _update(+ connection,+ "code_sessions",+ {key: value for key, value in _values(session).items() if key in fields},+ "id = ? AND revision = ?",+ (session.id, expected_revision),+ )+++def _write_run(connection: sqlite3.Connection, run: CodeRun) -> None:+ row = connection.execute(+ "SELECT * FROM code_runs WHERE session_id = ? AND id = ?",+ (run.session_id, run.id),+ ).fetchone()+ if row is None:+ raise CodeNotFoundError("Code turn not found.")+ previous = _record(CodeRun, row)+ if (+ run.status not in _RUN_TRANSITIONS[previous.status]+ or (+ previous.status in {"completed", "failed", "interrupted"}+ and (+ run.finished_at != previous.finished_at+ or (previous.error is not None and run.error != previous.error)+ )+ )+ or (previous.stop_requested and not run.stop_requested)+ or (previous.submission_started and not run.submission_started)+ or any(+ getattr(previous, key) != getattr(run, key)+ for key in ("ordinal", "text", "model", "reasoning_effort")+ )+ or (+ previous.native_turn_id is not None+ and previous.native_turn_id != run.native_turn_id+ )+ ):+ raise CodeConflictError("This Code turn no longer accepts that update.")+ values = _values(run)+ for key in (+ "id",+ "session_id",+ "ordinal",+ "text",+ "model",+ "reasoning_effort",+ "created_at",+ ):+ values.pop(key)+ _update(+ connection,+ "code_runs",+ values,+ "session_id = ? AND id = ? AND status = ?",+ (run.session_id, run.id, previous.status),+ )+++def _write_item(connection: sqlite3.Connection, item: CodeItem) -> None:+ row = connection.execute(+ "SELECT * FROM code_items WHERE session_id = ? AND id = ?",+ (item.session_id, item.id),+ ).fetchone()+ if row is None:+ _insert(connection, "code_items", item)+ return+ previous = _record(CodeItem, row)+ if (+ previous.run_id != item.run_id+ or previous.sequence != item.sequence+ or previous.kind != item.kind+ or (previous.complete and not item.complete)+ or any(+ getattr(previous, key) is not None+ and getattr(previous, key) != getattr(item, key)+ for key in ("native_turn_id", "native_item_id")+ )+ ):+ raise CodeConflictError("This transcript entry belongs to different work.")+ values = _values(item)+ for key in ("id", "session_id", "run_id", "sequence"):+ values.pop(key)+ _update(+ connection,+ "code_items",+ values,+ "session_id = ? AND id = ?",+ (item.session_id, item.id),+ )+++def _write_prompt(connection: sqlite3.Connection, prompt: CodePrompt) -> None:+ row = connection.execute(+ "SELECT * FROM code_prompts WHERE session_id = ? AND id = ?",+ (prompt.session_id, prompt.id),+ ).fetchone()+ if row is None:+ _insert(connection, "code_prompts", prompt)+ return+ previous = _record(CodePrompt, row)+ if (+ prompt.status not in _PROMPT_TRANSITIONS[previous.status]+ or any(+ getattr(previous, key) != getattr(prompt, key)+ for key in (+ "generation",+ "request_id",+ "native_turn_id",+ "native_item_id",+ "kind",+ )+ )+ or (+ previous.response_id is not None+ and previous.response_id != prompt.response_id+ )+ ):+ raise CodeConflictError("This native prompt is no longer active.")+ values = _values(prompt)+ for key in ("id", "session_id"):+ values.pop(key)+ _update(+ connection,+ "code_prompts",+ values,+ "session_id = ? AND id = ? AND status = ?",+ (prompt.session_id, prompt.id, previous.status),+ )+++class SQLiteCodeStore:+ def __init__(self, database_path: Path, lock_path: Path) -> None:+ self._path = database_path+ self._lock = InterprocessFileLock(lock_path)+ self._started = False+ self._lifecycle = asyncio.Lock()++ async def start(self) -> None:+ async with self._lifecycle:+ if self._started:+ return+ initialization = asyncio.create_task(+ anyio.to_thread.run_sync(self._initialize)+ )+ try:+ await asyncio.shield(initialization)+ except BaseException:+ await asyncio.gather(initialization, return_exceptions=True)+ self._lock.release()+ raise+ self._started = True++ def _initialize(self) -> None:+ self._path.parent.mkdir(parents=True, exist_ok=True)+ if not self._lock.acquire():+ raise CodeUnavailableError(+ "Code sessions is already owned by another FCC server."+ )+ if os.name != "nt":+ self._path.parent.chmod(0o700)+ self._execute(self._initialize_schema)+ if os.name != "nt":+ for path in (+ self._path,+ Path(f"{self._path}-wal"),+ Path(f"{self._path}-shm"),+ ):+ if path.exists():+ path.chmod(0o600)++ async def close(self) -> None:+ async with self._lifecycle:+ self._started = False+ await anyio.to_thread.run_sync(self._lock.release)++ def _execute[T](self, operation: Callable[[sqlite3.Connection], T]) -> T:+ try:+ with closing(sqlite3.connect(self._path, timeout=10)) as connection:+ connection.row_factory = sqlite3.Row+ connection.execute("PRAGMA foreign_keys = ON")+ with connection:+ return operation(connection)+ except sqlite3.IntegrityError as exc:+ raise CodeConflictError(+ "This Code operation conflicts with existing session state."+ ) from exc+ except sqlite3.Error as exc:+ raise CodeUnavailableError("Code session storage is unavailable.") from exc++ async def _run[T](self, operation: Callable[[sqlite3.Connection], T]) -> T:+ if not self._started:+ raise CodeUnavailableError("Code session storage is closed.")+ return await anyio.to_thread.run_sync(self._execute, operation)++ def _initialize_schema(self, connection: sqlite3.Connection) -> None:+ connection.execute("PRAGMA journal_mode = WAL")+ connection.executescript(_SCHEMA)+ connection.execute("BEGIN IMMEDIATE")+ connection.execute(+ "UPDATE code_runs SET status = 'interrupted', finished_at = ?, error = ? "+ "WHERE status IN ('preparing','running','stopping')",+ (+ now_ms(),+ "FCC restarted before this turn finished. Its input was not resent.",+ ),+ )+ connection.execute(+ "UPDATE code_prompts SET status = 'expired' WHERE status IN ('pending','answering')"+ )++ async def create(self, session: CodeSession) -> CodeSession:+ def operation(connection: sqlite3.Connection) -> CodeSession:+ connection.execute("BEGIN IMMEDIATE")+ if connection.execute(+ "SELECT 1 FROM code_deleted WHERE id = ?", (session.id,)+ ).fetchone():+ raise CodeConflictError(+ "This session was deleted. Create a new session."+ )+ row = connection.execute(+ "SELECT * FROM code_sessions WHERE id = ?", (session.id,)+ ).fetchone()+ if row:+ previous = _record(CodeSession, row)+ if previous.cwd != session.cwd or previous.harness != session.harness:+ raise CodeConflictError(+ "This session ID was already used for another folder."+ )+ return previous+ _insert(connection, "code_sessions", session)+ return session++ return await self._run(operation)++ async def get_session(self, session_id: str) -> CodeSession:+ return await self._run(lambda connection: _session(connection, session_id))++ async def list_sessions(+ self, cursor: tuple[int, str] | None, limit: int, query: str = ""+ ) -> CodePage:+ def operation(connection: sqlite3.Connection) -> CodePage:+ clauses, parameters = [], []+ if query.strip():+ clauses.append(+ "(instr(title_search, ?) > 0 OR instr(cwd_search, ?) > 0)"+ )+ parameters.extend([query.strip().casefold()] * 2)+ if cursor:+ clauses.append("(updated_at, id) < (?, ?)")+ parameters.extend(cursor)+ where = " WHERE " + " AND ".join(clauses) if clauses else ""+ rows = connection.execute(+ "SELECT * FROM code_sessions"+ + where+ + " ORDER BY updated_at DESC, id DESC LIMIT ?",+ (*parameters, limit + 1),+ ).fetchall()+ sessions = tuple(_record(CodeSession, row) for row in rows[:limit])+ last = sessions[-1] if sessions and len(rows) > limit else None+ return CodePage(sessions, (last.updated_at, last.id) if last else None)++ return await self._run(operation)++ async def pending_deletions(self) -> tuple[CodeSession, ...]:+ return await self._run(+ lambda connection: tuple(+ _record(CodeSession, row)+ for row in connection.execute(+ "SELECT * FROM code_sessions WHERE status != 'ready'"+ )+ )+ )++ async def is_deleted(self, session_id: str) -> bool:+ return await self._run(+ lambda connection: (+ connection.execute(+ "SELECT 1 FROM code_deleted WHERE id = ?", (session_id,)+ ).fetchone()+ is not None+ )+ )++ async def get_run(self, session_id: str, run_id: str) -> CodeRun | None:+ def operation(connection: sqlite3.Connection) -> CodeRun | None:+ row = connection.execute(+ "SELECT * FROM code_runs WHERE session_id = ? AND id = ?",+ (session_id, run_id),+ ).fetchone()+ return _record(CodeRun, row) if row else None++ return await self._run(operation)++ async def runs(self, session_id: str) -> tuple[CodeRun, ...]:+ return await self._run(+ lambda connection: tuple(+ _record(CodeRun, row)+ for row in connection.execute(+ "SELECT * FROM code_runs WHERE session_id = ? ORDER BY ordinal",+ (session_id,),+ )+ )+ )++ async def latest_run(self, session_id: str) -> CodeRun | None:+ def operation(connection: sqlite3.Connection) -> 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++ return await self._run(operation)++ async def items(+ self, session_id: str, before: tuple[int, int] | None, limit: int | None+ ) -> tuple[CodeItem, ...]:+ return (await self.item_page(session_id, before, limit)).items++ async def item_page(+ self, session_id: str, before: tuple[int, int] | None, limit: int | None+ ) -> 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)+ for row in connection.execute(+ "SELECT * FROM code_runs WHERE session_id = ? ORDER BY ordinal",+ (session_id,),+ )+ if row["id"] in run_ids+ )+ 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)),+ runs,+ (last["run_ordinal"], last["sequence"]) if last else None,+ )++ return await self._run(operation)++ async def prompts(self, session_id: str) -> tuple[CodePrompt, ...]:+ return await self._run(+ lambda connection: tuple(+ _record(CodePrompt, row)+ for row in connection.execute(+ "SELECT * FROM code_prompts WHERE session_id = ? ORDER BY id",+ (session_id,),+ )+ )+ )++ async def update_settings(+ self, session: CodeSession, expected_revision: int+ ) -> CodeSession:+ def operation(connection: sqlite3.Connection) -> CodeSession:+ connection.execute("BEGIN IMMEDIATE")+ previous = _session(connection, session.id)+ if previous.status != "ready":+ raise CodeConflictError("This session is being deleted.")+ if (previous.model, previous.reasoning_effort) != (+ session.model,+ session.reasoning_effort,+ ):+ _idle(connection, session.id)+ _write_session(connection, session, expected_revision, settings=True)+ return _session(connection, session.id)++ return await self._run(operation)++ async def admit_run(+ self, session: CodeSession, run: CodeRun, item: CodeItem, expected_revision: int+ ) -> tuple[CodeSession, CodeRun]:+ def operation(connection: sqlite3.Connection) -> tuple[CodeSession, CodeRun]:+ connection.execute("BEGIN IMMEDIATE")+ previous = _session(connection, session.id)+ row = connection.execute(+ "SELECT * FROM code_runs WHERE session_id = ? AND id = ?",+ (session.id, run.id),+ ).fetchone()+ if row:+ receipt = _record(CodeRun, row)+ if receipt.text != run.text:+ raise CodeConflictError(+ "This Send ID was already used for a different message."+ )+ return previous, receipt+ if (+ previous.status != "ready"+ or previous.model != run.model+ or run.session_id != session.id+ ):+ raise CodeConflictError(+ "This session changed. Refresh it and try again."+ )+ _idle(connection, session.id)+ _write_session(connection, session, expected_revision, settings=True)+ ordinal = connection.execute(+ "SELECT coalesce(max(ordinal), 0) + 1 FROM code_runs WHERE session_id = ?",+ (session.id,),+ ).fetchone()[0]+ admitted = run.model_copy(update={"ordinal": ordinal})+ if (+ item.session_id != session.id+ or item.run_id != run.id+ or item.id != run.id+ or item.kind != "user"+ ):+ raise CodeConflictError(+ "The submitted message belongs to different work."+ )+ _insert(connection, "code_runs", admitted)+ _insert(connection, "code_items", item)+ return _session(connection, session.id), admitted++ return await self._run(operation)++ async def claim_prompt(+ self, session_id: str, prompt_id: str, response_id: str, generation: str+ ) -> CodePrompt:+ def operation(connection: sqlite3.Connection) -> CodePrompt:+ connection.execute("BEGIN IMMEDIATE")+ row = connection.execute(+ "SELECT * FROM code_prompts WHERE session_id = ? AND id = ?",+ (session_id, prompt_id),+ ).fetchone()+ if row is None:+ raise CodeNotFoundError("This prompt no longer exists.")+ prompt = _record(CodePrompt, row)+ if prompt.response_id == response_id:+ return prompt+ if prompt.status != "pending" or prompt.generation != generation:+ raise CodeConflictError(+ "This prompt was already answered or is no longer active."+ )+ claimed = prompt.model_copy(+ update={"status": "answering", "response_id": response_id}+ )+ _write_prompt(connection, claimed)+ return claimed++ return await self._run(operation)++ async def save_progress(+ self,+ session: CodeSession,+ expected_revision: int,+ *,+ run: CodeRun | None = None,+ items: Sequence[CodeItem] = (),+ prompts: Sequence[CodePrompt] = (),+ ) -> None:+ def operation(connection: sqlite3.Connection) -> None:+ connection.execute("BEGIN IMMEDIATE")+ _write_session(connection, session, expected_revision, settings=False)+ if run is not None:+ if run.session_id != session.id:+ raise CodeConflictError("This turn belongs to another session.")+ _write_run(connection, run)+ for item in items:+ if item.session_id != session.id:+ raise CodeConflictError("This entry belongs to another session.")+ _write_item(connection, item)+ for prompt in prompts:+ if prompt.session_id != session.id:+ raise CodeConflictError("This prompt belongs to another session.")+ _write_prompt(connection, prompt)++ await self._run(operation)++ async def delete(self, session_id: str) -> None:+ def operation(connection: sqlite3.Connection) -> None:+ connection.execute("BEGIN IMMEDIATE")+ connection.execute(+ "INSERT OR IGNORE INTO code_deleted(id) VALUES (?)", (session_id,)+ )+ connection.execute("DELETE FROM code_sessions WHERE id = ?", (session_id,))++ await self._run(operation)+++_SCHEMA = """+CREATE TABLE IF NOT EXISTS code_sessions(+ id TEXT PRIMARY KEY NOT NULL, cwd TEXT NOT NULL, model TEXT NOT NULL, reasoning_effort TEXT,+ harness TEXT NOT NULL CHECK(harness = 'codex'), title TEXT NOT NULL, title_search TEXT NOT NULL,+ cwd_search TEXT NOT NULL, auto_title INTEGER NOT NULL CHECK(auto_title IN (0,1)), native_thread_id TEXT,+ native_may_have_input INTEGER NOT NULL CHECK(native_may_have_input IN (0,1)),+ revision INTEGER NOT NULL CHECK(revision > 0), status TEXT NOT NULL CHECK(status IN ('ready','deleting','delete_uncertain')),+ error TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL+);+CREATE INDEX IF NOT EXISTS code_sessions_recent ON code_sessions(updated_at DESC, id DESC);+CREATE TABLE IF NOT EXISTS code_runs(+ session_id TEXT NOT NULL REFERENCES code_sessions(id) ON DELETE CASCADE, id TEXT NOT NULL,+ ordinal INTEGER NOT NULL CHECK(ordinal > 0), text TEXT NOT NULL, model TEXT NOT NULL, reasoning_effort TEXT,+ status TEXT NOT NULL CHECK(status IN ('preparing','running','stopping','completed','interrupted','failed')),+ submission_started INTEGER NOT NULL CHECK(submission_started IN (0,1)), native_turn_id TEXT,+ stop_requested INTEGER NOT NULL CHECK(stop_requested IN (0,1)), error TEXT, error_details TEXT NOT NULL,+ created_at INTEGER NOT NULL, finished_at INTEGER,+ PRIMARY KEY(session_id,id), UNIQUE(session_id,ordinal), UNIQUE(session_id,native_turn_id)+);+CREATE UNIQUE INDEX IF NOT EXISTS code_one_active_run ON code_runs(session_id)+ WHERE status IN ('preparing','running','stopping');+CREATE TABLE IF NOT EXISTS code_items(+ session_id TEXT NOT NULL REFERENCES code_sessions(id) ON DELETE CASCADE, id TEXT NOT NULL,+ run_id TEXT NOT NULL, sequence INTEGER NOT NULL CHECK(sequence > 0), native_turn_id TEXT, native_item_id TEXT,+ kind TEXT NOT NULL, title TEXT NOT NULL, text TEXT NOT NULL, detail TEXT NOT NULL,+ complete INTEGER NOT NULL CHECK(complete IN (0,1)), raw TEXT NOT NULL,+ PRIMARY KEY(session_id,id), FOREIGN KEY(session_id,run_id) REFERENCES code_runs(session_id,id) ON DELETE CASCADE,+ UNIQUE(session_id,sequence), UNIQUE(session_id,native_turn_id,native_item_id)+);+CREATE INDEX IF NOT EXISTS code_items_run ON code_items(session_id,run_id,sequence);+CREATE TABLE IF NOT EXISTS code_prompts(+ session_id TEXT NOT NULL REFERENCES code_sessions(id) ON DELETE CASCADE, id TEXT NOT NULL,+ generation TEXT NOT NULL, request_id TEXT NOT NULL, native_turn_id TEXT, native_item_id TEXT,+ kind TEXT NOT NULL, form TEXT NOT NULL, raw TEXT NOT NULL,+ status TEXT NOT NULL CHECK(status IN ('pending','answering','resolved','expired')), response_id TEXT, error TEXT,+ PRIMARY KEY(session_id,id), UNIQUE(session_id,generation,request_id), UNIQUE(session_id,response_id)+);+CREATE TABLE IF NOT EXISTS code_deleted(id TEXT PRIMARY KEY NOT NULL);+"""diff --git a/src/free_claude_code/runtime/codex_app_server.py b/src/free_claude_code/runtime/codex_app_server.pynew file mode 100644index 00000000..c98899d2--- /dev/null+++ b/src/free_claude_code/runtime/codex_app_server.py@@ -0,0 +1,654 @@+"""Owned Codex app-server processes over bidirectional stdio JSONL."""++import asyncio+import hashlib+import json+import os+import shutil+import signal+import subprocess+import uuid+from collections.abc import Mapping+from contextlib import ExitStack, suppress+from dataclasses import dataclass, replace++from free_claude_code.application.code_sessions.models import (+ CodeCatalog,+ CodeConflictError,+ CodeModel,+ CodeUnavailableError,+ CodeValidationError,+ HarnessEvent,+ NativeHistoryMissing,+ NativeThread,+)+from free_claude_code.application.code_sessions.ports import EventSink, HarnessSelection+from free_claude_code.application.ports import RequestRuntimePort+from free_claude_code.cli.launchers.codex import SPEC, prepare_codex_launch+from free_claude_code.cli.launchers.codex_model_catalog import build_codex_model_catalog+from free_claude_code.cli.launchers.resources import LaunchResources+from free_claude_code.cli.launchers.runner import LaunchContext+from free_claude_code.cli.process_registry import register_pid, unregister_pid+from free_claude_code.config.server_urls import local_proxy_root_url+from free_claude_code.core.json_types import JsonObject+from free_claude_code.core.version import package_version++from .codex_catalog import current_codex_models+from .codex_protocol import (+ CodexProtocol,+ NativePrompt,+ array_value,+ object_value,+ string_value,+)+++class CodexAppServer:+ def __init__(+ self,+ command: list[str],+ env: Mapping[str, str],+ cwd: str,+ sink: EventSink,+ *,+ model_slugs: Mapping[str, str] | None = None,+ fingerprints: Mapping[str, str] | None = None,+ reasoning: Mapping[str, bool] | None = None,+ resources: ExitStack | None = None,+ ) -> None:+ self.generation = str(uuid.uuid4())+ self.thread_id: str | None = None+ self._owned_threads: set[str] = set()+ self._command, self._env, self._cwd, self._sink = command, dict(env), cwd, sink+ self._model_slugs = dict(model_slugs or {})+ self._fingerprints = dict(fingerprints or {})+ self._reasoning = dict(reasoning or {})+ self._resources = resources or ExitStack()+ self._protocol = CodexProtocol(self.generation)+ self._pending: dict[str, tuple[str, asyncio.Future[JsonObject]]] = {}+ self._requests: dict[str | int, NativePrompt] = {}+ self._queue: asyncio.Queue[HarnessEvent | None] = asyncio.Queue()+ self._writer_lock = asyncio.Lock()+ self._process: asyncio.subprocess.Process | None = None+ self._reader: asyncio.Task[None] | None = None+ self._stderr: asyncio.Task[None] | None = None+ self._dispatcher: asyncio.Task[None] | None = None+ self._closing: asyncio.Task[None] | None = None+ self._reaping: asyncio.Task[None] | None = None+ self._alive = False+ self._stderr_tail = bytearray()++ @property+ def process(self) -> asyncio.subprocess.Process:+ if self._process is None:+ raise CodeUnavailableError("Codex has not started.")+ return self._process++ async def start(self) -> None:+ try:+ self._process = await asyncio.create_subprocess_exec(+ *self._command,+ cwd=self._cwd,+ env=self._env,+ stdin=asyncio.subprocess.PIPE,+ stdout=asyncio.subprocess.PIPE,+ stderr=asyncio.subprocess.PIPE,+ creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,+ start_new_session=os.name != "nt",+ )+ register_pid(self._process.pid)+ self._alive = True+ self._reader = asyncio.create_task(self._read(), name="fcc-codex-jsonl")+ self._stderr = asyncio.create_task(+ self._read_stderr(), name="fcc-codex-stderr"+ )+ self._dispatcher = asyncio.create_task(+ self._dispatch(), name="fcc-codex-events"+ )+ await self.rpc(+ "initialize",+ {+ "clientInfo": {+ "name": "free_claude_code",+ "title": "Free Claude Code",+ "version": package_version(),+ },+ "capabilities": {+ "experimentalApi": True,+ "mcpServerOpenaiFormElicitation": False,+ },+ },+ )+ await self._write({"method": "initialized", "params": {}})+ except BaseException:+ await self.close()+ raise++ def supports(self, selection: HarnessSelection) -> bool:+ return (+ self._alive+ and self._closing is None+ and self._fingerprints.get(selection.model) == selection.configuration_key+ )++ async def create_thread(self) -> NativeThread:+ response = await self.rpc(+ "thread/start", {"cwd": self._cwd, "modelProvider": "fcc"}+ )+ native = self._protocol.history(response)+ self.thread_id = native.id+ return native++ async def resume_thread(self, thread_id: str) -> NativeThread:+ response = await self.rpc(+ "thread/resume",+ {"threadId": thread_id, "cwd": self._cwd, "modelProvider": "fcc"},+ )+ native = self._protocol.history(response)+ self.thread_id = native.id+ return native++ async def read_thread(self, thread_id: str) -> NativeThread:+ return self._protocol.history(+ await self.rpc("thread/read", {"threadId": thread_id, "includeTurns": True})+ )++ async def start_turn(+ self, text: str, selection: HarnessSelection, client_id: str+ ) -> str:+ model = self._model_slugs.get(selection.model)+ if not self.thread_id or model is None:+ raise CodeUnavailableError(+ "Codex is not prepared for the selected FCC model."+ )+ params: JsonObject = {+ "threadId": self.thread_id,+ "input": [{"type": "text", "text": text}],+ "clientUserMessageId": client_id,+ "model": model,+ }+ if self._reasoning.get(selection.model, True):+ params["summary"] = "auto"+ params["effort"] = selection.reasoning_effort+ result = await self.rpc("turn/start", params)+ turn_id = string_value(object_value(result.get("turn")).get("id"))+ if not turn_id:+ raise CodeUnavailableError(+ "Codex did not return a turn ID; input was not resent."+ )+ return turn_id++ async def interrupt(self, turn_id: str) -> None:+ await self.rpc(+ "turn/interrupt", {"threadId": self.thread_id, "turnId": turn_id}+ )++ def prepare_answer(self, request_id: str | int, answer: JsonObject) -> JsonObject:+ prompt = self._requests.get(request_id)+ if prompt is None:+ raise CodeConflictError("This native prompt is no longer active.")+ return prompt.answer(answer)++ async def respond(self, request_id: str | int, response: JsonObject) -> None:+ async with self._writer_lock:+ if not self._alive or request_id not in self._requests:+ raise CodeConflictError("This native prompt is no longer active.")+ self._write_frame({"id": request_id, "result": response})+ self._requests.pop(request_id, None)+ assert self.process.stdin is not None+ await self.process.stdin.drain()++ async def delete_thread(self, thread_id: str) -> None:+ await self.rpc("thread/delete", {"threadId": thread_id})++ async def rpc(self, method: str, params: JsonObject) -> JsonObject:+ if not self._alive:+ raise CodeUnavailableError("The Codex connection is closed.")+ request_id = f"fcc-{uuid.uuid4()}"+ future: asyncio.Future[JsonObject] = asyncio.get_running_loop().create_future()+ # A cancelled caller does not erase the pending native response/identity.+ future.add_done_callback(+ lambda value: value.exception() if not value.cancelled() else None+ )+ self._pending[request_id] = method, future+ try:+ await self._write({"id": request_id, "method": method, "params": params})+ async with asyncio.timeout(30):+ return await asyncio.shield(future)+ except asyncio.CancelledError:+ raise+ except TimeoutError as exc:+ raise CodeUnavailableError(+ "Codex did not acknowledge the request. It was not resent."+ ) from exc++ async def _write(self, message: JsonObject) -> None:+ async with self._writer_lock:+ self._write_frame(message)+ assert self.process.stdin is not None+ await self.process.stdin.drain()++ def _write_frame(self, message: JsonObject) -> None:+ if not self._alive or self.process.stdin is None:+ raise CodeUnavailableError("The Codex connection is closed.")+ self.process.stdin.write(+ (json.dumps(message, ensure_ascii=False, allow_nan=False) + "\n").encode(+ "utf-8"+ )+ )++ async def _read(self) -> None:+ assert self.process.stdout is not None+ buffer = bytearray()+ message = "The Codex process ended."+ discarded_output: asyncio.Task[None] | None = None+ try:+ while chunk := await self.process.stdout.read(65536):+ buffer.extend(chunk)+ while (position := buffer.find(b"\n")) >= 0:+ frame = bytes(buffer[:position])+ del buffer[: position + 1]+ if frame.strip():+ await self._packet(+ object_value(json.loads(frame.decode("utf-8")))+ )+ if buffer.strip():+ raise ValueError("Incomplete native JSONL frame")+ except Exception as exc:+ message = f"The Codex connection failed ({type(exc).__name__})."+ discarded_output = asyncio.create_task(self._discard_stdout())+ finally:+ self._alive = False+ for _, future in self._pending.values():+ if not future.done():+ future.set_exception(CodeUnavailableError(message))+ self._pending.clear()+ self._requests.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()+ if discarded_output is not None:+ await discarded_output+ self._queue.put_nowait(+ HarnessEvent(self.generation, self.thread_id, "closed", message=message)+ )+ self._queue.put_nowait(None)++ async def _discard_stdout(self) -> None:+ # Keep draining a failed protocol stream until EOF, so a full pipe+ # cannot block native shutdown or retain its subprocess transport.+ assert self.process.stdout is not None+ while await self.process.stdout.read(65536):+ pass++ async def _packet(self, packet: JsonObject) -> None:+ method = string_value(packet.get("method"))+ if not method:+ request_id = packet.get("id")+ pending = (+ self._pending.pop(request_id, None)+ if isinstance(request_id, str)+ else None+ )+ if pending is None:+ return+ operation, future = pending+ if future.done():+ return+ if "error" in packet:+ error = object_value(packet["error"])+ message = (+ self._redact(string_value(error.get("message")))+ or "Codex rejected the request."+ )+ if operation in {+ "thread/read",+ "thread/resume",+ "thread/delete",+ } and any(+ phrase in message.lower()+ for phrase in (+ "thread not found",+ "thread does not exist",+ "no rollout found",+ "not found for thread",+ )+ ):+ future.set_exception(NativeHistoryMissing(message))+ elif error.get("code") == -32601:+ future.set_exception(+ CodeUnavailableError(+ "This Codex version lacks the required app-server method. Update Codex."+ )+ )+ else:+ future.set_exception(CodeConflictError(message))+ return+ result = object_value(packet.get("result"))+ if operation in {"thread/start", "thread/resume"}:+ identity = string_value(object_value(result.get("thread")).get("id"))+ if identity:+ self.thread_id = identity+ self._owned_threads.add(identity)+ future.set_result(result)+ return+ params = object_value(packet.get("params"))+ if method == "thread/started":+ thread = object_value(params.get("thread"))+ source = object_value(object_value(thread.get("source")).get("subAgent"))+ parent = object_value(source.get("thread_spawn")).get("parent_thread_id")+ child = string_value(thread.get("id"))+ if child and isinstance(parent, str) and parent in self._owned_threads:+ self._owned_threads.add(child)+ return+ request_id = packet.get("id")+ if isinstance(request_id, str | int) and not isinstance(request_id, bool):+ try:+ thread_id = string_value(params.get("threadId")) or self.thread_id+ if thread_id and thread_id not in self._owned_threads:+ raise CodeValidationError(+ "Codex requested input for a conversation outside this Code session."+ )+ prompt = NativePrompt(method, request_id, params)+ except CodeValidationError as exc:+ await self._write(+ {"id": request_id, "error": {"code": -32601, "message": str(exc)}}+ )+ self._queue.put_nowait(+ HarnessEvent(+ self.generation, self.thread_id, "error", message=str(exc)+ )+ )+ return+ self._requests[request_id] = prompt+ request = prompt.request()+ if thread_id != self.thread_id:+ request = replace(+ request,+ turn_id=None,+ form={+ **request.form,+ "detail": "A Codex subagent needs your input.\n"+ + string_value(request.form.get("detail")),+ },+ )+ self._queue.put_nowait(+ HarnessEvent(+ self.generation,+ self.thread_id,+ "prompt",+ turn_id=request.turn_id,+ prompt=request,+ )+ )+ return+ event = self._protocol.notification(method, params)+ if event is not None:+ if event.kind == "resolved" and event.request_id is not None:+ self._requests.pop(event.request_id, None)+ if event.thread_id in self._owned_threads:+ event = replace(event, thread_id=self.thread_id)+ if event.kind == "turn_completed":+ for key, prompt in tuple(self._requests.items()):+ if (+ prompt.params.get("turnId") == event.turn_id+ and prompt.params.get("threadId") == event.thread_id+ ):+ self._requests.pop(key, None)+ if (+ event.thread_id != self.thread_id+ and event.thread_id in self._owned_threads+ ):+ self._queue.put_nowait(+ HarnessEvent(+ self.generation,+ self.thread_id,+ "resolved",+ request_id=key,+ )+ )+ self._queue.put_nowait(event)++ async def _dispatch(self) -> None:+ while (event := await self._queue.get()) is not None:+ await self._sink(event)++ async def _read_stderr(self) -> None:+ assert self.process.stderr is not None+ while chunk := await self.process.stderr.read(8192):+ self._stderr_tail.extend(chunk)+ del self._stderr_tail[:-16384]++ def _redact(self, text: str) -> str:+ for key, value in self._env.items():+ if value and any(+ part in key.upper()+ for part in ("TOKEN", "API_KEY", "PASSWORD", "SECRET")+ ):+ text = text.replace(value, "[redacted]")+ return text++ async def close(self) -> None:+ if asyncio.current_task() is self._dispatcher:+ await self._reap_owned_process()+ return+ if self._closing is None:+ self._closing = asyncio.create_task(+ self._close(),+ name="fcc-codex-close",+ )+ await asyncio.shield(self._closing)++ async def _close(self) -> None:+ await self._reap_owned_process()+ if self._reader is not None:+ await self._reader+ if self._dispatcher is not None:+ await self._dispatcher++ async def _reap_owned_process(self) -> None:+ if self._reaping is None:+ self._reaping = asyncio.create_task(self._reap(), name="fcc-codex-reap")+ await asyncio.shield(self._reaping)++ async def _reap(self) -> None:+ process = self._process+ if process is not None:+ if process.stdin is not None:+ process.stdin.close()+ try:+ async with asyncio.timeout(5):+ await process.wait()+ except TimeoutError:+ await self._kill_tree(process)+ if self._stderr is not None:+ await self._stderr+ unregister_pid(process.pid)+ self._alive = False+ self._resources.close()++ @staticmethod+ async def _kill_tree(process: asyncio.subprocess.Process) -> None:+ if process.returncode is not None:+ return+ if os.name == "nt":+ killer = await asyncio.create_subprocess_exec(+ "taskkill",+ "/PID",+ str(process.pid),+ "/T",+ "/F",+ stdout=asyncio.subprocess.DEVNULL,+ stderr=asyncio.subprocess.DEVNULL,+ creationflags=subprocess.CREATE_NO_WINDOW,+ )+ await killer.wait()+ else:+ with suppress(ProcessLookupError):+ os.killpg(process.pid, signal.SIGKILL)+ if process.returncode is None:+ with suppress(ProcessLookupError):+ process.kill()+ await process.wait()+++@dataclass(frozen=True, slots=True)+class _CodexSelection:+ context: LaunchContext+ model: str+ configuration_key: str+ fingerprints: dict[str, str]+ reasoning_effort: str | None++ async def open(self, cwd: str, sink: EventSink) -> CodexAppServer:+ resources = ExitStack()+ try:+ prepared = prepare_codex_launch(+ self.context,+ [+ "-c",+ "features.default_mode_request_user_input=true",+ "-c",+ "tools.experimental_request_user_input.enabled=true",+ "app-server",+ ],+ LaunchResources(resources),+ )+ connection = CodexAppServer(+ prepared.command,+ prepared.env,+ cwd,+ sink,+ model_slugs={+ model.provider_model_ref: model.wire_slug+ for model in self.context.models+ },+ fingerprints=self.fingerprints,+ reasoning={+ model.provider_model_ref: model.supports_reasoning is not False+ for model in self.context.models+ },+ resources=resources,+ )+ await connection.start()+ return connection+ except BaseException:+ resources.close()+ raise+++class CodexHarnessFactory:+ def __init__(+ self,+ runtime: RequestRuntimePort,+ *,+ binary: str | None = None,+ env: Mapping[str, str] | None = None,+ ) -> None:+ self._runtime, self._binary, self._env = runtime, binary, env++ def availability(self) -> tuple[bool, str | None]:+ if self._binary or shutil.which("codex"):+ return True, None+ return False, "Codex is not installed. " + SPEC.install_hint++ def catalog(self) -> CodeCatalog:+ settings = self._runtime.current_settings()+ models = current_codex_models(self._runtime, settings)+ entries = array_value(build_codex_model_catalog(models).get("models"))+ return CodeCatalog(+ settings.model,+ tuple(+ _model_option(model.provider_model_ref, object_value(entry))+ for model, entry in zip(models, entries, strict=True)+ ),+ )++ def prepare(self, model: str, reasoning_effort: str | None) -> _CodexSelection:+ binary = self._binary or shutil.which("codex")+ if binary is None:+ raise CodeUnavailableError("Codex is not installed. " + SPEC.install_hint)+ settings = self._runtime.current_settings()+ models = current_codex_models(self._runtime, settings)+ selected = next(+ (+ candidate+ for candidate in models+ if candidate.provider_model_ref == model+ ),+ None,+ )+ if selected is None:+ raise CodeValidationError(+ "This model is unavailable. Choose another model."+ )+ catalog = build_codex_model_catalog(models)+ entries = {+ string_value(entry.get("slug")): entry+ for value in array_value(catalog.get("models"))+ if (entry := object_value(value))+ }+ option = _model_option(model, entries[selected.wire_slug])+ if (+ reasoning_effort is not None+ and reasoning_effort not in option.reasoning_efforts+ ):+ raise CodeValidationError(+ "This reasoning effort is unavailable. Choose another effort or Model default."+ )+ effort = reasoning_effort or option.default_reasoning_effort+ fingerprints = {+ model.provider_model_ref: _fingerprint(entries[model.wire_slug])+ for model in models+ }+ context = LaunchContext(+ binary,+ settings.model_copy(update={"model": model}),+ local_proxy_root_url(settings),+ settings.proxy_auth_token,+ dict(self._env if self._env is not None else os.environ),+ models,+ )+ return _CodexSelection(+ context, model, fingerprints[model], fingerprints, effort+ )++ async def open_history(self, cwd: str, sink: EventSink) -> CodexAppServer:+ binary = self._binary or shutil.which("codex")+ if binary is None:+ raise CodeUnavailableError(+ "Codex is needed to remove its native conversation. "+ + SPEC.install_hint+ )+ connection = CodexAppServer(+ [binary, "app-server"],+ dict(self._env if self._env is not None else os.environ),+ cwd,+ sink,+ )+ await connection.start()+ return connection+++def _model_option(model: str, entry: JsonObject) -> CodeModel:+ return CodeModel(+ id=model,+ display_name=string_value(entry.get("display_name")) or model,+ reasoning_efforts=tuple(+ string_value(object_value(level).get("effort"))+ for level in array_value(entry.get("supported_reasoning_levels"))+ ),+ default_reasoning_effort=string_value(entry.get("default_reasoning_level"))+ or None,+ )+++def _fingerprint(entry: JsonObject) -> str:+ behavior = {+ key: value+ for key, value in entry.items()+ if key not in {"display_name", "description", "priority", "visibility"}+ }+ return hashlib.sha256(+ json.dumps(behavior, sort_keys=True, ensure_ascii=True).encode()+ ).hexdigest()diff --git a/src/free_claude_code/runtime/codex_catalog.py b/src/free_claude_code/runtime/codex_catalog.pyindex 2ff30612..1da9354d 100644--- a/src/free_claude_code/runtime/codex_catalog.py+++ b/src/free_claude_code/runtime/codex_catalog.py@@ -11,8 +11,26 @@ from free_claude_code.cli.launchers.codex_model_catalog import (build_codex_model_catalog,write_codex_model_catalog,)-from free_claude_code.cli.launchers.model_catalog import client_models_from_response+from free_claude_code.cli.launchers.model_catalog import (+ ClientModel,+ client_models_from_response,+)from free_claude_code.config.paths import codex_model_catalog_path+from free_claude_code.config.settings import Settings+++def current_codex_models(+ runtime: RequestRuntimePort, settings: Settings | None = None+) -> tuple[ClientModel, ...]:+ """Read the current FCC inventory without a request to the server itself."""+ response = build_models_list_response(+ settings or runtime.current_settings(),+ runtime,+ view=ModelCatalogView.RESPONSES,+ )+ return client_models_from_response(+ response.model_dump(by_alias=True, exclude_none=True)+ )class CodexModelCatalogPublisher:@@ -39,16 +57,7 @@ class CodexModelCatalogPublisher:runtime: RequestRuntimePort,catalog_path: Path,) -> None:- models_response = build_models_list_response(- runtime.current_settings(),- runtime,- view=ModelCatalogView.RESPONSES,- )- catalog = build_codex_model_catalog(- client_models_from_response(- models_response.model_dump(by_alias=True, exclude_none=True)- )- )+ catalog = build_codex_model_catalog(current_codex_models(runtime))models = catalog.get("models")if not isinstance(models, list) or not models:raise ValueError("Codex model catalog contains no routable models.")diff --git a/src/free_claude_code/runtime/codex_protocol.py b/src/free_claude_code/runtime/codex_protocol.pynew file mode 100644index 00000000..e9bf8978--- /dev/null+++ b/src/free_claude_code/runtime/codex_protocol.py@@ -0,0 +1,603 @@+"""Codex app-server v2 item and interactive-request projection."""++import json+import math+from dataclasses import dataclass, field++from jsonschema import FormatChecker++from free_claude_code.application.code_sessions.models import (+ CodeValidationError,+ HarnessEvent,+ ItemUpdate,+ NativeThread,+ NativeTurn,+ PromptRequest,+ RunStatus,+)+from free_claude_code.core.json_types import JsonObject, JsonValue+++def object_value(value: object) -> JsonObject:+ return dict(value) if isinstance(value, dict) else {}+++def array_value(value: object) -> list[JsonValue]:+ return list(value) if isinstance(value, list | tuple) else []+++def string_value(value: object) -> str:+ return value if isinstance(value, str) else ""+++def pretty(value: object) -> str:+ return json.dumps(value, ensure_ascii=False, indent=2)+++@dataclass(slots=True)+class _Item:+ raw: JsonObject = field(default_factory=dict)+ text: str = ""+ output: str = ""+ summary: dict[int, str] = field(default_factory=dict)+ reasoning: dict[int, str] = field(default_factory=dict)+++class CodexProtocol:+ def __init__(self, generation: str) -> None:+ self.generation = generation+ self._items: dict[tuple[str, str], _Item] = {}++ def notification(self, method: str, params: JsonObject) -> HarnessEvent | None:+ thread_id = string_value(params.get("threadId")) or None+ turn = object_value(params.get("turn"))+ turn_id = (+ string_value(params.get("turnId")) or string_value(turn.get("id")) or None+ )+ if method in {"turn/started", "turn/completed"}:+ status: RunStatus = "completed"+ if turn.get("status") == "interrupted":+ status = "interrupted"+ elif turn.get("status") == "failed":+ status = "failed"+ return HarnessEvent(+ self.generation,+ thread_id,+ "turn_started" if method == "turn/started" else "turn_completed",+ turn_id=turn_id,+ status=status,+ message=string_value(object_value(turn.get("error")).get("message"))+ or None,+ error_details=object_value(turn.get("error")),+ )+ if method == "error":+ return HarnessEvent(+ self.generation,+ thread_id,+ "error",+ turn_id=turn_id,+ message=string_value(object_value(params.get("error")).get("message")),+ will_retry=params.get("willRetry") is True,+ error_details=object_value(params.get("error")),+ )+ if method == "serverRequest/resolved":+ request_id = params.get("requestId")+ if isinstance(request_id, str | int) and not isinstance(request_id, bool):+ return HarnessEvent(+ self.generation, thread_id, "resolved", request_id=request_id+ )+ return None+ if not thread_id or not turn_id:+ return None+ raw = object_value(params.get("item"))+ 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())+ complete = method == "item/completed"+ delta = string_value(params.get("delta"))+ if method in {"item/started", "item/completed"}:+ item.raw = {**item.raw, **raw}+ elif method == "item/agentMessage/delta":+ item.raw.setdefault("type", "agentMessage")+ item.text += delta+ elif method in {+ "item/reasoning/summaryTextDelta",+ "item/reasoning/textDelta",+ "item/reasoning/summaryPartAdded",+ }:+ item.raw.setdefault("type", "reasoning")+ summary = method != "item/reasoning/textDelta"+ index = params.get("summaryIndex" if summary else "contentIndex", 0)+ if not isinstance(index, int) or isinstance(index, bool) or index < 0:+ return None+ parts = item.summary if summary else item.reasoning+ parts[index] = parts.get(index, "") + delta+ elif method in {+ "item/commandExecution/outputDelta",+ "item/fileChange/outputDelta",+ }:+ item.raw.setdefault(+ "type", "fileChange" if "fileChange" in method else "commandExecution"+ )+ item.output += delta+ elif method == "item/fileChange/patchUpdated":+ item.raw["changes"] = params.get("changes", [])+ elif method == "item/mcpToolCall/progress":+ item.output += string_value(params.get("message")) + "\n"+ else:+ return None+ return HarnessEvent(+ self.generation,+ thread_id,+ "item",+ turn_id=turn_id,+ item=self._project(turn_id, item_id, item, complete),+ )++ def history(self, payload: JsonObject) -> NativeThread:+ thread = object_value(payload.get("thread"))+ thread_id = string_value(thread.get("id"))+ if not thread_id:+ raise CodeValidationError("Codex did not return a conversation ID.")+ turns: list[NativeTurn] = []+ for raw_turn in array_value(thread.get("turns")):+ turn = object_value(raw_turn)+ turn_id = string_value(turn.get("id"))+ items: list[ItemUpdate] = []+ for value in array_value(turn.get("items")):+ raw = object_value(value)+ 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}+ items.append(self._project(turn_id, item_id, accumulated, True))+ if turn_id:+ error = object_value(turn.get("error"))+ status: RunStatus = (+ "failed"+ if turn.get("status") == "failed"+ else "interrupted"+ if turn.get("status") == "interrupted"+ else "completed"+ )+ turns.append(+ NativeTurn(+ turn_id,+ tuple(items),+ status,+ string_value(error.get("message")) or None,+ error,+ )+ )+ return NativeThread(thread_id, tuple(turns))++ @staticmethod+ def _project(turn_id: str, item_id: str, item: _Item, complete: bool) -> ItemUpdate:+ raw = item.raw+ native_kind = string_value(raw.get("type"))+ kind, text, title, detail = "tool", "", native_kind, ""+ if native_kind == "userMessage":+ kind = "user"+ text = "\n".join(+ string_value(object_value(value).get("text"))+ for value in array_value(raw.get("content"))+ )+ elif native_kind == "agentMessage":+ kind = "text"+ text = (+ string_value(raw.get("text"))+ if complete and "text" in raw+ else item.text or string_value(raw.get("text"))+ )+ questions = array_value(raw.get("questions"))+ if questions:+ detail = "\n\n".join(+ string_value(object_value(question).get("title"))+ for question in questions+ )+ elif native_kind == "reasoning":+ kind, title = "reasoning", "Thinking"+ summary = [string_value(value) for value in array_value(raw.get("summary"))]+ content = [string_value(value) for value in array_value(raw.get("content"))]+ if not any(summary):+ summary = [value for _, value in sorted(item.summary.items())]+ if not any(content):+ content = [value for _, value in sorted(item.reasoning.items())]+ text = "\n\n".join(value for value in [*summary, *content] if value)+ elif native_kind == "commandExecution":+ title = string_value(raw.get("command")) or "Command"+ output = string_value(raw.get("aggregatedOutput")) or item.output+ detail = "\n".join(+ value+ for value in [+ string_value(raw.get("cwd")),+ output,+ f"Exit code: {raw['exitCode']}"+ if raw.get("exitCode") is not None+ else "",+ ]+ if value+ )+ elif native_kind == "fileChange":+ kind, title = "tool", "File changes"+ changes = []+ for value in array_value(raw.get("changes")):+ change = object_value(value)+ changes.append(+ "\n".join(+ [+ string_value(change.get("path")),+ string_value(change.get("diff")),+ ]+ )+ )+ detail = "\n\n".join(changes) or item.output+ elif native_kind == "mcpToolCall":+ title = ".".join(+ value+ for value in [+ string_value(raw.get("server")),+ string_value(raw.get("tool")),+ ]+ if value+ )+ detail = "\n\n".join(+ value+ for value in [+ pretty(raw.get("arguments")),+ pretty(raw.get("result")) if raw.get("result") is not None else "",+ pretty(raw.get("error")) if raw.get("error") else "",+ item.output,+ ]+ if value+ )+ else:+ title = native_kind or "Native item"+ detail = pretty(raw)+ source: JsonObject = {+ "item": dict(raw),+ "stream": {+ "text": item.text,+ "output": item.output,+ "summary": {+ str(index): value for index, value in sorted(item.summary.items())+ },+ "reasoning": {+ str(index): value for index, value in sorted(item.reasoning.items())+ },+ },+ }+ return ItemUpdate(+ turn_id,+ item_id,+ kind,+ text=text,+ title=title,+ detail=detail,+ raw=source,+ complete=complete,+ client_id=string_value(raw.get("clientId")) or None,+ )+++class NativePrompt:+ def __init__(self, method: str, request_id: str | int, params: JsonObject) -> None:+ self.method, self.request_id, self.params = method, request_id, params+ self.decisions: list[JsonValue] = []+ self.grants: dict[str, tuple[str, JsonValue]] = {}+ self.kind, self.form = self._form()++ def request(self) -> PromptRequest:+ return PromptRequest(+ self.request_id,+ self.kind,+ self.form,+ dict(self.params),+ string_value(self.params.get("turnId")) or None,+ string_value(self.params.get("itemId")) or None,+ )++ def _form(self) -> tuple[str, JsonObject]:+ params = self.params+ if self.method in {+ "item/commandExecution/requestApproval",+ "item/fileChange/requestApproval",+ }:+ offered = params.get("availableDecisions")+ self.decisions = (+ array_value(offered)+ if isinstance(offered, list)+ else ["accept", "acceptForSession", "decline", "cancel"]+ )+ labels = {+ "accept": "Allow once",+ "acceptForSession": "Allow for this session",+ "decline": "Decline",+ "cancel": "Cancel turn",+ }+ choices: list[JsonValue] = []+ for index, decision in enumerate(self.decisions):+ if isinstance(decision, str):+ label = labels.get(decision, decision)+ elif "acceptWithExecpolicyAmendment" in object_value(decision):+ amendment = object_value(+ object_value(decision).get("acceptWithExecpolicyAmendment")+ )+ label = "Allow and remember command prefix: " + " ".join(+ string_value(value)+ for value in array_value(amendment.get("execpolicy_amendment"))+ )+ else:+ label = "Apply requested network rule: " + pretty(decision)+ choices.append({"id": str(index), "label": label})+ details = [+ string_value(params.get(key))+ for key in ("command", "cwd", "grantRoot", "reason")+ ]+ if params.get("additionalPermissions"):+ details.append(pretty(params["additionalPermissions"]))+ return "approval", {+ "title": "Permission requested",+ "detail": "\n".join(value for value in details if value),+ "choices": choices,+ }+ if self.method == "item/tool/requestUserInput":+ questions: list[JsonValue] = []+ for value in array_value(params.get("questions")):+ question = object_value(value)+ questions.append(+ {+ "id": question.get("id"),+ "label": question.get("question"),+ "header": question.get("header"),+ "options": question.get("options"),+ "allow_other": question.get("isOther", False),+ "secret": question.get("isSecret", False),+ }+ )+ return "questions", {+ "title": "Codex needs your input",+ "questions": questions,+ }+ if self.method == "item/permissions/requestApproval":+ permissions = object_value(params.get("permissions"))+ choices: list[JsonValue] = []+ if object_value(permissions.get("network")).get("enabled") is True:+ self.grants["network"] = ("network", {"enabled": True})+ choices.append({"id": "network", "label": "Network access"})+ files = object_value(permissions.get("fileSystem"))+ for access in ("read", "write", "entries"):+ for index, grant in enumerate(array_value(files.get(access))):+ if (+ access == "entries"+ and object_value(grant).get("access") == "deny"+ ):+ continue+ key = f"{access}:{index}"+ self.grants[key] = (access, grant)+ label = (+ f"{access.title()}: {grant}"+ if access != "entries"+ else pretty(grant)+ )+ choices.append({"id": key, "label": label})+ return "permissions", {+ "title": "Additional permissions",+ "detail": string_value(params.get("reason")),+ "choices": choices,+ }+ if self.method == "mcpServer/elicitation/request":+ mode = params.get("mode")+ form: JsonObject = {+ "title": string_value(params.get("serverName")) or "Tool question",+ "detail": string_value(params.get("message")),+ }+ if mode == "url":+ form["url"] = params.get("url")+ return "url", form+ schema = object_value(params.get("requestedSchema"))+ fields: list[JsonValue] = []+ unsupported = mode != "form" or schema.get("type") != "object"+ required = array_value(schema.get("required"))+ for name, value in object_value(schema.get("properties")).items():+ definition = object_value(value)+ field_type = string_value(definition.get("type"))+ if field_type not in {+ "string",+ "integer",+ "number",+ "boolean",+ "array",+ }:+ unsupported = True+ choices = _enum_options(definition)+ if field_type == "array" and (+ not choices+ or any(+ not isinstance(object_value(choice).get("value"), str)+ for choice in choices+ )+ ):+ unsupported = True+ fields.append(+ {+ "id": name,+ "label": definition.get("title", name),+ "description": definition.get("description"),+ "type": field_type,+ "required": name in required,+ "options": choices,+ "default": definition.get("default"),+ "minimum": definition.get("minimum"),+ "maximum": definition.get("maximum"),+ "minLength": definition.get("minLength"),+ "maxLength": definition.get("maxLength"),+ }+ )+ form.update({"fields": fields, "unsupported": unsupported})+ return "form", form+ raise CodeValidationError(f"Unsupported native interaction: {self.method}")++ def answer(self, answer: JsonObject) -> JsonObject:+ if self.kind == "approval":+ choice = answer.get("choice")+ if not isinstance(choice, str) or choice not in {+ str(index) for index in range(len(self.decisions))+ }:+ raise CodeValidationError("Choose one of the offered decisions.")+ return {"decision": self.decisions[int(choice)]}+ if self.kind == "questions":+ values = object_value(answer.get("answers"))+ questions = [+ object_value(value)+ for value in array_value(self.params.get("questions"))+ ]+ if set(values) != {+ string_value(question.get("id")) for question in questions+ }:+ raise CodeValidationError("Answer each question before submitting.")+ result: JsonObject = {}+ for question in questions:+ key = string_value(question.get("id"))+ entries = array_value(values.get(key))+ if not entries or any(+ not isinstance(value, str) or not value.strip() for value in entries+ ):+ raise CodeValidationError("Answer each question before submitting.")+ options = {+ string_value(object_value(value).get("label"))+ for value in array_value(question.get("options"))+ }+ if (+ options+ and not question.get("isOther")+ and any(value not in options for value in entries)+ ):+ raise CodeValidationError("Choose an offered answer.")+ result[key] = {"answers": entries}+ return {"answers": result}+ if self.kind == "permissions":+ selected = array_value(answer.get("selected"))+ if any(+ not isinstance(value, str) or value not in self.grants+ for value in selected+ ) or answer.get("scope", "turn") not in {"turn", "session"}:+ raise CodeValidationError(+ "Choose only the requested permissions and scope."+ )+ permissions: JsonObject = {}+ files: JsonObject = {}+ requested_files = object_value(+ object_value(self.params.get("permissions")).get("fileSystem")+ )+ denies = [+ value+ for value in array_value(requested_files.get("entries"))+ if object_value(value).get("access") == "deny"+ ]+ if denies:+ files["entries"] = denies+ for key in selected:+ access, value = self.grants[string_value(key)]+ if access == "network":+ permissions["network"] = value+ else:+ files[access] = [*array_value(files.get(access)), value]+ if files:+ if requested_files.get("globScanMaxDepth") is not None:+ files["globScanMaxDepth"] = requested_files["globScanMaxDepth"]+ permissions["fileSystem"] = files+ return {"permissions": permissions, "scope": answer.get("scope", "turn")}+ action = answer.get("action")+ if action not in {"accept", "decline", "cancel"}:+ raise CodeValidationError(+ "Choose whether to answer or dismiss this prompt."+ )+ if action != "accept":+ return {"action": action, "content": None}+ if self.kind == "url":+ return {"action": "accept", "content": None}+ if self.form.get("unsupported"):+ raise CodeValidationError(+ "This tool's form is not supported. Decline or cancel it."+ )+ values = object_value(answer.get("values"))+ schema = object_value(self.params.get("requestedSchema"))+ properties = object_value(schema.get("properties"))+ if not set(values).issubset(properties) or any(+ name not in values for name in array_value(schema.get("required"))+ ):+ raise CodeValidationError("Complete the required fields.")+ for name, value in values.items():+ _validate_field(name, value, object_value(properties[name]))+ return {"action": "accept", "content": values}+++def _enum_options(definition: JsonObject) -> list[JsonValue]:+ if definition.get("type") == "array":+ definition = object_value(definition.get("items"))+ values = array_value(definition.get("enum"))+ names = array_value(definition.get("enumNames"))+ if values:+ return [+ {"value": value, "label": names[index] if index < len(names) else value}+ for index, value in enumerate(values)+ ]+ return [+ {+ "value": object_value(value).get("const"),+ "label": object_value(value).get("title"),+ }+ for value in array_value(definition.get("oneOf", definition.get("anyOf")))+ ]+++def _validate_field(name: str, value: JsonValue, definition: JsonObject) -> None:+ kind = definition.get("type")+ valid = True+ if kind == "boolean":+ valid = isinstance(value, bool)+ elif kind in {"number", "integer"}:+ valid = (+ isinstance(value, int | float)+ and not isinstance(value, bool)+ and math.isfinite(value)+ )+ if valid and kind == "integer":+ valid = isinstance(value, int)+ if valid and isinstance(value, int | float):+ minimum, maximum = definition.get("minimum"), definition.get("maximum")+ valid = (not isinstance(minimum, int | float) or value >= minimum) and (+ not isinstance(maximum, int | float) or value <= maximum+ )+ elif kind == "string":+ valid = isinstance(value, str)+ if isinstance(value, str):+ minimum, maximum = definition.get("minLength"), definition.get("maxLength")+ valid = (not isinstance(minimum, int) or len(value) >= minimum) and (+ not isinstance(maximum, int) or len(value) <= maximum+ )+ format_name = definition.get("format")+ if isinstance(format_name, str):+ valid = valid and FormatChecker().conforms(value, format_name)+ elif kind == "array":+ valid = isinstance(value, list) and all(+ isinstance(entry, str) for entry in value+ )+ if valid and isinstance(value, list):+ minimum, maximum = definition.get("minItems"), definition.get("maxItems")+ valid = (not isinstance(minimum, int) or len(value) >= minimum) and (+ not isinstance(maximum, int) or len(value) <= maximum+ )+ else:+ valid = False+ options = [+ object_value(option).get("value") for option in _enum_options(definition)+ ]+ if options:+ candidates = array_value(value) if kind == "array" else [value]+ valid = valid and all(candidate in options for candidate in candidates)+ if not valid:+ raise CodeValidationError(f"Invalid value for {name}.")diff --git a/tests/api/support.py b/tests/api/support.pyindex 60df99d3..c52dc341 100644--- a/tests/api/support.py+++ b/tests/api/support.py@@ -7,6 +7,7 @@ from fastapi import FastAPIfrom free_claude_code.api.app import create_appfrom free_claude_code.api.ports import ApiServicesfrom free_claude_code.application.chat import ChatApplicationPort+from free_claude_code.application.code_sessions import CodeApplicationPortfrom free_claude_code.application.connected_accounts import ConnectedAccountPortfrom free_claude_code.config.loader import ManagedConfigStorefrom free_claude_code.config.settings import Settings@@ -24,6 +25,7 @@ def create_test_app(restart_callback: RestartCallback | None = None,connected_accounts: Mapping[str, ConnectedAccountPort] | None = None,chat: ChatApplicationPort | None = None,+ code: CodeApplicationPort | None = None,) -> FastAPI:"""Build an API app with explicit in-memory runtime services."""store = ManagedConfigStore()@@ -65,6 +67,7 @@ def create_test_app(admin=runtime,tasks=runtime,chat=chat,+ code=code,))diff --git a/tests/api/test_admin.py b/tests/api/test_admin.pyindex 7210be08..3cd60bf7 100644--- a/tests/api/test_admin.py+++ b/tests/api/test_admin.py@@ -178,6 +178,7 @@ def test_admin_page_uses_installed_version(monkeypatch, tmp_path):("admin.js", "text/javascript"),("chat_sessions.css", "text/css"),("chat_sessions.js", "text/javascript"),+ ("session_ui.js", "text/javascript"),("model_combobox.js", "text/javascript"),),)diff --git a/tests/api/test_chat_markdown.py b/tests/api/test_chat_markdown.pyindex fdee0d7e..4e65ff0f 100644--- a/tests/api/test_chat_markdown.py+++ b/tests/api/test_chat_markdown.py@@ -1,8 +1,8 @@-from free_claude_code.api.chat_markdown import render_chat_markdown+from free_claude_code.api.markdown import render_markdowndef test_chat_markdown_escapes_html_and_never_loads_remote_images():- rendered = render_chat_markdown(+ rendered = render_markdown('<script>alert("x")</script>\n\n')@@ -14,7 +14,7 @@ def test_chat_markdown_escapes_html_and_never_loads_remote_images():def test_chat_markdown_disables_non_http_links():- rendered = render_chat_markdown("[unsafe](javascript:alert(1))")+ rendered = render_markdown("[unsafe](javascript:alert(1))")assert "href=" not in renderedassert "unsafe" in rendereddiff --git a/tests/api/test_chat_routes.py b/tests/api/test_chat_routes.pyindex 2458b48d..dd9df64e 100644--- a/tests/api/test_chat_routes.py+++ b/tests/api/test_chat_routes.py@@ -8,13 +8,11 @@ from free_claude_code.application.chat import (ChatActiveOperation,ChatCompaction,ChatContextEstimate,- ChatEventOverflowError,ChatModelOption,ChatOperationAcknowledgement,ChatOperationKind,ChatOperationPhase,ChatPreferences,- ChatPublishedEvent,ChatReasoning,ChatSegment,ChatSession,@@ -27,6 +25,10 @@ from free_claude_code.application.chat import (SegmentKind,)from free_claude_code.application.chat.models import ChatGeneration+from free_claude_code.application.session_events import (+ EventOverflowError,+ PublishedEvent,+)from free_claude_code.core.model_capabilities import ModelInputModalityfrom tests.api.support import create_test_app@@ -44,7 +46,7 @@ class StubSubscription:return self._events()async def _events(self):- yield ChatPublishedEvent(+ yield PublishedEvent(event="turn.completed",id=5,data={@@ -65,7 +67,7 @@ class OverflowSubscription(StubSubscription):async def _events(self):if False:yield- raise ChatEventOverflowError(9)+ raise EventOverflowError(9)class StubChat:diff --git a/tests/api/test_code_sessions_routes.py b/tests/api/test_code_sessions_routes.pynew file mode 100644index 00000000..ead849da--- /dev/null+++ b/tests/api/test_code_sessions_routes.py@@ -0,0 +1,126 @@+import asyncio+import uuid++import httpx+import pytest+import pytest_asyncio++from free_claude_code.application.code_sessions import CodeService+from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore+from tests.api.support import create_test_app+from tests.code_sessions_support import FakeHarness+++@pytest_asyncio.fixture+async def code_api(tmp_path):+ harness = FakeHarness()+ code = CodeService(+ SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock"), harness+ )+ await code.start()+ app = create_test_app(code=code)+ try:+ async with httpx.AsyncClient(+ transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1"+ ) as client:+ yield client, code, harness, tmp_path, app+ finally:+ await code.close()+ await app.state.services.admin.close()+++async def create_session(code_api):+ client, _, _, folder, _ = code_api+ response = await client.post(+ "/admin/api/code/sessions",+ json={"session_id": str(uuid.uuid4()), "cwd": str(folder), "harness": "codex"},+ )+ assert response.status_code == 201+ return response.json()+++async def test_code_library_has_one_harness_and_no_native_work_on_open(code_api):+ client, _, harness, _, _ = code_api+ bootstrap = await client.get("/admin/api/code/bootstrap")+ assert bootstrap.json()["harnesses"] == [{"id": "codex", "name": "Codex"}]+ session = await create_session(code_api)+ detail = await client.get(f"/admin/api/code/sessions/{session['id']}")+ assert detail.status_code == 200+ assert detail.headers["cache-control"] == "no-store"+ assert detail.json()["items"] == []+ assert harness.connections == []+ page = await client.get(f"/admin/code/{session['id']}")+ assert page.status_code == 200+++async def test_http_send_competition_and_safe_item_projection(code_api):+ client, code, harness, _, _ = code_api+ session = await create_session(code_api)+ path = f"/admin/api/code/sessions/{session['id']}"+ responses = await asyncio.gather(+ *(+ client.post(+ path + "/turns",+ json={+ "operation_id": str(uuid.uuid4()),+ "expected_revision": session["revision"],+ "expected_epoch": code.epoch,+ "text": text,+ },+ )+ for text in ("one", "two")+ )+ )+ assert sorted(response.status_code for response in responses) == [202, 409]+ await harness.started.wait()+ await harness.connections[0].text(+ "turn-1", "answer", "**safe** <script>bad()</script>", complete=True+ )+ await harness.connections[0].finish("turn-1")+ detail = (await client.get(path)).json()+ item = detail["items"][-1]+ assert "<strong>safe</strong>" in item["html"]+ assert "<script>" not in item["html"]+ assert "raw" not in item+ assert detail["run"]["status"] == "completed"+++async def test_code_commands_reject_unplanned_fields_and_other_harnesses(code_api):+ client, code, _, folder, _ = code_api+ response = await client.post(+ "/admin/api/code/sessions",+ json={"session_id": str(uuid.uuid4()), "cwd": str(folder), "harness": "cline"},+ )+ assert response.status_code == 422+ session = await create_session(code_api)+ response = await client.post(+ f"/admin/api/code/sessions/{session['id']}/turns",+ json={+ "operation_id": str(uuid.uuid4()),+ "expected_revision": session["revision"],+ "expected_epoch": code.epoch,+ "text": "hi",+ "model": "override",+ },+ )+ assert response.status_code == 422+++ "headers", [{"host": "remote.example"}, {"origin": "https://remote.example"}]+)+async def test_code_routes_share_admin_access_boundary(code_api, headers):+ client, _, harness, _, _ = code_api+ for path in (+ "/admin/code",+ "/admin/api/code/bootstrap",+ "/admin/api/code/sessions",+ "/admin/api/code/events",+ ):+ response = await client.get(path, headers=headers)+ assert response.status_code == 403+ assert harness.connections == []diff --git a/tests/application/test_chat_events.py b/tests/application/test_chat_events.pyindex a41ae74b..3f6f7f38 100644--- a/tests/application/test_chat_events.py+++ b/tests/application/test_chat_events.py@@ -2,13 +2,15 @@ import asyncioimport pytest-from free_claude_code.application.chat import ChatEventOverflowError-from free_claude_code.application.chat.events import ChatEventPublisher+from free_claude_code.application.session_events import (+ EventOverflowError,+ EventPublisher,+)@pytest.mark.asyncioasync def test_subscribers_receive_the_same_ordered_events_independently() -> None:- publisher = ChatEventPublisher(queue_size=4)+ publisher = EventPublisher(queue_size=4)first = publisher.subscribe()second = publisher.subscribe()first_events = first.__aiter__()@@ -34,7 +36,7 @@ async def test_subscribers_receive_the_same_ordered_events_independently() -> No@pytest.mark.asyncioasync def test_slow_subscriber_overflow_does_not_block_a_healthy_subscriber() -> None:- publisher = ChatEventPublisher(queue_size=2)+ publisher = EventPublisher(queue_size=2)slow = publisher.subscribe()healthy = publisher.subscribe()slow_events = slow.__aiter__()@@ -47,7 +49,7 @@ async def test_slow_subscriber_overflow_does_not_block_a_healthy_subscriber() ->)assert await asyncio.wait_for(anext(healthy_events), timeout=1) == published- with pytest.raises(ChatEventOverflowError) as raised:+ with pytest.raises(EventOverflowError) as raised:await asyncio.wait_for(anext(slow_events), timeout=1)assert raised.value.cursor == 3@@ -60,7 +62,7 @@ async def test_slow_subscriber_overflow_does_not_block_a_healthy_subscriber() ->@pytest.mark.asyncioasync def test_publisher_close_releases_every_waiting_subscription() -> None:- publisher = ChatEventPublisher()+ publisher = EventPublisher()first = publisher.subscribe().__aiter__()second = publisher.subscribe().__aiter__()diff --git a/tests/application/test_code_sessions.py b/tests/application/test_code_sessions.pynew file mode 100644index 00000000..836d0896--- /dev/null+++ b/tests/application/test_code_sessions.py@@ -0,0 +1,1005 @@+import asyncio+import uuid++import pytest+import pytest_asyncio++from free_claude_code.application.code_sessions import CodeConflictError, CodeService+from free_claude_code.application.code_sessions.models import (+ CodeUnavailableError,+ CodeValidationError,+ HarnessEvent,+ ItemUpdate,+)+from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore+from tests.code_sessions_support import FakeConnection, FakeHarness+++def new_id():+ return str(uuid.uuid4())+++@pytest_asyncio.fixture+async def code(tmp_path):+ harness = FakeHarness()+ store = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")+ service = CodeService(store, harness)+ await service.start()+ try:+ yield service, harness, tmp_path+ finally:+ await service.close()+++async def session_for(code):+ service, _, directory = code+ return await service.create_session(new_id(), str(directory))+++async def test_selected_model_and_effort_are_session_settings_captured_on_send(code):+ service, harness, _ = code+ harness.configurations["provider/other"] = "other"+ session = await session_for(code)+ for effort in (None, "high", None):+ session = await service.update_settings(+ session.id,+ session.revision,+ {"model": "provider/other", "reasoning_effort": effort},+ )+ run = await service.send(+ session.id,+ new_id(),+ session.revision,+ "hello",+ expected_epoch=service.epoch,+ )+ await harness.wait_inputs(run.ordinal)+ connection = harness.connections[0]+ with pytest.raises(CodeConflictError):+ await service.update_settings(+ session.id, session.revision + 1, {"reasoning_effort": "low"}+ )+ await connection.finish(f"turn-{run.ordinal}")+ session = (await service.get_detail(session.id)).session+ assert connection.efforts == ["medium", "high", "medium"]+ assert {value[2] for value in connection.inputs} == {"provider/other"}+ assert len(harness.connections) == 1+ harness.configurations.pop("provider/other")+ with pytest.raises(CodeValidationError, match="unavailable"):+ await service.send(+ session.id,+ new_id(),+ session.revision,+ "kept draft",+ expected_epoch=service.epoch,+ )+ assert (await service.get_detail(session.id)).session.model == "provider/other"+++async def test_catalog_effort_removal_requires_choice_but_model_change_resolves_default(+ code,+):+ service, harness, _ = code+ session = await session_for(code)+ session = await service.update_settings(+ session.id, session.revision, {"reasoning_effort": "xhigh"}+ )+ harness.efforts = ("low", "medium")+ with pytest.raises(CodeValidationError, match="effort"):+ await service.send(+ session.id,+ new_id(),+ session.revision,+ "hello",+ expected_epoch=service.epoch,+ )+ harness.configurations["provider/other"] = "other"+ session = await service.update_settings(+ session.id, session.revision, {"model": "provider/other"}+ )+ assert session.reasoning_effort is None+ assert session.model == "provider/other"+++async def test_failed_outcome_is_durable_once_after_partial_output_and_older_pagination(+ code,+):+ service, harness, _ = code+ session = await session_for(code)+ run = await service.send(+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch+ )+ await harness.started.wait()+ connection = harness.connections[0]+ for kind in ("text", "reasoning", "tool"):+ await connection.text("turn-1", kind, f"partial {kind}", kind=kind)+ await connection.finish("turn-1", "failed", "Provider rejected the request")+ await connection.finish("turn-1", "failed", "duplicate")+ detail = await service.get_detail(session.id)+ assert detail.session.error is None+ assert detail.runs == (detail.run,)+ assert detail.run.error == "Provider rejected the request"+ assert [item.text for item in detail.items] == [+ "first",+ "partial text",+ "partial reasoning",+ "partial tool",+ ]+ await service.send(+ session.id,+ new_id(),+ detail.session.revision,+ "second",+ expected_epoch=service.epoch,+ )+ await harness.wait_inputs(2)+ for index in range(55):+ await connection.text("turn-2", str(index), str(index), complete=True)+ active = await service.get_detail(session.id)+ assert active.items[0].text == "first"+ assert len(active.items) == 60+ await connection.finish("turn-2")+ latest = await service.get_detail(session.id)+ assert run.id not in {value.id for value in latest.runs}+ older = await service.get_detail(session.id, before=latest.next_before)+ assert (+ next(value for value in older.runs if value.id == run.id).error+ == detail.run.error+ )+++async def test_retry_notice_does_not_finish_run_and_stale_error_is_ignored(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch+ )+ await harness.started.wait()+ connection = harness.connections[0]+ await connection.sink(+ HarnessEvent(+ connection.generation,+ connection.thread_id,+ "error",+ turn_id="turn-1",+ message="retry",+ will_retry=True,+ )+ )+ assert (await service.get_detail(session.id)).run.status == "running"+ await connection.text("turn-1", "text", "success", complete=True)+ await connection.finish("turn-1")+ subscription, _ = await service.subscribe()+ cursor = service.cursor+ await connection.sink(+ HarnessEvent(+ connection.generation,+ connection.thread_id,+ "error",+ turn_id="turn-1",+ message="stale",+ )+ )+ assert service.cursor == cursor+ await subscription.aclose()+ assert (await service.get_detail(session.id)).run.error is None++[email protected]("client_id", [True, False])+async def test_acknowledgement_loss_recovers_old_turn_before_newer_send(+ code, client_id+):+ service, harness, _ = code+ session = await session_for(code)+ harness.start_gate.clear()+ first = await service.send(+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch+ )+ await harness.submitted.wait()+ connection = harness.connections[0]+ harness.histories[connection.thread_id] = [+ ItemUpdate(+ "turn-1",+ "native-user",+ "user",+ text="first",+ complete=True,+ client_id=first.id if client_id else None,+ ),+ ItemUpdate("turn-1", "tail", "text", text="recovered tail", complete=True),+ ]+ await connection.close()+ await service.wait_idle(session.id)+ detail = await service.get_detail(session.id)+ assert detail.run.status == "failed"+ await service.send(+ session.id,+ new_id(),+ detail.session.revision,+ "second",+ expected_epoch=service.epoch,+ )+ await harness.wait_inputs(2)+ recovered = await service.get_detail(session.id)+ assert [item.text for item in recovered.items] == [+ "first",+ "recovered tail",+ "second",+ ]+ assert recovered.runs[0].status == "failed"+ assert recovered.items[0].id == first.id+++async def test_prompt_membership_and_deleted_subscription_are_authoritative(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch+ )+ await harness.started.wait()+ connection = harness.connections[0]+ await connection.prompt(0, turn_id=None)+ detail = await service.get_detail(session.id)+ assert detail.active_prompt_ids == (detail.prompts[0].id,)+ await connection.resolve(0)+ assert (await service.get_detail(session.id)).active_prompt_ids == ()+ await connection.finish("turn-1")+ session = (await service.get_detail(session.id)).session+ await service.delete_session(session.id, session.revision)+ await service.wait_idle(session.id)+ subscription, ready = await service.subscribe()+ assert ready["sessions"] == []+ assert session.id not in service._owners+ await subscription.aclose()+++async def test_ambiguous_native_history_fails_recovery_without_resending_input(code):+ service, harness, _ = code+ session = await session_for(code)+ harness.start_gate.clear()+ await service.send(+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch+ )+ await harness.submitted.wait()+ connection = harness.connections[0]+ harness.histories[connection.thread_id] = [+ ItemUpdate(turn_id, "item", "text", text="unmatched", complete=True)+ for turn_id in ("unknown-1", "unknown-2")+ ]+ await connection.close()+ await service.wait_idle(session.id)+ detail = await service.get_detail(session.id)+ await service.send(+ session.id,+ new_id(),+ detail.session.revision,+ "second",+ expected_epoch=service.epoch,+ )+ await service.wait_idle(session.id)+ detail = await service.get_detail(session.id)+ assert detail.run.status == "failed"+ assert "could not be matched" in detail.run.error+ assert [item.text for item in detail.items] == ["first", "second"]+ assert sum(len(connection.inputs) for connection in harness.connections) == 1+++async def test_settings_and_send_compete_for_the_same_revision(code):+ service, harness, _ = code+ session = await session_for(code)+ outcomes = await asyncio.gather(+ service.update_settings(+ session.id, session.revision, {"reasoning_effort": "high"}+ ),+ service.send(+ session.id,+ new_id(),+ session.revision,+ "hello",+ expected_epoch=service.epoch,+ ),+ return_exceptions=True,+ )+ assert sum(isinstance(result, CodeConflictError) for result in outcomes) == 1+ detail = await service.get_detail(session.id)+ assert detail.session.revision == session.revision + 1+ if detail.run:+ assert detail.run.reasoning_effort == "medium"+ else:+ assert detail.session.reasoning_effort == "high"+ assert harness.connections == []+++async def test_old_service_epoch_cannot_admit_a_new_send_but_can_read_receipt(code):+ service, harness, _ = code+ session = await session_for(code)+ with pytest.raises(CodeConflictError, match="restarted"):+ await service.send(+ session.id, new_id(), session.revision, "stale", expected_epoch="previous"+ )+ assert harness.connections == []+ run = await service.send(+ session.id, new_id(), session.revision, "accepted", expected_epoch=service.epoch+ )+ repeated = await service.send(+ session.id, run.id, session.revision, "accepted", expected_epoch="previous"+ )+ assert repeated.id == run.id+++async def test_poorer_native_history_keeps_captured_source_and_reasoning(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch+ )+ await harness.started.wait()+ connection = harness.connections[0]+ original = ItemUpdate(+ "turn-1",+ "reasoning",+ "reasoning",+ text="Full captured reasoning",+ complete=True,+ raw={+ "item": {+ "id": "reasoning",+ "summary": ["original"],+ "opaque": {"signature": "retained"},+ },+ "stream": {"reasoning": {"0": "full"}},+ },+ )+ await connection.sink(+ HarnessEvent(+ connection.generation,+ connection.thread_id,+ "item",+ turn_id="turn-1",+ item=original,+ )+ )+ await connection.finish("turn-1")+ harness.histories[connection.thread_id] = [+ ItemUpdate(+ "turn-1",+ "reasoning",+ "reasoning",+ text="Shorter native history",+ complete=True,+ raw={"item": {"id": "reasoning", "summary": []}, "stream": {}},+ )+ ]+ harness.configurations[harness.model] = "changed"+ detail = await service.get_detail(session.id)+ await service.send(+ session.id,+ new_id(),+ detail.session.revision,+ "next",+ expected_epoch=service.epoch,+ )+ await harness.wait_inputs(2)+ retained = next(+ item+ for item in (await service.get_detail(session.id)).items+ if item.native_item_id == "reasoning"+ )+ assert retained.text == original.text+ assert retained.raw == original.raw+++async def test_storage_start_failure_is_isolated_to_code(tmp_path):+ class BrokenStore(SQLiteCodeStore):+ async def start(self):+ raise CodeUnavailableError("Code disk unavailable")++ service = CodeService(+ BrokenStore(tmp_path / "code.db", tmp_path / "code.lock"), FakeHarness()+ )+ try:+ await service.start()+ assert service.availability() == (False, "Code disk unavailable")+ finally:+ await service.close()+++async def test_shutdown_settles_run_when_native_interrupt_never_acknowledges(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id,+ new_id(),+ session.revision,+ "stop on shutdown",+ expected_epoch=service.epoch,+ )+ await harness.started.wait()+ harness.interrupt_gate.clear()+ await asyncio.wait_for(service.close(), 8)+ assert harness.connections[0].closed+++async def test_storage_failure_retires_native_work_even_with_pending_prompt(+ code, monkeypatch+):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "prompt", expected_epoch=service.epoch+ )+ await harness.started.wait()+ connection = harness.connections[0]+ await connection.prompt(1)++ async def fail_save(*args, **kwargs):+ raise CodeUnavailableError("Code disk unavailable")++ monkeypatch.setattr(service._store, "save_progress", fail_save)+ await connection.text("turn-1", "text", "unsaved", complete=True)+ await asyncio.wait_for(service.wait_idle(session.id), 3)+ assert connection.closed+ with pytest.raises(CodeUnavailableError):+ await service.get_detail(session.id)+++async def test_same_send_id_in_two_sessions_has_independent_receipts(code, monkeypatch):+ service, harness, _ = code+ first, second = await session_for(code), await session_for(code)+ original = service._store.get_run+ looked_up = 0+ barrier = asyncio.Event()++ async def simultaneous_lookup(session_id, run_id):+ nonlocal looked_up+ result = await original(session_id, run_id)+ looked_up += 1+ if looked_up == 2:+ barrier.set()+ await barrier.wait()+ return result++ monkeypatch.setattr(service._store, "get_run", simultaneous_lookup)+ operation = new_id()+ outcomes = await asyncio.gather(+ *(+ service.send(+ session.id,+ operation,+ session.revision,+ "once",+ expected_epoch=service.epoch,+ )+ for session in (first, second)+ ),+ return_exceptions=True,+ )+ assert {+ value.session_id for value in outcomes if not isinstance(value, BaseException)+ } == {first.id, second.id}+ await harness.wait_inputs(2)+ assert sum(len(connection.inputs) for connection in harness.connections) == 2+++async def idle_native(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "one", expected_epoch=service.epoch+ )+ await harness.started.wait()+ await harness.connections[0].finish("turn-1")+ return (await service.get_detail(session.id)).session+++async def test_deletion_fences_commands_and_repeated_delete_has_one_native_call(code):+ service, harness, folder = code+ session = await idle_native(code)+ project = folder / "project.txt"+ project.write_text("keep")+ harness.delete_gate.clear()+ await service.delete_session(session.id, session.revision)+ await harness.deleting.wait()+ await service.delete_session(session.id, session.revision)+ with pytest.raises(CodeConflictError):+ await service.send(+ session.id, new_id(), session.revision, "late", expected_epoch=service.epoch+ )+ with pytest.raises(CodeConflictError):+ await service.update_settings(session.id, session.revision, {"title": "late"})+ harness.delete_gate.set()+ await service.wait_idle(session.id)+ assert harness.connections[0].deleted == [session.native_thread_id]+ assert project.read_text() == "keep"+ assert not (await service.list_sessions()).sessions+++async def test_lost_native_delete_ack_reconciles_without_repeating_delete(code):+ service, harness, _ = code+ session = await idle_native(code)+ harness.delete_before_error = True+ harness.delete_error = CodeUnavailableError("Delete acknowledgement lost")+ await service.delete_session(session.id, session.revision)+ await service.wait_idle(session.id)+ assert not (await service.list_sessions()).sessions+ assert sum(len(connection.deleted) for connection in harness.connections) == 1+++async def test_local_delete_commit_failure_keeps_fence_and_can_reconcile(+ code, monkeypatch+):+ service, harness, _ = code+ session = await idle_native(code)+ original = service._store.delete++ async def failing_delete(session_id):+ raise CodeUnavailableError("Delete commit failed")++ monkeypatch.setattr(service._store, "delete", failing_delete)+ await service.delete_session(session.id, session.revision)+ await asyncio.wait_for(service.wait_idle(session.id), 3)+ detail = await service.get_detail(session.id)+ assert detail.session.status == "delete_uncertain"+ assert detail.items+ with pytest.raises(CodeConflictError):+ await service.send(+ session.id,+ new_id(),+ detail.session.revision,+ "late",+ expected_epoch=service.epoch,+ )+ monkeypatch.setattr(service._store, "delete", original)+ await service.delete_session(session.id, detail.session.revision)+ await service.wait_idle(session.id)+ assert not (await service.list_sessions()).sessions+ assert sum(len(connection.deleted) for connection in harness.connections) == 1+++async def test_late_old_native_events_cannot_claim_a_new_turn_before_ack(code):+ service, harness, _ = code+ session = await idle_native(code)+ connection = harness.connections[0]+ harness.start_gate.clear()+ harness.started.clear()+ await service.send(+ session.id, new_id(), session.revision, "next", expected_epoch=service.epoch+ )+ await harness.wait_inputs(2)+ await connection.sink(+ HarnessEvent(+ connection.generation,+ connection.thread_id,+ "turn_started",+ turn_id="turn-1",+ )+ )+ await connection.text("turn-1", "late", "obsolete", complete=True)+ await connection.finish("turn-1")+ detail = await service.get_detail(session.id)+ assert detail.run.status == "preparing"+ assert not any(item.text == "obsolete" for item in detail.items)+ harness.start_gate.set()+ await harness.started.wait()+ detail = await service.get_detail(session.id)+ assert detail.run.native_turn_id == "turn-2"+++async def test_creation_identity_received_during_cleanup_is_saved(code, monkeypatch):+ service, harness, _ = code+ session = await session_for(code)+ original_close = FakeConnection.close++ async def failed_create(connection):+ raise CodeUnavailableError("Native creation acknowledgement timed out")++ async def close_with_late_reply(connection):+ connection.thread_id = "late-native-id"+ harness.histories[connection.thread_id] = []+ await original_close(connection)++ monkeypatch.setattr(FakeConnection, "create_thread", failed_create)+ monkeypatch.setattr(FakeConnection, "close", close_with_late_reply)+ await service.send(+ session.id,+ new_id(),+ session.revision,+ "uncertain create",+ expected_epoch=service.epoch,+ )+ await service.wait_idle(session.id)+ detail = await service.get_detail(session.id)+ assert detail.session.native_thread_id == "late-native-id"+ assert detail.run.status == "failed"+ assert not harness.connections[0].inputs+++async def test_failed_stop_persistence_closes_work_without_waiting_for_more_output(+ code, monkeypatch+):+ service, harness, _ = code+ session = await session_for(code)+ run = await service.send(+ session.id,+ new_id(),+ session.revision,+ "quiet work",+ expected_epoch=service.epoch,+ )+ await harness.started.wait()++ async def failed_save(*args, **kwargs):+ raise CodeUnavailableError("Disk failed")++ monkeypatch.setattr(service._store, "save_progress", failed_save)+ with pytest.raises(CodeUnavailableError):+ await service.stop(session.id, run.id)+ await asyncio.wait_for(service.wait_idle(session.id), 3)+ assert harness.connections[0].closed+++async def test_create_is_lazy_and_retry_does_not_duplicate(code):+ service, harness, directory = code+ session = await session_for(code)+ repeated = await service.create_session(session.id, str(directory))+ assert repeated == session+ assert harness.connections == []+ assert len((await service.list_sessions()).sessions) == 1+++async def test_competing_sends_admit_only_one_and_repeat_returns_receipt(code):+ service, harness, _ = code+ session = await session_for(code)+ command = new_id()+ results = await asyncio.gather(+ service.send(+ session.id, command, session.revision, "first", expected_epoch=service.epoch+ ),+ service.send(+ session.id,+ new_id(),+ session.revision,+ "second",+ expected_epoch=service.epoch,+ ),+ return_exceptions=True,+ )+ assert sum(isinstance(result, CodeConflictError) for result in results) == 1+ run = results[0]+ assert not isinstance(run, BaseException)+ await harness.started.wait()+ repeat = await service.send(+ session.id, command, session.revision, "first", expected_epoch=service.epoch+ )+ assert repeat.id == run.id+ assert harness.connections[0].inputs == [(command, "first", "provider/model")]+ with pytest.raises(CodeConflictError):+ await service.send(+ session.id,+ command,+ session.revision,+ "changed",+ expected_epoch=service.epoch,+ )+++async def test_http_cancellation_does_not_cancel_native_creation(code):+ service, harness, _ = code+ session = await session_for(code)+ harness.creation_gate.clear()+ command = new_id()+ await service.send(+ session.id, command, session.revision, "continue", expected_epoch=service.epoch+ )+ await harness.creating.wait()+ # There is no HTTP-owned native waiter left to cancel after admission.+ detail = await service.get_detail(session.id)+ assert detail.run.id == command+ harness.creation_gate.set()+ await harness.started.wait()+ detail = await service.get_detail(session.id)+ assert detail.session.native_thread_id == "native-1"+ assert harness.connections[0].inputs[0][0] == command+++async def test_stop_before_native_ack_targets_that_run_only(code):+ service, harness, _ = code+ session = await session_for(code)+ harness.start_gate.clear()+ run = await service.send(+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch+ )+ await harness.submitted.wait()+ await service.stop(session.id, run.id)+ harness.start_gate.set()+ await harness.interrupted.wait()+ connection = harness.connections[0]+ assert connection.interrupts == ["turn-1"]+ await connection.finish("turn-1", "interrupted")+ detail = await service.get_detail(session.id)+ assert detail.run.status == "interrupted"+ second = await service.send(+ session.id,+ new_id(),+ detail.session.revision,+ "second",+ expected_epoch=service.epoch,+ )+ await harness.wait_inputs(2)+ await service.stop(session.id, run.id)+ assert second.id != run.id+ assert connection.interrupts == ["turn-1"]+++async def test_stop_during_creation_prevents_native_submission(code):+ service, harness, _ = code+ session = await session_for(code)+ harness.creation_gate.clear()+ run = await service.send(+ session.id,+ new_id(),+ session.revision,+ "do not run",+ expected_epoch=service.epoch,+ )+ await harness.creating.wait()+ await service.stop(session.id, run.id)+ harness.creation_gate.set()+ await service.wait_idle(session.id)+ detail = await service.get_detail(session.id)+ assert detail.run.status == "interrupted"+ assert detail.session.native_thread_id == "native-1"+ assert harness.connections[0].inputs == []+++async def test_browser_observers_are_independent_of_work(code):+ service, harness, _ = code+ session = await session_for(code)+ first, _ = await service.subscribe()+ second, _ = await service.subscribe()+ await service.send(+ session.id,+ new_id(),+ session.revision,+ "keep running",+ expected_epoch=service.epoch,+ )+ await harness.started.wait()+ await first.aclose()+ await second.aclose()+ connection = harness.connections[0]+ await connection.text("turn-1", "answer", "Still running", complete=True)+ await connection.finish("turn-1")+ detail = await service.get_detail(session.id)+ assert detail.items[-1].text == "Still running"+ assert detail.run.status == "completed"+ assert not connection.closed+++async def test_idle_delete_removes_both_histories_and_blocks_late_create(code):+ service, harness, directory = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch+ )+ await harness.started.wait()+ with pytest.raises(CodeConflictError):+ await service.delete_session(session.id, session.revision)+ assert harness.connections[0].deleted == []+ await harness.connections[0].finish("turn-1")+ detail = await service.get_detail(session.id)+ await service.delete_session(session.id, detail.session.revision)+ await service.wait_idle(session.id)+ assert harness.connections[0].deleted == ["native-1"]+ assert (await service.list_sessions()).sessions == ()+ with pytest.raises(CodeConflictError):+ await service.create_session(session.id, str(directory))+++async def test_restart_preserves_receipt_and_does_not_replay_input(tmp_path):+ harness = FakeHarness()+ database, lock = tmp_path / "code.db", tmp_path / "code.lock"+ first = CodeService(SQLiteCodeStore(database, lock), harness)+ await first.start()+ session = await first.create_session(new_id(), str(tmp_path))+ run = await first.send(+ session.id, new_id(), session.revision, "once", expected_epoch=first.epoch+ )+ await harness.started.wait()+ await first.close()+ second = CodeService(SQLiteCodeStore(database, lock), harness)+ await second.start()+ try:+ repeat = await second.send(+ session.id, run.id, session.revision, "once", expected_epoch=second.epoch+ )+ assert repeat.id == run.id+ assert repeat.status == "interrupted"+ assert len(harness.connections) == 1+ assert harness.connections[0].inputs == [(run.id, "once", "provider/model")]+ finally:+ await second.close()+++async def test_two_answers_claim_one_native_prompt(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "approval", expected_epoch=service.epoch+ )+ await harness.started.wait()+ connection = harness.connections[0]+ await connection.prompt(0)+ prompt = (await service.get_detail(session.id)).prompts[0]+ harness.answer_gate.clear()+ results = await asyncio.gather(+ service.answer(session.id, prompt.id, new_id(), {"choice": "accept"}),+ service.answer(session.id, prompt.id, new_id(), {"choice": "decline"}),+ return_exceptions=True,+ )+ assert sum(isinstance(result, CodeConflictError) for result in results) == 1+ await harness.answering.wait()+ harness.answer_gate.set()+ await harness.answered.wait()+ assert len(connection.answers) == 1+ assert (await service.get_detail(session.id)).prompts[0].status == "resolved"+++async def test_native_resolution_while_answer_is_waiting_never_resurrects_prompt(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "approval", expected_epoch=service.epoch+ )+ await harness.started.wait()+ connection = harness.connections[0]+ await connection.prompt(0)+ prompt = (await service.get_detail(session.id)).prompts[0]+ harness.answer_gate.clear()+ await service.answer(session.id, prompt.id, new_id(), {"choice": "accept"})+ await harness.answering.wait()+ await connection.resolve(0)+ harness.answer_gate.set()+ await harness.answered.wait()+ assert connection.answers == []+ assert (await service.get_detail(session.id)).prompts[0].status == "resolved"+++async def test_streaming_does_not_invalidate_rename_revision(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch+ )+ await harness.started.wait()+ before = await service.get_detail(session.id)+ await harness.connections[0].text("turn-1", "answer", "partial")+ after = await service.get_detail(session.id)+ assert after.version > before.version+ assert after.session.revision == before.session.revision+ await service.update_settings(+ session.id, before.session.revision, {"title": "My code"}+ )+ assert (await service.get_detail(session.id)).session.title == "My code"+++async def test_catalog_replacement_is_limited_to_selected_entry_and_session(code):+ service, harness, _ = code+ harness.configurations["provider/other"] = "other-1"+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch+ )+ await harness.started.wait()+ original = harness.connections[0]+ await original.finish("turn-1")+ harness.model = "provider/other"+ detail = await service.get_detail(session.id)+ selected = await service.update_settings(+ session.id, detail.session.revision, {"model": harness.model}+ )+ await service.send(+ session.id,+ new_id(),+ selected.revision,+ "second",+ expected_epoch=service.epoch,+ )+ await harness.wait_inputs(2)+ await original.finish("turn-2")+ assert len(harness.connections) == 1+ harness.configurations["unrelated/model"] = "new"+ harness.configurations["provider/other"] = "changed"+ detail = await service.get_detail(session.id)+ await service.send(+ session.id,+ new_id(),+ detail.session.revision,+ "third",+ expected_epoch=service.epoch,+ )+ await harness.wait_inputs(3)+ assert len(harness.connections) == 2+ assert original.closed+ assert harness.connections[1].resumed == ["native-1"]+++async def test_cancelled_http_admission_still_commits_and_executes_once(tmp_path):+ committed = asyncio.Event()+ release = asyncio.Event()++ class GatedStore(SQLiteCodeStore):+ async def admit_run(self, session, run, item, expected_revision):+ result = await super().admit_run(session, run, item, expected_revision)+ committed.set()+ await release.wait()+ return result++ harness = FakeHarness()+ service = CodeService(+ GatedStore(tmp_path / "code.db", tmp_path / "code.lock"), harness+ )+ await service.start()+ try:+ session = await service.create_session(new_id(), str(tmp_path))+ operation_id = new_id()+ http = asyncio.create_task(+ service.send(+ session.id,+ operation_id,+ session.revision,+ "once",+ expected_epoch=service.epoch,+ )+ )+ await committed.wait()+ http.cancel()+ with pytest.raises(asyncio.CancelledError):+ await http+ release.set()+ await harness.started.wait()+ repeat = await service.send(+ session.id,+ operation_id,+ session.revision,+ "once",+ expected_epoch=service.epoch,+ )+ assert repeat.id == operation_id+ assert len(harness.connections[0].inputs) == 1+ finally:+ release.set()+ await service.close()diff --git a/tests/application/test_execution.py b/tests/application/test_execution.pyindex 4793bf30..3d34d158 100644--- a/tests/application/test_execution.py+++ b/tests/application/test_execution.py@@ -1218,35 +1218,52 @@ async def test_empty_chunks_do_not_renew_provider_progress() -> None:@pytest.mark.asyncioasync def test_fallback_transition_does_not_reset_shared_progress_deadline() -> None:- timeout_seconds = 0.2+ primary_wait = WaitStep()primary = ControlledProvider(- [DelayStep(0.06), _execution_failure("primary overloaded")]+ [primary_wait, _execution_failure("primary overloaded")])fallback_wait = WaitStep()fallback = ControlledProvider([fallback_wait])providers = {"provider": primary, "fallback": fallback}executor = ProviderExecutor(providers.__getitem__,- progress_timeout_seconds=timeout_seconds,+ progress_timeout_seconds=60,)stream = executor.stream_messages(_routed_request(_target("fallback", "model")),raw_log_payload={},request_id="req_shared_deadline",)- loop = asyncio.get_running_loop()- started = loop.time()+ deadlines: list[float | None] = []+ timeouts: list[asyncio.Timeout] = []++ def controlled_timeout_at(deadline):+ deadlines.append(deadline)+ timeout = asyncio.timeout(None)+ timeouts.append(timeout)+ return timeoutwith (patch("free_claude_code.application.execution.trace_event") as trace_mock,- pytest.raises(ExecutionFailure) as exc_info,+ patch(+ "free_claude_code.application.execution.asyncio.timeout_at",+ controlled_timeout_at,+ ),):- await anext(stream)+ reading = asyncio.ensure_future(anext(stream))+ await primary_wait.started.wait()+ primary_wait.release.set()+ await fallback_wait.started.wait()+ # Expire the actual fallback read context after observing its admission;+ # machine load must not determine whether the shared deadline was reused.+ timeouts[-1].reschedule(asyncio.get_running_loop().time())+ with pytest.raises(ExecutionFailure) as exc_info:+ await reading- elapsed = loop.time() - started- assert fallback_wait.started.is_set()+ read_deadlines = [deadline for deadline in deadlines if deadline is not None]+ assert len(read_deadlines) >= 3+ assert len(set(read_deadlines)) == 1assert exc_info.value.kind == FailureKind.TIMEOUT- assert elapsed < 0.24assert primary.stream_close_calls == fallback.stream_close_calls == 1timeout_trace = next(call.kwargsdiff --git a/tests/code_sessions_support.py b/tests/code_sessions_support.pynew file mode 100644index 00000000..0116700b--- /dev/null+++ b/tests/code_sessions_support.py@@ -0,0 +1,284 @@+"""Controllable native harness used by application and browser tests."""++import asyncio+import uuid+from dataclasses import dataclass++from free_claude_code.application.code_sessions.models import (+ CodeCatalog,+ CodeConflictError,+ CodeModel,+ CodeUnavailableError,+ CodeValidationError,+ HarnessEvent,+ ItemUpdate,+ NativeHistoryMissing,+ NativeThread,+ NativeTurn,+ PromptRequest,+ RunStatus,+)+from free_claude_code.application.code_sessions.ports import EventSink, HarnessSelection+from free_claude_code.core.json_types import JsonObject+++class FakeHarness:+ def __init__(self):+ self.connections: list[FakeConnection] = []+ self.model = "provider/model"+ self.configurations = {self.model: "capabilities-1"}+ self.efforts = ("low", "medium", "high", "xhigh")+ self.default_effort = "medium"+ self.creation_gate = asyncio.Event()+ self.start_gate = asyncio.Event()+ self.creation_gate.set()+ self.start_gate.set()+ self.creating = asyncio.Event()+ self.started = asyncio.Event()+ self.submitted = asyncio.Event()+ self.interrupted = asyncio.Event()+ self.input_changed = asyncio.Event()+ self.answer_gate = asyncio.Event()+ self.answer_gate.set()+ self.answering = asyncio.Event()+ self.answered = asyncio.Event()+ self.interrupt_gate = asyncio.Event()+ self.interrupt_gate.set()+ self.turn_count = 0+ self.histories: dict[str, list[ItemUpdate]] = {}+ self.delete_error: Exception | None = None+ self.delete_gate = asyncio.Event()+ self.delete_gate.set()+ self.deleting = asyncio.Event()+ self.delete_before_error = False++ def availability(self):+ return True, None++ def catalog(self):+ return CodeCatalog(+ self.model,+ tuple(+ CodeModel(+ id=model,+ display_name=model,+ reasoning_efforts=self.efforts,+ default_reasoning_effort=self.default_effort,+ )+ for model in self.configurations+ ),+ )++ def prepare(self, model, reasoning_effort):+ if model not in self.configurations:+ raise CodeValidationError("This model is unavailable.")+ if reasoning_effort is not None and reasoning_effort not in self.efforts:+ raise CodeValidationError("This reasoning effort is unavailable.")+ return FakeSelection(+ self,+ model,+ self.configurations[model],+ dict(self.configurations),+ reasoning_effort or self.default_effort,+ )++ async def open_history(self, cwd: str, sink: EventSink):+ return await self.prepare(self.model, None).open(cwd, sink)++ async def wait_inputs(self, count: int):+ while sum(len(connection.inputs) for connection in self.connections) < count:+ self.input_changed.clear()+ await self.input_changed.wait()+++@dataclass+class FakeSelection:+ harness: FakeHarness+ model: str+ configuration_key: str+ catalog: dict[str, str]+ reasoning_effort: str | None++ async def open(self, cwd: str, sink: EventSink):+ connection = FakeConnection(self.harness, sink, self.catalog)+ self.harness.connections.append(connection)+ return connection+++class FakeConnection:+ def __init__(self, harness: FakeHarness, sink: EventSink, catalog: dict[str, str]):+ self.harness = harness+ self.sink = sink+ self.catalog = catalog+ self.generation = str(uuid.uuid4())+ self.thread_id: str | None = None+ self.inputs: list[tuple[str, str, str]] = []+ self.efforts: list[str | None] = []+ self.interrupts: list[str] = []+ self.deleted: list[str] = []+ self.resumed: list[str] = []+ self.answers: list[tuple[str | int, JsonObject]] = []+ self.requests: dict[str | int, PromptRequest] = {}+ self.closed = False++ def supports(self, selection: HarnessSelection):+ return (+ not self.closed+ and self.catalog.get(selection.model) == selection.configuration_key+ )++ async def create_thread(self):+ self.harness.creating.set()+ await self.harness.creation_gate.wait()+ if self.closed:+ raise CodeUnavailableError("Native process closed during creation.")+ self.thread_id = f"native-{len(self.harness.histories) + 1}"+ self.harness.histories[self.thread_id] = []+ return NativeThread(self.thread_id)++ async def resume_thread(self, thread_id: str):+ self.resumed.append(thread_id)+ self.thread_id = thread_id+ return await self.read_thread(thread_id)++ async def read_thread(self, thread_id: str):+ if thread_id not in self.harness.histories:+ raise NativeHistoryMissing("Native conversation not found.")+ groups: dict[str, list[ItemUpdate]] = {}+ for item in self.harness.histories[thread_id]:+ groups.setdefault(item.turn_id, []).append(item)+ return NativeThread(+ thread_id,+ tuple(+ NativeTurn(turn_id, tuple(items)) for turn_id, items in groups.items()+ ),+ )++ async def start_turn(self, text: str, selection: HarnessSelection, client_id: str):+ self.inputs.append((client_id, text, selection.model))+ self.efforts.append(selection.reasoning_effort)+ self.harness.input_changed.set()+ self.harness.submitted.set()+ self.harness.turn_count += 1+ turn_id = f"turn-{self.harness.turn_count}"+ await self.harness.start_gate.wait()+ if self.closed:+ raise CodeUnavailableError("Native process closed during submission.")+ await self.sink(+ HarnessEvent(+ self.generation, self.thread_id, "turn_started", turn_id=turn_id+ )+ )+ self.harness.started.set()+ return turn_id++ async def interrupt(self, turn_id: str):+ self.interrupts.append(turn_id)+ self.harness.interrupted.set()+ await self.harness.interrupt_gate.wait()+ if self.closed:+ raise CodeUnavailableError(+ "Native process closed before interrupt acknowledgement."+ )+ await self.finish(turn_id, "interrupted")++ async def finish(self, turn_id: str, status: RunStatus = "completed", message=None):+ await self.sink(+ HarnessEvent(+ self.generation,+ self.thread_id,+ "turn_completed",+ turn_id=turn_id,+ status=status,+ message=message,+ )+ )++ async def text(+ self, turn_id: str, item_id: str, text: str, *, complete=False, kind="text"+ ):+ item = ItemUpdate(+ turn_id,+ item_id,+ kind,+ text=text,+ complete=complete,+ raw={"id": item_id, "text": text},+ )+ if self.thread_id:+ self.harness.histories[self.thread_id].append(item)+ await self.sink(+ HarnessEvent(+ self.generation, self.thread_id, "item", turn_id=turn_id, item=item+ )+ )++ async def prompt(self, request_id: str | int, turn_id: str | None = "turn-1"):+ prompt = PromptRequest(+ request_id,+ "approval",+ {+ "title": "Run command?",+ "choices": [+ {"id": "accept", "label": "Allow"},+ {"id": "decline", "label": "Decline"},+ ],+ },+ {"requestId": request_id},+ turn_id,+ )+ self.requests[request_id] = prompt+ await self.sink(+ HarnessEvent(+ self.generation,+ self.thread_id,+ "prompt",+ turn_id=turn_id,+ prompt=prompt,+ )+ )++ def prepare_answer(self, request_id: str | int, answer: JsonObject):+ if request_id not in self.requests:+ raise CodeConflictError("Prompt resolved.")+ return dict(answer)++ async def respond(self, request_id: str | int, response: JsonObject):+ self.harness.answering.set()+ await self.harness.answer_gate.wait()+ try:+ if request_id not in self.requests:+ raise CodeConflictError("Prompt resolved.")+ self.answers.append((request_id, response))+ await self.resolve(request_id)+ finally:+ self.harness.answered.set()++ async def resolve(self, request_id: str | int):+ self.requests.pop(request_id, None)+ await self.sink(+ HarnessEvent(+ self.generation, self.thread_id, "resolved", request_id=request_id+ )+ )++ async def delete_thread(self, thread_id: str):+ self.deleted.append(thread_id)+ self.harness.deleting.set()+ await self.harness.delete_gate.wait()+ if self.harness.delete_before_error:+ self.harness.histories.pop(thread_id, None)+ if self.harness.delete_error:+ raise self.harness.delete_error+ self.harness.histories.pop(thread_id, None)++ async def close(self):+ if self.closed:+ return+ self.closed = True+ self.harness.creation_gate.set()+ self.harness.start_gate.set()+ self.harness.answer_gate.set()+ self.harness.interrupt_gate.set()+ self.harness.delete_gate.set()+ await self.sink(HarnessEvent(self.generation, self.thread_id, "closed"))diff --git a/tests/runtime/codex_fake_process.py b/tests/runtime/codex_fake_process.pynew file mode 100644index 00000000..293164ee--- /dev/null+++ b/tests/runtime/codex_fake_process.py@@ -0,0 +1,161 @@+"""Deterministic JSONL peer for native transport tests; never executes tools."""++import json+import sys+++def emit(value):+ encoded = (json.dumps(value, ensure_ascii=False) + "\n").encode("utf-8")+ # Exercise framing across both large messages and UTF-8 boundaries.+ for start in range(0, len(encoded), 32767):+ sys.stdout.buffer.write(encoded[start : start + 32767])+ sys.stdout.buffer.flush()+++mode = sys.argv[1]+creation_id = None+turn = "turn-1"+for line in sys.stdin.buffer:+ request = json.loads(line)+ method = request.get("method")+ request_id = request.get("id")+ if method == "initialize":+ emit({"id": request_id, "result": {"userAgent": "codex/0.153.0"}})+ elif method == "initialized":+ pass+ elif method == "thread/start":+ if mode == "delayed-create":+ creation_id = request_id+ else:+ emit(+ {+ "id": request_id,+ "result": {"thread": {"id": "native-1", "turns": []}},+ }+ )+ elif method == "test/barrier":+ emit({"id": request_id, "result": {}})+ elif method == "test/release-create":+ emit({"id": creation_id, "result": {"thread": {"id": "native-1", "turns": []}}})+ emit({"id": request_id, "result": {}})+ elif method == "turn/start":+ emit(+ {+ "method": "turn/started",+ "params": {+ "threadId": "native-1",+ "turn": {"id": turn, "status": "inProgress"},+ },+ }+ )+ if mode in {"prompt", "child-prompt"}:+ if mode == "child-prompt":+ emit(+ {+ "method": "thread/started",+ "params": {+ "thread": {+ "id": "child-1",+ "source": {+ "subAgent": {+ "thread_spawn": {+ "parent_thread_id": "native-1",+ "depth": 1,+ }+ }+ },+ }+ },+ }+ )+ emit(+ {+ "method": "item/commandExecution/requestApproval",+ "id": 0,+ "params": {+ "threadId": "child-1" if mode == "child-prompt" else "native-1",+ "turnId": turn,+ "itemId": "command",+ "command": "echo test",+ "availableDecisions": ["accept", "decline", "cancel"],+ },+ }+ )+ else:+ emit(+ {+ "method": "item/agentMessage/delta",+ "params": {+ "threadId": "native-1",+ "turnId": turn,+ "itemId": "answer",+ "delta": "snow ☃ " * 16000,+ },+ }+ )+ emit(+ {+ "method": "item/completed",+ "params": {+ "threadId": "native-1",+ "turnId": turn,+ "item": {+ "id": "answer",+ "type": "agentMessage",+ "text": "snow ☃ " * 16000,+ },+ },+ }+ )+ emit(+ {+ "method": "turn/completed",+ "params": {+ "threadId": "native-1",+ "turn": {"id": turn, "status": "completed"},+ },+ }+ )+ emit(+ {"id": request_id, "result": {"turn": {"id": turn, "status": "inProgress"}}}+ )+ elif method is None and request_id == 0:+ emit(+ {+ "method": "serverRequest/resolved",+ "params": {"threadId": "native-1", "requestId": 0},+ }+ )+ emit(+ {+ "method": "item/completed",+ "params": {+ "threadId": "native-1",+ "turnId": turn,+ "item": {+ "id": "answer",+ "type": "agentMessage",+ "text": request["result"]["decision"],+ },+ },+ }+ )+ emit(+ {+ "method": "turn/completed",+ "params": {+ "threadId": "native-1",+ "turn": {"id": turn, "status": "completed"},+ },+ }+ )+ elif method == "test/eof":+ break+ elif method == "test/malformed":+ sys.stdout.buffer.write(b"invalid-json\n")+ sys.stdout.buffer.flush()+ elif method == "test/malformed-flood":+ sys.stdout.buffer.write(b"invalid-json\n" + b"x" * 500_000 + b"\n")+ sys.stdout.buffer.flush()+ else:+ emit({"id": request_id, "result": {}})diff --git a/tests/runtime/test_code_sessions_sqlite.py b/tests/runtime/test_code_sessions_sqlite.pynew file mode 100644index 00000000..007e3c15--- /dev/null+++ b/tests/runtime/test_code_sessions_sqlite.py@@ -0,0 +1,277 @@+import asyncio+import sqlite3+import threading+import uuid+from contextlib import closing++import pytest+import pytest_asyncio++from free_claude_code.application.code_sessions.models import (+ CodeConflictError,+ CodeItem,+ CodePrompt,+ CodeRun,+ CodeSession,+ CodeUnavailableError,+)+from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore+++async def test_cancelled_initialization_drains_thread_before_releasing_owner_lock(+ tmp_path,+):+ entered = threading.Event()+ release = threading.Event()+ initialized = threading.Event()++ class GatedStore(SQLiteCodeStore):+ def _initialize(self):+ entered.set()+ assert release.wait(5)+ super()._initialize()+ initialized.set()++ store = GatedStore(tmp_path / "code.db", tmp_path / "code.lock")+ starting = asyncio.create_task(store.start())+ await asyncio.to_thread(entered.wait, 3)+ starting.cancel()+ release.set()+ with pytest.raises(asyncio.CancelledError):+ await starting+ await asyncio.to_thread(initialized.wait, 3)+ second = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")+ try:+ await second.start()+ session = await second.create(+ CodeSession(id=str(uuid.uuid4()), cwd=str(tmp_path), model="provider/model")+ )+ assert (await second.get_session(session.id)).id == session.id+ finally:+ await store.close()+ await second.close()+++async def test_store_has_one_process_owner_and_can_reopen_after_close(tmp_path):+ first = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")+ second = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")+ await first.start()+ try:+ with pytest.raises(CodeUnavailableError, match="another FCC"):+ await second.start()+ finally:+ await first.close()+ await second.start()+ await second.close()+++async def test_reused_item_id_cannot_overwrite_another_session(tmp_path):+ store = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")+ await store.start()+ try:+ first, second = [+ await store.create(+ CodeSession(+ id=str(uuid.uuid4()), cwd=str(tmp_path), model="provider/model"+ )+ )+ for _ in range(2)+ ]+ shared_id = str(uuid.uuid4())+ first, first_run = await _admit(store, first, text="first")+ original = CodeItem(+ id=shared_id,+ session_id=first.id,+ sequence=2,+ run_id=first_run.id,+ kind="tool",+ text="original output",+ complete=True,+ )+ await store.save_progress(first, first.revision, items=(original,))+ await _admit(store, second, run_id=shared_id, text="second")+ assert (await store.items(first.id, None, None))[-1] == original+ assert (await store.items(second.id, None, None))[0].text == "second"+ finally:+ await store.close()+++async def _admit(store, session, *, run_id=None, text="message", sequence=1):+ run_id = run_id or str(uuid.uuid4())+ run = CodeRun(id=run_id, session_id=session.id, text=text, model=session.model)+ item = CodeItem(+ id=run_id,+ session_id=session.id,+ run_id=run_id,+ sequence=sequence,+ kind="user",+ text=text,+ complete=True,+ )+ return await store.admit_run(+ session.model_copy(update={"revision": session.revision + 1}),+ run,+ item,+ session.revision,+ )+++@pytest_asyncio.fixture+async def store(tmp_path):+ result = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")+ await result.start()+ yield result+ await result.close()+++async def _session(store):+ return await store.create(+ CodeSession(id=str(uuid.uuid4()), cwd="/work", model="provider/model")+ )+++async def test_admission_is_atomic_and_idempotent(store):+ session = await _session(store)+ results = await asyncio.gather(+ _admit(store, session), _admit(store, session), return_exceptions=True+ )+ assert sum(isinstance(result, CodeConflictError) for result in results) == 1+ session, run = next(result for result in results if isinstance(result, tuple))+ assert (+ len(await store.runs(session.id))+ == len(await store.items(session.id, None, None))+ == 1+ )+ assert await _admit(store, session, run_id=run.id) == (session, run)+ await store.save_progress(+ session, session.revision, run=run.model_copy(update={"status": "completed"})+ )+ collision = CodeItem(+ id=str(uuid.uuid4()),+ session_id=session.id,+ run_id=run.id,+ sequence=2,+ kind="tool",+ text="keep me",+ complete=True,+ )+ await store.save_progress(session, session.revision, items=(collision,))+ with pytest.raises(CodeConflictError):+ await _admit(store, session, run_id=collision.id, sequence=3)+ assert (await store.get_session(session.id)).revision == session.revision+ assert len(await store.runs(session.id)) == 1+ assert (await store.items(session.id, None, None))[-1] == collision+++async def test_schema_rejects_second_active_run_and_cross_session_item_link(+ store, tmp_path+):+ session, run = await _admit(store, await _session(store))+ other = await _session(store)+ with closing(sqlite3.connect(tmp_path / "code.db")) as connection:+ connection.execute("PRAGMA foreign_keys = ON")+ columns = [row[1] for row in connection.execute("PRAGMA table_info(code_runs)")]+ expressions = [+ "'another'"+ if column == "id"+ else "ordinal + 1"+ if column == "ordinal"+ else column+ for column in columns+ ]+ with pytest.raises(sqlite3.IntegrityError):+ connection.execute(+ f"INSERT INTO code_runs SELECT {','.join(expressions)} FROM code_runs"+ )+ columns = [+ row[1] for row in connection.execute("PRAGMA table_info(code_items)")+ ]+ expressions = ["?" if column == "session_id" else column for column in columns]+ with pytest.raises(sqlite3.IntegrityError):+ connection.execute(+ f"INSERT INTO code_items SELECT {','.join(expressions)} FROM code_items",+ (other.id,),+ )+ assert await store.get_run(session.id, run.id) == run+++async def test_prompt_claim_and_settings_are_guarded_in_storage(store):+ session = await _session(store)+ prompts = tuple(+ CodePrompt(+ id=str(uuid.uuid4()),+ session_id=session.id,+ generation="g",+ request_id=request_id,+ kind="question",+ form={},+ raw={},+ )+ for request_id in (1, "1")+ )+ await store.save_progress(session, session.revision, prompts=prompts)+ results = await asyncio.gather(+ *(+ store.claim_prompt(session.id, prompts[0].id, str(uuid.uuid4()), "g")+ for _ in range(2)+ ),+ return_exceptions=True,+ )+ assert sum(isinstance(result, CodeConflictError) for result in results) == 1+ claimed = next(result for result in results if isinstance(result, CodePrompt))+ assert (+ await store.claim_prompt(session.id, claimed.id, claimed.response_id, "g")+ == claimed+ )+ with pytest.raises(CodeConflictError):+ await store.claim_prompt(session.id, prompts[1].id, claimed.response_id, "g")+ settings = session.model_copy(+ update={"model": "provider/other", "revision": session.revision + 1}+ )+ with pytest.raises(CodeConflictError):+ await store.update_settings(settings, session.revision)+ await store.save_progress(+ session,+ session.revision,+ prompts=(+ claimed.model_copy(update={"status": "resolved"}),+ prompts[1].model_copy(update={"status": "expired"}),+ ),+ )+ assert (+ await store.update_settings(settings, session.revision)+ ).model == "provider/other"+ with pytest.raises(CodeConflictError):+ await store.update_settings(+ session.model_copy(update={"title": "stale"}), session.revision+ )+++async def test_recovered_old_output_pages_with_its_original_run_outcome(store):+ session, old = await _admit(store, await _session(store))+ old = old.model_copy(update={"status": "failed", "error": "first failed"})+ await store.save_progress(session, session.revision, run=old)+ session, newer = await _admit(store, session, sequence=2)+ tail = CodeItem(+ id=str(uuid.uuid4()),+ session_id=session.id,+ run_id=old.id,+ sequence=3,+ kind="assistant",+ text="recovered",+ complete=True,+ )+ await store.save_progress(session, session.revision, items=(tail,))+ page = await store.item_page(session.id, None, 2)+ assert [item.run_id for item in page.items] == [old.id, newer.id]+ assert page.runs[0].error == "first failed"+ assert page.next_before == (old.ordinal, 3)+ older = await store.item_page(session.id, page.next_before, 2)+ assert [item.sequence for item in older.items] == [1]diff --git a/tests/runtime/test_codex_app_server.py b/tests/runtime/test_codex_app_server.pynew file mode 100644index 00000000..06cc987f--- /dev/null+++ b/tests/runtime/test_codex_app_server.py@@ -0,0 +1,195 @@+import asyncio+import os+import sys+from pathlib import Path++import pytest++from free_claude_code.application.code_sessions.models import CodeUnavailableError+from free_claude_code.runtime.codex_app_server import CodexAppServer+from tests.code_sessions_support import FakeHarness+++async def connect(tmp_path, mode):+ events = []+ completed = asyncio.Event()+ prompted = asyncio.Event()++ async def receive(event):+ events.append(event)+ if event.kind == "turn_completed":+ completed.set()+ if event.kind == "prompt":+ prompted.set()++ native = CodexAppServer(+ [sys.executable, str(Path(__file__).with_name("codex_fake_process.py")), mode],+ dict(os.environ),+ str(tmp_path),+ receive,+ model_slugs={"provider/model": "provider/model"},+ fingerprints={"provider/model": "capabilities-1"},+ )+ await native.start()+ return native, events, completed, prompted+++async def test_jsonl_large_unicode_events_can_precede_rpc_ack(tmp_path):+ native, events, completed, _ = await connect(tmp_path, "large")+ try:+ assert (await native.create_thread()).id == "native-1"+ assert (+ await native.start_turn(+ "hello", FakeHarness().prepare("provider/model", None), "input-1"+ )+ == "turn-1"+ )+ await asyncio.wait_for(completed.wait(), 3)+ texts = [+ event.item.text for event in events if event.item and event.item.complete+ ]+ assert texts == ["snow ☃ " * 16000]+ finally:+ await native.close()+++async def test_server_rpc_during_start_preserves_numeric_zero_id(tmp_path):+ native, events, completed, prompted = await connect(tmp_path, "prompt")+ try:+ await native.create_thread()+ await native.start_turn(+ "hello", FakeHarness().prepare("provider/model", None), "input-1"+ )+ await asyncio.wait_for(prompted.wait(), 3)+ response = native.prepare_answer(0, {"choice": "0"})+ await native.respond(0, response)+ await asyncio.wait_for(completed.wait(), 3)+ assert any(event.item and event.item.text == "accept" for event in events)+ assert any(+ event.kind == "resolved" and event.request_id == 0 for event in events+ )+ finally:+ await native.close()+++async def test_cancelled_creation_waiter_retains_late_native_identity(tmp_path):+ native, _, _, _ = await connect(tmp_path, "delayed-create")+ try:+ creation = asyncio.create_task(native.create_thread())+ await native.rpc("test/barrier", {})+ creation.cancel()+ with pytest.raises(asyncio.CancelledError):+ await creation+ await native.rpc("test/release-create", {})+ assert native.thread_id == "native-1"+ finally:+ await native.close()+++async def test_eof_completes_pending_calls_and_cleanup(tmp_path):+ native, _, _, _ = await connect(tmp_path, "large")+ try:+ with pytest.raises(CodeUnavailableError):+ await native.rpc("test/eof", {})+ finally:+ await native.close()+ assert native.process.returncode is not None++[email protected]("method", ["test/malformed", "test/malformed-flood"])+async def test_malformed_frame_reports_closed_only_after_process_termination(+ tmp_path, method+):+ closed = asyncio.Event()+ returncodes = []++ async def receive(event):+ if event.kind == "closed":+ returncodes.append(native.process.returncode)+ closed.set()++ native = CodexAppServer(+ [+ sys.executable,+ str(Path(__file__).with_name("codex_fake_process.py")),+ "large",+ ],+ dict(os.environ),+ str(tmp_path),+ receive,+ )+ try:+ await native.start()+ with pytest.raises(CodeUnavailableError):+ await native.rpc(method, {})+ await asyncio.wait_for(closed.wait(), 8)+ assert returncodes and returncodes[0] is not None+ assert native.process.stdout is not None and native.process.stdout.at_eof()+ finally:+ if native.process.stdout is not None and not native.process.stdout.at_eof():+ await native.process.stdout.read()+ await native.close()+++async def test_spawned_agent_prompt_is_visible_in_its_registered_root_session(tmp_path):+ native, events, completed, prompted = await connect(tmp_path, "child-prompt")+ try:+ await native.create_thread()+ await native.start_turn(+ "delegate", FakeHarness().prepare("provider/model", None), "input-1"+ )+ await asyncio.wait_for(prompted.wait(), 3)+ event = next(event for event in events if event.kind == "prompt")+ assert event.thread_id == "native-1"+ assert event.prompt.turn_id is None+ assert event.prompt.raw["threadId"] == "child-1"+ await native.respond(0, native.prepare_answer(0, {"choice": "0"}))+ await asyncio.wait_for(completed.wait(), 3)+ finally:+ await native.close()++[email protected]("reasoning", [True, False])+async def test_turn_start_resets_sticky_effort_and_preserves_client_identity(+ tmp_path, monkeypatch, reasoning+):+ async def receive(event):+ pass++ native = CodexAppServer(+ [],+ {},+ str(tmp_path),+ receive,+ model_slugs={"provider/model": "native-slug"},+ reasoning={"provider/model": reasoning},+ )+ native.thread_id = "thread"+ requests = []++ async def rpc(method, params):+ assert method == "turn/start"+ requests.append(params)+ return {"turn": {"id": "turn"}}++ monkeypatch.setattr(native, "rpc", rpc)+ harness = FakeHarness()+ for effort in (None, "high", None):+ await native.start_turn(+ "hello", harness.prepare("provider/model", effort), "operation"+ )+ assert [request.get("effort") for request in requests] == (+ ["medium", "high", "medium"] if reasoning else [None, None, None]+ )+ assert all(+ request["clientUserMessageId"] == "operation"+ and request["model"] == "native-slug"+ for request in requests+ )diff --git a/tests/runtime/test_codex_catalog.py b/tests/runtime/test_codex_catalog.pyindex 9ddd3f34..99fdfd55 100644--- a/tests/runtime/test_codex_catalog.py+++ b/tests/runtime/test_codex_catalog.py@@ -4,12 +4,14 @@ from unittest.mock import patchimport pytest+from free_claude_code.application.code_sessions.models import CodeValidationErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.application.ports import (RequestRuntimeLease,RequestRuntimePort,)from free_claude_code.config.settings import Settings+from free_claude_code.runtime.codex_app_server import CodexHarnessFactoryfrom free_claude_code.runtime.codex_catalog import CodexModelCatalogPublisher@@ -102,3 +104,19 @@ def test_empty_projection_preserves_existing_catalog(tmp_path: Path) -> None:publisher.publish(_runtime())assert catalog_path.read_text(encoding="utf-8") == "last known good\n"+++def test_code_picker_and_native_selection_use_the_same_advertised_efforts():+ factory = CodexHarnessFactory(_runtime(), binary="codex")+ advertised = factory.catalog()+ assert advertised.default_model == "nvidia_nim/configured"+ model = advertised.models[1]+ selected = factory.prepare(model.id, None)+ assert selected.model == model.id+ assert selected.context.settings.model == model.id+ assert selected.reasoning_effort == model.default_reasoning_effort == "medium"+ assert factory.prepare(model.id, "high").reasoning_effort == "high"+ with pytest.raises(CodeValidationError, match="effort"):+ factory.prepare(model.id, "unsupported")+ with pytest.raises(CodeValidationError, match="model"):+ factory.prepare("missing/model", None)diff --git a/tests/runtime/test_codex_protocol.py b/tests/runtime/test_codex_protocol.pynew file mode 100644index 00000000..28eace48--- /dev/null+++ b/tests/runtime/test_codex_protocol.py@@ -0,0 +1,300 @@+import pytest++from free_claude_code.application.code_sessions import CodeValidationError+from free_claude_code.runtime.codex_protocol import CodexProtocol, NativePrompt+++def notification(protocol, method, **extra):+ return protocol.notification(+ method, {"threadId": "thread", "turnId": "turn", "itemId": "item", **extra}+ )+++def test_reasoning_keeps_summary_and_content_indices_and_original_completion():+ protocol = CodexProtocol("generation")+ notification(+ protocol, "item/reasoning/summaryTextDelta", summaryIndex=1, delta="Second"+ )+ notification(+ protocol, "item/reasoning/summaryTextDelta", summaryIndex=0, delta="First"+ )+ notification(+ protocol,+ "item/reasoning/textDelta",+ contentIndex=0,+ delta="Available reasoning",+ )+ event = notification(+ protocol,+ "item/completed",+ item={+ "id": "item",+ "type": "reasoning",+ "summary": [],+ "content": [],+ "opaque": "keep",+ },+ )+ assert event.item.text == "First\n\nSecond\n\nAvailable reasoning"+ assert event.item.raw["item"]["opaque"] == "keep"+ assert event.item.raw["stream"]["summary"] == {"0": "First", "1": "Second"}+++def test_text_final_replaces_partial_without_losing_source_metadata():+ protocol = CodexProtocol("generation")+ notification(protocol, "item/agentMessage/delta", delta="Hel")+ event = notification(+ protocol,+ "item/completed",+ item={+ "id": "item",+ "type": "agentMessage",+ "text": "Hello",+ "delivery": "async",+ "questions": [{"title": "Continue?"}],+ },+ )+ assert event.item.text == "Hello"+ assert event.item.raw["item"]["questions"] == [{"title": "Continue?"}]+ assert event.item.complete+++def test_retryable_error_does_not_turn_into_completion():+ event = notification(+ CodexProtocol("generation"), "error", error={"message": "retry"}, willRetry=True+ )+ assert event.kind == "error"+ assert event.message == "retry"+ assert event.will_retry is True+ assert event.error_details == {"message": "retry"}+++def test_command_completion_keeps_output_and_exit_code():+ protocol = CodexProtocol("generation")+ notification(protocol, "item/commandExecution/outputDelta", delta="output\n")+ event = notification(+ protocol,+ "item/completed",+ item={+ "id": "item",+ "type": "commandExecution",+ "command": "pytest",+ "cwd": "/work",+ "status": "completed",+ "exitCode": 1,+ },+ )+ assert "output" in event.item.detail+ assert "1" in event.item.detail+ assert event.item.title == "pytest"+++def test_approval_can_only_select_exact_native_offered_decisions():+ amendment = {"acceptWithExecpolicyAmendment": {"execpolicy_amendment": ["pytest"]}}+ prompt = NativePrompt(+ "item/commandExecution/requestApproval",+ 7,+ {+ "threadId": "thread",+ "turnId": "turn",+ "itemId": "item",+ "command": "pytest",+ "availableDecisions": ["accept", amendment, "decline", "cancel"],+ },+ )+ assert prompt.answer({"choice": "1"}) == {"decision": amendment}+ assert prompt.answer({"choice": "2"}) == {"decision": "decline"}+ with pytest.raises(CodeValidationError):+ prompt.answer({"choice": "acceptForSession"})+++def test_questions_preserve_ids_and_free_text_and_need_an_answer():+ prompt = NativePrompt(+ "item/tool/requestUserInput",+ "7",+ {+ "threadId": "thread",+ "turnId": "turn",+ "itemId": "item",+ "isBlocking": False,+ "questions": [+ {+ "id": "choice",+ "header": "Choose",+ "question": "Where?",+ "options": [{"label": "Here", "description": "This folder"}],+ "isOther": True,+ "isSecret": False,+ }+ ],+ },+ )+ assert prompt.answer({"answers": {"choice": ["Elsewhere"]}}) == {+ "answers": {"choice": {"answers": ["Elsewhere"]}}+ }+ with pytest.raises(CodeValidationError):+ prompt.answer({"answers": {"unknown": ["x"]}})+++def test_permission_grant_is_selected_subset_and_keeps_denies():+ prompt = NativePrompt(+ "item/permissions/requestApproval",+ 8,+ {+ "threadId": "thread",+ "turnId": "turn",+ "itemId": "item",+ "permissions": {+ "network": {"enabled": True},+ "fileSystem": {+ "read": ["/work"],+ "entries": [+ {"access": "deny", "path": {"type": "path", "path": "/secret"}}+ ],+ },+ },+ },+ )+ response = prompt.answer({"selected": ["network"], "scope": "turn"})+ assert response == {+ "scope": "turn",+ "permissions": {+ "network": {"enabled": True},+ "fileSystem": {+ "entries": [+ {"access": "deny", "path": {"type": "path", "path": "/secret"}}+ ]+ },+ },+ }+ with pytest.raises(CodeValidationError):+ prompt.answer({"selected": ["unoffered"], "scope": "session"})+++def test_mcp_form_answers_use_schema_types_and_reject_invalid_values():+ prompt = NativePrompt(+ "mcpServer/elicitation/request",+ 9,+ {+ "threadId": "thread",+ "turnId": None,+ "serverName": "local",+ "mode": "form",+ "message": "Choose a limit",+ "requestedSchema": {+ "type": "object",+ "required": ["limit"],+ "properties": {+ "limit": {"type": "integer", "minimum": 1, "maximum": 4}+ },+ },+ },+ )+ assert prompt.answer({"action": "accept", "values": {"limit": 2}}) == {+ "action": "accept",+ "content": {"limit": 2},+ }+ with pytest.raises(CodeValidationError):+ prompt.answer({"action": "accept", "values": {"limit": 7}})+ assert prompt.answer({"action": "decline"}) == {+ "action": "decline",+ "content": None,+ }+++def test_native_form_rejects_invalid_documented_string_format():+ prompt = NativePrompt(+ "mcpServer/elicitation/request",+ 1,+ {+ "threadId": "thread",+ "mode": "form",+ "serverName": "tool",+ "message": "Email",+ "requestedSchema": {+ "type": "object",+ "properties": {"email": {"type": "string", "format": "email"}},+ },+ },+ )+ with pytest.raises(CodeValidationError):+ prompt.answer({"action": "accept", "values": {"email": "invalid"}})+ assert (+ prompt.answer({"action": "accept", "values": {"email": "[email protected]"}})[+ "action"+ ]+ == "accept"+ )++[email protected]("choices,supported", [(["one", "two"], True), ([1, 2], False)])+def test_multiselect_projection_matches_the_negotiated_string_contract(+ choices, supported+):+ prompt = NativePrompt(+ "mcpServer/elicitation/request",+ 1,+ {+ "threadId": "thread",+ "mode": "form",+ "serverName": "tool",+ "requestedSchema": {+ "type": "object",+ "properties": {+ "selection": {+ "type": "array",+ "items": {+ "oneOf": [+ {"const": value, "title": str(value)}+ for value in choices+ ]+ },+ }+ },+ },+ },+ )+ assert prompt.form["unsupported"] is not supported+ if supported:+ assert prompt.answer({"action": "accept", "values": {"selection": choices}})[+ "content"+ ] == {"selection": choices}+ else:+ with pytest.raises(CodeValidationError, match="not supported"):+ prompt.answer({"action": "accept", "values": {"selection": choices}})+ for action in ("decline", "cancel"):+ assert prompt.answer({"action": action}) == {"action": action, "content": None}+++def test_history_preserves_native_turns_client_ids_and_failure_details():+ native = CodexProtocol("g").history(+ {+ "thread": {+ "id": "thread",+ "turns": [+ {+ "id": "first",+ "status": "failed",+ "error": {+ "message": "Rejected",+ "additionalDetails": "details",+ },+ "items": [+ {+ "id": "user",+ "type": "userMessage",+ "clientId": "operation",+ "content": [{"type": "text", "text": "Hello"}],+ }+ ],+ }+ ],+ }+ }+ )+ assert native.turns[0].items[0].client_id == "operation"+ assert native.turns[0].status == "failed"+ assert native.turns[0].error_details == {+ "message": "Rejected",+ "additionalDetails": "details",+ }diff --git a/uv.lock b/uv.lockindex e0b5729e..210c3d6e 100644--- a/uv.lock+++ b/uv.lock@@ -598,7 +598,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.22.10"+version = "5.23.2"source = { editable = "." }dependencies = [{ name = "aiohttp" },