create-workframe 0.1.18 → 0.1.20

package/workframe-api/test_agent_identity_authority.py

@@ -0,0 +1,96 @@
+"""Shared agent identity vs per-user runtime proxy regression checks."""
+
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+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 crew_registry  # noqa: E402
+import hermes_profiles  # noqa: E402
+import runtime_cohort  # noqa: E402
+import server  # noqa: E402
+
+
+def test_runtime_display_name_comes_from_shared_agent() -> None:
+    with (
+        patch.object(server, "_agent_db_display_name", return_value="Shared Architect"),
+        patch.object(server, "_agent_registry_row", return_value={"display_name": "Template Architect"}),
+    ):
+        assert (
+            runtime_cohort._runtime_display_label("bob-user", "architect", "workspace-1")
+            == "Shared Architect"
+        )
+
+
+def test_native_display_name_comes_from_shared_agent() -> None:
+    with (
+        patch.object(server, "NATIVE_PROFILE", "workframe-agent"),
+        patch.object(hermes_profiles, "_agent_db_display_name", return_value="Shared Concierge"),
+    ):
+        assert hermes_profiles._native_display_name() == "Shared Concierge"
+
+
+def test_runtime_identity_fields_ignore_runtime_registry_metadata() -> None:
+    def registry_row(slug: str) -> dict[str, str]:
+        if slug.startswith("u-"):
+            return {"display_name": "Bob's Clone", "tagline": "Runtime drift"}
+        return {"display_name": "Shared Agent", "tagline": "Workspace identity", "role": "Architect"}
+
+    with (
+        patch.object(crew_registry, "_agent_registry_row", side_effect=registry_row),
+        patch.object(crew_registry, "_workspace_agent_identities", return_value={}),
+        patch.object(server, "_profile_display_name", return_value="Fallback"),
+        patch.object(server, "_profile_role", return_value="Fallback role"),
+        patch.object(server, "_resolve_avatar_fields", side_effect=lambda row: row),
+    ):
+        identity = crew_registry._agent_identity_fields(
+            "u-bob-user-architect",
+            "workspace-1",
+            "bob-user",
+        )
+    assert identity["display_name"] == "Shared Agent"
+    assert identity["tagline"] == "Workspace identity"
+    assert identity["role"] == "Architect"
+
+
+def test_runtime_identity_sync_preserves_credentials() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        template_dir = root / "architect"
+        runtime_dir = root / "u-bob-architect"
+        template_dir.mkdir()
+        runtime_dir.mkdir()
+        (template_dir / "SOUL.md").write_text("shared soul\n", encoding="utf-8")
+        (template_dir / "AGENTS.md").write_text("shared agents\n", encoding="utf-8")
+        (runtime_dir / "SOUL.md").write_text("stale runtime soul\n", encoding="utf-8")
+        (runtime_dir / "AGENTS.md").write_text("stale runtime agents\n", encoding="utf-8")
+        (runtime_dir / ".env").write_text("OPENROUTER_API_KEY=user-secret\n", encoding="utf-8")
+
+        with (
+            patch.object(server, "_profile_dir", side_effect=lambda slug: root / slug),
+            patch.object(runtime_cohort, "_ensure_profile_terminal_cwd", return_value=None),
+        ):
+            runtime_cohort._backfill_runtime_identity("u-bob-architect", "architect")
+
+        assert (runtime_dir / "SOUL.md").read_text(encoding="utf-8") == "shared soul\n"
+        assert (runtime_dir / "AGENTS.md").read_text(encoding="utf-8") == "shared agents\n"
+        assert (runtime_dir / ".env").read_text(encoding="utf-8") == "OPENROUTER_API_KEY=user-secret\n"
+
+
+if __name__ == "__main__":
+    test_runtime_display_name_comes_from_shared_agent()
+    test_native_display_name_comes_from_shared_agent()
+    test_runtime_identity_fields_ignore_runtime_registry_metadata()
+    test_runtime_identity_sync_preserves_credentials()
+    print("test_agent_identity_authority: ok")

package/workframe-api/test_chat_attribution_history.py

