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

{cc_session_tools-2.3.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.3.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.3.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.3.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.3.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" }

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

@@ -653,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__,
@@ -667,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":
@@ -677,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
@@ -1239,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
@@ -1250,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
@@ -1486,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(
@@ -1674,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",
@@ -2181,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.3.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.3.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()
 

cc_session_tools-2.4.0/src/cc_session_tools/lib/install_sync.py

@@ -0,0 +1,103 @@
+"""Tracks the last ccst version for which `ccst install-everything --apply`
+succeeded — lets `main()` nudge an interactive user to re-run it after an
+upgrade, and lets `ccst doctor` report the same fact as a check result.
+
+Backed by the install_sync table in sessions.db, following the same
+established pattern as doctor_mutes.py (see its module docstring and
+sessions_db.py's): small persistent CLI state belongs in the shared
+sessions.db file, not a bespoke JSON/db file per subsystem.
+"""
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from cc_session_tools.lib import sessions_db
+
+_SYNCED_VERSION_KEY = "synced_version"
+
+
+def get_synced_version(*, path: Path | None = None) -> str | None:
+    """Return the version `install-everything --apply` last succeeded for,
+    or None if it has never been recorded.
+
+    Covers three distinct states, all returning None: no sessions.db file at
+    all (fresh machine); a sessions.db that predates this table (every
+    existing installation upgrading to the version that ships this feature —
+    session_tags/sessions/doctor_mutes already exist, but install_sync
+    doesn't yet — connect(readonly=True) skips DDL by design, since it must
+    not create/migrate a store it's only meant to read, so this case reaches
+    the SELECT and must be caught there too, not just around connect()
+    itself); and a sessions.db that is corrupt/not a valid SQLite file at
+    all, which callers of this function (main()'s interactive gate among
+    them) must be able to survive without crashing - a corrupt db is
+    reported the same as "never synced" rather than propagating an
+    exception. sqlite3.DatabaseError is the shared parent of
+    OperationalError ("no such table") and the corrupt-file case, so
+    catching it alone covers both without a second except clause.
+    """
+    try:
+        conn = sessions_db.connect(path=path, readonly=True)
+    except sqlite3.OperationalError:
+        return None
+    try:
+        row = conn.execute(
+            "SELECT value FROM install_sync WHERE key = ?", (_SYNCED_VERSION_KEY,)
+        ).fetchone()
+        return row["value"] if row is not None else None
+    except sqlite3.DatabaseError:
+        return None  # "no such table: install_sync" (pre-upgrade db) or a corrupt file
+    finally:
+        conn.close()
+
+
+_EXEMPT_NOUNS = frozenset({"install-everything", "doctor", "repair", "migrate"})
+
+
+def should_block_for_unsynced_install(
+    *,
+    noun: str | None,
+    verb: str | None,
+    installed_version: str,
+    synced_version: str | None,
+    is_interactive: bool,
+) -> bool:
+    """True if main() should abort this invocation with an install-everything
+    nudge instead of dispatching it.
+
+    is_interactive must be False for every automated caller (a Claude Code
+    hook via `ccst hooks run`, a ccsched job, any future scheduled/scripted
+    caller) - this is the primary safety property, checked first. Exempt
+    nouns are never blocked regardless of interactivity, so the user always
+    has a way to see or fix the state this function is protecting against:
+    install-everything (the fix), doctor (the diagnostic tool), repair
+    ("Repair known sessions.db/store corruption" - the exact tool needed
+    when the sync marker's own store is what's broken), and migrate (this
+    repo's own doctor output tells users to run `ccst migrate all` "from a
+    plain terminal" when a legacy-data migration is pending - blocking that
+    instruction would be self-defeating). `hooks run` is additionally exempt
+    by name, belt-and-braces alongside is_interactive always being False for
+    it in practice - the one path this function must never block under any
+    circumstance.
+    """
+    if not is_interactive:
+        return False
+    if noun in _EXEMPT_NOUNS:
+        return False
+    if noun == "hooks" and verb == "run":
+        return False
+    return synced_version != installed_version
+
+
+def record_synced(version: str, *, path: Path | None = None) -> None:
+    """Record that `install-everything --apply` just succeeded for `version`."""
+    conn = sessions_db.connect(path=path)
+    try:
+        conn.execute(
+            "INSERT INTO install_sync (key, value, updated_at) VALUES (?, ?, ?) "
+            "ON CONFLICT(key) DO UPDATE SET value=excluded.value, updated_at=excluded.updated_at",
+            (_SYNCED_VERSION_KEY, version, sessions_db._now_iso()),
+        )
+        conn.commit()
+    finally:
+        conn.close()

{cc_session_tools-2.3.0 → cc_session_tools-2.4.0}/src/cc_session_tools/lib/sessions_db.py

@@ -57,6 +57,12 @@ CREATE TABLE IF NOT EXISTS doctor_mutes (
     name     TEXT PRIMARY KEY,
     muted_at TEXT NOT NULL
 );
+
+CREATE TABLE IF NOT EXISTS install_sync (
+    key        TEXT PRIMARY KEY,
+    value      TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
 """
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 2.3.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.3.0 → cc_session_tools-2.4.0}/src/cc_session_tools.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ src/cc_session_tools/lib/debug.py
 src/cc_session_tools/lib/doctor.py
 src/cc_session_tools/lib/doctor_mutes.py
 src/cc_session_tools/lib/hook_registry.py
+src/cc_session_tools/lib/install_sync.py
 src/cc_session_tools/lib/levenshtein.py
 src/cc_session_tools/lib/paths.py
 src/cc_session_tools/lib/picker.py
@@ -173,6 +174,7 @@ tests/test_ccst_hooks_install_prune.py
 tests/test_ccst_hooks_install_zero_arg.py
 tests/test_ccst_hooks_uninstall.py
 tests/test_ccst_install_everything.py
+tests/test_ccst_main_gate.py
 tests/test_ccst_pdata_cli.py
 tests/test_ccst_pdata_init_cli.py
 tests/test_ccst_pdata_reconcile_cli.py
@@ -200,6 +202,7 @@ tests/test_doctor_mutes.py
 tests/test_empty_session.py
 tests/test_hook_cache.py
 tests/test_hooks_install.py
+tests/test_install_sync.py
 tests/test_last_screenshot.py
 tests/test_levenshtein.py
 tests/test_marker_allow.py