neander-checkpoints 0.1.0__tar.gz

neander_checkpoints-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 neander.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

neander_checkpoints-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: neander-checkpoints
+Version: 0.1.0
+Summary: Checkpoint management for Claude Code sessions
+License-Expression: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Dynamic: license-file

neander_checkpoints-0.1.0/README.md

@@ -0,0 +1,199 @@
+# neander_checkpoints
+
+Capture Claude Code sessions alongside your Git history. Understand *why* code changed, not just *what*. Resume where you left off — even on a different machine.
+
+Built natively for Claude Code using hooks, skills, and scripts. No external binaries. Install once, works automatically.
+
+## Why
+
+Your git log shows what code changed. But when AI writes your code, the *how* and *why* live in the conversation — prompts, reasoning, tool calls, dead ends, decisions. Without capturing that, you lose context the moment a session ends.
+
+neander_checkpoints solves this:
+
+- **Understand why code changed** — see the full prompt/response transcript and files touched for any checkpoint
+- **Keep git history clean** — checkpoint data lives on a separate orphan branch, never pollutes your working tree
+- **Onboard faster** — show teammates the path from prompt to change to commit
+- **Search across checkpoints** — find the checkpoint where you fixed the auth bug, by keyword, branch, file, or just asking in natural language
+- **Remote checkpoint support** — fetch checkpoints from remote with `--fetch`, search and browse across machines
+- **Cross-machine resume** — push checkpoints to remote, pull them on another machine, continue exactly where you left off
+
+## How it works
+
+Once installed, everything is automatic:
+
+1. **You code with Claude** — business as usual
+2. **On every commit**, a hook captures the session transcript and metadata as a checkpoint on the `neander/checkpoints/v1` orphan branch
+3. **On session end**, a final checkpoint captures everything even if no commits were made
+4. **Commits get linked** — a `Claude-Session` trailer is added so you can trace any commit back to the conversation that produced it
+5. **All reads go through the checkpoint branch** — commands read directly from git, not local files. Use `--fetch` to pull remote checkpoint data first
+
+When you need context, just ask naturally:
+
+| You say | What happens |
+|---|---|
+| "What did I do yesterday?" | Claude searches checkpoints, shows relevant results |
+| "Why did we make this change?" | Claude finds the checkpoint that touched the file, reads the transcript |
+
+| "Go back to before that change" | Claude lists checkpoints and offers to restore |
+| "How much did that checkpoint cost?" | Claude shows token usage and cost estimate |
+
+## Commands
+
+All commands work as Claude Code skills — Claude auto-invokes them based on conversation context. You can also use them explicitly as slash commands.
+
+All commands accept checkpoint IDs (16-char hex like `a3f8b9c1d2e4`), session IDs (UUIDs), or partial IDs.
+
+| Command | Description |
+|---|---|
+| `/neander-status` | Overview of active sessions and recent checkpoints |
+| `/neander-search` | Search checkpoints by keyword, branch, file, date, commit, or natural language |
+| `/neander-transcript` | View the condensed conversation transcript for a checkpoint |
+| `/neander-summarize` | Generate an AI summary (intent, outcome, learnings, friction, open items) and persist it |
+| `/neander-session-stats` | Token usage, cost estimate, duration, files modified for a checkpoint |
+| `/neander-redact` | Scan a transcript for secrets and PII before sharing |
+
+## Features
+
+### Status
+
+Shows the current session and recent checkpoints at a glance.
+
+```
+Current: 17e8f125 · opus · feat/impl-tasks-from-td · 0.4k tokens · 0 files
+         (not yet checkpointed)
+
+== Checkpoints (18 total) ==
+
+Checkpoint    Commit    Session   Date              Files  Topic
+------------  --------  --------  ----------------  -----  -----
+dfe7c7132205  70e684cf  37252de3  2026-03-28 13:20  9      Simplify the generate_tasks flow...
+b4d88d5d4fe9  70e684cf  37252de3  2026-03-28 13:20  9
+7b02e43d74db  67ff5c5c  37252de3  2026-03-28 13:18  9
+```
+
+### Search
+
+Find any checkpoint by keyword, branch, file, date, or commit — or just describe what you're looking for.
+
+```
+> "find the checkpoint where I fixed the WebSocket reconnection bugs"
+> /neander-search OAuth on feat/auth
+```
+
+### Transcripts
+
+Clean, readable conversation flow — strips IDE noise, tool results, and thinking blocks.
+
+```
+--- 2026-03-22 ---
+
+12:21 [User] Implement the following plan...
+
+12:21 [Assistant] I'll read both files in parallel.
+
+[Tool] Read: modules/chat/chat_websocket_handler.py
+
+[Tool] Edit: modules/chat/chat_websocket_handler.py
+
+[Tool] Bash: Run chat module tests
+
+12:22 [Assistant] Both fixes are done.
+
+12:30 [User] Can we also handle the edge case for...
+
+12:30 [Assistant] Good catch, I'll add validation.
+
+[Tool] Edit: modules/chat/chat_websocket_handler.py
+```
+
+### AI summaries
+
+Structured summaries generated once, persisted to the checkpoint branch, cached across sessions and machines.
+
+```
+### Intent
+Fix two reliability bugs in chat streaming: replay time window and upsert atomicity.
+
+### Outcome
+Both fixes implemented and tested.
+
+### Learnings
+**Code**:
+- `message_repository.py:94-121` — arrayFilters with $set is the right pattern for atomic MongoDB array updates
+
+### Friction
+- Unused datetime import needed a second cleanup pass
+
+### Open Items
+- Pre-existing test failure needs investigation
+```
+
+### Cross-machine resume
+
+Checkpoints are pushed to the remote automatically. On another machine:
+
+```
+# Fetches transcript from remote, prints: claude --resume <session-id>
+```
+
+
+### Secret redaction
+
+Three-layer detection before transcripts leave your machine:
+1. **Shannon entropy** — high-entropy strings (API keys, tokens)
+2. **Pattern matching** — 15+ known formats (AWS keys, GitHub PATs, JWTs, connection strings)
+3. **PII detection** — emails, phone numbers, SSNs
+
+See [EXAMPLES.md](EXAMPLES.md) for full output examples of every command.
+
+## Checkpoint format
+
+Stored on `neander/checkpoints/v1` — a versioned orphan branch that never touches your code history.
+
+```
+neander/checkpoints/v1/
+├── index.log                          # fast lookup index
+├── a3/
+│   └── f8b9c1d2e4567890/
+│       ├── metadata.json              # checkpoint ID, session IDs, commit, files, AI summary
+│       ├── transcript-<session-1>.jsonl
+│       └── transcript-<session-2>.jsonl
+```
+
+- **Multi-session** — concurrent sessions on the same commit don't collide
+- **Persisted summaries** — AI summaries cached in metadata.json
+- **Auto-push** — checkpoints pushed to remote after creation
+
+## Install
+
+```bash
+pip install neander-checkpoints
+```
+
+Then in any project:
+
+```bash
+cd /path/to/project
+neander-checkpoints install
+```
+
+That's it. The installer validates prerequisites (git repo, Claude Code, Python 3.10+), then copies scripts, skills, hooks, and permissions into the project's `.claude/` directory. Everything is self-contained — anyone who clones the repo gets it working out of the box.
+
+### What gets installed
+
+- **Scripts** — JSONL parser, checkpoint creator, secret redaction, session restore
+- **Skills** — 6 auto-invoked skills that Claude triggers based on conversation context
+- **Hooks** — `Stop` and `PostToolUse:Bash` hooks for automatic checkpointing and commit linking
+- **Permissions** — auto-allow rules so scripts run without approval prompts
+- **CLAUDE.md** — instructions telling Claude when to proactively use checkpoint tools
+- **Pre-push hook** — redacts secrets from transcripts before they leave your machine
+
+## Requirements
+
+- Python 3.10+
+- Claude Code 2.x
+- git
+
+## License
+
+MIT

