claude-baton 2.1.1 → 2.1.3

package/README.md

@@ -1,116 +1,294 @@
-# claude-baton
+<p align="center">
+  <h1 align="center">🎭 claude-baton</h1>
+  <p align="center"><strong>Never lose context between Claude Code sessions again.</strong></p>
+  <p align="center">
+    <a href="https://www.npmjs.com/package/claude-baton"><img src="https://img.shields.io/npm/v/claude-baton.svg" alt="npm version"></a>
+    <a href="https://github.com/bakabaka91/claude-baton/actions/workflows/ci.yml"><img src="https://github.com/bakabaka91/claude-baton/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+    <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
+    <a href="https://www.npmjs.com/package/claude-baton"><img src="https://img.shields.io/npm/dm/claude-baton.svg" alt="npm downloads"></a>
+  </p>
+</p>
 
-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.
+## 😤 The Problem
 
-## Workflow
+You're deep in a Claude Code session — 45 minutes in, multiple files changed, complex decisions made. Then:
+
+- Context gets compacted and Claude forgets what it was doing
+- You `/clear` or start a new session and lose everything
+- You spend 10 minutes re-explaining where you left off
+- Claude makes the same wrong decisions you already corrected
+
+**Sound familiar?**
+
+## ✨ The Solution
+
+claude-baton gives Claude Code **persistent memory across sessions**. It automatically saves what was built, what's next, and why — then restores it perfectly when you come back.
 
 ```
-/memo-resume → work → /memo-checkpoint → /compact or /clear → repeat
+Session 1                          Session 2
+┌─────────────────────┐            ┌─────────────────────┐
+│  Work on features   │            │  /memo-resume       │
+│  Make decisions      │            │  ↓                  │
+│  Hit blockers       │            │  Full context restored│
+│  ...context compacts │──💾──→    │  Decisions preserved │
+│  (auto-saved!)      │   DB      │  Next steps ready    │
+└─────────────────────┘            │  Git diff shown      │
+                                   │  Ready to continue!  │
+                                   └─────────────────────┘
 ```
 
-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)
+## 🎯 What You Get
+
+- **🔄 Seamless resume** — Start any session with `/memo-resume` and pick up exactly where you left off
+- **💾 Auto-checkpoint** — PreCompact hook saves your session state *before* Claude compacts context. You never have to remember.
+- **📊 Diff intelligence** — Resume shows what changed since your last session (new commits, modified files, dependency changes)
+- **🧠 Decision memory** — Key decisions and their reasoning survive across sessions
+- **📋 EOD summaries** — Generate end-of-day reports from all sessions with `/memo-eod`
+- **🔒 Fully local** — All data in a local SQLite database. No cloud, no API keys, no data leaves your machine.
+
+## 🏗️ Claude Code vs Claude Code + Baton
+
+Claude Code is powerful, but it has structural limitations around context persistence. Here's what changes with claude-baton:
+
+| Scenario | Claude Code alone | Claude Code + Baton |
+|----------|-------------------|---------------------|
+| **Context compaction** | 🔴 Claude silently loses session state. After compaction, it may forget decisions, repeat mistakes, or restart work already done. | 🟢 PreCompact hook auto-saves a structured checkpoint *before* compaction. Claude resumes with full context. |
+| **New session** | 🔴 Blank slate. You re-explain everything from scratch. Claude has to re-read files and rediscover project state. | 🟢 `/memo-resume` loads the last checkpoint with what was built, decisions, blockers, next steps, and git diff since then. |
+| **Decision persistence** | 🔴 "We decided not to use Redux because..." — gone after `/clear`. Claude may suggest Redux again next session. | 🟢 Decisions and their reasoning are stored in checkpoints and surfaced on resume. |
+| **Long-running tasks** | 🔴 Multi-session tasks lose continuity. Each session starts from zero context. | 🟢 Chained checkpoints maintain a thread across sessions. Each auto-checkpoint includes the previous one for continuity. |
+| **Team handover** | 🔴 No way to export what Claude was doing. Knowledge lives only in the conversation. | 🟢 `claude-baton export` produces JSON. `/memo-eod` generates daily summaries of all sessions. |
+| **Git awareness** | 🟡 Claude can run git commands but doesn't automatically know what changed since last session. | 🟢 Resume computes git diff since checkpoint — shows new commits, modified files, dependency changes. |
+
+### 🧱 The Moat: What Claude Code Can't Do Natively
+
+Claude Code has no **persistent structured memory** across sessions. This is the fundamental gap:
 
