create-workframe 0.1.14 → 0.1.16

package/workframe-api/test_api_errors.py

@@ -0,0 +1,33 @@
+"""api_errors public payload self-check."""
+from __future__ import annotations
+
+import urllib.error
+
+import api_errors
+
+
+def main() -> None:
+    raw = (
+        "runtime profile create failed: Traceback (most recent call last):\n"
+        '  File "/opt/hermes/hermes_cli/profiles.py", line 1\n'
+        "PermissionError: [Errno 13] Permission denied: '/opt/data/profiles/u-test-agent'"
+    )
+    payload = api_errors.public_api_error_payload(ValueError(raw))
+    assert payload["error"] == "runtime_profile_permission_denied"
+    assert "Traceback" not in payload["message"]
+    assert payload["message"]
+    assert payload["hint"]
+
+    assert api_errors.http_status_for_code("no_session") == 401
+    assert api_errors.http_status_for_code("room_not_found") == 404
+
+    refused = api_errors.public_api_error_payload(
+        urllib.error.URLError("[Errno 111] Connection refused"),
+    )
+    assert refused["error"] == "runtime_profile_api_config_failed"
+
+    print("test_api_errors: ok")
+
+
+if __name__ == "__main__":
+    main()

package/workframe-api/test_enrich_room_messages.py

@@ -0,0 +1,72 @@
+"""Regression: _enrich_room_messages must not reference undefined _srv in server.py."""
+
+from __future__ import annotations
+
+import os
+import sqlite3
+import sys
+import uuid
+from pathlib import Path
+
+API_DIR = Path(__file__).resolve().parent
+if str(API_DIR) not in sys.path:
+    sys.path.insert(0, str(API_DIR))
+
+os.environ.setdefault("WORKFRAME_API_DATA_DIR", str(API_DIR / ".tmp-test-data"))
+os.environ.setdefault("HERMES_DATA", str(API_DIR / ".tmp-test-hermes"))
+os.environ.setdefault("DEV_LOCAL_UNSAFE", "true")
+
+import server  # noqa: E402
+
+
+def test_enrich_room_messages_with_agent_sender(tmp_path: Path) -> None:
+    db = tmp_path / "workframe.db"
+    conn = sqlite3.connect(db)
+    conn.row_factory = sqlite3.Row
+    now = "1700000000"
+    agent_id = str(uuid.uuid4())
+    room_id = str(uuid.uuid4())
+    msg_id = str(uuid.uuid4())
+    conn.executescript(
+        f"""
+        CREATE TABLE agent_profiles (
+            id TEXT PRIMARY KEY,
+            slug TEXT,
+            display_name TEXT,
+            model_name TEXT,
+            model_provider TEXT,
+            deleted_at TEXT
+        );
+        CREATE TABLE messages (
+            id TEXT PRIMARY KEY,
+            room_id TEXT,
+            sender_user_id TEXT,
+            sender_agent_id TEXT,
+            parent_message_id TEXT,
+            content TEXT,
+            content_type TEXT,
+            metadata TEXT,
+            is_edited INTEGER,
+            created_at TEXT,
+            updated_at TEXT,
+            deleted_at TEXT
+        );
+        INSERT INTO agent_profiles (id, slug, display_name, model_name, model_provider, deleted_at)
+        VALUES ('{agent_id}', 'test-agent', 'Test Agent', 'gpt-4o-mini', 'openai', NULL);
+        INSERT INTO messages (
+            id, room_id, sender_user_id, sender_agent_id, parent_message_id,
+            content, content_type, metadata, is_edited, created_at, updated_at, deleted_at
+        ) VALUES (
+            '{msg_id}', '{room_id}', NULL, '{agent_id}', NULL,
+            'Hello!', 'text', '{{}}', 0, '{now}', '{now}', NULL
+        );
+        """
+    )
+    rows = conn.execute("SELECT * FROM messages").fetchall()
+    enriched = server._enrich_room_messages(conn, rows)
+    conn.close()
+
+    assert len(enriched) == 1
+    assert enriched[0]["content"] == "Hello!"
+    assert enriched[0]["sender_agent_slug"] == "test-agent"
+    assert enriched[0]["sender_agent_name"] == "Test Agent"

package/workframe-api/test_exception_hygiene.py

