pmem-ai 0.7.4 → 0.7.6

package/dist/commands/verify.js

@@ -61,341 +61,438 @@ function verifyCommand(options) {
             fix: 'Run: pmem init',
         });
     }
-    // 2. Check SQLite DB exists
-    const dbPath = path.join(pmemPath, 'pmem.db');
-    const dbExists = (0, fs_1.fileExists)(dbPath);
-    let db = null;
-    if (!dbExists) {
-        issues.push({
-            severity: 'warning',
-            type: 'missing_database',
-            message: '.pmem/pmem.db not found.',
-            fix: 'Run: pmem rebuild',
-        });
-    }
-    else {
-        try {
-            db = (0, db_1.openDatabase)(pmemPath);
-            (0, db_1.createSchema)(db);
-        }
-        catch (err) {
-            issues.push({
-                severity: 'error',
-                type: 'corrupt_database',
-                message: err?.message || '.pmem/pmem.db is corrupted.',
-                fix: 'Back up the file if needed, then run: pmem rebuild --full',
-            });
-            db = null;
-        }
-    }
-    // 2b. Lock status check
+    // 2b. Lock status check (read-only)
+    //
+    // v0.7.6 FIX-1 (issue #9): restructured the lock block. The old code
+    // emitted an `active_lock` warning here based purely on lock presence.
+    // The new flow instead tries to *acquire* the lock with a short timeout
+    // (see below) — if it cannot, another process is rebuilding right now
+    // and we defer stale-index checks instead of producing a transient
+    // `stale_index` warning. The `stale_lock` / `stale_lock_cleaned`
+    // classification still exists so users can still detect + clean
+    // crashed pmem processes that left a lock behind.
     const lockPath = path.join(pmemPath, '.lock');
     const lockStatus = (0, fs_1.getLockStatus)(lockPath);
