claude-recall 0.20.16 → 0.21.1

package/.claude/skills/auto-preferences/SKILL.md

@@ -8,14 +8,14 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 5 memories. Last updated: 2026-04-10.
+Auto-generated from 5 memories. Last updated: 2026-04-11.
 
 ## Rules
 
-- Session test preference 1775841028541
-- Test preference 1775841028479-2
-- Test preference 1775841028479-1
-- Test preference 1775841028479-0
+- Session test preference 1775896807164
+- Test preference 1775896807117-2
+- Test preference 1775896807117-1
+- Test preference 1775896807117-0
 - Test memory content
 
 ---

package/.claude/skills/auto-preferences/manifest.json

@@ -1,13 +1,13 @@
 {
   "topicId": "preferences",
-  "sourceHash": "ffe036415b05cb18e9c3e65a38a2e7dedbf02dfd5463c14a03184a9c93c75799",
+  "sourceHash": "47589a75902fabe04a4aab7d8c89e3cdd26c4c1cf7b6e3086a7ea3186413abe4",
   "memoryCount": 5,
-  "generatedAt": "2026-04-10T17:10:28.567Z",
+  "generatedAt": "2026-04-11T08:40:07.182Z",
   "memoryKeys": [
-    "memory_1775841028543_yc9163qfd",
-    "memory_1775841028515_8bjn9exsc",
-    "memory_1775841028500_gch5kvqxl",
-    "memory_1775841028480_n2evtiegj",
-    "memory_1775841028436_w06waet05"
+    "memory_1775896807165_8gx2muuz6",
+    "memory_1775896807142_2zmd3oc2x",
+    "memory_1775896807130_nsc3d9wky",
+    "memory_1775896807118_3qvm34ozn",
+    "memory_1775896807081_saak1fkqp"
   ]
 }

package/README.md

@@ -180,6 +180,24 @@ claude-recall import backup.json             # Import memories from JSON
 claude-recall clear --force                  # Delete all memories (irreversible)
 ```
 
+### Task Checkpoints
+
+Persistent "where I left off" snapshots — one per project, replaces previous on save. Not loaded as a rule; `load_rules` only hints that one exists.
+
+```bash
+claude-recall checkpoint save \
+  --completed "inference layer, domain layer" \
+  --remaining "wire server.js, strip 3GPP URNs" \
+  --blockers "none" \
+  --notes "see inference/README.md"
+
+claude-recall checkpoint load              # Show the latest checkpoint
+claude-recall checkpoint load --json       # Machine-readable
+claude-recall checkpoint clear             # Delete the checkpoint
+```
+
+Agents can also save/load checkpoints via MCP tools (`mcp__claude-recall__save_checkpoint` / `mcp__claude-recall__load_checkpoint`) or Pi tools (`recall_save_checkpoint` / `recall_load_checkpoint`).
+
 ### Troubleshooting
 
 ```bash
@@ -246,6 +264,11 @@ claude-recall outcomes --section stats   # Retrieval/helpfulness stats
 claude-recall outcomes --limit 20        # More items per section
 claude-recall monitor                    # Memory search monitoring stats
 
+# ── Task Checkpoints ────────────────────────────────────────────────
+claude-recall checkpoint save --completed <text> --remaining <text> [--blockers <text>] [--notes <text>] [--project <id>]
+claude-recall checkpoint load [--project <id>] [--json]
+claude-recall checkpoint clear [--project <id>]
+
 # ── Skills ───────────────────────────────────────────────────────────
 claude-recall skills generate            # Generate skills from memories
 claude-recall skills generate --dry-run  # Preview without writing

package/dist/cli/claude-recall-cli.js

@@ -500,6 +500,80 @@ class ClaudeRecallCLI {
             process.exit(1);
         }
     }