-## Install
+1. **No session state survives `/compact` or `/clear`** — Claude Code's context window is ephemeral. When it compacts, the nuanced understanding of *why* you made decisions, *what* you tried and rejected, and *where* you were headed is lost. CLAUDE.md can store project rules, but not dynamic session state.
+
+2. **No automatic preservation** — There's no built-in mechanism to save state before compaction. You'd have to manually write notes every time, which you won't.
+
+3. **No structured handover** — Even if you paste notes into a new session, Claude has to parse free-text. claude-baton provides structured data (what was built, current state, next steps, decisions, blockers, git context) that Claude can act on immediately.
+
+4. **No cross-session diff intelligence** — Claude Code can't tell you "3 files changed and 2 new commits landed since your last session." claude-baton compares checkpoint state against current git state and surfaces the delta.
+
+5. **No session history** — There's no way to look back at what you accomplished across multiple sessions in a day. claude-baton's `/memo-eod` synthesizes all checkpoints into a daily summary.
+
+claude-baton fills these gaps by sitting alongside Claude Code as an MCP server — it doesn't replace anything, it adds the persistence layer that's missing.
+
+## 🚀 Quick Start
+
+Two commands. That's it.
 
 ```bash
 npm install -g claude-baton
+claude-baton setup
 ```
 
-## Setup
+Start a new Claude Code session and you're ready to go:
 
-```bash
-claude-baton setup
+```
+You: /memo-checkpoint     ← saves session state
+You: /compact             ← safe, state is preserved
+You: /memo-resume         ← restores everything
 ```
 
-This:
-- Registers the MCP server via `claude mcp add` (user scope, available across all projects)
-- Registers the PreCompact hook for auto-checkpoint
-- Registers allowed tools so slash commands run without approval prompts
-- Initializes the SQLite database at `~/.claude-baton/store.db`
-- Installs slash commands to `~/.claude/commands/`
+## 📸 What It Looks Like
 
-## MCP Tools
+### `/memo-resume` — Session handover briefing
 
-| 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 |
+```
+## Session Resume — my-project — 2026-03-25
 
-## Slash Commands
+Resuming from checkpoint: 2026-03-25T15:26:07Z
+Source: auto checkpoint
 
-| 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 |
+### Branch
+main — currently on main
 
-## Auto-checkpoint
+### Where We Left Off
+v2.1.1 published on npm. Build clean. All tests passing.
 
-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.
+### What Was Built (Last Session)
+Implemented auto-checkpoint chaining with git diff context,
+switched LLM from haiku to sonnet for better summarization quality.
 
-## How it works
+### Decisions Made
+Used claude mcp add for server registration instead of manual config.
+Added source field (manual/auto) to distinguish checkpoint types.
 
-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.
+### Next Steps
+1. Test /memo-resume in a fresh session
+2. Verify auto-checkpoint fires on context compaction
 
-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.
+### Changes Since Checkpoint
+No changes since checkpoint — clean working tree, HEAD at 795f9aa.
 
-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.
+### Commits From Last Session
+795f9aa 2.1.1
+108b65e feat: switch LLM calls from haiku to sonnet
+fe5dae0 docs: fix README to reflect claude mcp add registration
+```
 
-4. **EOD Summary** — `/memo-eod` generates a daily summary from all checkpoints, combining what was built, decisions made, and blockers across sessions.
+### `/memo-eod` — End-of-day summary
 
-## CLI Commands
+```
+## EOD Summary — my-project — 2026-03-25
 
-```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
+### What Was Built / Shipped
+feat: auto-checkpoint chaining and resume resilience
+feat: allowed tools for frictionless slash commands
+fix: MCP server registration via claude mcp add
+
+### Decisions Made
+- Used claude mcp add for correct MCP discovery
+- Chained auto-checkpoints with previous context + git diff
+
+### Git Stats
+- Commits today: 12
+- Files changed: 15
+- Feature areas: feat, fix, docs, style, chore
 ```
 