-    if (lockStatus.exists) {
-        if (lockStatus.stale) {
-            const ageSec = lockStatus.age !== null ? Math.round(lockStatus.age / 1000) : '?';
-            if (options.fixLocks) {
-                (0, fs_1.breakLock)(lockPath);
-                issues.push({
-                    severity: 'warning',
-                    type: 'stale_lock_cleaned',
-                    message: `Stale lock at .pmem/.lock (age: ${ageSec}s) was cleaned.`,
-                    fix: 'Lock has been removed. You can now run pmem commands.',
-                });
-            }
-            else {
-                issues.push({
-                    severity: 'warning',
-                    type: 'stale_lock',
-                    message: `Stale lock detected at .pmem/.lock (age: ${ageSec}s).`,
-                    fix: 'Run: pmem verify --fix-locks (to clean stale lock)\n       Or: pmem doctor (to diagnose lock status)',
-                });
-            }
-        }
-        else if (lockStatus.age !== null) {
-            const ageSec = Math.round(lockStatus.age / 1000);
+    if (lockStatus.exists && lockStatus.stale) {
+        const ageSec = lockStatus.age !== null ? Math.round(lockStatus.age / 1000) : '?';
+        if (options.fixLocks) {
+            (0, fs_1.breakLock)(lockPath);
             issues.push({
                 severity: 'warning',
-                type: 'active_lock',
-                message: `Active lock at .pmem/.lock (age: ${ageSec}s). Another pmem process may be running.`,
-                fix: 'Wait for the other process to finish. If no other process is running, run: pmem verify --fix-locks',
+                type: 'stale_lock_cleaned',
+                message: `Stale lock at .pmem/.lock (age: ${ageSec}s) was cleaned.`,
+                fix: 'Lock has been removed. You can now run pmem commands.',
             });
         }
-    }
-    if (manifest) {
-        // 3. Check schema version
-        const currentSchema = manifest.pmem?.schema_version;
-        if (!currentSchema) {
+        else {
             issues.push({
                 severity: 'warning',
-                type: 'missing_schema_version',
-                message: 'Manifest is missing pmem.schema_version.',
-                fix: 'Run: pmem migrate --to 0.3',
+                type: 'stale_lock',
+                message: `Stale lock detected at .pmem/.lock (age: ${ageSec}s).`,
+                fix: 'Run: pmem verify --fix-locks (to clean stale lock)\n       Or: pmem doctor (to diagnose lock status)',
             });
         }
-        else if (currentSchema < '0.3') {
-            issues.push({
-                severity: 'warning',
-                type: 'old_schema_version',
-                message: `Project schema version is ${currentSchema}. Current CLI supports 0.3.`,
-                fix: 'Run: pmem migrate --to 0.3',
-            });
+    }
+    // v0.7.6 FIX-1 (issue #9): try to acquire the lock with a short timeout
+    // so a concurrent `pmem rebuild` cannot tear the SQLite index out from
+    // under us while we read it (which would produce a transient `stale_index`
+    // warning that disappears on the next verify). If we cannot acquire the
+    // lock, surface a single info-level `active_lock` note and skip the
+    // freshness checks entirely.
+    const lockAcquired = (0, fs_1.acquireLock)(lockPath, 500);
+    if (!lockAcquired) {
+        const ageSec = lockStatus.age !== null ? Math.round(lockStatus.age / 1000) : '?';
+        issues.push({
+            severity: 'info',
+            type: 'active_lock',
+            message: `Active lock at .pmem/.lock (age: ${ageSec}s). Another pmem process is running — deferring index freshness checks.`,
+            fix: 'Wait for the other pmem process to finish, then re-run: pmem verify',
+        });
+        const errors = issues.filter(i => i.severity === 'error');
+        const warnings = issues.filter(i => i.severity === 'warning');
+        const infos = issues.filter(i => i.severity === 'info');
+        const passed = errors.length === 0;
+        const score = Math.max(0, 100 - errors.length * 30 - warnings.length * 5);
+        const result = { passed, score, issues };
+        if (passed && warnings.length === 0) {
+            console.log(`Memory Verify Result: clean (index checks deferred).`);
+            console.log(`Score: ${score}/100`);
+            if (infos.length > 0) {
+                console.log('');
+                console.log('Informational Notes:');
+                for (const issue of infos) {
+                    console.log(`ℹ [${issue.type}] ${issue.message}`);
+                }
+            }
+            return;
+        }
+        console.log(`Memory Verify Result: ${passed ? 'Warnings found' : 'Failed'}`);
+        console.log(`Score: ${score}/100`);
+        console.log('');
+        for (const issue of issues) {
+            let icon = 'ℹ';
+            if (issue.severity === 'error')
+                icon = '✗';
+            else if (issue.severity === 'warning')
+                icon = '⚠';
+            console.log(`${icon} [${issue.type}] ${issue.message}`);
+            console.log(`  Fix: ${issue.fix}`);
+            console.log('');
         }
-        else if (currentSchema > '0.3') {
+        const hasErrors = issues.some(i => i.severity === 'error');
+        if (hasErrors) {
+            if (options.noExit)
+                return;
+            process.exit(2);
+        }
+        if (options.noExit)
+            return;
+        process.exit(0);
+    }
+    // v0.7.6 FIX-1 (issue #9): wrap the bulk of verify (manifest/schema/hash/
+    // policy checks + auto-fix) in a try/finally so the lock acquired above
+    // is always released — even on a thrown error or an auto-fix subprocess
+    // exit. The early-return `active_lock` branch above already bails before
+    // reaching this block, so it does not need its own release.
+    try {
+        // 2. Check SQLite DB exists (v0.7.6 FIX-1: moved here from before lock
+        //    acquisition so the active_lock fast path never sees a transient
+        //    missing_database warning when rebuild is busy creating the index).
+        const dbPath = path.join(pmemPath, 'pmem.db');
+        const dbExists = (0, fs_1.fileExists)(dbPath);
+        let db = null;
+        if (!dbExists) {
             issues.push({
-                severity: 'error',
-                type: 'newer_schema_version',
-                message: `Project schema version is ${currentSchema}. Current CLI only supports up to 0.3.`,
-                fix: 'Please upgrade pmem CLI to a newer version.',
+                severity: 'warning',
+                type: 'missing_database',
+                message: '.pmem/pmem.db not found.',
+                fix: 'Run: pmem rebuild',
             });
         }
-        if (db) {
-            const cards = db.prepare('SELECT * FROM cards WHERE is_deleted = 0').all();
-            // 4. Hash consistency — compare DB file_hash against actual .md file content
-            for (const card of cards) {
-                const cardFilePath = path.join(cwd, card.file_path);
-                if (!(0, fs_1.fileExists)(cardFilePath)) {
-                    issues.push({
-                        severity: 'warning',
-                        type: 'missing_card_file',
-                        message: `Card "${card.id}" references missing file: ${card.file_path}`,
-                        fix: 'Run: pmem rebuild',
-                    });
-                    continue;
-                }
-                const content = (0, fs_1.readFile)(cardFilePath);
-                if (!content)
-                    continue;
-                const currentFileHash = (0, hash_1.computeHash)(content);
-                if (currentFileHash !== card.file_hash) {
-                    issues.push({
-                        severity: 'warning',
-                        type: 'stale_index',
-                        message: `Card "${card.id}" file hash mismatch (stored: ${card.file_hash}, current: ${currentFileHash}).`,
-                        fix: 'Run: pmem rebuild',
-                    });
-                }
+        else {
+            try {
+                db = (0, db_1.openDatabase)(pmemPath);
+                (0, db_1.createSchema)(db);
             }
-            // 5. Orphan edges — edges referencing non-existent card IDs
-            const orphanFrom = db.prepare('SELECT e.* FROM edges e LEFT JOIN cards c ON e.from_id = c.id WHERE c.id IS NULL').all();
-            const orphanTo = db.prepare('SELECT e.* FROM edges e LEFT JOIN cards c ON e.to_id = c.id WHERE c.id IS NULL').all();
-            const orphanEdgeSet = new Map();
-            for (const e of orphanFrom) {
-                if (e.id !== undefined)
-                    orphanEdgeSet.set(e.id, e);
+            catch (err) {
+                issues.push({
+                    severity: 'error',
+                    type: 'corrupt_database',
+                    message: err?.message || '.pmem/pmem.db is corrupted.',
+                    fix: 'Back up the file if needed, then run: pmem rebuild --full',
+                });
+                db = null;
             }
-            for (const e of orphanTo) {
-                if (e.id !== undefined && !orphanEdgeSet.has(e.id))
-                    orphanEdgeSet.set(e.id, e);
+        }
+        if (manifest) {
+            // 3. Check schema version
+            const currentSchema = manifest.pmem?.schema_version;
+            if (!currentSchema) {
+                issues.push({
+                    severity: 'warning',
+                    type: 'missing_schema_version',
+                    message: 'Manifest is missing pmem.schema_version.',
+                    fix: 'Run: pmem migrate --to 0.3',
+                });
             }
-            if (orphanEdgeSet.size > 0) {
+            else if (currentSchema < '0.3') {
                 issues.push({
                     severity: 'warning',
-                    type: 'orphan_edges',
-                    message: `${orphanEdgeSet.size} edge(s) reference non-existent card IDs.`,
-                    fix: 'Run: pmem rebuild',
+                    type: 'old_schema_version',
+                    message: `Project schema version is ${currentSchema}. Current CLI supports 0.3.`,
+                    fix: 'Run: pmem migrate --to 0.3',
+                });
+            }
+            else if (currentSchema > '0.3') {
+                issues.push({
+                    severity: 'error',
+                    type: 'newer_schema_version',
+                    message: `Project schema version is ${currentSchema}. Current CLI only supports up to 0.3.`,
+                    fix: 'Please upgrade pmem CLI to a newer version.',
                 });
             }
-            // 6. Card policy checks
-            if (manifest.card_policy) {
-                const policy = manifest.card_policy;
-                // 6a. ID naming pattern — v0.7.0: render {types} placeholder if present
-                const config = (0, manifest_1.resolveConfig)(manifest);
-                const renderedPattern = (0, manifest_1.renderIdPattern)(policy.id_pattern, config.card_types);
-                const idRegex = new RegExp(renderedPattern);
+            if (db) {
+                const cards = db.prepare('SELECT * FROM cards WHERE is_deleted = 0').all();
+                // 4. Hash consistency — compare DB file_hash against actual .md file content
                 for (const card of cards) {
-                    if (!idRegex.test(card.id)) {
+                    const cardFilePath = path.join(cwd, card.file_path);
+                    if (!(0, fs_1.fileExists)(cardFilePath)) {
                         issues.push({
                             severity: 'warning',
-                            type: 'card_id_violation',
-                            message: `Card "${card.id}" does not match naming pattern.`,
-                            fix: `Rename card ID to match: ${renderedPattern}`,
+                            type: 'missing_card_file',
+                            message: `Card "${card.id}" references missing file: ${card.file_path}`,
+                            fix: 'Run: pmem rebuild',
+                        });
+                        continue;
+                    }
+                    const content = (0, fs_1.readFile)(cardFilePath);
+                    if (!content)
+                        continue;
+                    const currentFileHash = (0, hash_1.computeHash)(content);
+                    if (currentFileHash !== card.file_hash) {
+                        issues.push({
+                            severity: 'warning',
+                            type: 'stale_index',
+                            message: `Card "${card.id}" file hash mismatch (stored: ${card.file_hash}, current: ${currentFileHash}).`,
+                            fix: 'Run: pmem rebuild',
                         });
                     }
                 }
-                // 6b. Token count limits — read files and estimate tokens
-                for (const card of cards) {
-                    const filePath = path.join(cwd, card.file_path);
-                    const content = (0, fs_1.readFile)(filePath);
-                    if (content) {
-                        const estimatedTokens = (0, hash_1.tokenCount)(content);
-                        const maxForType = policy.max_tokens[card.type];
-                        if (maxForType && estimatedTokens > maxForType) {
-                            // Check if relaxed locally (frontmatter or manifest list)
-                            const isLocalRelaxed = (() => {
-                                const parsed = (0, yaml_1.parseFrontmatter)(content);
-                                if (parsed?.data) {
-                                    if (parsed.data.relaxed === true || parsed.data.token_policy === 'relaxed') {
+                // 5. Orphan edges — edges referencing non-existent card IDs
+                const orphanFrom = db.prepare('SELECT e.* FROM edges e LEFT JOIN cards c ON e.from_id = c.id WHERE c.id IS NULL').all();
+                const orphanTo = db.prepare('SELECT e.* FROM edges e LEFT JOIN cards c ON e.to_id = c.id WHERE c.id IS NULL').all();
+                const orphanEdgeSet = new Map();
+                for (const e of orphanFrom) {
+                    if (e.id !== undefined)
+                        orphanEdgeSet.set(e.id, e);
+                }
+                for (const e of orphanTo) {
+                    if (e.id !== undefined && !orphanEdgeSet.has(e.id))
+                        orphanEdgeSet.set(e.id, e);
+                }
+                if (orphanEdgeSet.size > 0) {
+                    issues.push({
+                        severity: 'warning',
+                        type: 'orphan_edges',
+                        message: `${orphanEdgeSet.size} edge(s) reference non-existent card IDs.`,
+                        fix: 'Run: pmem rebuild',
+                    });
+                }
+                // 6. Card policy checks
+                if (manifest.card_policy) {
+                    const policy = manifest.card_policy;
+                    // 6a. ID naming pattern — v0.7.0: render {types} placeholder if present
+                    const config = (0, manifest_1.resolveConfig)(manifest);
+                    const renderedPattern = (0, manifest_1.renderIdPattern)(policy.id_pattern, config.card_types);
+                    const idRegex = new RegExp(renderedPattern);
+                    for (const card of cards) {
+                        if (!idRegex.test(card.id)) {
+                            issues.push({
+                                severity: 'warning',
+                                type: 'card_id_violation',
+                                message: `Card "${card.id}" does not match naming pattern.`,
+                                fix: `Rename card ID to match: ${renderedPattern}`,
+                            });
+                        }
+                    }
+                    // 6b. Token count limits — read files and estimate tokens
+                    for (const card of cards) {
+                        const filePath = path.join(cwd, card.file_path);
+                        const content = (0, fs_1.readFile)(filePath);
+                        if (content) {
+                            const estimatedTokens = (0, hash_1.tokenCount)(content);
+                            const maxForType = policy.max_tokens[card.type];
+                            if (maxForType && estimatedTokens > maxForType) {
+                                // Check if relaxed locally (frontmatter or manifest list)
+                                const isLocalRelaxed = (() => {
+                                    const parsed = (0, yaml_1.parseFrontmatter)(content);
+                                    if (parsed?.data) {
+                                        if (parsed.data.relaxed === true || parsed.data.token_policy === 'relaxed') {
+                                            return true;
+                                        }
+                                    }
+                                    const relaxedCards = policy.relaxed_cards;
+                                    if (Array.isArray(relaxedCards) && relaxedCards.includes(card.id)) {
                                         return true;
                                     }
+                                    return false;
+                                })();
+                                const isRelaxed = !!(options.relaxed || isLocalRelaxed);
+                                if (isRelaxed) {
+                                    issues.push({
+                                        severity: 'info',
+                                        type: 'card_too_large_relaxed',
+                                        message: `Card "${card.id}" (~${estimatedTokens} tokens) exceeds the normal limit of ${maxForType} tokens for type "${card.type}". (Relaxed/suppressed warning).`,
+                                        fix: `To restore normal limits, remove '--relaxed' option, delete 'relaxed: true'/'token_policy: relaxed' from card frontmatter, or remove the card ID from 'relaxed_cards' in .pmem/manifest.yml.`,
+                                        card_id: card.id,
+                                    });
                                 }
-                                const relaxedCards = policy.relaxed_cards;
-                                if (Array.isArray(relaxedCards) && relaxedCards.includes(card.id)) {
-                                    return true;
+                                else {
+                                    issues.push({
+                                        severity: 'warning',
+                                        type: 'card_too_large',
+                                        message: `Card "${card.id}" is ~${estimatedTokens} tokens, exceeding the max configured limit of ${maxForType} tokens for card type "${card.type}" by ${estimatedTokens - maxForType} tokens.`,
+                                        fix: `Consider splitting this card, or raise the limit in .pmem/manifest.yml (card_policy -> max_tokens -> ${card.type}).\n` +
+                                            `       To suppress this warning locally, add 'token_policy: relaxed' or 'relaxed: true' to the card's frontmatter, or add the card ID to 'relaxed_cards' in .pmem/manifest.yml.\n` +
+                                            `       To temporarily relax all limits, run: pmem verify --relaxed`,
+                                        card_id: card.id,
+                                    });
                                 }
-                                return false;
-                            })();
-                            const isRelaxed = !!(options.relaxed || isLocalRelaxed);
-                            if (isRelaxed) {
-                                issues.push({
-                                    severity: 'info',
-                                    type: 'card_too_large_relaxed',
-                                    message: `Card "${card.id}" (~${estimatedTokens} tokens) exceeds the normal limit of ${maxForType} tokens for type "${card.type}". (Relaxed/suppressed warning).`,
-                                    fix: `To restore normal limits, remove '--relaxed' option, delete 'relaxed: true'/'token_policy: relaxed' from card frontmatter, or remove the card ID from 'relaxed_cards' in .pmem/manifest.yml.`,
-                                    card_id: card.id,
-                                });
-                            }
-                            else {
-                                issues.push({
-                                    severity: 'warning',
-                                    type: 'card_too_large',
-                                    message: `Card "${card.id}" is ~${estimatedTokens} tokens, exceeding the max configured limit of ${maxForType} tokens for card type "${card.type}" by ${estimatedTokens - maxForType} tokens.`,
-                                    fix: `Consider splitting this card, or raise the limit in .pmem/manifest.yml (card_policy -> max_tokens -> ${card.type}).\n` +
-                                        `       To suppress this warning locally, add 'token_policy: relaxed' or 'relaxed: true' to the card's frontmatter, or add the card ID to 'relaxed_cards' in .pmem/manifest.yml.\n` +
-                                        `       To temporarily relax all limits, run: pmem verify --relaxed`,
-                                    card_id: card.id,
-                                });
                             }
                         }
                     }
-                }
-                // 6c. Relation count threshold
-                for (const card of cards) {
-                    const { count: relatedEdgeCount } = db.prepare('SELECT COUNT(*) as count FROM edges WHERE from_id = ? OR to_id = ?').get(card.id, card.id);
-                    // Use per-card-type threshold if defined, otherwise fall back to global
-                    const threshold = policy.warn_when_related_count_gt_by_type?.[card.type]
-                        ?? policy.warn_when_related_count_gt;
-                    if (relatedEdgeCount > threshold) {
-                        issues.push({
-                            severity: 'warning',
-                            type: 'too_many_relations',
-                            message: `Card "${card.id}" has ${relatedEdgeCount} relations (threshold: ${threshold} for type "${card.type}").`,
-                            fix: 'Review whether all relations are necessary.',
-                        });
+                    // 6c. Relation count threshold
+                    for (const card of cards) {
+                        const { count: relatedEdgeCount } = db.prepare('SELECT COUNT(*) as count FROM edges WHERE from_id = ? OR to_id = ?').get(card.id, card.id);
+                        // Use per-card-type threshold if defined, otherwise fall back to global
+                        const threshold = policy.warn_when_related_count_gt_by_type?.[card.type]
+                            ?? policy.warn_when_related_count_gt;
+                        if (relatedEdgeCount > threshold) {
+                            // v0.7.6 (issue #10): fetch up to 10 lowest-confidence edges so the
+                            // agent can see which relations contribute to the count and which
+                            // are safe to prune. Sort ASC so lowest-confidence (best pruning
+                            // candidates) appear first.
+                            const topEdgesRaw = db.prepare(`SELECT from_id, to_id, type, source, confidence
+               FROM edges
+               WHERE from_id = ? OR to_id = ?
+               ORDER BY confidence ASC
+               LIMIT 10`).all(card.id, card.id);
+                            const topEdges = topEdgesRaw.map(e => ({
+                                from_id: e.from_id,
+                                to_id: e.to_id,
+                                type: e.type,
+                                source: e.source,
+                                confidence: e.confidence,
+                            }));
+                            const pruningCandidates = topEdges.filter(e => e.source === 'inferred' || e.confidence < 0.5);
+                            issues.push({
+                                severity: 'warning',
+                                type: 'too_many_relations',
+                                message: `Card "${card.id}" has ${relatedEdgeCount} relations (threshold: ${threshold} for type "${card.type}").`,
+                                fix: `Run: pmem relations ${card.id} --format json to inspect.`,
+                                card_id: card.id,
+                                relation_count: relatedEdgeCount,
+                                threshold,
+                                top_edges: topEdges,
+                                pruning_candidates: pruningCandidates,
+                            });
+                        }
                     }
                 }
+                // 9. Stale memory: source files newer than card update time
+                // Uses shared consistency check to stay aligned with update --suggest
+                const staleMemoryIssues = (0, consistency_1.checkStaleMemory)(pmemPath);
+                for (const ci of staleMemoryIssues) {
+                    issues.push({
+                        severity: 'warning',
+                        type: ci.type,
+                        message: ci.message,
+                        fix: ci.card_id ? `Run: pmem update --confirm to update ${ci.card_id}.` : 'Run: pmem rebuild',
+                        card_id: ci.card_id,
+                    });
+                }
             }
-            // 9. Stale memory: source files newer than card update time
-            // Uses shared consistency check to stay aligned with update --suggest
-            const staleMemoryIssues = (0, consistency_1.checkStaleMemory)(pmemPath);
-            for (const ci of staleMemoryIssues) {
+            // 7. Check AGENTS.md exists
+            if (!(0, fs_1.fileExists)(path.join(cwd, 'AGENTS.md'))) {
                 issues.push({
                     severity: 'warning',
-                    type: ci.type,
-                    message: ci.message,
-                    fix: ci.card_id ? `Run: pmem update --confirm to update ${ci.card_id}.` : 'Run: pmem rebuild',
-                    card_id: ci.card_id,
+                    type: 'missing_agents',
+                    message: 'AGENTS.md not found in project root.',
+                    fix: 'Run: pmem init',
+                });
+            }
+            // 8. Check memory_status.dirty
+            if (manifest.memory_status?.dirty) {
+                issues.push({
+                    severity: 'warning',
+                    type: 'memory_dirty',
+                    message: `Memory is marked dirty since ${manifest.memory_status.dirty_since || 'unknown'}. Reason: ${manifest.memory_status.dirty_reason || 'unknown'}.`,
+                    fix: 'Run: pmem update --auto (to detect changes) or pmem update --confirm (to record updates).',
                 });
             }
         }
-        // 7. Check AGENTS.md exists
-        if (!(0, fs_1.fileExists)(path.join(cwd, 'AGENTS.md'))) {
-            issues.push({
-                severity: 'warning',
-                type: 'missing_agents',
-                message: 'AGENTS.md not found in project root.',
-                fix: 'Run: pmem init',
-            });
-        }
-        // 8. Check memory_status.dirty
-        if (manifest.memory_status?.dirty) {
-            issues.push({
-                severity: 'warning',
-                type: 'memory_dirty',
-                message: `Memory is marked dirty since ${manifest.memory_status.dirty_since || 'unknown'}. Reason: ${manifest.memory_status.dirty_reason || 'unknown'}.`,
-                fix: 'Run: pmem update --auto (to detect changes) or pmem update --confirm (to record updates).',
-            });
-        }
-    }
-    // Build result
-    const errors = issues.filter(i => i.severity === 'error');
-    const warnings = issues.filter(i => i.severity === 'warning');
-    const infos = issues.filter(i => i.severity === 'info');
-    const passed = errors.length === 0;
-    const score = Math.max(0, 100 - errors.length * 30 - warnings.length * 5);
-    const result = { passed, score, issues };
-    // Output
-    if (passed && warnings.length === 0) {
-        console.log(`✓ Memory verification passed.`);
-        console.log(`  Score: ${score}/100`);
-        if (infos.length > 0) {
-            console.log('');
-            console.log('Informational Notes:');
-            for (const issue of infos) {
-                console.log(`ℹ [${issue.type}] ${issue.message}`);
+        // Build result
+        const errors = issues.filter(i => i.severity === 'error');
+        const warnings = issues.filter(i => i.severity === 'warning');
+        const infos = issues.filter(i => i.severity === 'info');
+        const passed = errors.length === 0;
+        const score = Math.max(0, 100 - errors.length * 30 - warnings.length * 5);
+        const result = { passed, score, issues };
+        // Output
+        if (passed && warnings.length === 0) {
+            console.log(`✓ Memory verification passed.`);
+            console.log(`  Score: ${score}/100`);
+            if (infos.length > 0) {
+                console.log('');
+                console.log('Informational Notes:');
+                for (const issue of infos) {
+                    console.log(`ℹ [${issue.type}] ${issue.message}`);
+                }
             }
+            return;
         }
-        return;
-    }
-    console.log(`Memory Verify Result: ${passed ? 'Warnings found' : 'Failed'}`);
-    console.log(`Score: ${score}/100`);
-    console.log('');
-    for (const issue of issues) {
-        let icon = 'ℹ';
-        if (issue.severity === 'error')
-            icon = '✗';
-        else if (issue.severity === 'warning')
-            icon = '⚠';
-        console.log(`${icon} [${issue.type}] ${issue.message}`);
-        console.log(`  Fix: ${issue.fix}`);
+        console.log(`Memory Verify Result: ${passed ? 'Warnings found' : 'Failed'}`);
+        console.log(`Score: ${score}/100`);
         console.log('');
-    }
-    // --fix-stale: refresh stale_memory cards by bumping last_verified timestamps.
-    // This is separate from --fix so agents can choose between "repair structural
-    // index state" and "also acknowledge that source-file changes are reviewed."
-    if (options.fixStale) {
-        const staleIssues = issues.filter(i => i.type === 'stale_memory');
-        if (staleIssues.length > 0 && db) {
-            console.log(`Auto-fixing ${staleIssues.length} stale memory card(s)...`);
-            for (const issue of staleIssues) {
-                if (issue.card_id) {
-                    const card = db.prepare('SELECT file_path FROM cards WHERE id = ?').get(issue.card_id);
-                    if (card) {
-                        const cardFilePath = path.join(cwd, card.file_path);
-                        if ((0, fs_1.fileExists)(cardFilePath)) {
-                            updateFrontmatterTimestamp(cardFilePath, 'last_verified');
-                            console.log(`  Updated last_verified timestamp for card: ${issue.card_id}`);
+        for (const issue of issues) {
+            let icon = 'ℹ';
+            if (issue.severity === 'error')
+                icon = '✗';
+            else if (issue.severity === 'warning')
+                icon = '⚠';
+            console.log(`${icon} [${issue.type}] ${issue.message}`);
+            console.log(`  Fix: ${issue.fix}`);
+            console.log('');
+        }
+        // --fix-stale: refresh stale_memory cards by bumping last_verified timestamps.
+        // This is separate from --fix so agents can choose between "repair structural
+        // index state" and "also acknowledge that source-file changes are reviewed."
+        if (options.fixStale) {
+            const staleIssues = issues.filter(i => i.type === 'stale_memory');
+            if (staleIssues.length > 0 && db) {
+                console.log(`Auto-fixing ${staleIssues.length} stale memory card(s)...`);
+                for (const issue of staleIssues) {
+                    if (issue.card_id) {
+                        const card = db.prepare('SELECT file_path FROM cards WHERE id = ?').get(issue.card_id);
+                        if (card) {
+                            const cardFilePath = path.join(cwd, card.file_path);
+                            if ((0, fs_1.fileExists)(cardFilePath)) {
+                                updateFrontmatterTimestamp(cardFilePath, 'last_verified');
+                                console.log(`  Updated last_verified timestamp for card: ${issue.card_id}`);
+                            }
                         }
                     }
                 }
+                console.log('Rebuilding indexes for updated cards...');
+                (0, rebuild_1.rebuildCommand)();
+            }
+            // Also fix structural index issues (stale_index, etc.) when --fix-stale is used
+            const fixableIssue = issues.find(i => i.type === 'stale_index' ||
+                i.type === 'missing_database' ||
+                i.type === 'missing_card_file' ||
+                i.type === 'orphan_edges');
+            if (fixableIssue && staleIssues.length === 0) {
+                console.log('Auto-fixing: rebuilding indexes...');
+                (0, rebuild_1.rebuildCommand)();
             }
-            console.log('Rebuilding indexes for updated cards...');
-            (0, rebuild_1.rebuildCommand)();
         }
-        // Also fix structural index issues (stale_index, etc.) when --fix-stale is used
-        const fixableIssue = issues.find(i => i.type === 'stale_index' ||
-            i.type === 'missing_database' ||
-            i.type === 'missing_card_file' ||
-            i.type === 'orphan_edges');
-        if (fixableIssue && staleIssues.length === 0) {
-            console.log('Auto-fixing: rebuilding indexes...');
-            (0, rebuild_1.rebuildCommand)();
+        // --fix: repair structural index state only (stale_index, missing db, etc.)
+        // Does NOT touch stale_memory — use --fix-stale for that.
+        if (options.fix && !options.fixStale) {
+            const fixableIssue = issues.find(i => i.type === 'stale_index' ||
+                i.type === 'missing_database' ||
+                i.type === 'missing_card_file' ||
+                i.type === 'orphan_edges');
+            if (fixableIssue) {
+                console.log('Auto-fixing: rebuilding indexes...');
+                (0, rebuild_1.rebuildCommand)();
+            }
         }
-    }
-    // --fix: repair structural index state only (stale_index, missing db, etc.)
-    // Does NOT touch stale_memory — use --fix-stale for that.
-    if (options.fix && !options.fixStale) {
-        const fixableIssue = issues.find(i => i.type === 'stale_index' ||
-            i.type === 'missing_database' ||
-            i.type === 'missing_card_file' ||
-            i.type === 'orphan_edges');
-        if (fixableIssue) {
-            console.log('Auto-fixing: rebuilding indexes...');
-            (0, rebuild_1.rebuildCommand)();
+        // --fix-locks cleans stale locks during the check pass above,
+        // but if a stale lock was found and not cleaned (e.g., --fix-locks not passed),
+        // we provide guidance here.
+        const hasErrors = issues.some(i => i.severity === 'error');
+        if (hasErrors) {
+            if (options.noExit)
+                return;
+            (0, fs_1.releaseLock)(lockPath);
+            process.exit(2);
         }
-    }
-    // --fix-locks cleans stale locks during the check pass above,
-    // but if a stale lock was found and not cleaned (e.g., --fix-locks not passed),
-    // we provide guidance here.
-    const hasErrors = issues.some(i => i.severity === 'error');
-    if (hasErrors) {
         if (options.noExit)
             return;
-        process.exit(2);
+        (0, fs_1.releaseLock)(lockPath);
+        process.exit(0);
+    }
+    finally {
+        // If we got here via an exception thrown during verify (e.g. a SQL
+        // error from createSchema), still release the lock. The explicit
+        // `releaseLock` calls above cover the normal exit paths since
+        // `process.exit` does NOT run `finally` blocks.
+        try {
+            (0, fs_1.releaseLock)(lockPath);
+        }
+        catch { /* ignore */ }
     }
-    if (options.noExit)
-        return;
-    process.exit(0);
 }
 function updateFrontmatterTimestamp(filePath, field) {
     const content = (0, fs_1.readFile)(filePath);