fix(react_agent): persist tokens via workspace repo, not control-plane DB (#713) (#785)

* fix(react_agent): persist tokens via workspace repo, not control-plane DB (#713)

_persist_token_usage called Database(...).initialize(), which runs
SchemaManager.create_schema() and seeds users/api_keys/sessions + an
admin@localhost row into every per-workspace state.db. It also masked #712
(initialize 'succeeded' without ever creating token_usage).

Persist through a plain TokenRepository(sync_conn=...) over the workspace DB
instead — reusing the existing INSERT + MetricsTracker cost calc, with no
control-plane schema creation. token_usage itself is created by
workspace._init_database (#712).

Closes #713

* test/style: assert accounts+audit_logs absent, hoist sqlite3 import (#713 review)

Author: frankbria

codeframe/core/react_agent.py

@@ -11,6 +11,7 @@
 import json
 import logging
 import os
+import sqlite3
 import threading
 from pathlib import Path
 from datetime import datetime, timezone
@@ -343,21 +344,27 @@ def _estimate_total_cost(self) -> float:
     def _persist_token_usage(self, task_id: str) -> None:
         """Persist accumulated token records to the workspace database.
 
-        Uses MetricsTracker.record_token_usage_sync for synchronous writes.
+        Writes through a plain per-workspace TokenRepository (issue #713): the
+        control-plane Database.initialize() runs SchemaManager, which seeds
+        users/api_keys/sessions + an admin row into the domain DB. The
+        token_usage table itself is created by workspace._init_database (#712).
         Failures are logged but never propagated to the caller.
-        The database connection is always closed via try/finally.
+        The connection is always closed via try/finally.
         """
         if not self._token_records:
             return
 
-        db = None
+        conn = None
         try:
             from codeframe.lib.metrics_tracker import MetricsTracker
-            from codeframe.platform_store.database import Database
+            from codeframe.platform_store.repositories.token_repository import (
+                TokenRepository,
+            )
 
-            db = Database(str(self.workspace.db_path))
-            db.initialize()
-            tracker = MetricsTracker(db=db)
+            conn = sqlite3.connect(str(self.workspace.db_path))
+            # TokenRepository exposes save_token_usage, the only method
+            # MetricsTracker needs; no control-plane schema is created.
+            tracker = MetricsTracker(db=TokenRepository(sync_conn=conn))
 
             # v1 tasks have integer PKs; v2 workspaces use UUID strings.
             # Pass the raw value — SQLite preserves the type, and downstream
@@ -386,9 +393,9 @@ def _persist_token_usage(self, task_id: str) -> None:
                 "Token usage persistence failed for task %s", task_id, exc_info=True,
             )
         finally:
-            if db is not None:
+            if conn is not None:
                 try:
-                    db.close()
+                    conn.close()
                 except Exception:
                     pass
 

tests/core/test_react_agent_tokens.py

@@ -294,3 +294,57 @@ def test_react_agent_token_persistence_failure_doesnt_crash(
         # Token records should still be available in-memory
         records = agent.get_token_usage()
         assert len(records) == 1
+
+
+class TestPersistDoesNotPolluteWorkspaceDb:
+    """Issue #713 / P0.2: _persist_token_usage must write through the
+    per-workspace schema, NOT the control-plane Database (which seeds
+    users/api_keys/sessions + an admin row into the workspace DB)."""
+
+    def _real_workspace(self, tmp_path):
+        from codeframe.core.workspace import create_or_load_workspace
+
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        return create_or_load_workspace(repo)
+
+    def test_persists_token_usage_without_control_plane_tables(self, tmp_path):
+        import sqlite3
+
+        from codeframe.core.react_agent import ReactAgent
+
+        ws = self._real_workspace(tmp_path)
+        agent = ReactAgent(workspace=ws, llm_provider=MockProvider())
+        agent._token_records = [
+            {
+                "input_tokens": 100,
+                "output_tokens": 50,
+                "model": "claude-sonnet-4-5",
+                "call_type": "task_execution",
+                "iteration": 1,
+            }
+        ]
+
+        agent._persist_token_usage("a1b2c3d4-uuid-task")
+
+        conn = sqlite3.connect(str(ws.db_path))
+        try:
+            row_count = conn.execute("SELECT COUNT(*) FROM token_usage").fetchone()[0]
+            tables = {
+                r[0]
+                for r in conn.execute(
+                    "SELECT name FROM sqlite_master WHERE type='table'"
+                )
+            }
+        finally:
+            conn.close()
+
+        # The record was written...
+        assert row_count == 1
+        # ...and none of the control-plane/auth tables (nor the admin row they
+        # carry) were seeded into the per-workspace domain DB.
+        assert "users" not in tables
+        assert "accounts" not in tables
+        assert "api_keys" not in tables
+        assert "sessions" not in tables
+        assert "audit_logs" not in tables