-## Uninstall
+## 🔧 How It Works
 
-```bash
-# Remove hooks, MCP server, slash commands, and database
-claude-baton uninstall
+```
+┌──────────────────────────────────────────────────────────┐
+│                    Claude Code Session                     │
+│                                                           │
+│  /memo-resume ←── reads latest checkpoint from DB         │
+│       ↓                                                   │
+│  You work normally                                        │
+│       ↓                                                   │
+│  /memo-checkpoint ──→ saves state + git context to DB     │
+│       ↓                                                   │
+│  /compact or /clear (safe!)                               │
+│                                                           │
+│  ┌─────────────────────────────────────────────┐         │
+│  │ 🪝 PreCompact Hook (automatic)              │         │
+│  │                                              │         │
+│  │ Context about to compact?                    │         │
+│  │   → Read conversation transcript             │         │
+│  │   → Fetch previous checkpoint for chaining   │         │
+│  │   → Extract state via claude -p --model sonnet│        │
+│  │   → Save auto-checkpoint to DB               │         │
+│  └─────────────────────────────────────────────┘         │
+└──────────────────────────────────────────────────────────┘
+                          ↕
+                 ~/.claude-baton/store.db
+                    (local SQLite)
+```
+
+### The checkpoint lifecycle
+
+1. **💾 Checkpoint** — Captures what you built, current state, next steps, decisions, blockers, and git context (branch, uncommitted files, recent commits)
+
+2. **🪝 Auto-checkpoint** — Before context compaction, the PreCompact hook reads the transcript, fetches the previous checkpoint for continuity, and uses `claude -p --model sonnet` to extract a structured checkpoint automatically
+
+3. **🔄 Resume** — Fetches the latest checkpoint, compares current git state vs checkpoint state, computes what changed (new commits, file diffs, dependency changes), and presents a structured handover briefing
+
+4. **📊 EOD Summary** — Synthesizes all checkpoints from the day into a daily summary: what was built, decisions made, blockers, and next steps
+
+## 📋 Slash Commands
+
+| Command | Description |
+|---------|-------------|
+| `/memo-resume` | 🔄 Restore context from last checkpoint — run this at session start |
+| `/memo-checkpoint` | 💾 Save session state with git context — safe to `/compact` after |
+| `/memo-eod` | 📊 End-of-day summary combining all sessions |
 
-# Remove the binary
-npm uninstall -g claude-baton
+## 🛠️ CLI Commands
+
+```bash
+claude-baton setup               # 🔧 one-time setup (MCP, hooks, commands)
+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 everything cleanly
+claude-baton uninstall --keep-data  # ❌ uninstall but preserve your data
 ```
 
-To keep your data: `claude-baton uninstall --keep-data`
+## 🔌 MCP Tools
+
+For automation and advanced use cases, claude-baton exposes 4 MCP tools:
 
-## Data model
+| 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 |
 
-All data lives in `~/.claude-baton/store.db`:
+## 🤔 Why Not Just...
 
-- **checkpoints** — session state snapshots (what was built, current state, next steps, decisions, blockers, git context)
+| Alternative | Limitation |
+|-------------|------------|
+| **Manual notes** | You have to remember to write them. You won't. |
+| **CLAUDE.md** | Great for project rules, not for session state that changes every hour |
+| **TodoWrite** | Tracks tasks, not context. Doesn't capture decisions, blockers, or git state |
+| **Just re-explain** | Wastes 5-10 minutes per session. Loses decision reasoning. |
+| **Git commit messages** | Captures *what* changed, not *why* or *what's next* |
+
+claude-baton captures the **full session context** — what was built, why decisions were made, what's blocked, and what to do next — automatically.
+
+## 📦 What Setup Does
+
+`claude-baton setup` is a single command that configures everything:
+
+```
+✓ Registered MCP server (user scope — works across all projects)
+✓ Registered PreCompact hook for auto-checkpoint
+✓ Registered allowed tools (slash commands run without prompts)
+✓ Initialized database at ~/.claude-baton/store.db
+✓ Installed slash commands to ~/.claude/commands/
+```
+
+## 🗄️ Data Model
+
+All data lives locally in `~/.claude-baton/store.db`:
+
+- **checkpoints** — session state snapshots with git context, source tracking (`manual` | `auto`)
 - **daily_summaries** — LLM-generated EOD summaries
 
-## Requirements
+No data leaves your machine. No cloud. No API keys. LLM calls use your existing `claude -p` subscription.
 
-- Node.js >= 18
-- Claude Code CLI installed and authenticated (setup uses `claude mcp add`)
-- No API keys needed — LLM calls use `claude -p`
+## 📋 Requirements
 
-## Development
+- **Node.js** >= 18
+- **Claude Code CLI** installed and authenticated
+- **No API keys needed** — all LLM calls use `claude -p` (your existing subscription)
+
+## 🧑‍💻 Development
 
 ```bash
 git clone https://github.com/bakabaka91/claude-baton.git
 cd claude-baton
 npm install
 npm run build
