Address second round of CodeRabbit review comments

- utils/cli_chat_reader.py: populate tool outputs in messages_to_bubbles()
  by pre-scanning role=="tool" messages and matching by toolCallId.  Tool
  outputs are no longer silently dropped (output was always "").
  Use max(createdAt, store.db mtime) for last_updated_ms in
  list_cli_projects(), so sessions with new turns refresh the timestamp.

- api/search.py: include tool call inputs/summaries in the exclusion-check
  content_parts for CLI sessions, so sensitive payloads in tool calls
  cannot bypass is_excluded_by_rules.

- utils/cursor_md_exporter.py: extend cursor_cli_session_to_markdown()
  with workspace_info, bubbles, and title_override parameters.  Callers
  can now pass pre-computed bubbles (avoids redundant DB read) and a
  caller-derived title (needed for filenames in export.py).  Error
  handling changed: traverse_blobs/messages_to_bubbles errors now
  propagate instead of silently collapsing to empty bubbles.  Body
  rendering now includes tool OUTPUT blocks when present.

- scripts/export.py: remove the ~80-line duplicate Markdown generator;
  delegate to cursor_cli_session_to_markdown() with workspace_info and
  pre-computed bubbles.  Keeps title derivation and --since filtering
  in place; only the rendering is delegated.

- tests/test_cli_chat_reader.py: update last_updated_ms test to assert
  >= max(createdAt) instead of == createdAt, since mtime now dominates
  for freshly created test files.

Rejected: "don't drop empty sessions" (same reasoning as before).

Author: wpak-ai

api/search.py

@@ -378,10 +378,15 @@ def search():
                                     break
 
                         bubble_texts = [b["text"] for b in bubbles if b.get("text")]
+                        tool_payloads = [
+                            tc.get("input") or tc.get("summary") or ""
+                            for b in bubbles
+                            for tc in (b.get("metadata") or {}).get("toolCalls") or []
+                        ]
                         exclusion_text = _build_exclusion_searchable(
                             project_name=ws_name,
                             chat_title=title,
-                            content_parts=bubble_texts,
+                            content_parts=bubble_texts + tool_payloads,
                         )
                         if is_excluded_by_rules(rules, exclusion_text):
                             continue

scripts/export.py

@@ -37,6 +37,7 @@
     messages_to_bubbles,
     aggregate_session_stats,
 )
+from utils.cursor_md_exporter import cursor_cli_session_to_markdown
 
 _logger = logging.getLogger(__name__)
 
@@ -861,12 +862,13 @@ def assign_workspace(cd, cid):
             if not bubbles:
                 continue
 
-            # Derive title from first user bubble
+            # Derive title for the filename (shared exporter does it too, but
+            # we need it here first to build the output path).
             title = session_name
             if not title or title.startswith("New Agent"):
                 for b in bubbles:
                     if b["type"] == "user" and b.get("text"):
-                        first_lines = [l for l in b["text"].split("\n") if l.strip()]
+                        first_lines = [ln for ln in b["text"].split("\n") if ln.strip()]
                         if first_lines:
                             title = first_lines[0][:100]
                             if len(title) == 100:
@@ -887,73 +889,25 @@ def assign_workspace(cd, cid):
             if is_excluded_by_rules(exclusion_rules, searchable):
                 continue
 
-            # Aggregate statistics
-            total_tool_calls = 0
-            tool_breakdown: dict = {}
-            for b in bubbles:
-                tcs = (b.get("metadata") or {}).get("toolCalls") or []
-                total_tool_calls += len(tcs)
-                for tc in tcs:
-                    tn = tc.get("name", "unknown")
-                    tool_breakdown[tn] = tool_breakdown.get(tn, 0) + 1
-
             title_slug = slug(title)
             ts_str = datetime.fromtimestamp(created_ms / 1000).strftime("%Y-%m-%dT%H-%M-%S")
             filename = f"{ts_str}__{title_slug}__{session_id[:8]}.md"
             rel_dir = os.path.join(today, ws_slug_cli, "cli")
             out_path = os.path.join(out_dir, rel_dir, filename)
 
