agentledger-cli 0.1.0__py3-none-any.whl

agentledger/__init__.py

@@ -0,0 +1,2 @@
+"""Report coding-agent sessions to the AgentLedger Snowflake Native App."""
+__version__ = "0.1.0"

agentledger/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

agentledger/agents/__init__.py

@@ -0,0 +1,8 @@
+"""The agents agentledger sets up. Each module names itself (ID, NAME) and can tell whether the
+agent is on this machine (detected), whether it's set up (hooked), and install / uninstall
+itself. Agents whose sessions are loaded from the machine also turn a hook call into a job
+(job), find their newest session (newest), and read a session into the app's shape (payload)."""
+from . import claude, cortex, cursor, gemini
+
+AGENTS = {agent.ID: agent for agent in (claude, cursor, gemini, cortex)}
+REPORTERS = {id: agent for id, agent in AGENTS.items() if hasattr(agent, "payload")}

agentledger/agents/claude.py

@@ -0,0 +1,258 @@
+"""Claude Code sessions, hooked from ~/.claude/settings.json (Stop and SessionEnd).
+
+The transcript is ~/.claude/projects/<project>/<session id>.jsonl. Claude Code writes each API
+response as several lines (thinking, text, tool calls) sharing one message id, with the final
+usage on the last of them; each response becomes one of the app's model calls, with its model,
+token counts and timing. A prompt the developer typed starts a turn (step 0). Background-task
+notices and Claude Code's own meta messages continue the current turn, and local slash commands
+and interrupts are left out. Tool calls keep their arguments and results (clipped); names are
+mapped to the ones the trace's file cards understand, Read results are renumbered in Cortex
+Code's "12... text" form, and Edit results get the "Edit location" line Cortex Code's carry.
+Thinking is not loaded, and <system-reminder> blocks and client harness context (T3 Code's
+attachment notes) are removed from prompts. The session is attributed to the git repository its
+tool calls touched most, else each prompt to the folder it ran in.
+"""
+import json
+import os
+import re
+from collections import OrderedDict
+from datetime import datetime
+from pathlib import Path
+
+from .. import hooks
+from ..repo import PATH_ARGS, repo_of_paths, repo_state, toplevel
+from ..trace import RESULT_CHARS, clip, clip_args, request
+
+ID, NAME = "claude", "Claude Code"
+HOME = Path(os.environ.get("CLAUDE_CONFIG_DIR") or Path.home() / ".claude").expanduser()
+SETTINGS = HOME / "settings.json"
+PROJECTS = HOME / "projects"
+EVENTS = ("Stop", "SessionEnd")
+
+TOOL_NAMES = {"Read": "read", "Edit": "edit", "Write": "write", "Bash": "bash", "Grep": "grep", "Glob": "glob",
+              "Skill": "skill", "Agent": "task", "Task": "task", "WebFetch": "web_fetch", "WebSearch": "web_search",
+              "AskUserQuestion": "ask_user_question", "NotebookEdit": "notebook_edit", "TodoWrite": "todo_write"}
+READ_LINES = 400
+REMINDER = re.compile(r"<system-reminder>.*?</system-reminder>\s*", re.S)
+# Context a client harness adds around the typed prompt (T3 Code's attachment metadata).
+HARNESS = re.compile(r"<t3_context\b.*?</t3_context>\s*|^\[Attached image .*? is saved at: .*?\]\s*$", re.S | re.M)
+CLAUDE_READ_LINE = re.compile(r"^\s*(\d+)\t(.*)$")
+# User messages that aren't prompts to the agent: local slash commands and their output, interrupts.
+NOT_PROMPTS = ("<command-name>", "<local-command-stdout>", "<local-command-caveat>", "[Request interrupted by user")
+
+
+def detected():
+    return HOME.is_dir()
+
+
+def hooked():
+    return hooks.present(SETTINGS, nested=True)
+
+
+def install(command, config):
+    if hooks.install(SETTINGS, EVENTS, command, nested=True):
+        return f"hook added to {SETTINGS}"
+    return None
+
+
+def uninstall(config):
+    return hooks.remove(SETTINGS, nested=True)
+
+
+def job(hook):
+    """The session a Stop / SessionEnd hook is about, or None."""
+    transcript = Path(hook.get("transcript_path") or "").expanduser().resolve()
+    if transcript.suffix != ".jsonl" or PROJECTS.resolve() not in transcript.parents or not transcript.is_file():
+        return None
+    cwd = hook.get("cwd") if isinstance(hook.get("cwd"), str) else None
+    return {"path": str(transcript), "label": transcript.stem, "folders": [cwd] if cwd else [], "folder": cwd}
+
+
+def newest():
+    return max(PROJECTS.glob("*/*.jsonl"), key=lambda p: p.stat().st_mtime, default=None)
+
+
+def _ts(value):
+    """Transcript timestamps (2026-10-09T00:50:29.548Z) as the naive UTC text Snowflake parses."""
+    return datetime.fromisoformat(value.replace("Z", "+00:00")).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
+
+def _text(content):
+    """Text of a message's content: a string, or its text blocks; images become "[image]" only when
+    there's no text (a prompt names its own attachments)."""
+    if isinstance(content, str):
+        return content
+    blocks = [b for b in content if isinstance(b, dict)] if isinstance(content, list) else []
+    texts = [b.get("text", "") for b in blocks if b.get("type") == "text"]
+    return "\n".join(texts) if any(t.strip() for t in texts) else "\n".join(
+        "[image]" for b in blocks if b.get("type") == "image")
+
+
+def prompt_of(entry):
+    """The prompt a user line carries, or None when it isn't one the developer typed."""
+    if entry.get("isMeta") or entry.get("turnOrigin") == "task_notification":
+        return None
+    content = entry["message"].get("content")
+    if isinstance(content, list) and any(isinstance(b, dict) and b.get("type") == "tool_result" for b in content):
+        return None
+    text = HARNESS.sub("", REMINDER.sub("", _text(content))).strip()
+    if not text or text.startswith(NOT_PROMPTS) or text.startswith("<task-notification>"):
+        return None
+    return text
+
+
+def edit_location(patch, old_string, new_string):
+    """Where an Edit's new text landed, from the structured patch Claude Code keeps beside the result,
+    in the words Cortex Code's edit results use ("Edit location: lines 12-16"), so the trace's diff
+    card can number its lines. None without a patch."""
+    old = (old_string or "").split("\n")
+    skip = next((i for i, line in enumerate(old) if line.strip()), 0)  # leading blank lines
+    for hunk in patch or []:
+        n = hunk.get("oldStart")
+        for line in hunk.get("lines") or []:
+            if line[:1] not in (" ", "-"):
+                continue
+            if n is not None and line[1:] == old[skip]:
+                start = n - skip
+                return f"Edit location: lines {start}-{start + max(len((new_string or '').split(chr(10))), 1) - 1}"
+            n = None if n is None else n + 1
+    return None
+
+
+def _result(name, block, tool_result=None, args=None):
+    text = _text(block.get("content"))
+    if name == "edit" and isinstance(tool_result, dict):
+        if where := edit_location(tool_result.get("structuredPatch"), (args or {}).get("old_string"),
+                                  (args or {}).get("new_string")):
+            text = f"{text}\n{where}"
+    if name == "read":
+        lines = text.splitlines()[:READ_LINES]
+        numbered = [CLAUDE_READ_LINE.match(line) for line in lines]
+        if numbered and all(numbered):
+            text = "\n".join(f"{m.group(1)}... {m.group(2)}" for m in numbered)
+    # The trace marks a tool call failed when its result reads as an error.
+    if block.get("is_error") and not text.lstrip().lower().startswith("error"):
+        text = "Error: " + text
+    return clip(text, RESULT_CHARS)
+
+
+def model_calls(entries):
+    """One dict per API response on the main thread, in order: prompt (for turn starts), step,
+    model, usage, response text, tool calls, start (when its input was sent) and end."""
+    calls = OrderedDict()
+    results = {}
+    last_input, step, pending_prompt = None, 0, None
+    for e in entries:
+        if e.get("isSidechain"):
+            continue
+        kind = e.get("type")
+        if kind == "user":
+            last_input = e["timestamp"]
+            content = e["message"].get("content")
+            for block in content if isinstance(content, list) else []:
+                if isinstance(block, dict) and block.get("type") == "tool_result":
+                    # Claude Code writes each result on its own line, with its details (an edit's
+                    # structured patch) in toolUseResult.
+                    results[block.get("tool_use_id")] = (block, e.get("toolUseResult"))
+            if (prompt := prompt_of(e)) is not None:
+                # Prompts sent before the agent answered (e.g. after an interrupt) open one turn together.
+                pending_prompt = prompt if pending_prompt is None else f"{pending_prompt}\n\n{prompt}"
+                step = 0
+        elif kind == "assistant":
+            m = e["message"]
+            if m.get("model") == "<synthetic>" or not m.get("id"):
+                continue
+            call = calls.get(m["id"])
+            if call is None:
+                call = calls[m["id"]] = {"prompt": pending_prompt, "step": step, "model": m.get("model"),
+                                         "start": last_input or e["timestamp"], "end": e["timestamp"],
+                                         "usage": {}, "texts": [], "tools": [], "error": e.get("isApiErrorMessage")}
+                pending_prompt, step = None, step + 1
+            call["end"] = e["timestamp"]
+            usage = m.get("usage") or {}
+            if (usage.get("output_tokens") or 0) >= (call["usage"].get("output_tokens") or 0):
+                call["usage"] = usage
+            for block in m.get("content") or []:
+                if block.get("type") == "text" and block.get("text", "").strip():
+                    call["texts"].append(block["text"].strip())
+                elif block.get("type") == "tool_use":
+                    name = block.get("name") or "tool"
+                    call["tools"].append({"id": block.get("id"), "name": TOOL_NAMES.get(name, name.lower()),
+                                          "args": clip_args(block.get("input"))})
+    for call in calls.values():
+        for tool in call["tools"]:
+            block = results.get(tool["id"])
+            tool["result"] = _result(tool["name"], block[0], block[1], tool["args"]) if block else None
+    return list(calls.values())
+
+
+def to_requests(calls, session_id):
+    requests = []
+    for i, call in enumerate(calls):
+        u = call["usage"]
+        cache_read, cache_write = u.get("cache_read_input_tokens") or 0, u.get("cache_creation_input_tokens") or 0
+        requests.append(request(
+            f"claude-{session_id[:8]}-{i}", call["step"], _ts(call["start"]), _ts(call["end"]),
+            call["prompt"] if call["step"] == 0 else None, "\n\n".join(call["texts"]) or None, call["tools"],
+            model=call["model"],
+            status="ERROR" if call["error"] else "SUCCESS",
+            # The app's input count includes cached input, as Snowflake's telemetry does.
+            input_tokens=(u.get("input_tokens") or 0) + cache_read + cache_write,
+            output_tokens=u.get("output_tokens") or 0,
+            cache_read_tokens=cache_read,
+            cache_write_tokens=cache_write))
+    return requests
+
+
+def git_reports(entries, repo_dir=None):
+    """One report per prompt, like the git hook's UserPromptSubmit: the git state of the folder the
+    prompt ran in (or of repo_dir), with the running prompt count. The branch is the one Claude Code
+    recorded with the prompt when it ran in that repository, so work on earlier branches keeps its
+    branch; the commit and dirty flag are known only for the branch checked out now."""
+    reports, states, tops = [], {}, {}
+    for e in entries:
+        if e.get("type") != "user" or e.get("isSidechain") or prompt_of(e) is None:
+            continue
+        folder = repo_dir or e.get("cwd")
+        if folder not in states:
+            states[folder] = repo_state(folder)
+        state = states[folder]
+        if not state:
+            continue
+        report = {"observed_at": _ts(e["timestamp"]), "prompt_seq": len(reports) + 1, **state}
+        cwd, recorded = e.get("cwd"), e.get("gitBranch")
+        if recorded and cwd:
+            for path in {cwd, folder}:
+                if path not in tops:
+                    tops[path] = toplevel(path)
+            if tops[cwd] and tops[cwd] == tops[folder]:
+                branch = None if recorded == "HEAD" else recorded
+                if branch != state["branch"]:
+                    report.update(branch=branch, head_sha=None, is_dirty=None)
+        reports.append(report)
+    return reports
+
+
+def payload(path, repo_dir=None, folder=None):
+    """The session for core.ingest_external_session. `repo_dir` pins its repository. Claude Code
+    records each prompt's folder itself, so `folder` isn't needed."""
+    entries = [json.loads(line) for line in Path(path).read_text().splitlines() if line.strip()]
+    entries = [e for e in entries if e.get("type") in ("user", "assistant") and e.get("timestamp")]
+    session_id = next(e["sessionId"] for e in entries if e.get("sessionId"))
+    calls = model_calls(entries)
+    models = [c["model"] for c in calls if c["model"]]
+    repo_dir = repo_dir or repo_of_paths(
+        (block.get("input") or {}).get(key)
+        for e in entries if e.get("type") == "assistant" and isinstance((e.get("message") or {}).get("content"), list)
+        for block in e["message"]["content"] if isinstance(block, dict) and block.get("type") == "tool_use"
+        for key in PATH_ARGS)
+    return {
+        "session_id": session_id,
+        "agent": "claude-code",
+        "agent_name": NAME,
+        "model": max(set(models), key=models.count) if models else None,
+        "started_at": _ts(entries[0]["timestamp"]),
+        "prompts": sum(1 for c in calls if c["step"] == 0 and c["prompt"]),
+        "git_reports": git_reports(entries, repo_dir),
+        "requests": to_requests(calls, session_id),
+    }

