claude-baton 2.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 claude-baton contributors
+
+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.

package/README.md

@@ -0,0 +1,115 @@
+# claude-baton
+
+Never lose context between Claude Code sessions again.
+
+claude-baton is an MCP server that gives Claude Code session continuity. It saves checkpoints of your session state, auto-saves before context compaction, and restores full context when you start a new session.
+
+## Workflow
+
+```
+/memo-resume → work → /memo-checkpoint → /compact or /clear → repeat
+```
+
+1. **Resume** — start a session with `/memo-resume` to pick up where you left off
+2. **Work** — do your thing
+3. **Checkpoint** — run `/memo-checkpoint` before `/compact` or `/clear` (or let the auto-checkpoint handle `/compact` for you)
+
+## Install
+
+```bash
+npm install -g claude-baton
+```
+
+## Setup
+
+```bash
+claude-baton setup
+```
+
+This:
+- Registers the MCP server in `~/.claude/settings.json`
+- Registers the PreCompact hook for auto-checkpoint
+- Initializes the SQLite database at `~/.claude-baton/store.db`
+- Installs slash commands to `~/.claude/commands/`
+
+## MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `save_checkpoint` | Save session state (what was built, current state, next steps, git context) |
+| `get_checkpoint` | Retrieve a checkpoint by ID, or the latest for the project |
+| `list_checkpoints` | List all checkpoints for a date |
+| `daily_summary` | Generate EOD summary from the day's checkpoints |
+
+## Slash Commands
+
+| Command | Description |
+|---------|-------------|
+| `/memo-checkpoint` | Save session state with git context — safe to `/compact` or `/clear` after |
+| `/memo-resume` | Restore context from last checkpoint at session start |
+| `/memo-eod` | End-of-day summary combining git activity with stored data |
+
+## Auto-checkpoint
+
+A PreCompact hook automatically saves a checkpoint before Claude Code compacts context. This means you never lose session state during long conversations — it happens transparently.
+
+## How it works
+
+1. **Checkpoint** — `/memo-checkpoint` (or the MCP tool) captures what you built, current state, next steps, decisions, blockers, and git context. Stored in a local SQLite database.
+
+2. **Auto-checkpoint** — Before context compaction, the PreCompact hook reads the conversation transcript, sends it to `claude -p --model haiku` to extract session state, and saves a checkpoint automatically.
+
+3. **Resume** — `/memo-resume` fetches the latest checkpoint, compares git state, shows what changed since the checkpoint, and presents a structured handover briefing with actionable next steps.
+
+4. **EOD Summary** — `/memo-eod` generates a daily summary from all checkpoints, combining what was built, decisions made, and blockers across sessions.
+
+## CLI Commands
+
+```bash
+claude-baton status              # checkpoint counts, db size
+claude-baton projects            # list tracked projects
+claude-baton export [--project]  # export as JSON
+claude-baton import <file>       # import from JSON
+claude-baton reset [--project]   # clear data (with confirmation)
+claude-baton uninstall           # remove hooks, commands, MCP server, and database
+claude-baton uninstall --keep-data  # uninstall but preserve the database
+```
+
+## Uninstall
+
+```bash
+# Remove hooks, MCP server, slash commands, and database
+claude-baton uninstall
+
+# Remove the binary
+npm uninstall -g claude-baton
+```
+
+To keep your data: `claude-baton uninstall --keep-data`
+
+## Data model
+
+All data lives in `~/.claude-baton/store.db`:
+
+- **checkpoints** — session state snapshots (what was built, current state, next steps, decisions, blockers, git context)
+- **daily_summaries** — LLM-generated EOD summaries
+
+## Requirements
+
+- Node.js >= 18
+- Claude Code with a Claude subscription (for `claude -p` calls)
+- No API keys needed
+
+## Development
+
+```bash
+git clone https://github.com/bakabaka91/claude-baton.git
+cd claude-baton
+npm install
+npm run build
+npm test
+```
+
+## License
+
+MIT

package/bin/claude-baton.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/cli.js');

package/commands/memo-checkpoint.md

