fix(cache): fingerprint SQLite WAL sidecars so reload picks up new sessions

OpenCode (and Hermes) run SQLite in WAL mode: new sessions land in <db>-wal
while the main .db's size/mtime stay put until a checkpoint. cache_inputs()
fingerprinted only the .db, so CachedStore kept serving the stale rollup and a
reload (r) or the --web report's refresh never showed sessions written since.
Include the -wal/-shm sidecars in the fingerprint; a read-only connection reads
them, so the re-parse surfaces the new rows. Missing sidecars (a non-WAL DB, or
a checkpoint that removed them) are skipped by the fingerprint's stat().

Author: hamidi-dev

src/opentab/stores/hermes.py

@@ -403,8 +403,12 @@ def _node(
         }
 
     def cache_inputs(self) -> list[str]:
-        # The single DB file whose (size, mtime) fingerprints the warm-start cache.
-        return [self.db_path]
+        # The DB file whose (size, mtime) fingerprints the warm-start cache, plus its
+        # WAL sidecars: if Hermes runs SQLite in WAL mode, new sessions land in
+        # <db>-wal and the main .db's mtime doesn't move until a checkpoint, so
+        # fingerprinting the .db alone would let a reload serve a stale cache. Missing
+        # sidecars (a non-WAL DB) are simply skipped by the fingerprint's stat().
+        return [self.db_path, self.db_path + "-wal", self.db_path + "-shm"]
 
     def workflows(self) -> list[Workflow]:
         self._sessions = None  # reload on `r`

src/opentab/stores/opencode.py

@@ -187,8 +187,16 @@ def _session_text_expr(self, alias: str, columns: list[str], fallback: str) -> s
         return f"coalesce({', '.join(parts)}, {fallback})"
 
     def cache_inputs(self) -> list[str]:
-        # The single DB file whose (size, mtime) fingerprints the warm-start cache.
-        return [os.path.abspath(self.db)]
+        # The DB file whose (size, mtime) fingerprints the warm-start cache, plus its
+        # WAL sidecars. OpenCode runs SQLite in WAL mode, so new sessions land in
+        # <db>-wal and the main .db's size/mtime don't move until a checkpoint -- so
+        # fingerprinting the .db alone made a reload (r, or the report's refresh) serve
+        # the stale cache and never show sessions written since. The sidecars move on
+        # every commit; a read-only connection still reads them, so a re-parse sees the
+        # new rows. Missing sidecars (a non-WAL DB, or a checkpoint that removed them)
+        # are simply skipped by the fingerprint's stat().
+        db = os.path.abspath(self.db)
+        return [db, db + "-wal", db + "-shm"]
 
     def workflows(self) -> list[Workflow]:
         # Load every root session; the App filters by the active range in memory

test_opentab.py

@@ -7551,6 +7551,78 @@ def workflow_nodes(self, workflow_id):
     assert app.store.node_calls == 2
 
 
+def test_cache_invalidates_on_wal_write_so_reload_sees_new_opencode_sessions():
+    # OpenCode runs SQLite in WAL mode, so a new session lands in <db>-wal while the
+    # main .db's size/mtime don't move until a checkpoint. cache_inputs() must
+    # fingerprint the WAL sidecars, or CachedStore keeps serving the stale rollup and a
+    # reload (r) / the report's refresh never shows sessions written since -- the
+    # reported "--web refresh doesn't get new sessions" bug.
+    with tempfile.TemporaryDirectory() as tmp:
+        old_xdg = os.environ.get("XDG_CONFIG_HOME")
+        os.environ["XDG_CONFIG_HOME"] = os.path.join(tmp, "cfg")  # isolate the cache dir
+        db = os.path.join(tmp, "opencode.db")
+        # Writer stays open the whole test with autocheckpoint off, so every commit
+        # stays in the -wal file and the main .db is never checkpointed/rewritten.
+        w = sqlite3.connect(db)
+        w.execute("PRAGMA journal_mode=WAL")
+        w.execute("PRAGMA wal_autocheckpoint=0")
+        w.executescript(
+            """
+            create table session (
+              id text primary key, parent_id text, title text, directory text,
+              time_created integer, cost real default 0 not null,
+              tokens_input integer default 0 not null, tokens_output integer default 0 not null,
+              tokens_reasoning integer default 0 not null, tokens_cache_read integer default 0 not null,
+              tokens_cache_write integer default 0 not null
+            );
+            create table message (id text primary key, session_id text, data text);
+            """
+        )
+        w.execute(
+            "insert into session values ('s1',null,'One','/work/repo',1760000000000,1.0,0,0,0,0,0)"
+        )
+        w.commit()
+        try:
+            store = ot.Store(db, type("A", (), {"demo": False})())
+            ci = store.cache_inputs()
+            assert db in ci and db + "-wal" in ci and db + "-shm" in ci  # sidecars fingerprinted
+
+            cid = "opencode|" + db
+            cargs = type("A", (), {"demo": False, "no_cache": False})()
+
+            # Cold: parse s1 and write the cache (workflows + breakdown both fresh).
+            c1 = ot.CachedStore(store, cid, cargs)
+            assert [x.id for x in c1.workflows()] == ["s1"]
+            c1.model_breakdown()
+            assert c1.served_from_cache is False
+
+            # Warm: a fresh wrapper over the unchanged DB serves the cache untouched.
+            c2 = ot.CachedStore(store, cid, cargs)
+            c2.workflows()
+            assert c2.served_from_cache is True
+
+            # OpenCode adds a new session -> it lands in the WAL, main .db mtime unchanged.
+            mtime_before = os.stat(db).st_mtime_ns
+            w.execute(
+                "insert into session values ('s2',null,'Two','/work/repo',1760000100000,2.0,0,0,0,0,0)"
+            )
+            w.commit()
+            assert os.stat(db).st_mtime_ns == mtime_before  # the WAL grew, not the .db
+
+            # A reload now MISSES the cache (the -wal fingerprint moved) and re-parses,
+            # so the new session is visible -- the fix.
+            c3 = ot.CachedStore(store, cid, cargs)
+            wf3 = c3.workflows()
+            assert c3.served_from_cache is False
+            assert sorted(x.id for x in wf3) == ["s1", "s2"]
+        finally:
+            w.close()
+            if old_xdg is None:
+                os.environ.pop("XDG_CONFIG_HOME", None)
+            else:
+                os.environ["XDG_CONFIG_HOME"] = old_xdg
+
+
 def test_wsl_mount_root_and_windows_path_mapping():
     with tempfile.TemporaryDirectory() as tmp:
         # wsl.conf parsing: [automount] root= wins, comments stripped, missing -> /mnt.