cc-session-tools 4.0.2__tar.gz → 4.1.0__tar.gz

{cc_session_tools-4.0.2/src/cc_session_tools.egg-info → cc_session_tools-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 4.0.2
+Version: 4.1.0
 Summary: Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (hooks package)
 Author: raffishquartan
 License: MIT License
@@ -422,8 +422,7 @@ These keep the rest of CCST working without any action from you:
 - `messaging-deliver` - delivers `ccmsg` messages at session start and each prompt.
 - `catchup` - catches up missed scheduled jobs and shows the digest.
 - `pdata-sync` - syncs `pdata` databases across your machines (see below).
-- `pending-migration` and `pending-rename` - surface unfinished data migrations and
-  half-finished session renames.
+- `pending-migration` - surfaces unfinished data migrations.
 - `last-screenshot` - type `>lss` in a prompt and Claude gets the path of your newest
   screenshot (set `CCST_SCREENSHOT_DIR`; several directories may be separated by `:`).
 - `marker-allow` - lets skills drop small marker files without a permission prompt.
@@ -560,7 +559,7 @@ flag.
 | `sessions`           | inspect `sessions.db`; one-shot schema migrations                         |
 | `repair`             | repair known `sessions.db` corruption                                     |
 | `gc`                 | `report` and `prune` orphaned per-session data                            |
-| `telemetry`          | `query` and `trim` the hook-invocation log                                |
+| `telemetry`          | `query` and `trim` the hook log; `recover` a command from its hash        |
 | `migrate`            | one-shot migrations from legacy flat-file stores to SQLite                |
 | `context-override`   | toggle the context-window warning for the current session                 |
 
@@ -607,7 +606,9 @@ CCST is deliberately not a server or a shared team tool. It is local infrastruct
 person running Claude Code hard, on one or more of their own machines. Everything is SQLite
 under `~/.local/share/claude/`, one file per subsystem (sessions, messages, scheduler,
 telemetry, command cache), and all of it is inspectable with `ccst telemetry query`,
-`ccst gc report`, `ccst sessions list`, or a plain `sqlite3` shell. `ccst doctor` is the one
+`ccst gc report`, `ccst sessions list`, or a plain `sqlite3` shell. Telemetry stores only a
+hash of each reviewed command; `ccst telemetry recover <hash>` finds the command behind it in
+the firing session's transcripts. `ccst doctor` is the one
 command that checks all of it at once. Run it any time something feels off.
 
 ## Contributing

{cc_session_tools-4.0.2 → cc_session_tools-4.1.0}/README.md

@@ -363,8 +363,7 @@ These keep the rest of CCST working without any action from you:
 - `messaging-deliver` - delivers `ccmsg` messages at session start and each prompt.
 - `catchup` - catches up missed scheduled jobs and shows the digest.
 - `pdata-sync` - syncs `pdata` databases across your machines (see below).
-- `pending-migration` and `pending-rename` - surface unfinished data migrations and
-  half-finished session renames.
+- `pending-migration` - surfaces unfinished data migrations.
 - `last-screenshot` - type `>lss` in a prompt and Claude gets the path of your newest
   screenshot (set `CCST_SCREENSHOT_DIR`; several directories may be separated by `:`).
 - `marker-allow` - lets skills drop small marker files without a permission prompt.
@@ -501,7 +500,7 @@ flag.
 | `sessions`           | inspect `sessions.db`; one-shot schema migrations                         |
 | `repair`             | repair known `sessions.db` corruption                                     |
 | `gc`                 | `report` and `prune` orphaned per-session data                            |
-| `telemetry`          | `query` and `trim` the hook-invocation log                                |
+| `telemetry`          | `query` and `trim` the hook log; `recover` a command from its hash        |
 | `migrate`            | one-shot migrations from legacy flat-file stores to SQLite                |
 | `context-override`   | toggle the context-window warning for the current session                 |
 
@@ -548,7 +547,9 @@ CCST is deliberately not a server or a shared team tool. It is local infrastruct
 person running Claude Code hard, on one or more of their own machines. Everything is SQLite
 under `~/.local/share/claude/`, one file per subsystem (sessions, messages, scheduler,
 telemetry, command cache), and all of it is inspectable with `ccst telemetry query`,
-`ccst gc report`, `ccst sessions list`, or a plain `sqlite3` shell. `ccst doctor` is the one
+`ccst gc report`, `ccst sessions list`, or a plain `sqlite3` shell. Telemetry stores only a
+hash of each reviewed command; `ccst telemetry recover <hash>` finds the command behind it in
+the firing session's transcripts. `ccst doctor` is the one
 command that checks all of it at once. Run it any time something feels off.
 
 ## Contributing

{cc_session_tools-4.0.2 → cc_session_tools-4.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cc-session-tools"
-version = "4.0.2"
+version = "4.1.0"
 description = "Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (hooks package)"
 readme = "README.md"
 license = { file = "LICENSE" }

{cc_session_tools-4.0.2 → cc_session_tools-4.1.0}/src/cc_session_tools/cli/ccst.py

@@ -29,6 +29,10 @@ Current subcommands:
   telemetry trim                 Trim telemetry.db by size / age (see ccst telemetry trim --help).
   telemetry query                Query recent hook fires from telemetry.db (see
                                  ccst telemetry query --help).
+  telemetry recover <hash>...    Recover the Bash command behind each bash-security-review
+                                 input_hash from the firing sessions' transcripts, one
+                                 compact line per hash (requires CCST_FIRES_ACCESS=1; see
+                                 ccst telemetry recover --help).
   gc report                      Report orphaned per-session-uuid entries across the
                                  scheduler, messaging, and session-env stores (never
                                  deletes anything).
@@ -106,6 +110,7 @@ import datetime
 import importlib
 import json
 import os
+import subprocess
 import sys
 from dataclasses import dataclass
 from enum import Enum
@@ -119,7 +124,7 @@ from cc_session_tools.hooks_install import (
     prune_stale_hooks,
     write_json_atomic,
 )
-from cc_session_tools.lib import machine_identity
+from cc_session_tools.lib import command_recovery, machine_identity
 from cc_session_tools.lib.claude_md_install import SECTION_IDS as CLAUDE_MD_SECTION_IDS
 from cc_session_tools.lib.claude_md_install import DRIFT_WARNING_MARKER, MarkdownAction, MarkdownResult
 from cc_session_tools.lib.hook_registry import HOOK_DESCRIPTIONS, HOOK_VERBS
@@ -998,6 +1003,43 @@ def _cmd_telemetry_query(args: argparse.Namespace) -> int:
     return query_main(argv)
 
 
+def _non_negative_int(raw: str) -> int:
+    """argparse type for a count that may be 0, else a usage error naming it."""
+    try:
+        value = int(raw)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"{raw!r} is not an integer") from None
+    if value < 0:
+        raise argparse.ArgumentTypeError(f"{raw!r} is negative")
+    return value
+
+
+def _cmd_telemetry_recover(args: argparse.Namespace) -> int:
+    # A self-imposed convention shared with update-command-cache: bash-hard-deny
+    # does not match this verb, so the variable is enforced here alone.
+    if os.environ.get("CCST_FIRES_ACCESS") != "1":
+        print(
+            "Refusing to read telemetry.db and transcripts without CCST_FIRES_ACCESS=1.\n"
+            "Re-run as: CCST_FIRES_ACCESS=1 ccst telemetry recover <hash>...",
+            file=sys.stderr,
+        )
+        return 2
+    try:
+        hashes = command_recovery.normalise_args(args.hashes)
+    except command_recovery.MalformedHashError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    results = command_recovery.recover(
+        hashes,
+        projects_dir=Path(args.projects_dir) if args.projects_dir else None,
+        hooks_dir=Path(args.hooks_dir) if args.hooks_dir else None,
+        scan_all=args.scan_all,
+    )
+    for rec in results:
+        print(command_recovery.format_line(rec, args.max_chars))
+    return 0
+
+
 # ---------- gc report ----------
 
 
@@ -3260,6 +3302,40 @@ def _build_parser() -> argparse.ArgumentParser:
         help="telemetry.db directory (default: CCST_HOOKS_DIR or ~/.local/share/claude/)",
     )
 