@@ -0,0 +1,43 @@
+Save session state before context loss.
+
+## Steps
+
+1. Detect the project from the current working directory.
+
+2. Capture git state by running these bash commands:
+   - `git branch --show-current`
+   - `git status --short`
+   - `git diff --name-only HEAD`
+   - `git log --since="2 hours ago" --format="%h %s"`
+   - `git log --oneline -10` (this becomes the git_snapshot)
+
+3. Check if any plan documents exist (PLAN.md, docs/*.md specs, roadmaps). If one is being actively worked on, note the file path and the current phase/step (e.g. "docs/v2-plan.md Phase 2 Step 3").
+
+4. Summarize the session state from the conversation context:
+   - **what_was_built**: what was accomplished this session
+   - **current_state**: where things stand now
+   - **next_steps**: what should happen next
+   - **decisions**: key choices made and WHY
+   - **blockers**: anything blocking progress
+   - **plan_reference**: file path and section of the active plan document (e.g. "docs/v2-plan.md Phase 2 Step 3"), or omit if no plan is active
+
+5. Call the `save_checkpoint` MCP tool with all fields:
+   - what_was_built
+   - current_state
+   - next_steps
+   - decisions
+   - blockers
+   - plan_reference (from step 3, if applicable)
+   - branch (from step 2)
+   - uncommitted_files (array of lines from git status --short)
+   - git_snapshot (from git log --oneline -10)
+
+6. Print structured confirmation:
+
+```
+Checkpoint saved -- safe to /compact or /clear
+Branch: [branch name]
+State: [current_state summary]
+Next: [next_steps]
+Uncommitted: [count] files
+```

package/commands/memo-eod.md

@@ -0,0 +1,42 @@
+End-of-day summary combining git activity with stored checkpoints.
+
+## Steps
+
+1. Detect the project from the current working directory.
+
+2. Collect git activity for today by running:
+   - `git log --since="$(date '+%Y-%m-%d') 00:00:00" --until="$(date '+%Y-%m-%d') 23:59:59" --format="%h|||%s|||%ai|||%an" --all`
+   - Parse and group commits by conventional commit prefix (feat/fix/chore/refactor/test/docs).
+
+3. Review changed files:
+   - `git diff --name-only HEAD~10 HEAD 2>/dev/null | head -30`
+
+4. Call the `daily_summary` MCP tool (defaults to today).
+   This internally gathers checkpoints and sends them to Haiku for synthesis, then stores the result.
+
+5. Merge git activity from step 2 with the daily_summary output.
+
+6. Display formatted summary:
+
+```
+## EOD Summary -- [Project Name] -- [DATE]
+
+### What Was Built / Shipped
+[Commits grouped by area + what_was_built from daily_summary]
+
+### Decisions Made
+[From daily_summary + checkpoint decisions]
+
+### Blockers and Failures
+[From daily_summary blockers]
+
+### Open Questions / Tomorrow
+[next_steps from daily_summary]
+
+### Git Stats
+- Commits today: [count]
+- Files changed: [count]
+- Feature areas: [list of commit prefixes]
+```
+
+7. Confirm: "EOD saved for [Project Name] -- [DATE]. [N] commits today."

package/commands/memo-resume.md

@@ -0,0 +1,76 @@
+Restore context from last checkpoint at session start.
+
+## Steps
+
+1. Detect the project from the current working directory.
+
+2. Call the `list_checkpoints` MCP tool with today's date. If multiple checkpoints exist, show them and note which is latest.
+
+3. Call the `get_checkpoint` MCP tool (latest by default, or by ID if the user specified one via $ARGUMENTS).
+
+4. Capture current git state by running these bash commands:
+   - `git branch --show-current`
+   - `git status --short`
+   - `git log --oneline -10`
+   - `git diff --stat main...HEAD`
+
+5. If the checkpoint has a `plan_reference` field (e.g. "docs/v2-plan.md Phase 2 Step 3"), read the referenced file and extract the relevant section. Parse the plan_reference to get the file path (everything before the section identifier like "Phase" or "Step") and the section name.
+
+6. Diff intelligence -- compare checkpoint state to current state:
+   - If checkpoint has a `git_snapshot`, extract the top commit hash and run `git diff --stat <hash>..HEAD` to see what files changed since checkpoint
+   - Compare checkpoint `uncommitted_files` vs current `git status --short` -- note any files that were added, removed, or committed since checkpoint
+   - If `package.json` appears in changed files, run `git diff <hash>..HEAD -- package.json` to check for dependency changes
+   - Summarize as: "X files modified, Y new commits, Z dependency changes" (or "No changes since checkpoint" if clean)
+
+7. Present the structured handover briefing:
+
+```
+## Session Resume -- [Project Name] -- [DATE]
+
+Resuming from checkpoint: [timestamp]
+
+### Branch
+[checkpoint branch] -- currently on [current branch]
+[Flag if they differ]
+
+### Where We Left Off
+[current_state from checkpoint]
+
+### What Was Built (Last Session)
+[what_was_built from checkpoint]
+
+### Decisions Made
+[decisions from checkpoint -- or "None recorded"]
+
+### Blockers
+[blockers from checkpoint -- or "None"]
+[If blockers exist, surface them prominently with a warning]
+
+### Active Plan Context
+[If plan_reference exists: show the reference, then the extracted section content from step 5]
+[If no plan_reference: "No active plan"]
+
+### Changes Since Checkpoint
+[Diff intelligence summary from step 6]
+[Files changed, new commits, dependency changes]
+
+### Next Steps
+Present as numbered action items:
+1. [first action from next_steps]
+2. [second action if applicable]
+...
+
+### Uncommitted Work
+[checkpoint uncommitted_files vs current git status]
+[Flag if they differ -- someone may have stashed or committed manually]
+
+### Commits From Last Session
+[git_snapshot from checkpoint -- these are the commits made during that session]
+[If empty: "No commits were made in the last session"]
+
+### Git Activity Since Checkpoint
+[Any NEW commits since the checkpoint timestamp that were NOT in git_snapshot]
+[If none: "No new commits since checkpoint"]
+```
+
+8. End with: "Ready to continue. Want me to start with step 1, or are we doing something else?" (referring to the numbered action items above)

package/dist/cli.d.ts

@@ -0,0 +1,22 @@
+export declare function handleAutoCheckpoint(): Promise<void>;
+export declare function handleSetup(): Promise<void>;
+export declare function installCommands(): {
+    installed: number;
+    skipped: number;
+};
+export declare function handleUninstall(opts: {
+    keepData?: boolean;
+    force?: boolean;
+}): Promise<void>;
+export declare function handleStatus(opts: {
+    project?: string;
+}): Promise<void>;
+export declare function handleProjects(): Promise<void>;
+export declare function handleExport(opts: {
+    project?: string;
+}): Promise<void>;
+export declare function handleImport(file: string): Promise<void>;
+export declare function handleReset(opts: {
+    project?: string;
+    force?: boolean;
+}): Promise<void>;