cc-session-tools 2.7.0__tar.gz → 2.7.2__tar.gz

{cc_session_tools-2.7.0/src/cc_session_tools.egg-info → cc_session_tools-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 2.7.0
+Version: 2.7.2
 Summary: Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (cccs_hooks)
 Author: raffishquartan
 License: MIT License
@@ -687,6 +687,8 @@ Where `<name>` is one of:
 | `messaging-deliver` | `cccs_hooks.messaging_deliver` |
 | `catchup` | `cccs_hooks.catchup` |
 | `context-window-warning` | `cccs_hooks.context_window_warning` |
+| `pending-migration` | `cccs_hooks.pending_migration` |
+| `pending-rename` | `cccs_hooks.pending_rename` |
 
 The dispatcher reads the event payload from stdin, calls the matching module's
 `main()`, and propagates its exit code.
@@ -795,7 +797,7 @@ The `ccst` umbrella CLI provides hook and skill management, shell helper install
 Brings `~/.claude/settings.json` into line with a source `settings.json`: adds
 the hooks it is missing, and removes any entry naming a hook this build of CCST
 cannot run. With no `--source`, auto-discovers the bundled
-`config/hooks-bundle.json` and installs all eleven default hooks.
+`config/hooks-bundle.json` and installs all thirteen default hooks.
 
 ```sh
 # Dry run (default) - shows what would be added

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/README.md

@@ -630,6 +630,8 @@ Where `<name>` is one of:
 | `messaging-deliver` | `cccs_hooks.messaging_deliver` |
 | `catchup` | `cccs_hooks.catchup` |
 | `context-window-warning` | `cccs_hooks.context_window_warning` |
+| `pending-migration` | `cccs_hooks.pending_migration` |
+| `pending-rename` | `cccs_hooks.pending_rename` |
 
 The dispatcher reads the event payload from stdin, calls the matching module's
 `main()`, and propagates its exit code.
@@ -738,7 +740,7 @@ The `ccst` umbrella CLI provides hook and skill management, shell helper install
 Brings `~/.claude/settings.json` into line with a source `settings.json`: adds
 the hooks it is missing, and removes any entry naming a hook this build of CCST
 cannot run. With no `--source`, auto-discovers the bundled
-`config/hooks-bundle.json` and installs all eleven default hooks.
+`config/hooks-bundle.json` and installs all thirteen default hooks.
 
 ```sh
 # Dry run (default) - shows what would be added

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cc-session-tools"
-version = "2.7.0"
+version = "2.7.2"
 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.7.0 → cc_session_tools-2.7.2}/src/cc_session_tools/cli/ccst.py

@@ -1071,12 +1071,14 @@ def _cmd_pdata_init(args: argparse.Namespace) -> int:
             )
         except (FileNotFoundError, ValueError) as exc:
             print(f"ccst pdata: {exc}", file=sys.stderr)
+            print(f"ERROR: {exc}")
             return 2
 
         if write_result.failure is not None:
             print("ccst pdata init: verification failed, nothing was cut over:", file=sys.stderr)
             for reason in write_result.failure.reasons:
                 print(f"  - {reason}", file=sys.stderr)
+            print(f"ERROR: verification failed ({len(write_result.failure.reasons)} reason(s))")
             return 1
 
         print(
@@ -1088,6 +1090,8 @@ def _cmd_pdata_init(args: argparse.Namespace) -> int:
             print(f"  cut over: {path}")
         print()
         print(write_result.report)  # spec §7.1 step 4's diff report, for review
+        print(f"\nVerify: ccst pdata verify --project {args.project} --full")
+        print("SUCCESS")
         return 0
 
 
@@ -2094,7 +2098,11 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     pdata_init_parser.add_argument(
         "--write", action="store_true",
-        help="Perform the write/verify/backup/cutover phase (default: dry-run only)",
+        help=(
+            "Perform the write/verify/backup/cutover phase (default: dry-run only). "
+            "Streams progress to stdout and also writes it to "
+            "<project>/ccst-pdata-init-write.log"
+        ),
     )
 
     pdata_reconcile_parser = pdata_sub.add_parser(

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/src/cc_session_tools/config/hooks-bundle.json

@@ -26,6 +26,12 @@
             "command": "ccst hooks run pending-migration",
             "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..."
           }
         ]
       }

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/src/cc_session_tools/lib/db.py

