claude-code-log 1.4.0__tar.gz → 1.5.0__tar.gz

claude_code_log-1.5.0/.devbox-foldyard/.gitignore

@@ -0,0 +1 @@
+*

claude_code_log-1.5.0/.github/workflows/ci.yml

@@ -0,0 +1,117 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: ["ubuntu-latest", "windows-latest"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+        include:
+          - os: "ubuntu-latest"
+            python-version: "3.12"
+            is-primary: true
+
+    env:
+      # Collect coverage only on the primary job: it is the only one that
+      # uploads the reports and feeds the PR comment, while --cov costs
+      # ~65% extra pytest wall time (worst on Windows). Windows-only
+      # covered lines measured at 5 (diffing covered lines per file,
+      # Windows vs the primary artifact): the SIGUSR1 no-op return and the
+      # drive-letter branch of convert_project_path_to_claude_dir, both in
+      # cli.py. Those were never in the published report (non-primary
+      # coverage was computed and discarded), so this changes nothing.
+      COV: ${{ matrix.is-primary && '--cov=claude_code_log --cov-report=xml --cov-report=html --cov-report=term' || '' }}
+      COV_APPEND: ${{ matrix.is-primary && '--cov=claude_code_log --cov-append --cov-report=xml --cov-report=html --cov-report=term' || '' }}
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        # Full history so test/test_commit_linkifier.py's
+        # TestIntegrationLocalRepo can resolve SHAs older than the
+        # current tip (`git branch -r --contains` reads local refs
+        # only and needs the commits in the object DB).
+        fetch-depth: 0
+
+    - name: Move TEMP to the workspace disk (Windows)
+      # On windows runners TMP/TEMP default to the C: OS disk, whose
+      # throttled I/O dominates this tmp-heavy suite; RUNNER_TEMP lives on
+      # the same disk as the workspace (D:). Measured via A/B experiment
+      # (run 28715118956): this redirect alone took the unit selection from
+      # 555s mean to 150s — parity with ubuntu (~161s). Defender is NOT the
+      # culprit: real-time protection is already off on current images
+      # (exclusions/disable measured as no-ops), and a ReFS dev drive
+      # (~296s) was dominated by this redirect. Details: work/win-io.md
+      if: runner.os == 'Windows'
+      shell: pwsh
+      run: |
+        "TMP=$env:RUNNER_TEMP" >> $env:GITHUB_ENV
+        "TEMP=$env:RUNNER_TEMP" >> $env:GITHUB_ENV
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v4
+      with:
+        enable-cache: true
+
+    - name: Set up Python ${{ matrix.python-version }}
+      run: uv python install ${{ matrix.python-version }}
+
+    - name: Install dependencies
+      run: uv sync --all-extras --dev && uv run playwright install chromium
+
+    - name: Run unit tests (coverage on primary only)
+      # -p no:playwright: unit tests don't use the browser fixtures; skipping the
+      # plugin avoids a ~1s playwright import per xdist worker, which Windows pays
+      # per spawned worker. See work/xdist-import-cost.md.
+      run: uv run pytest -p no:playwright -m "not (tui or browser or benchmark)" ${{ env.COV }}
+
+    - name: Run TUI tests (coverage append on primary only)
+      run: uv run pytest -m tui ${{ env.COV_APPEND }}
+
+    - name: Run browser tests (coverage append on primary only)
+      run: uv run pytest -m browser ${{ env.COV_APPEND }}
+
+    - name: Run benchmark tests with coverage append (primary only)
+      if: matrix.is-primary
+      env:
+        CLAUDE_CODE_LOG_DEBUG_TIMING: "1"
+      run: uv run pytest -m benchmark ${{ env.COV_APPEND }} -v
+
+    - name: Upload coverage HTML report as artifact
+      uses: actions/upload-artifact@v4
+      if: matrix.is-primary
+      with:
+        name: coverage-report-html
+        path: htmlcov/
+        retention-days: 30
+
+    - name: Upload coverage XML as artifact
+      uses: actions/upload-artifact@v4
+      if: matrix.is-primary
+      with:
+        name: coverage-report-xml
+        path: coverage.xml
+        retention-days: 30
+
+    - name: Coverage comment (PR only)
+      if: github.event_name == 'pull_request' && matrix.is-primary
+      uses: py-cov-action/python-coverage-comment-action@v3
+      with:
+        GITHUB_TOKEN: ${{ github.token }}
+        MINIMUM_GREEN: 75
+        MINIMUM_ORANGE: 60
+
+    - name: Run linting
+      run: uv run ruff check
+
+    - name: Run formatting check
+      run: uv run ruff format --check
+
+    - name: Run type checking
+      run: uv run pyright

{claude_code_log-1.4.0 → claude_code_log-1.5.0}/CHANGELOG.md

@@ -6,6 +6,66 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [1.5.0] - 2026-07-09
+
+### Changed
+
+- **Filter <local-command-caveat>-wrapped caveat messages (Claude Code ≥ ~2.1) (#269)**
+- **Fix perpetual re-regeneration of projects with up-to-date caches (#268)**
+- **Fix ty possibly-missing-attribute warnings in tests (#267)**
+- **Speed up cache freshness checks on large archives (#266)**
+- **ci: move TMP/TEMP to the workspace disk on Windows runners**
+- **perf(cov): use sys.monitoring coverage core (COVERAGE_CORE=sysmon equivalent)**
+- **ci: collect coverage only on the primary matrix job**
+- **Improve Artifact tool look&feel: label-linked result, lean tool use (#262) (#263)**
+- **Remap dangling parent refs when dedup drops a distinct DAG node (#259) (#261)**
+- **Render the Artifact tool (deploy HTML/MD page → claude.ai URL) (#257) (#260)**
+- **Handle the full variety of Workflow invocation shapes (#174 follow-up) (#258)**
+- **Regenerate a --no-cache directory when a source .jsonl grows (#254) (#256)**
+- **Regenerate single-file output when its source grows; fix success-message accuracy (#221 follow-up) (#253)**
+- **Surface the model each agent ran on, once per agent context (#246) (#252)**
+- **feat: use nicer glyphs for fold/unfold controls (#247) (#255)**
+- **Escape raw HTML in assistant/tool content to fix XSS  (#245)**
+- **Warn that --output / --format are ignored under --tui (#220) (#241)**
+- **Speed up the SQLite metadata-cache build (connection reuse + synchronous=NORMAL) (#251)**
+- **Cut pytest-xdist per-worker import cost on Windows unit runs (#250)**
+- **Speed up integration-test fixtures on Windows (shrink copied transcripts; skip symlink tests when unavailable) (#249)**
+- **Stream output to stdout: support -o - / /dev/stdout (#223 part 2) (#239)**
+- **Keep fork points visible when their host message is detail-filtered (#233 follow-up) (#240)**
+- **Explicit --output: always regenerate, infer format from suffix, fix stdout hang (#221, #222, #223 part 1) (#237)**
+- **Connect fork-point and branch headers to their anchor message (#238)**
+- **Anchor fork points whose node is an unrendered system message (#236)**
+- **Render Read/Write of any Markdown file as Markdown, not Pygments (#232) (#234)**
+- **Generic tool results: render structured content items (#227) (#235)**
+- **Nested agent hierarchies: visual layer (#213, part 2 — WIP) (#219)**
+- **Render nested sub-agent hierarchies (#213) (#218)**
+- **Build(deps): bump pygments from 2.19.2 to 2.20.0 (#228)**
+- **Build(deps): bump requests from 2.32.5 to 2.33.0 (#229)**
+- **Build(deps-dev): bump pytest from 9.0.1 to 9.0.3 (#230)**
+- **Build(deps): bump idna from 3.11 to 3.15 (#231)**
+- **Side-channel prompt rendering + params-fold UX and accessibility (#174 follow-up) (#217)**
+- **Polish the workflow run tree + dev-docs sync (#174 follow-up) (#215)**
+- **Hybrid JSON/Markdown rendering for tool params tables (#216)**
+- **Linearize assistant-continuation tool-flow forks instead of branching (#214)**
+- **Enrich fork-point and branch nav labels with message summaries (#179 follow-up) (#212)**
+- **Render dynamic-workflow run tree on the nested DOM (#174 PR3) (#210)**
+- **Keep recaps visible at all detail levels; add --no-recaps (#179) (#209)**
+- **Dedupe "unrecognized message type" warnings per file (#211)**
+- **work/: delete the completed converter/renderer simplification plans (#208)**
+- **Flag auto-memory interactions: 🧠 titles + memory filter (#192) (#204)**
+- **Phase 3: single-axis collapse — delete pre-render _filter_by_detail (#206)**
+- **Render Workflow tool-input (JS) + async-result JSON bodies (#174 PR2) (#205)**
+- **Phase 2 of ghosting epic: detail-filter ghosts in place; drop _reindex_filtered_context (#194)**
+- **Parse dynamic-Workflow runs into WorkflowRun models (#174 PR1) (#203)**
+- **Bump mistune from 3.1.4 to 3.2.1 (#202)**
+- **Bump gitpython from 3.1.45 to 3.1.50 (#200)**
+- **Exclude docs/ from ty type-checking (#201)**
+- **Render message tree as nested DOM (PR0 for #174) (#191)**
+- **Bump urllib3 from 2.5.0 to 2.7.0 (#199)**
+- **Ghost-aware ctx.messages; skill-fold uses None slots (ghosting epic Phase 1) (#193)**
+- **Merge pull request #198 from daaain/fix-linux-release**
+
+
 ## [1.4.0] - 2026-06-03
 
 ### Changed

{claude_code_log-1.4.0 → claude_code_log-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-log
-Version: 1.4.0
+Version: 1.5.0
 Summary: Convert Claude Code transcript JSONL files to HTML
 Project-URL: Homepage, https://github.com/daaain/claude-code-log
 Project-URL: Issues, https://github.com/daaain/claude-code-log/issues

{claude_code_log-1.4.0 → claude_code_log-1.5.0}/claude_code_log/cache.py

@@ -10,7 +10,7 @@ import zlib
 from contextlib import contextmanager
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, Generator, List, Optional
+from typing import Any, Callable, Dict, Generator, List, Optional
 
 from packaging import version
 from pydantic import BaseModel
@@ -39,7 +39,6 @@ class CachedFileInfo(BaseModel):
     source_mtime: float
     cached_mtime: float
     message_count: int
-    session_ids: list[str]
 
 
 class SessionCacheData(BaseModel):
@@ -220,6 +219,72 @@ def get_library_version() -> str:
 # ========== Cache Path Configuration ==========
 
 
+def subagents_fingerprint(jsonl_path: Path) -> str:
+    """Fingerprint of the sidecar inputs that feed spawn discovery (#213).
+
+    Parsing a transcript also reads ``agent-*.meta.json`` sidecars (see
+    ``converter._subagent_meta_map``), so they must take part in cache
+    invalidation: a sidecar appearing after the transcript was cached
+    (e.g. a still-running agent spawning a child without touching the
+    trunk file) would otherwise go unnoticed by the mtime-only check.
+
+    The fingerprint is ``"<count>:<newest int mtime>"`` over the sidecars
+    of the dirs where this transcript's children can live — the sibling
+    ``<stem>/subagents/`` dir, plus the containing dir for agent files
+    (the flat layout puts children next to their parent). Sidecars are
+    written once at spawn time, so count+newest-mtime captures every
+    addition and removal. Empty string when there are none.
+
+    Deliberately narrower than ``converter._subagent_meta_map``'s scan
+    for TRUNK files: the parse also defensively checks the project dir
+    itself, but Claude Code never writes sidecars there, and
+    fingerprinting it would rescan a potentially large dir on every
+    cache read for a theoretical-only input.
+    """
+    candidates = [jsonl_path.parent / jsonl_path.stem / "subagents"]
+    if jsonl_path.parent.name == "subagents":
+        candidates.append(jsonl_path.parent)
+    metas: list[Path] = []
+    for directory in candidates:
+        if directory.is_dir():
+            metas.extend(directory.glob("agent-*.meta.json"))
+    if not metas:
+        return ""
+    try:
+        newest = max(int(p.stat().st_mtime) for p in metas)
+    except OSError:
+        # A sidecar vanished mid-scan; treat as unstable so the next
+        # check re-reads (an always-mismatching fingerprint is safe).
+        return f"{len(metas)}:unstable"
+    return f"{len(metas)}:{newest}"
+
+
+def _cache_row_is_fresh(
+    row: sqlite3.Row, source_mtime: float, current_fp: Callable[[], str]
+) -> bool:
+    """Decide whether a cached_files row is still fresh.
+
+    Single source of truth for the freshness rule shared by
+    is_file_cached() and get_modified_files(). current_fp is a callable
+    so callers only pay for the sidecar fingerprint scan when the mtime
+    check passes (and get_modified_files() can plug in its
+    scandir-optimized variant).
+
+    Cache is valid if modification times match (within 1 second
+    tolerance) and the sidecar inputs of spawn discovery (#213) match
+    too — new agent-*.meta.json files appear without touching the
+    source jsonl. Pre-007 rows carry NULL: accept those only when the
+    file has no sidecars today (nothing to miss), so legacy caches
+    don't mass-invalidate while sessions WITH sidecars reparse once.
+    """
+    if abs(source_mtime - row["source_mtime"]) >= 1.0:
+        return False
+    cached_fp = row["subagents_fingerprint"]
+    if cached_fp is None:
+        return current_fp() == ""
+    return cached_fp == current_fp()
+
+
 def get_cache_db_path(projects_dir: Path) -> Path:
     """Get cache database path, respecting CLAUDE_CODE_LOG_CACHE_PATH env var.
 
@@ -240,6 +305,16 @@ def get_cache_db_path(projects_dir: Path) -> Path:
 # ========== Cache Manager ==========
 
 
+# Process-level memo of cache DBs whose migrations have already been
+# checked. CacheManager is constructed per project (the TUI project
+# selector builds one per table row, on every resize), so without the
+# memo every instance re-pays the migration check: a connection plus
+# version-table and migration-directory reads, ~2ms each (issue #12).
+# The exists() guard in _init_database covers --clear-cache deleting
+# the DB file mid-process.
+_migrated_db_paths: set[str] = set()
+
+
 class CacheManager:
     """SQLite-based cache manager for Claude Code Log."""
 
@@ -266,27 +341,109 @@ class CacheManager:
         else:
             self.db_path = get_cache_db_path(project_path.parent)
 
+        # When inside a batch() scope this holds the single shared connection
+        # reused by every _get_connection() call; None means the default
+        # open-a-connection-per-call behaviour. Set before _init_database() so
+        # the field always exists before any _get_connection() could run, even
+        # if migrations are ever routed through it.
+        self._shared_conn: Optional[sqlite3.Connection] = None
+
         # Initialise database and ensure project exists
         self._init_database()
         self._project_id: Optional[int] = None
         self._ensure_project_exists()
 
-    @contextmanager
-    def _get_connection(self) -> Generator[sqlite3.Connection, None, None]:
-        """Get a database connection with proper settings."""
-        conn = sqlite3.connect(self.db_path, timeout=30.0)
+    def _configure_connection(self, conn: sqlite3.Connection) -> None:
+        """Apply the standard pragmas/row factory to a fresh connection."""
         conn.row_factory = sqlite3.Row
         conn.execute("PRAGMA foreign_keys = ON")
         conn.execute("PRAGMA journal_mode = WAL")
+        # synchronous=NORMAL is the recommended pairing for WAL: it keeps
+        # durability across application crashes (only a power/OS crash can lose
+        # the last committed transaction) while skipping an fsync on every
+        # commit. The cache is fully regenerable from the JSONL source, so that
+        # residual risk is acceptable.
+        conn.execute("PRAGMA synchronous = NORMAL")
+
+    def _open_configured_connection(self) -> sqlite3.Connection:
+        """Open a connection and apply pragmas, closing it if setup fails.
+
+        If a PRAGMA in ``_configure_connection`` raises, the just-opened
+        handle is closed before re-raising so it can't leak and lock the
+        .db/.db-wal/.db-shm files — the exact failure mode the connection
+        lifecycle elsewhere is careful to avoid (Windows WinError 32).
+        """
+        conn = sqlite3.connect(self.db_path, timeout=30.0)
+        try:
+            self._configure_connection(conn)
+        except BaseException:
+            conn.close()
+            raise
+        return conn
+
+    @contextmanager
+    def _get_connection(self) -> Generator[sqlite3.Connection, None, None]:
+        """Get a database connection with proper settings.
+
+        Inside a ``batch()`` scope this yields the shared connection without
+        closing it (the batch owns its lifecycle). Otherwise it opens a fresh
+        connection and closes it on exit — the default, Windows-safe behaviour
+        (no lingering file handle on the .db/.db-wal/.db-shm files).
+        """
+        if self._shared_conn is not None:
+            yield self._shared_conn
+            return
+
+        conn = self._open_configured_connection()
         try:
             yield conn
         finally:
             conn.close()
 
+    @contextmanager
+    def batch(self) -> Generator[None, None, None]:
+        """Reuse a single connection for every operation within the scope.
+
+        A full project build issues ~190 ``_get_connection`` calls; opening a
+        fresh SQLite connection each time dominates cache-build cost. Wrapping
+        the build in ``with cache_manager.batch():`` collapses those to one
+        connection.
+
+        Lifecycle guarantees (the risky part — see the integrity tests):
+        - The shared connection is **always closed on scope exit**, including
+          when the body raises (the ``finally``). This releases the file lock
+          on the .db/.db-wal/.db-shm files *before* any caller tears down a
+          TemporaryDirectory or runs ``clear_cache``/rmtree — critical on
+          Windows, which refuses to delete open files (WinError 32).
+        - Outside a batch, behaviour is unchanged (connection-per-call).
+        - Nesting is a no-op: an inner ``batch()`` reuses the outer connection
+          and does NOT close it, so the converter loop can't double-open or
+          close a connection still in use by an enclosing scope.
+        """
+        if self._shared_conn is not None:
+            # Already batching — reuse the existing shared connection and leave
+            # its lifecycle to the outermost batch().
+            yield
+            return
+
+        # Open+configure first; only publish to _shared_conn once setup has
+        # succeeded, so a failed PRAGMA never leaves a half-initialised (and
+        # now-closed) handle assigned for other calls to reuse.
+        conn = self._open_configured_connection()
+        self._shared_conn = conn
+        try:
+            yield
+        finally:
+            self._shared_conn = None
+            conn.close()
+
     def _init_database(self) -> None:
         """Create schema if needed using migration runner."""
-        # Run any pending migrations
+        key = str(self.db_path)
+        if key in _migrated_db_paths and self.db_path.exists():
+            return
         run_migrations(self.db_path)
+        _migrated_db_paths.add(key)
 
     def _ensure_project_exists(self) -> None:
         """Ensure project record exists and get its ID."""
@@ -471,18 +628,19 @@ class CacheManager:
 
         with self._get_connection() as conn:
             row = conn.execute(
-                "SELECT source_mtime FROM cached_files WHERE project_id = ? AND file_name = ?",
+                "SELECT source_mtime, subagents_fingerprint FROM cached_files"
+                " WHERE project_id = ? AND file_name = ?",
                 (self._project_id, jsonl_path.name),
             ).fetchone()
 
         if not row:
             return False
 
-        source_mtime = jsonl_path.stat().st_mtime
-        cached_mtime = row["source_mtime"]
-
-        # Cache is valid if modification times match (within 1 second tolerance)
-        return abs(source_mtime - cached_mtime) < 1.0
+        return _cache_row_is_fresh(
+            row,
+            jsonl_path.stat().st_mtime,
+            lambda: subagents_fingerprint(jsonl_path),
+        )
 
     def load_cached_entries(self, jsonl_path: Path) -> Optional[List[TranscriptEntry]]:
         """Load cached transcript entries for a JSONL file."""
@@ -564,14 +722,27 @@ class CacheManager:
         return [self._deserialize_entry(row) for row in rows]
 
     def save_cached_entries(
-        self, jsonl_path: Path, entries: List[TranscriptEntry]
+        self,
+        jsonl_path: Path,
+        entries: List[TranscriptEntry],
+        subagents_fp: Optional[str] = None,
     ) -> None:
-        """Save parsed transcript entries to cache."""
+        """Save parsed transcript entries to cache.
+
+        ``subagents_fp`` is the sidecar fingerprint AS OF THE PARSE —
+        callers that scanned sidecars should pass the value captured
+        before the scan, so a sidecar landing mid-parse mismatches on the
+        next read and forces a reparse (over-invalidation; computing it
+        here at save time would instead validate a parse that never saw
+        the late sidecar). Falls back to computing now when omitted.
+        """
         if self._project_id is None:
             return
 
         source_mtime = jsonl_path.stat().st_mtime
         cached_mtime = datetime.now().timestamp()
+        if subagents_fp is None:
+            subagents_fp = subagents_fingerprint(jsonl_path)
 
         with self._get_connection() as conn:
             # Insert or update file record
@@ -579,13 +750,15 @@ class CacheManager:
             conn.execute(
                 """
                 INSERT INTO cached_files
-                (project_id, file_name, file_path, source_mtime, cached_mtime, message_count)
-                VALUES (?, ?, ?, ?, ?, ?)
+                (project_id, file_name, file_path, source_mtime, cached_mtime,
+                 message_count, subagents_fingerprint)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT(project_id, file_name) DO UPDATE SET
                     file_path = excluded.file_path,
                     source_mtime = excluded.source_mtime,
                     cached_mtime = excluded.cached_mtime,
-                    message_count = excluded.message_count
+                    message_count = excluded.message_count,
+                    subagents_fingerprint = excluded.subagents_fingerprint
                 """,
                 (
                     self._project_id,
@@ -594,6 +767,7 @@ class CacheManager:
                     source_mtime,
                     cached_mtime,
                     len(entries),
+                    subagents_fp,
                 ),
             )
 
@@ -738,21 +912,82 @@ class CacheManager:
         if self._project_id is None:
             return []
 
+        with self._get_connection() as conn:
+            return self._get_working_directories(conn)
+
+    def _get_working_directories(self, conn: sqlite3.Connection) -> List[str]:
+        """get_working_directories() on an already-open connection."""
+        rows = conn.execute(
+            "SELECT DISTINCT cwd FROM sessions WHERE project_id = ? AND cwd IS NOT NULL",
+            (self._project_id,),
+        ).fetchall()
+        return [row["cwd"] for row in rows]
+
+    def get_modified_files(self, jsonl_files: List[Path]) -> List[Path]:
+        """Get list of JSONL files that need to be reprocessed.
+
+        Batched equivalent of calling is_file_cached() per file: one SQL
+        query fetches every cached row (one connection open instead of
+        one per file), and one scandir per parent directory rules out
+        subagent-sidecar fingerprints, replacing the per-file query +
+        directory probes that dominated freshness-check time on large
+        archives (issue #12).
+        """
+        if not jsonl_files:
+            return []
+        if self._project_id is None:
+            return list(jsonl_files)
+
         with self._get_connection() as conn:
             rows = conn.execute(
-                "SELECT DISTINCT cwd FROM sessions WHERE project_id = ? AND cwd IS NOT NULL",
+                "SELECT file_name, source_mtime, subagents_fingerprint"
+                " FROM cached_files WHERE project_id = ?",
                 (self._project_id,),
             ).fetchall()
+        cached = {row["file_name"]: row for row in rows}
+
+        # A session file's sidecars live under <parent>/<stem>/subagents,
+        # so one scandir of the parent tells us which files can have a
+        # non-empty fingerprint without any per-file stat probes.
+        subdir_names: Dict[Path, set[str]] = {}
+
+        def current_fp(jsonl_file: Path) -> str:
+            parent = jsonl_file.parent
+            if parent.name == "subagents":
+                # Agent file in a subagents dir: its sidecars sit next to
+                # it, so the full fingerprint scan is required.
+                return subagents_fingerprint(jsonl_file)
+            names = subdir_names.get(parent)
+            if names is None:
+                try:
+                    with os.scandir(parent) as entries:
+                        names = {e.name for e in entries if e.is_dir()}
+                except OSError:
+                    names = set[str]()
+                subdir_names[parent] = names
+            return subagents_fingerprint(jsonl_file) if jsonl_file.stem in names else ""
+
+        modified: List[Path] = []
+        for jsonl_file in jsonl_files:
+            row = cached.get(jsonl_file.name)
+            if row is None:
+                modified.append(jsonl_file)
+                continue
+
+            try:
+                source_mtime = jsonl_file.stat().st_mtime
+            except OSError:
+                # Missing file: same outcome as is_file_cached()'s
+                # exists() check returning False.
+                modified.append(jsonl_file)
+                continue
+
+            if not _cache_row_is_fresh(
+                row, source_mtime, lambda file=jsonl_file: current_fp(file)
+            ):
+                modified.append(jsonl_file)
 
-        return [row["cwd"] for row in rows]
-
-    def get_modified_files(self, jsonl_files: List[Path]) -> List[Path]:
-        """Get list of JSONL files that need to be reprocessed."""
-        return [
-            jsonl_file
-            for jsonl_file in jsonl_files
-            if not self.is_file_cached(jsonl_file)
-        ]
+        return modified
 
     def get_cached_project_data(self) -> Optional[ProjectCache]:
         """Get the cached project data if available."""
@@ -775,19 +1010,11 @@ class CacheManager:
 
             cached_files: Dict[str, CachedFileInfo] = {}
             for row in file_rows:
-                # Get session IDs for this file from messages
-                session_rows = conn.execute(
-                    "SELECT DISTINCT session_id FROM messages WHERE file_id = ? AND session_id IS NOT NULL",
-                    (row["id"],),
-                ).fetchall()
-                session_ids = [r["session_id"] for r in session_rows]
-
                 cached_files[row["file_name"]] = CachedFileInfo(
                     file_path=row["file_path"],
                     source_mtime=row["source_mtime"],
                     cached_mtime=row["cached_mtime"],
                     message_count=row["message_count"],
-                    session_ids=session_ids,
                 )
 
             # Get sessions
@@ -813,6 +1040,10 @@ class CacheManager:
                     team_name=row["team_name"] if "team_name" in row.keys() else None,
                 )
 
+            # On the same connection: calling the public method here
+            # would open a second connection per call.
+            working_directories = self._get_working_directories(conn)
+
         return ProjectCache(
             version=project_row["version"],
             cache_created=project_row["cache_created"],
@@ -825,7 +1056,7 @@ class CacheManager:
             total_cache_creation_tokens=project_row["total_cache_creation_tokens"],
             total_cache_read_tokens=project_row["total_cache_read_tokens"],
             sessions=sessions,
-            working_directories=self.get_working_directories(),
+            working_directories=working_directories,
             earliest_timestamp=project_row["earliest_timestamp"],
             latest_timestamp=project_row["latest_timestamp"],
         )
@@ -855,6 +1086,11 @@ class CacheManager:
             # JSONLs are re-ingested, so the project index keeps showing
             # the old session-id title until the cache is rebuilt.
             "1.2.0": "1.3.0",
+            # 1.5.0 filters <local-command-caveat>-wrapped caveat messages
+            # (Claude Code ≥ ~2.1) from session previews: caches built
+            # earlier have the caveat text baked into first_user_message
+            # for affected sessions.
+            "1.4.0": "1.5.0",
         }
 
         cache_ver = version.parse(cache_version)