agentledger/agents/cortex.py

@@ -0,0 +1,42 @@
+"""Cortex Code. Its sessions reach the app through Snowflake's own telemetry; what it needs on the
+developer machine is the git hook plugin the app publishes as a Cortex Extension."""
+import re
+import shutil
+import subprocess
+
+ID, NAME = "cortex", "Cortex Code"
+PLUGIN = "agentledger"
+
+
+class SetupError(Exception):
+    pass
+
+
+def _plugin(*args):
+    return subprocess.run(["cortex", "plugin", *args], capture_output=True, text=True, timeout=180)
+
+
+def detected():
+    return shutil.which("cortex") is not None
+
+
+def hooked():
+    return bool(re.search(rf"^\s*{PLUGIN} v\S+ \[enabled", _plugin("list").stdout, re.M))
+
+
+def install(command, config):
+    if hooked():
+        return None
+    fqn = f"{config['app']}.PLUGINS.AGENTLEDGER"
+    out = _plugin("install", fqn, *(["-c", config["connection"]] if config["connection"] else []))
+    if out.returncode:
+        reason = (out.stderr or out.stdout).strip().splitlines()[-1:] or ["no output"]
+        raise SetupError(f"couldn't install the git plugin {fqn} ({reason[0]}). An app admin publishes it "
+                         "from the dashboard's Setup page, under Git integration.")
+    return f"git plugin {fqn} installed"
+
+
+def uninstall(config):
+    if not re.search(rf"^\s*{PLUGIN} v", _plugin("list").stdout, re.M):
+        return False
+    return _plugin("uninstall", PLUGIN).returncode == 0