-            # Frontmatter — free-form scalars use json.dumps() for safe YAML quoting.
-            fm_lines = ["---"]
-            fm_lines.append(f"log_id: {json.dumps(session_id, ensure_ascii=False)}")
-            fm_lines.append("log_type: cli_agent")
-            fm_lines.append(f"title: {json.dumps(title, ensure_ascii=False)}")
-            fm_lines.append(f"created_at: {datetime.fromtimestamp(created_ms / 1000).isoformat()}")
-            fm_lines.append(f"workspace: {ws_slug_cli}")
-            fm_lines.append(f"workspace_name: {json.dumps(ws_name, ensure_ascii=False)}")
-            if cp.get("workspace_path"):
-                fm_lines.append(f"workspace_path: {json.dumps(cp['workspace_path'], ensure_ascii=False)}")
-            fm_lines.append(f"project_id: {json.dumps(cp['project_id'], ensure_ascii=False)}")
-            fm_lines.append(f"session_id: {json.dumps(session_id, ensure_ascii=False)}")
-            if meta.get("mode"):
-                fm_lines.append(f"mode: {json.dumps(meta['mode'], ensure_ascii=False)}")
-            fm_lines.append(f"message_count: {len(bubbles)}")
-            if total_tool_calls:
-                fm_lines.append(f"total_tool_calls: {total_tool_calls}")
-            if tool_breakdown:
-                fm_lines.append("tool_call_breakdown:")
-                for tn, cnt in sorted(tool_breakdown.items(), key=lambda x: -x[1]):
-                    fm_lines.append(f"  {json.dumps(tn, ensure_ascii=False)}: {cnt}")
-            fm_lines.append("---")
-            fm_str = "\n".join(fm_lines) + "\n\n"
-
-            # Header
-            header_meta = [f"Created: {datetime.fromtimestamp(created_ms / 1000).strftime('%Y-%m-%d %H:%M:%S')}"]
-            if meta.get("mode"):
-                header_meta.append(f"Mode: {meta['mode']}")
-            if total_tool_calls:
-                header_meta.append(f"Tool calls: {total_tool_calls}")
-            header = f"# {title}\n\n_{' | '.join(header_meta)}_\n\n---\n\n"
-
-            # Body
-            body = ""
-            for b in bubbles:
-                role_label = "User" if b["type"] == "user" else "Assistant"
-                body += f"### {role_label}\n\n"
-                body += b.get("text", "") + "\n\n"
-                tool_calls = (b.get("metadata") or {}).get("toolCalls") or []
-                for tc in tool_calls:
-                    summary = tc.get("summary") or tc.get("name") or "unknown"
-                    body += f"> **Tool: {summary}**\n"
-                    if tc.get("input"):
-                        body += "> **INPUT:**\n> ```\n"
-                        for iline in str(tc["input"]).split("\n"):
-                            body += f"> {iline}\n"
-                        body += "> ```\n"
-                    body += "\n"
-                body += "---\n\n"
-
-            md = fm_str + header + body
+            # Delegate Markdown generation to the shared exporter.
+            md = cursor_cli_session_to_markdown(
+                session["db_path"],
+                session_meta=meta,
+                workspace_info={
+                    "workspace": ws_slug_cli,
+                    "workspace_name": ws_name,
+                    "workspace_path": cp.get("workspace_path"),
+                    "project_id": cp["project_id"],
+                },
+                bubbles=bubbles,
+                title_override=title,
+            )
             rel_path = os.path.join(today, ws_slug_cli, "cli", filename)
             exported.append({
                 "id": session_id,

tests/test_cli_chat_reader.py

@@ -474,12 +474,15 @@ def test_sessions_grouped_by_project(self):
         self.assertIn("proj1", ids)
         self.assertIn("proj2", ids)
 
-    def test_last_updated_ms_uses_max_created_at(self):
+    def test_last_updated_ms_is_at_least_max_created_at(self):
+        # last_updated_ms = max(createdAt, store.db mtime) across all sessions.
+        # Since test files are freshly created, mtime >= createdAt always; we only
+        # assert the floor: the value must be >= max(createdAt) and > 0.
         self._make_session("proj1", "sess1", {"createdAt": 1000})
         self._make_session("proj1", "sess2", {"createdAt": 5000})
         projects = list_cli_projects(self.chats_dir)
         proj = next(p for p in projects if p["project_id"] == "proj1")
-        self.assertEqual(proj["last_updated_ms"], 5000)
+        self.assertGreaterEqual(proj["last_updated_ms"], 5000)
 
     def test_workspace_name_extracted_from_user_info(self):
         ws_path = "/home/user/my-project"

utils/cli_chat_reader.py

@@ -219,24 +219,43 @@ def messages_to_bubbles(messages: list[dict], created_at_ms: int) -> list[dict]:
     - ``user`` messages: strip ``<user_info>`` preamble, keep query text.
     - ``assistant`` messages with text parts → ``type: "ai"`` bubble.
     - ``assistant`` messages with ``tool-call`` parts → ``type: "ai"`` bubble
-      with ``metadata.toolCalls``.
-    - ``tool`` (result) messages are skipped; their content is not separately
-      surfaced (tool call IDs link them to the preceding assistant bubble).
+      with ``metadata.toolCalls``.  The ``output`` field of each tool call is
+      populated from the corresponding ``role: "tool"`` result message (matched
+      by ``toolCallId``).
+    - ``tool`` (result) messages are used only to populate tool-call outputs;
+      they are not emitted as separate bubbles.
 
     Per-message timestamps are unavailable in CLI sessions; ``created_at_ms``
     is used for all bubbles with a 1 ms sequence offset so UI sorting is stable.
     """
+    # Pre-scan: build toolCallId → output text map from role=="tool" messages.
+    tool_outputs: dict[str, str] = {}
+    for msg in messages:
+        if msg.get("role") != "tool":
+            continue
+        content = msg.get("content", "")
+        if isinstance(content, list):
+            for part in content:
+                if not isinstance(part, dict):
+                    continue
+                if part.get("type") == "tool-result":
+                    tid = part.get("toolCallId", "")
+                    result = part.get("result", "")
+                    if tid:
+                        tool_outputs[tid] = str(result) if result else ""
+        elif isinstance(content, str) and content:
+            # Plain string result with no toolCallId — store under empty key
+            # only if not already set, to avoid clobbering a keyed entry.
+            tool_outputs.setdefault("", content)
+
     bubbles: list[dict] = []
     seq = 0
 
     for msg in messages:
         role = msg.get("role", "")
         content = msg.get("content", "")
 
-        if role == "system":
-            continue
-
-        if role == "tool":
+        if role in ("system", "tool"):
             continue
 
         ts = created_at_ms + seq
@@ -266,6 +285,7 @@ def messages_to_bubbles(messages: list[dict], created_at_ms: int) -> list[dict]:
                 for tc in tool_calls:
                     args = tc.get("args", {})
                     name = tc.get("name", "unknown")
+                    tid = tc.get("toolCallId", "")
                     # Build a human-readable summary
                     if name in ("Glob", "glob_file_search"):
                         pattern = args.get("glob_pattern") or args.get("pattern") or ""
@@ -299,8 +319,8 @@ def messages_to_bubbles(messages: list[dict], created_at_ms: int) -> list[dict]:
                         "status": "",
                         "summary": summary,
                         "input": input_display,
-                        "output": "",
-                        "toolCallId": tc.get("toolCallId", ""),
+                        "output": tool_outputs.get(tid, ""),
+                        "toolCallId": tid,
                     })
                 if not text.strip():
                     tc0 = formatted_calls[0]
@@ -371,8 +391,13 @@ def list_cli_projects(chats_path: str) -> list[dict]:
         projects[pid]["sessions"].append(session)
 
         created = session["meta"].get("createdAt") or 0
-        if created > projects[pid]["last_updated_ms"]:
-            projects[pid]["last_updated_ms"] = created
+        try:
+            mtime_ms = int(os.path.getmtime(session["db_path"]) * 1000)
+        except OSError:
+            mtime_ms = 0
+        session_ts = max(created, mtime_ms)
+        if session_ts > projects[pid]["last_updated_ms"]:
+            projects[pid]["last_updated_ms"] = session_ts
 
     # Resolve workspace path / name from a session's messages
     for pid, proj in projects.items():

utils/cursor_md_exporter.py

@@ -2,16 +2,16 @@
 
 Exposes ``cursor_cli_session_to_markdown`` — a reusable function that
 generates a complete Markdown document (YAML frontmatter + body) from a
-Cursor CLI ``store.db`` session.  The logic is extracted from
-``scripts/export.py`` so it can be called programmatically without running
-the full export CLI.
+Cursor CLI ``store.db`` session.  The logic is shared between
+``scripts/export.py`` and any programmatic caller.
 """
 
 from __future__ import annotations
 
 import json
 from datetime import datetime
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from utils.cli_chat_reader import traverse_blobs, messages_to_bubbles
 
@@ -28,6 +28,9 @@ def _slug(s: str) -> str:
 def cursor_cli_session_to_markdown(
     db_path: str | Path,
     session_meta: dict | None = None,
+    workspace_info: dict | None = None,
+    bubbles: list[dict] | None = None,
+    title_override: str | None = None,
 ) -> str:
     """Generate a complete Markdown document from a Cursor CLI store.db session.
 
@@ -39,11 +42,28 @@ def cursor_cli_session_to_markdown(
         Optional dict with pre-read session metadata (keys: ``agentId``,
         ``createdAt``, ``name``, ``mode``).  If omitted, metadata is read
         from ``db_path`` automatically.
+    workspace_info:
+        Optional dict with workspace-level fields to include in frontmatter.
+        Recognised keys: ``workspace`` (slug), ``workspace_name``,
+        ``workspace_path``, ``project_id``.
+    bubbles:
+        Pre-computed bubble list from ``messages_to_bubbles()``.  When
+        provided the database is not re-read, avoiding a redundant SQL query.
+    title_override:
+        Caller-supplied title (e.g. already derived for a filename).  When
+        set, skips the first-user-message derivation heuristic.
 
     Returns
     -------
     str
         Full Markdown text including YAML frontmatter and conversation body.
+
+    Raises
+    ------
+    Exception
+        Re-raises any exception from ``traverse_blobs`` / ``messages_to_bubbles``
+        so callers can detect unreadable databases rather than silently receiving
+        an empty document.
     """
     db_path = Path(db_path)
 
@@ -63,15 +83,14 @@ def cursor_cli_session_to_markdown(
     session_name: str = session_meta.get("name") or f"Session {session_id[:8]}"
     mode: str = session_meta.get("mode", "")
 
-    # Reconstruct conversation.
-    try:
+    # Reconstruct conversation — callers may pass pre-computed bubbles to
+    # avoid a redundant DB read.  Errors propagate; caller decides how to handle.
+    if bubbles is None:
         messages = traverse_blobs(str(db_path))
         bubbles = messages_to_bubbles(messages, created_ms)
-    except Exception:
-        bubbles = []
 
     # Derive title.
-    title = session_name
+    title = title_override or session_name
     if not title or title.startswith("New Agent"):
         for b in bubbles:
             if b["type"] == "user" and b.get("text"):
@@ -102,6 +121,16 @@ def cursor_cli_session_to_markdown(
     fm_lines.append(
         f"created_at: {datetime.fromtimestamp(created_ms / 1000).isoformat()}"
     )
+    # Workspace-level fields (only when caller provides them).
+    ws_info = workspace_info or {}
+    if ws_info.get("workspace"):
+        fm_lines.append(f"workspace: {ws_info['workspace']}")
+    if ws_info.get("workspace_name"):
+        fm_lines.append(f"workspace_name: {json.dumps(ws_info['workspace_name'], ensure_ascii=False)}")
+    if ws_info.get("workspace_path"):
+        fm_lines.append(f"workspace_path: {json.dumps(ws_info['workspace_path'], ensure_ascii=False)}")
+    if ws_info.get("project_id"):
+        fm_lines.append(f"project_id: {json.dumps(ws_info['project_id'], ensure_ascii=False)}")
     fm_lines.append(f"session_id: {json.dumps(session_id, ensure_ascii=False)}")
     if mode:
         fm_lines.append(f"mode: {json.dumps(mode, ensure_ascii=False)}")
@@ -140,6 +169,11 @@ def cursor_cli_session_to_markdown(
                 for iline in str(tc["input"]).split("\n"):
                     body += f"> {iline}\n"
                 body += "> ```\n"
+            if tc.get("output"):
+                body += "> **OUTPUT:**\n> ```\n"
+                for oline in str(tc["output"]).split("\n"):
+                    body += f"> {oline}\n"
+                body += "> ```\n"
             body += "\n"
         body += "---\n\n"