+    telemetry_recover_parser = telemetry_sub.add_parser(
+        "recover",
+        help="Recover the Bash command behind bash-security-review input hashes",
+        description=(
+            "For each hash (full, or a prefix of at least 8 hex characters; a sha256: "
+            "prefix is accepted) print one tab-separated line: hash as given (normalised), "
+            "status (command|session|ambiguous|unknown), full hash (command only), session "
+            "uuid, <transcript>:<line>, command. A command is printed only when it "
+            "re-hashes to the given hash. Searches the firing sessions' main and subagent "
+            "transcripts. Requires CCST_FIRES_ACCESS=1."
+        ),
+    )
+    telemetry_recover_parser.add_argument(
+        "hashes", nargs="+", metavar="HASH", help="input_hash, full or a prefix of 8+ hex characters",
+    )
+    telemetry_recover_parser.add_argument(
+        "--max-chars", type=_non_negative_int, default=command_recovery.DEFAULT_MAX_CHARS,
+        metavar="N",
+        help="Cut each escaped command to N characters, marking how many were cut "
+             f"(default: {command_recovery.DEFAULT_MAX_CHARS}; 0 for no limit)",
+    )
+    telemetry_recover_parser.add_argument(
+        "--scan-all", action="store_true",
+        help="Search every transcript, not only those of sessions that fired the hash",
+    )
+    telemetry_recover_parser.add_argument(
+        "--projects-dir", default=None, metavar="DIR",
+        help="Transcript root (default: ~/.claude/projects)",
+    )
+    telemetry_recover_parser.add_argument(
+        "--hooks-dir", default=None, metavar="DIR",
+        help="telemetry.db directory (default: CCST_HOOKS_DIR or ~/.local/share/claude/)",
+    )
+
     # ---- gc ----
     gc_parser = sub.add_parser("gc", help="Garbage-collection reports for per-session-uuid stores")
     gc_sub = gc_parser.add_subparsers(dest="verb", metavar="<verb>")
