claude-baton 2.0.1 → 2.1.1

package/README.md

@@ -27,8 +27,9 @@ claude-baton setup
 ```
 
 This:
-- Registers the MCP server in `~/.claude/settings.json`
+- 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/`
 
@@ -97,8 +98,8 @@ All data lives in `~/.claude-baton/store.db`:
 ## Requirements
 
 - Node.js >= 18
-- Claude Code with a Claude subscription (for `claude -p` calls)
-- No API keys needed
+- Claude Code CLI installed and authenticated (setup uses `claude mcp add`)
+- No API keys needed — LLM calls use `claude -p`
 
 ## Development
 

package/commands/memo-resume.md

@@ -8,6 +8,17 @@ 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."`
+   - 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
+   - 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)
+
 4. Capture current git state by running these bash commands:
    - `git branch --show-current`
    - `git status --short`
@@ -28,6 +39,8 @@ Restore context from last checkpoint at session start.
 ## Session Resume -- [Project Name] -- [DATE]
 
 Resuming from checkpoint: [timestamp]
+Source: [auto/manual] checkpoint
+[Staleness warning if applicable]
 
 ### Branch
 [checkpoint branch] -- currently on [current branch]

package/dist/cli.js

@@ -5,8 +5,8 @@ import { fileURLToPath } from "url";
 import path from "path";
 import os from "os";
 import { createInterface } from "readline";
-import { initDatabase, getDefaultDbPath, saveDatabase, countAll, listProjects, insertCheckpoint, getAllCheckpoints, getAllDailySummaries, deleteProjectData, deleteAllData, } from "./store.js";
-import { ensureDir } from "./utils.js";
+import { initDatabase, getDefaultDbPath, saveDatabase, countAll, listProjects, insertCheckpoint, getLatestCheckpoint, getAllCheckpoints, getAllDailySummaries, deleteProjectData, deleteAllData, } from "./store.js";
+import { ensureDir, normalizeProjectPath } from "./utils.js";
 import { callClaudeJson } from "./llm.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function readPromptTemplate(name) {
@@ -33,8 +33,9 @@ export async function handleAutoCheckpoint() {
         }
         let transcriptPath;
         try {
-            const metadata = JSON.parse(stdinData);
-            transcriptPath = metadata?.input?.metadata?.transcript_path;
+            const hookInput = JSON.parse(stdinData);
+            // Claude Code PreCompact hook sends flat JSON with transcript_path at top level
+            transcriptPath = hookInput?.transcript_path;
         }
         catch {
             console.error("[claude-baton] Could not parse hook metadata, skipping auto-checkpoint");
@@ -54,15 +55,44 @@ export async function handleAutoCheckpoint() {
         const branch = gitCmd("git branch --show-current");
         const status = gitCmd("git status --short");
         const log = gitCmd("git log --oneline -10");
-        // Build prompt
+        // Initialize DB and fetch previous checkpoint for chaining
+        const dbPath = getDefaultDbPath();
+        const db = await initDatabase(dbPath);
+        const projectPath = normalizeProjectPath(process.cwd());
+        const prevCheckpoint = getLatestCheckpoint(db, projectPath);
+        // Compute git diff since last checkpoint
+        let gitDiffSinceCheckpoint = "";
+        if (prevCheckpoint?.git_snapshot) {
+            const topCommitHash = prevCheckpoint.git_snapshot
+                .split("\n")[0]
+                ?.split(" ")[0];
+            if (topCommitHash) {
+                gitDiffSinceCheckpoint = gitCmd(`git diff --stat ${topCommitHash}..HEAD`);
+            }
+        }
+        // Build previous checkpoint context
+        let prevContext = "No previous checkpoint exists for this project.";
+        if (prevCheckpoint) {
+            prevContext = [
+                `What was built: ${prevCheckpoint.what_was_built}`,
+                `Current state: ${prevCheckpoint.current_state}`,
+                `Next steps: ${prevCheckpoint.next_steps}`,
+                prevCheckpoint.decisions_made
+                    ? `Decisions: ${prevCheckpoint.decisions_made}`
+                    : null,
+            ]
+                .filter(Boolean)
+                .join("\n");
+        }
+        // Build prompt with three sections
         const template = readPromptTemplate("auto_checkpoint.txt");
-        const prompt = template.replace("{TRANSCRIPT}", transcript);
+        const prompt = template
+            .replace("{{PREVIOUS_CHECKPOINT}}", prevContext)
+            .replace("{{GIT_DIFF}}", gitDiffSinceCheckpoint || "No file changes since last checkpoint.")
+            .replace("{{TRANSCRIPT}}", transcript);
         // Call LLM
-        const result = await callClaudeJson(prompt, "haiku", 30000);
+        const result = await callClaudeJson(prompt, "sonnet", 60000);
         // Save checkpoint
-        const dbPath = getDefaultDbPath();
-        const db = await initDatabase(dbPath);
-        const projectPath = process.cwd();
         const sessionId = new Date().toISOString();
         const uncommittedFiles = status
             ? status.split("\n").map((l) => l.trim())
@@ -74,6 +104,7 @@ export async function handleAutoCheckpoint() {
             uncommittedFiles,
             gitSnapshot: log || undefined,
             planReference: result.plan_reference || undefined,
+            source: "auto",
         }, dbPath);
         console.error("[claude-baton] Auto-checkpoint saved before compaction");
     }
