Add last user message timestamp to search results

Author: in-asanz

README.md

@@ -39,6 +39,7 @@ By default, text output includes only:
 
 - `Nombre`
 - `Fecha`
+- `Ultimo mensaje usuario`
 - `Descripcion`
 
 Use `--verbose` to include local paths, scores, and match reasons.

SKILL.md

@@ -21,6 +21,7 @@ The bundled script is offline-only and should not send conversation contents out
 6. Return the best matches in a simple format with:
    - conversation name
    - date and time
+   - date and time of the last user message
    - short description
 
 ## Ask Only When Needed
@@ -41,6 +42,7 @@ For each candidate, provide:
 
 - `Nombre`
 - `Fecha`
+- `Ultimo mensaje usuario`
 - `Descripcion`
 
 Include the local file path only when it materially helps disambiguate or when the user asks for it.

scripts/find_codex_conversations.py

@@ -25,12 +25,19 @@ class SearchResult:
     session_id: str
     thread_name: str
     updated_at: str
+    last_user_message_at: str
     description: str
     session_path: str
     score: int
     reasons: list[str]
 
 
+@dataclass
+class UserMessage:
+    text: str
+    timestamp: str
+
+
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description="Search local Codex conversations under ~/.codex."
@@ -207,8 +214,18 @@ def merge_index_and_session_files(entries: list[SessionIndexEntry], session_path
     return merged
 
 
-def extract_user_messages(session_path: Path) -> list[str]:
-    messages: list[str] = []
+def extract_event_timestamp(event: dict[str, object], payload: dict[str, object]) -> str:
+    timestamp = (
+        event.get("timestamp")
+        or payload.get("timestamp")
+        or event.get("created_at")
+        or payload.get("created_at")
+    )
+    return str(timestamp).strip() if timestamp else ""
+
+
+def extract_user_messages(session_path: Path) -> list[UserMessage]:
+    messages: list[UserMessage] = []
     try:
         with session_path.open("r", encoding="utf-8") as handle:
             for line in handle:
@@ -224,7 +241,9 @@ def extract_user_messages(session_path: Path) -> list[str]:
                 if event_type == "event_msg" and payload.get("type") in USER_MESSAGE_TYPES:
                     text = payload.get("message", "").strip()
                     if text:
-                        messages.append(text)
+                        messages.append(
+                            UserMessage(text=text, timestamp=extract_event_timestamp(event, payload))
+                        )
                         continue
                 if event_type == "response_item" and payload.get("type") == "message" and payload.get("role") == "user":
                     contents = payload.get("content", [])
@@ -235,7 +254,12 @@ def extract_user_messages(session_path: Path) -> list[str]:
                             if text:
                                 text_parts.append(text)
                     if text_parts:
-                        messages.append(" ".join(text_parts))
+                        messages.append(
+                            UserMessage(
+                                text=" ".join(text_parts),
+                                timestamp=extract_event_timestamp(event, payload),
+                            )
+                        )
     except OSError:
         return []
     return messages
@@ -281,14 +305,14 @@ def is_noise_line(line: str) -> bool:
     return False
 
 
-def extract_description(messages: list[str], fallback: str) -> str:
+def extract_description(messages: list[UserMessage], fallback: str) -> str:
     for message in messages:
-        if "AGENTS.md instructions for" in message and "## My request for Codex:" not in message:
+        if "AGENTS.md instructions for" in message.text and "## My request for Codex:" not in message.text:
             continue
-        candidates = [message]
+        candidates = [message.text]
         marker = "## My request for Codex:"
-        if marker in message:
-            candidates.insert(0, message.split(marker, 1)[1])
+        if marker in message.text:
+            candidates.insert(0, message.text.split(marker, 1)[1])
         for candidate_block in candidates:
             for line in candidate_block.splitlines():
                 if is_noise_line(line):
@@ -327,7 +351,8 @@ def score_entry(
     score = 0
     reasons: list[str] = []
     description = ""
-    messages: list[str] = []
+    messages: list[UserMessage] = []
+    last_user_message_at = ""
 
     if exact_date and entry.updated_at.startswith(exact_date.strftime("%Y-%m-%d")):
         score += 25
@@ -343,11 +368,17 @@ def score_entry(
         messages = extract_user_messages(session_path)
         if messages:
             description = extract_description(messages, entry.thread_name)
+            last_user_message_at = messages[-1].timestamp
             for idx, message in enumerate(messages[:6]):
                 for query in queries:
                     exact_weight = 45 if idx == 0 else 20
                     token_weight = 8 if idx == 0 else 4
-                    query_score, query_reasons = score_text_match(query, message, exact_weight=exact_weight, token_weight=token_weight)
+                    query_score, query_reasons = score_text_match(
+                        query,
+                        message.text,
+                        exact_weight=exact_weight,
+                        token_weight=token_weight,
+                    )
                     score += query_score
                     prefix = "first-user" if idx == 0 else "user"
                     reasons.extend([f"{prefix}:{reason}" for reason in query_reasons])
@@ -359,6 +390,7 @@ def score_entry(
         session_id=entry.session_id,
         thread_name=entry.thread_name or "Sin nombre",
         updated_at=entry.updated_at,
+        last_user_message_at=last_user_message_at,
         description=description,
         session_path=str(session_path) if session_path else "",
         score=score,
@@ -385,6 +417,7 @@ def render_text(results: list[SearchResult], verbose: bool = False) -> str:
         lines = [
             f"Nombre: {result.thread_name}",
             f"Fecha: {result.updated_at or 'Unknown'}",
+            f"Ultimo mensaje usuario: {result.last_user_message_at or 'Unknown'}",
             f"Descripcion: {result.description}",
         ]
         if verbose:
@@ -405,6 +438,7 @@ def render_json(results: list[SearchResult], verbose: bool = False) -> str:
         item: dict[str, object] = {
             "thread_name": result.thread_name,
             "updated_at": result.updated_at,
+            "last_user_message_at": result.last_user_message_at,
             "description": result.description,
         }
         if verbose:

tests/test_find_codex_conversations.py

@@ -53,6 +53,7 @@ def test_query_matches_accents_in_title_and_messages(self) -> None:
                     },
                     {
                         "type": "event_msg",
+                        "timestamp": "2026-04-21T08:35:00Z",
                         "payload": {"type": "user_message", "message": "Necesito reescalar imagenes RAW."},
                     },
                 ],
@@ -62,6 +63,7 @@ def test_query_matches_accents_in_title_and_messages(self) -> None:
 
             self.assertEqual(result.returncode, 0, result.stderr)
             payload = json.loads(result.stdout)
+            self.assertEqual(payload[0]["last_user_message_at"], "2026-04-21T08:35:00Z")
             self.assertEqual(payload[0]["thread_name"], "Reescalar imágenes RAW")
 
     def test_default_text_hides_path_score_and_reasons(self) -> None:
@@ -77,6 +79,7 @@ def test_default_text_hides_path_score_and_reasons(self) -> None:
             self.assertEqual(result.returncode, 0, result.stderr)
             self.assertIn("Nombre:", result.stdout)
             self.assertIn("Fecha:", result.stdout)
+            self.assertIn("Ultimo mensaje usuario:", result.stdout)
             self.assertIn("Descripcion:", result.stdout)
             self.assertNotIn("Path:", result.stdout)
             self.assertNotIn("Score:", result.stdout)
@@ -126,6 +129,7 @@ def test_missing_index_discovers_sessions_by_metadata(self) -> None:
                         "payload": {
                             "type": "message",
                             "role": "user",
+                            "timestamp": "2026-04-24T09:15:00Z",
                             "content": [{"type": "input_text", "text": "Migrate the assembly workflow."}],
                         },
                     },
@@ -137,6 +141,7 @@ def test_missing_index_discovers_sessions_by_metadata(self) -> None:
 
             self.assertEqual(result.returncode, 0, result.stderr)
             payload = json.loads(result.stdout)
+            self.assertEqual(payload[0]["last_user_message_at"], "2026-04-24T09:15:00Z")
             self.assertEqual(payload[0]["thread_name"], "Assembly migration")
             self.assertNotIn("session_path", payload[0])
 
@@ -153,6 +158,7 @@ def test_indexed_session_path_can_match_arbitrary_id_in_filename(self) -> None:
                 [
                     {
                         "type": "event_msg",
+                        "timestamp": "2026-04-25T12:05:00Z",
                         "payload": {"type": "user_message", "message": "Find this arbitrary identifier session."},
                     }
                 ],
@@ -165,6 +171,48 @@ def test_indexed_session_path_can_match_arbitrary_id_in_filename(self) -> None:
             self.assertEqual(len(payload), 1)
             self.assertEqual(payload[0]["thread_name"], "Indexed fallback")
 
+    def test_last_user_message_timestamp_uses_latest_user_message(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            write_jsonl(
+                root / "sessions" / "2026" / "04" / "26" / "latest-user-message.jsonl",
+                [
+                    {
+                        "type": "session_meta",
+                        "payload": {
+                            "id": "latest-user-message",
+                            "thread_name": "Latest user timestamp",
+                            "updated_at": "2026-04-26T09:00:00Z",
+                        },
+                    },
+                    {
+                        "type": "event_msg",
+                        "timestamp": "2026-04-26T09:05:00Z",
+                        "payload": {"type": "user_message", "message": "First timestamp check."},
+                    },
+                    {
+                        "type": "event_msg",
+                        "timestamp": "2026-04-26T09:10:00Z",
+                        "payload": {"type": "agent_message", "message": "Intermediate answer."},
+                    },
+                    {
+                        "type": "response_item",
+                        "timestamp": "2026-04-26T09:15:00Z",
+                        "payload": {
+                            "type": "message",
+                            "role": "user",
+                            "content": [{"type": "input_text", "text": "Second timestamp check."}],
+                        },
+                    },
+                ],
+            )
+
+            result = self.run_cli(root, "--query", "timestamp", "--json")
+
+            self.assertEqual(result.returncode, 0, result.stderr)
+            payload = json.loads(result.stdout)
+            self.assertEqual(payload[0]["last_user_message_at"], "2026-04-26T09:15:00Z")
+
     def test_archived_sessions_are_searched(self) -> None:
         with tempfile.TemporaryDirectory() as temp_dir:
             root = Path(temp_dir)