Address feedback from brad

Author: clean6378-max-it

services/search.py

@@ -76,7 +76,11 @@ def resolve_search_since_ms(
     since_days: int | None = None,
     now: datetime | None = None,
 ) -> int | None:
-    """Return epoch-ms cutoff for search, or ``None`` to search all history."""
+    """Return epoch-ms cutoff for search, or ``None`` to search all history.
+
+    Composers with no parseable timestamp (``updated_ms <= 0``) remain
+    searchable when a window is active; see ``_INCLUDE_UNKNOWN_TIMESTAMPS_IN_WINDOW``.
+    """
     if all_history:
         return None
     days = since_days if since_days is not None else DEFAULT_SEARCH_WINDOW_DAYS
@@ -348,6 +352,7 @@ class _SearchWorkspaceAssigner:
     invalid_workspace_aliases: dict[str, str]
 
     def workspace_for_composer(self, composer: Composer) -> str:
+        # Deliberately omit global bubble index (same as list/summary paths).
         return assign_composer_workspace(
             composer,
             project_layouts_map=self.ctx.project_layouts_map,
@@ -477,7 +482,7 @@ def _search_global_storage_via_index(
 ) -> list[SearchResult] | None:
     """Search using local FTS index. Returns ``None`` to fall back to live scan."""
     from services.search_index import (
-        query_all_composer_bubble_texts,
+        query_all_bubble_texts_for_composer_ids,
         query_composer_bubble_hits,
         query_composer_rows_in_window,
         query_composer_title_hits,
@@ -520,6 +525,8 @@ def _search_global_storage_via_index(
             if query_lower in raw_lower:
                 candidate_ids.add(composer_id)
 
+        all_bubbles_by_composer = query_all_bubble_texts_for_composer_ids(candidate_ids)
+
         for composer_id in candidate_ids:
             composer_row = search_pool.get(composer_id)
             if composer_row is None:
@@ -584,7 +591,7 @@ def _search_global_storage_via_index(
                     if not has_match:
                         continue
 
-                all_bubble_texts = query_all_composer_bubble_texts(composer_id)
+                all_bubble_texts = all_bubbles_by_composer.get(composer_id, [])
                 exclusion_text = _composer_exclusion_text(
                     project_name=project_name,
                     title=title,

services/search_index.py

@@ -47,6 +47,7 @@
     "ensure_search_index",
     "index_is_usable",
     "index_search_enabled",
+    "query_all_bubble_texts_for_composer_ids",
     "query_all_composer_bubble_texts",
     "query_composer_bubble_hits",
     "query_composer_title_hits",
@@ -258,6 +259,7 @@ def build_search_index(
                 _create_schema(conn)
                 composer_count = 0
                 bubble_count = 0
+                indexed_composer_ids: set[str] = set()
 
                 with open_global_db(workspace_path) as (src_conn, _):
                     if src_conn is None:
@@ -267,6 +269,7 @@ def build_search_index(
                     ).fetchall()
                     for row in composer_rows:
                         composer_id = row["key"].split(":")[1]
+                        indexed_composer_ids.add(composer_id)
                         raw_text = _composer_row_raw_text(row)
                         try:
                             cd = json.loads(raw_text)
@@ -300,6 +303,8 @@ def build_search_index(
                         if len(parts) < 2 or not parts[1]:
                             continue
                         composer_id = parts[1]
+                        if composer_id not in indexed_composer_ids:
+                            continue
                         text = _quick_bubble_text(row["value"])
                         if not text:
                             continue
@@ -485,18 +490,38 @@ def query_all_composer_bubble_texts(composer_id: str) -> list[str]:
     """All indexed bubble texts for one composer (exclusion-rule checks)."""
     if not composer_id or not index_search_enabled():
         return []
+    by_id = query_all_bubble_texts_for_composer_ids({composer_id})
+    return by_id.get(composer_id, [])
+
+
+def query_all_bubble_texts_for_composer_ids(
+    composer_ids: set[str] | frozenset[str],
+) -> dict[str, list[str]]:
+    """Batch-load all indexed bubble texts for exclusion-rule checks."""
+    if not composer_ids or not index_search_enabled():
+        return {}
 
+    ids = list(composer_ids)
+    result: dict[str, list[str]] = {}
     with _index_db_conn(readonly=True) as conn:
         if conn is None:
-            return []
+            return {}
         try:
-            rows = conn.execute(
-                "SELECT text FROM bubbles_fts WHERE composer_id = ?",
-                (composer_id,),
-            ).fetchall()
+            for offset in range(0, len(ids), 500):
+                chunk = ids[offset : offset + 500]
+                placeholders = ",".join("?" * len(chunk))
+                rows = conn.execute(
+                    "SELECT composer_id, text FROM bubbles_fts"
+                    f" WHERE composer_id IN ({placeholders})",
+                    chunk,
+                ).fetchall()
+                for row in rows:
+                    text = row["text"]
+                    if text:
+                        result.setdefault(row["composer_id"], []).append(text)
         except sqlite3.Error:
-            return []
-        return [row["text"] for row in rows if row["text"]]
+            return {}
+    return result
 
 
 def query_composer_rows_in_window(

services/workspace_listing.py

@@ -148,6 +148,7 @@ def _build_workspace_projects_uncached(
                             project_name_map=project_name_map,
                             workspace_path_map=workspace_path_map,
                             workspace_entries=workspace_entries,
+                            # Empty bubble map matches summary assignment (#95 perf tradeoff).
                             bubble_map=bubble_map,
                             composer_id_to_ws=composer_id_to_ws,
                             invalid_workspace_ids=invalid_workspace_ids,

services/workspace_resolver.py

@@ -109,7 +109,7 @@ def matching_workspace_ids_for_folder(
         first_folder = folders[0] if folders else None
         if first_folder:
             target_folder = normalize_file_path(first_folder)
-    except Exception as e:
+    except (OSError, json.JSONDecodeError, KeyError, TypeError, ValueError) as e:
         warn_workspace_json_read(_logger, workspace_id, e)
     if not target_folder:
         return matching
@@ -120,7 +120,7 @@ def matching_workspace_ids_for_folder(
             f2 = folders2[0] if folders2 else None
             if f2 and normalize_file_path(f2) == target_folder:
                 matching.add(entry["name"])
-        except Exception as e:
+        except (OSError, json.JSONDecodeError, KeyError, TypeError, ValueError) as e:
             warn_workspace_json_read(_logger, entry["name"], e)
     return matching
 
@@ -433,7 +433,7 @@ def infer_invalid_workspace_aliases(
             continue
         try:
             cd = json.loads(row["value"])
-        except Exception as e:
+        except (json.JSONDecodeError, TypeError, ValueError) as e:
             _logger.warning(
                 "Failed to decode Composer from composerData:%s: %s",
                 cid,

services/workspace_tabs.py

@@ -67,7 +67,6 @@
 )
 from utils.workspace_path import get_cli_chats_path
 from services.workspace_resolver import (
-    determine_project_for_conversation,
     infer_invalid_workspace_aliases,
     lookup_workspace_display_name,
     matching_workspace_ids_for_folder,
@@ -576,38 +575,18 @@ def assemble_single_tab(
             return {"error": "Conversation not found"}, 404
 
         row = rows[0]
-        try:
-            parsed = json.loads(row["value"])
-        except (json.JSONDecodeError, TypeError, ValueError) as e:
-            payload_len, payload_fp = _kv_payload_log_meta(row["value"])
-            _logger.warning(
-                "Failed to decode Composer from composerData:%s: %s (payload_len=%d, payload_sha256=%s)",
-                composer_id,
-                e,
-                payload_len,
-                payload_fp,
-            )
-            return {"error": "Failed to parse conversation"}, 500
-        try:
-            composer = Composer.from_dict(parsed, composer_id=composer_id)
-        except SchemaError as e:
-            _logger.warning(
-                "Failed to parse Composer from composerData:%s: %s",
-                composer_id,
-                e,
-            )
-            return {"error": "Failed to parse conversation"}, 500
+        composer = parse_composer_data_row(
+            row["key"], row["value"], parse_warnings=parse_warnings,
+        )
+        if composer is None:
+            return {"error": "Conversation not found"}, 404
 
-        # Verify the conversation belongs to the requested workspace.
-        # Always scoped: only load messageRequestContext rows for this composer.
         project_layouts_map: dict[str, list[str]] = {}
         invalid_workspace_aliases: dict[str, str] = {}
         project_layouts_map[composer_id] = load_project_layouts_for_composer(
             global_db, composer_id,
         )
         if invalid_workspace_ids:
-            # Alias resolution still needs the composer roster, but project layouts
-            # are intentionally limited to this composer (single-tab scope).
             composer_rows_for_aliases = safe_fetchall(global_db, COMPOSER_ROWS_WITH_HEADERS_SQL)
             invalid_workspace_aliases = infer_invalid_workspace_aliases(
                 composer_rows=composer_rows_for_aliases,
@@ -620,23 +599,24 @@ def assemble_single_tab(
                 invalid_workspace_ids=invalid_workspace_ids,
             )
 
-        pid = determine_project_for_conversation(
-            composer, composer_id, project_layouts_map,
-            project_name_map, workspace_path_map,
-            workspace_entries, {}, composer_id_to_ws, invalid_workspace_ids,
+        bubble_map = load_bubbles_for_composer(
+            global_db, composer_id, parse_warnings=parse_warnings,
+        )
+        assigned = assign_composer_workspace(
+            composer,
+            project_layouts_map=project_layouts_map,
+            project_name_map=project_name_map,
+            workspace_path_map=workspace_path_map,
+            workspace_entries=workspace_entries,
+            bubble_map=bubble_map,
+            composer_id_to_ws=composer_id_to_ws,
+            invalid_workspace_ids=invalid_workspace_ids,
+            invalid_workspace_aliases=invalid_workspace_aliases,
         )
-        mapped_ws = composer_id_to_ws.get(composer_id)
-        if not pid and mapped_ws in invalid_workspace_ids:
-            pid = invalid_workspace_aliases.get(mapped_ws)
-        assigned = pid if pid else "global"
 
         if assigned not in matching_ws_ids:
             return {"error": "Conversation not found"}, 404
 
-        # Scoped loads — only rows for this composer_id.
-        bubble_map = load_bubbles_for_composer(
-            global_db, composer_id, parse_warnings=parse_warnings
-        )
         contexts = load_message_request_context_for_composer(global_db, composer_id)
         code_block_diffs = load_code_block_diffs_for_composer(global_db, composer_id)
 
@@ -743,16 +723,18 @@ def assemble_workspace_tabs(
         # Get composer data entries with conversations
         composer_rows = safe_fetchall(global_db, COMPOSER_ROWS_WITH_HEADERS_SQL)
 
-        invalid_workspace_aliases = infer_invalid_workspace_aliases(
-            composer_rows=composer_rows,
-            project_layouts_map=project_layouts_map,
-            project_name_map=project_name_map,
-            workspace_path_map=workspace_path_map,
-            workspace_entries=workspace_entries,
-            bubble_map=bubble_map,
-            composer_id_to_ws=composer_id_to_ws,
-            invalid_workspace_ids=invalid_workspace_ids,
-        )
+        invalid_workspace_aliases: dict[str, str] = {}
+        if invalid_workspace_ids:
+            invalid_workspace_aliases = infer_invalid_workspace_aliases(
+                composer_rows=composer_rows,
+                project_layouts_map=project_layouts_map,
+                project_name_map=project_name_map,
+                workspace_path_map=workspace_path_map,
+                workspace_entries=workspace_entries,
+                bubble_map=bubble_map,
+                composer_id_to_ws=composer_id_to_ws,
+                invalid_workspace_ids=invalid_workspace_ids,
+            )
 
         for row in composer_rows:
             composer = parse_composer_data_row(
@@ -762,16 +744,18 @@ def assemble_workspace_tabs(
                 continue
             composer_id = composer.composer_id
             try:
-                # Determine project
-                pid = determine_project_for_conversation(
-                    composer, composer_id, project_layouts_map,
-                    project_name_map, workspace_path_map,
-                    workspace_entries, bubble_map, composer_id_to_ws, invalid_workspace_ids,
+                assigned = assign_composer_workspace(
+                    composer,
+                    project_layouts_map=project_layouts_map,
+                    project_name_map=project_name_map,
+                    workspace_path_map=workspace_path_map,
+                    workspace_entries=workspace_entries,
+                    # Assignment matches summary path; bubble_map used only for tab body.
+                    bubble_map={},
+                    composer_id_to_ws=composer_id_to_ws,
+                    invalid_workspace_ids=invalid_workspace_ids,
+                    invalid_workspace_aliases=invalid_workspace_aliases,
                 )
-                mapped_ws = composer_id_to_ws.get(composer_id)
-                if not pid and mapped_ws in invalid_workspace_ids:
-                    pid = invalid_workspace_aliases.get(mapped_ws)
-                assigned = pid if pid else "global"
 
                 if assigned not in matching_ws_ids:
                     continue

tests/test_workspace_list_count_alignment.py

@@ -13,7 +13,11 @@
 from services.workspace_composer_scan import parse_composer_data_row
 from services.workspace_db import build_composer_id_to_workspace_id, collect_workspace_entries
 from services.workspace_listing import list_workspace_projects
-from services.workspace_tabs import list_workspace_tab_summaries
+from services.workspace_tabs import (
+    assemble_single_tab,
+    assemble_workspace_tabs,
+    list_workspace_tab_summaries,
+)
 from tests._fixture_ids import HAPPY_COMPOSER_ID, HAPPY_WORKSPACE_ID
 
 
@@ -109,6 +113,45 @@ def test_parallel_composer_registry_covers_all_workspaces(tmp_path):
         assert mapping[f"cmp-{i}"] == ws_id
 
 
+def test_summary_and_full_tabs_share_assignment(tmp_path):
+    """Summary and full /tabs agree on which composers belong after assignment."""
+    ws_root = _layout(tmp_path)
+    global_db = os.path.join(tmp_path, "globalStorage", "state.vscdb")
+    with contextlib.closing(sqlite3.connect(global_db)) as conn:
+        conn.execute(
+            "INSERT INTO cursorDiskKV ([key], value) VALUES (?, ?)",
+            (
+                f"bubbleId:{HAPPY_COMPOSER_ID}:b1",
+                json.dumps({"type": "user", "text": "hello", "bubbleId": "b1"}),
+            ),
+        )
+        conn.commit()
+
+    summary, summary_status = list_workspace_tab_summaries(
+        HAPPY_WORKSPACE_ID, ws_root, rules=[], nocache=True,
+    )
+    full, full_status = assemble_workspace_tabs(
+        HAPPY_WORKSPACE_ID, ws_root, rules=[],
+    )
+    assert summary_status == 200
+    assert full_status == 200
+    summary_ids = {t["id"] for t in summary["tabs"]}
+    full_ids = {t["id"] for t in full["tabs"]}
+    assert summary_ids == full_ids
+
+
+def test_single_tab_null_composer_placeholder_returns_404(tmp_path):
+    ws_root = _layout(
+        tmp_path,
+        extra_rows=[("composerData:empty-state-draft", None)],
+    )
+    payload, status = assemble_single_tab(
+        "global", "empty-state-draft", ws_root, rules=[],
+    )
+    assert status == 404
+    assert "error" in payload
+
+
 def test_excluded_model_dropped_from_list_and_summary(tmp_path):
     ws_root = _layout(tmp_path)
     rules = [["gpt-4o"]]