fix: filename timestamp, slug cap, tool content, and capping in exports (Closes #12)

- Add session timestamp prefix to exported filenames (YYYY-MM-DDTHH-MM-SS__)
- Remove 60-char cap on title slugs in bulk and single-session export paths
- Preserve file read content, glob filename lists, and grep match content
  from tool results in jsonl_parser.py (previously silently discarded)
- Remove all content caps in md_exporter.py: Files Touched list (was 20),
  Commands Run list (was 30, strings capped at 120), URLs Accessed list
  (was 15, strings capped at 150), bash stdout (was 2000), stderr (was 1000),
  Write content (was 500), Edit old/new (was 300), Task prompts (was 500),
  generic tool inputs (was 500), generic tool result (was 2000)
- Fix timestamp format: now renders as YYYY-MM-DD HH:MM:SS.mmm UTC instead
  of stripping timezone and sub-second precision
- Include total_cache_creation_tokens in frontmatter when non-zero

Made-with: Cursor

Author: wpak-ai

scripts/export.py

@@ -370,21 +370,22 @@ def cmd_export(args):
                 )
                 meta["first_timestamp"] = ts
             date_str = ts[:10]
-            title_slug = _slugify(session["title"])[:60]
+            ts_file = ts[:19].replace(":", "-")   # 2026-02-10T01-46-15
+            title_slug = _slugify(session["title"])
             short_id = sid[:8]
             project_slug = _slugify(project["name"])
 
             if fmt in ("md", "both"):
                 md = session_to_markdown(session, stats)
                 rel_path = os.path.join(
-                    date_str, project_slug, f"{title_slug}__{short_id}.md"
+                    date_str, project_slug, f"{ts_file}__{title_slug}__{short_id}.md"
                 )
                 all_exports.append((rel_path, md))
 
             if fmt in ("json", "both"):
                 js = session_to_json(session, stats)
                 rel_path = os.path.join(
-                    date_str, project_slug, f"{title_slug}__{short_id}.json"
+                    date_str, project_slug, f"{ts_file}__{title_slug}__{short_id}.json"
                 )
                 all_exports.append((rel_path, js))
 
@@ -448,16 +449,18 @@ def cmd_export(args):
 
 def _export_single(session: dict, stats: dict, fmt: str, out_dir: str):
     """Write one session to disk as md, json, or both."""
-    title_slug = _slugify(session["title"])[:60]
+    title_slug = _slugify(session["title"])
     short_id = session["session_id"][:8]
+    ts = session["metadata"].get("first_timestamp", "")
+    ts_file = ts[:19].replace(":", "-") if ts else "0000-00-00T00-00-00"
 
     files = []
     if fmt in ("md", "both"):
         md = session_to_markdown(session, stats)
-        files.append((f"{title_slug}__{short_id}.md", md))
+        files.append((f"{ts_file}__{title_slug}__{short_id}.md", md))
     if fmt in ("json", "both"):
         js = session_to_json(session, stats)
-        files.append((f"{title_slug}__{short_id}.json", js))
+        files.append((f"{ts_file}__{title_slug}__{short_id}.json", js))
 
     os.makedirs(out_dir, exist_ok=True)
     for fname, content in files:

utils/jsonl_parser.py

@@ -363,9 +363,11 @@ def _parse_tool_result(tool_result, slug: str = None) -> dict | None:
         tool_result.get("filenames"), list
     ):
         result["result_type"] = "glob"
-        result["num_files"] = tool_result.get("numFiles", len(tool_result["filenames"]))
+        filenames = tool_result["filenames"]
+        result["num_files"] = tool_result.get("numFiles", len(filenames))
         result["truncated"] = tool_result.get("truncated", False)
         result["duration_ms"] = tool_result.get("durationMs")
+        result["filenames"] = filenames
         return result
 
     # Grep results: have mode + numFiles/numLines
@@ -375,13 +377,20 @@ def _parse_tool_result(tool_result, slug: str = None) -> dict | None:
         result["num_files"] = tool_result.get("numFiles", 0)
         result["num_lines"] = tool_result.get("numLines", 0)
         result["duration_ms"] = tool_result.get("durationMs")
