sede 0.2.2__tar.gz → 0.2.3__tar.gz

{sede-0.2.2/src/sede.egg-info → sede-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sede
-Version: 0.2.2
+Version: 0.2.3
 Summary: Session deleter for coding assistants
 Author-email: Ilya Popov <ilypopv@gmail.com>
 License: MIT
@@ -146,7 +146,7 @@ When no sessions are found for a provider, the same screen layout is shown inste
 - Claude: deletes selected `.jsonl` session file, then removes parent project dir only if empty.
 - Copilot: deletes the selected session directory recursively.
 - Antigravity: deletes the selected conversation directory recursively.
-- OpenCode: deletes selected session rows (`part`/`message`/`session` with `PRAGMA foreign_keys=ON`) from the shared `opencode.db`; DB file and other sessions are untouched.
+- OpenCode: deletes selected session rows from the shared `opencode.db` (`part`/`message`/`session` for v1, `session_v2` plus related rows for v2, with `PRAGMA foreign_keys=ON`); v2 child sessions are removed too, while the DB file and other sessions are untouched.
 - Always review selected entries before confirming.
 
 ## Session Sources
@@ -154,4 +154,4 @@ When no sessions are found for a provider, the same screen layout is shown inste
 - Claude: `~/.claude/projects/*/*.jsonl`
 - Copilot: `~/.copilot/session-state/<session-id>/`
 - Antigravity: `~/.gemini/antigravity-cli/brain/<session-id>/` and `~/.gemini/antigravity/brain/<session-id>/`
-- OpenCode: `~/.local/share/opencode/opencode.db` (fallback `~/Library/Application Support/opencode/opencode.db`, `XDG_DATA_HOME` honoured; same XDG path for brew/non-brew) — only chat sessions are surfaced, caches (`~/.cache/opencode`, `~/.local/state/opencode`, snapshot/log) are excluded
+- OpenCode: `~/.local/share/opencode/opencode.db` (fallback `~/Library/Application Support/opencode/opencode.db`, `XDG_DATA_HOME` honoured; same XDG path for brew/non-brew) — reads both v1 (`session`/`message`/`part`) and v2 (`session_v2`/`session_message`/`session_part`) tables; only chat sessions are surfaced, caches (`~/.cache/opencode`, `~/.local/state/opencode`, snapshot/log) are excluded

{sede-0.2.2 → sede-0.2.3}/README.md

@@ -125,7 +125,7 @@ When no sessions are found for a provider, the same screen layout is shown inste
 - Claude: deletes selected `.jsonl` session file, then removes parent project dir only if empty.
 - Copilot: deletes the selected session directory recursively.
 - Antigravity: deletes the selected conversation directory recursively.
-- OpenCode: deletes selected session rows (`part`/`message`/`session` with `PRAGMA foreign_keys=ON`) from the shared `opencode.db`; DB file and other sessions are untouched.
+- OpenCode: deletes selected session rows from the shared `opencode.db` (`part`/`message`/`session` for v1, `session_v2` plus related rows for v2, with `PRAGMA foreign_keys=ON`); v2 child sessions are removed too, while the DB file and other sessions are untouched.
 - Always review selected entries before confirming.
 
 ## Session Sources
@@ -133,4 +133,4 @@ When no sessions are found for a provider, the same screen layout is shown inste
 - Claude: `~/.claude/projects/*/*.jsonl`
 - Copilot: `~/.copilot/session-state/<session-id>/`
 - Antigravity: `~/.gemini/antigravity-cli/brain/<session-id>/` and `~/.gemini/antigravity/brain/<session-id>/`
-- OpenCode: `~/.local/share/opencode/opencode.db` (fallback `~/Library/Application Support/opencode/opencode.db`, `XDG_DATA_HOME` honoured; same XDG path for brew/non-brew) — only chat sessions are surfaced, caches (`~/.cache/opencode`, `~/.local/state/opencode`, snapshot/log) are excluded
+- OpenCode: `~/.local/share/opencode/opencode.db` (fallback `~/Library/Application Support/opencode/opencode.db`, `XDG_DATA_HOME` honoured; same XDG path for brew/non-brew) — reads both v1 (`session`/`message`/`part`) and v2 (`session_v2`/`session_message`/`session_part`) tables; only chat sessions are surfaced, caches (`~/.cache/opencode`, `~/.local/state/opencode`, snapshot/log) are excluded

{sede-0.2.2 → sede-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sede"
-version = "0.2.2"
+version = "0.2.3"
 description = "Session deleter for coding assistants"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "MIT" }

{sede-0.2.2 → sede-0.2.3}/src/sede/discovery.py

@@ -359,6 +359,71 @@ def _discover_antigravity_sessions() -> list[SessionRecord]:
     return sorted(sessions, key=lambda s: s.updated_at, reverse=True)
 
 
+_OPENCODE_SESSION_SCHEMAS = (
+    ("session_v2", "session_message", "session_part"),
+    ("session", "message", "part"),
+)
+
+_OPENCODE_V2_SESSION_TABLES = (
+    "blob_ref",
+    "instruction_entry",
+    "instruction_state",
+    "schedule",
+    "session_inbox",
+    "session_part",
+    "session_message",
+)
+
+
+def _opencode_table_names(cursor: sqlite3.Cursor) -> set[str]:
+    """Returns the table names present in an OpenCode SQLite database.
+
+    Args:
+        cursor: Cursor connected to the OpenCode database.
+
+    Returns:
+        The set of table names available in the database.
+    """
+    return {
+        row[0]
+        for row in cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+    }
+
+
+def _opencode_payload_size(
+    cursor: sqlite3.Cursor,
+    session_id: str,
+    message_table: str,
+    part_table: str,
+    fallback_size: int,
+) -> int:
+    """Estimates an OpenCode session size from stored payload columns.
+
+    Args:
+        cursor: Cursor connected to the OpenCode database.
+        session_id: Session identifier to measure.
+        message_table: Table holding message payloads for this schema.
+        part_table: Table holding message part payloads for this schema.
+        fallback_size: Size to use when no payload rows are found.
+
+    Returns:
+        The combined payload size in bytes, or ``fallback_size`` when both
+        payload tables contain no data for the session.
+    """
+    size_bytes = 0
+    try:
+        for table in (message_table, part_table):
+            cursor.execute(
+                f"SELECT COALESCE(SUM(LENGTH(data)), 0) FROM {table} "
+                "WHERE session_id = ?",
+                (session_id,),
+            )
+            size_bytes += int(cursor.fetchone()[0] or 0)
+    except sqlite3.Error:
+        return 0
+    return size_bytes or fallback_size
+
+
 def _opencode_db_paths() -> list[Path]:
     """Returns candidate paths for the OpenCode SQLite database.
 
@@ -416,10 +481,12 @@ def _opencode_cache_paths() -> list[tuple[str, Path, str]]:
 def _discover_opencode_sessions() -> list[SessionRecord]:
     """Discovers OpenCode sessions from the SQLite database.
 
-    Sessions are read from ``~/.local/share/opencode/opencode.db`` (and
-    fallbacks). Only chat sessions are surfaced — local caches such as
-    ``~/.cache/opencode`` or ``~/.local/share/opencode/snapshot`` are
-    intentionally excluded.
+    Reads both the legacy v1 ``session``/``message``/``part`` tables and the
+    v2 ``session_v2``/``session_message``/``session_part`` tables, so a single
+    database can surface sessions stored by either version. Sessions are read
+    from ``~/.local/share/opencode/opencode.db`` (and fallbacks). Only chat
+    sessions are surfaced — local caches such as ``~/.cache/opencode`` or
+    ``~/.local/share/opencode/snapshot`` are intentionally excluded.
 
     Returns:
         Discovered OpenCode sessions sorted by last update time, newest
@@ -435,73 +502,66 @@ def _discover_opencode_sessions() -> list[SessionRecord]:
             uri = f"file:{db_path}?mode=ro"
             conn = sqlite3.connect(uri, uri=True)
             cursor = conn.cursor()
-            # Verify required tables exist.
-            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='session'")
-            if cursor.fetchone() is None:
-                conn.close()
-                continue
+            tables = _opencode_table_names(cursor)
 
-            # Left join project to resolve worktree when session.directory is empty.
-            cursor.execute(
-                "SELECT s.id, s.project_id, s.directory, s.title, "
-                "s.time_created, s.time_updated, p.worktree "
-                "FROM session s LEFT JOIN project p ON s.project_id = p.id"
-            )
-            rows = cursor.fetchall()
-
-            # Pre-compute sizes per session when possible (message + part payloads).
-            for row in rows:
-                sid, pid, directory, title, t_created, t_updated, worktree = row
-                if sid in seen_ids:
+            for session_table, message_table, part_table in _OPENCODE_SESSION_SCHEMAS:
+                if session_table not in tables:
                     continue
-                seen_ids.add(sid)
-                project_path = directory or worktree or "Unknown project"
-                title_val = title or sid
-                # time columns are milliseconds since epoch
-                try:
-                    ms = int(t_updated if t_updated is not None else t_created)
-                    updated_at = datetime.fromtimestamp(ms / 1000, tz=timezone.utc)
-                except Exception:
-                    try:
-                        stat = db_path.stat()
-                        updated_at = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)
-                    except OSError:
-                        updated_at = datetime.now(timezone.utc)
 
