free-claude-code 6.3.1__tar.gz → 6.3.3__tar.gz

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: free-claude-code
-Version: 6.3.1
+Version: 6.3.3
 Summary: Local proxy connecting coding agents to OpenAI-compatible AI providers
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/e2e/test_code_sessions.py

@@ -597,14 +597,18 @@ def test_settings_apply_preserves_open_creation_and_picker(
     page, admin_base_url, tmp_path, code_control
 ):
     pending = []
-    page.route("**/admin/api/config/apply", lambda route: pending.append(route))
-    page.expose_function("applyRequestIntercepted", lambda: bool(pending))
+
+    def capture_apply(route):
+        pending.append(route)
+        page.evaluate("window.applyRequestIntercepted = true")
+
+    page.route("**/admin/api/config/apply", capture_apply)
     page.goto(f"{admin_base_url}/admin")
     expect(page.locator("#messageArea")).to_have_text("")
     page.locator("#field-PORT").fill("8081")
     page.get_by_role("button", name="Apply", exact=True).click()
     expect(page.locator("#messageArea")).to_have_text("Applying…")
-    page.wait_for_function("window.applyRequestIntercepted()")
+    page.wait_for_function("window.applyRequestIntercepted === true")
     assert len(pending) == 1
     page.get_by_role("button", name="Code sessions", exact=True).click()
     page.get_by_role("button", name="New code session", exact=True).click()
@@ -1722,7 +1726,13 @@ def test_off_clears_effort_when_reasoning_becomes_unavailable(
 ):
     url = create_session(page, admin_base_url, tmp_path)
     effort = page.locator("#codeReasoning")
-    effort.select_option("high")
+    with page.expect_response(
+        lambda response: (
+            response.request.method == "PATCH" and "/api/code/sessions/" in response.url
+        )
+    ) as changed:
+        effort.select_option("high")
+    assert changed.value.json()["reasoning_effort"] == "high"
     expect(effort).to_be_enabled()
     page.locator("#codeComposer").fill("Preserve this draft")
     code_control.harness.efforts = ("off",)

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/smoke/lib/e2e.py

@@ -32,6 +32,7 @@ from free_claude_code.messaging.voice import VoiceCancellationResult
 from free_claude_code.messaging.workflow import MessagingWorkflow
 from smoke.lib.child_process import run_captured_text
 from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
+from smoke.lib.http import conversation_headers
 from smoke.lib.server import RunningServer, start_server
 from smoke.lib.skips import fail_missing_env, skip_if_upstream_unavailable_events
 
@@ -88,6 +89,7 @@ class ConversationDriver:
         self.config = config
         self.messages: list[dict[str, Any]] = []
         self.turns: list[ConversationTurn] = []
+        self._session_id = str(uuid.uuid4())
 
     def ask(
         self,
@@ -120,7 +122,7 @@ class ConversationDriver:
         *,
         headers: dict[str, str] | None = None,
     ) -> ConversationTurn:
-        request_headers = headers or auth_headers()
+        request_headers = conversation_headers(headers, session_id=self._session_id)
         stream_payload = {**payload, "stream": True}
         with httpx.stream(
             "POST",
@@ -148,7 +150,7 @@ class ConversationDriver:
     ) -> dict[str, Any]:
         response = httpx.post(
             f"{self.server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=conversation_headers(session_id=self._session_id),
             json=payload,
             timeout=self.config.timeout_s,
         )

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/smoke/lib/http.py

@@ -1,5 +1,6 @@
 """HTTP helpers for live smoke requests."""
 
+import uuid
 from typing import Any
 
 import httpx
@@ -10,6 +11,16 @@ from .config import SmokeConfig, auth_headers, redacted
 from .server import RunningServer
 
 
