cc-session-tools 2.2.0__tar.gz → 2.4.0__tar.gz

{cc_session_tools-2.2.0/src/cc_session_tools.egg-info → cc_session_tools-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 2.2.0
+Version: 2.4.0
 Summary: Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (cccs_hooks)
 Author: raffishquartan
 License: MIT License
@@ -144,6 +144,12 @@ It runs `ccst doctor` at the end so you can see the health check immediately. Re
 
 > **Note:** `install-everything.sh` handles steps 1–5 of setup. Step 6 — adding broader CCST guidance to your global `~/.claude/CLAUDE.md` (session management, 8-digit gate, etc.) — is interactive and must be run separately afterwards. See [Configure your global CLAUDE.md](#configure-your-global-claudemd) below.
 
+> **After upgrading** (`uv tool install --reinstall`/`--upgrade`, or `pip`/`pipx` equivalents):
+> re-run `ccst install-everything --apply` so skills/hooks/shell functions/scheduled jobs stay in
+> sync with the new version. If you forget, `ccst` itself will remind you — any interactive
+> command run from a real terminal on a version that hasn't been synced prints a nudge and exits
+> until you do (automated callers like Claude Code's own hooks are never affected).
+
 **Manual path — step by step:**
 
 ```sh
@@ -884,14 +890,19 @@ ccst claude-md uninstall --apply
 
 Run a full health check: PATH for all six CLIs, env vars (`REPO_ROOT`/`PROJ_ROOT`),
 `~/.claude/settings.json` JSON validity, expected hook registrations present,
-skill symlinks correct and pointing at the installed source, version drift
-between installed `ccst` and the latest release on PyPI.
+skill symlinks correct and pointing at the installed source, whether
+`install-everything --apply` has been run for the currently-installed version,
+and version drift between installed `ccst` and the latest release on PyPI.
 
 ```sh
 ccst doctor           # checks everything, including PyPI version check
 ccst doctor --no-pypi # skip the network version check (useful in CI)
+ccst doctor --all     # also print OK checks (default: only WARN/FAIL)
 ```
 
+By default only WARN/FAIL results are printed — a clean machine is otherwise dozens of `[OK]`
+lines to scroll past. Use `--all` to see the full check list, including everything that passed.
+
 Exit `0` if all checks are OK. Exit `1` if any check is WARN or FAIL.
 
 ### `ccst telemetry trim`

{cc_session_tools-2.2.0 → cc_session_tools-2.4.0}/README.md

@@ -87,6 +87,12 @@ It runs `ccst doctor` at the end so you can see the health check immediately. Re
 
 > **Note:** `install-everything.sh` handles steps 1–5 of setup. Step 6 — adding broader CCST guidance to your global `~/.claude/CLAUDE.md` (session management, 8-digit gate, etc.) — is interactive and must be run separately afterwards. See [Configure your global CLAUDE.md](#configure-your-global-claudemd) below.
 
+> **After upgrading** (`uv tool install --reinstall`/`--upgrade`, or `pip`/`pipx` equivalents):
+> re-run `ccst install-everything --apply` so skills/hooks/shell functions/scheduled jobs stay in
+> sync with the new version. If you forget, `ccst` itself will remind you — any interactive
+> command run from a real terminal on a version that hasn't been synced prints a nudge and exits
+> until you do (automated callers like Claude Code's own hooks are never affected).
+
 **Manual path — step by step:**
 
 ```sh
@@ -827,14 +833,19 @@ ccst claude-md uninstall --apply
 
 Run a full health check: PATH for all six CLIs, env vars (`REPO_ROOT`/`PROJ_ROOT`),
 `~/.claude/settings.json` JSON validity, expected hook registrations present,
-skill symlinks correct and pointing at the installed source, version drift
-between installed `ccst` and the latest release on PyPI.
+skill symlinks correct and pointing at the installed source, whether
+`install-everything --apply` has been run for the currently-installed version,
+and version drift between installed `ccst` and the latest release on PyPI.
 
 ```sh
 ccst doctor           # checks everything, including PyPI version check
 ccst doctor --no-pypi # skip the network version check (useful in CI)
+ccst doctor --all     # also print OK checks (default: only WARN/FAIL)
 ```
 
+By default only WARN/FAIL results are printed — a clean machine is otherwise dozens of `[OK]`
+lines to scroll past. Use `--all` to see the full check list, including everything that passed.
+
 Exit `0` if all checks are OK. Exit `1` if any check is WARN or FAIL.
 
 ### `ccst telemetry trim`

{cc_session_tools-2.2.0 → cc_session_tools-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cc-session-tools"
-version = "2.2.0"
+version = "2.4.0"
 description = "Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (cccs_hooks)"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -55,12 +55,24 @@ cccs-stats = "cccs_hooks.stats:main"
 
 [tool.setuptools.packages.find]
 where = ["src"]
+# skills/ and config/ are bundled data, not importable code - without this
+# exclude, setuptools' auto-discovery treats every skills/<name>/ subdirectory
+# containing a .py file (scripts, dev-only test suites) as its own importable
+# sub-package, which then bypasses exclude-package-data entirely (that option
+# only filters within the file's *own* discovered package, and a wrongly
+# auto-discovered "cc_session_tools.skills.<name>.tests" package was never
+# covered by an exclude-package-data entry keyed just "cc_session_tools").
+exclude = ["cc_session_tools.skills", "cc_session_tools.skills.*", "cc_session_tools.config", "cc_session_tools.config.*"]
 
 [tool.setuptools.package-data]
 claude_code_usage = ["data/*.json"]
+cc_session_tools = ["skills/**/*", "config/*"]
+
+[tool.setuptools.exclude-package-data]
+cc_session_tools = ["**/tests/*", "**/__pycache__/*"]
 
 [tool.pytest.ini_options]
-testpaths = ["tests", "tests/scheduler", "skills/move-session/tests", "skills/list-empty-sessions/tests", "skills/delete-sessions/tests", "skills/generate-8digit-code/tests", "skills/reduce-persistent-context/tests", "skills/update-command-cache/tests"]
+testpaths = ["tests", "tests/scheduler", "src/cc_session_tools/skills/move-session/tests", "src/cc_session_tools/skills/list-empty-sessions/tests", "src/cc_session_tools/skills/delete-sessions/tests", "src/cc_session_tools/skills/generate-8digit-code/tests", "src/cc_session_tools/skills/reduce-persistent-context/tests", "src/cc_session_tools/skills/update-command-cache/tests"]
 addopts = "-q"
 pythonpath = ["src"]
 

{cc_session_tools-2.2.0 → cc_session_tools-2.4.0}/src/cc_session_tools/cli/ccst.py

@@ -88,17 +88,15 @@ from cc_session_tools.lib.hook_registry import HOOK_DESCRIPTIONS, HOOK_VERBS
 def _discover_source_dir() -> Path:
     """Return the bundled skills/ directory.
 
-    Walk up from this module's file to find the repo root containing skills/.
-    Falls back to ~/repos/claude-code-session-tools/skills/ for wheel installs.
+    skills/ is packaged inside cc_session_tools (declared as package-data in
+    pyproject.toml), so it sits at the same relative depth from this module
+    whether cc_session_tools is an editable source checkout or an installed
+    wheel: src/cc_session_tools/cli/ccst.py -> ../skills. No install-location
+    fallback is needed - a fallback here would just mask a broken install.
     """
-    # From src/cc_session_tools/cli/ccst.py walk up: cli/ -> cc_session_tools/ -> src/ -> repo root
-    here = Path(__file__).resolve()
-    candidate = here.parent.parent.parent.parent / "skills"
+    candidate = Path(__file__).resolve().parent.parent / "skills"
     if candidate.is_dir():
         return candidate
-    fallback = Path.home() / "repos" / "claude-code-session-tools" / "skills"
-    if fallback.is_dir():
-        return fallback
     raise FileNotFoundError(
         "Cannot locate bundled skills/ directory. "
         "Run from the source tree or use --source to specify the path explicitly."
@@ -108,18 +106,12 @@ def _discover_source_dir() -> Path:
 def _discover_bundle() -> Path:
     """Return the bundled config/hooks-bundle.json path.
 
-    Walk up from this module's file to find the repo root containing config/.
-    Falls back to ~/repos/claude-code-session-tools/config/... for wheel installs.
+    config/ is packaged inside cc_session_tools the same way skills/ is (see
+    _discover_source_dir) - src/cc_session_tools/cli/ccst.py -> ../config.
     """
-    here = Path(__file__).resolve()
-    candidate = here.parent.parent.parent.parent / "config" / "hooks-bundle.json"
+    candidate = Path(__file__).resolve().parent.parent / "config" / "hooks-bundle.json"
     if candidate.is_file():
         return candidate
-    fallback = (
-        Path.home() / "repos" / "claude-code-session-tools" / "config" / "hooks-bundle.json"
-    )
-    if fallback.is_file():
-        return fallback
     raise FileNotFoundError(
         "Cannot locate bundled config/hooks-bundle.json. "
         "Run from the source tree or use --source to specify the path explicitly."
@@ -661,6 +653,7 @@ def _cmd_doctor(args: argparse.Namespace) -> int:
 
     from cc_session_tools.lib.pdata import verify as _pdata_verify
     from cc_session_tools.lib.pdata.init_paths import default_projects_root
+    from cc_session_tools.lib import install_sync
 
     results = run_all_checks(
         installed_version=__version__,
@@ -675,6 +668,7 @@ def _cmd_doctor(args: argparse.Namespace) -> int:
         projects_root=default_projects_root(),
         pdata_verify_projects=_pdata_verify.discover_projects(),
         sessions_db_path=store_paths["sessions"],
+        synced_version=install_sync.get_synced_version(),
     )
 
     if args.drift or getattr(args, "mode", None) == "drift":
@@ -685,7 +679,7 @@ def _cmd_doctor(args: argparse.Namespace) -> int:
             print(report)
         return 1 if unmuted else 0
 
-    print(format_results(results))
+    print(format_results(results, show_all=getattr(args, "all", False)))
 
     any_issue = any(r.status in (Status.WARN, Status.FAIL) for r in results)
     return 1 if any_issue else 0
@@ -1247,6 +1241,8 @@ def _cmd_sessions_list(args: argparse.Namespace) -> int:
 
 
 def _cmd_repair_sessions(args: argparse.Namespace) -> int:
+    import sqlite3
+
     from cc_session_tools.lib import db as db_lib
     from cc_session_tools.lib import sessions_db, sessions_repair
     from cc_session_tools.lib.roots import RootsConfigError, load_session_roots
@@ -1258,21 +1254,32 @@ def _cmd_repair_sessions(args: argparse.Namespace) -> int:
         print(str(e), file=sys.stderr)
         return 1
 
-    if args.execute:
-        if not db_path.exists():
-            # sqlite3.connect() auto-creates an empty file, so without this check
-            # db_lib.backup_to() below would silently back up (and repair() would open)
-            # a brand-new, empty sessions.db instead of failing loudly on the mistake.
-            print(f"No sessions.db found at {db_path} — nothing to back up or repair.", file=sys.stderr)
-            return 1
-        backup_dir = db_path.parent / "repair-backups"
-        backup_dir.mkdir(parents=True, exist_ok=True)
-        stamp = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
-        backup_path = backup_dir / f"sessions-{stamp}.db"
-        db_lib.backup_to(db_path, backup_path)
-        print(f"Backed up sessions.db to {backup_path}")
-
-    report = sessions_repair.repair(roots, path=db_path, dry_run=not args.execute)
+    # sqlite3.connect() (and the online backup API below) open lazily and
+    # only fail once a statement actually touches the file, so a corrupt-
+    # but-existing sessions.db reaches this try, not the exists() check
+    # above. This is the tool users are told to run to fix store corruption
+    # - both the backup step and the repair itself must fail loudly with a
+    # clear message here, not a raw traceback.
+    try:
+        if args.execute:
+            if not db_path.exists():
+                # sqlite3.connect() auto-creates an empty file, so without this
+                # check db_lib.backup_to() below would silently back up (and
+                # repair() would open) a brand-new, empty sessions.db instead
+                # of failing loudly on the mistake.
+                print(f"No sessions.db found at {db_path} — nothing to back up or repair.", file=sys.stderr)
+                return 1
+            backup_dir = db_path.parent / "repair-backups"
+            backup_dir.mkdir(parents=True, exist_ok=True)
+            stamp = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+            backup_path = backup_dir / f"sessions-{stamp}.db"
+            db_lib.backup_to(db_path, backup_path)
+            print(f"Backed up sessions.db to {backup_path}")
+
+        report = sessions_repair.repair(roots, path=db_path, dry_run=not args.execute)
+    except sqlite3.DatabaseError as exc:
+        print(f"{db_path} exists but failed to open: {exc}", file=sys.stderr)
+        return 1
     if not any((report.repaired, report.unresolved, report.ambiguous, report.conflicts)):
         print("No non-absolute project_dir rows found in sessions.db.")
         return 0
@@ -1494,6 +1501,27 @@ def _cmd_install_everything(args: argparse.Namespace) -> int:
         if rc != 0:
             overall_rc = rc
 
+    if apply and overall_rc == 0:
+        import sqlite3
+
+        from cc_session_tools.lib import install_sync
+        try:
+            install_sync.record_synced(__version__)
+        except sqlite3.DatabaseError as exc:
+            # A corrupt sessions.db must not erase the five install steps'
+            # already-successful work (and their printed summary) that ran
+            # just above - print a clear warning and continue to the health
+            # check, which surfaces store corruption of its own accord.
+            # Letting this propagate would also be self-defeating: this is
+            # the exact command the interactive gate (main()) tells a user
+            # to run to fix an out-of-sync install.
+            print(
+                f"  warning: could not record the install-everything sync marker "
+                f"({exc}) - sessions.db may be corrupt; run `ccst repair sessions` "
+                "to investigate",
+                file=sys.stderr,
+            )
+
     print(f"\n=== {total_steps}/{total_steps}  Health check ===")
     _cmd_doctor(
         argparse.Namespace(
@@ -1682,6 +1710,11 @@ def _build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Skip the PyPI version-drift check",
     )
+    doctor_parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Show every check result, including OK (default: only non-OK)",
+    )
     doctor_parser.add_argument(
         "--drift",
         action="store_true",
@@ -2189,6 +2222,37 @@ def main() -> None:
         parser.print_help(sys.stderr)
         sys.exit(1)
 
+    from cc_session_tools.lib import install_sync
+
+    is_interactive = sys.stderr.isatty()
+    # Read the marker only when interactive: `ccst hooks run <verb>` fires on
+    # every single tool call in every open Claude Code session, and ccsched
+    # jobs run on a schedule - neither has a TTY on stderr, and neither
+    # should pay a SQLite open/close on every invocation just to compute a
+    # value should_block_for_unsynced_install would immediately discard
+    # anyway (its own is_interactive=False check returns False before ever
+    # looking at synced_version).
+    synced_version = install_sync.get_synced_version() if is_interactive else None
+    if install_sync.should_block_for_unsynced_install(
+        noun=args.noun,
+        verb=getattr(args, "verb", None),
+        installed_version=__version__,
+        synced_version=synced_version,
+        is_interactive=is_interactive,
+    ):
+        if synced_version is None:
+            state = "install-everything has never been run for this installation"
+        else:
+            state = f"install-everything was last synced at {synced_version}"
+        print(
+            f"ccst is installed at {__version__}, but {state}.\n"
+            "Skills, hooks, shell functions, scheduled jobs, and CLAUDE.md config may be "
+            "out of sync with this version.\n\n"
+            "Run: ccst install-everything --apply\n",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
     if args.noun == "hooks":
         if args.verb == "install":
             sys.exit(_cmd_hooks_install(args))

cc_session_tools-2.4.0/src/cc_session_tools/config/hooks-bundle.json

@@ -0,0 +1,118 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "ccst hooks run session-tag",
+            "timeout": 5,
+            "statusMessage": "Checking cc wrapper session tag..."
+          },
+          {
+            "type": "command",
+            "command": "ccst hooks run messaging-deliver",
+            "timeout": 10,
+            "statusMessage": "Delivering inter-session messages..."
+          },
+          {
+            "type": "command",
+            "command": "ccst hooks run catchup",
+            "timeout": 10,
+            "statusMessage": "Reconciling scheduled-task catch-up..."
+          },
+          {
+            "type": "command",
+            "command": "ccst hooks run pending-migration",
+            "timeout": 5,
+            "statusMessage": "Checking for unmigrated legacy data stores..."
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "ccst hooks run last-screenshot",
+            "timeout": 5,
+            "statusMessage": "Resolving latest screenshot for >lss..."
+          },
+          {
+            "type": "command",
+            "command": "ccst hooks run messaging-deliver",
+            "timeout": 10,
+            "statusMessage": "Checking for new inter-session messages..."
+          },
+          {
+            "type": "command",
+            "command": "ccst hooks run catchup",
+            "timeout": 10,
+            "statusMessage": "Surfacing scheduled-task catch-up..."
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "ccst hooks run bash-hard-deny",
+            "timeout": 5,
+            "statusMessage": "Checking Bash command against hard-deny rules..."
+          },
+          {
+            "type": "command",
+            "command": "ccst hooks run marker-allow",
+            "timeout": 5,
+            "statusMessage": "Checking for skill-marker touch..."
+          },
+          {
+            "type": "command",
+            "command": "ccst hooks run bash-security-review",
+            "timeout": 30,
+            "statusMessage": "Reviewing shell command for security risks..."
+          }
+        ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "ccst hooks run confirm-8digit",
+            "timeout": 10,
+            "statusMessage": "Checking 8-digit confirmation gate..."
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "ccst hooks run after-response",
+            "timeout": 10,
+            "statusMessage": "Recording session activity..."
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "manual",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "ccst hooks run worklog-guard",
+            "timeout": 5,
+            "statusMessage": "Checking WORKLOG.md freshness..."
+          }
+        ]
+      }
+    ]
+  }
+}

cc_session_tools-2.4.0/src/cc_session_tools/config/session-tag-hook.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "ccst hooks run session-tag",
+            "timeout": 5,
+            "statusMessage": "Writing session tag file..."
+          }
+        ]
+      }
+    ]
+  }
+}