@@ -3941,10 +4017,48 @@ def _build_parser() -> argparse.ArgumentParser:
         "action", nargs="?", default="on", choices=["on", "off", "status"]
     )
 
+    # ---- move-session ----
+    # Listed here for the help output only: main() forwards `ccst move-session
+    # ...` to the bundled script before argparse runs (see _cmd_move_session).
+    sub.add_parser(
+        "move-session",
+        add_help=False,
+        help="Move and/or rename a Claude Code session (the move-session skill's script; "
+        "`ccst move-session --help` for its options)",
+    )
+
     return parser
 
 
+MOVE_SESSION_NOUN = "move-session"
+
+
+def _cmd_move_session(script_args: list[str]) -> int:
+    """Run the bundled move-session script with ``script_args`` unchanged,
+    under this interpreter (the one that has cc-session-tools installed), and
+    return its exit code.
+
+    Dispatched before argparse because the script owns its own command line:
+    a subparser could not forward a call whose first argument is an option
+    (every real call starts with --src-session), and ``--help`` would print
+    ccst's help instead of the script's. A subprocess keeps the script's
+    sys.argv, argparse prog and module state its own.
+
+    Not exempt from install auto-sync, like any ordinary ccst command.
+    """
+    from cc_session_tools.lib import install_sync
+
+    install_sync.ensure_synced(
+        noun=MOVE_SESSION_NOUN, verb=None, installed_version=__version__
+    )
+    script = _discover_source_dir() / "move-session" / "scripts" / "move_session.py"
+    return subprocess.run([sys.executable, str(script), *script_args]).returncode
+
+
 def main() -> None:
+    if sys.argv[1:2] == [MOVE_SESSION_NOUN]:
+        sys.exit(_cmd_move_session(sys.argv[2:]))
+
     parser = _build_parser()
     args = parser.parse_args()
 
