spooling 0.2.11__tar.gz → 0.2.12__tar.gz

{spooling-0.2.11/spooling.egg-info → spooling-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spooling
-Version: 0.2.11
+Version: 0.2.12
 Summary: Local session tracker and semantic search for AI coding assistants
 Author: Parsed Analytics, Inc.
 License: MIT
@@ -176,7 +176,11 @@ Common options: `--days N`, `--project TEXT`, `--provider/-p NAME`, `--limit/-n
 
 `tools --agent` and `agents --tool` look inside an agent's own runs. `traces --agent/--tool` matches whole traces, like the Traces page.
 
-`spooling tools --cloud` and `spooling agents --cloud` show workspace-wide totals from Spooling Cloud. The cloud endpoints only support `--limit`, so combining `--cloud` with other filters is an error. Agent data is only recorded for providers that expose subagents (for example Claude Code's `Task` tool), so `spooling agents` can be empty for other providers.
+`spooling tools --cloud` and `spooling agents --cloud` show workspace-wide totals from Spooling Cloud. The cloud endpoints only support `--limit`, so combining `--cloud` with other filters is an error. Agent data is only recorded for providers that expose subagents (currently Claude Code, via its `Agent` tool, previously called `Task`), so `spooling agents` is empty for other providers.
+
+After upgrading, `spooling sync` re-reads your Claude Code sessions once to pick up agents. To force a re-read of any provider's files at any time, run `spooling sync --reparse` (optionally with `-p claude-code`).
+
+Agent runs show duration and the prompt that started them. Their own tokens, cost and tool calls are not attributed yet, because Claude Code writes subagent activity to separate transcript files that Spooling does not read yet.
 
 ### `spooling search <query>`
 

{spooling-0.2.11 → spooling-0.2.12}/README.md

@@ -140,7 +140,11 @@ Common options: `--days N`, `--project TEXT`, `--provider/-p NAME`, `--limit/-n
 
 `tools --agent` and `agents --tool` look inside an agent's own runs. `traces --agent/--tool` matches whole traces, like the Traces page.
 
-`spooling tools --cloud` and `spooling agents --cloud` show workspace-wide totals from Spooling Cloud. The cloud endpoints only support `--limit`, so combining `--cloud` with other filters is an error. Agent data is only recorded for providers that expose subagents (for example Claude Code's `Task` tool), so `spooling agents` can be empty for other providers.
+`spooling tools --cloud` and `spooling agents --cloud` show workspace-wide totals from Spooling Cloud. The cloud endpoints only support `--limit`, so combining `--cloud` with other filters is an error. Agent data is only recorded for providers that expose subagents (currently Claude Code, via its `Agent` tool, previously called `Task`), so `spooling agents` is empty for other providers.
+
+After upgrading, `spooling sync` re-reads your Claude Code sessions once to pick up agents. To force a re-read of any provider's files at any time, run `spooling sync --reparse` (optionally with `-p claude-code`).
+
+Agent runs show duration and the prompt that started them. Their own tokens, cost and tool calls are not attributed yet, because Claude Code writes subagent activity to separate transcript files that Spooling does not read yet.
 
 ### `spooling search <query>`
 

{spooling-0.2.11 → spooling-0.2.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spooling"
-version = "0.2.11"
+version = "0.2.12"
 description = "Local session tracker and semantic search for AI coding assistants"
 readme = "README.md"
 authors = [{ name = "Parsed Analytics, Inc." }]

{spooling-0.2.11 → spooling-0.2.12}/spooling/cli.py

@@ -65,10 +65,11 @@ def init():
 @cli.command()
 @click.option("--no-embed", is_flag=True, help="Skip embedding (faster sync)")
 @click.option("--provider", "-p", default=None, help="Only sync a specific provider (claude-code, jsonl-session, codex, cursor, copilot, windsurf)")
-def sync(no_embed, provider):
+@click.option("--reparse", is_flag=True, help="Re-read session files even if they look unchanged (rebuilds traces/spans)")
+def sync(no_embed, provider, reparse):
     """Sync AI coding sessions to the database."""
     from spooling.ingest import sync as do_sync
-    do_sync(embed=not no_embed, provider_filter=provider)
+    do_sync(embed=not no_embed, provider_filter=provider, reparse=reparse)
 
 
 @cli.command()
@@ -1475,8 +1476,9 @@ def agents_cmd(tools, cloud_mode, days, project, provider, limit, as_json):
     if not rows:
         console.print(
             "[yellow]No agent spans found locally.[/yellow]\n"
-            "[dim]Agent runs are recorded for providers that expose subagents (e.g. Claude Code's Task tool). "
-            "Run 'spooling sync' after using one, or try 'spooling agents --cloud'.[/dim]"
+            "[dim]Agent runs are recorded for providers that expose subagents (currently Claude Code, via its "
+            "Agent/Task tool). Run 'spooling sync' after using one, or try 'spooling agents --cloud'.\n"
+            "If you use Claude Code and still see this, run 'spooling sync --reparse -p claude-code'.[/dim]"
         )
         return
     table = Table(title="Agents" + (f" that called {', '.join(tools)}" if tools else ""), show_lines=False)

{spooling-0.2.11 → spooling-0.2.12}/spooling/ingest.py

@@ -458,8 +458,42 @@ def _sync_remote_provider(conn, provider, prov_info: dict, embed: bool) -> tuple
     return total_sessions, total_messages, total_chunks
 
 
-def sync(embed: bool = True, provider_filter: str | None = None):
-    """Sync sessions from all connected providers to the database."""
+_REVISION_PREFIX = "__parser_revision__:"
+
+
+def _needs_reread(conn, synced: dict, provider_type: str, revision: int, reparse: bool) -> bool:
+    """True if this provider's already-synced files must be re-read this run.
+
+    Either the user asked (``--reparse``), or a parser fix shipped
+    (``provider.parser_revision`` is newer than the one recorded at last sync)
+    and there are previously synced files that were parsed the old way.
+    """
+    if reparse:
+        return True
+    if not revision:
+        return False
+    stored = synced.get(_REVISION_PREFIX + provider_type)
+    if stored is not None and stored >= revision:
+        return False
+    row = conn.execute(
+        "SELECT COUNT(*) AS n FROM sync_state WHERE provider_id = %s AND file_path NOT LIKE %s",
+        (provider_type, _REVISION_PREFIX + "%"),
+    ).fetchone()
+    return bool(row["n"])
+
+
+def _record_revision(conn, synced: dict, provider_type: str, revision: int) -> None:
+    if revision and synced.get(_REVISION_PREFIX + provider_type) != revision:
+        _mark_synced(conn, _REVISION_PREFIX + provider_type, revision, provider_type)
+        synced[_REVISION_PREFIX + provider_type] = revision
+
+
+def sync(embed: bool = True, provider_filter: str | None = None, reparse: bool = False):
+    """Sync sessions from all connected providers to the database.
+
+    ``reparse`` re-reads files even if they look unchanged (also done
+    automatically, once, when a provider's parser improves).
+    """
     conn = get_connection()
     connected = _get_connected_providers(conn)
 
@@ -533,20 +567,31 @@ def sync(embed: bool = True, provider_filter: str | None = None):
         if not files:
             continue
 
+        revision = getattr(provider, "parser_revision", 0)
+        reread = _needs_reread(conn, synced, prov_info["type"], revision, reparse)
+        # When re-reading, pretend nothing was synced so every file is parsed again.
+        prov_synced = {} if reread else synced
+
         # Filter to new or changed files. Incremental providers (many sessions
         # per file) are always scanned; they skip unchanged sessions themselves.
         to_process = []
         for f in files:
             size = f.stat().st_size
-            if provider.incremental or str(f) not in synced or synced[str(f)] != size:
+            if provider.incremental or str(f) not in prov_synced or prov_synced[str(f)] != size:
                 to_process.append(f)
 
         if not to_process:
+            _record_revision(conn, synced, prov_info["type"], revision)
+            conn.commit()
             continue
 
         console.print(
             f"[bold]{provider.name}:[/bold] Found {len(to_process)} new/updated session files."
         )
+        if reread and not reparse:
+            console.print(
+                f"  [dim]Re-reading {provider.name} sessions once to pick up improved parsing.[/dim]"
+            )
 
         total_messages = 0
         total_chunks = 0
@@ -570,7 +615,7 @@ def sync(embed: bool = True, provider_filter: str | None = None):
                 batch_sessions: list[tuple] = []  # (file, [sessions])
 
                 for f in batch_files:
-                    sessions = parse_file(provider, f, synced)
+                    sessions = parse_file(provider, f, prov_synced)
                     for session in sessions:
                         _store_session(conn, session)
                         if session.trace is not None:
@@ -601,6 +646,8 @@ def sync(embed: bool = True, provider_filter: str | None = None):
                     _mark_synced(conn, str(f), f.stat().st_size, prov_info["type"])
                 conn.commit()
 
+        _record_revision(conn, synced, prov_info["type"], revision)
+
         # Update provider stats
         conn.execute(
             """UPDATE providers SET

{spooling-0.2.11 → spooling-0.2.12}/spooling/parser.py

@@ -30,6 +30,12 @@ _SYSTEM_PREFIXES = re.compile(
 _XML_TAG_STRIP = re.compile(r"<[^>]+>[^<]*</[^>]+>\s*")
 
 
+# Claude Code's subagent-launching tool. It was called "Task" and is now called
+# "Agent"; both carry ``subagent_type`` + ``prompt``/``description`` and must
+# produce an agent span.
+AGENT_TOOL_NAMES = ("Task", "Agent")
+
+
 @dataclass
 class ToolCallDetail:
     tool_use_id: str
@@ -569,7 +575,7 @@ def _build_trace(
                 tool_id = tu.get("id") or f"tu-{uid}-{tool_name}"
                 tool_input = tu.get("input") if isinstance(tu.get("input"), dict) else None
 
-                if tool_name == "Task":
+                if tool_name in AGENT_TOOL_NAMES:
                     # Agent span — child of whatever parent_span is.
                     sub_type = (tool_input or {}).get("subagent_type") or "generic"
                     prompt = (tool_input or {}).get("prompt") or (tool_input or {}).get("description")

{spooling-0.2.11 → spooling-0.2.12}/spooling/providers/base.py

@@ -61,6 +61,11 @@ class Provider(ABC):
     # ``parse_session_file`` so unchanged sessions are skipped cheaply.
     incremental: bool = False
 
+    # Bump when a parser fix changes what is extracted from files that were
+    # already synced (e.g. a new span type). Ingest then re-reads this
+    # provider's files once, instead of skipping them as "unchanged".
+    parser_revision: int = 0
+
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
         # Don't register the abstract RemoteProvider base.

{spooling-0.2.11 → spooling-0.2.12}/spooling/providers/claude_code.py

@@ -37,6 +37,8 @@ def _claude_config_dirs() -> list[Path]:
 class ClaudeCodeProvider(Provider):
     type_id = "claude-code"
     name = "Claude Code"
+    # 2: subagent calls named "Agent" (not just "Task") now create agent spans.
+    parser_revision = 2
 
     def default_data_path(self) -> Path:
         candidates = [d / "projects" for d in _claude_config_dirs()]

{spooling-0.2.11 → spooling-0.2.12/spooling.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spooling
-Version: 0.2.11
+Version: 0.2.12
 Summary: Local session tracker and semantic search for AI coding assistants
 Author: Parsed Analytics, Inc.
 License: MIT
@@ -176,7 +176,11 @@ Common options: `--days N`, `--project TEXT`, `--provider/-p NAME`, `--limit/-n
 
 `tools --agent` and `agents --tool` look inside an agent's own runs. `traces --agent/--tool` matches whole traces, like the Traces page.
 
-`spooling tools --cloud` and `spooling agents --cloud` show workspace-wide totals from Spooling Cloud. The cloud endpoints only support `--limit`, so combining `--cloud` with other filters is an error. Agent data is only recorded for providers that expose subagents (for example Claude Code's `Task` tool), so `spooling agents` can be empty for other providers.
+`spooling tools --cloud` and `spooling agents --cloud` show workspace-wide totals from Spooling Cloud. The cloud endpoints only support `--limit`, so combining `--cloud` with other filters is an error. Agent data is only recorded for providers that expose subagents (currently Claude Code, via its `Agent` tool, previously called `Task`), so `spooling agents` is empty for other providers.
+
+After upgrading, `spooling sync` re-reads your Claude Code sessions once to pick up agents. To force a re-read of any provider's files at any time, run `spooling sync --reparse` (optionally with `-p claude-code`).
+
+Agent runs show duration and the prompt that started them. Their own tokens, cost and tool calls are not attributed yet, because Claude Code writes subagent activity to separate transcript files that Spooling does not read yet.
 
 ### `spooling search <query>`
 

{spooling-0.2.11 → spooling-0.2.12}/spooling.egg-info/SOURCES.txt

@@ -64,6 +64,7 @@ spooling/providers/kiro.py
 spooling/providers/opencode.py
 spooling/providers/session_file.py
 spooling/providers/windsurf.py
+tests/test_agent_spans.py
 tests/test_claude_code_provider.py
 tests/test_cloud_errors.py
 tests/test_insights.py

spooling-0.2.12/tests/test_agent_spans.py

@@ -0,0 +1,172 @@
+"""Claude Code subagent calls ("Agent", formerly "Task") become agent spans,
+and sessions synced before that fix are re-read once."""
+
+import json
+
+import pytest
+from click.testing import CliRunner
+
+from spooling import db as db_mod
+from spooling import ingest, insights
+from spooling.cli import cli
+from spooling.parser import parse_session_file
+from spooling.providers import base as base_mod
+
+SID = "33333333-aaaa-4bbb-8ccc-000000000003"
+CWD = "/Users/dev/code/my-app"
+
+
+def _rec(type_, uuid, parent, ts, **kw):
+    r = {"type": type_, "uuid": uuid, "parentUuid": parent, "isSidechain": False,
+         "timestamp": ts, "cwd": CWD, "gitBranch": "main", "version": "2.1.0", "sessionId": SID}
+    r.update(kw)
+    return r
+
+
+def session_with_subagent(tool_name: str, subagent_type: str | None = "Explore"):
+    inp = {"description": "Audit the app", "prompt": "Do a thorough audit"}
+    if subagent_type:
+        inp["subagent_type"] = subagent_type
+    return [
+        _rec("user", "u1", None, "2026-11-01T10:00:00Z",
+             message={"role": "user", "content": "audit the app"}),
+        _rec("assistant", "a1", "u1", "2026-11-01T10:00:05Z",
+             message={"role": "assistant", "model": "claude-sonnet-4-5", "content": [
+                 {"type": "tool_use", "id": "toolu_agent", "name": tool_name, "input": inp},
+                 {"type": "tool_use", "id": "toolu_bash", "name": "Bash", "input": {"command": "ls"}}],
+                 "usage": {"input_tokens": 10, "output_tokens": 5}}),
+        _rec("user", "u2", "a1", "2026-11-01T10:00:30Z",
+             message={"role": "user", "content": [
+                 {"type": "tool_result", "tool_use_id": "toolu_agent", "content": "audit done"},
+                 {"type": "tool_result", "tool_use_id": "toolu_bash", "content": "a b c"}]}),
+    ]
+
+
+def write(root, records):
+    d = root / "projects" / "-Users-dev-code-my-app"
+    d.mkdir(parents=True, exist_ok=True)
+    f = d / f"{SID}.jsonl"
+    f.write_text("\n".join(json.dumps(r) for r in records) + "\n")
+    return f
+
+
+@pytest.fixture
+def home(tmp_path, monkeypatch):
+    h = tmp_path / "claude"
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(h))
+    monkeypatch.setattr(base_mod, "PATH_OVERRIDES_FILE", tmp_path / "paths.json")
+    monkeypatch.setattr(db_mod, "DB_PATH", tmp_path / "spooling.db")
+    return h
+
+
+def agent_spans(conn):
+    return [dict(r) for r in conn.execute(
+        "SELECT name, agent_type, agent_prompt FROM spans WHERE kind = 'agent'").fetchall()]
+
+
+class TestParser:
+    @pytest.mark.parametrize("tool", ["Agent", "Task"])
+    def test_subagent_tool_creates_agent_span(self, home, tool):
+        f = write(home, session_with_subagent(tool))
+        trace = parse_session_file(f, provider_id="claude-code", project_from_cwd=True).trace
+        agents = [s for s in trace.spans if s.kind.value == "agent"]
+        assert len(agents) == 1
+        assert agents[0].agent_type == "Explore"
+        assert agents[0].agent_prompt == "Do a thorough audit"
+        # the agent call is not also recorded as a plain tool span
+        assert not [s for s in trace.spans if s.kind.value == "tool" and s.tool_name in ("Agent", "Task")]
+        # other tools are unaffected
+        assert [s.tool_name for s in trace.spans if s.kind.value == "tool"] == ["Bash"]
+
+    def test_missing_subagent_type_defaults_to_generic(self, home):
+        f = write(home, session_with_subagent("Agent", subagent_type=None))
+        trace = parse_session_file(f, provider_id="claude-code", project_from_cwd=True).trace
+        assert [s.agent_type for s in trace.spans if s.kind.value == "agent"] == ["generic"]
+
+    def test_agent_span_is_closed_by_its_result(self, home):
+        f = write(home, session_with_subagent("Agent"))
+        trace = parse_session_file(f, provider_id="claude-code", project_from_cwd=True).trace
+        agent = next(s for s in trace.spans if s.kind.value == "agent")
+        assert agent.ended_at is not None and agent.duration_ms > 0
+
+
+class TestReread:
+    def _old_sync(self, home):
+        """Simulate a database synced by a version that ignored 'Agent' calls."""
+        f = write(home, session_with_subagent("Agent"))
+        ingest.sync(embed=False, provider_filter="claude-code")
+        conn = db_mod.get_connection()
+        # What an old install looks like: spans parsed the old way, no revision recorded.
+        conn.execute("DELETE FROM spans WHERE kind = 'agent'")
+        conn.execute("DELETE FROM sync_state WHERE file_path LIKE '__parser_revision__:%'")
+        conn.commit()
+        assert agent_spans(conn) == []
+        conn.close()
+        return f
+
+    def test_fresh_install_records_revision_without_rereading(self, home, capsys):
+        write(home, session_with_subagent("Agent"))
+        ingest.sync(embed=False, provider_filter="claude-code")
+        conn = db_mod.get_connection()
+        assert len(agent_spans(conn)) == 1
+        rev = conn.execute("SELECT last_size FROM sync_state WHERE file_path = '__parser_revision__:claude-code'").fetchone()
+        assert rev["last_size"] == 2
+        conn.close()
+        assert "improved parsing" not in capsys.readouterr().out
+
+    def test_upgrade_rereads_old_sessions_once(self, home, capsys):
+        self._old_sync(home)
+        capsys.readouterr()
+
+        ingest.sync(embed=False, provider_filter="claude-code")
+        conn = db_mod.get_connection()
+        assert [a["agent_type"] for a in agent_spans(conn)] == ["Explore"]
+        # no duplicate sessions/traces from the re-read
+        assert conn.execute("SELECT COUNT(*) AS n FROM sessions").fetchone()["n"] == 1
+        assert conn.execute("SELECT COUNT(*) AS n FROM traces").fetchone()["n"] == 1
+        conn.close()
+        assert "improved parsing" in capsys.readouterr().out
+
+        # second sync: revision recorded, nothing is re-read any more
+        ingest.sync(embed=False, provider_filter="claude-code")
+        assert "improved parsing" not in capsys.readouterr().out
+
+    def test_reparse_flag_forces_reread_of_unchanged_files(self, home):
+        write(home, session_with_subagent("Agent"))
+        ingest.sync(embed=False, provider_filter="claude-code")
+        conn = db_mod.get_connection()
+        conn.execute("DELETE FROM spans WHERE kind = 'agent'")
+        conn.commit()
+        conn.close()
+
+        ingest.sync(embed=False, provider_filter="claude-code")           # unchanged -> skipped
+        conn = db_mod.get_connection()
+        assert agent_spans(conn) == []
+        conn.close()
+
+        ingest.sync(embed=False, provider_filter="claude-code", reparse=True)
+        conn = db_mod.get_connection()
+        assert len(agent_spans(conn)) == 1
+        conn.close()
+
+    def test_other_providers_not_forced(self, home):
+        """A revision bump on claude-code must not make other providers re-read."""
+        from spooling.providers.opencode import OpencodeProvider
+        assert OpencodeProvider.parser_revision == 0
+        conn = db_mod.get_connection()
+        assert ingest._needs_reread(conn, {}, "opencode", 0, reparse=False) is False
+        conn.close()
+
+    def test_end_to_end_agents_command(self, home):
+        self._old_sync(home)
+        r = CliRunner().invoke(cli, ["agents", "--json"])
+        assert json.loads(r.output) == []
+        ingest.sync(embed=False, provider_filter="claude-code")
+        data = json.loads(CliRunner().invoke(cli, ["agents", "--json"]).output)
+        assert [(d["name"], d["runs"]) for d in data] == [("Explore", 1)]
+
+    def test_sync_cli_reparse_flag(self, home, monkeypatch):
+        seen = {}
+        monkeypatch.setattr(ingest, "sync", lambda **kw: seen.update(kw))
+        CliRunner().invoke(cli, ["sync", "--reparse", "-p", "claude-code", "--no-embed"])
+        assert seen == {"embed": False, "provider_filter": "claude-code", "reparse": True}