@@ -4,9 +4,11 @@ from pathlib import Path
 
 ROOT = Path(__file__).resolve().parent
 src = (ROOT / "server.py").read_text(encoding="utf-8")
+auth_src = (ROOT / "handler_modules" / "handler_auth.py").read_text(encoding="utf-8")
+admin_src = (ROOT / "handler_modules" / "handler_admin.py").read_text(encoding="utf-8")
 messaging_src = (ROOT / "workspace_messaging.py").read_text(encoding="utf-8")
 assert "_log_handler_error" in src
-assert 'POST /api/auth/start' in src
-assert 'POST /api/admin/vault/init' in src
+assert 'POST /api/auth/start' in auth_src
+assert 'POST /api/admin/vault/init' in admin_src
 assert "_sync_workspace_messaging_gateway restart" in messaging_src
 print("exception hygiene self-check ok")

package/workframe-api/test_hermes_admin.py

@@ -41,6 +41,12 @@ def test_commands_catalog_shape() -> None:
     assert isinstance(catalog["entries"], list)
     assert all(entry.get("wired") is True for entry in catalog["entries"])
     assert not any(entry.get("wip") for entry in catalog["entries"])
+    assert not any(entry.get("dispatch") in {"gateway", "client:noOp"} for entry in catalog["entries"])
+
+
+def test_unproven_gateway_commands_stay_hidden() -> None:
+    assert hermes_admin._resolve_command("/retry") is None
+    assert hermes_admin._resolve_command("/quit") is None
 
 
 def test_commands_exec_client_dispatch() -> None:
@@ -66,6 +72,7 @@ if __name__ == "__main__":
     test_resolve_command_alias()
     test_resolve_command_unknown()
     test_commands_catalog_shape()
+    test_unproven_gateway_commands_stay_hidden()
     test_commands_exec_client_dispatch()
     test_commands_exec_not_slash()
     test_gquota_stub()

package/workframe-api/test_install_wizard_resume.py

@@ -17,6 +17,33 @@ stack_config.DATA_DIR = td
 stack_config.CONFIG_PATH = td / "stack_config.json"
 db_path = str(td / "workframe.db")
 