{cc_session_tools-2.2.0 → cc_session_tools-2.4.0}/src/cc_session_tools/lib/doctor.py

@@ -293,6 +293,36 @@ def check_pypi_version(installed_version: str, timeout: float = 3.0) -> CheckRes
         )
 
 
+def check_install_everything_synced(
+    installed_version: str, synced_version: str | None
+) -> CheckResult:
+    """WARN (not FAIL - always self-recoverable with one command, same
+    severity rationale as check_ccsched_job_registered) if the running ccst
+    version doesn't match the version 'install-everything --apply' last
+    succeeded for."""
+    name = "install:synced"
+    if synced_version == installed_version:
+        return CheckResult(
+            name=name, status=Status.OK,
+            reason=f"install-everything last synced at {installed_version}",
+        )
+    if synced_version is None:
+        return CheckResult(
+            name=name, status=Status.WARN,
+            reason=(
+                f"installed {installed_version}, install-everything has never been run — "
+                "run `ccst install-everything --apply`"
+            ),
+        )
+    return CheckResult(
+        name=name, status=Status.WARN,
+        reason=(
+            f"installed {installed_version}, install-everything last synced at "
+            f"{synced_version} — run `ccst install-everything --apply`"
+        ),
+    )
+
+
 def _version_tuple(v: str) -> tuple[int, ...]:
     """Parse a simple a.b.c version string into a comparable tuple."""
     parts: list[int] = []