+        content = tool_result.get("content", "")
+        if content and isinstance(content, str):
+            result["content"] = content
         return result
 
     # Read result: have file dict with content
     if "file" in tool_result and isinstance(tool_result["file"], dict):
+        file_obj = tool_result["file"]
         result["result_type"] = "file_read"
-        result["file_path"] = tool_result["file"].get("filePath", "")
-        result["num_lines"] = tool_result["file"].get("numLines")
+        result["file_path"] = file_obj.get("filePath", "")
+        result["num_lines"] = file_obj.get("numLines")
+        content = file_obj.get("content", "")
+        if content and isinstance(content, str):
+            result["content"] = content
         return result
 
     # WebSearch results

utils/md_exporter.py

@@ -32,6 +32,8 @@ def _build_frontmatter(session: dict) -> str:
     lines.append(f"total_input_tokens: {meta['total_input_tokens']}")
     lines.append(f"total_output_tokens: {meta['total_output_tokens']}")
     lines.append(f"total_cache_read_tokens: {meta['total_cache_read_tokens']}")
+    if meta.get("total_cache_creation_tokens", 0) > 0:
+        lines.append(f"total_cache_creation_tokens: {meta['total_cache_creation_tokens']}")
     lines.append(f"total_tool_calls: {meta['total_tool_calls']}")
     if meta["tool_call_counts"]:
         lines.append("tool_call_breakdown:")
@@ -129,20 +131,18 @@ def _build_summary(session: dict, stats: dict) -> str:
         lines.append("| Action | File |")
         lines.append("|--------|------|")
         for fp in created_files:
-            lines.append(f"| Create | `{_truncate(fp, 100)}` |")
+            lines.append(f"| Create | `{fp}` |")
         for fp in written_files:
-            lines.append(f"| Edit | `{_truncate(fp, 100)}` |")
-        for fp in read_files[:20]:
-            lines.append(f"| Read | `{_truncate(fp, 100)}` |")
-        if len(read_files) > 20:
-            lines.append(f"| Read | _...and {len(read_files) - 20} more_ |")
+            lines.append(f"| Edit | `{fp}` |")
+        for fp in read_files:
+            lines.append(f"| Read | `{fp}` |")
         lines.append("")
 
     # Commands run
     commands = stats.get("commands_run", [])
     if commands:
         lines.append("### Commands Run\n")
-        for i, cmd in enumerate(commands[:30], 1):
+        for i, cmd in enumerate(commands, 1):
             status = ""
             if cmd.get("is_error"):
                 status = " -- **error**"
@@ -152,19 +152,15 @@ def _build_summary(session: dict, stats: dict) -> str:
                 status = " -- success"
             elif cmd.get("return_code_interpretation"):
                 status = f" -- {cmd['return_code_interpretation']}"
-            lines.append(f"{i}. `{_truncate(cmd['command'], 120)}`{status}")
-        if len(commands) > 30:
-            lines.append(f"\n_...and {len(commands) - 30} more commands_")
+            lines.append(f"{i}. `{cmd['command']}`{status}")
         lines.append("")
 
     # URLs accessed
     urls = stats.get("urls_accessed", [])
     if urls:
         lines.append("### URLs Accessed\n")
-        for url in urls[:15]:
-            lines.append(f"- `{_truncate(url, 150)}`")
-        if len(urls) > 15:
-            lines.append(f"- _...and {len(urls) - 15} more_")
+        for url in urls:
+            lines.append(f"- `{url}`")
         lines.append("")
 
     # Tool result summary
@@ -221,7 +217,7 @@ def _render_user(msg: dict) -> str:
         tr = msg["tool_result"]
         if isinstance(tr, dict):
             lines.append("\n**Tool Result:**")
-            lines.append(f"```\n{_truncate(str(tr), 2000)}\n```")
+            lines.append(f"```\n{str(tr)}\n```")
 
     lines.append("\n---\n")
     return "\n".join(lines)
@@ -281,16 +277,16 @@ def _render_tool_use(tool: dict) -> str:
         fp = inp.get("file_path", "")
         content = inp.get("content", "")
         lines.append(f">\n> File: `{fp}`")
-        lines.append(f">\n> ```\n> {_truncate(content, 500)}\n> ```")
+        lines.append(f">\n> ```\n> {content}\n> ```")
     elif name == "Edit":
         fp = inp.get("file_path", "")
         old = inp.get("old_string", "")
         new = inp.get("new_string", "")
         lines.append(f">\n> File: `{fp}`")
         if old:
-            lines.append(f">\n> Old:\n> ```\n> {_truncate(old, 300)}\n> ```")
+            lines.append(f">\n> Old:\n> ```\n> {old}\n> ```")
         if new:
-            lines.append(f">\n> New:\n> ```\n> {_truncate(new, 300)}\n> ```")
+            lines.append(f">\n> New:\n> ```\n> {new}\n> ```")
     elif name == "Glob":
         lines.append(f">\n> Pattern: `{inp.get('pattern', '')}`")
         if inp.get("path"):
@@ -305,7 +301,7 @@ def _render_tool_use(tool: dict) -> str:
         lines.append(f">\n> Description: {inp.get('description', '')}")
         lines.append(f"> Agent: {inp.get('subagent_type', '')}")
         if inp.get("prompt"):
-            lines.append(f">\n> **Prompt:**\n> ```\n> {_truncate(inp['prompt'], 500)}\n> ```")
+            lines.append(f">\n> **Prompt:**\n> ```\n> {inp['prompt']}\n> ```")
     elif name == "TodoWrite":
         todos = inp.get("todos", [])
         for t in todos:
@@ -319,10 +315,7 @@ def _render_tool_use(tool: dict) -> str:
         for q in questions:
             lines.append(f">\n> Q: {q.get('question', '')}")
     else:
-        inp_str = str(inp)
-        if len(inp_str) > 500:
-            inp_str = inp_str[:500] + "..."
-        lines.append(f">\n> Input: `{inp_str}`")
+        lines.append(f">\n> Input: `{str(inp)}`")
 
     return "\n".join(lines)
 
@@ -346,15 +339,18 @@ def _render_tool_result(parsed: dict) -> str:
 
         lines.append(f"\n**Bash Result{status}:**")
         if stdout:
-            lines.append(f"```\n{_truncate(stdout, 2000)}\n```")
+            lines.append(f"```\n{stdout}\n```")
         if stderr:
-            lines.append(f"**stderr:**\n```\n{_truncate(stderr, 1000)}\n```")
+            lines.append(f"**stderr:**\n```\n{stderr}\n```")
 
     elif rt == "file_read":
         fp = parsed.get("file_path", "")
         num_lines = parsed.get("num_lines")
         detail = f" ({num_lines} lines)" if num_lines else ""
         lines.append(f"\n**Read:** `{fp}`{detail}")
+        content = parsed.get("content", "")
+        if content:
+            lines.append(f"```\n{content}\n```")
 
     elif rt == "file_edit":
         fp = parsed.get("file_path", "")
@@ -368,11 +364,18 @@ def _render_tool_result(parsed: dict) -> str:
         n = parsed.get("num_files", 0)
         trunc = " (truncated)" if parsed.get("truncated") else ""
         lines.append(f"\n**Glob:** {n} files found{trunc}")
+        filenames = parsed.get("filenames", [])
+        if filenames:
+            for fn in filenames:
+                lines.append(f"- `{fn}`")
 
     elif rt == "grep":
         n = parsed.get("num_files", 0)
         nl = parsed.get("num_lines", 0)
         lines.append(f"\n**Grep:** {n} files, {nl} lines matched")
+        content = parsed.get("content", "")
+        if content:
+            lines.append(f"```\n{content}\n```")
 
     elif rt == "web_search":
         q = parsed.get("query", "")
@@ -434,10 +437,13 @@ def _render_system(msg: dict) -> str:
 
 
 def _format_ts(ts: str) -> str:
-    """2024-01-15T10:30:00Z -> 2024-01-15 10:30:00"""
+    """2024-01-15T10:30:00.123Z -> 2024-01-15 10:30:00.123 UTC"""
     try:
         dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
-        return dt.strftime("%Y-%m-%d %H:%M:%S")
+        ms = dt.microsecond // 1000
+        if ms:
+            return dt.strftime(f"%Y-%m-%d %H:%M:%S.{ms:03d} UTC")
+        return dt.strftime("%Y-%m-%d %H:%M:%S UTC")
     except (ValueError, AttributeError):
         return ts