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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: free-claude-code
-Version: 6.3.2
+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.2 → free_claude_code-6.3.3}/e2e/test_code_sessions.py

@@ -1726,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.2 → 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.2 → 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.2 → 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.2 → 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
-    + ";"
-)

free_claude_code-6.3.3/src/free_claude_code/runtime/sqlite_database.py

@@ -0,0 +1,163 @@
+"""Offline relocation and transactional schema initialization of FCC's database.
+
+The caller must hold the Code owner lock until the store closes. Connections
+opened here never escape initialization, including when migration fails.
+"""
+
+import sqlite3
+from contextlib import closing
+from pathlib import Path
+
+from .sqlite_migrations import MIGRATIONS
+
+# Historical columns identify supported files without depending on live models.
+_BASE_COLUMNS = {
+    "code_sessions": "id cwd model reasoning_effort harness title title_search cwd_search "
+    "auto_title native_thread_id native_may_have_input revision status error created_at updated_at",
+    "code_runs": "session_id id ordinal text model reasoning_effort status submission_started "
+    "native_turn_id stop_requested error error_details created_at finished_at",
+    "code_items": "session_id id run_id sequence native_turn_id native_item_id kind title text detail complete raw",
+    "code_prompts": "session_id id generation request_id native_turn_id native_item_id kind form raw status response_id error",
+    "code_deleted": "id",
+}
+_SIDECARS = ("-wal", "-shm", "-journal")
+
+
+def _connect(path: Path, *, existing: bool = False) -> sqlite3.Connection:
+    connection = sqlite3.connect(
+        path.as_uri() + ("?mode=rw" if existing else "?mode=rwc"),
+        uri=True,
+        timeout=10,
+        autocommit=True,
+    )
+    connection.row_factory = sqlite3.Row
+    connection.execute("PRAGMA foreign_keys = ON")
+    return connection
+
+
+def _schema_version(connection: sqlite3.Connection) -> int:
+    version = connection.execute("PRAGMA user_version").fetchone()[0]
+    if not 0 <= version <= MIGRATIONS[-1][0]:
+        raise sqlite3.DatabaseError(f"Unsupported FCC database version {version}.")
+    tables = {
+        row[0]
+        for row in connection.execute(
+            "SELECT name FROM sqlite_schema WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%'"
+        )
+    }
+    if version == 0 and not tables:
+        return version
+    if tables != _BASE_COLUMNS.keys():
+        raise sqlite3.DatabaseError(
+            "Unrecognized FCC database schema. Saved data was preserved."
+        )
+    for table, baseline in _BASE_COLUMNS.items():
+        expected = set(baseline.split())
+        if version >= 2 and table in ("code_sessions", "code_runs"):
+            expected.add("mode")
+        if version >= 2 and table == "code_sessions":
+            expected.add("native_permission_defaults")
+        if version >= 3 and table == "code_sessions":
+            expected.add("context_used_tokens")
+        actual = {row[1] for row in connection.execute(f"PRAGMA table_info({table})")}
+        if not expected <= actual:
+            raise sqlite3.DatabaseError(f"Incomplete FCC database schema in {table}.")
+    return version
+
+
+def _sidecars(path: Path) -> bool:
+    return any(
+        Path(f"{path}{suffix}").exists() or Path(f"{path}{suffix}").is_symlink()
+        for suffix in _SIDECARS
+    )
+
+
+def _check_path(path: Path) -> None:
+    if path.is_symlink():
+        raise sqlite3.DatabaseError(
+            "FCC database path is redirected. Saved data was preserved."
+        )
+    if not path.exists() and _sidecars(path):
+        raise sqlite3.DatabaseError(
+            "FCC database has orphan journal files. Saved data was preserved."
+        )
+
+
+def _relocate(source: Path, destination: Path) -> None:
+    with closing(_connect(source, existing=True)) as connection:
+        _schema_version(connection)
+        if connection.execute("PRAGMA journal_mode").fetchone()[0] == "wal":
+            busy, pages, checkpointed = connection.execute(
+                "PRAGMA wal_checkpoint(TRUNCATE)"
+            ).fetchone()
+            if busy or pages != checkpointed:
+                raise sqlite3.DatabaseError(
+                    "FCC database checkpoint is busy. Stop FCC before updating."
+                )
+        if connection.execute("PRAGMA journal_mode=DELETE").fetchone()[0] != "delete":
+            raise sqlite3.DatabaseError(
+                "FCC database journals are still in use. Stop FCC before updating."
+            )
+    if _sidecars(source):
+        raise sqlite3.DatabaseError(
+            "FCC database journal files remain. Saved data was preserved."
+        )
+    _check_path(destination)
+    if destination.exists():
+        raise sqlite3.DatabaseError(
+            "FCC has both legacy and current databases. Resolve the file conflict before starting Code."
+        )
+    source.rename(destination)
+
+
+def initialize_database(path: Path, legacy_path: Path | None = None) -> None:
+    """Apply pending migrations, relocating the legacy file first if present."""
+    if tuple(version for version, _ in MIGRATIONS) != tuple(
+        range(1, len(MIGRATIONS) + 1)
+    ):
+        raise sqlite3.DatabaseError(
+            "FCC database migration versions must be contiguous."
+        )
+    path = path.parent.resolve() / path.name
+    _check_path(path)
+    if legacy_path is not None:
+        legacy_path = (
+            legacy_path.parent.parent.resolve()
+            / legacy_path.parent.name
+            / legacy_path.name
+        )
+        if legacy_path.parent.resolve() != legacy_path.parent:
+            raise sqlite3.DatabaseError(
+                "Legacy Code directory is redirected. Saved data was preserved."
+            )
+        _check_path(legacy_path)
+        if legacy_path.exists() and path.exists():
+            raise sqlite3.DatabaseError(
+                "FCC has both legacy and current databases. Resolve the file conflict before starting Code."
+            )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if legacy_path is not None and legacy_path.exists():
+        _relocate(legacy_path, path)
+    with closing(_connect(path)) as connection:
+        version = _schema_version(connection)
+        if connection.execute("PRAGMA journal_mode=WAL").fetchone()[0] != "wal":
+            raise sqlite3.DatabaseError("FCC database could not enable WAL.")
+        for next_version, upgrade in MIGRATIONS:
+            if next_version <= version:
+                continue
+            connection.execute("BEGIN IMMEDIATE")
+            try:
+                upgrade(connection)
+                if (
+                    connection.execute("PRAGMA foreign_key_check").fetchone()
+                    is not None
+                ):
+                    raise sqlite3.DatabaseError(
+                        "FCC database has an invalid record link."
+                    )
+                connection.execute(f"PRAGMA user_version={next_version}")
+                connection.execute("COMMIT")
+            except BaseException:
+                if connection.in_transaction:
+                    connection.execute("ROLLBACK")
+                raise