@@ -94,29 +125,76 @@ export async function handleSetup() {
             settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
         }
         catch {
-            settings = {};
+            console.error("Error: could not parse ~/.claude/settings.json. Fix the file manually and re-run setup.");
+            return;
+        }
+    }
+    // Register MCP server via `claude mcp add` (the correct way for Claude Code
+    // to discover servers). Uses --scope user for cross-project availability.
+    const serverScript = path.resolve(__dirname, "..", "bin", "claude-baton.js");
+    try {
+        // Remove first (idempotent) then add — avoids "already exists" errors
+        execSync("claude mcp remove claude-baton -s user 2>/dev/null || true", {
+            encoding: "utf-8",
+            timeout: 10000,
+        });
+        execSync(`claude mcp add -s user claude-baton -- node ${serverScript} serve`, { encoding: "utf-8", timeout: 10000 });
+        console.error("  Registered MCP server (user scope)");
+    }
+    catch {
+        console.error("  Warning: could not register MCP server via 'claude mcp add'.");
+        console.error("  Ensure Claude Code CLI is installed. You can manually run:");
+        console.error(`  claude mcp add -s user claude-baton -- node ${serverScript} serve`);
+    }
+    // Clean up legacy mcpServers from settings.json if present
+    if (settings.mcpServers &&
+        typeof settings.mcpServers === "object" &&
+        settings.mcpServers["claude-baton"]) {
+        delete settings.mcpServers["claude-baton"];
+        if (Object.keys(settings.mcpServers).length === 0) {
+            delete settings.mcpServers;
         }
     }
-    // Register MCP server
-    const mcpServers = (settings.mcpServers ?? {});
-    mcpServers["claude-baton"] = {
-        command: "npx",
-        args: ["-y", "claude-baton", "serve"],
-    };
-    settings.mcpServers = mcpServers;
     // Register PreCompact hook (idempotent — skip if already present)
     const hooks = (settings.hooks ?? {});
     const preCompactHooks = (hooks.PreCompact ?? []);