-npm test
+npm test            # 97 tests
 ```
 
-## License
+## 🗑️ Uninstall
+
+Clean removal — no traces left behind:
+
+```bash
+claude-baton uninstall        # removes hooks, MCP server, commands, and database
+npm uninstall -g claude-baton # removes the binary
+```
+
+To keep your checkpoint data: `claude-baton uninstall --keep-data`
+
+## 📄 License
 
 MIT
+
+---
+
+<p align="center">
+  <strong>Built for developers who are tired of re-explaining context to Claude.</strong><br>
+  <a href="https://www.npmjs.com/package/claude-baton">npm</a> · <a href="https://github.com/bakabaka91/claude-baton/issues">Issues</a> · <a href="https://github.com/bakabaka91/claude-baton/blob/main/CONTRIBUTING.md">Contributing</a>
+</p>

package/commands/memo-checkpoint.md

@@ -35,9 +35,10 @@ Save session state before context loss.
 6. Print structured confirmation:
 
 ```
-Checkpoint saved -- safe to /compact or /clear
-Branch: [branch name]
-State: [current_state summary]
-Next: [next_steps]
-Uncommitted: [count] files
+💾 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

@@ -12,31 +12,31 @@ End-of-day summary combining git activity with stored checkpoints.
    - `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.
+   This internally gathers checkpoints and sends them to Sonnet 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]
+## 📊 EOD Summary — [Project Name] — [DATE]
 
-### What Was Built / Shipped
+### 🏗️ What Was Built / Shipped
 [Commits grouped by area + what_was_built from daily_summary]
 
-### Decisions Made
+### 🧭 Decisions Made
 [From daily_summary + checkpoint decisions]
 
-### Blockers and Failures
-[From daily_summary blockers]
+### 🚧 Blockers and Failures
+[From daily_summary blockers -- or "✅ None"]
 
-### Open Questions / Tomorrow
+### 🔮 Open Questions / Tomorrow
 [next_steps from daily_summary]
 
-### Git Stats
-- Commits today: [count]
-- Files changed: [count]
-- Feature areas: [list of commit prefixes]
+### 📈 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."
+7. Confirm: "✅ EOD saved for [Project Name] — [DATE]. [N] commits today."

package/commands/memo-resume.md

@@ -9,13 +9,13 @@ Restore context from last checkpoint at session start.
 3. Call the `get_checkpoint` MCP tool (latest by default, or by ID if the user specified one via $ARGUMENTS).
 
 3.5. **Staleness check:** If a checkpoint was found, compute the time delta between the checkpoint's `created_at` and now:
-   - More than 7 days old: display `"WARNING: This checkpoint is [N] days old. Project state may have changed significantly."`
-   - More than 24 hours but 7 days or less: display `"Note: This checkpoint is [N] hours/days old."`
+   - More than 7 days old: display `"⚠️ WARNING: This checkpoint is [N] days old. Project state may have changed significantly."`
+   - More than 24 hours but 7 days or less: display `"📌 Note: This checkpoint is [N] hours/days old."`
    - 24 hours or less: no staleness note
 
 3.75. **Cold-start fallback:** If NO checkpoint exists for this project:
    - Run `git log --oneline -20`, `git diff --stat HEAD~5..HEAD`, `git branch --show-current`, `git status --short`
-   - Present a "Cold Start Briefing" with recent commits, file changes, and uncommitted work
+   - Present a "🆕 Cold Start Briefing" with recent commits, file changes, and uncommitted work
    - End with: "No checkpoint to resume from, but here is the project state from git. What would you like to work on?"
    - Skip remaining steps (4-8)
 
@@ -36,54 +36,54 @@ Restore context from last checkpoint at session start.
 7. Present the structured handover briefing:
 
 ```