neander_checkpoints-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "neander-checkpoints"
+version = "0.1.0"
+description = "Checkpoint management for Claude Code sessions"
+requires-python = ">=3.10"
+license = "MIT"
+
+[project.scripts]
+neander-checkpoints = "neander_checkpoints.cli:main"
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+neander_checkpoints = [
+    "bundled/scripts/*",
+    "bundled/skills/**/*",
+    "bundled/hooks/*",
+]

neander_checkpoints-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

neander_checkpoints-0.1.0/src/neander_checkpoints/__init__.py

@@ -0,0 +1,3 @@
+"""Checkpoint management for Claude Code sessions."""
+
+__version__ = "0.1.0"

neander_checkpoints-0.1.0/src/neander_checkpoints/bundled/hooks/hooks_config.json

@@ -0,0 +1,26 @@
+{
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash __SCRIPTS_DIR__/on_stop.sh 2>/dev/null || true"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash __SCRIPTS_DIR__/detect_commit.sh 2>/dev/null || true"
+          }
+        ]
+      }
+    ]
+  }
+}

neander_checkpoints-0.1.0/src/neander_checkpoints/bundled/hooks/project_claude_snippet.md

@@ -0,0 +1,36 @@
+## Checkpoint Management (neander_checkpoints)
+
+This project has checkpoint management tools installed in `.claude/scripts/` and `.claude/skills/`.
+
+### IMPORTANT: Always use skills, not raw scripts
+
+When the user asks about checkpoints, sessions, summaries, transcripts, or history, **invoke the corresponding skill using the Skill tool** — do NOT try to do it yourself with raw git commands or scripts. The skills handle persistence and formatting correctly.
+
+| User says | Invoke this skill |
+|---|---|
+| "summarize checkpoint ..." | `/neander-summarize` |
+| "show transcript ...", "what happened in ..." | `/neander-transcript` |
+| "search checkpoints ...", "find the checkpoint where ..." | `/neander-search` |
+| "what did I do yesterday/last week" | `/neander-search` |
+| "checkpoint stats", "how much did it cost" | `/neander-session-stats` |
+| "recent checkpoints", "what's been going on" | `/neander-status` |
+
+### When to use these tools proactively
+
+You don't need to wait for the user to run a slash command. Use the skills naturally when the context calls for it:
+
+- **User asks about previous work** → invoke `/neander-search`
+- **User asks about code history beyond git** → invoke `/neander-search`, then `/neander-transcript`
+- **User seems lost or is re-doing work** → invoke `/neander-search` to check if a previous checkpoint solved this
+
+### Available scripts (for direct use only when skills don't cover the case)
+
+All commands read from the git checkpoint branch. Use `--fetch` to pull remote data first. The primary flag is `--checkpoint`/`-c` (`--session`/`-s` still works as alias).
+
+```bash
+python3 __SCRIPTS_DIR__/parse_jsonl.py list --project <cwd>
+python3 __SCRIPTS_DIR__/parse_jsonl.py search --project <cwd> --keyword "text" --branch "name" --fetch
+python3 __SCRIPTS_DIR__/parse_jsonl.py stats --checkpoint <checkpoint-id>
+python3 __SCRIPTS_DIR__/parse_jsonl.py transcript --checkpoint <checkpoint-id>
+bash __SCRIPTS_DIR__/restore.sh <session-id> <cwd>
+```