+    /**
+     * Save a task checkpoint for the current (or specified) project.
+     */
+    checkpointSave(opts) {
+        try {
+            const projectId = opts.project || config_1.ConfigService.getInstance().getProjectId();
+            this.memoryService.saveCheckpoint(projectId, {
+                completed: opts.completed,
+                remaining: opts.remaining,
+                blockers: opts.blockers || 'none',
+                notes: opts.notes,
+            });
+            console.log(`\n✅ Checkpoint saved for project: ${projectId}\n`);
+            console.log(`  Completed: ${opts.completed}`);
+            console.log(`  Remaining: ${opts.remaining}`);
+            console.log(`  Blockers:  ${opts.blockers || 'none'}`);
+            if (opts.notes)
+                console.log(`  Notes:     ${opts.notes}`);
+            console.log('');
+        }
+        catch (error) {
+            console.error('❌ Checkpoint save failed:', error);
+            process.exit(1);
+        }
+    }
+    /**
+     * Load the latest task checkpoint for the current (or specified) project.
+     */
+    checkpointLoad(opts) {
+        try {
+            const projectId = opts.project || config_1.ConfigService.getInstance().getProjectId();
+            const checkpoint = this.memoryService.loadCheckpoint(projectId);
+            if (!checkpoint) {
+                console.log(`\nNo checkpoint found for project: ${projectId}\n`);
+                return;
+            }
+            if (opts.json) {
+                console.log(JSON.stringify({ projectId, ...checkpoint }, null, 2));
+                return;
+            }
+            const updatedDate = new Date(checkpoint.updated_at).toLocaleString();
+            console.log(`\n📌 Checkpoint for project: ${projectId}`);
+            console.log(`   Updated: ${updatedDate}\n`);
+            console.log(`  Completed: ${checkpoint.completed}`);
+            console.log(`  Remaining: ${checkpoint.remaining}`);
+            console.log(`  Blockers:  ${checkpoint.blockers}`);
+            if (checkpoint.notes)
+                console.log(`  Notes:     ${checkpoint.notes}`);
+            console.log('');
+        }
+        catch (error) {
+            console.error('❌ Checkpoint load failed:', error);
+            process.exit(1);
+        }
+    }
+    /**
+     * Delete the task checkpoint for the current (or specified) project.
+     */
+    checkpointClear(opts) {
+        try {
+            const projectId = opts.project || config_1.ConfigService.getInstance().getProjectId();
+            const deleted = this.memoryService.deleteCheckpoint(projectId);
+            if (deleted) {
+                console.log(`\n✅ Checkpoint cleared for project: ${projectId}\n`);
+            }
+            else {
+                console.log(`\nNo checkpoint to clear for project: ${projectId}\n`);
+            }
+        }
+        catch (error) {
+            console.error('❌ Checkpoint clear failed:', error);
+            process.exit(1);
+        }
+    }
     /**
      * Show system status
      */
@@ -1394,6 +1468,48 @@ async function main() {
         await cli.clear(options);
         process.exit(0);
     });
+    // Checkpoint command group
+    const checkpoint = program
+        .command('checkpoint')
+        .description('Save and load task checkpoints (work-in-progress snapshots)');
+    checkpoint
+        .command('save')
+        .description('Save a task checkpoint for the current project (replaces previous)')
+        .requiredOption('--completed <text>', 'What is done')
+        .requiredOption('--remaining <text>', 'What is left to do')
+        .option('--blockers <text>', 'Current blockers (default: "none")')
+        .option('--notes <text>', 'Free-form notes, file refs, etc.')
+        .option('--project <id>', 'Project ID (default: current)')
+        .action((options) => {
+        const cli = new ClaudeRecallCLI(program.opts());
+        cli.checkpointSave({
+            project: options.project,
+            completed: options.completed,
+            remaining: options.remaining,
+            blockers: options.blockers,
+            notes: options.notes,
+        });
+        process.exit(0);
+    });
+    checkpoint
+        .command('load')
+        .description('Load the latest task checkpoint for the current project')
+        .option('--project <id>', 'Project ID (default: current)')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        const cli = new ClaudeRecallCLI(program.opts());
+        cli.checkpointLoad({ project: options.project, json: options.json });
+        process.exit(0);
+    });
+    checkpoint
+        .command('clear')
+        .description('Delete the task checkpoint for the current project')
+        .option('--project <id>', 'Project ID (default: current)')
+        .action((options) => {
+        const cli = new ClaudeRecallCLI(program.opts());
+        cli.checkpointClear({ project: options.project });
+        process.exit(0);
+    });
     // Status command
     program
         .command('status')