+assert install_api.resolve_install_wizard_step(db_path) == "intro"
+
+# Registered admin + stale saved smtp must not skip deployment.
+import sqlite3
+
+conn = sqlite3.connect(db_path)
+conn.executescript(
+    """
+    CREATE TABLE workspaces (
+        id TEXT PRIMARY KEY, slug TEXT, display_name TEXT, owner_id TEXT,
+        settings_json TEXT, deleted_at INTEGER, status TEXT, created_at TEXT, updated_at TEXT
+    );
+    """
+)
+conn.execute(
+    "INSERT INTO workspaces (id, slug, display_name, owner_id, settings_json, deleted_at, status, created_at, updated_at) "
+    "VALUES ('ws1', 'default', 'Workframe', 'u1', '{}', NULL, 'active', '1', '1')",
+)
+conn.commit()
+conn.close()
+
+stack_config.patch_stack_config(
+    {"smtp": {"admin_email": "owner@example.com"}, "wizard_step": "smtp"},
+)
+assert install_api.install_owner_claimed(db_path)
+assert install_api.resolve_install_wizard_step(db_path) == "welcome"
+
 # SMTP saved + tested
 stack_config.patch_stack_config(
     {
@@ -36,7 +63,11 @@ stack_config.patch_stack_config({"smtp": {"admin_email": "owner@example.com"}})
 
 assert stack_config.smtp_setup_complete()
 assert not stack_config.install_admin_verified()
-assert install_api.resolve_install_wizard_step(db_path) == "smtp"
+assert install_api.resolve_install_wizard_step(db_path) == "admin_auth"
+
+# Registered owner before verify still resumes at OTP (register ≠ verify).
+assert install_api.install_owner_claimed(db_path)
+assert install_api.resolve_install_wizard_step(db_path) == "admin_auth"
 
 stack_config.mark_install_admin_verified("owner@example.com")
 assert stack_config.install_admin_verified()
@@ -50,24 +81,19 @@ assert payload["smtp"]["admin_verified"] is True
 
 wizard = install_api.install_wizard_public_payload(db_path)
 assert wizard["admin_verified"] is True
+assert wizard["owner_claimed"] is True
 assert wizard["resume_step"] == "workframe"
 
-# Workspace progress → billing
-import sqlite3
+allowed, _ = install_api.install_auth_email_allowed("owner@example.com")
+assert allowed
+denied, deny = install_api.install_auth_email_allowed("other@example.com")
+assert not denied and deny.get("error") == "install_admin_email_required"
 
+# Workspace progress → billing
 conn = sqlite3.connect(db_path)
-conn.executescript(
-    """
-    CREATE TABLE workspaces (
-        id TEXT PRIMARY KEY, slug TEXT, display_name TEXT, owner_id TEXT,
-        settings_json TEXT, deleted_at INTEGER, status TEXT, created_at TEXT, updated_at TEXT
-    );
-    """
-)
 settings = {"admin_onboarding_done": True}
 conn.execute(
-    "INSERT INTO workspaces (id, slug, display_name, owner_id, settings_json, deleted_at, status, created_at, updated_at) "
-    "VALUES ('ws1', 'default', 'Workframe', 'u1', ?, NULL, 'active', '1', '1')",
+    "UPDATE workspaces SET settings_json = ? WHERE id = 'ws1'",
     (json.dumps(settings),),
 )
 conn.commit()

package/workframe-api/test_model_surface_consistency.py

@@ -10,108 +10,126 @@ import tempfile
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parent
-tmpdir = tempfile.mkdtemp(prefix="wf-model-surface-")
-os.environ["WORKFRAME_AGENTS_DIR"] = tmpdir
-os.environ["WORKFRAME_PROJECT"] = "ModelSurfaceTest"
-os.environ["NATIVE_PROFILE"] = "surface-test-agent"
+PROF = "surface-test-agent"
 
-spec = importlib.util.spec_from_file_location("wf_server_model_surface", ROOT / "server.py")
-server = importlib.util.module_from_spec(spec)
-sys.modules["wf_server_model_surface"] = server
-spec.loader.exec_module(server)
-sys.modules["server"] = server  # ponytail: extracted modules resolve _srv() to this instance
 
-PROF = "surface-test-agent"
-prof_dir = server._profile_dir(PROF)
-prof_dir.mkdir(parents=True, exist_ok=True)
-(prof_dir / "config.yaml").write_text(
-    "model:\n  default: gpt-5.4-medium\n  provider: openai-codex\n",
-    encoding="utf-8",
-)
-cfg_path = prof_dir / "config.yaml"
-before = cfg_path.read_bytes()
-
-# A: GET models must not mutate config.yaml
-server.hermes_models(PROF, user_id="", workspace_id="")
-assert cfg_path.read_bytes() == before, "hermes_models must not rewrite config on read"
-
-# B: reconcile idempotent when routing already matches codex oauth
-assert server._profile_routing_matches_billing(PROF, "codex")
-assert server._reconcile_profile_llm_for_user(PROF, "user-1", "") is False
-
-# C: billing resolution honors prefer= when model exists in that catalog
-connected = {"codex", "openrouter"}
-assert server._resolve_billing_provider_for_model(
-    "gpt-5.4-medium", connected, prefer="codex",
-) == "codex"
-assert server._resolve_billing_provider_for_model(
-    "openrouter/owl-alpha", connected, prefer="openrouter",
-) == "openrouter"
-assert server._resolve_billing_provider_for_model(
-    "openai-codex/gpt-5.4-mini", {"codex", "openrouter"},
-) == "codex"
-
-# D: set with explicit billing_provider returns billing id in response
-applied = server.hermes_model_set(
-    PROF, "gpt-5.4-medium", user_id="", workspace_id="", billing_provider="codex",
-)
-assert applied.get("ok"), applied
-assert applied.get("billing_provider") == "codex"
-assert applied.get("provider") == "codex"
-
-# E: reconcile picks model billing over stale openrouter proxy yaml
-(prof_dir / "config.yaml").write_text(
-    "model:\n  default: openai-codex/gpt-5.4-mini\n  provider: custom\n"
-    "  base_url: http://workframe-api:8080/internal/llm/openrouter/v1\n",
-    encoding="utf-8",
-)
-_orig_picker = server._user_llm_providers_for_picker
-_orig_can = server._user_can_use_llm
-_orig_sync = server._sync_oauth_llm_to_profile
-server._user_llm_providers_for_picker = lambda uid: {"codex"} if uid == "user-1" else set()
-server._user_can_use_llm = lambda uid, ws, prov: uid == "user-1" and prov == "codex"
-server._sync_oauth_llm_to_profile = lambda *a, **k: None
-try:
-    assert server._reconcile_profile_llm_for_user(PROF, "user-1", "") is True
-    block = server._read_model_block(PROF)
-    assert block.get("provider") == "openai-codex"
-    assert block.get("default") == "gpt-5.4-mini"
-    assert not block.get("base_url")
-finally:
-    server._user_llm_providers_for_picker = _orig_picker
-    server._user_can_use_llm = _orig_can
-    server._sync_oauth_llm_to_profile = _orig_sync
-
-# F: runtime disk wins over template in _read_model_block
-runtime_prof = "u-test-user-surface-test-agent"
-runtime_dir = server._profile_dir(runtime_prof)
-runtime_dir.mkdir(parents=True, exist_ok=True)
-(runtime_dir / "config.yaml").write_text(
-    "model:\n  default: gpt-5.4-mini\n  provider: openai-codex\n",
-    encoding="utf-8",
-)
-block = server._read_model_block(runtime_prof)
-assert block.get("default") == "gpt-5.4-mini", block
-assert block.get("provider") == "openai-codex", block
-
-# G: template model save mirrors to runtime (same model id, not stale template re-read)
-runtime_prof = "u-test-user2-surface-test-agent"
-runtime_dir = server._profile_dir(runtime_prof)
-runtime_dir.mkdir(parents=True, exist_ok=True)
-(runtime_dir / "config.yaml").write_text(
-    "model:\n  default: gpt-5.4-medium\n  provider: openai-codex\n",
-    encoding="utf-8",
-)
-_orig_restart = server._restart_runtime_profile_gateway
-server._restart_runtime_profile_gateway = lambda *a, **k: None
-try:
+def _run_checks(server) -> None:
+    prof_dir = server._profile_dir(PROF)
+    prof_dir.mkdir(parents=True, exist_ok=True)
+    (prof_dir / "config.yaml").write_text(
+        "model:\n  default: gpt-5.4-medium\n  provider: openai-codex\n",
+        encoding="utf-8",
+    )
+    cfg_path = prof_dir / "config.yaml"
+    before = cfg_path.read_bytes()
+
+    # A: GET models must not mutate config.yaml
+    server.hermes_models(PROF, user_id="", workspace_id="")
+    assert cfg_path.read_bytes() == before, "hermes_models must not rewrite config on read"
+
+    # B: reconcile idempotent when routing already matches codex oauth
+    assert server._profile_routing_matches_billing(PROF, "codex")
+    assert server._reconcile_profile_llm_for_user(PROF, "user-1", "") is False
+
+    # C: billing resolution honors prefer= when model exists in that catalog
+    connected = {"codex", "openrouter"}
+    assert server._resolve_billing_provider_for_model(
+        "gpt-5.4-medium", connected, prefer="codex",
+    ) == "codex"
+    assert server._resolve_billing_provider_for_model(
+        "openrouter/owl-alpha", connected, prefer="openrouter",
+    ) == "openrouter"
+    assert server._resolve_billing_provider_for_model(
+        "openai-codex/gpt-5.4-mini", {"codex", "openrouter"},
+    ) == "codex"
+
+    # D: set with explicit billing_provider returns billing id in response
     applied = server.hermes_model_set(
-        PROF, "gpt-5.4-mini", user_id="test-user2", workspace_id="", billing_provider="codex",
+        PROF, "gpt-5.4-medium", user_id="", workspace_id="", billing_provider="codex",
+    )
+    assert applied.get("ok"), applied
+    assert applied.get("billing_provider") == "codex"
+    assert applied.get("provider") == "codex"
+
+    # E: reconcile picks model billing over stale openrouter proxy yaml
+    (prof_dir / "config.yaml").write_text(
+        "model:\n  default: openai-codex/gpt-5.4-mini\n  provider: custom\n"
+        "  base_url: http://workframe-api:8080/internal/llm/openrouter/v1\n",
+        encoding="utf-8",
     )
-finally:
-    server._restart_runtime_profile_gateway = _orig_restart
-assert applied.get("ok"), applied
-runtime_block = server._parse_model_block_from_disk(runtime_prof)
-assert runtime_block.get("default") == "gpt-5.4-mini", runtime_block
+    _orig_picker = server._user_llm_providers_for_picker
+    _orig_can = server._user_can_use_llm
+    _orig_sync = server._sync_oauth_llm_to_profile
+    server._user_llm_providers_for_picker = lambda uid: {"codex"} if uid == "user-1" else set()
+    server._user_can_use_llm = lambda uid, ws, prov: uid == "user-1" and prov == "codex"
+    server._sync_oauth_llm_to_profile = lambda *a, **k: None
+    try:
+        assert server._reconcile_profile_llm_for_user(PROF, "user-1", "") is True
+        block = server._read_model_block(PROF)
+        assert block.get("provider") == "openai-codex"
+        assert block.get("default") == "gpt-5.4-mini"
+        assert not block.get("base_url")
+    finally:
+        server._user_llm_providers_for_picker = _orig_picker
+        server._user_can_use_llm = _orig_can
+        server._sync_oauth_llm_to_profile = _orig_sync
+
+    # F: runtime disk wins over template in _read_model_block
+    runtime_prof = "u-test-user-surface-test-agent"
+    runtime_dir = server._profile_dir(runtime_prof)
+    runtime_dir.mkdir(parents=True, exist_ok=True)
+    (runtime_dir / "config.yaml").write_text(
+        "model:\n  default: gpt-5.4-mini\n  provider: openai-codex\n",
+        encoding="utf-8",
+    )
+    block = server._read_model_block(runtime_prof)
+    assert block.get("default") == "gpt-5.4-mini", block
+    assert block.get("provider") == "openai-codex", block
+
+    # G: template model save mirrors to runtime (same model id, not stale template re-read)
+    runtime_prof = "u-test-user2-surface-test-agent"
+    runtime_dir = server._profile_dir(runtime_prof)
+    runtime_dir.mkdir(parents=True, exist_ok=True)
+    (runtime_dir / "config.yaml").write_text(
+        "model:\n  default: gpt-5.4-medium\n  provider: openai-codex\n",
+        encoding="utf-8",
+    )
+    _orig_restart = server._restart_runtime_profile_gateway
+    server._restart_runtime_profile_gateway = lambda *a, **k: None
+    try:
+        applied = server.hermes_model_set(
+            PROF, "gpt-5.4-mini", user_id="test-user2", workspace_id="", billing_provider="codex",
+        )
+    finally:
+        server._restart_runtime_profile_gateway = _orig_restart
+    assert applied.get("ok"), applied
+    runtime_block = server._parse_model_block_from_disk(runtime_prof)
+    assert runtime_block.get("default") == "gpt-5.4-mini", runtime_block
+
+
+def _run_self_check() -> None:
+    tmpdir = tempfile.mkdtemp(prefix="wf-model-surface-")
+    os.environ["WORKFRAME_AGENTS_DIR"] = tmpdir
+    os.environ["HERMES_DATA"] = tmpdir
+    os.environ["WORKFRAME_API_DATA_DIR"] = str(Path(tmpdir) / "api")
+    os.environ["WORKFRAME_PROJECT"] = "ModelSurfaceTest"
+    os.environ["NATIVE_PROFILE"] = "surface-test-agent"
+
+    spec = importlib.util.spec_from_file_location("wf_server_model_surface", ROOT / "server.py")
+    server = importlib.util.module_from_spec(spec)
+    sys.modules["wf_server_model_surface"] = server
+    spec.loader.exec_module(server)
+    prev_server = sys.modules.get("server")
+    sys.modules["server"] = server  # ponytail: extracted modules resolve _srv() to this instance
+    try:
+        _run_checks(server)
+    finally:
+        if prev_server is None:
+            sys.modules.pop("server", None)
+        else:
+            sys.modules["server"] = prev_server
+
 
-print("model surface consistency self-check ok")
+if __name__ == "__main__":
+    _run_self_check()
+    print("model surface consistency self-check ok")

package/workframe-api/test_profile_model_yaml.py

@@ -9,7 +9,10 @@ from pathlib import Path
 import yaml
 
 ROOT = Path(__file__).resolve().parent
-os.environ.setdefault("WORKFRAME_AGENTS_DIR", tempfile.mkdtemp(prefix="wf-yaml-test-"))
+_test_root = tempfile.mkdtemp(prefix="wf-yaml-test-")
+os.environ["WORKFRAME_AGENTS_DIR"] = _test_root
+os.environ["HERMES_DATA"] = _test_root
+os.environ["WORKFRAME_API_DATA_DIR"] = str(Path(_test_root) / "api")
 os.environ.setdefault("WORKFRAME_PROJECT", "YamlTest")
 os.environ.setdefault("NATIVE_PROFILE", "yaml-test-agent")
 

package/workframe-api/test_provider_bindings.py

@@ -44,9 +44,19 @@ def test_parse_device_oauth_log() -> None:
     assert parsed["user_code"] == "ABCD-1234"
 
 
+def test_device_oauth_error_from_log() -> None:
+    text = (
+        "hermes_cli.auth.AuthError: OpenAI is rate-limiting Codex login requests (HTTP 429). "
+        "Wait a minute and run the login again."
+    )
+    msg = provider_bindings._device_oauth_error_from_log(text)
+    assert msg and "429" in msg
+
+
 if __name__ == "__main__":
     test_hermes_oauth_auth_keys()
     test_auth_json_has_oauth_material()
     test_merge_oauth_auth_into_profile()
     test_parse_device_oauth_log()
+    test_device_oauth_error_from_log()
     print("test_provider_bindings: ok")

package/workframe-api/test_run_ledger.py

@@ -88,7 +88,8 @@ def test_schema_and_round_trip() -> None:
             conn.close()
 
         events = run_ledger.list_run_events_for_room("room-1")
-        assert len(events) >= 2
+        assert len(events) == 1
+        assert events[0]["event_type"] == "run.completed"
         assert events[0]["source"] == "run_ledger"
 
 

package/workframe-api/test_server_reexports.py

@@ -86,6 +86,10 @@ _REQUIRED = (
     "_promote_workspace_owner_if_unclaimed",
     "_sync_workspace_home_room",
     "_onboard_workspace_member_rooms",
+    "_profile_model",
+    "_USER_LLM_PICKER_TTL_SEC",
+    "_invalidate_profile_health_cache",
+    "_profile_toolsets_ready",
 )
 
 

package/workframe-api/test_user_llm_prefs.py

@@ -0,0 +1,99 @@
+"""LLM prefs persist in users.platform_ids without messaging-only validation."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+import time
+import uuid
+from pathlib import Path
+
+import pytest
+
+API_DIR = Path(__file__).resolve().parent
+if str(API_DIR) not in sys.path:
+    sys.path.insert(0, str(API_DIR))
+
+os.environ.setdefault("WORKFRAME_API_DATA_DIR", str(API_DIR / ".tmp-test-data"))
+os.environ.setdefault("HERMES_DATA", str(API_DIR / ".tmp-test-hermes"))
+os.environ.setdefault("DEV_LOCAL_UNSAFE", "true")
+
+import server  # noqa: E402
+
+
+@pytest.fixture()
+def llm_prefs_db(monkeypatch: pytest.MonkeyPatch):
+    with tempfile.TemporaryDirectory(prefix="wf-llm-prefs-") as tmp:
+        data_dir = Path(tmp) / "api"
+        data_dir.mkdir(parents=True, exist_ok=True)
+        monkeypatch.setattr(server, "DATA_DIR", data_dir)
+        monkeypatch.setattr(server, "AUTH_DB_PATH", data_dir / "auth.db")
+        server._ensure_workframe_db_schema()
+        yield data_dir
+
+
+def _insert_user(*, email: str, display_name: str, platform_ids: str) -> str:
+    user_id = str(uuid.uuid4())
+    now = str(int(time.time()))
+    conn = server._workframe_db()
+    try:
+        conn.execute(
+            "INSERT INTO users (id, email, display_name, role, status, platform_ids, created_at, updated_at) "
+            "VALUES (?,?,?,?,?,?,?,?)",
+            (user_id, email, display_name, "owner", "active", platform_ids, now, now),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+    return user_id
+
+
+def test_user_llm_prefs_round_trip(llm_prefs_db) -> None:  # noqa: ARG001
+    import user_prefs  # noqa: WPS433
+
+    user_id = _insert_user(email="prefs@test.local", display_name="Prefs", platform_ids="{}")
+
+    user_prefs.write_user_llm_prefs(
+        user_id,
+        primary="openrouter/google/gemini-2.5-flash",
+        fallback_chain=[{"provider": "openrouter", "model": "anthropic/claude-sonnet-4.5"}],
+    )
+
+    conn = server._workframe_db()
+    try:
+        row = conn.execute(
+            "SELECT platform_ids FROM users WHERE id = ?", (user_id,),
+        ).fetchone()
+    finally:
+        conn.close()
+    pids = json.loads(row["platform_ids"])
+    assert pids["llm_primary"] == "openrouter/google/gemini-2.5-flash"
+    chain = json.loads(pids["llm_fallback_chain"])
+    assert chain[0]["model"] == "anthropic/claude-sonnet-4.5"
+
+    primary, fb = user_prefs.read_user_llm_prefs(user_id)
+    assert primary == "openrouter/google/gemini-2.5-flash"
+    assert fb[0]["model"] == "anthropic/claude-sonnet-4.5"
+
+
+def test_user_llm_prefs_infers_primary_from_fallback_chain(llm_prefs_db) -> None:  # noqa: ARG001
+    import user_prefs  # noqa: WPS433
+
+    platform_ids = json.dumps({
+        "llm_fallback_chain": json.dumps([{"provider": "openrouter", "model": "google/gemini-2.5-flash"}]),
+    })
+    user_id = _insert_user(
+        email="fallback@test.local",
+        display_name="Fallback",
+        platform_ids=platform_ids,
+    )
+
+    inferred, chain = user_prefs.read_user_llm_prefs(user_id)
+    assert inferred == "openrouter/google/gemini-2.5-flash"
+    assert chain[0]["model"] == "google/gemini-2.5-flash"
+
+
+if __name__ == "__main__":
+    raise SystemExit(pytest.main([__file__, "-q"]))

package/workframe-api/time-overlay-split.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Split provider vs user overlay timing."""
+from __future__ import annotations
+
+import sqlite3
+import time
+
+import server
+
+
+def ms(t0: float) -> int:
+    return round((time.perf_counter() - t0) * 1000)
+
+
+def main() -> int:
+    conn = sqlite3.connect(str(server.DATA_DIR / "workframe.db"))
+    conn.row_factory = sqlite3.Row
+    room = conn.execute(
+        """
+        SELECT r.id, r.workspace_id, ap.slug AS agent_slug
+        FROM rooms r
+        JOIN agent_profiles ap ON ap.id = r.agent_profile_id
+        JOIN room_memberships rm ON rm.room_id = r.id AND rm.status = 'active'
+        WHERE r.room_type = 'direct' AND r.deleted_at IS NULL
+        ORDER BY r.updated_at DESC
+        LIMIT 1
+        """,
+    ).fetchone()
+    user = conn.execute(
+        """
+        SELECT u.id FROM users u
+        JOIN room_memberships rm ON rm.user_id = u.id AND rm.room_id = ?
+        WHERE u.status = 'active'
+        LIMIT 1
+        """,
+        (str(room["id"]),),
+    ).fetchone()
+    conn.close()
+    room_id = str(room["id"])
+    ws_id = str(room["workspace_id"])
+    user_id = str(user["id"])
+    prof = server._resolve_chat_hermes_profile(str(room["agent_slug"]), user_id, room_id, ws_id)
+    provider = server._llm_billing_provider(prof, user_id=user_id, workspace_id=ws_id)
+
+    for i in range(5):
+        t = time.perf_counter()
+        server._overlay_turn_provider_env(prof, user_id, ws_id, provider, f"p-{i}")
+        p_ms = ms(t)
+        t = time.perf_counter()
+        server._overlay_turn_user_env(prof, user_id, ws_id, f"u-{i}")
+        u_ms = ms(t)
+        print(f"turn_{i} provider_ms={p_ms} user_ms={u_ms} total_ms={p_ms + u_ms}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())