@@ -0,0 +1,59 @@
+"""Historical chat badges use completed run evidence, not the current model."""
+
+from __future__ import annotations
+
+import sqlite3
+
+import chat_sessions
+import server
+
+
+def test_session_run_attributions_preserve_model_switch_history(tmp_path, monkeypatch) -> None:
+    db_path = tmp_path / "workframe.db"
+    conn = sqlite3.connect(db_path)
+    conn.executescript(
+        """
+        CREATE TABLE runs (
+            run_id TEXT PRIMARY KEY,
+            session_id TEXT,
+            profile_slug TEXT,
+            status TEXT,
+            created_at TEXT
+        );
+        CREATE TABLE run_line_items (
+            line_item_id TEXT PRIMARY KEY,
+            run_id TEXT,
+            kind TEXT,
+            model TEXT,
+            provider TEXT,
+            created_at TEXT
+        );
+        """,
+    )
+    conn.executemany(
+        "INSERT INTO runs VALUES (?,?,?,?,?)",
+        [
+            ("r1", "session-1", "u-user-agent", "completed", "2026-01-01T00:00:01Z"),
+            ("r2", "session-1", "u-user-agent", "completed", "2026-01-01T00:00:02Z"),
+        ],
+    )
+    conn.executemany(
+        "INSERT INTO run_line_items VALUES (?,?,?,?,?,?)",
+        [
+            ("l1", "r1", "llm_turn", "openrouter/auto", "openrouter", "2026-01-01T00:00:01Z"),
+            ("l2", "r2", "llm_turn", "google/gemini-2.5-flash", "openrouter", "2026-01-01T00:00:02Z"),
+        ],
+    )
+    conn.commit()
+    conn.close()
+
+    def _connect():
+        db = sqlite3.connect(db_path)
+        db.row_factory = sqlite3.Row
+        return db
+
+    monkeypatch.setattr(server, "_workframe_db", _connect)
+    assert chat_sessions._session_run_attributions("u-user-agent", "session-1") == [
+        ("openrouter/auto", "openrouter"),
+        ("google/gemini-2.5-flash", "openrouter"),
+    ]

package/workframe-api/test_enrich_room_messages.py

@@ -19,7 +19,7 @@ os.environ.setdefault("DEV_LOCAL_UNSAFE", "true")
 import server  # noqa: E402
 
 
-def test_enrich_room_messages_with_agent_sender(tmp_path: Path) -> None:
+def test_enrich_room_messages_preserve_turn_attribution(tmp_path: Path) -> None:
     db = tmp_path / "workframe.db"
     conn = sqlite3.connect(db)
     conn.row_factory = sqlite3.Row
@@ -58,7 +58,8 @@ def test_enrich_room_messages_with_agent_sender(tmp_path: Path) -> None:
             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