package/dist/mcp/tools/memory-tools.js

@@ -1,10 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryTools = void 0;
+exports.formatRuleValue = formatRuleValue;
 const config_1 = require("../../services/config");
 const search_monitor_1 = require("../../services/search-monitor");
 const skill_generator_1 = require("../../services/skill-generator");
 const outcome_storage_1 = require("../../services/outcome-storage");
+/**
+ * Render any memory.value shape as a readable string for load_rules output.
+ *
+ * Memory values land in the DB in several historical shapes. The previous
+ * rendering used `m.value.content || m.value.value || JSON.stringify(m.value)`
+ * which short-circuited on truthy non-string objects, producing "[object Object]"
+ * when string interpolation eventually called toString() on the returned object.
+ *
+ * Rules:
+ *   1. strings/numbers pass through (or coerce)
+ *   2. null/undefined → empty string
+ *   3. objects: prefer the first STRING field in order: content, value, title, description
+ *      (only string — non-string `content` falls through to title)
+ *   4. nested failure shapes: extract `what_failed` (top-level or under `content`)
+ *   5. last resort: truncated JSON.stringify (never raw object)
+ *
+ * Exported for direct unit testing in tests/unit/format-rule-value.test.ts.
+ */
+function formatRuleValue(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value !== 'object')
+        return String(value);
+    const v = value;
+    // Prefer the first non-empty string field. Order matters:
+    // - `content` covers legacy hook failures and promoted lessons (lesson text)
+    // - `value` covers preference shape
+    // - `title` covers tool-outcome-watcher failures whose `content` is a nested object
+    // - `description` is a last-ditch human label
+    for (const field of ['content', 'value', 'title', 'description']) {
+        const candidate = v[field];
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return candidate;
+        }
+    }
+    // Nested failure object — extract what_failed if present
+    if (typeof v.what_failed === 'string' && v.what_failed.trim()) {
+        return v.what_failed;
+    }
+    if (v.content && typeof v.content === 'object') {
+        const inner = v.content;
+        if (typeof inner.what_failed === 'string' && inner.what_failed.trim()) {
+            return inner.what_failed;
+        }
+    }
+    // Last resort: truncated JSON. Never return a raw object.
+    try {
+        const json = JSON.stringify(value);
+        return json.length > 200 ? json.substring(0, 200) + '…' : json;
+    }
+    catch {
+        return String(value);
+    }
+}
 class MemoryTools {
     constructor(memoryService, logger, onMemoryChanged) {
         this.memoryService = memoryService;
@@ -162,7 +219,34 @@ class MemoryTools {
                     required: ['id']
                 },
                 handler: this.handleDeleteMemory.bind(this)
-            }
+            },
+            {
+                name: 'mcp__claude-recall__save_checkpoint',
+                description: 'Save a task checkpoint — a structured snapshot of work in progress (completed/remaining/blockers/notes). Replaces any previous checkpoint for this project. Call when ending a work session or pausing on a task.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        completed: { type: 'string', description: 'What has been finished in this work stream' },
+                        remaining: { type: 'string', description: 'What is left to do' },
+                        blockers: { type: 'string', description: 'Current blockers (use "none" if none)' },
+                        notes: { type: 'string', description: 'Optional free-form notes, file references, etc.' },
+                        projectId: { type: 'string', description: 'Optional project ID override. Defaults to current project.' },
+                    },
+                    required: ['completed', 'remaining', 'blockers'],
+                },
+                handler: this.handleSaveCheckpoint.bind(this),
+            },
+            {
+                name: 'mcp__claude-recall__load_checkpoint',
+                description: 'Load the latest task checkpoint for the current project. Returns null if none exists. Call at the start of a session to recall where you left off — load_rules will hint when one exists.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'Optional project ID override. Defaults to current project.' },
+                    },
+                },
+                handler: this.handleLoadCheckpoint.bind(this),
+            },
         ];
     }
     /**
@@ -260,7 +344,7 @@ class MemoryTools {
             const sections = [];
             if (rules.preferences.length > 0) {
                 sections.push('## Preferences\n' + rules.preferences.map(m => {
-                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    const val = formatRuleValue(m.value);
                     // Only show key prefix if it's a meaningful name (not auto-generated)
                     const key = m.preference_key || m.key || '';
                     const isAutoKey = key.startsWith('memory_') || key.startsWith('auto_') || key.startsWith('pref_');
@@ -269,7 +353,7 @@ class MemoryTools {
             }
             if (rules.corrections.length > 0) {
                 sections.push('## Corrections\n' + rules.corrections.map(m => {
-                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    const val = formatRuleValue(m.value);
                     const isPromoted = m.key.startsWith('promoted_') || m.value?.source === 'promotion-engine';
                     const evidence = isPromoted && m.value?.evidence_count ? ` (learned from ${m.value.evidence_count} observations)` : '';
                     return isPromoted ? `- [promoted lesson] ${val}${evidence}` : `- ${val}`;
@@ -281,21 +365,21 @@ class MemoryTools {
                 const regularFailures = rules.failures.filter(m => !m.key.startsWith('promoted_') && m.value?.source !== 'promotion-engine');
                 if (promotedLessons.length > 0) {
                     sections.push('## Promoted Lessons (learned from repeated outcomes)\n' + promotedLessons.map(m => {
-                        const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                        const val = formatRuleValue(m.value);
                         const evidence = m.value?.evidence_count ? ` (seen ${m.value.evidence_count}x)` : '';
                         return `- ${val}${evidence}`;
                     }).join('\n'));
                 }
                 if (regularFailures.length > 0) {
                     sections.push('## Failures\n' + regularFailures.map(m => {
-                        const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                        const val = formatRuleValue(m.value);
                         return `- ${val}`;
                     }).join('\n'));
                 }
             }
             if (rules.devops.length > 0) {
                 sections.push('## DevOps Rules\n' + rules.devops.map(m => {
-                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    const val = formatRuleValue(m.value);
                     return `- ${val}`;
                 }).join('\n'));
             }
@@ -349,15 +433,30 @@ class MemoryTools {
             catch {
                 // Non-critical
             }
+            // Checkpoint hint — surface existence without dumping content
+            let checkpointHint = '';
+            try {
+                const project = projectId || context.projectId || config_1.ConfigService.getInstance().getProjectId();
+                if (this.memoryService.hasCheckpoint(project)) {
+                    const cp = this.memoryService.loadCheckpoint(project);
+                    if (cp) {
+                        const updatedDate = new Date(cp.updated_at).toLocaleString();
+                        checkpointHint = `📌 You have an unfinished task checkpoint from ${updatedDate} — call \`load_checkpoint\` to see completed/remaining/blockers before starting work.\n\n`;
+                    }
+                }
+            }
+            catch {
+                // Non-critical
+            }
             let rulesText;
             if (sections.length > 0) {
                 const body = sections.join('\n\n');
                 rulesText = directive
-                    ? `${directive}\n\n---\n\n${body}`
-                    : body;
+                    ? `${directive}\n\n${checkpointHint}---\n\n${body}`
+                    : `${checkpointHint}${body}`;
             }
             else {
-                rulesText = 'No active rules found. This may be a new project.';
+                rulesText = checkpointHint || 'No active rules found. This may be a new project.';
             }
             return {
                 rules: rulesText,
@@ -462,6 +561,45 @@ class MemoryTools {
             throw error;
         }
     }
+    async handleSaveCheckpoint(input, context) {
+        try {
+            const { completed, remaining, blockers, notes, projectId } = input;
+            if (typeof completed !== 'string' || typeof remaining !== 'string' || typeof blockers !== 'string') {
+                throw new Error('completed, remaining, and blockers are required string fields');
+            }
+            const project = projectId || config_1.ConfigService.getInstance().getProjectId();
+            this.memoryService.saveCheckpoint(project, { completed, remaining, blockers, notes });
+            return {
+                success: true,
+                projectId: project,
+                message: `Checkpoint saved for project: ${project}`,
+            };
+        }
+        catch (error) {
+            this.logger.error('MemoryTools', 'Failed to save checkpoint', error);
+            throw error;
+        }
+    }
+    async handleLoadCheckpoint(input, context) {
+        try {
+            const { projectId } = input || {};
+            const project = projectId || config_1.ConfigService.getInstance().getProjectId();
+            const checkpoint = this.memoryService.loadCheckpoint(project);
+            if (!checkpoint) {
+                return { found: false, projectId: project };
+            }
+            return {
+                found: true,
+                projectId: project,
+                ...checkpoint,
+                updated_at_iso: new Date(checkpoint.updated_at).toISOString(),
+            };
+        }
+        catch (error) {
+            this.logger.error('MemoryTools', 'Failed to load checkpoint', error);
+            throw error;
+        }
+    }
     getTools() {
         return this.tools;
     }

package/dist/memory/storage.js

@@ -329,6 +329,51 @@ class MemoryStorage {
         // This ensures that other processes (like CLI) can see the changes immediately
         this.db.pragma('wal_checkpoint(TRUNCATE)');
     }
+    // --- Task checkpoint methods ---
+    checkpointKey(projectId) {
+        return `task-checkpoint:${projectId}`;
+    }
+    saveCheckpoint(projectId, input) {
+        const checkpoint = {
+            completed: input.completed,
+            remaining: input.remaining,
+            blockers: input.blockers,
+            notes: input.notes,
+            updated_at: Date.now(),
+        };
+        // Use a deterministic key per project so INSERT OR REPLACE replaces the previous one.
+        // Direct INSERT OR REPLACE bypasses fuzzy/hash dedup since they check `key != ?`.
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO memories
+      (key, value, type, project_id, file_path, timestamp, relevance_score, access_count,
+       preference_key, is_active, superseded_by, superseded_at, confidence_score, sophistication_level, scope, content_hash)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const value = JSON.stringify(checkpoint);
+        const contentHash = this.computeContentHash(checkpoint, 'task-checkpoint');
+        stmt.run(this.checkpointKey(projectId), value, 'task-checkpoint', projectId, null, checkpoint.updated_at, 1.0, 0, null, 1, null, null, null, 1, null, contentHash);
+        this.db.pragma('wal_checkpoint(TRUNCATE)');
+    }
+    loadCheckpoint(projectId) {
+        const row = this.db.prepare('SELECT value FROM memories WHERE key = ? AND type = ?').get(this.checkpointKey(projectId), 'task-checkpoint');
+        if (!row)
+            return null;
+        try {
+            return JSON.parse(row.value);
+        }
+        catch {
+            return null;
+        }
+    }
+    hasCheckpoint(projectId) {
+        const row = this.db.prepare('SELECT 1 FROM memories WHERE key = ? AND type = ?').get(this.checkpointKey(projectId), 'task-checkpoint');
+        return !!row;
+    }
+    deleteCheckpoint(projectId) {
+        const result = this.db.prepare('DELETE FROM memories WHERE key = ? AND type = ?').run(this.checkpointKey(projectId), 'task-checkpoint');
+        this.db.pragma('wal_checkpoint(TRUNCATE)');
+        return result.changes > 0;
+    }
     retrieve(key) {
         const stmt = this.db.prepare('SELECT * FROM memories WHERE key = ?');
         const row = stmt.get(key);

package/dist/pi/extension.js

@@ -217,9 +217,21 @@ function default_1(pi) {
                         os.recordRetrieval(m.key);
                 }
                 catch { /* non-critical */ }
