fix(ci): restore dev pytest baseline (#6704)

* chore(ci): initialize dev pytest baseline repair

* fix(ci): restore utility compaction tests and CSS snapshot

tests/test_aux_llm_owner_scope.py

@@ -1,3 +1,4 @@
+import ast
 from pathlib import Path
 
 
@@ -8,11 +9,42 @@ def _src(path: str) -> str:
     return (ROOT / path).read_text(encoding="utf-8")
 
 
+def _utility_kwargs(source: str, function_name: str) -> dict:
+    tree = ast.parse(source)
+
+    functions = [
+        node for node in ast.walk(tree)
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+        and node.name == function_name
+    ]
+    assert len(functions) == 1, function_name
+
+    calls = [
+        node for node in ast.walk(functions[0])
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "resolve_endpoint"
+        and node.args
+        and isinstance(node.args[0], ast.Constant)
+        and node.args[0].value == "utility"
+    ]
+    assert len(calls) == 1, function_name
+
+    return {
+        kw.arg: ast.unparse(kw.value)
+        for kw in calls[0].keywords
+    }
+
+
 def test_registered_manual_compaction_uses_session_owner_for_utility_endpoint():
     session_src = _src("routes/session_routes.py")
 
     assert 'owner = getattr(session, "owner", None) or effective_user(request)' in session_src
-    assert 'resolve_endpoint("utility", owner=owner)' in session_src
+    kwargs = _utility_kwargs(session_src, "compact_session")
+    assert kwargs["owner"] == "owner"
+    assert kwargs["fallback_url"] == "getattr(session, 'endpoint_url', None)"
+    assert kwargs["fallback_model"] == "getattr(session, 'model', None)"
+    assert kwargs["fallback_headers"] == "getattr(session, 'headers', None)"
 
 
 def test_task_name_generation_uses_owner_scoped_session_endpoint():
@@ -31,7 +63,11 @@ def test_auto_compaction_utility_endpoint_keeps_chat_owner():
 
     assert "owner=user" in helper_src
     assert "owner: Optional[str] = None" in compact_src
-    assert 'resolve_endpoint("utility", owner=owner)' in compact_src
+    kwargs = _utility_kwargs(compact_src, "maybe_compact")
+    assert kwargs["owner"] == "owner"
+    assert kwargs["fallback_url"] == "endpoint_url"
+    assert kwargs["fallback_model"] == "model"
+    assert kwargs["fallback_headers"] == "headers"
 
 
 def test_background_session_sort_uses_owner_task_endpoint():

tests/test_chatgpt_reasoning_and_grouping.py

@@ -183,7 +183,10 @@ def test_history_and_chat_routes_support_reasoning_effort():
     """Verify history and chat routes support reasoning_effort and thinking_mode persistence."""
     hist_src = (ROOT / "routes/history/history_routes.py").read_text(encoding="utf-8")
     assert "reasoning_effort" in hist_src
-    assert 'mode = f"effort:{clean_effort}"' in hist_src
+    assert "def _effort_mode(" in hist_src
+    assert 'return f"effort:{effort}" if effort else "off"' in hist_src
+    assert "mode = _effort_mode(session.model, raw_effort)" in hist_src
+    assert "mode = _effort_mode(session.model, raw_mode[7:])" in hist_src
 
     chat_src = (ROOT / "routes/chat_routes.py").read_text(encoding="utf-8")
     assert "validate_reasoning_effort(sess.model, reasoning_effort)" in chat_src

tests/test_context_compactor.py

@@ -311,7 +311,14 @@ class TestMaybeCompactFourthMessage:
 
         cc.get_context_length = lambda url, model: context_length
         cc.llm_call_async = _fake_summary
-        cc.resolve_endpoint = lambda which, owner=None: (None, None, None)
+        def fake_resolve_endpoint(which, **kwargs):
+            assert which == "utility"
+            assert kwargs["fallback_url"] == "http://local/v1/chat/completions"
+            assert kwargs["fallback_model"] == "local-model"
+            assert kwargs["fallback_headers"] == {}
+            return None, None, None
+
+        cc.resolve_endpoint = fake_resolve_endpoint
         cc._update_session_history = lambda *a, **k: None
         try:
             return asyncio.run(

tests/test_history_compact_tool_calls.py

@@ -108,8 +108,12 @@ def _compact_prompt_for(monkeypatch, history):
     import src.model_context as model_context
 
     monkeypatch.setattr(agent_runs, "is_active", lambda session_id: False)
-    def fake_resolve_endpoint(kind, owner=None):
+    def fake_resolve_endpoint(kind, owner=None, **kwargs):
         captured.setdefault("resolve_calls", []).append((kind, owner))
+        if "fallback_url" in kwargs:
+            captured.setdefault("fallback_calls", []).append(
+                (kind, owner, kwargs)
+            )
         return None, None, {}
 
     monkeypatch.setattr(endpoint_resolver, "resolve_endpoint", fake_resolve_endpoint)
@@ -127,6 +131,13 @@ def _compact_prompt_for(monkeypatch, history):
     assert response.status_code == 200
     assert response.json()["status"] == "ok"
     assert manager.saved is True
+    assert any(
+        kind == "utility"
+        and kwargs.get("fallback_url") == session.endpoint_url
+        and kwargs.get("fallback_model") == session.model
+        and kwargs.get("fallback_headers") == session.headers
+        for kind, _owner, kwargs in captured.get("fallback_calls", [])
+    )
     return captured["messages"][1]["content"]
 
 
@@ -151,8 +162,12 @@ def _registered_compact_response(monkeypatch, history, active_run=False):
     import src.llm_core as llm_core
 
     monkeypatch.setattr(agent_runs, "is_active", lambda session_id: active_run)
-    def fake_resolve_endpoint(kind, owner=None):
+    def fake_resolve_endpoint(kind, owner=None, **kwargs):
         captured.setdefault("resolve_calls", []).append((kind, owner))
+        if "fallback_url" in kwargs:
+            captured.setdefault("fallback_calls", []).append(
+                (kind, owner, kwargs)
+            )
         return None, None, {}
 
     monkeypatch.setattr(endpoint_resolver, "resolve_endpoint", fake_resolve_endpoint)
@@ -237,6 +252,14 @@ def test_registered_manual_compact_route_uses_session_owner(monkeypatch):
     assert response.status_code == 200
     assert manager.replaced_messages is not None
     assert ("utility", "session-owner") in captured["resolve_calls"]
+    assert any(
+        kind == "utility"
+        and owner == "session-owner"
+        and kwargs.get("fallback_url") == manager.session.endpoint_url
+        and kwargs.get("fallback_model") == manager.session.model
+        and kwargs.get("fallback_headers") == manager.session.headers
+        for kind, owner, kwargs in captured.get("fallback_calls", [])
+    )
 
 
 def test_registered_manual_compact_route_rejects_active_agent_run(monkeypatch):

tests/test_model_helper_owner_scope.py

@@ -36,7 +36,26 @@ def test_task_parse_resolves_with_owner_scope():
 def test_history_compact_resolves_with_owner_scope():
     body = _function_source("routes/history/history_routes.py", "compact_session")
     assert "owner = effective_user(request)" in body
-    assert 'resolve_endpoint("utility", owner=owner or None)' in body
+    tree = ast.parse(body)
+    calls = [
+        node for node in ast.walk(tree)
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "resolve_endpoint"
+        and node.args
+        and isinstance(node.args[0], ast.Constant)
+        and node.args[0].value == "utility"
+    ]
+    assert len(calls) == 1
+
+    kwargs = {
+        kw.arg: ast.unparse(kw.value)
+        for kw in calls[0].keywords
+    }
+    assert kwargs["owner"] == "owner or None"
+    assert kwargs["fallback_url"] == "getattr(session, 'endpoint_url', None)"
+    assert kwargs["fallback_model"] == "getattr(session, 'model', None)"
+    assert kwargs["fallback_headers"] == "getattr(session, 'headers', None)"
 
 
 def test_note_reminder_synthesis_resolves_with_owner_scope():