agentledger/agents/cursor.py

@@ -0,0 +1,242 @@
+"""Cursor CLI sessions, hooked from ~/.cursor/hooks.json (stop and sessionEnd).
+
+The store is ~/.cursor/acp-sessions/<id>/store.db. Its ordered message list (user, assistant,
+tool) maps onto the app's model calls and tool calls. After compaction the live checkpoint
+only keeps a short tail, so the loader uses the fullest snapshot still in the file and appends
+the live continuation. The file has no token counts and no per-message clock, so tokens stay
+zero. Each turn starts at the time Cursor stamps on its prompt (to the minute) and each call
+two seconds after the previous one. Cursor's own user messages (workspace context, summaries
+after compaction) aren't prompts; a typed one comes wrapped in <user_query>. Tool names are
+renamed to the ones the trace's file cards understand (Read, StrReplace, Write). The session is
+attributed to the git repository its tool calls touched most, else to its workspace, and to the
+branches the repository's reflog shows checked out while it ran.
+"""
+import json
+import re
+import sqlite3
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from .. import hooks
+from ..repo import PATH_ARGS, git_reports, repo_of_paths
+from ..trace import RESULT_CHARS, clip, clip_args, request
+
+ID, NAME = "cursor", "Cursor CLI"
+HOME = Path.home() / ".cursor"
+HOOKS_FILE = HOME / "hooks.json"
+SESSIONS = HOME / "acp-sessions"
+EVENTS = ("stop", "sessionEnd")
+
+TOOL_NAMES = {"Read": "read", "StrReplace": "edit", "Write": "write"}
+ARG_RENAMES = {"path": "file_path", "contents": "content"}
+READ_LINES = 200
+# Cursor doesn't record the model in the store.
+MODEL = "grok-4.7"
+
+# "<timestamp>Sunday, Oct 11, 2026, 12:30 PM (UTC-5)</timestamp>" before each typed prompt.
+STAMP = re.compile(r"<timestamp>\s*(.+?)\s*\(UTC(?:([+-])(\d{1,2})(?::?(\d{2}))?)?\)\s*</timestamp>")
+
+
+def detected():
+    return HOME.is_dir()
+
+
+def hooked():
+    return hooks.present(HOOKS_FILE, nested=False)
+
+
+def install(command, config):
+    if hooks.install(HOOKS_FILE, EVENTS, command, nested=False):
+        return f"hook added to {HOOKS_FILE}"
+    return None
+
+
+def uninstall(config):
+    return hooks.remove(HOOKS_FILE, nested=False)
+
+
+def job(hook):
+    """The session a stop / sessionEnd hook is about, or None."""
+    session = hook.get("conversation_id") or hook.get("session_id") or ""
+    store = SESSIONS / session / "store.db"
+    if not re.fullmatch(r"[A-Za-z0-9_-]+", session) or not store.is_file():
+        return None
+    roots = [r for r in hook.get("workspace_roots") or [] if isinstance(r, str)]
+    return {"path": str(store), "label": session, "folders": roots, "folder": roots[0] if roots else None}
+
+
+def newest():
+    return max(SESSIONS.glob("*/store.db"), key=lambda p: p.stat().st_mtime, default=None)
+
+
+def _varint(buf, i):
+    n = shift = 0
+    while True:
+        b = buf[i]
+        i += 1
+        n |= (b & 0x7F) << shift
+        if not b & 0x80:
+            break
+        shift += 7
+    return n, i
+
+
+def message_hashes(root):
+    """Field 1 of a checkpoint blob: message hashes in conversation order."""
+    hashes, i = [], 0
+    while i < len(root) and root[i] == 0x0A:
+        i += 1
+        n, i = _varint(root, i)
+        chunk = root[i:i + n]
+        i += n
+        if n != 32:
+            break
+        hashes.append(chunk.hex())
+    return hashes
+
+
+def stitch(fullest, latest):
+    """Fullest snapshot plus whatever the live checkpoint added after their last shared message."""
+    if not latest:
+        return fullest
+    if not fullest:
+        return latest
+    seen = set(fullest)
+    shared = [i for i, h in enumerate(latest) if h in seen]
+    if not shared:
+        return latest
+    return fullest + [h for h in latest[shared[-1] + 1:] if h not in seen]
+
+
+def ordered_messages(db_path):
+    """Messages in conversation order.
+
+    The live root is a compacted checkpoint (a short tail). Older checkpoints in the same
+    file still hold the longer list, and the longest of those is a prefix of the next.
+    """
+    con = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    try:
+        blobs = {i: data for i, data in con.execute("SELECT id, data FROM blobs")}
+        raw = con.execute("SELECT value FROM meta").fetchone()[0]
+    finally:
+        con.close()
+    text = bytes.fromhex(raw.decode() if isinstance(raw, (bytes, bytearray)) else raw).decode()
+    meta = json.loads(text)
+    snapshots = [message_hashes(data) for data in blobs.values() if data[:2] == b"\x0a\x20"]
+    snapshots = [h for h in snapshots if h]
+    fullest = max(snapshots, key=len) if snapshots else []
+    latest = message_hashes(blobs[meta["latestRootBlobId"]]) if meta.get("latestRootBlobId") in blobs else []
+    messages = []
+    for h in stitch(fullest, latest):
+        data = blobs.get(h)
+        if data and data.startswith(b"{"):
+            messages.append(json.loads(data))
+    return meta, messages
+
+
+def _text(content):
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(c.get("text", "") for c in content if isinstance(c, dict) and c.get("type") == "text").strip()
+    return ""
+
+
+def is_prompt(text):
+    """True for a prompt the person typed. Cursor wraps those in <user_query>; its own messages
+    (<user_info>, <conversation_summary>, ...) start with a tag."""
+    return bool(text) and ("<user_query>" in text or not text.lstrip().startswith("<"))
+
+
+def sent_at(text):
+    """When a prompt was sent (UTC, naive), from Cursor's <timestamp>; None without one."""
+    m = STAMP.search(text or "")
+    if not m:
+        return None
+    try:
+        local = datetime.strptime(m[1], "%A, %b %d, %Y, %I:%M %p")
+    except ValueError:
+        return None
+    offset = timedelta(hours=int(m[3] or 0), minutes=int(m[4] or 0))
+    return local - offset if m[2] != "-" else local + offset
+
+
+def _result(name, args, result):
+    if isinstance(result, (dict, list)):
+        result = json.dumps(result)
+    result = "" if result is None else str(result)
+    if name == "read":
+        start = int(args.get("offset") or 1)
+        lines = result.splitlines()[:READ_LINES]
+        return "\n".join(f"{start + i}... {line}" for i, line in enumerate(lines))
+    return clip(result, RESULT_CHARS)
+
+
+def to_requests(messages, session_id, started, ended):
+    """One app model call per assistant message. A user message starts a turn (step 0)."""
+    calls = []
+    prompt, step, pending = None, 0, None
+    for message in messages:
+        role = message.get("role")
+        if role == "user":
+            if is_prompt(text := _text(message.get("content"))):
+                prompt, step = text, 0
+        elif role == "assistant":
+            content = message.get("content") if isinstance(message.get("content"), list) else []
+            tools = [{"id": c.get("toolCallId"), "args": clip_args(c.get("args"), ARG_RENAMES), "result": None,
+                      "name": TOOL_NAMES.get(c.get("toolName"), (c.get("toolName") or "tool").lower())}
+                     for c in content if isinstance(c, dict) and c.get("type") == "tool-call"]
+            pending = {"step": step, "query": prompt if step == 0 else None,
+                       "at": sent_at(prompt) if step == 0 else None, "response": _text(content) or None,
+                       "tools": tools}
+            calls.append(pending)
+            prompt, step = None, step + 1
+        elif role == "tool" and pending:
+            for block in message.get("content") or []:
+                if not isinstance(block, dict):
+                    continue
+                for tool in pending["tools"]:
+                    if tool["id"] and tool["id"] == block.get("toolCallId"):
+                        tool["result"] = _result(tool["name"], tool["args"], block.get("result"))
+    requests, clock = [], started
+    for i, call in enumerate(calls):
+        # The store has no per-message clock. A turn starts when its prompt was sent, and its
+        # calls follow two seconds apart, never before the previous call.
+        start = max(clock, call["at"] or clock)
+        end, clock = start + timedelta(seconds=1), start + timedelta(seconds=2)
+        requests.append(request(f"cursor-{session_id[:8]}-{i}", call["step"], f"{start:%Y-%m-%d %H:%M:%S}",
+                                f"{end:%Y-%m-%d %H:%M:%S}", call["query"], call["response"], call["tools"]))
+    return requests
+
+
+def worked_in(messages):
+    """The git repository the session's tool calls touched most, or None."""
+    return repo_of_paths((tool.get("args") or {}).get(key)
+                         for message in messages if message.get("role") == "assistant"
+                         and isinstance(message.get("content"), list)
+                         for tool in message["content"] if isinstance(tool, dict) and tool.get("type") == "tool-call"
+                         for key in PATH_ARGS)
+
+
+def payload(path, repo_dir=None, folder=None):
+    """The session for core.ingest_external_session. `repo_dir` pins its repository; `folder`
+    (its workspace) is used when its tool calls name none."""
+    meta, messages = ordered_messages(path)
+    created = datetime.fromtimestamp(meta["createdAt"] / 1000, timezone.utc).replace(tzinfo=None)
+    ended = datetime.now(timezone.utc).replace(tzinfo=None)
+    session_id = meta["agentId"]
+    prompts = [text for m in messages if m.get("role") == "user" and is_prompt(text := _text(m.get("content")))]
+    # The session starts with its first prompt; the store can be created long before it.
+    stamps = [at for at in map(sent_at, prompts) if at]
+    started = stamps[0] if stamps else created
+    reports = git_reports(repo_dir or worked_in(messages) or folder, started, stamps)
+    return {
+        "session_id": session_id,
+        "agent": "cursor-cli",
+        "agent_name": NAME,
+        "model": MODEL,
+        "started_at": f"{started:%Y-%m-%d %H:%M:%S}",
+        **({"git_reports": reports} if reports else {}),
+        "prompts": len(prompts),
+        "requests": to_requests(messages, session_id, started, max(ended, started + timedelta(seconds=1))),
+    }