neander_checkpoints-0.1.0/src/neander_checkpoints/bundled/scripts/checkpoint.sh

@@ -0,0 +1,173 @@
+#!/usr/bin/env bash
+#
+# checkpoint.sh — Save current session transcript to a git orphan branch.
+#
+# Creates/updates a neander/checkpoints/v1 orphan branch with session
+# transcripts and metadata. Supports multiple sessions per checkpoint.
+#
+# Usage:
+#   checkpoint.sh <session_jsonl_path> [commit_sha]
+#   checkpoint.sh --commit <sha> <path1> [path2] ...
+#
+
+set -euo pipefail
+
+CHECKPOINT_BRANCH="neander/checkpoints/v1"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PARSER="$SCRIPT_DIR/parse_jsonl.py"
+
+# Parse args
+SESSION_FILES=()
+COMMIT_SHA=""
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --commit)
+            COMMIT_SHA="$2"
+            shift 2
+            ;;
+        *)
+            SESSION_FILES+=("$1")
+            shift
+            ;;
+    esac
+done
+
+if [ ${#SESSION_FILES[@]} -eq 0 ]; then
+    echo "Usage: checkpoint.sh <session_jsonl_path> [commit_sha]" >&2
+    exit 1
+fi
+
+# Backward compat: if two positional args and second isn't a file, it's commit sha
+if [ ${#SESSION_FILES[@]} -ge 2 ] && [ -z "$COMMIT_SHA" ]; then
+    LAST_IDX=$(( ${#SESSION_FILES[@]} - 1 ))
+    LAST="${SESSION_FILES[$LAST_IDX]}"
+    if [ ! -f "$LAST" ]; then
+        COMMIT_SHA="$LAST"
+        unset "SESSION_FILES[$LAST_IDX]"
+    fi
+fi
+
+[ -z "$COMMIT_SHA" ] && COMMIT_SHA="$(git rev-parse HEAD 2>/dev/null || echo 'none')"
+
+TIMESTAMP="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+# Collect valid session IDs and files
+VALID_FILES=()
+SESSION_IDS=()
+for f in "${SESSION_FILES[@]}"; do
+    if [ ! -f "$f" ]; then
+        echo "Warning: Session file not found, skipping: $f" >&2
+        continue
+    fi
+    VALID_FILES+=("$f")
+    SESSION_IDS+=("$(basename "$f" .jsonl)")
+done
+
+if [ ${#VALID_FILES[@]} -eq 0 ]; then
+    echo "Error: No valid session files provided" >&2
+    exit 1
+fi
+
+# Generate checkpoint ID
+CHECKPOINT_INPUT=""
+for sid in "${SESSION_IDS[@]}"; do
+    CHECKPOINT_INPUT="${CHECKPOINT_INPUT}${sid}"
+done
+CHECKPOINT_INPUT="${CHECKPOINT_INPUT}${TIMESTAMP}"
+CHECKPOINT_ID="$(echo "$CHECKPOINT_INPUT" | shasum -a 256 | cut -c1-16)"
+
+# Shard directory
+SHARD_DIR="${CHECKPOINT_ID:0:2}/${CHECKPOINT_ID:2}"
+
+# Collect modified files from all sessions
+ALL_FILES_JSON="[]"
+for f in "${VALID_FILES[@]}"; do
+    stats="$(python3 "$PARSER" stats --session "$f" --json 2>/dev/null || echo '{}')"
+    files="$(echo "$stats" | python3 -c "import json,sys; print(json.dumps(json.load(sys.stdin).get('modified_files',[])))" 2>/dev/null || echo '[]')"
+    ALL_FILES_JSON="$(python3 -c "
+import json
+a = json.loads('$ALL_FILES_JSON')
+b = json.loads('$files')
+print(json.dumps(sorted(set(a + b))))
+")"
+done
+
+# Build session IDs JSON
+SESSION_IDS_JSON="$(python3 -c "import json; print(json.dumps($(printf '"%s",' "${SESSION_IDS[@]}" | sed 's/,$//' | sed 's/^/[/;s/$/]/')))")"
+
+# Build metadata
+METADATA="$(python3 -c "
+import json
+metadata = {
+    'id': '$CHECKPOINT_ID',
+    'session_ids': $SESSION_IDS_JSON,
+    'commit_sha': '$COMMIT_SHA',
+    'created_at': '$TIMESTAMP',
+    'merged_files': $ALL_FILES_JSON,
+    'summary': None
+}
+print(json.dumps(metadata, indent=2))
+")"
+
+# Save current branch
+ORIGINAL_BRANCH="$(git symbolic-ref --short HEAD 2>/dev/null || git rev-parse HEAD)"
+STASH_NEEDED=false
+if ! git diff --quiet 2>/dev/null || ! git diff --cached --quiet 2>/dev/null; then
+    STASH_NEEDED=true
+    git stash push -m "checkpoint-auto-stash" --quiet
+fi
+
+cleanup() {
+    git checkout "$ORIGINAL_BRANCH" --quiet 2>/dev/null || true
+    if [ "$STASH_NEEDED" = true ]; then
+        git stash pop --quiet 2>/dev/null || true
+    fi
+}
+trap cleanup EXIT
+
+# Create orphan branch if it doesn't exist
+if ! git rev-parse --verify "$CHECKPOINT_BRANCH" >/dev/null 2>&1; then
+    git checkout --orphan "$CHECKPOINT_BRANCH" --quiet
+    git rm -rf . --quiet 2>/dev/null || true
+    echo "# Claude Code Session Checkpoints (v1)" > README.md
+    git add README.md
+    git commit -m "Initialize checkpoint branch" --quiet
+else
+    git checkout "$CHECKPOINT_BRANCH" --quiet
+fi
+
+# Create checkpoint directory
+mkdir -p "$SHARD_DIR"
+
+# Copy transcripts — one per session
+for i in "${!VALID_FILES[@]}"; do
+    f="${VALID_FILES[$i]}"
+    sid="${SESSION_IDS[$i]}"
+    cp "$f" "$SHARD_DIR/transcript-${sid}.jsonl"
+done
+
+# Write metadata
+echo "$METADATA" > "$SHARD_DIR/metadata.json"
+
+# Update index
+for sid in "${SESSION_IDS[@]}"; do
+    echo "$CHECKPOINT_ID|$sid|$COMMIT_SHA|$TIMESTAMP" >> index.log
+done
+
+# Commit
+git add "$SHARD_DIR" index.log
+git commit -m "checkpoint: ${CHECKPOINT_ID} sessions=${#SESSION_IDS[@]} commit=${COMMIT_SHA:0:8}" --quiet
+
+CHECKPOINT_REF="$(git rev-parse HEAD)"
+
+# Push to remote if one exists
+if git remote get-url origin >/dev/null 2>&1; then
+    git push origin "$CHECKPOINT_BRANCH" --quiet 2>/dev/null || true
+fi
+
+echo "Checkpoint created: $CHECKPOINT_ID"
+echo "  Sessions: ${SESSION_IDS[*]}"
+echo "  Commit:   $COMMIT_SHA"
+echo "  Branch:   $CHECKPOINT_BRANCH"
+echo "  Ref:      $CHECKPOINT_REF"

neander_checkpoints-0.1.0/src/neander_checkpoints/bundled/scripts/detect_commit.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+#
+# detect_commit.sh — Hook script for PostToolUse:Bash
+#
+# Receives JSON on stdin from Claude Code hook system.
+# Checks if the Bash command was a git commit on a user branch
+# (not our checkpoint branch or internal scripts).
+# If so, triggers checkpoint.sh and link_commit.sh.
+#
+# Usage: detect_commit.sh (reads JSON from stdin)
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# Read hook input from stdin
+INPUT="$(cat)"
+
+# Extract fields from JSON
+COMMAND="$(echo "$INPUT" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('tool_input',{}).get('command',''))" 2>/dev/null || echo "")"
+SESSION_ID="$(echo "$INPUT" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('session_id',''))" 2>/dev/null || echo "")"
+TRANSCRIPT_PATH="$(echo "$INPUT" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('transcript_path',''))" 2>/dev/null || echo "")"
+
+# Only trigger on user git commits, not our internal scripts
+# Skip if:
+#   - command doesn't contain "git commit"
+#   - command is from checkpoint.sh, save_summary.sh, or link_commit.sh
+#   - current branch is the checkpoint branch
+echo "$COMMAND" | grep -qE "git commit" || exit 0
+echo "$COMMAND" | grep -qE "checkpoint|save_summary|persist_summary" && exit 0
+[ -z "$SESSION_ID" ] && exit 0
+
+CURRENT_BRANCH="$(git symbolic-ref --short HEAD 2>/dev/null || echo "")"
+echo "$CURRENT_BRANCH" | grep -q "neander/checkpoints" && exit 0
+
+# Link the commit to this session
+"$SCRIPT_DIR/link_commit.sh" "$SESSION_ID"
+
+# Find the session JSONL and checkpoint it at this commit
+COMMIT_SHA="$(git rev-parse HEAD 2>/dev/null || echo 'none')"
+
+SESSION_FILE=""
+if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+    SESSION_FILE="$TRANSCRIPT_PATH"
+else
+    PROJECTS_DIR="$HOME/.claude/projects"
+    if [ -d "$PROJECTS_DIR" ]; then
+        SESSION_FILE="$(find "$PROJECTS_DIR" -name "${SESSION_ID}.jsonl" -type f 2>/dev/null | head -1)"
+    fi
+fi
+
+if [ -n "$SESSION_FILE" ]; then
+    "$SCRIPT_DIR/checkpoint.sh" "$SESSION_FILE" "$COMMIT_SHA" &
+fi

neander_checkpoints-0.1.0/src/neander_checkpoints/bundled/scripts/link_commit.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+#
+# link_commit.sh — Add session metadata trailer to the most recent commit.
+#
+# Called by PostToolUse:Bash hook when a git commit is detected.
+# Adds a "Claude-Session" trailer linking the commit to the active session.
+#
+# Usage: link_commit.sh <session_id>
+#
+
+set -euo pipefail
+
+SESSION_ID="${1:?Usage: link_commit.sh <session_id>}"
+
+# Only proceed if we're in a git repo
+if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    exit 0
+fi
+
+# Get the latest commit message
+CURRENT_MSG="$(git log -1 --format=%B)"
+
+# Don't add trailer if already present
+if echo "$CURRENT_MSG" | grep -q "Claude-Session:"; then
+    exit 0
+fi
+
+# Amend the commit with the trailer
+git commit --amend --no-edit --trailer "Claude-Session: $SESSION_ID" --quiet 2>/dev/null || true

neander_checkpoints-0.1.0/src/neander_checkpoints/bundled/scripts/on_stop.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+#
+# on_stop.sh — Hook script for Stop event
+#
+# Receives JSON on stdin from Claude Code hook system.
+# Only creates a checkpoint if the session actually modified files
+# (i.e., used Write/Edit tools). Skips read-only sessions like
+# running /neander-summarize or asking questions.
+#
+# Usage: on_stop.sh (reads JSON from stdin)
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PARSER="$SCRIPT_DIR/parse_jsonl.py"
+
+# Read hook input from stdin
+INPUT="$(cat)"
+
+# Extract fields from JSON
+SESSION_ID="$(echo "$INPUT" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('session_id',''))" 2>/dev/null || echo "")"
+TRANSCRIPT_PATH="$(echo "$INPUT" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('transcript_path',''))" 2>/dev/null || echo "")"
+
+# Find session file
+SESSION_FILE=""
+if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+    SESSION_FILE="$TRANSCRIPT_PATH"
+elif [ -n "$SESSION_ID" ]; then
+    PROJECTS_DIR="$HOME/.claude/projects"
+    if [ -d "$PROJECTS_DIR" ]; then
+        SESSION_FILE="$(find "$PROJECTS_DIR" -name "${SESSION_ID}.jsonl" -type f 2>/dev/null | head -1)"
+    fi
+fi
+
+[ -z "$SESSION_FILE" ] && exit 0
+
+# Only checkpoint if the session modified files
+FILE_COUNT="$(python3 "$PARSER" files --session "$SESSION_FILE" 2>/dev/null | wc -l | tr -d ' ')"
+if [ "$FILE_COUNT" -eq 0 ]; then
+    exit 0
+fi
+
+COMMIT_SHA="$(git rev-parse HEAD 2>/dev/null || echo 'none')"
+"$SCRIPT_DIR/checkpoint.sh" "$SESSION_FILE" "$COMMIT_SHA"