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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 2.1.0
+Version: 2.2.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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cc-session-tools"
-version = "2.1.0"
+version = "2.2.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.1.0 → cc_session_tools-2.2.0}/src/cc_session_tools/cli/ccr.py

@@ -23,6 +23,30 @@ def _format_size(num_bytes: int) -> str:
     return f"{size:.1f}GB"
 
 
+def _warn_if_fragment_matches_corrupted_row(fragment: str) -> None:
+    """Print a stderr diagnostic when `fragment` matches a sessions.db row whose project_dir
+    is non-absolute. Such a row is invisible to every lookup path here — the exact-match fast
+    path and find_matching_sessions both filter by root, and find_orphan_transcripts skips it
+    because its cc-sessions/<name>/ directory already exists on disk — so without this it reads
+    as an ordinary "not found" rather than a fixable data problem. Called unconditionally
+    whenever `matches` is computed, not only when it's empty, so a corrupted sibling of a
+    resumable match is still surfaced. Mirrors ccs.py's _warn_if_corrupted_rows_present."""
+    from cc_session_tools.lib import sessions_repair
+
+    corrupted = [
+        row for row in sessions_repair.find_non_absolute_rows()
+        if fragment in row.basename
+    ]
+    if corrupted:
+        names = ", ".join(row.basename for row in corrupted)
+        print(
+            f"ccr: {len(corrupted)} session(s) matching '{fragment}' have an invalid "
+            f"(non-absolute) project_dir and can't be resumed by name: {names} — run "
+            "'ccst repair sessions --dry-run' to see them, then --execute to fix.",
+            file=sys.stderr,
+        )
+
+
 def _pick_duplicate_transcript(basename: str, candidates: list[Path]) -> Path | None:
     """Multiple JSONL transcripts share one session tag - e.g. hitting Ctrl-L
     twice mid-session clears one copy while `claude --resume` still lists it
@@ -114,6 +138,7 @@ def main(argv: list[str] | None = None) -> int:
         matches.extend(o for o in orphans if o.basename not in on_disk_basenames)
     debug(f"fragment: {args.fragment!r}")
     debug(f"matches: {[m.basename for m in matches]}")
+    _warn_if_fragment_matches_corrupted_row(args.fragment)
 
     if not matches:
         print(f"ccr: no sessions match '{args.fragment}'", file=sys.stderr)

{cc_session_tools-2.1.0 → cc_session_tools-2.2.0}/src/cc_session_tools/cli/ccs.py

@@ -398,8 +398,10 @@ def _collect_session_rows(
     order_by/limit push an indexed ORDER BY ... LIMIT into SQL (see
     sessions_db.list_sessions) when order_by is a DB-backed column - this is
     what makes "most recent N" an O(log n) lookup, not a fetch-everything-then-
-    slice. For --global, the root filter is applied after the DB query, so with
-    --limit the returned N rows are the N most recent *before* root filtering.
+    slice. For --global, the root filter is applied after the DB query — see
+    _fetch_global_limited() for how the limit case stays correct despite that,
+    and _warn_if_corrupted_rows_present() for the stderr diagnostic printed
+    whenever a non-absolute project_dir row is found and omitted.
 
     `order_by` uses ccs's flag vocabulary ("opened"/"active"); it is mapped
     here to the sessions.db column names ("last_opened"/"last_active").
@@ -413,8 +415,11 @@ def _collect_session_rows(
         except RootsConfigError as e:
             print(str(e), file=sys.stderr)
             sys.exit(1)
-        rows = sessions_db.list_sessions(order_by=db_order_by, limit=db_limit)
-        return [r for r in rows if r.project_dir.parent in roots]
+        if db_limit is None:
+            rows = sessions_db.list_sessions(order_by=db_order_by, limit=None)
+            _warn_if_corrupted_rows_present(rows)
+            return [r for r in rows if r.project_dir.parent in roots]
+        return _fetch_global_limited(roots, db_order_by, db_limit)
 
     cwd = Path.cwd().resolve()
     return sessions_db.list_sessions(
@@ -422,6 +427,49 @@ def _collect_session_rows(
     )
 
 
+_GLOBAL_LIMIT_GROWTH_FACTOR = 4
+
+
+def _warn_if_corrupted_rows_present(rows: list["sessions_db.SessionRow"]) -> None:
+    """Print a visible (user- and Claude-Code-visible, via stderr) heads-up when any fetched
+    row has a non-absolute project_dir — these are the specific rows `ccst repair sessions`
+    can fix, as opposed to ordinary out-of-root rows (a project simply not under a configured
+    root), which are normal scoping and not flagged."""
+    corrupted = sum(1 for r in rows if not r.project_dir.is_absolute())
+    if corrupted:
+        print(
+            f"ccs: {corrupted} session(s) in sessions.db have an invalid (non-absolute) "
+            "project_dir and are missing from this --global listing — run "
+            "'ccst repair sessions --dry-run' to see them, then --execute to fix.",
+            file=sys.stderr,
+        )
+
+
+def _fetch_global_limited(
+    roots: list[Path], db_order_by: str, db_limit: int
+) -> list["sessions_db.SessionRow"]:
+    """Fetch the db_limit most-recent in-root rows for --global.
+
+    A plain `ORDER BY ... LIMIT db_limit` applied before the root filter can
+    starve the result: any out-of-root (or corrupted — see
+    _warn_if_corrupted_rows_present) row sitting ahead of a legitimate one in
+    last_active/last_opened order consumes a LIMIT slot that never gets
+    root-filtered back in. Grow the DB-side fetch window geometrically until
+    either db_limit in-root rows have survived the filter or the table is
+    exhausted (`len(rows) < fetch` signals exhaustion) — this keeps the
+    common case (most rows are in-root) at one query while staying correct
+    when it isn't. The corrupted-row warning fires once, on the final fetch.
+    """
+    fetch = db_limit
+    while True:
+        rows = sessions_db.list_sessions(order_by=db_order_by, limit=fetch)
+        filtered = [r for r in rows if r.project_dir.parent in roots]
+        if len(filtered) >= db_limit or len(rows) < fetch:
+            _warn_if_corrupted_rows_present(rows)
+            return filtered[:db_limit]
+        fetch *= _GLOBAL_LIMIT_GROWTH_FACTOR
+
+
 def _display_path(p: Path) -> str:
     home = Path.home()
     try:
@@ -1056,6 +1104,14 @@ def main(argv: list[str] | None = None) -> int:
             file=sys.stderr,
         )
         return 2
+    if args.limit is not None and args.limit < 1:
+        print(
+            f"ccs: --limit must be a positive integer, got {args.limit} "
+            "(SQLite treats a negative LIMIT as unbounded, and Python's "
+            "list[:N] slicing would silently drop from the wrong end)",
+            file=sys.stderr,
+        )
+        return 2
 
     # Validate date filter args eagerly so bad values are caught before any I/O.
     date_filter: tuple[str | None, str | None] | None = None

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

@@ -674,6 +674,7 @@ def _cmd_doctor(args: argparse.Namespace) -> int:
         legacy_migration_paths=legacy_migration_paths,
         projects_root=default_projects_root(),
         pdata_verify_projects=_pdata_verify.discover_projects(),
+        sessions_db_path=store_paths["sessions"],
     )
 
     if args.drift or getattr(args, "mode", None) == "drift":
@@ -1245,6 +1246,58 @@ def _cmd_sessions_list(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_repair_sessions(args: argparse.Namespace) -> int:
+    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
+
+    db_path = Path(args.sessions_db) if args.sessions_db else sessions_db.default_db_path()
+    try:
+        roots = load_session_roots()
+    except RootsConfigError as e:
+        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)
+    if not any((report.repaired, report.unresolved, report.ambiguous, report.conflicts)):
+        print("No non-absolute project_dir rows found in sessions.db.")
+        return 0
+
+    verb = "fixed" if args.execute else "would fix"
+    for basename, new_dir in report.repaired:
+        print(f"  {verb}: {basename} -> {new_dir}")
+    for basename in report.unresolved:
+        print(
+            f"  UNRESOLVED (no on-disk cc-sessions/{basename} under any root): {basename}",
+            file=sys.stderr,
+        )
+    for basename, candidates in report.ambiguous.items():
+        print(f"  AMBIGUOUS ({len(candidates)} candidates, skipped): {basename}", file=sys.stderr)
+    for basename in report.conflicts:
+        print(
+            f"  CONFLICT (a correct row for this basename already exists, skipped): {basename}",
+            file=sys.stderr,
+        )
+
+    if not args.execute and report.repaired:
+        print(f"\n{len(report.repaired)} row(s) would be repaired. Re-run with --execute to apply.")
+    return 1 if (report.unresolved or report.ambiguous or report.conflicts) else 0
+
+
 def _fmt_ts(epoch: float) -> str:
     if not epoch:
         return "(never)"
@@ -2034,6 +2087,32 @@ def _build_parser() -> argparse.ArgumentParser:
              "Claude Code session.")
     m_all.add_argument("--dry-run", action="store_true")
 
+    # ---- repair ----
+    repair_parser = sub.add_parser("repair", help="Repair known sessions.db/store corruption")
+    repair_sub = repair_parser.add_subparsers(dest="verb", metavar="<verb>")
+    repair_sub.required = True
+    r_sessions = repair_sub.add_parser(
+        "sessions",
+        help=(
+            "Fix sessions.db rows whose project_dir is not an absolute path (invisible "
+            "to `ccl`/`ccs --global`) by re-resolving them from on-disk cc-sessions/ "
+            "directories. Dry-run by default."
+        ),
+    )
+    r_sessions_mode = r_sessions.add_mutually_exclusive_group()
+    r_sessions_mode.add_argument(
+        "--execute", action="store_true",
+        help="Apply the repair (default: dry-run, print what would change).",
+    )
+    r_sessions_mode.add_argument(
+        "--dry-run", action="store_true",
+        help="Print what would change without writing (this is the default).",
+    )
+    r_sessions.add_argument(
+        "--sessions-db", default=None, metavar="PATH",
+        help="sessions.db path override (default: from CCST_SESSIONS_DIR)",
+    )
+
     # ---- ccsched-jobs ----
     ccsched_jobs_parser = sub.add_parser(
         "ccsched-jobs", help="Provision CCST-bundled ccsched jobs",
@@ -2188,6 +2267,10 @@ def main() -> None:
         if args.verb == "all":
             sys.exit(_cmd_migrate_all(args))
 
+    if args.noun == "repair":
+        if args.verb == "sessions":
+            sys.exit(_cmd_repair_sessions(args))
+
     if args.noun == "ccsched-jobs":
         if args.verb == "install":
             sys.exit(_cmd_ccsched_jobs_install(args))

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

@@ -677,6 +677,31 @@ def check_pdata_verify(projects: list[str]) -> list[CheckResult]:
     return results
 
 
+def check_sessions_project_dir_absolute(sessions_db_path: Path) -> list[CheckResult]:
+    """WARN if any sessions.db row has a non-absolute project_dir. Every reader that
+    scopes --global by root (ccs.py, sessions.find_matching_sessions) compares
+    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."""
+    from cc_session_tools.lib import sessions_repair
+
+    bad = sessions_repair.find_non_absolute_rows(path=sessions_db_path)
+    if not bad:
+        return [CheckResult(
+            name="sessions:project-dir-absolute", status=Status.OK,
+            reason="all sessions.db rows have an absolute project_dir",
+        )]
+    return [CheckResult(
+        name="sessions:project-dir-absolute", status=Status.WARN,
+        reason=(
+            f"{len(bad)} sessions.db row(s) have a non-absolute project_dir and are "
+            "invisible to `ccl`/`ccs --global` — run 'ccst repair sessions --dry-run' "
+            "to see them, then --execute to fix"
+        ),
+    )]
+
+
 # ---------- high-level runner ----------
 
 
@@ -693,6 +718,7 @@ def run_all_checks(
     legacy_migration_paths: LegacyMigrationPaths | None = None,
     projects_root: Path | None = None,
     pdata_verify_projects: list[str] | None = None,
+    sessions_db_path: Path | None = None,
 ) -> list[CheckResult]:
     """Run the full doctor suite and return results.
 
