cctally 1.75.0 → 1.75.1

package/CHANGELOG.md

@@ -5,6 +5,12 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.75.1] - 2026-07-20
+
+### Fixed
+- Database repair now rejects an SQLite shell without functional `.recover` support before creating a forensic copy, explains the required `SQLITE_ENABLE_DBPAGE_VTAB` capability, and runs its public Linux recovery tests against a checksum-pinned official SQLite shell instead of Ubuntu's incompatible distro build.
+- Automatic transcript-space reclamation now drives zero-column `incremental_vacuum` pragmas through SQLite's completion path in bounded, progress-checked chunks, fixing the Python 3.11/Linux case that could leave freed pages on the freelist after retention pruning.
+
 ## [1.75.0] - 2026-07-20
 
 ### Added

package/bin/_cctally_db.py

@@ -6411,6 +6411,25 @@ def _run_sqlite_recover(
     return True, ""
 
 
+def _probe_sqlite_recover(sqlite_binary: str) -> "tuple[bool, str]":
+    """Prove the selected shell has a functional ``.recover`` command."""
+    try:
+        probe = subprocess.run(
+            [sqlite_binary, ":memory:", ".recover"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=False,
+        )
+    except OSError as exc:
+        return False, str(exc)
+    stderr = probe.stderr.decode("utf-8", "replace").strip()
+    if probe.returncode != 0:
+        return False, stderr or f"sqlite3 .recover probe exited {probe.returncode}"
+    if b"BEGIN;" not in probe.stdout or b"COMMIT;" not in probe.stdout:
+        return False, stderr or "sqlite3 .recover probe produced incomplete SQL"
+    return True, ""
+
+
 def _repair_preflight_and_copy(
     path: pathlib.Path,
     backup: pathlib.Path,
@@ -6549,6 +6568,28 @@ def _cmd_db_repair_claimed(args: argparse.Namespace, path: pathlib.Path) -> int:
     """Repair body; caller owns the marker and has proved no old handles."""
 
     timeout_ms = int(getattr(args, "busy_timeout_ms", 250) or 250)
+    sqlite_binary = (
+        getattr(args, "sqlite3_binary", None) or shutil.which("sqlite3")
+    )
+    if not sqlite_binary:
+        eprint(
+            "cctally: db repair requires the sqlite3 command-line tool for "
+            'its corruption-tolerant ".recover" operation. The live DB is '
+            "untouched and no corrupt backup was created."
+        )
+        return 3
+    recover_supported, recover_reason = _probe_sqlite_recover(
+        str(sqlite_binary)
+    )
+    if not recover_supported:
+        eprint(
+            "cctally: the selected sqlite3 build does not support SQLite "
+            f".recover ({recover_reason}). Install the official sqlite.org "
+            "CLI built with SQLITE_ENABLE_DBPAGE_VTAB. The live DB is "
+            "untouched and no corrupt backup was created."
+        )
+        return 3
+
     stamp = _db_backup_timestamp()
     backup = _unique_sibling_path(
         path.with_name(f"{path.name}.bak-corrupt-malformed-{stamp}")
@@ -6623,18 +6664,6 @@ def _cmd_db_repair_claimed(args: argparse.Namespace, path: pathlib.Path) -> int:
             close_guard()
             return 3
 
-        sqlite_binary = (
-            getattr(args, "sqlite3_binary", None) or shutil.which("sqlite3")
-        )
-        if not sqlite_binary:
-            eprint(
-                "cctally: db repair requires the sqlite3 command-line tool for "
-                'its corruption-tolerant ".recover" operation. The live DB is '
-                f"untouched and the corrupt backup is {backup}."
-            )
-            close_guard()
-            return 3
-
         ok, reason = _run_sqlite_recover(
             str(sqlite_binary), snapshot, recovered_path, scratch
         )

package/bin/_lib_conversation_retention.py

@@ -197,6 +197,27 @@ def _stamp_retention_prune(conn: sqlite3.Connection, now_utc: dt.datetime) -> No
     )
 
 
+def _reclaim_incremental_vacuum(conn: sqlite3.Connection) -> None:
+    """Drive zero-column incremental-vacuum rows to completion portably."""
+    remaining = int(conn.execute("PRAGMA freelist_count").fetchone()[0])
+    if remaining <= 0:
+        return
+    chunk_pages = 4096
+    max_passes = (remaining + chunk_pages - 1) // chunk_pages + 1
+    for _ in range(max_passes):
+        requested = min(remaining, chunk_pages)
+        # executescript() routes through sqlite3_exec(), which steps zero-column
+        # pragma rows through SQLITE_DONE on Python/SQLite combinations where a
+        # Cursor.fetchall() can stop after the first row (public Linux 3.11).
+        conn.executescript(f"PRAGMA incremental_vacuum({requested});")
+        after = int(conn.execute("PRAGMA freelist_count").fetchone()[0])
+        if after <= 0:
+            return
+        if after >= remaining:
+            return
+        remaining = after
+
+
 def _maybe_prune_conversation_retention(
     conn: sqlite3.Connection,
     *,
@@ -271,12 +292,11 @@ def _maybe_prune_conversation_retention(
                 # already-durable prune.
                 if stats.total_rows > 0:
                     try:
-                        # `.fetchall()` drives the pragma to completion — a bare
-                        # execute() steps it once and reclaims a single page. This
-                        # clears the freelist and drops page_count; the physical
-                        # file shrinks on the next `wal_checkpoint(TRUNCATE)` the
-                        # sync loop already forces (#297).
-                        conn.execute("PRAGMA incremental_vacuum").fetchall()
+                        # Use the sqlite3_exec path and verify progress between
+                        # bounded chunks. This clears the freelist and drops
+                        # page_count; the physical file shrinks on the next
+                        # `wal_checkpoint(TRUNCATE)` the sync loop forces (#297).
+                        _reclaim_incremental_vacuum(conn)
                     except sqlite3.Error:
                         pass
                 return stats

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cctally",
-  "version": "1.75.0",
+  "version": "1.75.1",
   "description": "Claude Code usage tracker and local dashboard for Pro/Max subscription limits - weekly cost-per-percent trend, quota forecasts, threshold alerts. ccusage-compatible.",
   "homepage": "https://github.com/omrikais/cctally",
   "repository": {