-    const hasMemoriaHook = preCompactHooks.some((h) => h.command && h.command.includes("claude-baton"));
-    if (!hasMemoriaHook) {
+    const hasBatonHook = preCompactHooks.some((h) => Array.isArray(h.hooks) &&
+        h.hooks.some((hook) => hook.command?.includes("claude-baton")));
+    if (!hasBatonHook) {
+        const autoCheckpointBin = path.resolve(__dirname, "..", "bin", "claude-baton.js");
         preCompactHooks.push({
-            type: "command",
-            command: "npx -y claude-baton auto-checkpoint",
+            matcher: "",
+            hooks: [
+                {
+                    type: "command",
+                    command: `node ${autoCheckpointBin} auto-checkpoint`,
+                },
+            ],
         });
         hooks.PreCompact = preCompactHooks;
         settings.hooks = hooks;
         console.error("  Registered PreCompact hook");
     }
+    // Register allowed tools for frictionless slash commands (idempotent)
+    const BATON_TOOLS = [
+        "Bash(git status*)",
+        "Bash(git log*)",
+        "Bash(git diff*)",
+        "Bash(git branch*)",
+        "Bash(node *claude-baton*)",
+    ];
+    const allowedTools = (settings.allowedTools ?? []);
+    let toolsAdded = 0;
+    for (const tool of BATON_TOOLS) {
+        if (!allowedTools.includes(tool)) {
+            allowedTools.push(tool);
+            toolsAdded++;
+        }
+    }
+    if (toolsAdded > 0) {
+        settings.allowedTools = allowedTools;
+        console.error(`  Registered ${toolsAdded} allowed tools`);
+    }
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     const dbPath = getDefaultDbPath();
     await initDatabase(dbPath);
@@ -152,12 +230,22 @@ export function installCommands() {
 }
 // --- Uninstall command ---
 export async function handleUninstall(opts) {
-    // 1. Remove MCP server from settings.json
+    // 1. Remove MCP server via claude CLI + clean up settings.json
+    try {
+        execSync("claude mcp remove claude-baton -s user 2>/dev/null || true", {
+            encoding: "utf-8",
+            timeout: 10000,
+        });
+        console.error("  Removed MCP server");
+    }
+    catch {
+        console.error("  Warning: could not remove MCP server via CLI");
+    }
     const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
     if (existsSync(settingsPath)) {
         try {
             const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-            // Remove MCP server registration
+            // Remove legacy MCP server from settings.json if present
             if (settings.mcpServers &&
                 typeof settings.mcpServers === "object" &&
                 settings.mcpServers["claude-baton"]) {
@@ -165,7 +253,6 @@ export async function handleUninstall(opts) {
                 if (Object.keys(settings.mcpServers).length === 0) {
                     delete settings.mcpServers;
                 }
-                console.error("  Removed MCP server from settings.json");
             }
             // Remove PreCompact hook
             if (settings.hooks &&
@@ -173,7 +260,8 @@ export async function handleUninstall(opts) {
                 settings.hooks.PreCompact) {
                 const hooksObj = settings.hooks;
                 const preCompact = hooksObj.PreCompact;
-                const filtered = preCompact.filter((h) => !h.command || !h.command.includes("claude-baton"));
+                const filtered = preCompact.filter((h) => !Array.isArray(h.hooks) ||
+                    !h.hooks.some((hook) => hook.command?.includes("claude-baton")));
                 if (filtered.length === 0) {
                     delete hooksObj.PreCompact;
                 }
@@ -185,6 +273,21 @@ export async function handleUninstall(opts) {
                 }
                 console.error("  Removed PreCompact hook");
             }
+            // Remove allowed tools
+            if (Array.isArray(settings.allowedTools)) {
+                const BATON_PATTERNS = [
+                    "Bash(git status*)",
+                    "Bash(git log*)",
+                    "Bash(git diff*)",
+                    "Bash(git branch*)",
+                    "Bash(node *claude-baton*)",
+                ];
+                settings.allowedTools = settings.allowedTools.filter((t) => !BATON_PATTERNS.includes(t));
+                if (settings.allowedTools.length === 0) {
+                    delete settings.allowedTools;
+                }
+                console.error("  Removed allowed tools");
+            }
             writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
         }
         catch {
@@ -229,7 +332,7 @@ export async function handleStatus(opts) {
         return;
     }
     const db = await initDatabase(dbPath);
-    const projectPath = opts.project ?? process.cwd();
+    const projectPath = opts.project ?? normalizeProjectPath(process.cwd());
     const counts = countAll(db, projectPath);
     const dbSize = statSync(dbPath).size;
     console.log(`Project: ${projectPath}`);
@@ -289,8 +392,17 @@ export async function handleImport(file) {
         return;
     }
     let imported = 0;
+    let skipped = 0;
     if (Array.isArray(data.checkpoints)) {
         for (const cp of data.checkpoints) {
+            if (!cp.project_path ||
+                !cp.session_id ||
+                !cp.current_state ||
+                !cp.what_was_built ||
+                !cp.next_steps) {
+                skipped++;
+                continue;
+            }
             insertCheckpoint(db, cp.project_path, cp.session_id, cp.current_state, cp.what_was_built, cp.next_steps, {
                 branch: cp.branch,
                 decisionsMade: cp.decisions_made,
@@ -302,7 +414,7 @@ export async function handleImport(file) {
         }
     }
     saveDatabase(db, dbPath);
-    console.error(`Imported ${imported} items.`);
+    console.error(`Imported ${imported} items.${skipped ? ` Skipped ${skipped} malformed.` : ""}`);
 }
 // --- Reset command ---
 export async function handleReset(opts) {

package/dist/index.js

@@ -3,10 +3,12 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { initDatabase, getDefaultDbPath, insertCheckpoint, getLatestCheckpoint, getCheckpoint, getCheckpointsByDate, insertDailySummary, } from "./store.js";
 import { callClaudeJson } from "./llm.js";
+import { normalizeProjectPath } from "./utils.js";
 import { readFileSync, statSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(path.join(__dirname, "..", "package.json"), "utf-8"));
 let db;
 let dbPath;
 let lastDbMtime = 0;
@@ -25,13 +27,6 @@ async function reloadDbIfChanged() {
 }
 /** Stable fallback session ID — generated once at module load, not per call. */
 const fallbackSessionId = `session-${Date.now()}`;
-/** Build an MCP error response with a descriptive message. */
-function toolError(message) {
-    return {
-        content: [{ type: "text", text: `Error: ${message}` }],
-        isError: true,
-    };
-}
 /**
  * Validate that a required string argument is present and is a string.
  * Returns the validated string, or throws with a descriptive message.
@@ -50,7 +45,7 @@ class ValidationError extends Error {
         this.name = "ValidationError";
     }
 }
-const server = new Server({ name: "claude-baton", version: "1.0.0" }, { capabilities: { tools: {} } });
+const server = new Server({ name: "claude-baton", version: pkg.version }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
@@ -81,6 +76,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: "string",
                         description: "Reference to active plan document and section, e.g. 'docs/plan.md Phase 2 Step 3'",
                     },
+                    source: {
+                        type: "string",
+                        enum: ["manual", "auto"],
+                        description: "Checkpoint source. Defaults to manual.",
+                    },
                     project: {
                         type: "string",
                         description: "Project path (defaults to cwd)",
@@ -144,7 +144,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    const projectPath = args?.project ?? process.cwd();
+    const projectPath = args?.project ?? normalizeProjectPath(process.cwd());
     await reloadDbIfChanged();
     try {
         switch (name) {
@@ -161,6 +161,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     uncommittedFiles: a?.uncommitted_files,
                     gitSnapshot: a?.git_snapshot,
                     planReference: a?.plan_reference,
+                    source: a?.source ?? "manual",
                 }, dbPath);
                 return { content: [{ type: "text", text: `Checkpoint saved: ${id}` }] };
             }
@@ -206,7 +207,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const summaryPrompt = summaryTemplate
                     .replace("{{DATE}}", date)
                     .replace("{{ACTIVITY}}", activityParts.join("\n\n"));
-                const summaryResult = await callClaudeJson(summaryPrompt, "haiku", 30000);
+                const summaryResult = await callClaudeJson(summaryPrompt, "sonnet", 60000);
                 insertDailySummary(db, projectPath, date, summaryResult, dbPath);
                 return {
                     content: [

package/dist/llm.js

@@ -49,7 +49,7 @@ function callClaudeRaw(prompt, model = "haiku", timeout = 30000) {
             if (settled)
                 return;
             settled = true;
-            if (process.env.MEMORIA_DEBUG) {
+            if (process.env.CLAUDE_BATON_DEBUG) {
                 console.error(`[DEBUG] claude -p exit=${code} stdout=${stdout.slice(0, 500)} stderr=${stderr.slice(0, 200)}`);
             }
             if (code !== 0) {
@@ -65,7 +65,7 @@ function callClaudeRaw(prompt, model = "haiku", timeout = 30000) {
             settled = true;
             reject(new Error(`Failed to spawn claude: ${err.message}`));
         });
-        if (process.env.MEMORIA_DEBUG) {
+        if (process.env.CLAUDE_BATON_DEBUG) {
             console.error(`[DEBUG] Prompt length: ${prompt.length}, first 300 chars: ${prompt.slice(0, 300)}`);
         }
         proc.stdin.write(prompt);

package/dist/store.d.ts

@@ -11,6 +11,7 @@ export declare function insertCheckpoint(db: Database, projectPath: string, sess
     uncommittedFiles?: string[];
     gitSnapshot?: string;
     planReference?: string;
+    source?: "manual" | "auto";
 }, dbPath?: string): string;
 export declare function getCheckpoint(db: Database, id: string): Checkpoint | null;
 export declare function getLatestCheckpoint(db: Database, projectPath: string): Checkpoint | null;

package/dist/store.js

@@ -45,6 +45,7 @@ export function initSchema(db) {
       uncommitted_files TEXT DEFAULT '[]',
       git_snapshot TEXT,
       plan_reference TEXT,
+      source TEXT DEFAULT 'manual',
       created_at TEXT DEFAULT (datetime('now'))
     );
     CREATE INDEX IF NOT EXISTS idx_checkpoints_project ON checkpoints(project_path);
@@ -64,22 +65,35 @@ export function initSchema(db) {
     try {
         db.exec("ALTER TABLE checkpoints ADD COLUMN git_snapshot TEXT");
     }
-    catch {
-        // Column already exists — expected for new databases or already-migrated ones
+    catch (e) {
+        const msg = e instanceof Error ? e.message : "";
+        if (!msg.includes("duplicate column"))
+            throw e;
     }
     // Migration: add plan_reference column for existing databases
     try {
         db.exec("ALTER TABLE checkpoints ADD COLUMN plan_reference TEXT");
     }
-    catch {
-        // Column already exists
+    catch (e) {
+        const msg = e instanceof Error ? e.message : "";
+        if (!msg.includes("duplicate column"))
+            throw e;
+    }
+    // Migration: add source column for existing databases
+    try {
+        db.exec("ALTER TABLE checkpoints ADD COLUMN source TEXT DEFAULT 'manual'");
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : "";
+        if (!msg.includes("duplicate column"))
+            throw e;
     }
 }
 // --- Checkpoints CRUD ---
 export function insertCheckpoint(db, projectPath, sessionId, currentState, whatWasBuilt, nextSteps, opts, dbPath) {
     const id = crypto.randomUUID();
-    db.run(`INSERT INTO checkpoints (id, project_path, session_id, branch, current_state, what_was_built, next_steps, decisions_made, blockers, uncommitted_files, git_snapshot, plan_reference, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    db.run(`INSERT INTO checkpoints (id, project_path, session_id, branch, current_state, what_was_built, next_steps, decisions_made, blockers, uncommitted_files, git_snapshot, plan_reference, source, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
         id,
         projectPath,
         sessionId,
@@ -92,6 +106,7 @@ export function insertCheckpoint(db, projectPath, sessionId, currentState, whatW
         JSON.stringify(opts?.uncommittedFiles ?? []),
         opts?.gitSnapshot ?? null,
         opts?.planReference ?? null,
+        opts?.source ?? "manual",
         new Date().toISOString(),
     ]);
     if (dbPath)
@@ -122,11 +137,16 @@ function parseCheckpointRow(row) {
         uncommitted_files: JSON.parse(row.uncommitted_files),
         git_snapshot: row.git_snapshot ?? null,
         plan_reference: row.plan_reference ?? null,
+        source: row.source ?? "manual",
     };
 }
 export function getCheckpointsByDate(db, projectPath, date) {
-    const stmt = db.prepare("SELECT * FROM checkpoints WHERE project_path = ? AND created_at LIKE ? || '%' ORDER BY created_at ASC");
-    stmt.bind([projectPath, date]);
+    const startLocal = new Date(`${date}T00:00:00`);
+    const endLocal = new Date(`${date}T23:59:59.999`);
+    const startUtc = startLocal.toISOString();
+    const endUtc = endLocal.toISOString();
+    const stmt = db.prepare("SELECT * FROM checkpoints WHERE project_path = ? AND created_at >= ? AND created_at <= ? ORDER BY created_at ASC");
+    stmt.bind([projectPath, startUtc, endUtc]);
     const results = [];
     while (stmt.step()) {
         results.push(parseCheckpointRow(stmt.getAsObject()));

package/dist/types.d.ts

@@ -12,6 +12,7 @@ export interface Checkpoint {
     uncommitted_files: string[];
     git_snapshot: string | null;
     plan_reference: string | null;
+    source: "manual" | "auto";
     created_at: string;
 }
 /** An aggregated end-of-day summary of project activity. */

package/dist/utils.d.ts

@@ -1,2 +1,3 @@
 export declare function getProjectPath(): string;
+export declare function normalizeProjectPath(p: string): string;
 export declare function ensureDir(dirPath: string): void;

package/dist/utils.js

@@ -1,10 +1,23 @@
-import { mkdirSync, existsSync } from "fs";
+import { mkdirSync, realpathSync } from "fs";
+import path from "path";
 // --- Path helpers ---
 export function getProjectPath() {
     return process.cwd();
 }
-export function ensureDir(dirPath) {
-    if (!existsSync(dirPath)) {
-        mkdirSync(dirPath, { recursive: true });
+export function normalizeProjectPath(p) {
+    try {
+        const resolved = realpathSync(p);
+        return resolved.length > 1 && resolved.endsWith(path.sep)
+            ? resolved.slice(0, -1)
+            : resolved;
+    }
+    catch {
+        const normalized = path.resolve(p);
+        return normalized.length > 1 && normalized.endsWith(path.sep)
+            ? normalized.slice(0, -1)
+            : normalized;
     }
 }
+export function ensureDir(dirPath) {
+    mkdirSync(dirPath, { recursive: true });
+}

package/package.json

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

package/prompts/auto_checkpoint.txt

@@ -1,18 +1,35 @@
 You are extracting a session checkpoint from a Claude Code conversation transcript.
 
-Analyze the transcript and produce a JSON object with these fields:
+You have three sources of context:
 
-- what_was_built: What was accomplished in this session (1-3 sentences)
+PREVIOUS CHECKPOINT:
+{{PREVIOUS_CHECKPOINT}}
+
+GIT CHANGES SINCE LAST CHECKPOINT:
+{{GIT_DIFF}}
+
+CURRENT TRANSCRIPT:
+{{TRANSCRIPT}}
+
+Analyze these inputs and produce a JSON object with these fields:
+
+- what_was_built: What was accomplished since the previous checkpoint (1-3 sentences). Focus on what CHANGED — don't repeat already-captured work.
 - current_state: Current state of the project — what's passing, what's broken, what's uncommitted (1-2 sentences)
 - next_steps: What should be done next (1-2 sentences, actionable)
-- decisions_made: Key decisions made during this session, if any (1-2 sentences, or "None")
+- decisions_made: Key decisions made since the previous checkpoint, if any (1-2 sentences, or "None")
 - blockers: Anything blocking progress, if any (1 sentence, or "None")
 - plan_reference: If the session references an active plan document (e.g. PLAN.md, docs/plan.md, a spec file), include the file path and the specific section being worked on (e.g. "docs/v2-plan.md Phase 2 Step 3"). Null if no plan document is referenced.
 
 Rules:
 - Be concise — each field should be 1-3 sentences max
-- Focus on what changed, not what was discussed
-- next_steps should be specific enough to resume work
+- Focus on what was COMPLETED in THIS session's transcript, not what was discussed or explored
+- Don't repeat work already captured in the previous checkpoint
+- If the transcript is mostly noise (exploration, context-filling, debugging with no resolution), be honest: "Explored X and Y but no code changes yet"
+- Note file changes from git diff that aren't explained in the transcript
+- next_steps should be the logical next action based on THIS session's work, not inherited from the previous checkpoint
+- blockers should only include blockers that were ACTIVELY ENCOUNTERED in this session. Do NOT carry forward blockers from the previous checkpoint unless the session transcript shows they were hit. If nothing blocked progress, say "None"
+- current_state should lead with what IS working (e.g. "All tests passing, build clean") before mentioning what's not done
+- what_was_built should name specific features, not just describe generic "schema changes" — use the same terminology the transcript uses
 - For plan_reference, look for file reads/references to plan docs, spec files, or roadmap documents in the transcript
 - Output ONLY valid JSON, no markdown, no explanation
 
@@ -24,7 +41,4 @@ Example output:
   "decisions_made": "Using bcrypt over argon2 for password hashing due to simpler deployment. Storing refresh tokens in httpOnly cookies.",
   "blockers": "None",
   "plan_reference": "docs/auth-plan.md Phase 2 Step 1"
-}
-
-Transcript:
-{TRANSCRIPT}
+}

package/prompts/daily_summary.txt

@@ -15,7 +15,7 @@ Instructions:
 - Do not fabricate information not present in the activity data
 - If the activity data is sparse, reflect that honestly rather than padding
 
-Respond with ONLY a valid JSON object matching this shape:
+Respond with ONLY a valid JSON object matching this shape — no code fences, no text before or after. Your entire response must be parseable by JSON.parse().
 
 {"what_was_built": "...", "decisions_made": ["..."], "blockers": ["..."], "next_steps": ["..."], "highlights": "..."}
 
@@ -25,5 +25,3 @@ Field rules:
 - blockers: array of unresolved issues; use [] if none
 - next_steps: array of actionable items for the next session
 - highlights: one-line summary suitable for a changelog or standup
-
-Respond with ONLY valid JSON. Do not wrap in code fences. Do not include any text before or after the JSON object. Your entire response must be parseable by JSON.parse().