free_claude_code-6.3.3/src/free_claude_code/runtime/sqlite_migrations/__init__.py

@@ -0,0 +1,17 @@
+"""Ordered FCC database history. Published migrations are immutable.
+
+Add the next numbered module and append its upgrade function here. The runner
+owns transactions and user_version. Migrations use explicit execute statements,
+never executescript, and must not import mutable domain models or serializers.
+"""
+
+import sqlite3
+from collections.abc import Callable
+
+from . import v0001_code_schema, v0002_code_permissions, v0003_code_context_usage
+
+MIGRATIONS: tuple[tuple[int, Callable[[sqlite3.Connection], None]], ...] = (
+    (1, v0001_code_schema.upgrade),
+    (2, v0002_code_permissions.upgrade),
+    (3, v0003_code_context_usage.upgrade),
+)

free_claude_code-6.3.3/src/free_claude_code/runtime/sqlite_migrations/v0001_code_schema.py

@@ -0,0 +1,97 @@
+"""Version 1: baseline Code tables and permanent transcript entries for prompts."""
+
+import sqlite3
+
+_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(
+    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
+)""",
+)
+
+
+def upgrade(connection: sqlite3.Connection) -> None:
+    for statement in _SCHEMA:
+        connection.execute(statement)
+    for prompt in connection.execute(
+        "SELECT * FROM code_prompts ORDER BY rowid"
+    ).fetchall():
+        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 sqlite3.DatabaseError(
+                "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]
+        connection.execute(
+            "INSERT INTO code_items (session_id,id,run_id,sequence,kind,title,text,detail,complete,raw) "
+            "VALUES (?,?,?,?,'prompt','','','',1,'{}')",
+            (prompt["session_id"], prompt["id"], run["id"], sequence),
+        )
+    connection.execute("CREATE TABLE code_prompts_new" + _PROMPT_COLUMNS)
+    columns = "session_id,id,generation,request_id,native_turn_id,native_item_id,kind,form,raw,status,response_id,error"
+    connection.execute(
+        f"INSERT INTO code_prompts_new ({columns}) SELECT {columns} FROM code_prompts"
+    )
+    connection.execute("DROP TABLE code_prompts")
+    connection.execute("ALTER TABLE code_prompts_new RENAME TO code_prompts")

free_claude_code-6.3.3/src/free_claude_code/runtime/sqlite_migrations/v0002_code_permissions.py

@@ -0,0 +1,16 @@
+"""Version 2: persisted permission mode and original native defaults."""
+
+import sqlite3
+
+
+def upgrade(connection: sqlite3.Connection) -> None:
+    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'))"
+    )

free_claude_code-6.3.3/src/free_claude_code/runtime/sqlite_migrations/v0003_code_context_usage.py

@@ -0,0 +1,10 @@
+"""Version 3: optional model context usage for Code sessions."""
+
+import sqlite3
+
+
+def upgrade(connection: sqlite3.Connection) -> None:
+    connection.execute(
+        "ALTER TABLE code_sessions ADD COLUMN context_used_tokens INTEGER "
+        "CHECK(context_used_tokens IS NULL OR context_used_tokens >= 0)"
+    )

free_claude_code-6.3.3/tests/contracts/test_codex_smoke_storage.py

@@ -0,0 +1,58 @@
+"""Exercise the live smoke's SQL assertion without launching a harness."""
+
+import sqlite3
+from contextlib import closing, nullcontext
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from free_claude_code.config.paths import FCC_DATABASE_FILENAME
+from smoke.product import test_codex_modes_product_live as smoke
+
+
+@pytest.mark.parametrize("database_exists", [False, True])
+def test_child_review_smoke_reads_canonical_database_without_creating_files(
+    tmp_path, monkeypatch, database_exists
+):
+    home = tmp_path / "home/.fcc"
+    home.mkdir(parents=True)
+    (home / "code").mkdir()
+    database_path = home / FCC_DATABASE_FILENAME
+    if database_exists:
+        with closing(sqlite3.connect(database_path)) as connection, connection:
+            connection.execute("CREATE TABLE code_sessions(id, native_thread_id)")
+            connection.execute("INSERT INTO code_sessions VALUES ('session','parent')")
+            connection.execute("CREATE TABLE code_items(session_id,kind,raw)")
+            connection.execute(
+                "INSERT INTO code_items VALUES ('session','subagent_auto_review',?)",
+                ('{"threadId":"child"}',),
+            )
+    (tmp_path / "codex-home").mkdir()
+    (tmp_path / "child-marker.txt").write_text("smoke")
+    monkeypatch.setattr(smoke, "_environment", lambda *_: ({}, set()))
+    monkeypatch.setattr(
+        smoke,
+        "_canned_provider",
+        lambda *_: nullcontext(("http://provider.invalid", {"reviews": 1})),
+    )
+    monkeypatch.setattr(
+        smoke,
+        "SmokeServerDriver",
+        lambda *args, **kwargs: SimpleNamespace(
+            run=lambda: nullcontext(SimpleNamespace(base_url="http://server.invalid"))
+        ),
+    )
+
+    async def completed_review(*_):
+        return "session"
+
+    monkeypatch.setattr(smoke, "_exercise_child_review", completed_review)
+    config = MagicMock(spec=smoke.SmokeConfig, timeout_s=1)
+    if database_exists:
+        smoke.test_codex_child_review_local_e2e(config, tmp_path)
+    else:
+        with pytest.raises(sqlite3.OperationalError, match="unable to open"):
+            smoke.test_codex_child_review_local_e2e(config, tmp_path)
+    assert not (home / "code/code.db").exists()
+    assert database_path.exists() == database_exists