+                // Checkpoint hint — surface existence without dumping content
+                let checkpointHint = '';
+                try {
+                    if (ms.hasCheckpoint(projectId)) {
+                        const cp = ms.loadCheckpoint(projectId);
+                        if (cp) {
+                            const updatedDate = new Date(cp.updated_at).toLocaleString();
+                            checkpointHint = `📌 You have an unfinished task checkpoint from ${updatedDate} — call \`recall_load_checkpoint\` to see completed/remaining/blockers before starting work.\n\n`;
+                        }
+                    }
+                }
+                catch { /* non-critical */ }
                 const text = body
-                    ? `${LOAD_RULES_DIRECTIVE}\n\n---\n\n${body}`
-                    : 'No active rules found. This may be a new project.';
+                    ? `${LOAD_RULES_DIRECTIVE}\n\n${checkpointHint}---\n\n${body}`
+                    : (checkpointHint || 'No active rules found. This may be a new project.');
                 return {
                     content: [{ type: 'text', text }],
                 };
@@ -333,6 +345,73 @@ function default_1(pi) {
             }
         },
     });
+    // --- Tool: recall_save_checkpoint ---
+    pi.registerTool({
+        name: 'recall_save_checkpoint',
+        label: 'Save Task Checkpoint',
+        description: 'Save a structured snapshot of work in progress (completed/remaining/blockers/notes). Replaces any previous checkpoint for this project. Call when ending a session or pausing on a task.',
+        promptSnippet: 'Save a task checkpoint with what is done, what remains, and any blockers',
+        parameters: {},
+        async execute(_id, params, _signal, _onUpdate, _ctx) {
+            try {
+                const { completed, remaining, blockers, notes } = params || {};
+                if (typeof completed !== 'string' || typeof remaining !== 'string' || typeof blockers !== 'string') {
+                    return {
+                        content: [{ type: 'text', text: 'Error: completed, remaining, and blockers are required string fields' }],
+                        isError: true,
+                    };
+                }
+                const ms = memory_1.MemoryService.getInstance();
+                ms.saveCheckpoint(projectId, { completed, remaining, blockers, notes });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                success: true,
+                                projectId,
+                                message: `Checkpoint saved for project: ${projectId}`,
+                            }) }],
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `Failed to save checkpoint: ${err.message}` }],
+                    isError: true,
+                };
+            }
+        },
+    });
+    // --- Tool: recall_load_checkpoint ---
+    pi.registerTool({
+        name: 'recall_load_checkpoint',
+        label: 'Load Task Checkpoint',
+        description: 'Load the latest task checkpoint for the current project. Returns null if none exists. Call at session start to recall where you left off.',
+        promptSnippet: 'Load the saved task checkpoint to see what was in progress',
+        parameters: {},
+        async execute(_id, _params, _signal, _onUpdate, _ctx) {
+            try {
+                const ms = memory_1.MemoryService.getInstance();
+                const checkpoint = ms.loadCheckpoint(projectId);
+                if (!checkpoint) {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ found: false, projectId }) }],
+                    };
+                }
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                found: true,
+                                projectId,
+                                ...checkpoint,
+                                updated_at_iso: new Date(checkpoint.updated_at).toISOString(),
+                            }) }],
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `Failed to load checkpoint: ${err.message}` }],
+                    isError: true,
+                };
+            }
+        },
+    });
     // --- Tool: recall_delete_memory ---
     pi.registerTool({
         name: 'recall_delete_memory',

package/dist/services/memory.js

@@ -527,6 +527,24 @@ class MemoryService {
     getDatabase() {
         return this.storage.getDatabase();
     }
+    // --- Task checkpoint methods ---
+    saveCheckpoint(projectId, input) {
+        this.storage.saveCheckpoint(projectId, input);
+        this.logger.info('MemoryService', `Checkpoint saved for project: ${projectId}`);
+    }
+    loadCheckpoint(projectId) {
+        return this.storage.loadCheckpoint(projectId);
+    }
+    hasCheckpoint(projectId) {
+        return this.storage.hasCheckpoint(projectId);
+    }
+    deleteCheckpoint(projectId) {
+        const deleted = this.storage.deleteCheckpoint(projectId);
+        if (deleted) {
+            this.logger.info('MemoryService', `Checkpoint deleted for project: ${projectId}`);
+        }
+        return deleted;
+    }
     /**
      * Check if database is connected
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-recall",
-  "version": "0.20.16",
+  "version": "0.21.1",
   "description": "Persistent memory for Claude Code and Pi with native Skills integration, automatic capture, failure learning, and project scoping",
   "main": "dist/index.js",
   "bin": {