fix(#125): harden alias cache validation and honor nocache fast path

Author: clean6378-max-it

services/summary_cache.py

@@ -258,7 +258,12 @@ def get_cached_invalid_workspace_aliases(
     aliases = data.get("invalid_workspace_aliases")
     if not isinstance(aliases, dict):
         return None
-    return {str(k): str(v) for k, v in aliases.items()}
+    validated: dict[str, str] = {}
+    for key, value in aliases.items():
+        if not isinstance(key, str) or not isinstance(value, str):
+            return None
+        validated[key] = value
+    return validated
 
 
 def set_cached_invalid_workspace_aliases(

services/workspace_context.py

@@ -4,7 +4,7 @@
 
 import os
 import sqlite3
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, replace
 from typing import Any
 
 from models import Bubble
@@ -37,7 +37,7 @@ class WorkspaceContext:
     workspace_path_to_id: dict[str, str]
     project_layouts_map: dict[str, list[str]]
     bubble_map: dict[str, Bubble]
-    invalid_workspace_aliases: dict[str, str] = field(default_factory=dict)
+    invalid_workspace_aliases: dict[str, str] | None = None
 
 
 def _entries(
@@ -171,6 +171,8 @@ def resolve_invalid_workspace_aliases_cached(
     Returns:
         ``{invalid_id: replacement_id}``, or ``{}`` when every workspace is valid.
     """
+    if ctx.invalid_workspace_aliases is not None:
+        return ctx.invalid_workspace_aliases
     if not ctx.invalid_workspace_ids:
         return {}
 
@@ -227,6 +229,8 @@ def with_invalid_workspace_aliases(
     project_layouts_map: dict[str, list[str]] | None = None,
 ) -> WorkspaceContext:
     """Return *ctx* with ``invalid_workspace_aliases`` populated from cache."""
+    if ctx.invalid_workspace_aliases is not None:
+        return ctx
     aliases = resolve_invalid_workspace_aliases_cached(
         ctx,
         global_db,
@@ -235,6 +239,4 @@ def with_invalid_workspace_aliases(
         nocache=nocache,
         project_layouts_map=project_layouts_map,
     )
-    if aliases is ctx.invalid_workspace_aliases:
-        return ctx
     return replace(ctx, invalid_workspace_aliases=aliases)

services/workspace_listing.py

@@ -93,7 +93,7 @@ def list_workspace_projects(
     )
 
     projects, warnings = _build_workspace_projects_uncached(
-        workspace_path, rules, orch,
+        workspace_path, rules, orch, nocache=effective_nocache,
     )
     if not effective_nocache:
         set_cached_projects(orch.fingerprint, projects, warnings)
@@ -104,6 +104,8 @@ def _build_workspace_projects_uncached(
     workspace_path: str,
     rules: list[Any],
     orch: WorkspaceOrchestration,
+    *,
+    nocache: bool = False,
 ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
     parse_warnings = ParseWarningCollector()
     ctx = orch.ctx
@@ -129,6 +131,7 @@ def _build_workspace_projects_uncached(
                     global_db,
                     workspace_path,
                     rules,
+                    nocache=nocache,
                     project_layouts_map=project_layouts_map,
                 )
 

tests/test_summary_cache.py

@@ -102,6 +102,17 @@ def test_invalid_workspace_aliases_cache_miss_on_fingerprint_change(self):
         set_cached_invalid_workspace_aliases(fp1, {"broken-ws": "good-ws"})
         self.assertIsNone(get_cached_invalid_workspace_aliases(fp2))
 
+    def test_invalid_workspace_aliases_rejects_non_string_entries(self):
+        fp = {"version": 1, "workspace_path": "/ws", "global_db_mtime_ns": 100}
+        summary_cache._write_cache_file(
+            summary_cache.INVALID_WORKSPACE_ALIASES_CACHE_FILE,
+            {
+                "fingerprint": fp,
+                "invalid_workspace_aliases": {"broken-ws": 123},
+            },
+        )
+        self.assertIsNone(get_cached_invalid_workspace_aliases(fp))
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_workspace_context.py

@@ -362,4 +362,30 @@ def test_with_invalid_workspace_aliases_attaches_to_context():
                 assert enriched.invalid_workspace_aliases == {
                     "invalidws": "abc123workspace",
                 }
-                assert ctx.invalid_workspace_aliases == {}
+                assert ctx.invalid_workspace_aliases is None
+
+
+def test_resolve_invalid_workspace_aliases_uses_ctx_fast_path():
+    from dataclasses import replace
+
+    with tempfile.TemporaryDirectory() as tmp:
+        ws_root = _make_workspace_root(tmp)
+        _add_workspace_without_folders(ws_root, "invalidws")
+        ctx = resolve_workspace_context(ws_root)
+        enriched = replace(
+            ctx,
+            invalid_workspace_aliases={"invalidws": "abc123workspace"},
+        )
+        conn = _open_workspace_global_db(ws_root)
+        conn.commit()
+        try:
+            with patch(
+                "services.workspace_context.infer_invalid_workspace_aliases",
+            ) as mock_infer:
+                aliases = resolve_invalid_workspace_aliases_cached(
+                    enriched, conn, ws_root, [],
+                )
+            assert aliases == {"invalidws": "abc123workspace"}
+            mock_infer.assert_not_called()
+        finally:
+            conn.close()

tests/test_workspace_listing_performance.py

@@ -65,6 +65,15 @@ def _make_fixture(base: str) -> str:
     return ws_path
 
 
+def _make_fixture_with_invalid_workspace(base: str) -> str:
+    ws_path = _make_fixture(base)
+    invalid_dir = os.path.join(ws_path, "invalid-ws")
+    os.makedirs(invalid_dir)
+    with open(os.path.join(invalid_dir, "workspace.json"), "w", encoding="utf-8") as f:
+        json.dump({"folders": []}, f)
+    return ws_path
+
+
 class TestListWorkspaceProjectsNoBubbleScan(unittest.TestCase):
     """list_workspace_projects must not query bubbleId rows from global storage."""
 
@@ -126,6 +135,15 @@ def test_output_shape_preserved(self):
             self.assertIn("conversationCount", p)
             self.assertIn("lastModified", p)
 
+    def test_nocache_bypasses_alias_disk_cache(self):
+        ws_path = _make_fixture_with_invalid_workspace(self.tmp.name)
+        with patch(
+            "services.summary_cache.get_cached_invalid_workspace_aliases",
+        ) as mock_get:
+            mock_get.return_value = {"invalid-ws": "global"}
+            list_workspace_projects(ws_path, rules=[], nocache=True)
+        mock_get.assert_not_called()
+
 
 if __name__ == "__main__":
     unittest.main()