-                # Estimate size via sum of message/part data lengths.
-                size_bytes = 0
+                # Left join project to resolve worktree when directory is empty.
+                cursor.execute(
+                    "SELECT s.id, s.directory, s.title, "
+                    "s.time_created, s.time_updated, p.worktree "
+                    f"FROM {session_table} s "
+                    "LEFT JOIN project p ON s.project_id = p.id"
+                )
+                rows = cursor.fetchall()
+                # Fallback to DB file size if a session has no payload rows.
                 try:
-                    cursor.execute(
-                        "SELECT COALESCE(SUM(LENGTH(data)), 0) FROM message WHERE session_id = ?",
-                        (sid,),
-                    )
-                    msg_size = cursor.fetchone()[0] or 0
-                    cursor.execute(
-                        "SELECT COALESCE(SUM(LENGTH(data)), 0) FROM part WHERE session_id = ?",
-                        (sid,),
-                    )
-                    part_size = cursor.fetchone()[0] or 0
-                    size_bytes = int(msg_size) + int(part_size)
-                    # Fallback to DB file size if both are zero but session exists.
-                    if size_bytes == 0:
+                    fallback_size = db_path.stat().st_size // max(1, len(rows))
+                except OSError:
+                    fallback_size = 0
+
+                for row in rows:
+                    sid, directory, title, t_created, t_updated, worktree = row
+                    if sid in seen_ids:
+                        continue
+                    seen_ids.add(sid)
+                    project_path = directory or worktree or "Unknown project"
+                    title_val = title or sid
+                    # time columns are milliseconds since epoch
+                    try:
+                        ms = int(t_updated if t_updated is not None else t_created)
+                        updated_at = datetime.fromtimestamp(ms / 1000, tz=timezone.utc)
+                    except Exception:
                         try:
-                            size_bytes = db_path.stat().st_size // max(1, len(rows))
+                            stat = db_path.stat()
+                            updated_at = datetime.fromtimestamp(
+                                stat.st_mtime, tz=timezone.utc
+                            )
                         except OSError:
-                            size_bytes = 0
-                except sqlite3.Error:
-                    size_bytes = 0
-
-                sessions.append(
-                    SessionRecord(
-                        provider="opencode",
-                        session_id=sid,
-                        title=_shorten(title_val, 70),
-                        project_path=project_path,
-                        size_bytes=size_bytes,
-                        updated_at=updated_at,
-                        storage_path=db_path,
+                            updated_at = datetime.now(timezone.utc)
+
+                    # Estimate size via sum of message/part data lengths.
+                    size_bytes = _opencode_payload_size(
+                        cursor,
+                        sid,
+                        message_table,
+                        part_table,
+                        fallback_size,
+                    )
+
+                    sessions.append(
+                        SessionRecord(
+                            provider="opencode",
+                            session_id=sid,
+                            title=_shorten(title_val, 70),
+                            project_path=project_path,
+                            size_bytes=size_bytes,
+                            updated_at=updated_at,
+                            storage_path=db_path,
+                        )
                     )
-                )
             conn.close()
         except sqlite3.Error:
             try:
@@ -513,6 +573,64 @@ def _discover_opencode_sessions() -> list[SessionRecord]:
     return sorted(sessions, key=lambda s: s.updated_at, reverse=True)
 
 
+def _delete_opencode_v2_session(
+    cursor: sqlite3.Cursor, session_id: str, tables: set[str]
+) -> None:
+    """Deletes an OpenCode v2 session, its child sessions, and related rows.
+
+    Mirrors OpenCode's own session deletion: child sessions are removed
+    recursively, durable events and jobs for the session are dropped, and
+    session-scoped rows are deleted explicitly before the ``session_v2`` row
+    itself. Optional tables are skipped when absent so databases from older
+    or newer schema versions keep working.
+
+    Args:
+        cursor: Cursor connected to the OpenCode database.
+        session_id: Identifier of the session to delete.
+        tables: Table names present in the database.
+    """
+    if "session_v2" not in tables:
+        return
+
+    pending = [session_id]
+    seen: set[str] = set()
+
+    while pending:
+        current = pending.pop()
+        if current in seen:
+            continue
+        seen.add(current)
+
+        cursor.execute("SELECT id FROM session_v2 WHERE parent_id = ?", (current,))
+        pending.extend(row[0] for row in cursor.fetchall())
+
+        if "job" in tables:
+            cursor.execute(
+                "DELETE FROM job WHERE session_id = ? OR child_session_id = ?",
+                (current, current),
+            )
+        if "event" in tables:
+            cursor.execute("DELETE FROM event WHERE aggregate_id = ?", (current,))
+        if "event_sequence" in tables:
+            cursor.execute(
+                "DELETE FROM event_sequence WHERE aggregate_id = ?", (current,)
+            )
+        if "blob" in tables and "blob_ref" in tables:
+            cursor.execute(
+                "DELETE FROM blob WHERE hash IN ("
+                "SELECT hash FROM blob_ref WHERE session_id = ?"
+                ") AND NOT EXISTS ("
+                "SELECT 1 FROM blob_ref AS ref WHERE ref.hash = blob.hash "
+                "AND ref.session_id != ?"
+                ")",
+                (current, current),
+            )
+        for table in _OPENCODE_V2_SESSION_TABLES:
+            if table in tables:
+                cursor.execute(f"DELETE FROM {table} WHERE session_id = ?", (current,))
+        cursor.execute("DELETE FROM session_v2 WHERE id = ?", (current,))
+
+
 def _delete_opencode_session(session_path: Path, session_id: str) -> None:
     """Deletes an OpenCode session.
 
@@ -520,10 +638,11 @@ def _delete_opencode_session(session_path: Path, session_id: str) -> None:
         session_path: Path to the OpenCode database (``opencode.db``). For
             legacy cache entries this may be a cache directory.
         session_id: Session identifier. Cache entries prefixed with
-            ``cache:`` are removed via filesystem deletion; all other values
-            are treated as DB session ids and removed safely via
-            ``DELETE`` with explicit cleanup of ``message``/``part`` rows
-            so that a shared ``opencode.db`` file is never removed and
+            ``cache:`` are removed via filesystem deletion. Legacy v1
+            sessions are removed with explicit ``DELETE`` calls on
+            ``part``/``message``/``session``; v2 sessions use the
+            ``session_v2`` schema and also delete child sessions and their
+            related rows. A shared ``opencode.db`` file is never removed and
             other sessions remain untouched.
     """
     if session_id.startswith("cache:"):
@@ -538,9 +657,16 @@ def _delete_opencode_session(session_path: Path, session_id: str) -> None:
     try:
         conn.execute("PRAGMA foreign_keys = ON")
         cursor = conn.cursor()
-        cursor.execute("DELETE FROM part WHERE session_id = ?", (session_id,))
-        cursor.execute("DELETE FROM message WHERE session_id = ?", (session_id,))
-        cursor.execute("DELETE FROM session WHERE id = ?", (session_id,))
+        tables = _opencode_table_names(cursor)
+
+        if "session" in tables:
+            cursor.execute("DELETE FROM part WHERE session_id = ?", (session_id,))
+            cursor.execute("DELETE FROM message WHERE session_id = ?", (session_id,))
+            cursor.execute("DELETE FROM session WHERE id = ?", (session_id,))
+
+        if "session_v2" in tables:
+            _delete_opencode_v2_session(cursor, session_id, tables)
+
         conn.commit()
     finally:
         conn.close()

{sede-0.2.2 → sede-0.2.3/src/sede.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sede
-Version: 0.2.2
+Version: 0.2.3
 Summary: Session deleter for coding assistants
 Author-email: Ilya Popov <ilypopv@gmail.com>
 License: MIT
@@ -146,7 +146,7 @@ When no sessions are found for a provider, the same screen layout is shown inste
 - Claude: deletes selected `.jsonl` session file, then removes parent project dir only if empty.
 - Copilot: deletes the selected session directory recursively.
 - Antigravity: deletes the selected conversation directory recursively.
-- OpenCode: deletes selected session rows (`part`/`message`/`session` with `PRAGMA foreign_keys=ON`) from the shared `opencode.db`; DB file and other sessions are untouched.
+- OpenCode: deletes selected session rows from the shared `opencode.db` (`part`/`message`/`session` for v1, `session_v2` plus related rows for v2, with `PRAGMA foreign_keys=ON`); v2 child sessions are removed too, while the DB file and other sessions are untouched.
 - Always review selected entries before confirming.
 
 ## Session Sources
@@ -154,4 +154,4 @@ When no sessions are found for a provider, the same screen layout is shown inste
 - Claude: `~/.claude/projects/*/*.jsonl`
 - Copilot: `~/.copilot/session-state/<session-id>/`
 - Antigravity: `~/.gemini/antigravity-cli/brain/<session-id>/` and `~/.gemini/antigravity/brain/<session-id>/`
-- OpenCode: `~/.local/share/opencode/opencode.db` (fallback `~/Library/Application Support/opencode/opencode.db`, `XDG_DATA_HOME` honoured; same XDG path for brew/non-brew) — only chat sessions are surfaced, caches (`~/.cache/opencode`, `~/.local/state/opencode`, snapshot/log) are excluded
+- OpenCode: `~/.local/share/opencode/opencode.db` (fallback `~/Library/Application Support/opencode/opencode.db`, `XDG_DATA_HOME` honoured; same XDG path for brew/non-brew) — reads both v1 (`session`/`message`/`part`) and v2 (`session_v2`/`session_message`/`session_part`) tables; only chat sessions are surfaced, caches (`~/.cache/opencode`, `~/.local/state/opencode`, snapshot/log) are excluded

{sede-0.2.2 → sede-0.2.3}/tests/test_discovery_unit.py

@@ -204,8 +204,12 @@ def test_delete_antigravity_session_cleans_db_and_summaries(tmp_path: Path) -> N
 
     summaries_db = app_dir / "conversation_summaries.db"
     conn = sqlite3.connect(str(summaries_db))
-    conn.execute("CREATE TABLE conversation_summaries (conversation_id TEXT PRIMARY KEY, title TEXT)")
-    conn.execute("INSERT INTO conversation_summaries VALUES ('session-123', 'My Session')")
+    conn.execute(
+        "CREATE TABLE conversation_summaries (conversation_id TEXT PRIMARY KEY, title TEXT)"
+    )
+    conn.execute(
+        "INSERT INTO conversation_summaries VALUES ('session-123', 'My Session')"
+    )
     conn.commit()
     conn.close()
 
@@ -217,7 +221,9 @@ def test_delete_antigravity_session_cleans_db_and_summaries(tmp_path: Path) -> N
 
     conn = sqlite3.connect(str(summaries_db))
     cursor = conn.cursor()
-    cursor.execute("SELECT * FROM conversation_summaries WHERE conversation_id = 'session-123'")
+    cursor.execute(
+        "SELECT * FROM conversation_summaries WHERE conversation_id = 'session-123'"
+    )
     assert cursor.fetchone() is None
     conn.close()
 
@@ -329,12 +335,16 @@ def test_read_antigravity_metadata_extracts_tool_calls_cwd(tmp_path: Path) -> No
     assert metadata.get("prompt") == "Build feature"
 
 
-def test_discover_antigravity_sessions_handles_empty_root(tmp_path: Path, monkeypatch) -> None:
+def test_discover_antigravity_sessions_handles_empty_root(
+    tmp_path: Path, monkeypatch
+) -> None:
     monkeypatch.setattr(discovery.Path, "home", staticmethod(lambda: tmp_path))
     assert discovery._discover_antigravity_sessions() == []
 
 
-def test_find_profile_targets_matches_direct_marker(tmp_path: Path, monkeypatch) -> None:
+def test_find_profile_targets_matches_direct_marker(
+    tmp_path: Path, monkeypatch
+) -> None:
     monkeypatch.setattr(discovery.Path, "home", staticmethod(lambda: tmp_path))
     target = tmp_path / ".copilot" / "session-state"
     target.mkdir(parents=True)
@@ -344,7 +354,9 @@ def test_find_profile_targets_matches_direct_marker(tmp_path: Path, monkeypatch)
     assert found == [target]
 
 
-def test_find_profile_targets_finds_profile_subdirs(tmp_path: Path, monkeypatch) -> None:
+def test_find_profile_targets_finds_profile_subdirs(
+    tmp_path: Path, monkeypatch
+) -> None:
     monkeypatch.setattr(discovery.Path, "home", staticmethod(lambda: tmp_path))
 
     direct = tmp_path / ".copilot-profiles" / "az" / "session-state"
@@ -502,14 +514,18 @@ def test_delete_session_rejects_unknown_provider(tmp_path: Path) -> None:
         discovery.delete_session(record)
 
 
-def _create_opencode_db(db_path: Path, sessions: list[tuple[str, str, str, int]]) -> None:
+def _create_opencode_db(
+    db_path: Path, sessions: list[tuple[str, str, str, int]]
+) -> None:
     db_path.parent.mkdir(parents=True, exist_ok=True)
     conn = __import__("sqlite3").connect(str(db_path))
     conn.execute("CREATE TABLE project (id TEXT PRIMARY KEY, worktree TEXT)")
     conn.execute(
         "CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, directory TEXT, title TEXT, time_created INTEGER, time_updated INTEGER)"
     )
-    conn.execute("CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, data TEXT)")
+    conn.execute(
+        "CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, data TEXT)"
+    )
     conn.execute(
         "CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, data TEXT)"
     )
@@ -519,7 +535,9 @@ def _create_opencode_db(db_path: Path, sessions: list[tuple[str, str, str, int]]
             "INSERT INTO session VALUES (?, ?, ?, ?, ?, ?)",
             (sid, proj, f"/tmp/{proj}", title, ms - 1000, ms),
         )
-        conn.execute("INSERT INTO message VALUES (?, ?, ?)", (f"msg-{sid}", sid, "msgdata"))
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?)", (f"msg-{sid}", sid, "msgdata")
+        )
         conn.execute(
             "INSERT INTO part VALUES (?, ?, ?, ?)",
             (f"prt-{sid}", f"msg-{sid}", sid, "partdata"),
@@ -528,6 +546,44 @@ def _create_opencode_db(db_path: Path, sessions: list[tuple[str, str, str, int]]
     conn.close()
 
 
+def _create_opencode_v2_db(
+    db_path: Path,
+    sessions: list[tuple[str, str, str, int]],
+    parents: dict[str, str] | None = None,
+) -> None:
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = __import__("sqlite3").connect(str(db_path))
+    conn.execute("CREATE TABLE project (id TEXT PRIMARY KEY, worktree TEXT)")
+    conn.execute(
+        "CREATE TABLE session_v2 (id TEXT PRIMARY KEY, project_id TEXT, parent_id TEXT, directory TEXT, title TEXT, time_created INTEGER, time_updated INTEGER)"
+    )
+    conn.execute(
+        "CREATE TABLE session_message (id TEXT PRIMARY KEY, session_id TEXT, data TEXT)"
+    )
+    conn.execute(
+        "CREATE TABLE session_part (message_id TEXT, session_id TEXT, ordinal INTEGER, data TEXT)"
+    )
+    parent_ids = parents or {}
+    for sid, proj, title, ms in sessions:
+        conn.execute(
+            "INSERT OR IGNORE INTO project VALUES (?, ?)", (proj, f"/tmp/{proj}")
+        )
+        conn.execute(
+            "INSERT INTO session_v2 VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (sid, proj, parent_ids.get(sid), f"/tmp/{proj}", title, ms - 1000, ms),
+        )
+        conn.execute(
+            "INSERT INTO session_message VALUES (?, ?, ?)",
+            (f"msg-{sid}", sid, "msgdata"),
+        )
+        conn.execute(
+            "INSERT INTO session_part VALUES (?, ?, ?, ?)",
+            (f"msg-{sid}", sid, 0, "partdata"),
+        )
+    conn.commit()
+    conn.close()
+
+
 def test_opencode_db_paths_respects_home(monkeypatch, tmp_path: Path) -> None:
     monkeypatch.setattr(discovery.Path, "home", staticmethod(lambda: tmp_path))
     paths = discovery._opencode_db_paths()
@@ -630,12 +686,16 @@ def test_delete_opencode_cache_removes_file(tmp_path: Path) -> None:
     assert not cache_file.exists()
 
 
-def test_discover_opencode_sessions_handles_missing_db(monkeypatch, tmp_path: Path) -> None:
+def test_discover_opencode_sessions_handles_missing_db(
+    monkeypatch, tmp_path: Path
+) -> None:
     monkeypatch.setattr(discovery.Path, "home", staticmethod(lambda: tmp_path))
     assert discovery._discover_opencode_sessions() == []
 
 
-def test_discover_opencode_sessions_handles_corrupt_db(monkeypatch, tmp_path: Path) -> None:
+def test_discover_opencode_sessions_handles_corrupt_db(
+    monkeypatch, tmp_path: Path
+) -> None:
     monkeypatch.setattr(discovery.Path, "home", staticmethod(lambda: tmp_path))
     db_path = tmp_path / ".local" / "share" / "opencode" / "opencode.db"
     db_path.parent.mkdir(parents=True)
@@ -677,7 +737,9 @@ def test_discover_opencode_sessions_handles_empty_title_and_missing_project(
     conn.execute(
         "CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, directory TEXT, title TEXT, time_created INTEGER, time_updated INTEGER)"
     )
-    conn.execute("CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, data TEXT)")
+    conn.execute(
+        "CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, data TEXT)"
+    )
     conn.execute(
         "CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, data TEXT)"
     )
@@ -735,3 +797,281 @@ def test_delete_opencode_session_missing_db_raises(tmp_path: Path) -> None:
     )
     with pytest.raises(FileNotFoundError):
         discovery.delete_session(record)
+
+
+def test_discover_opencode_sessions_reads_v1_and_v2_tables(
+    monkeypatch, tmp_path: Path
+) -> None:
+    import sqlite3
+
+    monkeypatch.setattr(discovery.Path, "home", staticmethod(lambda: tmp_path))
+    db_path = tmp_path / ".local" / "share" / "opencode" / "opencode.db"
+    _create_opencode_v2_db(
+        db_path,
+        [("ses_v2", "proj_v2", "V2 Session", 1788600000000)],
+    )
+
+    conn = sqlite3.connect(str(db_path))
+    conn.execute(
+        "CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, directory TEXT, title TEXT, time_created INTEGER, time_updated INTEGER)"
+    )
+    conn.execute(
+        "CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, data TEXT)"
+    )
+    conn.execute(
+        "CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, data TEXT)"
+    )
+    conn.execute("INSERT INTO project VALUES ('proj_v1', '/tmp/proj_v1')")
+    conn.execute(
+        "INSERT INTO session VALUES ('ses_v1', 'proj_v1', '/tmp/proj_v1', 'V1 Session', ?, ?)",
+        (1788590000000, 1788590000000),
+    )
+    conn.execute("INSERT INTO message VALUES ('msg_v1', 'ses_v1', 'v1data')")
+    conn.execute("INSERT INTO part VALUES ('prt_v1', 'msg_v1', 'ses_v1', 'v1part')")
+    conn.commit()
+    conn.close()
+
+    sessions = discovery._discover_opencode_sessions()
+
+    assert [s.session_id for s in sessions] == ["ses_v2", "ses_v1"]
+    assert all(s.provider == "opencode" for s in sessions)
+    assert sessions[0].title == "V2 Session"
+    assert sessions[0].project_path == "/tmp/proj_v2"
+    assert sessions[0].size_bytes > 0
+    assert sessions[1].title == "V1 Session"
+
+
+def test_discover_opencode_sessions_v2_uses_fallbacks(
+    monkeypatch, tmp_path: Path
+) -> None:
+    import sqlite3
+
+    monkeypatch.setattr(discovery.Path, "home", staticmethod(lambda: tmp_path))
+    db_path = tmp_path / ".local" / "share" / "opencode" / "opencode.db"
+    _create_opencode_v2_db(
+        db_path,
+        [("ses_v2", "proj_v2", "V2 Session", 1788600000000)],
+    )
+
+    conn = sqlite3.connect(str(db_path))
+    conn.execute(
+        "INSERT INTO session_v2 VALUES ('ses_empty', 'missing', NULL, '', '', ?, ?)",
+        (1788590000000, 1788590000000),
+    )
+    conn.commit()
+    conn.close()
+
+    sessions = discovery._discover_opencode_sessions()
+    empty = next(s for s in sessions if s.session_id == "ses_empty")
+
+    assert empty.title == "ses_empty"
+    assert empty.project_path == "Unknown project"
+    assert empty.size_bytes > 0
+
+
+def test_discover_opencode_sessions_v2_handles_missing_payload_tables(
+    monkeypatch, tmp_path: Path
+) -> None:
+    import sqlite3
+
+    monkeypatch.setattr(discovery.Path, "home", staticmethod(lambda: tmp_path))
+    db_path = tmp_path / ".local" / "share" / "opencode" / "opencode.db"
+    db_path.parent.mkdir(parents=True)
+    conn = sqlite3.connect(str(db_path))
+    conn.execute("CREATE TABLE project (id TEXT PRIMARY KEY, worktree TEXT)")
+    conn.execute(
+        "CREATE TABLE session_v2 (id TEXT PRIMARY KEY, project_id TEXT, parent_id TEXT, directory TEXT, title TEXT, time_created INTEGER, time_updated INTEGER)"
+    )
+    conn.execute(
+        "INSERT INTO session_v2 VALUES ('ses_v2', 'proj_v2', NULL, '/tmp/proj_v2', 'V2 Session', 1788590000000, 1788590000000)"
+    )
+    conn.commit()
+    conn.close()
+
+    sessions = discovery._discover_opencode_sessions()
+
+    assert len(sessions) == 1
+    assert sessions[0].session_id == "ses_v2"
+    assert sessions[0].size_bytes == 0
+
+
+def test_delete_opencode_v2_session_removes_children_and_related_rows(
+    tmp_path: Path,
+) -> None:
+    import sqlite3
+
+    db_path = tmp_path / "opencode.db"
+    _create_opencode_v2_db(
+        db_path,
+        [
+            ("ses_parent", "proj", "Parent", 1788590000000),
+            ("ses_child", "proj", "Child", 1788590001000),
+            ("ses_other", "proj", "Other", 1788590002000),
+        ],
+        parents={"ses_child": "ses_parent"},
+    )
+
+    conn = sqlite3.connect(str(db_path))
+    conn.execute("CREATE TABLE instruction_state (session_id TEXT PRIMARY KEY)")
+    conn.execute("CREATE TABLE instruction_entry (session_id TEXT, key TEXT)")
+    conn.execute("CREATE TABLE blob_ref (session_id TEXT, message_id TEXT, hash TEXT)")
+    conn.execute("CREATE TABLE schedule (id TEXT PRIMARY KEY, session_id TEXT)")
+    conn.execute("CREATE TABLE session_inbox (id TEXT PRIMARY KEY, session_id TEXT)")
+    conn.execute(
+        "CREATE TABLE job (notification_id TEXT PRIMARY KEY, session_id TEXT, child_session_id TEXT)"
+    )
+    conn.execute(
+        "CREATE TABLE event_sequence (aggregate_id TEXT PRIMARY KEY, seq INTEGER)"
+    )
+    conn.execute("CREATE TABLE event (id TEXT PRIMARY KEY, aggregate_id TEXT)")
+    for sid in ("ses_parent", "ses_child", "ses_other"):
+        conn.execute("INSERT INTO instruction_state VALUES (?)", (sid,))
+        conn.execute("INSERT INTO instruction_entry VALUES (?, 'key')", (sid,))
+        conn.execute(
+            "INSERT INTO blob_ref VALUES (?, ?, ?)", (sid, f"msg-{sid}", "hash")
+        )
+        conn.execute("INSERT INTO schedule VALUES (?, ?)", (f"sch-{sid}", sid))
+        conn.execute("INSERT INTO session_inbox VALUES (?, ?)", (f"inbox-{sid}", sid))
+        conn.execute("INSERT INTO event_sequence VALUES (?, 1)", (sid,))
+        conn.execute("INSERT INTO event VALUES (?, ?)", (f"evt-{sid}", sid))
+    conn.execute("INSERT INTO job VALUES ('n1', 'ses_parent', NULL)")
+    conn.execute("INSERT INTO job VALUES ('n2', 'ses_other', 'ses_child')")
+    conn.execute("INSERT INTO job VALUES ('n3', 'ses_other', NULL)")
+    conn.commit()
+    conn.close()
+
+    record = SessionRecord(
+        provider="opencode",
+        session_id="ses_parent",
+        title="Parent",
+        project_path="/tmp/proj",
+        size_bytes=10,
+        updated_at=datetime.now(timezone.utc),
+        storage_path=db_path,
+    )
+    discovery.delete_session(record)
+
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+
+    checks = {
+        "session_v2": "id",
+        "session_message": "session_id",
+        "session_part": "session_id",
+        "instruction_state": "session_id",
+        "instruction_entry": "session_id",
+        "blob_ref": "session_id",
+        "schedule": "session_id",
+        "session_inbox": "session_id",
+        "event_sequence": "aggregate_id",
+        "event": "aggregate_id",
+    }
+    for table, column in checks.items():
+        assert (
+            cur.execute(
+                f"SELECT COUNT(*) FROM {table} WHERE {column} IN (?, ?)",
+                ("ses_parent", "ses_child"),
+            ).fetchone()[0]
+            == 0
+        )
+
+    assert cur.execute("SELECT COUNT(*) FROM session_v2").fetchone()[0] == 1
+    assert cur.execute("SELECT id FROM session_v2").fetchone()[0] == "ses_other"
+    assert cur.execute("SELECT COUNT(*) FROM session_message").fetchone()[0] == 1
+    assert cur.execute("SELECT COUNT(*) FROM session_part").fetchone()[0] == 1
+    assert cur.execute("SELECT COUNT(*) FROM instruction_state").fetchone()[0] == 1
+    assert cur.execute("SELECT COUNT(*) FROM blob_ref").fetchone()[0] == 1
+    assert cur.execute("SELECT COUNT(*) FROM schedule").fetchone()[0] == 1
+    assert cur.execute("SELECT COUNT(*) FROM session_inbox").fetchone()[0] == 1
+    assert cur.execute("SELECT COUNT(*) FROM event_sequence").fetchone()[0] == 1
+    assert cur.execute("SELECT COUNT(*) FROM event").fetchone()[0] == 1
+    assert cur.execute("SELECT notification_id FROM job").fetchall() == [("n3",)]
+    conn.close()
+
+
+def test_delete_opencode_v2_session_releases_unreferenced_blobs(
+    tmp_path: Path,
+) -> None:
+    import sqlite3
+
+    db_path = tmp_path / "opencode.db"
+    _create_opencode_v2_db(
+        db_path,
+        [
+            ("ses_parent", "proj", "Parent", 1788590000000),
+            ("ses_child", "proj", "Child", 1788590001000),
+            ("ses_other", "proj", "Other", 1788590002000),
+        ],
+        parents={"ses_child": "ses_parent"},
+    )
+
+    conn = sqlite3.connect(str(db_path))
+    conn.execute("CREATE TABLE blob (hash TEXT PRIMARY KEY, data TEXT)")
+    conn.execute("CREATE TABLE blob_ref (session_id TEXT, message_id TEXT, hash TEXT)")
+    for hash_value in ("b_parent", "b_shared", "b_child_other", "b_other"):
+        conn.execute("INSERT INTO blob VALUES (?, 'data')", (hash_value,))
+    for sid, hash_value in (
+        ("ses_parent", "b_parent"),
+        ("ses_parent", "b_shared"),
+        ("ses_child", "b_shared"),
+        ("ses_child", "b_child_other"),
+        ("ses_other", "b_child_other"),
+        ("ses_other", "b_other"),
+    ):
+        conn.execute(
+            "INSERT INTO blob_ref VALUES (?, ?, ?)", (sid, f"msg-{sid}", hash_value)
+        )
+    conn.commit()
+    conn.close()
+
+    record = SessionRecord(
+        provider="opencode",
+        session_id="ses_parent",
+        title="Parent",
+        project_path="/tmp/proj",
+        size_bytes=10,
+        updated_at=datetime.now(timezone.utc),
+        storage_path=db_path,
+    )
+    discovery.delete_session(record)
+
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+    assert cur.execute("SELECT hash FROM blob ORDER BY hash").fetchall() == [
+        ("b_child_other",),
+        ("b_other",),
+    ]
+    assert cur.execute(
+        "SELECT DISTINCT hash FROM blob_ref ORDER BY hash"
+    ).fetchall() == [
+        ("b_child_other",),
+        ("b_other",),
+    ]
+    conn.close()
+
+
+def test_delete_opencode_v2_session_without_optional_tables(tmp_path: Path) -> None:
+    import sqlite3
+
+    db_path = tmp_path / "opencode.db"
+    _create_opencode_v2_db(
+        db_path,
+        [("ses_v2", "proj", "V2 Session", 1788590000000)],
+    )
+
+    record = SessionRecord(
+        provider="opencode",
+        session_id="ses_v2",
+        title="V2 Session",
+        project_path="/tmp/proj",
+        size_bytes=10,
+        updated_at=datetime.now(timezone.utc),
+        storage_path=db_path,
+    )
+    discovery.delete_session(record)
+
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+    assert cur.execute("SELECT COUNT(*) FROM session_v2").fetchone()[0] == 0
+    assert cur.execute("SELECT COUNT(*) FROM session_message").fetchone()[0] == 0
+    conn.close()