-## Session Resume -- [Project Name] -- [DATE]
+## 🔄 Session Resume — [Project Name] — [DATE]
 
-Resuming from checkpoint: [timestamp]
-Source: [auto/manual] checkpoint
+📍 Resuming from checkpoint: [timestamp]
+🏷️ Source: [auto/manual] checkpoint
 [Staleness warning if applicable]
 
-### Branch
-[checkpoint branch] -- currently on [current branch]
-[Flag if they differ]
+### 🌿 Branch
+`[checkpoint branch]` — currently on `[current branch]`
+[Flag if they differ with ⚠️]
 
-### Where We Left Off
+### 📍 Where We Left Off
 [current_state from checkpoint]
 
-### What Was Built (Last Session)
+### 🏗️ What Was Built (Last Session)
 [what_was_built from checkpoint]
 
-### Decisions Made
+### 🧭 Decisions Made
 [decisions from checkpoint -- or "None recorded"]
 
-### Blockers
-[blockers from checkpoint -- or "None"]
-[If blockers exist, surface them prominently with a warning]
+### 🚧 Blockers
+[blockers from checkpoint -- or "✅ None"]
+[If blockers exist, surface them prominently with ⚠️]
 
-### Active Plan Context
+### 📋 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
+### 🔀 Changes Since Checkpoint
 [Diff intelligence summary from step 6]
 [Files changed, new commits, dependency changes]
 
-### Next Steps
+### 🎯 Next Steps
 Present as numbered action items:
 1. [first action from next_steps]
 2. [second action if applicable]
 ...
 
-### Uncommitted Work
+### 📝 Uncommitted Work
 [checkpoint uncommitted_files vs current git status]
-[Flag if they differ -- someone may have stashed or committed manually]
+[Flag if they differ with ⚠️ -- someone may have stashed or committed manually]
 
-### Commits From Last Session
+### 📜 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
+### 🆕 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)
+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.js

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { readFileSync, writeFileSync, copyFileSync, existsSync, statSync, readdirSync, unlinkSync, rmSync, } from "fs";
+import { readFileSync, writeFileSync, existsSync, statSync, lstatSync, readdirSync, unlinkSync, symlinkSync, rmSync, } from "fs";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 import path from "path";
@@ -214,15 +214,31 @@ export function installCommands() {
     const files = readdirSync(sourceDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
         const targetPath = path.join(targetDir, file);
-        if (existsSync(targetPath)) {
-            const name = file.replace(".md", "");
-            console.error(`  Skipping ${name} -- already exists`);
+        const sourcePath = path.join(sourceDir, file);
+        const name = file.replace(".md", "");
+        let isSymlink = false;
+        try {
+            isSymlink = lstatSync(targetPath).isSymbolicLink();
+        }
+        catch {
+            // File doesn't exist
+        }
+        if (isSymlink) {
+            // Our symlink — update to point to current package version
+            unlinkSync(targetPath);
+            symlinkSync(sourcePath, targetPath);
+            console.error(`  Updated /${name}`);
+            installed++;
+        }
+        else if (existsSync(targetPath)) {
+            // Regular file from old install — don't overwrite
+            console.error(`  Skipping ${name} -- already exists (run uninstall first to upgrade)`);
             skipped++;
         }
         else {
-            copyFileSync(path.join(sourceDir, file), targetPath);
-            const name = file.replace(".md", "");
-            console.error(`  Installed /${name}`);
+            // Fresh install — create symlink
+            symlinkSync(sourcePath, targetPath);
+            console.error(`  Linked /${name}`);
             installed++;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-baton",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "Session lifecycle management for Claude Code",
   "type": "module",
   "main": "dist/index.js",