@@ -726,6 +752,9 @@ def run_all_checks(
         Project names whose last persisted ``ccst pdata verify`` result should
         be reported; when None, the pdata-verify checks are skipped. Never
         triggers a verify run — only reads what the recurring job left behind.
+    sessions_db_path:
+        Path to sessions.db; when None, the project_dir-absolute check is
+        skipped.
     """
     results: list[CheckResult] = []
 
@@ -794,6 +823,10 @@ def run_all_checks(
     if pdata_verify_projects is not None:
         results.extend(check_pdata_verify(pdata_verify_projects))
 
+    # Non-absolute project_dir rows in sessions.db
+    if sessions_db_path is not None:
+        results.extend(check_sessions_project_dir_absolute(sessions_db_path))
+
     # PyPI version check
     if not skip_pypi:
         results.append(check_pypi_version(installed_version))

{cc_session_tools-2.1.0 → cc_session_tools-2.2.0}/src/cc_session_tools/lib/sessions_db.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 
 import os
 import sqlite3
+import sys
 import time
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -156,6 +157,27 @@ def _row_to_session(row: sqlite3.Row) -> SessionRow:
     )
 
 
+def _reject_non_absolute_project_dir(project_dir: Path, basename: str, *, source: str) -> None:
+    """Print a clear, unmissable diagnostic to stderr — visible to a human reading the
+    terminal AND to Claude Code, which surfaces hook stderr as tool/hook output. A silent
+    rejection here means this row is permanently invisible to `ccl`/`ccs --global` until
+    repaired, so every rejection must say so out loud."""
+    print(
+        f"[sessions-db] REJECTED write from {source}: project_dir={str(project_dir)!r} for "
+        f"session {basename!r} is not absolute. This session will be MISSING from `ccl`/"
+        "`ccs --global` listings until fixed — run 'ccst repair sessions --dry-run' to see "
+        "it, then --execute to fix.",
+        file=sys.stderr,
+    )
+
+
+def _is_valid_project_dir(project_dir: Path, basename: str, *, source: str) -> bool:
+    if project_dir.is_absolute():
+        return True
+    _reject_non_absolute_project_dir(project_dir, basename, source=source)
+    return False
+
+
 def ensure_session_row(
     project_dir: Path,
     basename: str,
@@ -169,12 +191,17 @@ def ensure_session_row(
     fires (hooks disabled/broken); the hook's own touch_last_opened() upsert
     is the normal path and would create the same row moments later regardless.
 
+    Also a no-op — with a loud stderr diagnostic — when `project_dir` is not
+    absolute; see `_is_valid_project_dir`.
+
     conn, if given, is reused as-is (caller owns commit/close) — see write_tag."""
     from cc_session_tools.lib.sessions import session_start_date
 
     start_date = session_start_date(basename)
     if start_date is None:
         return
+    if not _is_valid_project_dir(project_dir, basename, source="ensure_session_row"):
+        return
     owns_conn = conn is None
     c = conn if conn is not None else connect(path=path)
     try:
@@ -201,12 +228,17 @@ def touch_last_opened(
 ) -> None:
     """Upsert the last_opened timestamp (epoch seconds) for (project_dir, basename).
 
+    Also a no-op — with a loud stderr diagnostic — when `project_dir` is not
+    absolute; see `_is_valid_project_dir`.
+
     conn, if given, is reused as-is (caller owns commit/close) — see write_tag."""
     from cc_session_tools.lib.sessions import session_start_date
 
     start_date = session_start_date(basename)
     if start_date is None:
         return
+    if not _is_valid_project_dir(project_dir, basename, source="touch_last_opened"):
+        return
     ts = when if when is not None else time.time()
     owns_conn = conn is None
     c = conn if conn is not None else connect(path=path)
@@ -234,12 +266,17 @@ def touch_last_active(
 ) -> None:
     """Upsert the last_active timestamp (epoch seconds) for (project_dir, basename).
 
+    Also a no-op — with a loud stderr diagnostic — when `project_dir` is not
+    absolute; see `_is_valid_project_dir`.
+
     conn, if given, is reused as-is (caller owns commit/close) — see write_tag."""
     from cc_session_tools.lib.sessions import session_start_date
 
     start_date = session_start_date(basename)
     if start_date is None:
         return
+    if not _is_valid_project_dir(project_dir, basename, source="touch_last_active"):
+        return
     ts = when if when is not None else time.time()
     owns_conn = conn is None
     c = conn if conn is not None else connect(path=path)

cc_session_tools-2.2.0/src/cc_session_tools/lib/sessions_repair.py

@@ -0,0 +1,128 @@
+"""Repair sessions.db rows whose project_dir was written as a non-absolute Path.
+Resolves each affected row's correct project_dir by locating its on-disk
+cc-sessions/<basename>/ directory under the configured roots, then updates the row
+in place, preserving its timestamps. Never guesses when a basename's on-disk
+location is ambiguous (found under >1 root/project) or missing (found under none)
+— those are reported, not silently resolved, because a wrong guess would
+silently point `ccl`/`ccs` at the wrong project's session data, which is worse
+than the original missing-from-listings bug."""
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from cc_session_tools.lib import sessions_db
+
+
+@dataclass(slots=True)
+class RepairReport:
+    """Mutable accumulator, built up in place by repair() — not a frozen value object.
+
+    Note the duplicate-basename semantics differ across fields: `ambiguous` is a
+    dict keyed by basename (so a duplicate basename overwrites its own entry),
+    while `repaired`/`unresolved`/`conflicts` are lists (so a duplicate basename
+    can appear more than once). A caller counting rows across fields must account
+    for this asymmetry."""
+
+    repaired: list[tuple[str, Path]] = field(default_factory=list)
+    unresolved: list[str] = field(default_factory=list)
+    ambiguous: dict[str, list[Path]] = field(default_factory=dict)
+    conflicts: list[str] = field(default_factory=list)
+
+
+def find_non_absolute_rows(*, path: Path | None = None) -> list[sessions_db.SessionRow]:
+    """Every sessions.db row whose project_dir is not an absolute path."""
+    return [r for r in sessions_db.list_sessions(path=path) if not r.project_dir.is_absolute()]
+
+
+def _resolve_on_disk(basename: str, roots: list[Path]) -> list[Path]:
+    """Every project directly under a configured root whose cc-sessions/<basename>/
+    exists on disk — the set of plausible correct project_dir values for this row."""
+    matches: list[Path] = []
+    for root in roots:
+        if not root.is_dir():
+            continue
+        for proj in root.iterdir():
+            if proj.is_dir() and (proj / "cc-sessions" / basename).is_dir():
+                matches.append(proj)
+    return matches
+
+
+def repair(
+    roots: list[Path], *, path: Path | None = None, dry_run: bool = True
+) -> RepairReport:
+    """Resolve and (unless dry_run) fix every non-absolute project_dir row.
+
+    dry_run=True (the default) only computes and returns the report. dry_run=False
+    updates sessions.db in place — one UPDATE per uniquely-resolved row, leaving
+    start_date/last_opened/last_active/discovered_at untouched: a project_dir
+    correction is not a new session-activity event, so it must not move
+    last_opened/last_active. Callers that want a safety copy first should back up
+    the DB file (e.g. via db.backup_to()) before calling with dry_run=False; this
+    function does not.
+
+    A resolved row is never blindly UPDATEd: (project_dir, basename) is the table's
+    PRIMARY KEY, so if a correct row for (resolved_dir, basename) already exists —
+    e.g. ccd.py's ensure_session_row() wrote it independently at session-creation
+    time — writing the corrupted row on top would violate that key. Such rows are
+    reported as `conflicts` and left untouched rather than raising mid-batch. The
+    same applies when two bad rows in the SAME batch resolve to the same target
+    (e.g. one row has project_dir='.', another has '..', and both name the same
+    basename): applying one would make the other's UPDATE collide with it, so
+    both are reported as conflicts rather than letting row-processing order
+    arbitrarily pick a "winner".
+    """
+    bad_rows = find_non_absolute_rows(path=path)
+    report = RepairReport()
+    if not bad_rows:
+        return report
+
+    resolutions: list[tuple[sessions_db.SessionRow, Path]] = []
+    for row in bad_rows:
+        candidates = _resolve_on_disk(row.basename, roots)
+        if len(candidates) == 1:
+            resolutions.append((row, candidates[0]))
+        elif len(candidates) == 0:
+            report.unresolved.append(row.basename)
+        else:
+            report.ambiguous[row.basename] = candidates
+
+    if not resolutions:
+        return report
+
+    # Split out any resolution whose target (new_dir, basename) already has a row —
+    # applying it would violate the PRIMARY KEY. Check before writing anything, not
+    # via try/except around the UPDATE, so one conflict can't abort sibling rows'
+    # otherwise-valid updates. `batch_target_counts` catches the same collision
+    # when it happens WITHIN this batch (two bad rows resolving to the same
+    # target): every row sharing such a target is a conflict, not just whichever
+    # one is processed second — picking a "winner" by iteration order would be
+    # arbitrary and non-deterministic.
+    existing_keys = {
+        (r.project_dir, r.basename) for r in sessions_db.list_sessions(path=path)
+    }
+    batch_target_counts = Counter((new_dir, row.basename) for row, new_dir in resolutions)
+    applyable: list[tuple[sessions_db.SessionRow, Path]] = []
+    for row, new_dir in resolutions:
+        target = (new_dir, row.basename)
+        if target in existing_keys or batch_target_counts[target] > 1:
+            report.conflicts.append(row.basename)
+        else:
+            applyable.append((row, new_dir))
+            report.repaired.append((row.basename, new_dir))
+
+    if dry_run or not applyable:
+        return report
+
+    conn = sessions_db.connect(path=path)
+    try:
+        for row, new_dir in applyable:
+            conn.execute(
+                "UPDATE sessions SET project_dir = ? WHERE project_dir = ? AND basename = ?",
+                (str(new_dir), str(row.project_dir), row.basename),
+            )
+        conn.commit()
+    finally:
+        conn.close()
+    return report

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 2.1.0
+Version: 2.2.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

{cc_session_tools-2.1.0 → cc_session_tools-2.2.0}/src/cc_session_tools.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ src/cc_session_tools/lib/rules.py
 src/cc_session_tools/lib/session_gc.py
 src/cc_session_tools/lib/sessions.py
 src/cc_session_tools/lib/sessions_db.py
+src/cc_session_tools/lib/sessions_repair.py
 src/cc_session_tools/lib/shell_install.py
 src/cc_session_tools/lib/tasklist.py
 src/cc_session_tools/lib/telemetry_store.py
@@ -143,6 +144,7 @@ tests/test_ccst_pdata_cli.py
 tests/test_ccst_pdata_init_cli.py
 tests/test_ccst_pdata_reconcile_cli.py
 tests/test_ccst_pdata_verify_cli.py
+tests/test_ccst_repair_sessions_cli.py
 tests/test_ccst_sessions_cli.py
 tests/test_ccst_shell_install.py
 tests/test_ccst_skills_install.py
@@ -190,6 +192,7 @@ tests/test_session_names.py
 tests/test_session_tag.py
 tests/test_sessions.py
 tests/test_sessions_db.py
+tests/test_sessions_repair.py
 tests/test_tasklist.py
 tests/test_telemetry.py
 tests/test_telemetry_store.py

cc_session_tools-2.2.0/src/cccs_hooks/after_response.py

@@ -0,0 +1,46 @@
+"""Stop hook: records a session-activity sentinel into sessions.db.
+
+Fires via Stop event (after each Claude response, not once per session).
+Upserts the sessions table's last_active timestamp so `ccs --order-by active`
+can sort sessions by recency of Claude activity without a filesystem walk.
+Never blocks. Silent on the normal successful-write path; emits a
+systemMessage only when CLD_SESSION_DIR is shaped like cc-sessions/<basename>
+but not absolute, since writing would otherwise collapse project_dir to '.'.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import sys
+from pathlib import Path
+
+from cc_session_tools.lib import sessions_db
+
+
+def main(argv: list[str] | None = None) -> int:
+    session_dir_str = os.environ.get("CLD_SESSION_DIR", "")
+    if session_dir_str:
+        session_dir_path = Path(session_dir_str)
+        if session_dir_path.parent.name == "cc-sessions":
+            if not session_dir_path.is_absolute():
+                msg = (
+                    f"[after-response] CLD_SESSION_DIR is not absolute "
+                    f"({session_dir_str!r}); skipping sessions.db update to avoid writing "
+                    "a corrupt project_dir. Run 'ccst repair sessions --dry-run' if "
+                    "ccl/ccs --global later looks incomplete."
+                )
+                print(json.dumps({"systemMessage": msg}))
+            else:
+                try:
+                    sessions_db.touch_last_active(
+                        session_dir_path.parent.parent, session_dir_path.name
+                    )
+                except (OSError, sqlite3.Error) as exc:
+                    print(f"[after-response] Failed to record .last-active: {exc}", file=sys.stderr)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())