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
Show Codex sub-agent Auto-review results in Code sessions (#1728)
Ali Khokhardefc7425296c
diff --git a/e2e/test_code_sessions.py b/e2e/test_code_sessions.pyindex 9c1374be..5345152b 100644--- a/e2e/test_code_sessions.py+++ b/e2e/test_code_sessions.py@@ -10,6 +10,7 @@ from free_claude_code.application.code_sessions.models import (PromptRequest,)from free_claude_code.runtime.codex_protocol import CodexProtocol+from tests.code_sessions_support import CodexPackets@pytest.mark.parametrize("width", [1440, 900, 390])@@ -213,6 +214,235 @@ def test_review_updates_inline_and_unfinished_review_settles_after_restart_view(second.close()+def test_child_review_outlives_parent_and_updates_in_place_in_both_tabs(+ page, context, admin_base_url, tmp_path, code_control+):+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "Delegate work")+ connection = code_control.connection()+ packets = CodexPackets(connection)+ code_control.run(packets.spawn())+ second = context.new_page()+ try:+ second.goto(url)+ code_control.run(packets.review())+ review = page.locator('[data-kind="subagent_auto_review"]')+ expect(review.locator("summary")).to_have_text(+ "Sub-agent Auto-review: Reviewing"+ )+ identity = review.get_attribute("data-id")+ review.locator("summary").click()+ code_control.run(connection.finish("turn-1"))+ second.reload()+ expect(+ second.locator('[data-kind="subagent_auto_review"] summary')+ ).to_have_text("Sub-agent Auto-review: Reviewing")+ page.locator("#codeComposer").fill("Continue while reviewing")+ expect(page.locator("#codeSend")).to_be_enabled()+ page.locator("#codeSend").click()+ code_control.run(code_control.harness.wait_inputs(2))+ code_control.run(packets.review(status="approved"))+ expect(review.locator("summary")).to_have_text(+ "Sub-agent Auto-review: Approved"+ )+ expect(review).to_have_attribute("data-id", identity)+ expect(review.locator("details")).to_have_attribute("open", "")+ expect(+ second.locator('[data-kind="subagent_auto_review"] summary')+ ).to_have_text("Sub-agent Auto-review: Approved")+ messages = page.locator(".code-item")+ expect(messages).to_have_count(3)+ expect(messages.nth(1)).to_have_attribute("data-id", identity)+ expect(messages.nth(2)).to_contain_text("Continue while reviewing")+ code_control.run(connection.finish("turn-2"))+ code_control.run(packets.review(review_id="pending"))+ code_control.run(packets.warning())+ expect(page.locator('[data-kind="notice"]')).to_contain_text(+ "Sub-agent: Native warning"+ )+ code_control.run(connection.close())+ expected = [+ "Sub-agent Auto-review: Approved",+ "Sub-agent Auto-review: Result unavailable",+ ]+ expect(page.locator('[data-kind="subagent_auto_review"] summary')).to_have_text(+ expected+ )+ expect(+ second.locator('[data-kind="subagent_auto_review"] summary')+ ).to_have_text(expected)+ page.reload()+ expect(page.locator('[data-kind="subagent_auto_review"] summary')).to_have_text(+ expected+ )+ finally:+ second.close()+++ ("delivery", "status", "title"),+ [+ ("live", "approved", "Approved"),+ ("reconnect", "denied", "Denied"),+ ("stale_snapshot", "approved", "Approved"),+ ],+)+def test_pending_child_review_outside_page_survives_refresh_in_both_tabs(+ page, context, admin_base_url, tmp_path, code_control, delivery, status, title+):+ control_feed(page)+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "Delegate")+ connection = code_control.connection()+ packets = CodexPackets(connection)+ code_control.run(packets.spawn())+ code_control.run(packets.review())+ review = page.locator('[data-kind="subagent_auto_review"]')+ expect(review).to_have_count(1)+ identity = review.get_attribute("data-id")+ code_control.run(connection.finish("turn-1"))+ send(page, "Continue")+ code_control.run(code_control.harness.wait_inputs(2))++ async def more_output():+ for index in range(55):+ await connection.text(+ "turn-2", str(index), f"Output {index}", complete=True+ )+ await connection.finish("turn-2")++ code_control.run(more_output())+ page.reload()+ second = context.new_page()+ try:+ second.goto(url)+ for tab in (page, second):+ expect(+ tab.locator('[data-kind="subagent_auto_review"] summary')+ ).to_have_text("Sub-agent Auto-review: Reviewing")+ expect(tab.locator(".code-item").first).to_have_attribute(+ "data-id", identity+ )+ review.locator("summary").click()+ page.locator("#codeComposer").fill("Keep draft")+ if delivery == "reconnect":+ page.evaluate("window.dropCodeEvents = ['item.updated']")+ elif delivery == "stale_snapshot":+ endpoint = url.replace(admin_base_url, "").replace(+ "/admin/code/", "/admin/api/code/sessions/"+ )+ hold_code_reads(page, endpoint)+ page.evaluate("void window.codeFeed.onerror(new Event('error'))")+ page.wait_for_function(+ "path => window.codeReadHolds.some(held => held.path === path)",+ arg=endpoint,+ )+ code_control.run(packets.review(status=status))+ if delivery == "reconnect":+ page.evaluate(+ "window.dropCodeEvents = []; void window.codeFeed.onerror(new Event('error'))"+ )+ elif delivery == "stale_snapshot":+ expect(review.locator("summary")).to_have_text(+ f"Sub-agent Auto-review: {title}"+ )+ page.evaluate("window.releaseCodeReads()")+ expect(page.locator("#codeSend")).to_be_enabled()+ for tab in (page, second):+ expect(+ tab.locator('[data-kind="subagent_auto_review"] summary')+ ).to_have_text(f"Sub-agent Auto-review: {title}")+ expect(tab.locator(".code-item").first).to_have_attribute(+ "data-id", identity+ )+ expect(tab.locator('[data-kind="subagent_auto_review"]')).to_have_count(1)+ expect(review.locator("details")).to_have_attribute("open", "")+ expect(page.locator("#codeComposer")).to_have_value("Keep draft")+ page.get_by_role("button", name="Load older messages", exact=True).click()+ expect(page.locator(".code-item")).to_have_count(58)+ expect(page.locator('[data-kind="subagent_auto_review"]')).to_have_count(1)+ finally:+ second.close()+++def test_reobserved_child_review_outside_page_appears_without_refresh(+ page, context, admin_base_url, tmp_path, code_control+):+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "Delegate")+ first = code_control.connection()+ packets = CodexPackets(first)+ code_control.run(packets.spawn())+ code_control.run(packets.review())+ review = page.locator('[data-kind="subagent_auto_review"]')+ expect(review).to_have_count(1)+ identity = review.get_attribute("data-id")+ code_control.run(first.finish("turn-1"))+ code_control.run(first.close())+ send(page, "Continue")+ code_control.run(code_control.harness.wait_inputs(2))+ replacement = code_control.harness.connections[-1]++ async def more_output():+ for index in range(55):+ await replacement.text(+ "turn-2", str(index), f"Output {index}", complete=True+ )+ await replacement.finish("turn-2")++ code_control.run(more_output())+ page.reload()+ second = context.new_page()+ try:+ second.goto(url)+ for tab in (page, second):+ expect(tab.locator("#codeOlder")).to_be_visible()+ expect(tab.locator('[data-kind="subagent_auto_review"]')).to_have_count(0)+ packets = CodexPackets(replacement)+ code_control.run(packets.spawn())+ code_control.run(packets.review())+ for tab in (page, second):+ expect(+ tab.locator('[data-kind="subagent_auto_review"] summary')+ ).to_have_text("Sub-agent Auto-review: Reviewing")+ expect(tab.locator(".code-item").first).to_have_attribute(+ "data-id", identity+ )+ code_control.run(packets.review(status="approved"))+ for tab in (page, second):+ expect(+ tab.locator('[data-kind="subagent_auto_review"] summary')+ ).to_have_text("Sub-agent Auto-review: Approved")+ expect(tab.locator('[data-kind="subagent_auto_review"]')).to_have_count(1)+ finally:+ second.close()++[email protected]("change", ["start", "close"])+def test_child_review_liveness_ignores_an_older_detail_snapshot(+ page, admin_base_url, tmp_path, code_control, change+):+ url = create_session(page, admin_base_url, tmp_path)+ send(page, "Delegate")+ connection = code_control.connection()+ packets = CodexPackets(connection)+ code_control.run(packets.spawn())+ code_control.run(connection.finish("turn-1"))+ if change == "close":+ code_control.run(packets.review())+ path = f"{admin_base_url}/admin/api/code/sessions/{url.rsplit('/', 1)[1]}"+ previous = page.request.get(path).json()+ code_control.run(packets.review() if change == "start" else connection.close())+ title = "Sub-agent Auto-review: " + (+ "Reviewing" if change == "start" else "Result unavailable"+ )+ summary = page.locator('[data-kind="subagent_auto_review"] summary')+ expect(summary).to_have_text(title)+ page.route(path, lambda route: route.fulfill(json=previous))+ page.evaluate("window.CodeSessions.refresh()")+ expect(summary).to_have_text(title)++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()@@ -607,7 +837,7 @@ def test_old_detail_cannot_replace_streamed_output(const original = window.fetch;window.fetch = async (...args) => {const result = await original(...args);- if (/\\/api\\/code\\/sessions\\/[0-9a-f-]+$/.test(String(args[0]))) {+ if (/\\/api\\/code\\/sessions\\/[0-9a-f-]+$/.test(new URL(String(args[0]), location.origin).pathname)) {window.detailCaptured = true;await new Promise(resolve => { window.releaseDetail = resolve; });}diff --git a/pyproject.toml b/pyproject.tomlindex 55597a13..06ac82ca 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "6.2.0"+version = "6.2.1"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/smoke/README.md b/smoke/README.mdindex 9768b82c..d5f1fb8a 100644--- a/smoke/README.md+++ b/smoke/README.md@@ -150,7 +150,8 @@ uv run pytest smoke/product/test_nvidia_nim_vision_product_live.py -n 0 -s --tb=Run the installed Codex against a local simulated provider, with disposablesessions and folders. This checks Ask, Auto-review, Full access, and returning-to Use config without spending provider credits:+to Use config without spending provider credits. It also checks a sub-agent's+review completing after the parent reply and a subsequent message:```powershell$env:FCC_LIVE_SMOKE = "1"diff --git a/smoke/capabilities.py b/smoke/capabilities.pyindex 1780919e..ee64a264 100644--- a/smoke/capabilities.py+++ b/smoke/capabilities.py@@ -36,7 +36,11 @@ CAPABILITY_CONTRACTS: tuple[CapabilityContract, ...] = ("tests/runtime/test_code_sessions_sqlite.py","e2e/test_code_sessions.py",),- ("test_codex_modes_local_e2e", "test_codex_modes_free_provider_e2e"),+ (+ "test_codex_modes_local_e2e",+ "test_codex_child_review_local_e2e",+ "test_codex_modes_free_provider_e2e",+ ),),CapabilityContract("api_compatibility",diff --git a/smoke/features.py b/smoke/features.pyindex e665cbe9..561dcfe8 100644--- a/smoke/features.py+++ b/smoke/features.py@@ -38,7 +38,11 @@ FEATURE_INVENTORY: tuple[FeatureCoverage, ...] = ("e2e/test_code_sessions.py",),(),- ("test_codex_modes_local_e2e", "test_codex_modes_free_provider_e2e"),+ (+ "test_codex_modes_local_e2e",+ "test_codex_child_review_local_e2e",+ "test_codex_modes_free_provider_e2e",+ ),("clients",),("Codex executable",diff --git a/smoke/product/test_codex_modes_product_live.py b/smoke/product/test_codex_modes_product_live.pyindex 00ec86a3..a69d5675 100644--- a/smoke/product/test_codex_modes_product_live.py+++ b/smoke/product/test_codex_modes_product_live.py@@ -5,11 +5,12 @@ import jsonimport osimport shleximport shutil+import sqlite3import sysimport threadingimport uuidfrom collections.abc import Iterator-from contextlib import contextmanager+from contextlib import closing, contextmanagerfrom http.server import BaseHTTPRequestHandler, ThreadingHTTPServerfrom pathlib import Pathfrom typing import Any@@ -77,8 +78,32 @@ def _environment(tmp_path: Path, model: str) -> tuple[dict[str, str], set[str]]:return env, unset+def _tool_call(name: str, arguments: dict[str, Any]) -> dict[str, Any]:+ return {+ "tool_calls": [+ {+ "index": 0,+ "id": "call_" + uuid.uuid4().hex,+ "type": "function",+ "function": {"name": name, "arguments": json.dumps(arguments)},+ }+ ]+ }+++def _marker_command(marker: Path) -> str:+ return (+ f"Set-Content -LiteralPath '{str(marker).replace(chr(39), chr(39) * 2)}' -Value smoke"+ if os.name == "nt"+ else f"printf smoke > {shlex.quote(str(marker))}"+ )++@contextmanager-def _canned_provider() -> Iterator[tuple[str, dict[str, Any]]]:+def _canned_provider(+ review_release: threading.Event | None = None,+ child_finished: threading.Event | None = None,+) -> Iterator[tuple[str, dict[str, Any]]]:state: dict[str, Any] = {"requests": [], "command": None, "reviews": 0}class Handler(BaseHTTPRequestHandler):@@ -106,8 +131,19 @@ def _canned_provider() -> Iterator[tuple[str, dict[str, Any]]]:.get("json_schema", {}).get("schema", {}))+ # The child starts without the parent's history. Route the canned+ # actor by that boundary, independently of task-message encoding.+ child_request = child_finished is not None and not any(+ "FCC_PARENT_REVIEW_WORK" in json.dumps(message.get("content", ""))+ for message in request["messages"]+ if message["role"] == "user"+ )if "outcome" in schema.get("properties", {}):state["reviews"] += 1+ if review_release is not None:+ assert review_release.wait(30), (+ "Local child reviewer was not released"+ )delta = {"content": json.dumps({@@ -119,7 +155,35 @@ def _canned_provider() -> Iterator[tuple[str, dict[str, Any]]]:)}reason = "stop"- elif state["command"]:+ elif state.get("spawn"):+ functions = {+ tool["function"]["name"]: tool["function"]+ for tool in request["tools"]+ if tool["type"] == "function"+ }+ spawn_name = next(+ (+ name+ for name in functions+ if name.rsplit("__", 1)[-1] == "spawn_agent"+ ),+ None,+ )+ assert spawn_name is not None, list(functions)+ properties = functions[spawn_name]["parameters"]["properties"]+ arguments = {+ "message": "FCC_CHILD_REVIEW_WORK: Execute the disposable local smoke command, then finish."+ }+ if "task_name" in properties:+ arguments["task_name"] = "smoke_child"+ if "fork_turns" in properties:+ arguments["fork_turns"] = "none"+ elif "fork_context" in properties:+ arguments["fork_context"] = False+ state["spawn"] = False+ delta = _tool_call(spawn_name, arguments)+ reason = "tool_calls"+ elif state["command"] and (child_finished is None or child_request):names = [tool["function"]["name"]for tool in request["tools"]@@ -136,21 +200,11 @@ def _canned_provider() -> Iterator[tuple[str, dict[str, Any]]]:justification="Create the disposable smoke marker",)state["command"] = None- delta = {- "tool_calls": [- {- "index": 0,- "id": "call_" + uuid.uuid4().hex,- "type": "function",- "function": {- "name": "exec_command",- "arguments": json.dumps(arguments),- },- }- ]- }+ delta = _tool_call("exec_command", arguments)reason = "tool_calls"else:+ if child_request and child_finished is not None:+ child_finished.set()delta = {"content": "FCC_MODE_SMOKE_DONE"}reason = "stop"self.send_response(200)@@ -172,7 +226,7 @@ def _canned_provider() -> Iterator[tuple[str, dict[str, Any]]]:self.wfile.flush()except Exception as exc:state["error"] = repr(exc)- self.send_error(500, "Local smoke fixture failed")+ self.send_error(400, "Local smoke fixture failed")server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)server.daemon_threads = True@@ -231,11 +285,7 @@ async def _exercise(changed.raise_for_status()session = changed.json()marker = workspace.parent / f"marker-{uuid.uuid4().hex}.txt"- command = (- f"Set-Content -LiteralPath '{str(marker).replace(chr(39), chr(39) * 2)}' -Value smoke"- if os.name == "nt"- else f"printf smoke > {shlex.quote(str(marker))}"- )+ command = _marker_command(marker)if state is not None:state["command"] = commandstate["mode"] = mode@@ -354,6 +404,178 @@ def test_codex_modes_local_e2e(smoke_config: SmokeConfig, tmp_path: Path) -> Non)+async def _exercise_child_review(+ base_url: str,+ workspace: Path,+ release: threading.Event,+ finished: threading.Event,+ timeout_s: float,+) -> str:+ workspace.mkdir()+ async with httpx.AsyncClient(base_url=base_url, timeout=timeout_s) as client:+ bootstrap = (await client.get("/admin/api/code/bootstrap")).json()+ assert bootstrap["available"], bootstrap+ session_id = str(uuid.uuid4())+ path = f"/admin/api/code/sessions/{session_id}"+ created = await client.post(+ "/admin/api/code/sessions",+ json={"session_id": session_id, "cwd": str(workspace)},+ )+ created.raise_for_status()+ changed = await client.patch(+ path,+ json={+ "expected_revision": created.json()["revision"],+ "mode": "auto_review",+ },+ )+ changed.raise_for_status()+ session = changed.json()+ queue = asyncio.Queue()++ async def send(text: str) -> str:+ response = await client.post(+ path + "/turns",+ json={+ "operation_id": str(uuid.uuid4()),+ "expected_revision": session["revision"],+ "expected_epoch": bootstrap["epoch"],+ "text": text,+ },+ )+ response.raise_for_status()+ return response.json()["id"]++ async def event() -> dict[str, Any]:+ while True:+ value = await queue.get()+ if value.get("session_id") == session_id:+ assert value.get("prompt", {}).get("status") != "pending", value+ run = value.get("run") or {}+ assert run.get("status") not in {"failed", "interrupted"}, value+ return value++ async with client.stream(+ "GET", "/admin/api/code/events", timeout=None+ ) as response:+ response.raise_for_status()+ reading = asyncio.create_task(_events(response, queue))+ try:+ async with asyncio.timeout(timeout_s):+ await queue.get()+ first = await send(+ "FCC_PARENT_REVIEW_WORK: Delegate a harmless local command to one child agent."+ )+ review = None+ parent_done = False+ while review is None or not parent_done:+ value = await event()+ item = value.get("item", {})+ if item.get("kind") == "subagent_auto_review":+ review = item+ parent_done |= (+ value.get("run", {}).get("id") == first+ and value["run"]["status"] == "completed"+ )+ detail = (await client.get(path)).json()+ assert (+ not review["complete"]+ and review["id"] in detail["active_review_ids"]+ ), detail+ session = detail["session"]+ second = await send("Reply while the child review is pending.")+ while True:+ value = await event()+ if (+ value.get("run", {}).get("id") == second+ and value["run"]["status"] == "completed"+ ):+ break+ release.set()+ while True:+ value = await event()+ item = value.get("item", {})+ if item.get("id") == review["id"] and item["complete"]:+ assert item["title"] == "Sub-agent Auto-review: Approved", (+ item+ )+ assert (+ item["run_id"] == first+ and item["sequence"] == review["sequence"]+ ), item+ assert (+ value["run"]["id"] == second+ and value["run"]["status"] == "completed"+ ), value+ break+ assert await asyncio.to_thread(finished.wait, timeout_s), (+ "Child did not finish its command"+ )+ detail = (await client.get(path)).json()+ assert detail["active_review_ids"] == [], detail+ print(+ "child Auto-review: parent finished; next message completed; original review approved"+ )+ finally:+ release.set()+ reading.cancel()+ await asyncio.gather(reading, return_exceptions=True)+ return session_id+++def test_codex_child_review_local_e2e(+ smoke_config: SmokeConfig, tmp_path: Path+) -> None:+ env, unset = _environment(tmp_path, "lmstudio/codex-mode-smoke")+ with (tmp_path / "codex-home" / "config.toml").open(+ "a", encoding="utf-8"+ ) as config:+ config.write("[features]\nmulti_agent = true\nmulti_agent_v2 = true\n")+ release, finished = threading.Event(), threading.Event()+ marker = tmp_path / "child-marker.txt"+ with _canned_provider(release, finished) as (url, state):+ env["LM_STUDIO_BASE_URL"] = url+ state.update(spawn=True, mode="auto_review", command=_marker_command(marker))+ try:+ with SmokeServerDriver(+ smoke_config,+ name="codex-child-review-local",+ env_overrides=env,+ env_unset=unset,+ ).run() as server:+ session_id = asyncio.run(+ _exercise_child_review(+ server.base_url,+ tmp_path / "workspace",+ release,+ finished,+ smoke_config.timeout_s,+ )+ )+ assert marker.read_text().strip() == "smoke"+ with closing(+ sqlite3.connect(tmp_path / "home" / ".fcc" / "code" / "code.db")+ ) as database:+ root = database.execute(+ "SELECT native_thread_id FROM code_sessions WHERE id = ?",+ (session_id,),+ ).fetchone()[0]+ rows = database.execute(+ "SELECT raw FROM code_items WHERE session_id = ? AND kind = 'subagent_auto_review'",+ (session_id,),+ ).fetchall()+ assert rows and all(+ json.loads(row[0])["threadId"] != root for row in rows+ )+ assert "error" not in state, state.get("error")+ assert state["reviews"] == 1+ finally:+ release.set()+ (tmp_path / "child-requests.json").write_text(+ json.dumps(state, indent=2), encoding="utf-8"+ )++def test_codex_modes_free_provider_e2e(smoke_config: SmokeConfig, tmp_path: Path) -> None:diff --git a/src/free_claude_code/api/admin_static/code_sessions.js b/src/free_claude_code/api/admin_static/code_sessions.jsindex 556d49a6..fc232e4c 100644--- a/src/free_claude_code/api/admin_static/code_sessions.js+++ b/src/free_claude_code/api/admin_static/code_sessions.js@@ -78,6 +78,7 @@cursor: -1,items: new Map(),prompts: new Map(),+ activeReviewIds: new Set(),activePrompts: new Map(),runs: new Map(),loaded: false,@@ -118,6 +119,8 @@)record.runNotice = "";record.run = data.run;+ if (data.active_review_ids)+ record.activeReviewIds = new Set(data.active_review_ids);record.version = version;record.cursor = Math.max(record.cursor, data.cursor || 0);if (record.run) accepted(id, record.run.id);@@ -237,10 +240,16 @@const requestEpoch = epoch,token = viewToken,connection = syncToken;+ const params = new URLSearchParams();+ if (before) params.set("before", before);+ else+ // Reconcile unfinished entries even after they fall outside the newest page.+ for (const { value } of get(id).items.values())+ if (!value.complete) params.append("include_item_ids", value.id);let data;try {data = await api(- `${base}/sessions/${id}${before ? `/items?before=${encodeURIComponent(before)}` : ""}`,+ `${base}/sessions/${id}${before ? "/items" : ""}?${params}`,);} catch (error) {if (token !== viewToken || connection !== syncToken || selected !== id)@@ -1216,13 +1225,18 @@insertEntry(parent, node, item.sequence);}const summary = node.querySelector(".code-tool > summary");- if (summary)+ if (summary) {+ const childReview = item.kind === "subagent_auto_review";+ const active = childReview+ ? records.get(selected).activeReviewIds.has(item.id)+ : activeStatuses.has(run.status);summary.textContent =- item.kind === "auto_review" &&+ (childReview || item.kind === "auto_review") &&!item.complete &&- !activeStatuses.has(run.status)- ? "Auto-review: Result unavailable"+ !active+ ? `${childReview ? "Sub-agent " : ""}Auto-review: Result unavailable`: item.title || "Tool";+ }const content = node.querySelector(".code-prose"),value = item.html ?? item.text;if (node.codeText !== value) {diff --git a/src/free_claude_code/api/code_sessions_routes.py b/src/free_claude_code/api/code_sessions_routes.pyindex fdb6c71b..626b875c 100644--- a/src/free_claude_code/api/code_sessions_routes.py+++ b/src/free_claude_code/api/code_sessions_routes.py@@ -174,9 +174,13 @@ async def create(@router.get("/admin/api/code/sessions/{session_id}")async def detail(- session_id: str, services: ApiServices = Depends(get_services)+ session_id: str,+ include_item_ids: tuple[str, ...] = Query(default=()),+ services: ApiServices = Depends(get_services),) -> JsonObject:- return _detail_payload(await _code(services).get_detail(session_id))+ return _detail_payload(+ await _code(services).get_detail(session_id, include_item_ids=include_item_ids)+ )@router.get("/admin/api/code/sessions/{session_id}/items")@@ -303,6 +307,7 @@ def _detail_payload(detail: CodeDetail) -> JsonObject:"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),+ "active_review_ids": list(detail.active_review_ids),"items": [_item_payload(item) for item in detail.items],"prompts": [_prompt_payload(prompt) for prompt in detail.prompts],"epoch": detail.epoch,diff --git a/src/free_claude_code/application/code_sessions/models.py b/src/free_claude_code/application/code_sessions/models.pyindex 72478eaa..032c8ec3 100644--- a/src/free_claude_code/application/code_sessions/models.py+++ b/src/free_claude_code/application/code_sessions/models.py@@ -104,6 +104,7 @@ class CodeDetail:next_before: tuple[int, int] | None = Noneruns: tuple[CodeRun, ...] = ()active_prompt_ids: tuple[str, ...] = ()+ active_review_ids: tuple[str, ...] = ()@dataclass(frozen=True, slots=True)@@ -179,6 +180,7 @@ class HarnessEvent:message: str | None = Nonewill_retry: bool = Falseerror_details: JsonObject = field(default_factory=dict)+ raw: JsonObject = field(default_factory=dict)@dataclass(frozen=True, slots=True)diff --git a/src/free_claude_code/application/code_sessions/ports.py b/src/free_claude_code/application/code_sessions/ports.pyindex 7cce0c8e..016a3aea 100644--- a/src/free_claude_code/application/code_sessions/ports.py+++ b/src/free_claude_code/application/code_sessions/ports.py@@ -160,7 +160,11 @@ class CodeApplicationPort(Protocol):) -> CodePage: ...async def get_detail(- self, session_id: str, *, before: tuple[int, int] | None = None+ self,+ session_id: str,+ *,+ before: tuple[int, int] | None = None,+ include_item_ids: Sequence[str] = (),) -> CodeDetail: ...async def subscribe(self) -> tuple[EventSubscription, JsonObject]: ...diff --git a/src/free_claude_code/application/code_sessions/service.py b/src/free_claude_code/application/code_sessions/service.pyindex 91fb7d72..1f1e256d 100644--- a/src/free_claude_code/application/code_sessions/service.py+++ b/src/free_claude_code/application/code_sessions/service.py@@ -59,6 +59,7 @@ class _Owner:loaded_thread_id: str | None = Nonedirty: set[str] = field(default_factory=set)known_turns: set[str] = field(default_factory=set)+ review_generations: dict[str, str] = field(default_factory=dict)dirty_characters: int = 0storage_failed: bool = Falsefailure_task: asyncio.Task[None] | None = None@@ -75,6 +76,14 @@ class _Owner:for prompt in self.prompts.values())+ @property+ def active_review_ids(self) -> tuple[str, ...]:+ return tuple(+ item_id+ for item_id, generation in self.review_generations.items()+ if generation == self.generation+ )+class CodeService:def __init__(self, store: CodeStore, harness: HarnessFactory) -> None:@@ -212,7 +221,7 @@ class CodeService:{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+ run.native_turn_id for run in runs if run.native_turn_id},)if owner.run and owner.run.native_turn_id:@@ -260,7 +269,12 @@ class CodeService: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")+ and (+ owner.busy+ or owner.pending+ or owner.active_review_ids+ or owner.session.status != "ready"+ )]return subscription, {"epoch": self.epoch,@@ -273,7 +287,11 @@ class CodeService:return self._events.cursorasync def get_detail(- self, session_id: str, *, before: tuple[int, int] | None = None+ self,+ session_id: str,+ *,+ before: tuple[int, int] | None = None,+ include_item_ids: Sequence[str] = (),) -> CodeDetail:owner = await self._owner(session_id)async with owner.lock:@@ -284,17 +302,19 @@ class CodeService:active_start = (owner.run.ordinal, 0)page_before = min(before, active_start) if before else active_startpage = await self._store.item_page(session_id, page_before, 50)- active = [+ included_ids = {*owner.active_review_ids, *include_item_ids}+ extra = [itemfor item in owner.items.values()if (owner.busy and owner.run and item.run_id == owner.run.id)+ or item.id in included_idsor (item.kind == "prompt"and owner.prompts[item.id].status in {"pending", "answering"})]selected = sorted(- {item.id: item for item in [*page.items, *active]}.values(),+ {item.id: item for item in [*page.items, *extra]}.values(),key=lambda item: (owner.runs[item.run_id].ordinal, item.sequence),)prompt_ids = {item.id for item in selected if item.kind == "prompt"}@@ -315,7 +335,7 @@ class CodeService:run.id: runfor run in (*page.runs,- *(owner.runs[item.run_id] for item in active),+ *(owner.runs[item.run_id] for item in extra),*((owner.run,) if owner.run else ()),)}.values()@@ -325,6 +345,7 @@ class CodeService:for prompt in owner.prompts.values()if prompt.status in {"pending", "answering"}),+ owner.active_review_ids,)async def update_settings(@@ -733,7 +754,7 @@ class CodeService:})for item in turn.items:- self._update_item(owner, item, recovered_run=run)+ self._update_item(owner, item, run, historical=True)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()@@ -787,9 +808,7 @@ class CodeService:or not owner.busy):return- owner.connection = None- owner.generation = None- owner.loaded_thread_id = None+ self._detach_connection_locked(owner)await connection.close()async with owner.lock:if owner.run and owner.run.id == run.id and owner.busy:@@ -893,8 +912,37 @@ class CodeService: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)+ elif (+ event.kind == "item"+ and event.item is not None+ and event.item.kind == "subagent_auto_review"+ and run is not None+ ):+ existing = self._native_item(owner, event.item)+ if (+ existing is not None+ and existing.complete+ and not event.item.complete+ ):+ return+ target = owner.runs[existing.run_id] if existing else run+ item = self._update_item(owner, event.item, target)+ previous_generation = owner.review_generations.get(item.id)+ if item.complete:+ owner.review_generations.pop(item.id, None)+ else:+ owner.review_generations[item.id] = event.generation+ if previous_generation != owner.review_generations.get(item.id):+ # Reannounce the saved row when its liveness changes.+ owner.dirty.add(item.id)+ await self._flush_locked(owner)+ elif (+ event.kind == "item"+ and event.item is not None+ and matches+ and run is not None+ ):+ self._update_item(owner, event.item, run)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():@@ -971,6 +1019,7 @@ class CodeService:title="Notice",text=event.message,complete=True,+ raw=event.raw,)await self._persist(owner, owner.session, items=(item,))owner.items[item.id] = item@@ -979,9 +1028,7 @@ class CodeService:owner, "item.updated", item=item.model_dump(mode="json"))elif event.kind == "closed":- owner.connection = None- owner.generation = None- owner.loaded_thread_id = None+ self._detach_connection_locked(owner)if owner.busy:await self._finish_locked(owner,@@ -998,15 +1045,9 @@ class CodeService:"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(+ @staticmethod+ def _native_item(owner: _Owner, update: ItemUpdate) -> CodeItem | None:+ return next((itemfor item in owner.items.values()@@ -1015,6 +1056,18 @@ class CodeService:),None,)++ def _update_item(+ self,+ owner: _Owner,+ update: ItemUpdate,+ run: CodeRun,+ *,+ historical: bool = False,+ ) -> CodeItem:+ if update.kind != "subagent_auto_review":+ owner.known_turns.add(update.turn_id)+ existing = self._native_item(owner, update)if existing is None and update.kind == "user":if update.client_id is not None and update.client_id != run.id:raise CodeUnavailableError(@@ -1051,13 +1104,14 @@ class CodeService:complete=update.complete or bool(existing and existing.complete),)if item == existing:- return+ return existingowner.items[item.id] = itemowner.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+ return itemasync def _flush_later(self, owner: _Owner) -> None:await asyncio.sleep(0.25)@@ -1077,7 +1131,12 @@ class CodeService:owner.dirty.clear()owner.dirty_characters = 0for item in sorted(items, key=lambda value: value.sequence):- self._publish(owner, "item.updated", item=item.model_dump(mode="json"))+ self._publish(+ owner,+ "item.updated",+ item=item.model_dump(mode="json"),+ runs=[owner.runs[item.run_id].model_dump(mode="json")],+ )async def _finish_locked(self,@@ -1162,12 +1221,20 @@ class CodeService:await self._close_connection(owner)self._storage_failure(owner)+ def _detach_connection_locked(self, owner: _Owner) -> HarnessConnection | None:+ connection = owner.connection+ owner.connection = None+ owner.generation = None+ owner.loaded_thread_id = None+ if owner.review_generations:+ owner.review_generations.clear()+ if not owner.deleted:+ self._publish(owner, "session.updated")+ return connection+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+ connection = self._detach_connection_locked(owner)if connection is not None:await connection.close()async with owner.lock:@@ -1293,6 +1360,7 @@ class CodeService:"session_id": owner.session.id,"session": owner.session.model_dump(mode="json"),"run": owner.run.model_dump(mode="json") if owner.run else None,+ "active_review_ids": list(owner.active_review_ids),"version": owner.version,"epoch": self.epoch,}diff --git a/src/free_claude_code/runtime/codex_app_server.py b/src/free_claude_code/runtime/codex_app_server.pyindex e52d57ee..45a5b403 100644--- a/src/free_claude_code/runtime/codex_app_server.py+++ b/src/free_claude_code/runtime/codex_app_server.py@@ -432,8 +432,68 @@ class CodexAppServer:async def _dispatch(self) -> None:while (event := await self._queue.get()) is not None:+ review = event.item is not None and event.item.kind == "auto_review"+ if (+ event.thread_id is not None+ and event.thread_id != self.thread_id+ and (review or (event.kind == "notice" and event.message))+ and await self._owns_thread(event.thread_id)+ ):+ if review and event.item is not None:+ identity = json.dumps(+ [event.thread_id, event.item.raw["reviewId"]],+ separators=(",", ":"),+ )+ event = replace(+ event,+ thread_id=self.thread_id,+ item=replace(+ event.item,+ item_id=f"subagent-auto-review:{identity}",+ kind="subagent_auto_review",+ title=f"Sub-agent {event.item.title}",+ ),+ )+ else:+ event = replace(+ event,+ thread_id=self.thread_id,+ message=f"Sub-agent: {event.message}",+ )await self._sink(event)+ async def _owns_thread(self, thread_id: str) -> bool:+ # Native child listeners can deliver reviews without thread/started.+ # Resolve ancestry from metadata, outside the reader that serves the RPC.+ ancestors: set[str] = set()+ while thread_id not in self._owned_threads:+ if thread_id in ancestors:+ return False+ ancestors.add(thread_id)+ try:+ result = await self.rpc(+ "thread/read", {"threadId": thread_id, "includeTurns": False}+ )+ except (+ CodeConflictError,+ CodeUnavailableError,+ NativeHistoryMissing,+ OSError,+ ):+ return False+ thread = object_value(result.get("thread"))+ if thread.get("id") != thread_id:+ return False+ source = object_value(object_value(thread.get("source")).get("subAgent"))+ parent = string_value(+ object_value(source.get("thread_spawn")).get("parent_thread_id")+ )+ if not parent:+ return False+ thread_id = parent+ self._owned_threads.update(ancestors)+ return True+async def _read_stderr(self) -> None:assert self.process.stderr is not Nonewhile chunk := await self.process.stderr.read(8192):diff --git a/src/free_claude_code/runtime/codex_protocol.py b/src/free_claude_code/runtime/codex_protocol.pyindex 7a1d8081..a09dd228 100644--- a/src/free_claude_code/runtime/codex_protocol.py+++ b/src/free_claude_code/runtime/codex_protocol.py@@ -93,6 +93,7 @@ class CodexProtocol:thread_id,"notice",message=string_value(params.get("message")),+ raw=dict(params),)if not thread_id or not turn_id:return Nonediff --git a/tests/api/test_code_sessions_routes.py b/tests/api/test_code_sessions_routes.pyindex a06f7bbc..80a0e3fe 100644--- a/tests/api/test_code_sessions_routes.py+++ b/tests/api/test_code_sessions_routes.py@@ -9,7 +9,7 @@ from free_claude_code.application.code_sessions import CodeServicefrom free_claude_code.application.errors import ApplicationUnavailableErrorfrom free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStorefrom tests.api.support import create_test_app-from tests.code_sessions_support import FakeHarness+from tests.code_sessions_support import CodexPackets, FakeHarness@pytest_asyncio.fixture@@ -40,6 +40,35 @@ async def create_session(code_api):return response.json()+async def test_detail_exposes_child_review_liveness_without_native_source(code_api):+ client, code, harness, _, _ = code_api+ session = await create_session(code_api)+ path = f"/admin/api/code/sessions/{session['id']}"+ await code.send(+ session["id"],+ str(uuid.uuid4()),+ session["revision"],+ "Delegate",+ expected_epoch=code.epoch,+ )+ await asyncio.wait_for(harness.started.wait(), 3)+ connection = harness.connections[0]+ packets = CodexPackets(connection)+ await packets.spawn()+ await packets.review()+ await connection.finish("turn-1")+ detail = (await client.get(path)).json()+ review = detail["items"][-1]+ assert detail.get("active_review_ids") == [review["id"]]+ assert review["kind"] == "subagent_auto_review"+ assert not {"raw", "native_turn_id", "native_item_id", "generation"} & review.keys()+ await connection.close()+ closed = (await client.get(path)).json()+ assert closed["active_review_ids"] == []+ assert closed["items"] == detail["items"]++@pytest.mark.asyncioasync def test_mode_is_saved_but_native_defaults_stay_private(code_api):client, code, harness, _, _ = code_apidiff --git a/tests/application/test_code_sessions.py b/tests/application/test_code_sessions.pyindex 81676872..fcee592e 100644--- a/tests/application/test_code_sessions.py+++ b/tests/application/test_code_sessions.py@@ -1,5 +1,6 @@import asyncioimport uuid+from unittest.mock import AsyncMock, Mockimport pytestimport pytest_asyncio@@ -14,7 +15,7 @@ from free_claude_code.application.code_sessions.models import ()from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStorefrom free_claude_code.runtime.codex_protocol import CodexProtocol-from tests.code_sessions_support import FakeConnection, FakeHarness+from tests.code_sessions_support import CodexPackets, FakeConnection, FakeHarnessdef new_id():@@ -38,6 +39,282 @@ async def session_for(code):return await service.create_session(new_id(), str(directory))+ ("failure", "finished", "status"),+ [(BrokenPipeError, False, "failed"), (ConnectionResetError, True, "completed")],+)+async def test_child_lookup_pipe_failure_delivers_queued_close(+ code, monkeypatch, failure, finished, status+):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch+ )+ await asyncio.wait_for(harness.started.wait(), 3)+ connection = harness.connections[0]+ packets = CodexPackets(connection)+ await packets.spawn()+ await packets.review()+ if finished:+ await connection.finish("turn-1")+ native = packets.native+ monkeypatch.delattr(native, "rpc")+ native._alive = True+ native._process = Mock(+ stdin=Mock(drain=AsyncMock(side_effect=failure("Pipe closed")))+ )+ await native._packet(+ {+ "method": "guardianWarning",+ "params": {"threadId": "unregistered-child", "message": "Child warning"},+ }+ )+ native._queue.put_nowait(+ HarnessEvent(+ connection.generation,+ connection.thread_id,+ "closed",+ message="Native process ended",+ )+ )+ native._queue.put_nowait(None)+ try:+ await native._dispatch()+ detail = await service.get_detail(session.id)+ assert detail.active_review_ids == ()+ assert detail.run.status == status+ assert [item.kind for item in detail.items] == ["user", "subagent_auto_review"]+ assert not detail.items[-1].complete+ finally:+ for _, future in native._pending.values():+ future.cancel()+++async def test_pending_child_review_outside_page_keeps_its_run_and_history_cursor(code):+ service, harness, _ = code+ session = await session_for(code)+ first = await service.send(+ session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch+ )+ await asyncio.wait_for(harness.started.wait(), 3)+ connection = harness.connections[0]+ packets = CodexPackets(connection)+ await packets.spawn()+ await packets.review()+ review = (await service.get_detail(session.id)).items[-1]+ await connection.finish("turn-1")+ session = (await service.get_detail(session.id)).session+ await service.send(+ session.id, new_id(), session.revision, "Continue", expected_epoch=service.epoch+ )+ await asyncio.wait_for(harness.wait_inputs(2), 3)+ for index in range(55):+ await connection.text("turn-2", str(index), f"Output {index}", complete=True)+ await connection.finish("turn-2")+ newest = await service.get_detail(session.id)+ assert len(newest.items) == 51+ assert newest.items[0].id == review.id and newest.items[0].run_id == first.id+ assert first.id in {run.id for run in newest.runs}+ assert newest.active_review_ids == (review.id,)+ assert newest.next_before == (2, 9)+ await packets.review(status="approved")+ resolved = await service.get_detail(session.id)+ assert resolved.active_review_ids == ()+ assert review.id not in {item.id for item in resolved.items}+ assert resolved.next_before == newest.next_before+ refreshed = await service.get_detail(+ session.id, include_item_ids=(review.id, review.id, "missing")+ )+ assert len(refreshed.items) == 51+ assert refreshed.items[0].id == review.id and refreshed.items[0].complete+ assert first.id in {run.id for run in refreshed.runs}+ assert refreshed.next_before == newest.next_before+ older = await service.get_detail(session.id, before=newest.next_before)+ saved = next(item for item in older.items if item.id == review.id)+ assert saved.complete and saved.title == "Sub-agent Auto-review: Approved"+ assert saved.sequence == review.sequence and saved.run_id == first.id+ merged = {item.id: item for item in (*older.items, *resolved.items)}+ assert sorted(item.sequence for item in merged.values()) == list(range(1, 59))++[email protected]("ownership", ["notification", "metadata"])+async def test_owned_child_reviews_and_warnings_reach_saved_parent_transcript(+ code, ownership+):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch+ )+ await asyncio.wait_for(harness.started.wait(), 3)+ connection = harness.connections[0]+ packets = CodexPackets(connection)+ if ownership == "notification":+ await packets.spawn()+ await packets.spawn("grandchild", "child")+ await packets.spawn("unrelated", "outside")+ else:+ packets.parents.update(+ {+ "child": connection.thread_id,+ "grandchild": "child",+ "unrelated": "outside",+ }+ )+ for child in (connection.thread_id, "child", "grandchild", "unrelated"):+ await packets.review(child, status="approved", turn="turn-1")+ await packets.warning(child)+ detail = await service.get_detail(session.id)+ assert [item.kind for item in detail.items] == [+ "user",+ "auto_review",+ "notice",+ "subagent_auto_review",+ "notice",+ "subagent_auto_review",+ "notice",+ ]+ reviews = [item for item in detail.items if item.kind == "subagent_auto_review"]+ assert len({item.native_item_id for item in reviews}) == 2+ assert [item.raw["threadId"] for item in reviews] == ["child", "grandchild"]+ assert all(item.title == "Sub-agent Auto-review: Approved" for item in reviews)+ assert detail.items[-1].text == "Sub-agent: Native warning"+ assert detail.items[-1].raw == {+ "threadId": "grandchild",+ "message": "Native warning",+ }+ assert await service._store.items(session.id, None, None) == detail.items+ assert detail.run.status == "running"+++async def test_child_review_stays_with_first_entry_after_next_turn_begins(code):+ service, harness, _ = code+ session = await session_for(code)+ first = await service.send(+ session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch+ )+ await asyncio.wait_for(harness.started.wait(), 3)+ connection = harness.connections[0]+ packets = CodexPackets(connection)+ await packets.spawn()+ await packets.review()+ before = await service.get_detail(session.id)+ assert len(before.items) == 2+ review = before.items[-1]+ assert before.active_review_ids == (review.id,)+ await connection.finish("turn-1")+ await packets.send(+ "turn/completed",+ {"threadId": "child", "turn": {"id": "child-turn", "status": "completed"}},+ )+ assert (await service.get_detail(session.id)).active_review_ids == (review.id,)+ subscription, ready = await service.subscribe()+ events = aiter(subscription)+ try:+ assert ready["sessions"][0]["active_review_ids"] == [review.id]+ session = (await service.get_detail(session.id)).session+ harness.start_gate.clear()+ harness.started.clear()+ second = await service.send(+ session.id,+ new_id(),+ session.revision,+ "Continue",+ expected_epoch=service.epoch,+ )+ await asyncio.wait_for(harness.wait_inputs(2), 3)+ await packets.review(status="denied")+ await packets.review(status="denied")+ await packets.review()+ await packets.warning()+ await packets.review(review_id="next", status="approved", turn="turn-2")+ await packets.send(+ "turn/started", {"threadId": "child", "turn": {"id": "turn-2"}}+ )+ await packets.send(+ "turn/completed",+ {"threadId": "child", "turn": {"id": "turn-2", "status": "completed"}},+ )+ detail = await service.get_detail(session.id)+ saved = next(item for item in detail.items if item.id == review.id)+ assert (saved.run_id, saved.sequence, saved.native_turn_id) == (+ first.id,+ review.sequence,+ "child-turn",+ )+ assert saved.title == "Sub-agent Auto-review: Denied" and saved.complete+ assert detail.active_review_ids == ()+ assert detail.run.id == second.id and detail.run.native_turn_id is None+ assert all(item.run_id == second.id for item in detail.items[-3:])+ while (event := await asyncio.wait_for(anext(events), 3)).data.get(+ "item", {}+ ).get("id") != review.id:+ pass+ assert event.data["runs"][0]["id"] == first.id+ assert event.data["run"]["id"] == second.id+ harness.start_gate.set()+ await asyncio.wait_for(harness.started.wait(), 3)+ assert (await service.get_detail(session.id)).run.native_turn_id == "turn-2"+ await connection.finish("turn-2")+ finally:+ harness.start_gate.set()+ await subscription.aclose()++[email protected]("closure", ["native", "service"])+async def test_pending_child_review_becomes_unavailable_when_idle_connection_ends(+ code, closure+):+ service, harness, directory = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch+ )+ await asyncio.wait_for(harness.started.wait(), 3)+ connection = harness.connections[0]+ packets = CodexPackets(connection)+ await packets.spawn()+ await connection.finish("turn-1")+ await packets.review()+ before = await service.get_detail(session.id)+ assert len(before.items) == 2+ review = before.items[-1]+ assert before.active_review_ids == (review.id,)+ subscription, _ = await service.subscribe()+ events = aiter(subscription)+ try:+ if closure == "native":+ await connection.close()+ else:+ await service._close_connection(await service._owner(session.id))+ event = await asyncio.wait_for(anext(events), 3)+ assert event.data["active_review_ids"] == []+ await packets.review(status="approved")+ detail = await service.get_detail(session.id)+ assert detail.items == before.items+ assert detail.active_review_ids == ()+ assert detail.run.status == "completed"+ await service.close()+ restarted = CodeService(+ SQLiteCodeStore(directory / "code.db", directory / "code.lock"), harness+ )+ await restarted.start()+ try:+ restored = await restarted.get_detail(session.id)+ assert restored.items == before.items+ assert restored.active_review_ids == ()+ finally:+ await restarted.close()+ finally:+ await subscription.aclose()++@pytest.mark.asyncioasync def test_mode_is_captured_per_turn_and_does_not_recreate_native_process(code):service, harness, _ = code@@ -67,6 +344,80 @@ async def test_mode_is_captured_per_turn_and_does_not_recreate_native_process(coassert session.native_permission_defaults == harness.permission_defaults[email protected]("pending_output", [False, True])+async def test_reobserved_child_review_publishes_liveness_on_new_native_connection(+ code,+ pending_output,+):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch+ )+ await asyncio.wait_for(harness.started.wait(), 3)+ first = harness.connections[0]+ packets = CodexPackets(first)+ await packets.spawn()+ await packets.review()+ review = (await service.get_detail(session.id)).items[-1]+ await first.finish("turn-1")+ harness.configurations[harness.model] = "replacement"+ session = (await service.get_detail(session.id)).session+ await service.send(+ session.id, new_id(), session.revision, "Continue", expected_epoch=service.epoch+ )+ await asyncio.wait_for(harness.wait_inputs(2), 3)+ second = harness.connections[1]+ if not pending_output:+ await second.finish("turn-2")+ assert (await service.get_detail(session.id)).active_review_ids == ()+ packets = CodexPackets(second)+ await packets.spawn()+ subscription, _ = await service.subscribe()+ try:+ if pending_output:+ await second.text("turn-2", "reply", "In progress")+ await packets.review()+ event = await asyncio.wait_for(anext(aiter(subscription)), 3)+ while event.data["active_review_ids"] != [review.id]:+ event = await asyncio.wait_for(anext(aiter(subscription)), 3)+ assert event.data["active_review_ids"] == [review.id]+ assert event.data.get("item", {}).get("id") == review.id+ assert event.data["runs"][0]["id"] == review.run_id+ detail = await service.get_detail(session.id)+ assert next(item for item in detail.items if item.id == review.id) == review+ assert detail.run.status == ("running" if pending_output else "completed")+ finally:+ await subscription.aclose()+++async def test_forced_interrupt_clears_pending_child_review_liveness(code, monkeypatch):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch+ )+ await asyncio.wait_for(harness.started.wait(), 3)+ connection = harness.connections[0]+ packets = CodexPackets(connection)+ await packets.spawn()+ await packets.review()+ assert (await service.get_detail(session.id)).active_review_ids++ async def unavailable(_turn_id):+ raise CodeUnavailableError("Native interrupt transport failed")++ monkeypatch.setattr(connection, "interrupt", unavailable)+ await service.stop(session.id, (await service.get_detail(session.id)).run.id)+ await asyncio.wait_for(service.wait_idle(session.id), 3)+ detail = await service.get_detail(session.id)+ assert detail.active_review_ids == ()+ assert detail.run.status == "interrupted"+ assert not detail.items[-1].complete++@pytest.mark.asyncioasync def test_mode_change_and_send_compete_for_one_revision(code):service, harness, _ = codediff --git a/tests/code_sessions_support.py b/tests/code_sessions_support.pyindex 83ace4c0..c65ef86f 100644--- a/tests/code_sessions_support.py+++ b/tests/code_sessions_support.py@@ -3,6 +3,7 @@import asyncioimport uuidfrom dataclasses import dataclass+from unittest.mock import AsyncMockfrom free_claude_code.application.code_sessions.models import (CodeCatalog,@@ -22,6 +23,96 @@ from free_claude_code.application.code_sessions.models import (from free_claude_code.application.code_sessions.ports import EventSink, HarnessSelectionfrom free_claude_code.config.model_refs import split_provider_model_reffrom free_claude_code.core.json_types import JsonObject+from free_claude_code.runtime.codex_app_server import CodexAppServer+from free_claude_code.runtime.codex_protocol import CodexProtocol+++class CodexPackets:+ """Feed native packets through the real adapter without starting a process."""++ def __init__(self, connection):+ self.connection = connection+ self.native = CodexAppServer([], {}, "", connection.sink)+ self.native.generation = connection.generation+ self.native._protocol = CodexProtocol(connection.generation)+ self.parents: dict[str, str] = {}+ self.native.rpc = AsyncMock(side_effect=self.metadata)++ async def metadata(self, method: str, params: JsonObject) -> JsonObject:+ assert method == "thread/read" and params["includeTurns"] is False+ identity = params["threadId"]+ assert isinstance(identity, str)+ parent = self.parents.get(identity)+ return {+ "thread": {+ "id": identity,+ "source": {"subAgent": {"thread_spawn": {"parent_thread_id": parent}}}+ if parent+ else "vscode",+ }+ }++ async def send(self, method, params):+ if self.native.thread_id is None:+ future = asyncio.get_running_loop().create_future()+ self.native._pending["register"] = ("thread/resume", future)+ await self.native._packet(+ {+ "id": "register",+ "result": {"thread": {"id": self.connection.thread_id}},+ }+ )+ await self.native._packet({"method": method, "params": params})+ self.native._queue.put_nowait(None)+ await self.native._dispatch()++ async def spawn(self, child="child", parent=None):+ self.parents[child] = parent or self.connection.thread_id+ await self.send(+ "thread/started",+ {+ "thread": {+ "id": child,+ "source": {+ "subAgent": {+ "thread_spawn": {+ "parent_thread_id": parent or self.connection.thread_id,+ "depth": 1 if parent is None else 2,+ }+ }+ },+ }+ },+ )++ async def review(+ self, child="child", review_id="review", status="inProgress", turn="child-turn"+ ):+ payload = {+ "threadId": child,+ "turnId": turn,+ "reviewId": review_id,+ "targetItemId": "command",+ "startedAtMs": 1000,+ "action": {+ "type": "command",+ "command": "echo harmless",+ "cwd": "/tmp",+ "source": "shell",+ },+ "review": {"status": status, "rationale": f"Native {status}"},+ }+ if status != "inProgress":+ payload.update(completedAtMs=2000, decisionSource="agent")+ await self.send(+ "item/autoApprovalReview/started"+ if status == "inProgress"+ else "item/autoApprovalReview/completed",+ payload,+ )++ async def warning(self, child="child", message="Native warning"):+ await self.send("guardianWarning", {"threadId": child, "message": message})class FakeHarness:diff --git a/tests/runtime/codex_fake_process.py b/tests/runtime/codex_fake_process.pyindex b3358842..669b4e53 100644--- a/tests/runtime/codex_fake_process.py+++ b/tests/runtime/codex_fake_process.py@@ -2,6 +2,8 @@import jsonimport sys+import time+from pathlib import Pathdef emit(value):@@ -29,7 +31,7 @@ for line in sys.stdin.buffer:emit({"id": request_id, "result": {"userAgent": "codex/0.153.0"}})elif method == "initialized":pass- elif method == "thread/start":+ elif method in {"thread/start", "thread/resume"}:if mode == "delayed-create":creation_id = request_idelse:@@ -50,6 +52,8 @@ for line in sys.stdin.buffer:)emit({"id": request_id, "result": {}})elif method == "turn/start":+ if mode == "child-warning-on-close":+ turn = request["params"]["clientUserMessageId"]emit({"method": "turn/started",@@ -170,3 +174,14 @@ for line in sys.stdin.buffer:sys.stdout.buffer.flush()else:emit({"id": request_id, "result": {}})++if mode == "child-warning-on-close":+ emit(+ {+ "method": "guardianWarning",+ "params": {"threadId": "child", "message": "Child is shutting down"},+ }+ )+ # Keep stdout alive until the parent has processed this close-time event.+ while not Path(sys.argv[2]).exists():+ time.sleep(0.01)diff --git a/tests/runtime/test_codex_app_server.py b/tests/runtime/test_codex_app_server.pyindex c28d363b..0dd3e552 100644--- a/tests/runtime/test_codex_app_server.py+++ b/tests/runtime/test_codex_app_server.py@@ -1,16 +1,109 @@import asyncioimport osimport sys+import uuidfrom pathlib import Pathfrom unittest.mock import AsyncMockimport pytest+from free_claude_code.application.code_sessions import CodeServicefrom free_claude_code.application.code_sessions.models import CodeUnavailableError+from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStorefrom free_claude_code.runtime.codex_app_server import CodexAppServerfrom tests.code_sessions_support import FakeHarness+async def test_child_warning_during_shutdown_allows_connection_replacement(+ tmp_path, monkeypatch+):+ harness = FakeHarness()+ prepare = harness.prepare+ connections = []+ releases = []+ warning = asyncio.Event()++ def selection_for(model, effort, mode):+ selection = prepare(model, effort, mode)++ async def open_native(cwd, sink):+ release = tmp_path / f"release-{len(connections)}"+ releases.append(release)++ async def receive(event):+ await sink(event)+ if event.kind == "notice" and event.thread_id == "child":+ warning.set()++ native = CodexAppServer(+ [+ sys.executable,+ str(Path(__file__).with_name("codex_fake_process.py")),+ "child-warning-on-close",+ str(release),+ ],+ dict(os.environ),+ cwd,+ receive,+ model_slugs={model: model},+ fingerprints=selection.catalog,+ )+ await native.start()+ connections.append(native)+ return native++ monkeypatch.setattr(selection, "open", open_native)+ return selection++ monkeypatch.setattr(harness, "prepare", selection_for)+ service = CodeService(+ SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock"), harness+ )+ await service.start()+ observing = asyncio.create_task(warning.wait())+ try:+ session = await service.create_session(str(uuid.uuid4()), str(tmp_path))+ await service.send(+ session.id,+ str(uuid.uuid4()),+ session.revision,+ "First",+ expected_epoch=service.epoch,+ )+ await asyncio.wait_for(service.wait_idle(session.id), 3)+ first = await service.get_detail(session.id)+ assert first.run is not None+ assert first.run.status == "completed"+ harness.configurations[harness.model] = "replacement"+ await service.send(+ session.id,+ str(uuid.uuid4()),+ first.session.revision,+ "Next",+ expected_epoch=service.epoch,+ )+ dispatcher = connections[0]._dispatcher+ assert dispatcher is not None+ processed, _ = await asyncio.wait(+ (observing, dispatcher), timeout=3, return_when=asyncio.FIRST_COMPLETED+ )+ assert processed, "The close-time warning was never processed"+ releases[0].touch()+ await asyncio.wait_for(service.wait_idle(session.id), 3)+ detail = await service.get_detail(session.id)+ assert detail.run is not None+ assert detail.run.status == "completed", detail.run.error+ assert len(connections) == 2 and connections[0].process.returncode is not None+ assert all(item.kind != "notice" for item in detail.items)+ finally:+ for release in releases:+ release.touch()+ observing.cancel()+ await asyncio.gather(observing, return_exceptions=True)+ await service.close()++@pytest.mark.asyncio@pytest.mark.parametrize("profile", [None, {"id": "custom"}])async def test_complete_mode_overrides_restore_native_defaults(diff --git a/uv.lock b/uv.lockindex 0c26f99d..0f521c77 100644--- a/uv.lock+++ b/uv.lock@@ -598,7 +598,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "6.2.0"+version = "6.2.1"source = { editable = "." }dependencies = [{ name = "aiohttp" },