+def conversation_headers(
+    headers: dict[str, str] | None = None, *, session_id: str | None = None
+) -> dict[str, str]:
+    """Identify a smoke conversation while preserving explicit caller headers."""
+    result = httpx.Headers(auth_headers() if headers is None else headers)
+    result.setdefault("user-agent", "fcc-smoke/1.0")
+    result.setdefault("x-opencode-session", session_id or str(uuid.uuid4()))
+    return dict(result)
+
+
 def message_payload(
     text: str,
     *,
@@ -35,7 +46,7 @@ def post_json(
     *,
     headers: dict[str, str] | None = None,
 ) -> httpx.Response:
-    request_headers = headers or auth_headers()
+    request_headers = conversation_headers(headers)
     response = httpx.post(
         f"{server.base_url}{path}",
         headers=request_headers,
@@ -52,7 +63,7 @@ def collect_message_stream(
     *,
     headers: dict[str, str] | None = None,
 ) -> list[SSEEvent]:
-    request_headers = headers or auth_headers()
+    request_headers = conversation_headers(headers)
     stream_payload = {**payload, "stream": True}
     with httpx.stream(
         "POST",

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/smoke/prereq/test_provider_prereq_live.py

@@ -8,9 +8,9 @@ from free_claude_code.core.anthropic.stream_contracts import (
     text_content,
     thinking_content,
 )
-from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
+from smoke.lib.config import ProviderModel, SmokeConfig
 from smoke.lib.e2e import ProviderMatrixDriver
-from smoke.lib.http import collect_message_stream, message_payload
+from smoke.lib.http import collect_message_stream, conversation_headers, message_payload
 from smoke.lib.server import start_server
 from smoke.lib.skips import (
     skip_if_upstream_unavailable_events,
@@ -97,7 +97,7 @@ def test_client_disconnect_mid_stream_does_not_crash_server(
         with httpx.stream(
             "POST",
             f"{server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=conversation_headers(),
             json=message_payload(smoke_config.prompt, model="fcc-smoke-default"),
             timeout=smoke_config.timeout_s,
         ) as response:

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/smoke/product/test_codex_modes_product_live.py

@@ -22,6 +22,7 @@ from free_claude_code.config.env_migrations import (
     atomic_write_managed_config,
     settings_env_keys,
 )
+from free_claude_code.config.paths import FCC_DATABASE_FILENAME
 from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
 from smoke.lib.child_process import run_captured_text
 from smoke.lib.config import SmokeConfig
@@ -554,7 +555,11 @@ def test_codex_child_review_local_e2e(
                 )
                 assert marker.read_text().strip() == "smoke"
                 with closing(
-                    sqlite3.connect(tmp_path / "home" / ".fcc" / "code" / "code.db")
+                    sqlite3.connect(
+                        (tmp_path / "home" / ".fcc" / FCC_DATABASE_FILENAME).as_uri()
+                        + "?mode=ro",
+                        uri=True,
+                    )
                 ) as database:
                     root = database.execute(
                         "SELECT native_thread_id FROM code_sessions WHERE id = ?",

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/smoke/product/test_provider_product_live.py

@@ -9,7 +9,7 @@ from free_claude_code.core.anthropic.stream_contracts import (
     SSEEvent,
     parse_sse_lines,
 )
-from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
+from smoke.lib.config import ProviderModel, SmokeConfig
 from smoke.lib.e2e import (
     ConversationDriver,
     ProviderMatrixDriver,
@@ -19,7 +19,7 @@ from smoke.lib.e2e import (
     echo_tool_schema,
     tool_use_blocks,
 )
-from smoke.lib.http import collect_message_stream
+from smoke.lib.http import collect_message_stream, conversation_headers
 from smoke.lib.skips import (
     skip_if_upstream_unavailable_events,
     skip_if_upstream_unavailable_exception,
@@ -166,7 +166,7 @@ def test_provider_error_e2e(smoke_config: SmokeConfig) -> None:
     ):
         response = client.post(
             f"{server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=conversation_headers(),
             json={
                 "model": "fcc-smoke-default",
                 "max_tokens": 32,
@@ -605,11 +605,12 @@ def _scenario_reasoning_tool_continuation(
 def _scenario_disconnect(
     smoke_config: SmokeConfig, provider_model: ProviderModel
 ) -> None:
+    headers = conversation_headers()
     with _server_for_provider(smoke_config, provider_model, "disconnect") as server:
         with httpx.stream(
             "POST",
             f"{server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=headers,
             json={
                 "model": "fcc-smoke-default",
                 "max_tokens": 512,
@@ -623,7 +624,7 @@ def _scenario_disconnect(
         health = httpx.get(f"{server.base_url}/health", timeout=5)
         assert health.status_code == 200
         followup = ConversationDriver(server, smoke_config).ask(
-            "Reply with one short sentence."
+            "Reply with one short sentence.", headers=headers
         )
     _assert_provider_product_stream(followup.events)
 
@@ -646,4 +647,4 @@ def _openai_auth_headers(smoke_config: SmokeConfig) -> dict[str, str]:
     token = smoke_config.settings.proxy_auth_token
     if token:
         headers["authorization"] = f"Bearer {token}"
-    return headers
+    return conversation_headers(headers)

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/src/free_claude_code/config/paths.py

@@ -17,6 +17,7 @@ CONFIG_LOCK_FILENAME = "config.lock"
 FCC_TEMP_DIRNAME = "tmp"
 LAUNCHER_TEMP_DIRNAME = "launchers"
 CODE_STATE_DIRNAME = "code"
+FCC_DATABASE_FILENAME = "fcc.db"
 CODE_DATABASE_FILENAME = "code.db"
 CODE_LOCK_FILENAME = "code.lock"
 
@@ -45,8 +46,13 @@ def launcher_temp_dir_path() -> Path:
     return config_dir_path() / FCC_TEMP_DIRNAME / LAUNCHER_TEMP_DIRNAME
 
 
-def code_database_path() -> Path:
-    """Return the managed Code sessions database path."""
+def fcc_database_path() -> Path:
+    """Return the shared FCC database path."""
+    return config_dir_path() / FCC_DATABASE_FILENAME
+
+
+def legacy_code_database_path() -> Path:
+    """Return the former Code database path for startup relocation."""
     return config_dir_path() / CODE_STATE_DIRNAME / CODE_DATABASE_FILENAME
 
 

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/src/free_claude_code/providers/nvidia_nim/client.py

@@ -33,7 +33,6 @@ from .request_options import (
 )
 from .retry import (
     clone_body_without_chat_template,
-    clone_body_without_reasoning_budget,
     clone_body_without_reasoning_content,
 )
 from .tool_schema import (
@@ -61,10 +60,7 @@ class NvidiaNimChatBehavior(OpenAIChatBehavior):
 
     @property
     def reasoning_off_fields(self) -> tuple[tuple[str, ...], ...]:
-        return (
-            ("extra_body", "chat_template_kwargs", "thinking"),
-            ("extra_body", "chat_template_kwargs", "enable_thinking"),
-        )
+        return (("reasoning_effort",),)
 
     @property
     def normal_max_tokens(self) -> int | None:
@@ -118,17 +114,6 @@ class NvidiaNimChatBehavior(OpenAIChatBehavior):
             error_text = f"{error_text} {json.dumps(error_body, default=str)}"
         error_text = error_text.lower()
 
-        if _is_reasoning_budget_rejection(error_text) and (
-            bad_request_like or status_code == 500
-        ):
-            retry_body = clone_body_without_reasoning_budget(body)
-            if retry_body is None:
-                return None
-            logger.warning(
-                "NIM_STREAM: retrying without reasoning budget after upstream rejection"
-            )
-            return retry_body
-
         if not bad_request_like:
             return None
 
@@ -215,10 +200,3 @@ def _is_degraded_function(body: Mapping[str, Any]) -> bool:
         and function_id
         and state.strip() == _DEGRADED_FUNCTION_STATE
     )
-
-
-def _is_reasoning_budget_rejection(error_text: str) -> bool:
-    """Return whether NIM rejected optional thinking budget control."""
-    if "reasoning_budget" in error_text:
-        return True
-    return "thinking_token_budget" in error_text and "reasoning_config" in error_text

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/src/free_claude_code/providers/nvidia_nim/request_options.py

@@ -6,14 +6,21 @@ from typing import Any
 from free_claude_code.config.nim import NimSettings
 from free_claude_code.core.anthropic import ReasoningReplayMode, set_if_not_none
 from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
+from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
 from free_claude_code.providers.openai_chat import (
+    NamedEffortReasoning,
     OpenAIChatRequestPolicy,
     build_openai_chat_request_body,
 )
 
 from .tool_schema import sanitize_nim_tool_schemas
 
+NIM_REASONING = NamedEffortReasoning(
+    tuple((effort, effort.value) for effort in ReasoningEffort),
+    disabled_value="none",
+    enabled_value="high",
+)
+
 NIM_REQUEST_POLICY = OpenAIChatRequestPolicy(
     provider_name="NIM",
     reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,
@@ -106,14 +113,7 @@ def apply_nim_request_options(
         if not request_template_kwargs:
             extra_body.pop("chat_template_kwargs", None)
 
-    if reasoning.control is ReasoningControl.OFF or reasoning.requests_reasoning:
-        chat_template_kwargs = extra_body.setdefault("chat_template_kwargs", {})
-        if isinstance(chat_template_kwargs, dict):
-            enabled = reasoning.control is not ReasoningControl.OFF
-            chat_template_kwargs["thinking"] = enabled
-            chat_template_kwargs["enable_thinking"] = enabled
-            if enabled and (budget := reasoning.numeric_budget_tokens) is not None:
-                chat_template_kwargs["reasoning_budget"] = budget
+    NIM_REASONING.encode(body, reasoning)
 
     _set_extra(extra_body, "top_k", nim.top_k, ignore_value=-1)
     _set_extra(extra_body, "min_p", nim.min_p, ignore_value=0.0)

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/src/free_claude_code/providers/nvidia_nim/retry.py

@@ -7,11 +7,6 @@ from typing import Any
 from free_claude_code.core.history_replay import reasoning_context
 
 
-def clone_body_without_reasoning_budget(body: dict[str, Any]) -> dict[str, Any] | None:
-    """Clone a request body and strip only reasoning_budget fields."""
-    return _clone_strip_extra_body(body, _strip_reasoning_budget_fields)
-
-
 def clone_body_without_chat_template(body: dict[str, Any]) -> dict[str, Any] | None:
     """Clone a request body and strip NIM chat-template control fields."""
     return _clone_strip_extra_body(body, _strip_chat_template_fields)
@@ -42,17 +37,6 @@ def _clone_strip_extra_body(
     return cloned_body
 
 
-def _strip_reasoning_budget_fields(extra_body: dict[str, Any]) -> bool:
-    removed = extra_body.pop("reasoning_budget", None) is not None
-    chat_template_kwargs = extra_body.get("chat_template_kwargs")
-    if (
-        isinstance(chat_template_kwargs, dict)
-        and chat_template_kwargs.pop("reasoning_budget", None) is not None
-    ):
-        removed = True
-    return removed
-
-
 def _strip_chat_template_fields(extra_body: dict[str, Any]) -> bool:
     removed = extra_body.pop("chat_template", None) is not None
     if extra_body.pop("chat_template_kwargs", None) is not None:

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/src/free_claude_code/runtime/bootstrap.py

@@ -11,8 +11,9 @@ from free_claude_code.application.code_sessions import CodeService
 from free_claude_code.config.loader import ManagedConfigStore
 from free_claude_code.config.logging_config import configure_logging
 from free_claude_code.config.paths import (
-    code_database_path,
     code_lock_path,
+    fcc_database_path,
+    legacy_code_database_path,
     server_log_path,
 )
 from free_claude_code.config.settings import Settings
@@ -73,7 +74,11 @@ def build_asgi_app(
         model_catalog_publisher=CodexModelCatalogPublisher(),
     )
     code_service = CodeService(
-        SQLiteCodeStore(code_database_path(), code_lock_path()),
+        SQLiteCodeStore(
+            fcc_database_path(),
+            code_lock_path(),
+            legacy_database_path=legacy_code_database_path(),
+        ),
         CodexHarnessFactory(provider_manager),
     )
     runtime = ApplicationRuntime(

{free_claude_code-6.3.1 → free_claude_code-6.3.3}/src/free_claude_code/runtime/code_sessions_sqlite.py

@@ -25,6 +25,8 @@ from free_claude_code.application.code_sessions.models import (
 )
 from free_claude_code.core.interprocess_lock import InterprocessFileLock
 
+from .sqlite_database import initialize_database
+
 _JSON_FIELDS = frozenset(
     {"raw", "form", "error_details", "request_id", "native_permission_defaults"}
 )
@@ -299,58 +301,16 @@ def _write_prompt(connection: sqlite3.Connection, prompt: CodePrompt) -> None:
     )
 
 
-def _migrate_prompt_entries(connection: sqlite3.Connection) -> None:
-    """Give old prompts a permanent run-end position without rewriting history."""
-    for row in connection.execute(
-        "SELECT * FROM code_prompts ORDER BY rowid"
-    ).fetchall():
-        prompt = _record(CodePrompt, row)
-        run = connection.execute(
-            "SELECT id FROM code_runs WHERE session_id = ? AND native_turn_id = ?",
-            (prompt.session_id, prompt.native_turn_id),
-        ).fetchone()
-        if run is None and prompt.native_item_id is not None:
-            matches = connection.execute(
-                "SELECT DISTINCT run_id AS id FROM code_items WHERE session_id = ? AND native_item_id = ?",
-                (prompt.session_id, prompt.native_item_id),
-            ).fetchall()
-            if len(matches) == 1:
-                run = matches[0]
-        if run is None:
-            run = connection.execute(
-                "SELECT id FROM code_runs WHERE session_id = ? ORDER BY ordinal DESC LIMIT 1",
-                (prompt.session_id,),
-            ).fetchone()
-        if run is None:
-            raise CodeUnavailableError("A saved prompt has no saved conversation turn.")
-        sequence = connection.execute(
-            "SELECT COALESCE(MAX(sequence), 0) + 1 FROM code_items WHERE session_id = ?",
-            (prompt.session_id,),
-        ).fetchone()[0]
-        _insert(
-            connection,
-            "code_items",
-            CodeItem(
-                id=prompt.id,
-                session_id=prompt.session_id,
-                run_id=run["id"],
-                sequence=sequence,
-                kind="prompt",
-                complete=True,
-            ),
-        )
-    connection.execute("CREATE TABLE code_prompts_new" + _PROMPT_COLUMNS)
-    connection.execute("INSERT INTO code_prompts_new SELECT * FROM code_prompts")
-    connection.execute("DROP TABLE code_prompts")
-    connection.execute("ALTER TABLE code_prompts_new RENAME TO code_prompts")
-    if connection.execute("PRAGMA foreign_key_check").fetchone() is not None:
-        raise CodeUnavailableError("Code session history has an invalid record link.")
-    connection.execute("PRAGMA user_version = 1")
-
-
 class SQLiteCodeStore:
-    def __init__(self, database_path: Path, lock_path: Path) -> None:
+    def __init__(
+        self,
+        database_path: Path,
+        lock_path: Path,
+        *,
+        legacy_database_path: Path | None = None,
+    ) -> None:
         self._path = database_path
+        self._legacy_path = legacy_database_path
         self._lock = InterprocessFileLock(lock_path)
         self._started = False
         self._lifecycle = asyncio.Lock()
@@ -371,14 +331,28 @@ class SQLiteCodeStore:
             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)
+        try:
+            self._path.parent.mkdir(parents=True, exist_ok=True)
+            if os.name != "nt":
+                self._path.parent.chmod(0o700)
+            initialize_database(self._path, self._legacy_path)
+        except sqlite3.IntegrityError as exc:
+            raise CodeConflictError(
+                "Saved Code history conflicts with its schema."
+            ) from exc
+        except sqlite3.Error as exc:
+            raise CodeUnavailableError(
+                f"Code storage initialization failed: {exc}"
+            ) from exc
+        except OSError as exc:
+            raise CodeUnavailableError(
+                "Code database files could not be initialized or moved."
+            ) from exc
+        self._execute(self._recover)
         if os.name != "nt":
             for path in (
                 self._path,
@@ -412,30 +386,7 @@ class SQLiteCodeStore:
             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")
-        if connection.execute("PRAGMA user_version").fetchone()[0] == 0:
-            _migrate_prompt_entries(connection)
-        if connection.execute("PRAGMA user_version").fetchone()[0] == 1:
-            for table in ("code_sessions", "code_runs"):
-                connection.execute(
-                    f"ALTER TABLE {table} ADD COLUMN mode TEXT NOT NULL DEFAULT 'config' "
-                    "CHECK(mode IN ('config','ask','auto_review','full_access'))"
-                )
-            connection.execute(
-                "ALTER TABLE code_sessions ADD COLUMN native_permission_defaults TEXT "
-                "CHECK(native_permission_defaults IS NULL OR "
-                "(json_valid(native_permission_defaults) AND json_type(native_permission_defaults) = 'object'))"
-            )
-            connection.execute("PRAGMA user_version = 2")
-        if connection.execute("PRAGMA user_version").fetchone()[0] == 2:
-            connection.execute(
-                "ALTER TABLE code_sessions ADD COLUMN context_used_tokens INTEGER "
-                "CHECK(context_used_tokens IS NULL OR context_used_tokens >= 0)"
-            )
-            connection.execute("PRAGMA user_version = 3")
+    def _recover(self, connection: sqlite3.Connection) -> None:
         connection.execute(
             "UPDATE code_runs SET status = 'interrupted', finished_at = ?, error = ? "
             "WHERE status IN ('preparing','running','stopping')",
@@ -735,51 +686,3 @@ class SQLiteCodeStore:
             connection.execute("DELETE FROM code_sessions WHERE id = ?", (session_id,))
 
         await self._run(operation)
-
-
-_PROMPT_COLUMNS = """(
-    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),
-    FOREIGN KEY(session_id,id) REFERENCES code_items(session_id,id) ON DELETE CASCADE
-)"""
-
-_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_deleted(id TEXT PRIMARY KEY NOT NULL);
-"""
-    + "CREATE TABLE IF NOT EXISTS code_prompts"
-    + _PROMPT_COLUMNS
-    + ";"
-)