@@ -128,9 +128,19 @@ def backup_to(source_path: Path, dest_path: Path) -> None:
     cp needed (sqlite3.Connection.backup() handles this internally). Used by
     `ccst backup run` (Phase 7) and by migration scripts' pre-cutover safety
     copies.
+
+    The source opens through this module's own connect(readonly=True) — the same
+    WAL/busy-timeout-aware helper every other store connection in the codebase uses — so a
+    backup never takes any lock on the live source file (a plain sqlite3.connect() call would
+    still be a real, if short-lived, connection to a file this function's whole job is to
+    leave completely undisturbed). The destination is a throwaway file this function creates
+    and populates in one call, never reopened afterward, so it connects directly via plain
+    sqlite3.connect() rather than through connect() — routing it through the WAL-enabling
+    helper would just leave -wal/-shm sidecars on a file with no second reader to benefit from
+    WAL mode.
     """
     dest_path.parent.mkdir(parents=True, exist_ok=True)
-    src = sqlite3.connect(str(source_path))
+    src = connect(source_path, readonly=True)
     dst = sqlite3.connect(str(dest_path))
     try:
         src.backup(dst)

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/src/cc_session_tools/lib/hook_registry.py

@@ -32,6 +32,7 @@ HOOK_VERBS: dict[str, str] = {
     "catchup": "cccs_hooks.catchup",
     "pending-migration": "cccs_hooks.pending_migration",
     "context-window-warning": "cccs_hooks.context_window_warning",
+    "pending-rename": "cccs_hooks.pending_rename",
 }
 
 
@@ -48,6 +49,7 @@ 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`; 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)",
 }
 
 # Every settings.json hook entry CCST owns is spelled `ccst hooks run <name>`.

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/src/cc_session_tools/lib/pdata/backup.py

@@ -5,6 +5,7 @@ import os
 import sqlite3
 import tarfile
 import time
+from collections.abc import Callable
 from pathlib import Path
 
 from cc_session_tools.lib import db, paths
@@ -16,7 +17,14 @@ BACKUP_DIR_ENV = "CCST_PDATA_BACKUP_DIR"
 # mounted into WSL2) are often momentary — retry a few times before giving up rather than
 # crashing the whole --write run on the first blip.
 _MAX_ATTEMPTS = 3
-_RETRY_BACKOFF_SECONDS = (1, 2)
+_RETRY_BACKOFF_BASE_SECONDS = 1
+
+
+def _backoff_seconds(attempt: int) -> float:
+    """Exponential backoff (1s, 2s, 4s, ...) keyed only off the attempt number — unlike a
+    fixed-length lookup tuple, this can't drift out of sync with _MAX_ATTEMPTS if that
+    constant is ever changed without a matching edit elsewhere."""
+    return _RETRY_BACKOFF_BASE_SECONDS * (2 ** (attempt - 1))
 
 
 class BackupError(Exception):
@@ -29,10 +37,11 @@ def backup_dir() -> Path:
 
 
 def _snapshot_db_into_tar(tar: tarfile.TarFile, *, project: str, tmp_dir: Path) -> None:
-    """Add a point-in-time consistent copy of the project's .db to the archive, via the
-    sqlite3 backup API rather than a raw file copy — a raw copy of a WAL-mode database can
-    miss rows still sitting in the -wal file that haven't been checkpointed into the main
-    file yet. No-op if the project has no .db yet (a brand-new project's first --write).
+    """Add a point-in-time consistent copy of the project's .db to the archive, via
+    db.backup_to() (the sqlite3 backup API, WAL-safe — a raw file copy of a WAL-mode database
+    can miss rows still sitting in the -wal file that haven't been checkpointed into the main
+    file yet) rather than a raw copy. No-op if the project has no .db yet (a brand-new
+    project's first --write).
 
     Added under a `_pdata-db/` prefix distinct from the `<project>/` prefix that
     `create_backup()` uses for project_root's own contents — this snapshot is CCST's own
@@ -40,32 +49,25 @@ def _snapshot_db_into_tar(tar: tarfile.TarFile, *, project: str, tmp_dir: Path)
     not project content, so a human restoring `<project>/...` from this archive into
     project_root must never end up with a stray `.db` file mixed into their project files.
 
-    The source connection goes through the shared lib/db.py helper, readonly, matching this
-    repo's data-store convention (WAL + busy-timeout applied consistently). The destination
-    is a throwaway temp file immediately tar'd and deleted, not a persistent store, so it
-    connects directly via sqlite3.connect() — routing it through the WAL-enabling helper
-    would just leave -wal/-shm sidecars to clean up around a file that exists for a few
-    lines and is never reopened."""
+    The destination is a throwaway temp file immediately tar'd and deleted, not a persistent
+    store — db.backup_to() opens it via a plain (non-WAL) connection for exactly that reason,
+    since routing a file that exists for a few lines and is never reopened through the
+    WAL-enabling helper would just leave -wal/-shm sidecars to clean up."""
     db_source = store.db_path(project)
     if not db_source.exists():
         return
     snapshot_path = tmp_dir / f"{project}.db"
     try:
-        src_conn = db.connect(db_source, readonly=True)
-        try:
-            dst_conn = sqlite3.connect(snapshot_path)
-            try:
-                src_conn.backup(dst_conn)
-            finally:
-                dst_conn.close()
-        finally:
-            src_conn.close()
+        db.backup_to(db_source, snapshot_path)
         tar.add(snapshot_path, arcname=f"_pdata-db/{project}.db")
     finally:
         snapshot_path.unlink(missing_ok=True)
 
 
-def create_backup(*, project: str, project_root: Path) -> Path:
+def create_backup(
+    *, project: str, project_root: Path,
+    on_progress: Callable[[str], None] | None = None,
+) -> Path:
     """tar.gz snapshot of project_root as it stands right now, written outside
     project_root (spec §7.1 step 5 — "stored outside the project folder, before
     touching any original file"). One backup per --write invocation; never
@@ -73,10 +75,17 @@ def create_backup(*, project: str, project_root: Path) -> Path:
     philosophy (spec goals).
 
     Written to a temp path first and atomically renamed to the final
-    `<project>-<epoch>.tar.gz` name only once the archive is fully and successfully written —
-    a failed or interrupted run never leaves a corrupt file at the name a valid backup would
-    use. Transient OSErrors (e.g. a flaky network/DrvFS-backed project_root) are retried a
-    bounded number of times before raising BackupError.
+    `<project>-<YYYYMMDD-HHMMSS>.tar.gz` name only once the archive is fully and successfully
+    written — a failed or interrupted run never leaves a corrupt file at the name a valid
+    backup would use. The timestamp is second-granularity specifically so it keeps the same
+    collision-resistance across reruns within the same minute that the epoch it replaced had
+    — a coarser (e.g. minute-only) format would need a separate numeric tie-breaker to match.
+    Transient OSErrors (e.g. a flaky network/DrvFS-backed project_root) are retried a
+    bounded number of times before raising BackupError. Each failed attempt is reported
+    through on_progress (if given) before the retry sleep — otherwise a multi-attempt backup
+    that eventually succeeds leaves no trace in --write's progress log of the retries it took,
+    and a backup that eventually fails only ever shows the final BackupError, not what each
+    individual attempt actually hit.
 
     sqlite3.Error is caught alongside OSError because it is NOT an OSError subclass, yet
     _snapshot_db_into_tar's sqlite3 backup-API call can raise one (e.g. sqlite3.OperationalError
@@ -86,7 +95,7 @@ def create_backup(*, project: str, project_root: Path) -> Path:
     """
     target_dir = backup_dir()
     target_dir.mkdir(parents=True, exist_ok=True)
-    final_path = target_dir / f"{project}-{int(time.time())}.tar.gz"
+    final_path = target_dir / f"{project}-{time.strftime('%Y%m%d-%H%M%S')}.tar.gz"
     tmp_path = final_path.parent / (final_path.name + ".tmp")
 
     last_exc: OSError | sqlite3.Error | None = None
@@ -100,8 +109,10 @@ def create_backup(*, project: str, project_root: Path) -> Path:
         except (OSError, sqlite3.Error) as exc:
             last_exc = exc
             tmp_path.unlink(missing_ok=True)
+            if on_progress is not None:
+                on_progress(f"  backup attempt {attempt}/{_MAX_ATTEMPTS} failed: {exc}")
             if attempt < _MAX_ATTEMPTS:
-                time.sleep(_RETRY_BACKOFF_SECONDS[attempt - 1])
+                time.sleep(_backoff_seconds(attempt))
     raise BackupError(
         f"backup of {project!r} failed after {_MAX_ATTEMPTS} attempts: {last_exc}"
     ) from last_exc

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/src/cc_session_tools/lib/pdata/init_service.py

@@ -218,7 +218,9 @@ def write(
         # rehearsal sandbox (backup_dir_override), never in the real backup dir.
         _emit(on_progress, "Backing up project and database before cutover...")
         try:
-            backup_path = backup.create_backup(project=project, project_root=project_root)
+            backup_path = backup.create_backup(
+                project=project, project_root=project_root, on_progress=on_progress,
+            )
             _emit(on_progress, f"Backup written: {backup_path}")
         except backup.BackupError as exc:
             _emit(on_progress, "Backup failed — rolling back inserted rows...")

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/src/cc_session_tools/lib/pdata/write_log.py

@@ -90,8 +90,19 @@ class WriteLog:
         assert self._real_stderr is not None, "WriteLog.__exit__ called without a completed __enter__"
 
         if exc is not None:
+            # The exc_type/exc pairing is a stdlib __exit__ contract guarantee (exc_type is
+            # only ever None when exc is too), not something this method re-derives — same
+            # rationale as the asserts above.
+            assert exc_type is not None, "WriteLog.__exit__ called with exc but no exc_type"
             try:
                 traceback.print_exception(exc_type, exc, tb, file=self._file)
+                # An explicit sentinel line after the traceback, matching the ERROR/SUCCESS
+                # contract the CLI's own known exit paths write via print() — this is the one
+                # path that never reaches back to those print() calls, since the exception
+                # escapes the `with` block entirely. Without it, an absent sentinel would mean
+                # two different things (an escaped exception vs. the process being killed
+                # before __exit__ ran) instead of just the latter.
+                self._file.write(f"ERROR: {exc_type.__name__}: {exc}\n")
                 self._file.flush()
             except OSError:
                 pass  # same best-effort contract as _Tee — never let the log itself crash

cc_session_tools-2.7.2/src/cc_session_tools/skills/move-session/hooks/sessionstart-pending-rename.sh

@@ -0,0 +1,206 @@
+#!/bin/bash
+# SessionStart hook for the move-session skill.
+#
+# Scans the resumed session's project cwd for `cc-sessions/*/.pending-rename`
+# markers (written by move_session.py on a tag-changing operation). When found,
+# emits a system reminder telling the model to run `/rename <tag>` to fix the
+# picker label and then delete the marker.
+#
+# CC supplies the project cwd in either CLAUDE_PROJECT_DIR (preferred) or via
+# the json payload on stdin (cwd field). We try both.
+#
+# Three behaviours keep the scan cheap, bounded, and never silent:
+#
+#   - The scan root is canonicalised once (`cd -P`), so a project reached
+#     through a symlink (~/cc/<project> -> a 9p-mounted Windows drive, say) is
+#     walked by its real path instead of resolving the symlink hop for every
+#     entry `find` touches. No-op on the common case of a real directory.
+#   - The scan runs in the background against a soft deadline
+#     (CCST_PENDING_RENAME_SOFT_TIMEOUT, whole seconds, default 5).
+#     Overrunning it prints a short "could not complete" notice with the
+#     manual command and exits 0. Without it, the harness kills the hook at
+#     its own timeout and the user sees nothing at all - not even the
+#     remediation block a found marker would have printed.
+#   - Markers whose rename has already been applied (the session transcript
+#     carries a `custom-title` equal to the marker's tag) are dropped from the
+#     report: they are noise, not a to-do. The marker file itself is left
+#     alone - deleting files stays a user action, run outside CC.
+#
+# Bash 3.2 compatible (macOS still ships 3.2): no mapfile, no `wait -n`, no
+# associative arrays, no dependency on GNU `timeout`.
+
+set -euo pipefail
+
+# Wall-clock budget starts here, not at the wait: an external command that
+# stalls during setup then eats its own delay instead of adding to the total.
+SECONDS=0
+
+# Whole seconds, and the registered hook timeout (10s in hooks-bundle.json)
+# needs real margin above it, not the 2s a stopwatch would suggest: a bare
+# `sleep 5` on the WSL2 box this was measured on returns after 7.94s in roughly
+# one run in five - the VM parks an idle vCPU and every timer, builtin or not,
+# inherits the slack. The margin has to cover that or the harness kills the
+# hook before the notice prints, which is the whole bug being fixed.
+soft_timeout="${CCST_PENDING_RENAME_SOFT_TIMEOUT:-5}"
+# Above this many still-pending markers the per-marker block is replaced by a
+# count plus the two bulk-clear commands; a long dump nobody reads is the
+# reason these reminders get ignored in the first place.
+detail_max=3
+
+# Best-effort cwd resolution. CLAUDE_PROJECT_DIR is set by CC for SessionStart
+# hooks; fall back to PWD if absent.
+project_cwd="${CLAUDE_PROJECT_DIR:-${PWD:-}}"
+if [[ -z "$project_cwd" || ! -d "$project_cwd" ]]; then
+  exit 0
+fi
+
+# Canonicalise the one directory we are about to walk. `cd -P` + `pwd` is the
+# portable idiom: `realpath` and `readlink -f` are absent or differently
+# spelled on macOS.
+if ! cc_sessions_dir="$(cd -P "$project_cwd/cc-sessions" 2>/dev/null && pwd)"; then
+  exit 0
+fi
+
+# Does this marker's rename already show up in the session's transcript? If so
+# the marker is stale and there is nothing for the user to do.
+marker_fulfilled() {
+  local marker="$1"
+  local uuid tag transcript
+
+  uuid="$(awk '/^uuid:/ {print $2; exit}' "$marker" 2>/dev/null || true)"
+  tag="$(awk '/^tag:/ {print $2; exit}' "$marker" 2>/dev/null || true)"
+  if [[ -z "$uuid" || -z "$tag" ]]; then
+    return 1
+  fi
+
+  # The marker records the UUID but not which project directory holds the
+  # transcript, so glob across all of them.
+  for transcript in "$HOME"/.claude/projects/*/"$uuid".jsonl; do
+    if [[ ! -f "$transcript" ]]; then
+      continue
+    fi
+    if grep -qE "\"type\": ?\"custom-title\".*\"customTitle\": ?\"$tag\"|\"customTitle\": ?\"$tag\".*\"type\": ?\"custom-title\"" "$transcript" 2>/dev/null; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+# Everything that touches the filesystem lives here, so the soft deadline
+# covers the transcript reads as well as the `find` walk.
+scan() {
+  local marker
+  find "$cc_sessions_dir" -maxdepth 2 -name ".pending-rename" -type f 2>/dev/null |
+    while IFS= read -r marker; do
+      if marker_fulfilled "$marker"; then
+        continue
+      fi
+      printf '%s\n' "$marker"
+    done
+}
+
+scan_out="$(mktemp "${TMPDIR:-/tmp}/pending-rename.XXXXXX")"
+scan_fifo="$scan_out.fifo"
+mkfifo "$scan_fifo"
+trap 'rm -f "$scan_out" "$scan_fifo"' EXIT
+# Opened read-write so the open does not block on a writer and the read below
+# never sees EOF while the scan is still running.
+exec 3<> "$scan_fifo"
+
+# The scan announces completion down the fifo. The background group takes
+# stdin/stdout/stderr away from this script's own descriptors, via `exec` so
+# bash does not stash the originals on a spare fd to restore later: killing the
+# group is not enough on its own, because bash defers a SIGTERM until the
+# command it is waiting on returns, and anything still holding the hook's
+# stdout keeps a caller that reads to EOF waiting for a hook that already
+# exited - exactly the stall the soft deadline exists to prevent.
+( exec > /dev/null 2>&1 < /dev/null; scan > "$scan_out" || true; printf 'done\n' >&3 ) &
+scan_pid=$!
+
+# The deadline is a loop of one-second `read -t` waits against an absolute
+# deadline, not one long wait for the whole budget. Two separate effects force
+# this shape:
+#
+#   - `read -t` is a builtin, so no /bin/sleep spawn can stall it. A poll loop
+#     spawning sleep per tick, and a sleep-based watchdog child, were both
+#     measured drifting 2-3s past budget on a loaded box.
+#   - A *single* long wait is not enough either. Any wait can come back ~2.9s
+#     late on a hypervisor that parks an idle vCPU - `sleep`, `read -t`, and
+#     even a pure CPU busy-loop all show it, at 3/20 runs for both `sleep 5`
+#     and `read -t 5`. Re-arming 1s waits cut that to 1/46 runs here, so it
+#     reduces the exposure rather than removing it: a 1s wait can still slip.
+#     The registered timeout (hooks-bundle.json) carries the residue - it is
+#     sized for this deadline plus a whole slack event plus emit time, not for
+#     the deadline plus a token couple of seconds.
+#
+# macOS ships no GNU `timeout`, and `wait` has no timeout of its own. Whole
+# seconds only - bash 3.2's `read -t` rejects fractions.
+scan_completed=0
+while [[ $SECONDS -lt $soft_timeout ]]; do
+  if read -t 1 -r _ <&3; then
+    scan_completed=1
+    break
+  fi
+done
+
+if [[ $scan_completed -eq 0 ]]; then
+  # Only the immediate child is signalled; a `find` it spawned may outlive it
+  # briefly, writing into a file we are about to delete. Harmless, and cheaper
+  # than turning on job control just to signal a process group.
+  kill "$scan_pid" 2>/dev/null || true
+  echo "Pending session-rename check gave up after ${soft_timeout}s (slow filesystem?) - markers, if any, were not read."
+  echo ""
+  echo "To run the check by hand outside CC:"
+  echo "    find \"$cc_sessions_dir\" -name .pending-rename    # this project"
+  echo "    find -L ~/cc -name .pending-rename                 # all projects"
+  exit 0
+fi
+
+# Portable read loop rather than `mapfile` (bash 4.0+ only) - this script's
+# shebang binds to /bin/bash, which is bash 3.2 on macOS.
+markers=()
+while IFS= read -r marker; do
+  markers+=("$marker")
+done < "$scan_out"
+if [[ ${#markers[@]} -eq 0 ]]; then
+  exit 0
+fi
+
+if [[ ${#markers[@]} -gt $detail_max ]]; then
+  echo "${#markers[@]} pending session-rename markers in this project (per-marker detail suppressed above ${detail_max}). Clear this project, or every project:"
+  echo "    find \"$cc_sessions_dir\" -name .pending-rename -delete"
+  echo "    find -L ~/cc -name .pending-rename -delete"
+  exit 0
+fi
+
+# Build a single reminder block. The model reads this and acts on it.
+echo "${#markers[@]} pending session-rename marker(s) in this project (left by the move-session skill)."
+echo ""
+echo "TO SILENCE ALL REMINDERS IN THIS PROJECT AT ONCE (quick option):"
+echo "  Run this in a normal shell outside CC — deletes markers without updating picker labels:"
+echo "    find \"$cc_sessions_dir\" -name .pending-rename -delete"
+echo ""
+echo "TO SILENCE ALL REMINDERS ACROSS ALL PROJECTS AT ONCE:"
+echo "    find -L ~/cc -name .pending-rename -delete"
+echo ""
+echo "TO FIX AN INDIVIDUAL SESSION (updates picker label AND silences reminder):"
+echo "  1. Resume the session:  cd <project-dir> && claude --resume <uuid>"
+echo "  2. Run inside CC:       /rename <tag>  (shown per marker below)"
+echo "  3. Run outside CC:      rm <marker-path>  (shown per marker below)"
+echo ""
+echo "--- Markers in this project ---"
+echo ""
+i=0
+for marker in "${markers[@]}"; do
+  i=$((i + 1))
+  session_dir="$(dirname "$marker")"
+  tag_from_dir="$(basename "$session_dir")"
+  marker_uuid="$(awk '/^uuid:/ {print $2; exit}' "$marker" 2>/dev/null || true)"
+  marker_tag="$(awk '/^tag:/ {print $2; exit}' "$marker" 2>/dev/null || true)"
+  effective_tag="${marker_tag:-$tag_from_dir}"
+  echo "  [$i] UUID: ${marker_uuid:-unknown}"
+  echo "      Dir:  $session_dir"
+  echo "      Inside CC:   /rename $effective_tag"
+  echo "      Outside CC:  rm \"$marker\""
+  echo ""
+done

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/src/cc_session_tools/skills/pm-project-init/SKILL.md

@@ -103,6 +103,12 @@ explicit approval. **Never invoke `--write` without it.**
 ccst pdata init --project <project> [--rehearse <path>] --write
 ```
 
+`--write` streams progress to stdout as it runs and also writes everything printed - plus the
+traceback of anything that escapes unhandled - to `<project-root>/ccst-pdata-init-write.log`,
+flushed after every line. If a run hangs, crashes, or you're not sure what happened, read this
+log rather than re-running blind. It is excluded from classification (like the proposal file
+itself), so it never shows up as a manifest entry on a later dry-run.
+
 - **Exit 0:** everything imported, verified, backed up, and cut over. Report the backup tar path
   and the list of cut-over files to Chris.
 - **Exit 1:** verification failed. Nothing was cut over and no live rows were left behind (they
@@ -128,7 +134,12 @@ instruction.
 There is no `--rollback` flag. Recover by hand:
 
 1. Restore the backup tar (printed on a successful `--write`) over the project folder:
-   `tar -xzf <backup>.tar.gz -C <parent-of-project-root>`.
+   `tar -xzf <backup>.tar.gz -C <parent-of-project-root>`. This also drops a
+   `_pdata-db/<project>.db` sibling directory alongside `<project-root>` - a snapshot of the
+   project's SQLite store at backup time, CCST's own tool state, not project content. Never
+   move or copy it into `<project-root>` itself; if you need to restore the `.db`, copy it to
+   the real store path (`ccst pdata schema list --project <name>` will error with the current
+   path if you're unsure) and leave the extracted project folder alone.
 2. Undo the DB side with `ccst pdata delete --project <name> --id <id> --version <n>` for the
    specific rows that shouldn't have landed, or - for a wholesale bad run - delete the project's
    `.db` file directly and re-run `ccst pdata init` from scratch.

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2/src/cc_session_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 2.7.0
+Version: 2.7.2
 Summary: Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (cccs_hooks)
 Author: raffishquartan
 License: MIT License
@@ -687,6 +687,8 @@ Where `<name>` is one of:
 | `messaging-deliver` | `cccs_hooks.messaging_deliver` |
 | `catchup` | `cccs_hooks.catchup` |
 | `context-window-warning` | `cccs_hooks.context_window_warning` |
+| `pending-migration` | `cccs_hooks.pending_migration` |
+| `pending-rename` | `cccs_hooks.pending_rename` |
 
 The dispatcher reads the event payload from stdin, calls the matching module's
 `main()`, and propagates its exit code.
@@ -795,7 +797,7 @@ The `ccst` umbrella CLI provides hook and skill management, shell helper install
 Brings `~/.claude/settings.json` into line with a source `settings.json`: adds
 the hooks it is missing, and removes any entry naming a hook this build of CCST
 cannot run. With no `--source`, auto-discovers the bundled
-`config/hooks-bundle.json` and installs all eleven default hooks.
+`config/hooks-bundle.json` and installs all thirteen default hooks.
 
 ```sh
 # Dry run (default) - shows what would be added

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/src/cc_session_tools.egg-info/SOURCES.txt

@@ -137,6 +137,7 @@ src/cccs_hooks/messaging_deliver.py
 src/cccs_hooks/model_info.py
 src/cccs_hooks/normalise.py
 src/cccs_hooks/pending_migration.py
+src/cccs_hooks/pending_rename.py
 src/cccs_hooks/session_tag.py
 src/cccs_hooks/stats.py
 src/cccs_hooks/telemetry.py

cc_session_tools-2.7.2/src/cccs_hooks/pending_rename.py

@@ -0,0 +1,37 @@
+"""SessionStart hook: surface `.pending-rename` markers left by move-session.
+
+The implementation is the bash script bundled with the move-session skill —
+it is the thing the skill's bats suite grades, and it stays in bash so the
+skill remains self-contained for anyone reading or running it on its own.
+This module exists so the hook registers like every other CCST hook
+(`ccst hooks run pending-rename` in the bundle, one name in HOOK_VERBS,
+covered by the prune and doctor checks) instead of as a hand-written raw-path
+entry in someone's settings.json.
+
+`execv` rather than `subprocess`: the script owns stdin, stdout and the exit
+code, and replacing this process hands all three over with nothing left to
+forward.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import cc_session_tools
+
+HOOK_SCRIPT = (
+    Path(cc_session_tools.__file__).parent
+    / "skills"
+    / "move-session"
+    / "hooks"
+    / "sessionstart-pending-rename.sh"
+)
+
+
+def main() -> int:
+    """Hand the process over to the bundled hook script. Does not return."""
+    os.execvp("bash", ["bash", str(HOOK_SCRIPT)])
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/tests/test_ccst_doctor.py

@@ -545,7 +545,7 @@ def test_run_all_checks_includes_hook_checks(tmp_path: Path) -> None:
         skip_pypi=True,
     )
     hook_checks = [r for r in results if r.name.startswith("hook:")]
-    assert len(hook_checks) == 12  # all bundled hooks
+    assert len(hook_checks) == 13  # all bundled hooks
 
 
 def test_run_all_checks_warns_for_missing_hooks(tmp_path: Path) -> None:

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/tests/test_ccst_hook_dispatcher.py

@@ -69,5 +69,6 @@ def test_hook_verbs_covers_every_shim_module() -> None:
         "catchup",
         "pending-migration",
         "context-window-warning",
+        "pending-rename",
     }
     assert set(HOOK_VERBS) == expected

{cc_session_tools-2.7.0 → cc_session_tools-2.7.2}/tests/test_ccst_hooks_install_zero_arg.py

@@ -87,6 +87,7 @@ def test_hooks_install_bundle_all_hooks(tmp_path: Path) -> None:
         "ccst hooks run catchup",
         "ccst hooks run pending-migration",
         "ccst hooks run context-window-warning",
+        "ccst hooks run pending-rename",
     }
     assert expected == all_cmds, f"Missing: {expected - all_cmds}; extra: {all_cmds - expected}"