spooling 0.2.4__tar.gz → 0.2.6__tar.gz

{spooling-0.2.4/spooling.egg-info → spooling-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spooling
-Version: 0.2.4
+Version: 0.2.6
 Summary: Local session tracker and semantic search for AI coding assistants
 Author: Parsed Analytics, Inc.
 License: MIT

{spooling-0.2.4 → spooling-0.2.6}/pyproject.toml

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

{spooling-0.2.4 → spooling-0.2.6}/spooling/cli.py

@@ -71,6 +71,34 @@ def sync(no_embed, provider):
     do_sync(embed=not no_embed, provider_filter=provider)
 
 
+@cli.command()
+@click.option("--no-backup", is_flag=True, help="Skip the pre-optimize database backup")
+@click.option("--no-vacuum", is_flag=True, help="Skip VACUUM (faster, but doesn't reclaim disk space)")
+@click.option("--no-embed", is_flag=True, help="Skip embedding messages that are missing chunks")
+def optimize(no_backup, no_vacuum, no_embed):
+    """Deduplicate and compact the local database.
+
+    Removes duplicated tool-call rows left by older versions, truncates
+    oversized previews, embeds any messages missing chunks, and VACUUMs.
+    A backup is written next to the database first.
+    """
+    from spooling.optimize import optimize as run_optimize
+
+    try:
+        s = run_optimize(
+            backup=not no_backup, vacuum=not no_vacuum, embed=not no_embed,
+            log=lambda m: console.print(m),
+        )
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+    mb = lambda b: f"{b / 2**20:,.0f} MB"
+    console.print(
+        f"[green]Done.[/green] {mb(s['before_bytes'])} -> {mb(s['after_bytes'])} "
+        f"({mb(s['before_bytes'] - s['after_bytes'])} reclaimed)"
+    )
+
+
 @cli.command()
 def watch():
     """Watch for new session data and auto-sync."""

{spooling-0.2.4 → spooling-0.2.6}/spooling/cloud.py

@@ -229,6 +229,18 @@ def _collect_traces(session_ids: list[str]) -> list[dict]:
         if isinstance(v, str):
             return v
         return v.isoformat()
+
+    def _json(v, default):
+        """Return a parsed object regardless of whether v is already parsed or a JSON string."""
+        if v is None:
+            return default
+        if isinstance(v, str):
+            import json as _json_mod
+            try:
+                return _json_mod.loads(v)
+            except Exception:
+                return default
+        return v
     conn = get_connection()
     try:
         placeholders = ", ".join(["%s"] * len(session_ids))
@@ -282,19 +294,19 @@ def _collect_traces(session_ids: list[str]) -> list[dict]:
                     "cost_usd": float(s["cost_usd"] or 0),
                     "model": s["model"],
                     "tool_name": s["tool_name"],
-                    "tool_input": s["tool_input"],
+                    "tool_input": _json(s["tool_input"], None),
                     "tool_output": (s["tool_output"] or "")[:200000] if s["tool_output"] else None,
                     "tool_is_error": bool(s["tool_is_error"]),
                     "agent_type": s["agent_type"],
                     "agent_prompt": (s["agent_prompt"] or "")[:200000] if s["agent_prompt"] else None,
                     "vendor": s["vendor"],
                     "category": s["category"],
-                    "attrs": s["attrs"] or {},
+                    "attrs": _json(s["attrs"], {}),
                     "events": [
                         {
                             "name": e["name"],
                             "timestamp": _ts(e["timestamp"]),
-                            "attrs": e["attrs"] or {},
+                            "attrs": _json(e["attrs"], {}),
                         }
                         for e in events
                     ],
@@ -323,8 +335,8 @@ def _collect_traces(session_ids: list[str]) -> list[dict]:
                 "git_branch": t["git_branch"],
                 "model": t["model"],
                 "vendor_count": int(t["vendor_count"] or 0),
-                "top_vendors": t["top_vendors"] or [],
-                "attrs": t["attrs"] or {},
+                "top_vendors": _json(t["top_vendors"], []),
+                "attrs": _json(t["attrs"], {}),
                 "spans": spans_payload,
             })
         return out
@@ -442,6 +454,33 @@ def _push_batches(
     return total, rejected, None
 
 
+def _sync_local(log=console.print) -> None:
+    """Ingest new/updated provider sessions into the local DB before pushing.
+
+    `push` only reads the local DB, so without this step sessions created since
+    the last `spooling sync` (or `spooling watch`) would be silently skipped.
+    Embeddings are skipped (push doesn't use them and they dominate runtime);
+    run `spooling sync` or `spooling watch` for local semantic search.
+    A failure here is non-fatal: we warn and push whatever is already local.
+    """
+    from spooling.ingest import sync as do_sync
+
+    log("[dim]Syncing local sessions before push…[/dim]")
+    try:
+        do_sync(embed=False)
+    except Exception as e:  # noqa: BLE001
+        log(f"[yellow]Local sync failed ({e}); pushing what's already in the local DB.[/yellow]")
+
+
+_SYNC_OPTION = click.option(
+    "--sync/--no-sync",
+    "do_sync",
+    default=True,
+    show_default=True,
+    help="Ingest new provider sessions into the local DB before pushing. Use --no-sync to push only what is already local.",
+)
+
+
 @click.command()
 @click.option("--limit", default=100, help="Max sessions to push per run")
 @click.option("--batch", default=20, help="Sessions per request")
@@ -484,7 +523,8 @@ def _push_batches(
     is_flag=True,
     help="Skip the client-side secret redactor. By default spool scrubs secrets (Snowflake/AWS/GitHub/OpenAI/Anthropic/Stripe tokens, PEM private keys, KEY=VALUE lines whose key looks sensitive) before pushing. Use this only if you're sure the content is clean and you need raw values.",
 )
-def push(limit: int, batch: int, project: str | None, cwd_substr: str | None, title_substr: str | None, dry_run: bool, copy: bool, with_spans: bool, no_redact: bool):
+@_SYNC_OPTION
+def push(limit: int, batch: int, project: str | None, cwd_substr: str | None, title_substr: str | None, dry_run: bool, copy: bool, with_spans: bool, no_redact: bool, do_sync: bool):
     """Push local sessions up to Spooling Cloud.
 
     Without filters, this pushes the most recent ``--limit`` sessions from
@@ -519,6 +559,8 @@ def push(limit: int, batch: int, project: str | None, cwd_substr: str | None, ti
         return
     headers = _auth_headers()
     base = _api_base()
+    if do_sync:
+        _sync_local()
     sessions = _collect_sessions(
         limit=limit,
         since=None,
@@ -626,7 +668,8 @@ def push(limit: int, batch: int, project: str | None, cwd_substr: str | None, ti
     is_flag=True,
     help="Skip the client-side secret redactor (see `spooling push --help`).",
 )
-def cloud_watch(interval: int, limit: int, batch: int, lookback: int, no_redact: bool):
+@_SYNC_OPTION
+def cloud_watch(interval: int, limit: int, batch: int, lookback: int, no_redact: bool, do_sync: bool):
     """Continuously push new local sessions to Spooling Cloud (Ctrl+C to stop)."""
     headers = _auth_headers()
     base = _api_base()
@@ -651,6 +694,9 @@ def cloud_watch(interval: int, limit: int, batch: int, lookback: int, no_redact:
         headers = _auth_headers()
         since = (watermark - timedelta(minutes=lookback)) if watermark else None
 
+        if do_sync:
+            _sync_local(log=lambda *_a, **_k: None)
+
         try:
             sessions = _collect_sessions(limit=limit, since=since)
         except Exception as e:

{spooling-0.2.4 → spooling-0.2.6}/spooling/ingest.py

@@ -1,6 +1,7 @@
 """Ingestion pipeline - parse AI coding sessions from multiple providers and store in SQLite."""
 
 import json
+import re
 import struct
 from pathlib import Path
 
@@ -59,6 +60,24 @@ def _mark_synced(conn, file_path: str, size: int, provider_id: str = "jsonl-sess
     )
 
 
+# Cap stored tool-result previews; the full output lives in the source tool's
+# own data and isn't searched or displayed beyond a preview.
+MAX_RESULT_PREVIEW = 2000
+
+
+def _mark_session_synced(conn, session: ParsedSession) -> None:
+    """Record per-session version for incremental providers."""
+    if session.source_key and session.source_version is not None:
+        _mark_synced(conn, session.source_key, session.source_version, session.provider_id)
+
+
+def parse_file(provider, file_path, synced: dict[str, int] | None = None) -> list[ParsedSession]:
+    """Parse a provider file, passing per-session sync state when supported."""
+    if getattr(provider, "incremental", False):
+        return provider.parse_session_file(file_path, synced=synced)
+    return provider.parse_session_file(file_path)
+
+
 def _store_session(conn, session: ParsedSession):
     """Store a parsed session and its messages."""
     cost = _estimate_cost(
@@ -109,7 +128,7 @@ def _store_session(conn, session: ParsedSession):
                 tool_rows_full.append((
                     session.session_id, msg.uuid, _scrub(td.name),
                     _scrub(td.input_summary),
-                    _scrub(td.result_preview) or None,
+                    (_scrub(td.result_preview) or "")[:MAX_RESULT_PREVIEW] or None,
                     msg.timestamp,
                 ))
         else:
@@ -118,6 +137,10 @@ def _store_session(conn, session: ParsedSession):
                     session.session_id, msg.uuid, _scrub(tool_name), msg.timestamp,
                 ))
 
+    # Re-ingesting a session (file grew, incremental provider changed, ...)
+    # must replace its tool calls, not append another copy.
+    conn.execute("DELETE FROM tool_calls WHERE session_id = %s", (session.session_id,))
+
     if msg_rows:
         conn.executemany(
             """INSERT INTO messages (id, session_id, role, content, timestamp, tools_used,
@@ -287,14 +310,28 @@ def _serialize_embedding(vec: list[float]) -> bytes:
     return struct.pack(f"{len(vec)}f", *vec)
 
 
+_TOOL_MARKER_RE = re.compile(r"\[tool: [^\]]*\]")
+
+
+def _chunks_for_content(content: str | None) -> list[str]:
+    """Chunk message text for embedding.
+
+    Messages that are nothing but ``[tool: X]`` markers carry no searchable
+    meaning, so they produce no chunks.
+    """
+    if not content or not content.strip():
+        return []
+    if not _TOOL_MARKER_RE.sub("", content).strip():
+        return []
+    return chunk_text(content)
+
+
 def _collect_session_chunks(session: ParsedSession) -> tuple[list[str], list[dict]]:
     """Collect all text chunks and their metadata for a session (no embedding)."""
     all_chunks: list[str] = []
     chunk_meta: list[dict] = []
     for msg in session.messages:
-        if not msg.content.strip():
-            continue
-        for chunk in chunk_text(msg.content):
+        for chunk in _chunks_for_content(msg.content):
             all_chunks.append(chunk)
             chunk_meta.append({
                 "session_id": session.session_id,
@@ -336,6 +373,45 @@ def _embed_session(conn, session: ParsedSession):
     return len(all_chunks)
 
 
+def backfill_embeddings(conn, batch_size: int = 1000, log=None) -> int:
+    """Embed stored messages that have no chunks yet.
+
+    Lets ``sync --no-embed`` (and ``push``'s pre-sync) stay fast without
+    leaving permanent holes in local semantic search: the next embedding sync
+    picks up every message that is still missing chunks. Returns the number of
+    chunks written.
+    """
+    rows = conn.execute(
+        """SELECT m.id, m.session_id, m.role, m.content, m.timestamp, s.project
+           FROM messages m
+           JOIN sessions s ON s.id = m.session_id
+           WHERE m.content IS NOT NULL AND m.content != ''
+             AND NOT EXISTS (SELECT 1 FROM chunks c WHERE c.message_id = m.id)"""
+    ).fetchall()
+
+    chunks: list[str] = []
+    metas: list[dict] = []
+    for r in rows:
+        for chunk in _chunks_for_content(r["content"]):
+            chunks.append(chunk)
+            metas.append({
+                "session_id": r["session_id"], "message_id": r["id"],
+                "role": r["role"], "project": r["project"], "timestamp": r["timestamp"],
+            })
+    if not chunks:
+        return 0
+
+    if log:
+        log(f"[dim]Embedding {len(chunks)} chunks for messages missing them…[/dim]")
+    written = 0
+    for i in range(0, len(chunks), batch_size):
+        c, m = chunks[i:i + batch_size], metas[i:i + batch_size]
+        _write_chunk_rows(conn, c, embed_texts(c), m)
+        conn.commit()
+        written += len(c)
+    return written
+
+
 def _get_connected_providers(conn) -> list[dict]:
     """Get all connected providers from the database."""
     rows = conn.execute(
@@ -457,11 +533,12 @@ def sync(embed: bool = True, provider_filter: str | None = None):
         if not files:
             continue
 
-        # Filter to new or changed files
+        # 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 str(f) not in synced or synced[str(f)] != size:
+            if provider.incremental or str(f) not in synced or synced[str(f)] != size:
                 to_process.append(f)
 
         if not to_process:
@@ -493,11 +570,12 @@ def sync(embed: bool = True, provider_filter: str | None = None):
                 batch_sessions: list[tuple] = []  # (file, [sessions])
 
                 for f in batch_files:
-                    sessions = provider.parse_session_file(f)
+                    sessions = parse_file(provider, f, synced)
                     for session in sessions:
                         _store_session(conn, session)
                         if session.trace is not None:
                             _store_trace(conn, session.trace)
+                        _mark_session_synced(conn, session)
                         total_messages += session.message_count
                         total_sessions += 1
                     batch_sessions.append((f, sessions))
@@ -543,10 +621,26 @@ def sync(embed: bool = True, provider_filter: str | None = None):
             f"{total_chunks} chunks embedded.[/green]"
         )
 
+    if embed:
+        grand_total_chunks += backfill_embeddings(conn, log=console.print)
+
+    try:
+        stored = conn.execute("SELECT COUNT(*) AS n FROM tool_calls").fetchone()["n"]
+        expected = conn.execute("SELECT COALESCE(SUM(tool_call_count), 0) AS n FROM sessions").fetchone()["n"]
+        if stored > 2 * expected + 1000:
+            console.print(
+                f"[yellow]Your database holds {stored:,} tool-call rows but only ~{expected:,} are real "
+                f"(duplicates from older versions). Run [bold]spooling optimize[/bold] to reclaim the space.[/yellow]"
+            )
+    except Exception:
+        pass
+
     conn.close()
 
     if grand_total_sessions == 0:
         console.print("[green]All sessions already synced.[/green]")
+        if grand_total_chunks:
+            console.print(f"[green]Backfilled {grand_total_chunks} missing chunks.[/green]")
     else:
         console.print(
             f"\n[green]Total: {grand_total_sessions} sessions, "

spooling-0.2.6/spooling/optimize.py

@@ -0,0 +1,159 @@
+"""One-shot maintenance for the local SQLite store: `spooling optimize`.
+
+Older versions appended a fresh copy of every session's tool calls on each
+re-ingest (the opencode provider re-ingests *every* session on *every* sync),
+so ``tool_calls`` could be ~20x larger than the real data. This module:
+
+1. backs the database up,
+2. collapses duplicated ``tool_calls`` blocks,
+3. truncates oversized tool-result previews,
+4. embeds messages that are missing chunks (``sync --no-embed`` / push),
+5. enables incremental auto-vacuum and VACUUMs to give the space back.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sqlite3
+from collections.abc import Callable
+from datetime import datetime
+from pathlib import Path
+
+from spooling.config import DB_PATH
+
+MAX_RESULT_PREVIEW = 2000
+
+
+def db_size(path: Path = DB_PATH) -> int:
+    total = 0
+    for suffix in ("", "-wal", "-shm"):
+        p = Path(str(path) + suffix)
+        if p.exists():
+            total += p.stat().st_size
+    return total
+
+
+def duplicate_tool_calls(conn: sqlite3.Connection) -> tuple[int, int]:
+    """Return (stored_rows, expected_rows) for tool_calls.
+
+    ``expected`` is the sum of per-session tool_call_count, which is what a
+    clean store holds. Cheap enough to run after every sync as a hint.
+    """
+    stored = conn.execute("SELECT COUNT(*) FROM tool_calls").fetchone()[0]
+    expected = conn.execute("SELECT COALESCE(SUM(tool_call_count), 0) FROM sessions").fetchone()[0]
+    return stored, expected
+
+
+def dedupe_tool_calls(conn: sqlite3.Connection) -> int:
+    """Keep only each session's most recent block of tool calls.
+
+    Every ingest of a session inserted one full block of ``tool_call_count``
+    rows, so the newest ``tool_call_count`` rows (by id) are exactly the
+    current copy. Returns rows deleted.
+    """
+    cur = conn.execute(
+        """DELETE FROM tool_calls WHERE id IN (
+               SELECT id FROM (
+                   SELECT t.id AS id,
+                          ROW_NUMBER() OVER (PARTITION BY t.session_id ORDER BY t.id DESC) AS rn,
+                          s.tool_call_count AS n
+                   FROM tool_calls t
+                   JOIN sessions s ON s.id = t.session_id
+               ) WHERE n > 0 AND rn > n
+           )"""
+    )
+    return cur.rowcount
+
+
+def truncate_previews(conn: sqlite3.Connection, limit: int = MAX_RESULT_PREVIEW) -> int:
+    cur = conn.execute(
+        "UPDATE tool_calls SET tool_result_preview = substr(tool_result_preview, 1, ?) "
+        "WHERE length(tool_result_preview) > ?",
+        (limit, limit),
+    )
+    return cur.rowcount
+
+
+def backup_database(path: Path = DB_PATH) -> Path:
+    """Consistent copy via the SQLite backup API (safe with WAL/open readers)."""
+    backups = path.parent / "backups"
+    backups.mkdir(parents=True, exist_ok=True)
+    dest = backups / f"{path.stem}-{datetime.now():%Y%m%d-%H%M%S}.db"
+    free = shutil.disk_usage(path.parent).free
+    need = db_size(path) * 2  # backup + headroom for VACUUM's temp copy
+    if free < need:
+        raise RuntimeError(
+            f"Not enough free disk space for backup + VACUUM "
+            f"(need ~{need // 2**20} MB, have {free // 2**20} MB). "
+            f"Free some space or re-run with --no-backup --no-vacuum."
+        )
+    src = sqlite3.connect(str(path))
+    dst = sqlite3.connect(str(dest))
+    try:
+        src.backup(dst)
+    finally:
+        dst.close()
+        src.close()
+    return dest
+
+
+def optimize(
+    path: Path = DB_PATH,
+    *,
+    backup: bool = True,
+    vacuum: bool = True,
+    embed: bool = True,
+    log: Callable[[str], None] = print,
+) -> dict:
+    """Run all maintenance steps. Returns a summary dict."""
+    summary: dict = {"before_bytes": db_size(path)}
+
+    if backup:
+        dest = backup_database(path)
+        summary["backup"] = str(dest)
+        log(f"Backup written to {dest}")
+
+    # isolation_level=None -> autocommit, required for VACUUM.
+    conn = sqlite3.connect(str(path), isolation_level=None, timeout=60)
+    try:
+        conn.execute("PRAGMA foreign_keys=ON")
+        stored, expected = duplicate_tool_calls(conn)
+        log(f"tool_calls: {stored:,} stored vs ~{expected:,} expected")
+
+        conn.execute("BEGIN")
+        summary["tool_calls_deleted"] = dedupe_tool_calls(conn)
+        summary["previews_truncated"] = truncate_previews(conn)
+        conn.execute("COMMIT")
+        log(
+            f"Removed {summary['tool_calls_deleted']:,} duplicate tool_calls, "
+            f"truncated {summary['previews_truncated']:,} previews"
+        )
+    finally:
+        conn.close()
+
+    if embed:
+        from spooling.db import get_connection
+        from spooling.ingest import backfill_embeddings
+
+        c = get_connection()
+        try:
+            summary["chunks_backfilled"] = backfill_embeddings(c, log=log)
+        finally:
+            c.close()
+        log(f"Backfilled {summary['chunks_backfilled']:,} chunks")
+
+    conn = sqlite3.connect(str(path), isolation_level=None, timeout=60)
+    try:
+        conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+        if vacuum:
+            # auto_vacuum only takes effect on a full VACUUM.
+            conn.execute("PRAGMA auto_vacuum=INCREMENTAL")
+            log("Running VACUUM (this can take a minute)…")
+            conn.execute("VACUUM")
+        conn.execute("ANALYZE")
+        conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+    finally:
+        conn.close()
+
+    summary["after_bytes"] = db_size(path)
+    return summary

{spooling-0.2.4 → spooling-0.2.6}/spooling/parser.py

@@ -67,6 +67,13 @@ class ParsedSession:
     title: str | None = None
     provider_id: str = "jsonl-session"
     trace: Optional[Trace] = None
+    # Per-session incremental sync marker. Providers whose "file" holds many
+    # sessions (e.g. opencode's single SQLite DB) set these so ingest can skip
+    # sessions whose upstream version hasn't changed since the last sync.
+    # ``source_key`` is stored in sync_state.file_path, ``source_version`` in
+    # sync_state.last_size.
+    source_key: str | None = None
+    source_version: int | None = None
 
     @property
     def message_count(self) -> int:

{spooling-0.2.4 → spooling-0.2.6}/spooling/providers/base.py

@@ -54,6 +54,13 @@ class Provider(ABC):
     # the right form.
     requires_credentials: bool = False
 
+    # True for providers whose single "file" contains many sessions and that
+    # track per-session versions themselves (see ``ParsedSession.source_key``).
+    # Ingest then always scans the file (the file-size watermark is useless
+    # for a constantly-changing DB) and passes ``synced`` to
+    # ``parse_session_file`` so unchanged sessions are skipped cheaply.
+    incremental: bool = False
+
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
         # Don't register the abstract RemoteProvider base.

{spooling-0.2.4 → spooling-0.2.6}/spooling/providers/opencode.py

@@ -202,6 +202,7 @@ class OpencodeProvider(Provider):
 
     type_id = "opencode"
     name = "opencode"
+    incremental = True
 
     def default_data_path(self) -> Path:
         return OPENCODE_DB
@@ -213,7 +214,34 @@ class OpencodeProvider(Provider):
         db = data_path or self.resolved_data_path()
         return [db] if db.exists() else []
 
-    def parse_session_file(self, file_path: Path) -> list[ParsedSession]:
+    @staticmethod
+    def _session_versions(conn: sqlite3.Connection) -> dict[str, int]:
+        """Latest activity timestamp (ms) per session across session, message
+        and part rows. A session needs re-ingesting iff this changed."""
+        versions: dict[str, int] = {}
+        for sql in (
+            "SELECT id, time_updated FROM session",
+            "SELECT session_id, MAX(time_updated) FROM message GROUP BY session_id",
+            "SELECT session_id, MAX(time_updated) FROM part GROUP BY session_id",
+        ):
+            for sid, ts in conn.execute(sql):
+                if ts is not None and ts > versions.get(sid, 0):
+                    versions[sid] = int(ts)
+        return versions
+
+    @staticmethod
+    def source_key_for(file_path: Path, session_id: str) -> str:
+        return f"{file_path}#{session_id}"
+
+    def parse_session_file(
+        self, file_path: Path, synced: dict[str, int] | None = None
+    ) -> list[ParsedSession]:
+        """Parse opencode.db into sessions.
+
+        When ``synced`` (sync_state map of key -> version) is given, sessions
+        whose version hasn't changed since the last sync are skipped without
+        reading their messages/parts.
+        """
         try:
             conn = sqlite3.connect(f"file:{file_path}?mode=ro", uri=True)
         except sqlite3.Error:
@@ -226,9 +254,14 @@ class OpencodeProvider(Provider):
                 "SELECT id, directory, title, version, model, agent, "
                 "time_created, time_updated FROM session ORDER BY time_created"
             ).fetchall()
+            versions = self._session_versions(conn)
 
             for s in session_rows:
                 sid = s["id"]
+                key = self.source_key_for(file_path, sid)
+                version = versions.get(sid) or s["time_updated"]
+                if synced is not None and synced.get(key) == version:
+                    continue
                 message_rows = conn.execute(
                     "SELECT id, time_created, data FROM message "
                     "WHERE session_id = ? ORDER BY time_created, id",
@@ -292,6 +325,8 @@ class OpencodeProvider(Provider):
                     agent_version=s["version"] or None,
                     model=model,
                     provider_id="opencode",
+                    source_key=key,
+                    source_version=int(version) if version is not None else None,
                 )
                 session.trace = build_flat_trace_from_messages(
                     provider_id="opencode",

{spooling-0.2.4 → spooling-0.2.6}/spooling/schema.py

@@ -73,6 +73,7 @@ CREATE TABLE IF NOT EXISTS chunks (
 
 CREATE INDEX IF NOT EXISTS idx_chunks_session ON chunks(session_id);
 CREATE INDEX IF NOT EXISTS idx_chunks_project ON chunks(project);
+CREATE INDEX IF NOT EXISTS idx_chunks_message ON chunks(message_id);
 
 CREATE TABLE IF NOT EXISTS sync_state (
     file_path TEXT PRIMARY KEY,