+            'Hello!', 'text', '{{"model":"google/gemini-2.5-flash","llm_provider":"openrouter"}}',
+            0, '{now}', '{now}', NULL
         );
         """
     )
@@ -70,3 +71,43 @@ def test_enrich_room_messages_with_agent_sender(tmp_path: Path) -> None:
     assert enriched[0]["content"] == "Hello!"
     assert enriched[0]["sender_agent_slug"] == "test-agent"
     assert enriched[0]["sender_agent_name"] == "Test Agent"
+    assert enriched[0]["model"] == "google/gemini-2.5-flash"
+    assert enriched[0]["llm_provider"] == "openrouter"
+
+
+def test_enrich_room_messages_does_not_relabel_legacy_message(tmp_path: Path) -> None:
+    db = tmp_path / "workframe.db"
+    conn = sqlite3.connect(db)
+    conn.row_factory = sqlite3.Row
+    conn.executescript(
+        """
+        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 VALUES (
+            'agent-1', 'test-agent', 'Test Agent',
+            'gpt-5.4-mini', 'codex', NULL
+        );
+        INSERT INTO messages VALUES (
+            'message-1', 'room-1', NULL, 'agent-1', NULL, 'Old reply',
+            'text', '{}', 0, '1700000000', '1700000000', NULL
+        );
+        """
+    )
+
+    enriched = server._enrich_room_messages(
+        conn,
+        conn.execute("SELECT * FROM messages").fetchall(),
+    )
+    conn.close()
+
+    assert enriched[0]["sender_agent_name"] == "Test Agent"
+    assert "model" not in enriched[0]
+    assert "llm_provider" not in enriched[0]

package/workframe-api/test_llm_proxy_encoding.py

@@ -0,0 +1,33 @@
+"""Regression coverage for compressed upstream LLM responses."""
+
+from __future__ import annotations
+
+import credential_broker
+import llm_proxy
+
+
+def test_upstream_request_forces_identity_encoding(monkeypatch) -> None:
+    monkeypatch.setattr(
+        credential_broker,
+        "authorize_broker_lease",
+        lambda *args, **kwargs: credential_broker.BrokerLeaseAuth(ok=True, secret="test-secret"),
+    )
+
+    request, error = llm_proxy._build_upstream_request(
+        "openrouter",
+        "/chat/completions",
+        "POST",
+        {
+            "Authorization": "Bearer runtime-llm:test",
+            "Accept-Encoding": "gzip, deflate",
+            "Content-Type": "application/json",
+        },
+        b"{}",
+        resolve_secret=lambda *_: ("OPENROUTER_API_KEY", "unused"),
+    )
+
+    assert error is None
+    assert request is not None
+    headers = {key.lower(): value for key, value in request.header_items()}
+    assert headers["accept-encoding"] == "identity"
+    assert headers["authorization"] == "Bearer test-secret"

package/workframe-api/test_message_reactions.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import sqlite3
+
+import pytest
+
+import db_schema
+import message_reactions
+
+
+def reaction_db() -> sqlite3.Connection:
+    conn = sqlite3.connect(":memory:")
+    conn.row_factory = sqlite3.Row
+    conn.execute(
+        "CREATE TABLE schema_migrations (version TEXT PRIMARY KEY, description TEXT, applied_at TEXT)"
+    )
+    conn.execute(
+        "CREATE TABLE messages (id TEXT PRIMARY KEY, room_id TEXT, deleted_at TEXT)"
+    )
+    conn.execute(
+        "CREATE TABLE users (id TEXT PRIMARY KEY, display_name TEXT, avatar_url TEXT)"
+    )
+    # Run-ledger already owns migration 14. This regression marker ensures
+    # reactions still migrate on installs that have that older row.
+    conn.execute(
+        "INSERT INTO schema_migrations VALUES ('14', 'runs, run_events, run_line_items ledger tables', 'now')"
+    )
+    db_schema._migrate_v15_message_reactions(conn)
+    assert conn.execute(
+        "SELECT 1 FROM schema_migrations WHERE version = '15'"
+    ).fetchone()
+    conn.execute("INSERT INTO messages (id, room_id, deleted_at) VALUES ('message-1', 'room-1', NULL)")
+    conn.executemany(
+        "INSERT INTO users (id, display_name, avatar_url) VALUES (?, ?, ?)",
+        [
+            ("user-1", "Alan", "/avatars/alan.png"),
+            ("user-2", "Grace", None),
+        ],
+    )
+    conn.commit()
+    return conn
+
+
+def can_access_room(_conn: sqlite3.Connection, room_id: str, user_id: str) -> bool:
+    return room_id == "room-1" and user_id == "user-1"
+
+
+def test_room_reaction_toggles_and_aggregates() -> None:
+    conn = reaction_db()
+    try:
+        first = message_reactions.toggle_reaction(
+            conn, "room:room-1", "message-1", "👍", "user-1", can_access_room
+        )
+        assert first["reacted"] is True
+        assert first["reactions"] == [
+            {
+                "message_id": "message-1",
+                "emoji": "👍",
+                "count": 1,
+                "reacted": True,
+                "reactors": [
+                    {
+                        "user_id": "user-1",
+                        "display_name": "Alan",
+                        "avatar_url": "/avatars/alan.png",
+                    }
+                ],
+            }
+        ]
+
+        second = message_reactions.toggle_reaction(
+            conn, "room:room-1", "message-1", "👍", "user-1", can_access_room
+        )
+        assert second["reacted"] is False
+        assert second["reactions"] == []
+    finally:
+        conn.close()
+
+
+def test_room_reactions_include_people_for_hover_details() -> None:
+    conn = reaction_db()
+    try:
+        message_reactions.toggle_reaction(
+            conn, "room:room-1", "message-1", "🎉", "user-1", can_access_room
+        )
+        conn.execute(
+            """
+            INSERT INTO message_reactions (scope_key, message_id, user_id, emoji, created_at)
+            VALUES ('room:room-1', 'message-1', 'user-2', '🎉', '2')
+            """
+        )
+        conn.commit()
+
+        listed = message_reactions.list_reactions(
+            conn, "room:room-1", "user-1", can_access_room
+        )
+        assert listed["reactions"] == [
+            {
+                "message_id": "message-1",
+                "emoji": "🎉",
+                "count": 2,
+                "reacted": True,
+                "reactors": [
+                    {
+                        "user_id": "user-1",
+                        "display_name": "Alan",
+                        "avatar_url": "/avatars/alan.png",
+                    },
+                    {
+                        "user_id": "user-2",
+                        "display_name": "Grace",
+                        "avatar_url": None,
+                    },
+                ],
+            }
+        ]
+    finally:
+        conn.close()
+
+
+def test_room_reactions_require_room_access_and_existing_message() -> None:
+    conn = reaction_db()
+    try:
+        with pytest.raises(PermissionError):
+            message_reactions.list_reactions(
+                conn, "room:room-1", "user-2", can_access_room
+            )
+        with pytest.raises(ValueError, match="message_not_found"):
+            message_reactions.toggle_reaction(
+                conn, "room:room-1", "missing", "🔥", "user-1", can_access_room
+            )
+    finally:
+        conn.close()
+
+
+def test_dm_reactions_are_namespaced_by_authenticated_user() -> None:
+    conn = reaction_db()
+    try:
+        message_reactions.toggle_reaction(
+            conn, "dm:agent:session-1", "external-message", "✅", "user-1", can_access_room
+        )
+        mine = message_reactions.list_reactions(
+            conn, "dm:agent:session-1", "user-1", can_access_room
+        )
+        theirs = message_reactions.list_reactions(
+            conn, "dm:agent:session-1", "user-2", can_access_room
+        )
+        assert mine["reactions"][0]["count"] == 1
+        assert theirs["reactions"] == []
+    finally:
+        conn.close()

package/workframe-api/test_model_routing_reconcile.py

@@ -0,0 +1,122 @@
+"""Provider/model routing repairs for vault-backed API-key providers."""
+
+from __future__ import annotations
+
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+import yaml
+
+API_DIR = Path(__file__).resolve().parent
+if str(API_DIR) not in sys.path:
+    sys.path.insert(0, str(API_DIR))
+
+import server  # noqa: E402
+
+
+@pytest.fixture()
+def routing_data_dir():
+    with tempfile.TemporaryDirectory(prefix="wf-routing-") as tmp:
+        yield Path(tmp)
+
+
+def test_native_openrouter_config_is_reconciled_to_internal_proxy(
+    monkeypatch: pytest.MonkeyPatch,
+    routing_data_dir: Path,
+) -> None:
+    tmp_path = routing_data_dir
+    profile = "dogfood-agent"
+    profile_dir = tmp_path / "profiles" / profile
+    profile_dir.mkdir(parents=True)
+    config_path = profile_dir / "config.yaml"
+    config_path.write_text(
+        "model:\n"
+        "  default: google/gemini-2.5-flash\n"
+        "  provider: openrouter\n"
+        "  base_url: https://openrouter.ai/api/v1\n",
+        encoding="utf-8",
+    )
+
+    monkeypatch.setattr(server, "HERMES_DATA", tmp_path)
+    monkeypatch.setattr(server, "NATIVE_PROFILE", profile)
+    monkeypatch.setattr(server, "WORKFRAME_LLM_PROXY_INTERNAL", "http://workframe-api:8000")
+    monkeypatch.setattr(server, "_user_llm_providers_for_picker", lambda _user: {"openrouter"})
+    monkeypatch.setattr(server, "_user_can_use_llm", lambda *_args, **_kwargs: True)
+    monkeypatch.setattr(server, "_reload_runtime_profile_gateway", lambda *_args, **_kwargs: None)
+
+    assert server._reconcile_profile_llm_for_user(profile, "user-1", "workspace-1") is True
+
+    cfg = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+    assert cfg["model"]["default"] == "google/gemini-2.5-flash"
+    assert cfg["model"]["provider"] == "custom"
+    assert cfg["model"]["base_url"] == "http://workframe-api:8000/internal/llm/openrouter/v1"
+    assert isinstance(cfg["fallback_providers"], list)
+    assert cfg["fallback_providers"]
+    assert all(entry["provider"] == "custom" for entry in cfg["fallback_providers"])
+
+
+def test_native_openrouter_reconcile_is_idempotent(
+    monkeypatch: pytest.MonkeyPatch,
+    routing_data_dir: Path,
+) -> None:
+    tmp_path = routing_data_dir
+    profile = "dogfood-agent"
+    profile_dir = tmp_path / "profiles" / profile
+    profile_dir.mkdir(parents=True)
+    config_path = profile_dir / "config.yaml"
+    config_path.write_text(
+        "model:\n"
+        "  default: google/gemini-2.5-flash\n"
+        "  provider: custom\n"
+        "  base_url: http://workframe-api:8000/internal/llm/openrouter/v1\n"
+        "fallback_providers:\n"
+        "  - provider: custom\n"
+        "    model: meta-llama/llama-3.3-70b-instruct:free\n",
+        encoding="utf-8",
+    )
+
+    monkeypatch.setattr(server, "HERMES_DATA", tmp_path)
+    monkeypatch.setattr(server, "NATIVE_PROFILE", profile)
+    monkeypatch.setattr(server, "WORKFRAME_LLM_PROXY_INTERNAL", "http://workframe-api:8000")
+    monkeypatch.setattr(server, "_user_llm_providers_for_picker", lambda _user: {"openrouter"})
+    monkeypatch.setattr(server, "_user_can_use_llm", lambda *_args, **_kwargs: True)
+
+    assert server._reconcile_profile_llm_for_user(profile, "user-1", "workspace-1") is False
+
+
+def test_openrouter_reconcile_accepts_pyyaml_indentless_fallback_sequence(
+    monkeypatch: pytest.MonkeyPatch,
+    routing_data_dir: Path,
+) -> None:
+    profile = "dogfood-agent"
+    profile_dir = routing_data_dir / "profiles" / profile
+    profile_dir.mkdir(parents=True)
+    config_path = profile_dir / "config.yaml"
+    config_path.write_text(
+        "model:\n"
+        "  default: openrouter/auto\n"
+        "  provider: custom\n"
+        "  base_url: http://workframe-api:8000/internal/llm/openrouter/v1\n"
+        "fallback_providers:\n"
+        "- provider: custom\n"
+        "  model: anthropic/claude-sonnet-4.5\n"
+        "- provider: custom\n"
+        "  model: meta-llama/llama-3.3-70b-instruct:free\n",
+        encoding="utf-8",
+    )
+
+    monkeypatch.setattr(server, "HERMES_DATA", routing_data_dir)
+    monkeypatch.setattr(server, "NATIVE_PROFILE", profile)
+    monkeypatch.setattr(server, "WORKFRAME_LLM_PROXY_INTERNAL", "http://workframe-api:8000")
+    monkeypatch.setattr(server, "_user_llm_providers_for_picker", lambda _user: {"openrouter"})
+    monkeypatch.setattr(server, "_user_can_use_llm", lambda *_args, **_kwargs: True)
+
+    block = server._read_model_block(profile)
+    assert block["fallback_chain"] == [
+        {"provider": "custom", "model": "anthropic/claude-sonnet-4.5"},
+        {"provider": "custom", "model": "meta-llama/llama-3.3-70b-instruct:free"},
+    ]
+    assert server._profile_llm_proxy_ready(profile, "openrouter") is True
+    assert server._reconcile_profile_llm_for_user(profile, "user-1", "workspace-1") is False

package/workframe-api/test_model_surface_consistency.py

@@ -51,7 +51,7 @@ def _run_checks(server) -> None:
     assert applied.get("billing_provider") == "codex"
     assert applied.get("provider") == "codex"
 
-    # E: reconcile picks model billing over stale openrouter proxy yaml
+    # E: credential availability cannot silently change an agent-owned model/provider.
     (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",
@@ -60,19 +60,24 @@ def _run_checks(server) -> None:
     _orig_picker = server._user_llm_providers_for_picker
     _orig_can = server._user_can_use_llm
     _orig_sync = server._sync_oauth_llm_to_profile
+    _orig_reload = server._reload_runtime_profile_gateway
     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
+    server._reload_runtime_profile_gateway = lambda *a, **k: None
     try:
+        # Transport repair may add proxy-safe fallback rows, but it must not
+        # switch the configured OpenRouter billing provider to Codex.
         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")
+        assert block.get("provider") == "custom"
+        assert block.get("default") == "openai-codex/gpt-5.4-mini"
+        assert str(block.get("base_url") or "").endswith("/internal/llm/openrouter/v1")
     finally:
         server._user_llm_providers_for_picker = _orig_picker
         server._user_can_use_llm = _orig_can
         server._sync_oauth_llm_to_profile = _orig_sync
+        server._reload_runtime_profile_gateway = _orig_reload
 
     # F: runtime disk wins over template in _read_model_block
     runtime_prof = "u-test-user-surface-test-agent"
@@ -85,6 +90,7 @@ def _run_checks(server) -> None:
     block = server._read_model_block(runtime_prof)
     assert block.get("default") == "gpt-5.4-mini", block
     assert block.get("provider") == "openai-codex", block
+    assert server._resolve_models_profile(runtime_prof) == PROF
 
     # G: template model save mirrors to runtime (same model id, not stale template re-read)
     runtime_prof = "u-test-user2-surface-test-agent"
@@ -98,13 +104,47 @@ def _run_checks(server) -> None:
     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",
+            runtime_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
+    assert applied.get("profile") == PROF, applied
     runtime_block = server._parse_model_block_from_disk(runtime_prof)
     assert runtime_block.get("default") == "gpt-5.4-mini", runtime_block
+    template_block = server._parse_model_block_from_disk(PROF)
+    assert template_block.get("default") == "gpt-5.4-mini", template_block
+    assert template_block.get("provider") == "openai-codex", template_block
+
+    # H: missing user credentials deny execution elsewhere; provider resolution
+    # still reports the agent's configured Codex provider instead of OpenRouter.
+    _orig_picker = server._user_llm_providers_for_picker
+    _orig_can = server._user_can_use_llm
+    server._user_llm_providers_for_picker = lambda _uid: {"openrouter"}
+    server._user_can_use_llm = lambda *_args, **_kwargs: False
+    try:
+        assert server._llm_billing_provider(PROF, user_id="other-user") == "codex"
+    finally:
+        server._user_llm_providers_for_picker = _orig_picker
+        server._user_can_use_llm = _orig_can
+
+    # I: picker rows expose the billing provider encoded in the proxy URL,
+    # never Hermes' internal ``custom`` transport label.
+    proxy_block = {
+        "default": "google/gemini-2.5-flash",
+        "provider": "custom",
+        "base_url": "http://workframe-api:8080/internal/llm/openrouter/v1",
+        "fallback_chain": [
+            {"provider": "custom", "model": "anthropic/claude-sonnet-4.5"},
+        ],
+    }
+    augmented = server._augment_model_suggestions([], proxy_block)
+    assert {row.get("billing_provider") for row in augmented} == {"openrouter"}, augmented
+    assert augmented[0].get("label") == "gemini-2.5-flash", augmented
+    normalized = server._normalized_profile_fallback_chain(proxy_block, "openrouter")
+    assert normalized == [
+        {"provider": "openrouter", "model": "anthropic/claude-sonnet-4.5"},
+    ]
 
 
 def _run_self_check() -> None:

package/workframe-api/test_oauth_llm.py

@@ -53,6 +53,6 @@ finally:
     server._hermes_oauth_tokens_present = _orig
 
 mvp = server.PROVIDER_MVP_MODELS["codex"]["primary"]
-assert mvp == "gpt-5.4-medium"
+assert mvp == "gpt-5.4-mini"
 
 print("oauth llm self-check ok")

package/workframe-api/test_profile_gateway_health.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import profile_gateway
+
+
+def test_wait_profile_api_health_bypasses_negative_cache(monkeypatch) -> None:
+    server = profile_gateway._srv()
+    monkeypatch.setattr(server, "resolve_hermes_profile", lambda profile: profile)
+    monkeypatch.setattr(profile_gateway.time, "sleep", lambda _delay: None)
+
+    cache_modes: list[bool] = []
+
+    def health(_profile: str, **kwargs) -> bool:
+        cache_modes.append(bool(kwargs.get("use_cache", True)))
+        return len(cache_modes) >= 3
+
+    monkeypatch.setattr(profile_gateway, "_profile_api_healthy", health)
+
+    assert profile_gateway._wait_profile_api_healthy("dogfood-agent", attempts=4, delay=0.01)
+    assert cache_modes == [False, False, False]
+
+
+def test_wait_profile_api_health_stops_after_requested_attempts(monkeypatch) -> None:
+    server = profile_gateway._srv()
+    monkeypatch.setattr(server, "resolve_hermes_profile", lambda profile: profile)
+    sleeps: list[float] = []
+    monkeypatch.setattr(profile_gateway.time, "sleep", sleeps.append)
+    monkeypatch.setattr(
+        profile_gateway,
+        "_profile_api_healthy",
+        lambda _profile, **kwargs: False,
+    )
+
+    assert not profile_gateway._wait_profile_api_healthy(
+        "dogfood-agent", attempts=3, delay=0.25,
+    )
+    assert sleeps == [0.25, 0.25, 0.25]