review: 2 CodeRabbit findings on PR #30 — response-shape parity + alias-vote drift guard

* api/composers.py — get_composer() returned three different shapes for
  the same conceptual `conversation` field depending on which branch
  resolved the composer:
    - list_composers (line 89): `c["conversation"] = c.get("conversation") or []`
    - get_composer per-workspace (line 157):   `return jsonify(local.raw)` — raw, no normalisation
    - get_composer global fallback (line 185): `payload.setdefault("conversation", [])` — fills missing but not None
  All three sites now use the line-89 idiom, so the endpoint family
  returns an identical shape regardless of source.

* api/workspaces.py — `_infer_invalid_workspace_aliases()` was reparsing
  raw composer_rows with `json.loads` + bare `except Exception` *before*
  the per-row Composer.from_dict gates in list_workspaces() /
  get_workspace_tabs() ran. That meant schema-drifted composers could
  still cast votes in the workspace-alias inference and misassign
  otherwise-valid composers to the wrong workspace. Now gates via
  `Composer.from_dict(...)` with a narrow
  `(SchemaError, JSONDecodeError, TypeError, ValueError)` catch.

  Existing test_majority_vote_alias_selection fixture predated the
  strict createdAt gate from issue #24; added `createdAt` to each of
  the three composer rows so the fixture reflects real production shape.

  New test_drifted_composer_does_not_skew_vote pins the regression:
  seeds two well-formed boost-ws votes plus one drifted row that would
  vote for team-ws if counted, asserts the alias resolves to boost-ws.

Verified:
  - mypy --ignore-missing-imports --no-strict-optional . → Success
  - ruff check api/ utils/ scripts/export.py app.py → All checks passed
  - unittest discover tests → 224 / 224 OK (was 223 + 1 new regression test)

Author: timon0305

api/composers.py

@@ -154,7 +154,14 @@ def get_composer(composer_id):
                                 # JSON the list endpoint hid.
                                 print(f"Schema drift in workspace-local composer {composer_id}: {e}")
                                 continue
-                            return jsonify(local.raw)
+                            # Match list_composers() at line 89 and the global
+                            # fallback below: `conversation` is normalised to []
+                            # whether it's absent or None, so the response shape
+                            # is identical regardless of which branch resolved
+                            # the composer (CodeRabbit on PR #30).
+                            payload = dict(local.raw)
+                            payload["conversation"] = payload.get("conversation") or []
+                            return jsonify(payload)
             except SchemaError as e:
                 print(f"Schema drift in {db_path}: {e}")
             except (OSError, sqlite3.Error, json.JSONDecodeError, ValueError):
@@ -182,7 +189,7 @@ def get_composer(composer_id):
                         print(f"Schema drift in composer {composer_id}: {e}")
                         return jsonify({"error": "Composer schema drift"}), 404
                     payload = dict(composer.raw)
-                    payload.setdefault("conversation", [])
+                    payload["conversation"] = payload.get("conversation") or []
                     return jsonify(payload)
             except (OSError, sqlite3.Error, json.JSONDecodeError, ValueError):
                 pass

api/workspaces.py

@@ -447,8 +447,15 @@ def _infer_invalid_workspace_aliases(
         if mapped not in invalid_workspace_ids:
             continue
         try:
-            cd = json.loads(row["value"])
-        except Exception:
+            # Validate via Composer.from_dict so a schema-drifted row can't
+            # steer the alias vote and misassign otherwise-valid composers to
+            # the wrong workspace. The downstream per-row loops in
+            # list_workspaces() / get_workspace_tabs() already drop drift,
+            # but this helper runs BEFORE that loop and its votes shape
+            # invalid_workspace_aliases for every other composer.
+            composer = Composer.from_dict(json.loads(row["value"]), composer_id=cid)
+            cd = composer.raw
+        except (SchemaError, json.JSONDecodeError, TypeError, ValueError):
             continue
         inferred = _determine_project_for_conversation(
             cd,

tests/test_invalid_workspace_aliases.py

@@ -11,10 +11,13 @@
 
 class TestInvalidWorkspaceAliases(unittest.TestCase):
     def test_majority_vote_alias_selection(self):
+        # `createdAt` is required by Composer.from_dict (issue #24's strict
+        # numeric-millis gate). Production rows always carry it; the original
+        # fixture predated the gate.
         composer_rows = [
-            {"key": "composerData:cid-1", "value": json.dumps({"fullConversationHeadersOnly": []})},
-            {"key": "composerData:cid-2", "value": json.dumps({"fullConversationHeadersOnly": []})},
-            {"key": "composerData:cid-3", "value": json.dumps({"fullConversationHeadersOnly": []})},
+            {"key": "composerData:cid-1", "value": json.dumps({"createdAt": 1_715_000_000_000, "fullConversationHeadersOnly": []})},
+            {"key": "composerData:cid-2", "value": json.dumps({"createdAt": 1_715_000_000_000, "fullConversationHeadersOnly": []})},
+            {"key": "composerData:cid-3", "value": json.dumps({"createdAt": 1_715_000_000_000, "fullConversationHeadersOnly": []})},
         ]
         composer_id_to_ws = {
             "cid-1": "invalid-ws",
@@ -46,6 +49,44 @@ def test_majority_vote_alias_selection(self):
 
         self.assertEqual(aliases.get("invalid-ws"), "boost-ws")
 
+    def test_drifted_composer_does_not_skew_vote(self):
+        # CodeRabbit regression check: a schema-drifted composer
+        # (e.g. missing createdAt) must NOT cast a vote, because if it did
+        # it could outweigh well-formed composers and misassign every other
+        # composer mapped to the same invalid workspace.
+        composer_rows = [
+            # Two well-formed votes for boost-ws
+            {"key": "composerData:cid-1", "value": json.dumps({"createdAt": 1_715_000_000_000, "fullConversationHeadersOnly": []})},
+            {"key": "composerData:cid-2", "value": json.dumps({"createdAt": 1_715_000_000_000, "fullConversationHeadersOnly": []})},
+            # One drifted row that, if counted, would vote for team-ws
+            # (no createdAt → Composer.from_dict raises SchemaError → skip)
+            {"key": "composerData:cid-3", "value": json.dumps({"fullConversationHeadersOnly": []})},
+        ]
+        composer_id_to_ws = {"cid-1": "invalid-ws", "cid-2": "invalid-ws", "cid-3": "invalid-ws"}
+        project_layouts_map = {
+            "cid-1": [normalize_file_path(r"d:\_Cpp_Digest\boostbacklog")],
+            "cid-2": [normalize_file_path(r"d:\_Cpp_Digest\boostbacklog")],
+            "cid-3": [normalize_file_path(r"d:\_Cpp_Digest\team-brain")],
+        }
+        workspace_path_map = {
+            normalize_file_path(r"d:\_cpp_digest\boostbacklog"): "boost-ws",
+            normalize_file_path(r"d:\_cpp_digest\team-brain"): "team-ws",
+        }
+
+        aliases = _infer_invalid_workspace_aliases(
+            composer_rows=composer_rows,
+            project_layouts_map=project_layouts_map,
+            project_name_map={},
+            workspace_path_map=workspace_path_map,
+            workspace_entries=[],
+            bubble_map={},
+            composer_id_to_ws=composer_id_to_ws,
+            invalid_workspace_ids={"invalid-ws"},
+        )
+
+        # cid-3 is dropped (drift), so boost-ws wins 2-0 (not 2-1)
+        self.assertEqual(aliases.get("invalid-ws"), "boost-ws")
+
 
 if __name__ == "__main__":
     unittest.main()