agent-session-analytics 0.1.0__tar.gz → 0.2.0__tar.gz

{agent_session_analytics-0.1.0 → agent_session_analytics-0.2.0}/.gitignore

@@ -16,5 +16,8 @@ __pycache__/
 # Skill-creator iteration workspaces (eval runs, benchmarks, viewer HTML)
 skills/*-workspace/
 
+# Live smoke run records (just live-smoke)
+.live-smoke/
+
 # Serena MCP — machine-local; not tracked
 .serena/

agent_session_analytics-0.2.0/CHANGELOG.md

@@ -0,0 +1,66 @@
+# Changelog
+
+This file records the notable changes to the `agent-session-analytics` distribution.
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+The project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+A `0.x` minor release can contain breaking changes.
+
+The `publish agent-session-analytics` workflow reads the section for the tagged version.
+It uses that section as the GitHub release notes.
+To release, move the `Unreleased` entries into a new version section with the date.
+Then set the same version in `packages/agent-session-analytics/pyproject.toml`.
+Push a `agent-session-analytics-v<version>` tag after the release commit merges.
+
+## [Unreleased]
+
+## [0.2.0] - 2026-10-24
+
+### Changed
+
+- Ingest builds `tool_uses`, `tool_results`, `stop_events`, and `model_turns` from narrow rows that the staging pass pre-flattens. DuckDB no longer runs `json_extract` over `raw_entries.message`. The `raw_entries` step runs on one thread. Peak memory of an ingest step drops from 11.1 GB to 2.6 GB on a 1 M-row log set. Tables, columns, and types stay the same.
+- Every DuckDB run now sets `memory_limit` (default `4GB`, was `8GB`), `threads` (default `4`), and a 20GB spill cap. Ingest also sets `preserve_insertion_order=false`; read-only queries keep insertion order.
+- `SESSIONS_DUCKDB_MEMORY_LIMIT` must be at least 16MiB and below 16EiB. Ingest checks the value before the stage step.
+- An invalid `SESSIONS_DUCKDB_*` value makes `sql` exit 5 (a query error), not 4.
+- `tool_uses.input` keeps an explicit JSON `null`, and `tool_results.content` prints floats the way DuckDB prints them.
+- The schema version is now 3, so ingest rebuilds a version 1 or version 2 database.
+- omp and pi `model_turns.cache_creation_tokens` now holds the cache-write count (`cacheWrite`). It was NULL.
+- omp and pi `model_turns.context_tokens` now equals input + cache_read + cache_creation tokens, as it does for Claude.
+- The Codex adapter keeps `item_completed` `UserMessage` prompts, `task_complete`, and `turn_aborted` events as `raw_entries` rows. Codex `sessions.entry_count` counts them.
+- The omp and pi adapters keep the `attribution` of a user row in `raw_entries.message`. A row with `attribution` `agent` is not a real prompt.
+- Codex `raw_entries.isSidechain` is now `true` for every row of a rollout whose `session_meta.source` has a `subagent` value (`thread_spawn`, `guardian`, or `review`) and `false` otherwise. It was NULL.
+
+### Added
+
+- `SESSIONS_DUCKDB_THREADS` sets the DuckDB thread count.
+- DuckDB spills to a private `<db>.spill-<pid>-<token>` directory, one per process. DuckDB creates it only when a run spills, and the process removes it at exit.
+- A query-hygiene rule in `query-conventions.md`.
+- The `user_turns` table: one row per real user prompt (claude, codex, omp, and pi) with `turn_index`, the full `text`, and `prev_assistant_text`. Blank prompts and agent-run Codex rollouts stay out.
+- The `interrupt_events` table: main-session Claude `[Request interrupted` markers and Codex `turn_aborted` events with reason `interrupted` outside agent-run rollouts. The staging pass builds it. It can overlap `permission_denials`.
+
+### Fixed
+
+- `ingest` `elapsed_seconds` now includes the stage step that discovers and normalizes the logs. It was the DuckDB load time only.
+
+## [0.1.0] - 2026-10-11
+
+### Added
+
+- The `agent-session-analytics` console script with four JSON commands: `ingest`, `db-path`, `sql`, and `schema`.
+- A schema version stamped in the database. `ingest` rebuilds a database whose version differs, even inside the one-hour freshness window.
+- The engine moves out of the `skillz` skill and merges the dotfiles `session-analytics` engine at dotfiles commit `6ce36879`.
+- Codex `token_usage` rows reach `model_turns`. They do not count in `sessions.entry_count`.
+- The columns `model_turns.cache_creation_tokens`, `model_turns.context_tokens`, `sessions.version`, and `sessions.parent_session_id`.
+- The references `canonical-schema.md`, `harness-coverage.md`, and `query-conventions.md` ship as package data.
+
+### Changed
+
+- Codex `model_turns.tool_calls` is NULL, because Codex token rows carry no content.
+- Cursor timestamps are UTC.
+
+### Removed
+
+- The canned `query.sh` reports. Callers write their own SQL with `sql`.
+
+[Unreleased]: https://github.com/paulnsorensen/skillz-that-grillz/compare/agent-session-analytics-v0.2.0...HEAD
+[0.2.0]: https://github.com/paulnsorensen/skillz-that-grillz/compare/agent-session-analytics-v0.1.0...agent-session-analytics-v0.2.0
+[0.1.0]: https://github.com/paulnsorensen/skillz-that-grillz/releases/tag/agent-session-analytics-v0.1.0

{agent_session_analytics-0.1.0 → agent_session_analytics-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-session-analytics
-Version: 0.1.0
+Version: 0.2.0
 Summary: Ingest coding-agent session logs into DuckDB and query them read-only.
 Project-URL: Homepage, https://github.com/paulnsorensen/skillz-that-grillz/tree/main/packages/agent-session-analytics
 Project-URL: Source, https://github.com/paulnsorensen/skillz-that-grillz/tree/main/packages/agent-session-analytics
@@ -98,12 +98,18 @@ A consumer that queries the database directly runs
 - Otherwise an absolute `XDG_CACHE_HOME` selects
   `<cache>/dotfiles/session-analytics/sessions.duckdb`. A relative or unset
   value uses `~/.cache`.
-- `SESSIONS_DUCKDB_MEMORY_LIMIT` sets the DuckDB memory limit. The default is
-  `8GB`.
+- `SESSIONS_DUCKDB_MEMORY_LIMIT` sets the DuckDB memory limit, from 16MiB up to
+  but not including 16EiB. The default is `4GB`.
+- `SESSIONS_DUCKDB_THREADS` sets the DuckDB thread count, from 1 to 256. The
+  default is `4`.
 - `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, and `CURSOR_HOME` move the log roots.
 
 Ingest writes the transient `<db>.tmp` and `<db>.stage`, and a persistent
 `<db>.lock`. An `fcntl` lock serializes ingest runs. Ingest uses umask `077`.
+DuckDB spills large operations to a per-process `<db>.spill-<pid>-<token>`
+directory. DuckDB creates it only when a run spills, so a read-only query needs
+no writable directory. Each process removes its own directory at exit; a killed
+process can leave one behind, which is safe to delete. The spill cap is 20GB.
 
 ## Schema version
 

{agent_session_analytics-0.1.0 → agent_session_analytics-0.2.0}/README.md

@@ -75,12 +75,18 @@ A consumer that queries the database directly runs
 - Otherwise an absolute `XDG_CACHE_HOME` selects
   `<cache>/dotfiles/session-analytics/sessions.duckdb`. A relative or unset
   value uses `~/.cache`.
-- `SESSIONS_DUCKDB_MEMORY_LIMIT` sets the DuckDB memory limit. The default is
-  `8GB`.
+- `SESSIONS_DUCKDB_MEMORY_LIMIT` sets the DuckDB memory limit, from 16MiB up to
+  but not including 16EiB. The default is `4GB`.
+- `SESSIONS_DUCKDB_THREADS` sets the DuckDB thread count, from 1 to 256. The
+  default is `4`.
 - `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, and `CURSOR_HOME` move the log roots.
 
 Ingest writes the transient `<db>.tmp` and `<db>.stage`, and a persistent
 `<db>.lock`. An `fcntl` lock serializes ingest runs. Ingest uses umask `077`.
+DuckDB spills large operations to a per-process `<db>.spill-<pid>-<token>`
+directory. DuckDB creates it only when a run spills, so a read-only query needs
+no writable directory. Each process removes its own directory at exit; a killed
+process can leave one behind, which is safe to delete. The spill cap is 20GB.
 
 ## Schema version
 

{agent_session_analytics-0.1.0 → agent_session_analytics-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-session-analytics"
-version = "0.1.0"
+version = "0.2.0"
 description = "Ingest coding-agent session logs into DuckDB and query them read-only."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -29,10 +29,10 @@ Issues = "https://github.com/paulnsorensen/skillz-that-grillz/issues"
 Changelog = "https://github.com/paulnsorensen/skillz-that-grillz/blob/main/packages/agent-session-analytics/CHANGELOG.md"
 
 [dependency-groups]
-dev = ["pytest>=8", "pytest-xdist>=3", "basedpyright==1.40.1"]
+dev = ["pytest>=8", "pytest-xdist>=3", "basedpyright==1.40.2"]
 
 [build-system]
-requires = ["hatchling>=1.27.0"]
+requires = ["hatchling>=1.32.4"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
@@ -50,6 +50,7 @@ fromargs = { workspace = true }
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+markers = ["ac(id): ties a test to an acceptance-criterion ID"]
 addopts = "--strict-markers"
 
 [tool.basedpyright]

agent_session_analytics-0.2.0/src/agent_session_analytics/_adapters/__init__.py

@@ -0,0 +1,44 @@
+"""Harness log adapters and their registry.
+
+Each adapter is (name, discover, normalize):
+  discover()      -> list of source paths, or [] when no logs are reachable.
+  normalize(path) -> yields canonical raw-entry dicts (already harness-tagged).
+An adapter that finds nothing is non-fatal — the run logs it and continues.
+"""
+
+from __future__ import annotations
+
+from agent_session_analytics._adapters.claude import claude_discover, claude_normalize
+from agent_session_analytics._adapters.codex import codex_discover, codex_normalize
+from agent_session_analytics._adapters.copilot import copilot_discover
+from agent_session_analytics._adapters.cursor import cursor_discover, cursor_normalize
+from agent_session_analytics._adapters.pi_family import (
+    omp_discover,
+    omp_normalize,
+    pi_discover,
+    pi_normalize,
+)
+
+ADAPTERS = [
+    ("claude", claude_discover, claude_normalize),
+    ("codex", codex_discover, codex_normalize),
+    ("omp", omp_discover, omp_normalize),
+    ("pi", pi_discover, pi_normalize),
+    ("cursor", cursor_discover, cursor_normalize),
+    ("copilot", copilot_discover, None),
+]
+
+__all__ = [
+    "ADAPTERS",
+    "claude_discover",
+    "claude_normalize",
+    "codex_discover",
+    "codex_normalize",
+    "copilot_discover",
+    "cursor_discover",
+    "cursor_normalize",
+    "omp_discover",
+    "omp_normalize",
+    "pi_discover",
+    "pi_normalize",
+]

agent_session_analytics-0.2.0/src/agent_session_analytics/_adapters/_jsonl.py

@@ -0,0 +1,24 @@
+"""The JSON value type and the line reader that every harness adapter shares."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from typing import TypeAlias
+
+JsonValue: TypeAlias = "None | bool | int | float | str | list[JsonValue] | dict[str, JsonValue]"
+
+
+def iter_jsonl(path: str) -> Iterator[JsonValue]:
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        for line in fh:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                yield cast(JsonValue, json.loads(line))
+            except json.JSONDecodeError:
+                continue

agent_session_analytics-0.2.0/src/agent_session_analytics/_adapters/claude.py

@@ -0,0 +1,28 @@
+"""The Claude adapter: its logs already use the canonical envelope."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterator
+
+from agent_session_analytics._adapters._jsonl import JsonValue, iter_jsonl
+from agent_session_analytics._db import configured_path
+
+
+def claude_discover() -> list[str]:
+    root = os.path.join(configured_path("CLAUDE_CONFIG_DIR", "~/.claude"), "projects")
+    if not os.path.isdir(root):
+        return []
+    out: list[str] = []
+    for dirpath, _dirs, files in os.walk(root):
+        out.extend(os.path.join(dirpath, f) for f in files if f.endswith(".jsonl"))
+    return out
+
+
+def claude_normalize(path: str) -> Iterator[dict[str, JsonValue]]:
+    """Claude logs are already in the canonical envelope; just tag them."""
+    for entry in iter_jsonl(path):
+        if not isinstance(entry, dict):
+            continue
+        entry["harness"] = "claude"
+        yield entry

agent_session_analytics-0.2.0/src/agent_session_analytics/_adapters/codex.py

@@ -0,0 +1,376 @@
+"""The Codex adapter: rollout JSONL to the canonical envelope."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from collections.abc import Iterator
+from typing import cast
+
+from agent_session_analytics._adapters._jsonl import JsonValue, iter_jsonl
+from agent_session_analytics._db import configured_path
+
+
+def codex_discover() -> list[str]:
+    root = os.path.join(configured_path("CODEX_HOME", "~/.codex"), "sessions")
+    if not os.path.isdir(root):
+        return []
+    out: list[str] = []
+    for dirpath, _dirs, files in os.walk(root):
+        out.extend(os.path.join(dirpath, f) for f in files if f.endswith(".jsonl"))
+    return out
+
+
+def _codex_payload_is_error(payload: JsonValue) -> bool:
+    if not isinstance(payload, dict):
+        return False
+    status = payload.get("status")
+    if isinstance(status, str) and status.casefold() in ("error", "failed", "failure"):
+        return True
+    for key in ("isError", "is_error"):
+        value = payload.get(key)
+        if value is True or (isinstance(value, str) and value.casefold() == "true"):
+            return True
+    code = payload.get("exit_code")
+    return isinstance(code, int) and not isinstance(code, bool) and code != 0
+
+
+def _codex_content_block_payloads(blocks: list[JsonValue]) -> Iterator[dict[str, JsonValue]]:
+    if not blocks:
+        return
+    texts: list[str] = []
+    for block in blocks:
+        if not isinstance(block, dict) or block.get("type") != "input_text":
+            continue
+        block_text = block.get("text")
+        if not isinstance(block_text, str):
+            continue
+        texts.append(block_text)
+    if not texts:
+        return
+    header = texts[0]
+    if not re.fullmatch(
+        r"Script completed\nWall time(?:\s*:\s*|\s+)[^\n]*\nOutput:\n",
+        header,
+    ):
+        return
+    for block_text in texts[1:]:
+        try:
+            payload = cast(JsonValue, json.loads(block_text.strip()))
+        except ValueError:
+            continue
+        if isinstance(payload, dict):
+            yield payload
+
+
+def _codex_structured_payloads(out: JsonValue) -> Iterator[dict[str, JsonValue]]:
+    if isinstance(out, dict):
+        yield out
+        return
+    if isinstance(out, list):
+        yield from _codex_content_block_payloads(out)
+        return
+    if not isinstance(out, str):
+        return
+    text = out.strip()
+    try:
+        parsed = cast(JsonValue, json.loads(text))
+    except ValueError:
+        parsed = None
+    if isinstance(parsed, dict):
+        yield parsed
+        return
+    if isinstance(parsed, list):
+        yield from _codex_content_block_payloads(parsed)
+        return
+    marker = re.search(
+        r"^Script completed\n(?:Wall time(?:\s*:\s*|\s+)[^\n]*\n)?Output:\s*(.+)\s*\Z",
+        out,
+        re.DOTALL,
+    )
+    if not marker:
+        return
+    decoder = json.JSONDecoder()
+    text = marker.group(1)
+    position = 0
+    while position < len(text):
+        while position < len(text) and text[position].isspace():
+            position += 1
+        if position == len(text):
+            return
+        try:
+            parsed, end = cast(tuple[JsonValue, int], decoder.raw_decode(text, position))
+        except ValueError:
+            return
+        if isinstance(parsed, dict):
+            yield parsed
+        elif isinstance(parsed, list):
+            yield from (item for item in parsed if isinstance(item, dict))
+        position = end
+
+
+def _codex_output_is_error(out: JsonValue) -> str:
+    """Detect structured or legacy failure signals in a Codex tool output."""
+    if any(
+        _codex_payload_is_error(payload) for payload in _codex_structured_payloads(out)
+    ):
+        return "true"
+    if isinstance(out, str):
+        match = re.search(r"Process exited with code (-?\d+)\b", out)
+        if match and any(int(digit) != 0 for digit in match.group(1).lstrip("-")):
+            return "true"
+    return "false"
+
+
+def _codex_command(name: JsonValue, parsed: JsonValue, raw_input: JsonValue) -> str | None:
+    """The executed command string for codex shell-ish tools, or None.
+
+    Mirrors claude's ``input.command`` so ``tool_uses.bash_cmd`` populates:
+    ``exec_command`` carries it in ``cmd``; legacy ``shell`` carries an argv
+    array (the ``-lc``/``-c`` payload is the real command); the ``exec``
+    custom tool's argument IS the raw code string.
+    """
+    if name == "exec_command" and isinstance(parsed, dict):
+        cmd = parsed.get("cmd")
+        return cmd if isinstance(cmd, str) else None
+    if name == "shell" and isinstance(parsed, dict):
+        cmd = parsed.get("command")
+        if isinstance(cmd, str):
+            return cmd
+        if isinstance(cmd, list) and cmd:
+            if len(cmd) == 3 and cmd[1] in ("-lc", "-c"):
+                return str(cmd[2])
+            return " ".join(str(c) for c in cmd)
+        return None
+    if name == "exec" and isinstance(raw_input, str):
+        return raw_input
+    return None
+
+
+def _codex_token_usage(
+    payload: dict[str, JsonValue], last_total: JsonValue
+) -> tuple[dict[str, JsonValue] | None, JsonValue]:
+    """Map a token_count payload to (Claude-style usage, total_token_usage).
+
+    Returns usage None when last_token_usage is null or when total_token_usage
+    repeats the previous event (Codex re-emits it). The returned total is the
+    latest total seen on any token_count event, with or without usage.
+    """
+    info = payload.get("info")
+    if not isinstance(info, dict):
+        return None, last_total
+    total = info.get("total_token_usage")
+    new_total = last_total if total is None else total
+    last = info.get("last_token_usage")
+    if not isinstance(last, dict):
+        return None, new_total
+    if total is not None and total == last_total:
+        return None, new_total
+    usage: dict[str, JsonValue] = {
+        "input_tokens": last.get("input_tokens"),
+        "output_tokens": last.get("output_tokens"),
+        "cache_read_input_tokens": last.get("cached_input_tokens"),
+    }
+    return usage, new_total
+
+
+def _codex_parent_session(payload: dict[str, JsonValue]) -> str | None:
+    """Parent thread id of a sub-agent rollout, or None.
+
+    A sub-agent session_meta carries ``source.subagent.thread_spawn``; other
+    sessions carry a plain string or no ``source``.
+    """
+    source = payload.get("source")
+    subagent = source.get("subagent") if isinstance(source, dict) else None
+    spawn = subagent.get("thread_spawn") if isinstance(subagent, dict) else None
+    parent = spawn.get("parent_thread_id") if isinstance(spawn, dict) else None
+    return parent if isinstance(parent, str) and parent else None
+
+
+def _codex_is_subagent(payload: dict[str, JsonValue]) -> bool:
+    """Return True when session_meta marks an agent-run rollout.
+
+    Any ``source.subagent`` value counts: ``thread_spawn`` children, and
+    ``other`` (for example ``guardian``) or ``review`` runs that name no parent.
+    """
+    source = payload.get("source")
+    return isinstance(source, dict) and "subagent" in source
+
+
+def _codex_event(payload: dict[str, JsonValue]) -> dict[str, JsonValue] | None:
+    """Map one non-token ``event_msg`` payload to canonical fields, or None to drop it.
+
+    An ``item_completed`` ``UserMessage`` item becomes a user entry with its
+    text blocks. ``task_complete`` becomes an assistant entry with subtype
+    ``task_complete`` and ``last_agent_message`` as its one text block (no block
+    when the turn ended without one). ``turn_aborted`` becomes a system entry
+    with subtype ``turn_aborted`` and the abort reason in ``stopReason``.
+    """
+    ptype = payload.get("type")
+    if ptype == "item_completed":
+        item = payload.get("item")
+        if not isinstance(item, dict) or item.get("type") != "UserMessage":
+            return None
+        content = item.get("content")
+        blocks: list[JsonValue] = [
+            {"type": "text", "text": block["text"]}
+            for block in (content if isinstance(content, list) else [])
+            if isinstance(block, dict) and block.get("type") == "text" and isinstance(block.get("text"), str)
+        ]
+        return {"type": "user", "message": {"content": blocks}} if blocks else None
+    if ptype == "task_complete":
+        last = payload.get("last_agent_message")
+        blocks = [{"type": "text", "text": last}] if isinstance(last, str) else []
+        return {"type": "assistant", "subtype": "task_complete", "message": {"content": blocks}}
+    if ptype == "turn_aborted":
+        reason = payload.get("reason")
+        return {
+            "type": "system",
+            "subtype": "turn_aborted",
+            "stopReason": reason if isinstance(reason, str) else None,
+        }
+    return None
+
+
+def codex_normalize(path: str) -> Iterator[dict[str, object]]:
+    """Codex rollout JSONL -> canonical envelope.
+
+    session_meta carries id + cwd; a response_item/function_call becomes an
+    assistant tool_use block; a function_call_output OR custom_tool_call_output
+    becomes a user tool_result block (dropping the custom outputs was the ~50%
+    result-join gap — issue #704). Codex tool names (shell / apply_patch /
+    custom tools) are kept verbatim, and ``input.command`` is normalized to the
+    executed command string for shell-ish tools so ``bash_cmd`` extracts.
+    ``tool_search_output`` items have no matching call item and are dropped.
+    A forked rollout holds two ``session_meta`` records (own id first, parent
+    second); the first id, ``cwd``, and ``cli_version`` describe the file. A
+    token row before any id falls back to the file path, so ids stay unique.
+    ``session_meta.cli_version`` stamps ``version`` on every entry. A
+    sub-agent rollout names its parent in the first ``session_meta``; that id
+    stamps ``parentSessionId`` on every entry. Any ``source.subagent`` value
+    stamps ``isSidechain`` true on every entry, as Cursor does for sub-agent
+    files, so agent-run rollouts without a parent id stay identifiable. Each
+    non-duplicate
+    ``token_count`` event with a ``last_token_usage`` becomes one
+    ``token_usage`` entry (unique ``message.id``, empty content). Only
+    model_turns reads it, as one row; no other table sees it. User prompts,
+    ``task_complete``, and ``turn_aborted`` events map through _codex_event;
+    ``response_item`` user messages (preambles and injected context) stay out.
+    """
+    session_id = None
+    parent_session_id = None
+    is_subagent = False
+    cwd = None
+    cli_version = None
+    model = None
+    last_total = None
+    token_turns = 0
+
+    def envelope() -> dict[str, object]:
+        return {
+            "harness": "codex",
+            "timestamp": ts,
+            "sessionId": session_id,
+            "parentSessionId": parent_session_id,
+            "isSidechain": is_subagent,
+            "version": cli_version,
+            "cwd": cwd,
+        }
+
+    for entry in iter_jsonl(path):
+        if not isinstance(entry, dict):
+            continue
+        ts = entry.get("timestamp")
+        payload = entry.get("payload")
+        etype = entry.get("type")
+        if etype == "session_meta" and isinstance(payload, dict):
+            if session_id is None:
+                parent_session_id = _codex_parent_session(payload)
+                is_subagent = _codex_is_subagent(payload)
+            session_id = session_id or payload.get("id")
+            cwd = cwd or payload.get("cwd")
+            cli_version = cli_version or payload.get("cli_version") or None
+            continue
+        if etype == "turn_context" and isinstance(payload, dict):
+            cwd = payload.get("cwd") or cwd
+            model = payload.get("model") or model
+            continue
+        if (
+            etype == "event_msg"
+            and isinstance(payload, dict)
+            and payload.get("type") == "token_count"
+        ):
+            usage, last_total = _codex_token_usage(payload, last_total)
+            if usage is None:
+                continue
+            token_turns += 1
+            yield {
+                **envelope(),
+                "type": "token_usage",
+                "message": {
+                    "id": f"codex-tokens:{session_id or path}:{token_turns}",
+                    "model": model or "unknown",
+                    "content": [],
+                    "usage": usage,
+                },
+            }
+            continue
+        if etype == "event_msg" and isinstance(payload, dict):
+            event = _codex_event(payload)
+            if event is not None:
+                yield {
+                    **envelope(),
+                    **event,
+                }
+            continue
+        if etype != "response_item" or not isinstance(payload, dict):
+            continue
+        ptype = payload.get("type")
+        if ptype in ("function_call", "custom_tool_call"):
+            raw_input = payload.get("arguments") or payload.get("input")
+            try:
+                parsed: JsonValue = (
+                    cast(JsonValue, json.loads(raw_input)) if isinstance(raw_input, str) else raw_input
+                )
+            except (json.JSONDecodeError, TypeError):
+                parsed = {"raw": raw_input}
+            if not isinstance(parsed, dict):
+                parsed = {"raw": parsed}
+            name = payload.get("name")
+            command = _codex_command(name, parsed, raw_input)
+            if command is not None:
+                parsed["command"] = command
+            yield {
+                **envelope(),
+                "type": "assistant",
+                "message": {
+                    "content": [
+                        {
+                            "type": "tool_use",
+                            "id": payload.get("call_id"),
+                            "name": name,
+                            "input": parsed,
+                        }
+                    ]
+                },
+            }
+        elif ptype in ("function_call_output", "custom_tool_call_output"):
+            out = payload.get("output")
+            is_error = _codex_output_is_error(out)
+            if isinstance(out, dict):
+                out = json.dumps(out)
+            yield {
+                **envelope(),
+                "type": "user",
+                "message": {
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": payload.get("call_id"),
+                            "content": out,
+                            "is_error": is_error,
+                        }
+                    ]
+                },
+            }

agent_session_analytics-0.2.0/src/agent_session_analytics/_adapters/copilot.py

@@ -0,0 +1,9 @@
+"""The Copilot adapter: discovery only, because the CLI keeps no local transcript."""
+
+from __future__ import annotations
+
+
+def copilot_discover() -> list[str]:
+    # GitHub Copilot CLI persists no local session transcript we can find
+    # (~/.copilot holds skills/ + mcp-config.json only). See harness-coverage.md.
+    return []