@@ -454,7 +484,13 @@ def _count_new_store_rows(db_path: Path, tables: tuple[str, ...]) -> int:
         for table in tables:
             try:
                 total += int(conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0])
-            except sqlite3.OperationalError:
+            except sqlite3.DatabaseError:
+                # sqlite3.OperationalError ("no such table") is the common
+                # case; a corrupt file also reaches here, not the connect()
+                # guard above, because sqlite3.connect() opens lazily and
+                # only fails once a statement actually touches the file —
+                # both count as "can't be opened" per this function's
+                # contract, so both return 0 rather than raising.
                 continue
         return total
     finally:
@@ -683,10 +719,24 @@ def check_sessions_project_dir_absolute(sessions_db_path: Path) -> list[CheckRes
     project_dir.parent against a resolved, absolute root — a relative project_dir can
     never match, so the row becomes permanently invisible to --global listings without
     ever raising an error. Not FAIL: it degrades --global listings but does not block
-    core functionality, and `ccst repair sessions` fixes it non-destructively."""
+    core functionality, and `ccst repair sessions` fixes it non-destructively.
+
+    FAILs instead if sessions.db exists but isn't a valid SQLite file — same
+    "exists but failed to open" treatment check_data_stores already gives
+    this exact condition for other stores; sqlite3.connect() opens lazily
+    and only fails once find_non_absolute_rows actually queries the file, so
+    this must be caught here rather than assumed impossible."""
+    import sqlite3
+
     from cc_session_tools.lib import sessions_repair
 
-    bad = sessions_repair.find_non_absolute_rows(path=sessions_db_path)
+    try:
+        bad = sessions_repair.find_non_absolute_rows(path=sessions_db_path)
+    except sqlite3.DatabaseError as exc:
+        return [CheckResult(
+            name="sessions:project-dir-absolute", status=Status.FAIL,
+            reason=f"{sessions_db_path} exists but failed to open: {exc}",
+        )]
     if not bad:
         return [CheckResult(
             name="sessions:project-dir-absolute", status=Status.OK,
@@ -719,6 +769,7 @@ def run_all_checks(
     projects_root: Path | None = None,
     pdata_verify_projects: list[str] | None = None,
     sessions_db_path: Path | None = None,
+    synced_version: str | None = None,
 ) -> list[CheckResult]:
     """Run the full doctor suite and return results.
 
@@ -755,6 +806,9 @@ def run_all_checks(
     sessions_db_path:
         Path to sessions.db; when None, the project_dir-absolute check is
         skipped.
+    synced_version:
+        The version ``install-everything --apply`` last succeeded for, or
+        None if it has never been recorded.
     """
     results: list[CheckResult] = []
 
@@ -831,6 +885,11 @@ def run_all_checks(
     if not skip_pypi:
         results.append(check_pypi_version(installed_version))
 
+    # Install-everything sync state
+    results.append(
+        check_install_everything_synced(installed_version, synced_version)
+    )
+
     return results
 
 
@@ -860,17 +919,30 @@ def _extract_bundle_hook_names(bundle_path: Path) -> list[str]:
     return names
 
 
-def format_results(results: list[CheckResult]) -> str:
-    """Return a human-readable table of check results."""
+def format_results(results: list[CheckResult], *, show_all: bool = False) -> str:
+    """Return a human-readable table of check results.
+
+    By default (show_all=False) only WARN/FAIL results are printed, with a
+    hint on how to see the rest — a clean machine's `ccst doctor` output is
+    otherwise dozens of [OK] lines a user has to scroll past to find the one
+    thing that needs attention. show_all=True reproduces the full table this
+    function always printed before this parameter existed.
+    """
     if not results:
         return "(no checks ran)"
-    name_w = max(len(r.name) for r in results)
+    shown = results if show_all else [r for r in results if r.status is not Status.OK]
     lines = []
-    for r in results:
-        lines.append(f"[{r.status.value:<4}] {r.name:<{name_w}}  {r.reason}")
+    if shown:
+        name_w = max(len(r.name) for r in shown)
+        for r in shown:
+            lines.append(f"[{r.status.value:<4}] {r.name:<{name_w}}  {r.reason}")
+    elif not show_all:
+        lines.append(f"All {len(results)} checks OK.")
     has_issues = any(r.status in (Status.WARN, Status.FAIL) for r in results)
     if has_issues:
         lines.append("\nTip: run `ccst install-everything --apply` to sync skills, hooks, shell, and CLAUDE.md")
+    if not show_all:
+        lines.append("\nTo see full doctor output use --all argument")
     return "\n".join(lines)
 
 

{cc_session_tools-2.2.0 → cc_session_tools-2.4.0}/src/cc_session_tools/lib/doctor_mutes.py

@@ -25,7 +25,16 @@ def default_mutes_path() -> Path:
 
 def load_mutes(path: Path) -> dict[str, str]:
     """Return the mute map (check name -> ISO date). Empty if the store has
-    never been written to."""
+    never been written to, or is corrupt.
+
+    connect(readonly=True) skips DDL by design, so a sessions.db that
+    predates the doctor_mutes table reaches the SELECT and must be caught
+    there too, not just around connect() itself - and connect() opens
+    lazily, so a corrupt (not-a-valid-SQLite-file) db only fails on the
+    SELECT as sqlite3.DatabaseError, not on connect() as OperationalError.
+    `ccst doctor --list-mutes`/`--drift` must never crash on this - doctor
+    is exempt from the install-sync gate specifically so it always works.
+    """
     try:
         conn = sessions_db.connect(path=path, readonly=True)
     except sqlite3.OperationalError:
@@ -33,6 +42,8 @@ def load_mutes(path: Path) -> dict[str, str]:
     try:
         rows = conn.execute("SELECT name, muted_at FROM doctor_mutes").fetchall()
         return {r["name"]: r["muted_at"] for r in rows}
+    except sqlite3.DatabaseError:
+        return {}
     finally:
         conn.close()