@@ -4011,6 +4125,8 @@ def main() -> None:
             sys.exit(_cmd_telemetry_trim(args))
         if args.verb == "query":
             sys.exit(_cmd_telemetry_query(args))
+        if args.verb == "recover":
+            sys.exit(_cmd_telemetry_recover(args))
 
     if args.noun == "gc":
         if args.verb == "report":

{cc_session_tools-4.0.2 → cc_session_tools-4.1.0}/src/cc_session_tools/config/hooks-bundle.json

@@ -27,12 +27,6 @@
             "timeout": 5,
             "statusMessage": "Checking for unmigrated legacy data stores..."
           },
-          {
-            "type": "command",
-            "command": "ccst hooks run pending-rename",
-            "timeout": 10,
-            "statusMessage": "Checking for pending session-renames..."
-          },
           {
             "type": "command",
             "command": "ccst hooks run pdata-sync",

cc_session_tools-4.1.0/src/cc_session_tools/lib/command_recovery.py

@@ -0,0 +1,299 @@
+"""Recover the Bash command behind a bash-security-review ``input_hash``.
+
+telemetry.db stores only ``sha256:<hex>`` of each reviewed command, never its
+text. The same string is the ``input.command`` of a ``Bash`` tool_use record in
+a transcript, so the command can be recovered by hashing each Bash command in
+the transcripts of the sessions that fired the hash and keeping exact SHA-256
+matches. Nothing is guessed: a hash with no exact match is reported as the
+session it fired in (``session``), as ``ambiguous`` for a prefix matching
+several hashes, or as ``unknown``.
+
+Transcripts searched for session S, under the projects directory
+(``~/.claude/projects`` by default): every ``<key>/S.jsonl`` and every
+``<key>/S/subagents/*.jsonl`` (the hook's ``session_id`` for a subagent's
+command is the parent session's uuid). With ``scan_all`` every transcript is
+searched instead. Each file is read at most once per call to ``recover``.
+
+Backs ``ccst telemetry recover`` and the update-command-cache skill's ``list``
+previews. Reads only; writes to no store.
+"""
+from __future__ import annotations
+
+import enum
+import glob
+import hashlib
+import json
+import re
+import unicodedata
+from collections.abc import Iterable, Iterator, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from cc_session_tools.lib import db, paths, telemetry_store
+
+DEFAULT_MAX_CHARS = 200
+MIN_PREFIX_LEN = 8
+FULL_HASH_LEN = 64
+
+_SHA_PREFIX = "sha256:"
+_HEX_RE = re.compile(r"[0-9a-f]+")
+# Claude Code writes transcripts as compact JSON, so every Bash tool_use line
+# contains this substring; lines without it are skipped before json.loads.
+_BASH_MARKER = b'"name":"Bash"'
+_HOOK = "bash-security-review"
+_SIMPLE_ESCAPES = {"\t": "\\t", "\r": "\\r", "\n": "\\n"}
+# Control characters (C0, DEL, C1) and the line and paragraph separators.
+_ESCAPED_CATEGORIES = frozenset({"Cc", "Zl", "Zp"})
+
+
+class RecoveryStatus(enum.Enum):
+    COMMAND = "command"
+    SESSION = "session"
+    AMBIGUOUS = "ambiguous"
+    UNKNOWN = "unknown"
+
+
+class MalformedHashError(ValueError):
+    """A hash argument that is not 8-64 hex characters after normalisation."""
+
+    def __init__(self, arg: str) -> None:
+        super().__init__(
+            f"malformed hash argument {arg!r}: expected {MIN_PREFIX_LEN}-{FULL_HASH_LEN} "
+            f"hex characters, optionally prefixed with {_SHA_PREFIX!r}"
+        )
+        self.arg = arg
+
+
+@dataclass(frozen=True, slots=True)
+class Recovery:
+    """The outcome for one normalised hash argument.
+
+    ``full_hash`` and ``command`` are set only for ``COMMAND``; ``location`` is
+    ``<path>:<line>`` for ``COMMAND``, the session's transcript path (or empty)
+    for ``SESSION``, and empty otherwise.
+    """
+
+    arg: str
+    status: RecoveryStatus
+    full_hash: str
+    session_id: str
+    location: str
+    command: str
+
+
+@dataclass(frozen=True, slots=True)
+class _Match:
+    path: Path
+    line: int
+    command: str
+
+
+def normalise_hash_arg(raw: str) -> str:
+    """Lower-case, strip an optional ``sha256:`` prefix, and require 8-64 hex
+    characters. Raises MalformedHashError naming ``raw`` otherwise."""
+    value = raw.lower()
+    if value.startswith(_SHA_PREFIX):
+        value = value[len(_SHA_PREFIX):]
+    if not MIN_PREFIX_LEN <= len(value) <= FULL_HASH_LEN or not _HEX_RE.fullmatch(value):
+        raise MalformedHashError(raw)
+    return value
+
+
+def normalise_args(raws: Iterable[str]) -> list[str]:
+    """Normalise every argument (raising on the first malformed one) and
+    collapse duplicates, keeping first-seen order."""
+    seen: dict[str, None] = {}
+    for raw in raws:
+        seen.setdefault(normalise_hash_arg(raw), None)
+    return list(seen)
+
+
+def _escape_char(ch: str) -> str:
+    if ch in _SIMPLE_ESCAPES:
+        return _SIMPLE_ESCAPES[ch]
+    if unicodedata.category(ch) in _ESCAPED_CATEGORIES:
+        return f"\\u{ord(ch):04x}"
+    return ch
+
+
+def escape_command(command: str) -> str:
+    """One-line form of ``command``: tab, CR, LF as ``\\t``, ``\\r``, ``\\n``;
+    every other control character (C0, DEL, C1) and the Unicode line and
+    paragraph separators as ``\\uXXXX``; everything else literal."""
+    return "".join(_escape_char(ch) for ch in command)
+
+
+def format_command(command: str, max_chars: int) -> str:
+    """Escape ``command`` and, if the escaped text is longer than ``max_chars``
+    (0 = no limit), cut it without splitting an escape sequence and append
+    ``…[+N chars]``, N being the number of escaped characters cut."""
+    tokens = [_escape_char(ch) for ch in command]
+    total = sum(len(t) for t in tokens)
+    if max_chars == 0 or total <= max_chars:
+        return "".join(tokens)
+    kept: list[str] = []
+    used = 0
+    for token in tokens:
+        if used + len(token) > max_chars:
+            break
+        kept.append(token)
+        used += len(token)
+    return "".join(kept) + f"…[+{total - used} chars]"
+
+
+def format_line(rec: Recovery, max_chars: int) -> str:
+    """The tab-separated output line for one Recovery."""
+    command = format_command(rec.command, max_chars) if rec.command else ""
+    return "\t".join(
+        [rec.arg, rec.status.value, rec.full_hash, rec.session_id, rec.location, command]
+    )
+
+
+def iter_bash_commands(path: Path) -> Iterator[tuple[int, str]]:
+    """Yield (1-based line number, command) for every Bash tool_use in one
+    transcript file. A line that is not valid UTF-8 or JSON (a transcript still
+    being written can end mid-record) or whose command cannot be hashed (a lone
+    surrogate) cannot hold a recoverable command and is skipped."""
+    with path.open("rb") as fh:
+        for lineno, raw in enumerate(fh, start=1):
+            if _BASH_MARKER not in raw:
+                continue
+            try:
+                record = json.loads(raw.decode("utf-8"))
+            except (UnicodeDecodeError, json.JSONDecodeError):
+                continue
+            for command in _bash_commands_in(record):
+                try:
+                    command.encode()
+                except UnicodeEncodeError:
+                    continue
+                yield lineno, command
+
+
+def _bash_commands_in(record: object) -> Iterator[str]:
+    if not isinstance(record, dict):
+        return
+    message = record.get("message")
+    if not isinstance(message, dict):
+        return
+    content = message.get("content")
+    if not isinstance(content, list):
+        return
+    for block in content:
+        if (
+            isinstance(block, dict)
+            and block.get("type") == "tool_use"
+            and block.get("name") == "Bash"
+            and isinstance(block.get("input"), dict)
+            and isinstance(block["input"].get("command"), str)
+        ):
+            yield block["input"]["command"]
+
+
+def session_of(path: Path) -> str:
+    """The session uuid a transcript belongs to: its stem for a main
+    transcript, the parent session directory for a subagent transcript."""
+    if path.parent.name == "subagents":
+        return path.parent.parent.name
+    return path.stem
+
+
+def session_transcripts(projects_dir: Path, session_id: str) -> list[Path]:
+    """Main transcript(s) first, then subagent transcripts, each sorted."""
+    pattern = glob.escape(session_id)
+    return sorted(projects_dir.glob(f"*/{pattern}.jsonl")) + sorted(
+        projects_dir.glob(f"*/{pattern}/subagents/*.jsonl")
+    )
+
+
+def all_transcripts(projects_dir: Path) -> list[Path]:
+    return sorted(projects_dir.glob("*/*.jsonl")) + sorted(
+        projects_dir.glob("*/*/subagents/*.jsonl")
+    )
+
+
+def _fired_sessions(hooks_dir: Path | None) -> dict[str, dict[str, str]]:
+    """{full hash: {session_id: latest ts}} for every bash-security-review fire."""
+    db_file = telemetry_store.db_path(hooks_dir)
+    if not db_file.is_file():
+        return {}
+    conn = db.connect(db_file, readonly=True)
+    try:
+        rows = conn.execute(
+            "SELECT input_hash, session_id, MAX(ts) FROM telemetry_events "
+            "WHERE hook = ? GROUP BY input_hash, session_id",
+            (_HOOK,),
+        ).fetchall()
+    finally:
+        conn.close()
+    fired: dict[str, dict[str, str]] = {}
+    for input_hash, session_id, ts in rows:
+        full = input_hash[len(_SHA_PREFIX):] if input_hash.startswith(_SHA_PREFIX) else input_hash
+        fired.setdefault(full, {})[session_id] = ts
+    return fired
+
+
+def _scan(files: Sequence[Path], args: Sequence[str]) -> dict[str, _Match]:
+    """Read each file once; return the first occurrence of every command whose
+    hash starts with one of ``args``."""
+    by_len: dict[int, set[str]] = {}
+    for arg in args:
+        by_len.setdefault(len(arg), set()).add(arg)
+    found: dict[str, _Match] = {}
+    for path in files:
+        for lineno, command in iter_bash_commands(path):
+            digest = hashlib.sha256(command.encode()).hexdigest()
+            if digest in found:
+                continue
+            if any(digest[:n] in prefixes for n, prefixes in by_len.items()):
+                found[digest] = _Match(path, lineno, command)
+    return found
+
+
+def recover(
+    args: Sequence[str],
+    *,
+    projects_dir: Path | None = None,
+    hooks_dir: Path | None = None,
+    scan_all: bool = False,
+) -> list[Recovery]:
+    """One Recovery per argument, in order. ``args`` must already be
+    normalised (see normalise_args)."""
+    projects = projects_dir if projects_dir is not None else paths.claude_projects_dir()
+    fired = _fired_sessions(hooks_dir)
+    fired_matches = {arg: sorted(h for h in fired if h.startswith(arg)) for arg in args}
+
+    if scan_all:
+        files = all_transcripts(projects)
+    else:
+        sessions = sorted(
+            {s for hashes in fired_matches.values() for h in hashes for s in fired[h]}
+        )
+        files = [f for s in sessions for f in session_transcripts(projects, s)]
+    found = _scan(files, args)
+
+    results: list[Recovery] = []
+    for arg in args:
+        candidates = set(fired_matches[arg])
+        if scan_all:
+            candidates.update(h for h in found if h.startswith(arg))
+        if not candidates:
+            results.append(Recovery(arg, RecoveryStatus.UNKNOWN, "", "", "", ""))
+            continue
+        if len(candidates) > 1:
+            results.append(Recovery(arg, RecoveryStatus.AMBIGUOUS, "", "", "", ""))
+            continue
+        [full] = candidates
+        match = found.get(full)
+        if match is not None:
+            results.append(Recovery(
+                arg, RecoveryStatus.COMMAND, full, session_of(match.path),
+                f"{match.path}:{match.line}", match.command,
+            ))
+            continue
+        session_ts = fired[full]
+        latest = max(session_ts, key=lambda s: (session_ts[s], s))
+        transcripts = session_transcripts(projects, latest)
+        location = str(transcripts[0]) if transcripts else ""
+        results.append(Recovery(arg, RecoveryStatus.SESSION, "", latest, location, ""))
+    return results

{cc_session_tools-4.0.2 → cc_session_tools-4.1.0}/src/cc_session_tools/lib/hook_registry.py

@@ -32,7 +32,6 @@ HOOK_VERBS: dict[str, str] = {
     "catchup": "hooks.catchup",
     "pending-migration": "hooks.pending_migration",
     "context-window-warning": "hooks.context_window_warning",
-    "pending-rename": "hooks.pending_rename",
     "pdata-sync": "hooks.pdata_sync",
 }
 
@@ -50,7 +49,6 @@ HOOK_DESCRIPTIONS: dict[str, str] = {
     "catchup": "Reconciles+launches missed scheduled jobs (ccsched) detached and surfaces a catch-up digest (SessionStart + UserPromptSubmit)",
     "pending-migration": "Detects legacy pre-1.0.0 flat-file data left unmigrated (ccmsg/ccsched/sessions/telemetry) and surfaces a FAIL digest pointing at `ccst migrate all`, plus pdata project databases still on format 3 (integer ids) pointing at `ccst pdata migrate-uuid` and the runbook; honours `ccst doctor --mute` (SessionStart)",
     "context-window-warning": "Nudges toward /compact when the context window passes 150k/200k tokens; silenced for the session by /context-override (Stop)",
-    "pending-rename": "Surfaces `.pending-rename` markers left by the move-session skill, skipping those whose /rename already landed and collapsing the list above 3; self-times-out at 5s with a visible notice (SessionStart)",
     "pdata-sync": "Multi-laptop `ccst pdata` sync: rehydrates this project's DB from the published dump when it dominates local and the project isn't occupied by another live session (SessionStart), and publishes a fresh dump when local has new writes (SessionEnd); surfaces forks/checksum failures via Telegram + the catch-up digest",
 }
 

{cc_session_tools-4.0.2 → cc_session_tools-4.1.0}/src/cc_session_tools/lib/paths.py

@@ -21,3 +21,10 @@ def data_home() -> Path:
     if override:
         return Path(override)
     return Path.home() / ".local" / "share" / "claude"
+
+
+def claude_projects_dir() -> Path:
+    """Claude Code's transcript root, ~/.claude/projects (one <encoded-cwd>
+    directory per project, holding <uuid>.jsonl and <uuid>/subagents/*.jsonl).
+    Resolved on each call so tests that redirect Path.home() see their own."""
+    return Path.home() / ".claude" / "projects"

{cc_session_tools-4.0.2 → cc_session_tools-4.1.0}/src/cc_session_tools/lib/pdata/sync_notify.py

@@ -14,17 +14,13 @@ writes to, so a conflict is picked up by the existing `surface.surface()` / `dig
 pipeline (the machinery behind `[cc-scheduler] scheduled-task catch-up: ...`) with no second
 digest-plumbing path to maintain.
 
-This deliberately does NOT reuse the other SessionStart mechanism this repo has —
-`hooks.pending_rename`'s dedicated `.pending-rename`-marker bash hook. That mechanism is not
-a general-purpose "digest queue" a second caller can feed; it is a bespoke marker file plus a
-bespoke bash script checking exactly that one file, with no reusable write-side API at all —
-using it here would mean building a third channel (a new marker format, a new SessionStart hook
-script), which is exactly the "not building either channel" scope this module is meant to stay
-inside. It would also be redundant for the case it might otherwise justify itself for: a live
-session that just hit a conflict already gets an immediate, in-the-moment
-`hookSpecificOutput`/`systemMessage` straight from the calling hook (see Task 12's
-`hooks.pdata_sync`, which prints its own message using the same JSON protocol as
-`catchup.py`'s `_emit`, exactly like `pending_rename.py` does) — no digest round-trip needed.
+This deliberately does NOT add a dedicated SessionStart channel (a marker file plus its own
+hook script): that would be a third channel with no reusable write-side API, which is exactly
+the "not building either channel" scope this module is meant to stay inside. It would also be
+redundant for the case it might otherwise justify itself for: a live session that just hit a
+conflict already gets an immediate, in-the-moment `hookSpecificOutput`/`systemMessage` straight
+from the calling hook (see Task 12's `hooks.pdata_sync`, which prints its own message using the
+same JSON protocol as `catchup.py`'s `_emit`) — no digest round-trip needed.
 
 The ledger *is* still the right channel for the one case that genuinely needs it: a conflict
 discovered by Task 13's hourly bundled `ccsched` job, with no session open to print anything live.

{cc_session_tools-4.0.2 → cc_session_tools-4.1.0}/src/cc_session_tools/lib/session_gc.py

@@ -35,12 +35,12 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from cc_session_tools.lib import db as _db
+from cc_session_tools.lib import paths as _paths
 from cc_session_tools.lib.messaging.store import store_root as _default_messages_root
 from cc_session_tools.lib.scheduler.state import parse_ts_or_none as _parse_ts_or_none
 from cc_session_tools.lib.scheduler.store import scheduler_dir as _default_scheduler_dir
 from cc_session_tools.lib.sessions_db import default_db_path as _default_sessions_db_path
 
-DEFAULT_PROJECTS_DIR = Path.home() / ".claude" / "projects"
 DEFAULT_SESSION_ENV_DIR = Path.home() / ".claude" / "session-env"
 DEFAULT_MIN_AGE_HOURS = 24.0
 
@@ -217,7 +217,7 @@ def build_report(
     override, e.g. ``CC_SCHEDULER_DIR`` / ``CCST_MESSAGES_ROOT`` /
     ``CCST_SESSIONS_DIR``).
     """
-    projects_dir = projects_dir if projects_dir is not None else DEFAULT_PROJECTS_DIR
+    projects_dir = projects_dir if projects_dir is not None else _paths.claude_projects_dir()
     scheduler_dir = scheduler_dir if scheduler_dir is not None else _default_scheduler_dir()
     messages_root = messages_root if messages_root is not None else _default_messages_root()
     session_env_dir = (
@@ -488,7 +488,7 @@ def prune(
     ``only``, when given, restricts processing to that subset of
     ``STORE_NAMES``.
     """
-    projects_dir = projects_dir if projects_dir is not None else DEFAULT_PROJECTS_DIR
+    projects_dir = projects_dir if projects_dir is not None else _paths.claude_projects_dir()
     scheduler_dir = scheduler_dir if scheduler_dir is not None else _default_scheduler_dir()
     messages_root = messages_root if messages_root is not None else _default_messages_root()
     session_env_dir = (

{cc_session_tools-4.0.2 → cc_session_tools-4.1.0}/src/cc_session_tools/lib/sessions.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Iterator
 
+from cc_session_tools.lib import paths as _paths
 from cc_session_tools.lib.rules import encode_cwd
 
 SESSION_BASENAME_RE = re.compile(r"^(\d{8})(?:-to-\d{8})?-")
@@ -316,7 +317,7 @@ def transcript_dir_for_project(project_dir: Path) -> Path:
     Encoding: each '/' and '.' in the absolute project path is replaced with '-'.
     Does not check whether the directory exists.
     """
-    return Path.home() / ".claude" / "projects" / encode_cwd(str(project_dir))
+    return _paths.claude_projects_dir() / encode_cwd(str(project_dir))
 
 
 def _jsonl_has_custom_title(jsonl: Path, basename: str, suffix: str) -> bool: