shieldcortex 3.1.0 → 3.2.0

package/dist/api/routes/memories.js

@@ -1,3 +1,6 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readdirSync, readFileSync } from 'fs';
 import { getDatabase } from '../../database/init.js';
 import { searchMemories, getRecentMemories, getHighPriorityMemories, getMemoryStats, getMemoryById, addMemory, deleteMemory, accessMemory, updateMemory, promoteMemory, createMemoryLink, rowToMemory, enrichMemory, } from '../../memory/store.js';
 import { calculateDecayedScore } from '../../memory/decay.js';
@@ -6,6 +9,185 @@ import { getActivationStats, getActiveMemories } from '../../memory/activation.j
 import { detectContradictions, getContradictionsFor } from '../../memory/contradiction.js';
 import { emitConsolidation } from '../events.js';
 export function registerMemoryRoutes(app, requireNotLocked) {
+    app.get('/api/capture/openclaw/sessions', requireNotLocked, (req, res) => {
+        try {
+            const limit = Math.min(parseInt(req.query.limit, 10) || 20, 100);
+            const auditDir = join(homedir(), '.shieldcortex', 'audit');
+            const db = getDatabase();
+            const rows = db.prepare(`
+        SELECT * FROM memories
+        WHERE source_kind IN ('hook', 'plugin') OR source LIKE 'hook:openclaw%' OR source LIKE 'agent:openclaw-plugin%'
+        ORDER BY updated_at DESC
+        LIMIT 500
+      `).all();
+            const openClawMemories = rows.map(rowToMemory);
+            const sessionMap = new Map();
+            const getSession = (sessionId) => {
+                let session = sessionMap.get(sessionId);
+                if (!session) {
+                    session = {
+                        sessionId,
+                        firstSeenAt: new Date().toISOString(),
+                        lastSeenAt: new Date(0).toISOString(),
+                        storedMemoryCount: 0,
+                        loggedSaved: 0,
+                        skipped: 0,
+                        threats: 0,
+                        blocked: 0,
+                        quarantined: 0,
+                        autoExtracted: 0,
+                        keywordTriggered: 0,
+                        pinned: 0,
+                        suppressed: 0,
+                        hooks: new Set(),
+                        models: new Set(),
+                        agentIds: new Set(),
+                        memoryIds: new Set(),
+                        previews: [],
+                        events: [],
+                    };
+                    sessionMap.set(sessionId, session);
+                }
+                return session;
+            };
+            for (const memory of openClawMemories) {
+                const sessionId = typeof memory.metadata?.sessionId === 'string'
+                    ? memory.metadata.sessionId
+                    : memory.source?.startsWith('agent:openclaw-plugin:')
+                        ? memory.source.slice('agent:openclaw-plugin:'.length)
+                        : null;
+                if (!sessionId)
+                    continue;
+                const session = getSession(sessionId);
+                const createdAt = memory.createdAt.toISOString();
+                if (createdAt < session.firstSeenAt)
+                    session.firstSeenAt = createdAt;
+                if (createdAt > session.lastSeenAt)
+                    session.lastSeenAt = createdAt;
+                session.storedMemoryCount += 1;
+                session.memoryIds.add(memory.id);
+                if (typeof memory.metadata?.agentId === 'string')
+                    session.agentIds.add(memory.metadata.agentId);
+                if (memory.captureMethod === 'auto' || memory.captureMethod === 'plugin' || memory.captureMethod === 'hook') {
+                    session.autoExtracted += 1;
+                }
+                if (typeof memory.metadata?.trigger === 'string' || memory.tags.includes('keyword_trigger')) {
+                    session.keywordTriggered += 1;
+                }
+                if (memory.pinned)
+                    session.pinned += 1;
+                if (memory.status === 'suppressed')
+                    session.suppressed += 1;
+            }
+            if (existsSync(auditDir)) {
+                const files = readdirSync(auditDir)
+                    .filter((file) => /^realtime-\d{4}-\d{2}-\d{2}\.jsonl$/.test(file))
+                    .sort()
+                    .slice(-14);
+                for (const file of files) {
+                    const raw = readFileSync(join(auditDir, file), 'utf-8');
+                    for (const line of raw.split('\n')) {
+                        if (!line.trim())
+                            continue;
+                        try {
+                            const entry = JSON.parse(line);
+                            const sessionId = typeof entry.sessionId === 'string' ? entry.sessionId : null;
+                            if (!sessionId)
+                                continue;
+                            const session = getSession(sessionId);
+                            const ts = typeof entry.ts === 'string' ? entry.ts : new Date().toISOString();
+                            if (ts < session.firstSeenAt)
+                                session.firstSeenAt = ts;
+                            if (ts > session.lastSeenAt)
+                                session.lastSeenAt = ts;
+                            if (typeof entry.hook === 'string')
+                                session.hooks.add(entry.hook);
+                            if (typeof entry.model === 'string')
+                                session.models.add(entry.model);
+                            if (entry.type === 'memory') {
+                                const count = Number(entry.count ?? 0);
+                                const skipped = Number(entry.skipped ?? 0);
+                                session.loggedSaved += count;
+                                session.skipped += skipped;
+                                session.events.push({
+                                    ts,
+                                    type: 'memory',
+                                    hook: typeof entry.hook === 'string' ? entry.hook : undefined,
+                                    model: typeof entry.model === 'string' ? entry.model : undefined,
+                                    preview: typeof entry.preview === 'string' ? entry.preview : undefined,
+                                    count,
+                                    skipped,
+                                });
+                                if (typeof entry.preview === 'string' && session.previews.length < 6) {
+                                    session.previews.push(entry.preview);
+                                }
+                            }
+                            if (entry.type === 'threat') {
+                                session.threats += 1;
+                                const preview = typeof entry.preview === 'string' ? entry.preview : undefined;
+                                const lower = preview?.toLowerCase() ?? '';
+                                if (lower.includes('quarantine'))
+                                    session.quarantined += 1;
+                                if (lower.includes('block'))
+                                    session.blocked += 1;
+                                session.events.push({
+                                    ts,
+                                    type: lower.includes('quarantine') ? 'quarantine' : lower.includes('block') ? 'blocked' : 'threat',
+                                    hook: typeof entry.hook === 'string' ? entry.hook : undefined,
+                                    model: typeof entry.model === 'string' ? entry.model : undefined,
+                                    preview,
+                                });
+                                if (preview && session.previews.length < 6) {
+                                    session.previews.push(preview);
+                                }
+                            }
+                        }
+                        catch {
+                            // ignore malformed lines
+                        }
+                    }
+                }
+            }
+            const sessions = Array.from(sessionMap.values())
+                .map((session) => ({
+                sessionId: session.sessionId,
+                firstSeenAt: session.firstSeenAt,
+                lastSeenAt: session.lastSeenAt,
+                saved: Math.max(session.storedMemoryCount, session.loggedSaved),
+                skipped: session.skipped,
+                threats: session.threats,
+                blocked: session.blocked,
+                quarantined: session.quarantined,
+                autoExtracted: session.autoExtracted,
+                keywordTriggered: session.keywordTriggered,
+                pinned: session.pinned,
+                suppressed: session.suppressed,
+                hooks: Array.from(session.hooks),
+                models: Array.from(session.models),
+                agentIds: Array.from(session.agentIds),
+                previews: session.previews,
+                events: session.events
+                    .sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())
+                    .slice(0, 24),
+                memories: openClawMemories
+                    .filter((memory) => session.memoryIds.has(memory.id))
+                    .sort((a, b) => new Date(b.updatedAt ?? b.createdAt).getTime() - new Date(a.updatedAt ?? a.createdAt).getTime())
+                    .slice(0, 12),
+            }))
+                .sort((a, b) => new Date(b.lastSeenAt).getTime() - new Date(a.lastSeenAt).getTime())
+                .slice(0, limit);
+            const summary = {
+                sessions: sessions.length,
+                saved: sessions.reduce((sum, session) => sum + session.saved, 0),
+                skipped: sessions.reduce((sum, session) => sum + session.skipped, 0),
+                threats: sessions.reduce((sum, session) => sum + session.threats, 0),
+            };
+            res.json({ summary, sessions });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
     app.get('/api/memories', requireNotLocked, async (req, res) => {
         try {
             const project = typeof req.query.project === 'string' ? req.query.project : undefined;
@@ -110,11 +292,127 @@ export function registerMemoryRoutes(app, requireNotLocked) {
         JOIN memories m2 ON m1.title = m2.title AND m1.id < m2.id
         ${project ? 'WHERE m1.project = ?' : ''}
         LIMIT 50
+      `).all(...params);
+            const lowTrust = db.prepare(`
+        SELECT id, title, category, project, trust_score, source_kind, capture_method
+        FROM memories WHERE trust_score < 0.7 ${projectFilter}
+        ORDER BY trust_score ASC, updated_at DESC LIMIT 50
+      `).all(...params);
+            const noisyAutoExtracted = db.prepare(`
+        SELECT id, title, category, project, source_kind, capture_method, tags, trust_score
+        FROM memories
+        WHERE (capture_method = 'auto' OR tags LIKE '%auto-extracted%') ${projectFilter}
+        ORDER BY updated_at DESC LIMIT 50
+      `).all(...params);
+            const projectless = db.prepare(`
+        SELECT id, title, category, scope, source_kind, capture_method
+        FROM memories
+        WHERE (project IS NULL OR project = '') AND scope != 'global'
+        ORDER BY updated_at DESC LIMIT 50
+      `).all();
+            const statusCounts = db.prepare(`
+        SELECT status, COUNT(*) as count
+        FROM memories
+        ${project ? 'WHERE project = ?' : ''}
+        GROUP BY status
       `).all(...params);
             res.json({
                 neverAccessed: { count: neverAccessed.length, items: neverAccessed },
                 stale: { count: stale.length, items: stale },
                 duplicates: { count: duplicates.length, items: duplicates },
+                lowTrust: { count: lowTrust.length, items: lowTrust },
+                noisyAutoExtracted: { count: noisyAutoExtracted.length, items: noisyAutoExtracted },
+                projectless: { count: projectless.length, items: projectless },
+                status: statusCounts.reduce((acc, row) => {
+                    acc[row.status] = row.count;
+                    return acc;
+                }, {}),
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/review/queue', requireNotLocked, (req, res) => {
+        try {
+            const project = typeof req.query.project === 'string' ? req.query.project : undefined;
+            const limit = Math.min(parseInt(req.query.limit, 10) || 20, 100);
+            const db = getDatabase();
+            const projectFilter = project ? 'AND project = ?' : '';
+            const params = project ? [project] : [];
+            const stale = db.prepare(`
+        SELECT * FROM memories
+        WHERE decayed_score < 0.3 ${projectFilter}
+        AND last_accessed < datetime('now', '-30 days')
+        ORDER BY decayed_score ASC LIMIT ?
+      `).all(...params, limit);
+            const neverUsed = db.prepare(`
+        SELECT * FROM memories
+        WHERE access_count = 0 ${projectFilter}
+        AND created_at < datetime('now', '-1 day')
+        ORDER BY created_at DESC LIMIT ?
+      `).all(...params, limit);
+            const lowTrust = db.prepare(`
+        SELECT * FROM memories
+        WHERE trust_score < 0.7 ${projectFilter}
+        ORDER BY trust_score ASC, updated_at DESC LIMIT ?
+      `).all(...params, limit);
+            const noisyAutoExtracted = db.prepare(`
+        SELECT * FROM memories
+        WHERE (capture_method = 'auto' OR tags LIKE '%auto-extracted%') ${projectFilter}
+        ORDER BY updated_at DESC LIMIT ?
+      `).all(...params, limit);
+            const projectless = db.prepare(`
+        SELECT * FROM memories
+        WHERE (project IS NULL OR project = '') AND scope != 'global'
+        ORDER BY updated_at DESC LIMIT ?
+      `).all(limit);
+            const openClawSummary = db.prepare(`
+        SELECT
+          COUNT(*) as total,
+          SUM(CASE WHEN capture_method = 'auto' THEN 1 ELSE 0 END) as auto_count,
+          SUM(CASE WHEN tags LIKE '%keyword-trigger%' THEN 1 ELSE 0 END) as keyword_count,
+          SUM(CASE WHEN status = 'suppressed' THEN 1 ELSE 0 END) as suppressed_count,
+          SUM(CASE WHEN pinned = 1 THEN 1 ELSE 0 END) as pinned_count
+        FROM memories
+        WHERE (source_kind IN ('hook', 'plugin') OR tags LIKE '%openclaw%')
+        ${project ? 'AND project = ?' : ''}
+      `).get(...params);
+            const contradictions = detectContradictions({
+                project,
+                minScore: 0.4,
+                limit,
+            });
+            res.json({
+                summary: {
+                    stale: stale.length,
+                    neverUsed: neverUsed.length,
+                    lowTrust: lowTrust.length,
+                    noisyAutoExtracted: noisyAutoExtracted.length,
+                    projectless: projectless.length,
+                    contradictions: contradictions.length,
+                },
+                openClaw: {
+                    total: openClawSummary.total ?? 0,
+                    autoExtracted: openClawSummary.auto_count ?? 0,
+                    keywordTriggered: openClawSummary.keyword_count ?? 0,
+                    suppressed: openClawSummary.suppressed_count ?? 0,
+                    pinned: openClawSummary.pinned_count ?? 0,
+                },
+                sections: {
+                    stale: stale.map(rowToMemory),
+                    neverUsed: neverUsed.map(rowToMemory),
+                    lowTrust: lowTrust.map(rowToMemory),
+                    noisyAutoExtracted: noisyAutoExtracted.map(rowToMemory),
+                    projectless: projectless.map(rowToMemory),
+                    contradictions: contradictions.map((item) => ({
+                        memoryA: item.memoryA,
+                        memoryB: item.memoryB,
+                        score: item.score,
+                        reason: item.reason,
+                        sharedTopics: item.sharedTopics,
+                    })),
+                },
             });
         }
         catch (error) {
@@ -585,7 +883,7 @@ export function registerMemoryRoutes(app, requireNotLocked) {
     app.patch('/api/memories/:id', requireNotLocked, (req, res) => {
         try {
             const id = parseInt(req.params.id, 10);
-            const { title, content, category, tags, importance } = req.body;
+            const { title, content, category, tags, importance, status, pinned, reviewedBy, cloudExcluded, scope, project } = req.body;
             if (title !== undefined && (typeof title !== 'string' || title.trim().length === 0)) {
                 return res.status(400).json({ error: 'Title must be a non-empty string' });
             }
@@ -602,6 +900,24 @@ export function registerMemoryRoutes(app, requireNotLocked) {
             if (importance !== undefined && (typeof importance !== 'number' || importance < 0 || importance > 1)) {
                 return res.status(400).json({ error: 'Importance must be a number between 0 and 1' });
             }
+            if (status !== undefined && !['active', 'archived', 'suppressed', 'canonical'].includes(status)) {
+                return res.status(400).json({ error: 'Invalid review status' });
+            }
+            if (pinned !== undefined && typeof pinned !== 'boolean') {
+                return res.status(400).json({ error: 'Pinned must be boolean' });
+            }
+            if (cloudExcluded !== undefined && typeof cloudExcluded !== 'boolean') {
+                return res.status(400).json({ error: 'cloudExcluded must be boolean' });
+            }
+            if (reviewedBy !== undefined && reviewedBy !== null && typeof reviewedBy !== 'string') {
+                return res.status(400).json({ error: 'reviewedBy must be string or null' });
+            }
+            if (scope !== undefined && !['project', 'global'].includes(scope)) {
+                return res.status(400).json({ error: 'scope must be project or global' });
+            }
+            if (project !== undefined && project !== null && typeof project !== 'string') {
+                return res.status(400).json({ error: 'project must be string or null' });
+            }
             const updates = {};
             if (title !== undefined)
                 updates.title = title.trim();
@@ -613,6 +929,55 @@ export function registerMemoryRoutes(app, requireNotLocked) {
                 updates.tags = tags;
             if (importance !== undefined)
                 updates.salience = importance;
+            if (status !== undefined)
+                updates.status = status;
+            if (pinned !== undefined)
+                updates.pinned = pinned;
+            if (reviewedBy !== undefined)
+                updates.reviewedBy = reviewedBy;
+            if (cloudExcluded !== undefined)
+                updates.cloudExcluded = cloudExcluded;
+            if (scope !== undefined)
+                updates.scope = scope;
+            if (project !== undefined)
+                updates.project = project;
+            const updated = updateMemory(id, updates);
+            if (!updated) {
+                return res.status(404).json({ error: 'Memory not found' });
+            }
+            res.json(updated);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.patch('/api/memories/:id/review', requireNotLocked, (req, res) => {
+        try {
+            const id = parseInt(req.params.id, 10);
+            const { action, reviewedBy, project, scope } = req.body;
+            if (Number.isNaN(id)) {
+                return res.status(400).json({ error: 'Invalid memory ID' });
+            }
+            const reviewActor = typeof reviewedBy === 'string' && reviewedBy.trim() ? reviewedBy.trim() : 'dashboard';
+            const actionMap = {
+                archive: { status: 'archived', reviewedBy: reviewActor },
+                suppress: { status: 'suppressed', reviewedBy: reviewActor },
+                restore: { status: 'active', reviewedBy: reviewActor },
+                pin: { pinned: true, reviewedBy: reviewActor },
+                unpin: { pinned: false, reviewedBy: reviewActor },
+                canonicalize: { status: 'canonical', pinned: true, reviewedBy: reviewActor },
+                excludeCloud: { cloudExcluded: true, reviewedBy: reviewActor },
+                includeCloud: { cloudExcluded: false, reviewedBy: reviewActor },
+                rescopeProject: { scope: 'project', project: project ?? null, reviewedBy: reviewActor },
+                rescopeGlobal: { scope: 'global', project: null, reviewedBy: reviewActor },
+            };
+            if (!action || !actionMap[action]) {
+                return res.status(400).json({ error: 'Unsupported review action' });
+            }
+            const updates = {
+                ...actionMap[action],
+                ...(scope ? { scope } : {}),
+            };
             const updated = updateMemory(id, updates);
             if (!updated) {
                 return res.status(404).json({ error: 'Memory not found' });

package/dist/api/routes/recall.js

@@ -1,4 +1,5 @@
 import { searchMemoriesExplained } from '../../memory/store.js';
+import { getMemoryById, getRecentMemories } from '../../memory/store.js';
 export function registerRecallRoutes(app, requireNotLocked) {
     app.get('/api/recall/explain', requireNotLocked, async (req, res) => {
         try {
@@ -12,6 +13,9 @@ export function registerRecallRoutes(app, requireNotLocked) {
             const limit = Math.min(parseInt(req.query.limit, 10) || 10, 50);
             const includeDecayed = req.query.includeDecayed === 'true';
             const includeGlobal = req.query.includeGlobal !== 'false';
+            const includeArchived = req.query.includeArchived === 'true';
+            const includeSuppressed = req.query.includeSuppressed === 'true';
+            const expectedId = typeof req.query.expectedId === 'string' ? parseInt(req.query.expectedId, 10) : null;
             const results = await searchMemoriesExplained({
                 query,
                 project,
@@ -20,13 +24,62 @@ export function registerRecallRoutes(app, requireNotLocked) {
                 limit,
                 includeDecayed,
                 includeGlobal,
+                includeArchived,
+                includeSuppressed,
             });
+            let expectedMemory = null;
+            if (expectedId && Number.isFinite(expectedId)) {
+                const memory = getMemoryById(expectedId);
+                if (memory) {
+                    const foundIndex = results.findIndex((result) => result.memory.id === expectedId);
+                    expectedMemory = {
+                        id: memory.id,
+                        title: memory.title,
+                        status: memory.status,
+                        pinned: memory.pinned,
+                        cloudExcluded: memory.cloudExcluded,
+                        trustScore: memory.trustScore,
+                        captureMethod: memory.captureMethod,
+                        sourceKind: memory.sourceKind,
+                        rank: foundIndex >= 0 ? foundIndex + 1 : null,
+                        eligible: memory.status !== 'archived' && memory.status !== 'suppressed',
+                        reasons: [
+                            ...(memory.status === 'archived' ? ['Archived memories are excluded from normal recall'] : []),
+                            ...(memory.status === 'suppressed' ? ['Suppressed memories are excluded from normal recall'] : []),
+                            ...(memory.trustScore < 0.7 ? [`Low trust source (${memory.trustScore.toFixed(2)})`] : []),
+                            ...(memory.cloudExcluded ? ['Excluded from cloud sync'] : []),
+                            ...(foundIndex === -1 ? ['Did not rank in the current result window'] : []),
+                        ],
+                    };
+                }
+            }
+            const misses = getRecentMemories(200, project).filter((memory) => {
+                if (results.some((result) => result.memory.id === memory.id))
+                    return false;
+                if (memory.status === 'archived' || memory.status === 'suppressed')
+                    return false;
+                return memory.salience >= 0.65 || memory.pinned;
+            }).slice(0, 5).map((memory) => ({
+                id: memory.id,
+                title: memory.title,
+                status: memory.status,
+                salience: memory.salience,
+                captureMethod: memory.captureMethod,
+                sourceKind: memory.sourceKind,
+                whyNotRecalled: [
+                    'Lower relevance for this query than the returned set',
+                    ...(memory.pinned ? ['Pinned memories are still query-sensitive, not guaranteed results'] : []),
+                    ...(memory.trustScore < 0.7 ? [`Low trust source (${memory.trustScore.toFixed(2)})`] : []),
+                ],
+            }));
             res.json({
                 query,
                 project: project ?? null,
                 total: results.length,
                 sideEffects: 'disabled',
                 results,
+                expectedMemory,
+                misses,
             });
         }
         catch (error) {

package/dist/cloud/graph-sync.js

@@ -19,13 +19,15 @@ function tripleExternalId(id) {
 }
 function getAllowedMemoryExternalIds() {
     const db = getDatabase();
-    const rows = db.prepare('SELECT uuid, project, sensitivity_level FROM memories').all();
+    const rows = db.prepare('SELECT uuid, project, sensitivity_level, cloud_excluded FROM memories').all();
     return buildAllowedMemoryExternalIdSet(rows);
 }
 function buildAllowedMemoryExternalIdSet(rows) {
     const controls = getCloudSyncControls();
     return new Set(rows
         .filter((row) => {
+        if (row.cloud_excluded)
+            return false;
         if (!shouldSyncProject(row.project, controls))
             return false;
         if (controls.excludeSensitive && isSensitiveLevel(row.sensitivity_level))
@@ -114,11 +116,12 @@ function mapMemoryEntityRow(row) {
 }
 function getMemoryScopedEnvelope(memoryId) {
     const db = getDatabase();
-    const memory = db.prepare('SELECT id, uuid, project, sensitivity_level FROM memories WHERE id = ?').get(memoryId);
+    const memory = db.prepare('SELECT id, uuid, project, sensitivity_level, cloud_excluded FROM memories WHERE id = ?').get(memoryId);
     if (!memory)
         return null;
     const controls = getCloudSyncControls();
-    const memoryAllowed = shouldSyncProject(memory.project, controls) &&
+    const memoryAllowed = !memory.cloud_excluded &&
+        shouldSyncProject(memory.project, controls) &&
         !(controls.excludeSensitive && isSensitiveLevel(memory.sensitivity_level));
     if (!memoryAllowed) {
         return buildEnvelope([], [], [], [memory.uuid]);

package/dist/cloud/memory-sync.d.ts

@@ -15,6 +15,7 @@ export interface SyncedMemoryRecord {
     sensitivity_level: string | null;
     source: string | null;
     metadata: Record<string, unknown>;
+    cloud_excluded?: boolean;
     created_at: string;
     updated_at: string;
     deleted_at?: string | null;

package/dist/cloud/memory-sync.js

@@ -28,6 +28,7 @@ function rowToSyncRecord(row) {
         sensitivity_level: row.sensitivity_level ?? null,
         source: row.source ?? null,
         metadata: safeJsonParse(row.metadata, {}),
+        cloud_excluded: Boolean(row.cloud_excluded),
         created_at: new Date(row.created_at ?? Date.now()).toISOString(),
         updated_at: new Date(row.updated_at ?? row.created_at ?? Date.now()).toISOString(),
         deleted_at: null,
@@ -44,6 +45,8 @@ function buildEnvelope(records) {
     };
 }
 function shouldSyncRecord(record) {
+    if (record.cloud_excluded)
+        return false;
     const controls = getCloudSyncControls();
     if (!shouldSyncProject(record.project, controls))
         return false;

package/dist/database/init.js

@@ -261,6 +261,27 @@ function runMigrations(database) {
     if (!columnNames.has('source')) {
         database.exec("ALTER TABLE memories ADD COLUMN source TEXT DEFAULT 'user:direct'");
     }
+    if (!columnNames.has('status')) {
+        database.exec("ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'");
+    }
+    if (!columnNames.has('pinned')) {
+        database.exec('ALTER TABLE memories ADD COLUMN pinned INTEGER DEFAULT 0');
+    }
+    if (!columnNames.has('reviewed_at')) {
+        database.exec('ALTER TABLE memories ADD COLUMN reviewed_at TIMESTAMP');
+    }
+    if (!columnNames.has('reviewed_by')) {
+        database.exec('ALTER TABLE memories ADD COLUMN reviewed_by TEXT');
+    }
+    if (!columnNames.has('source_kind')) {
+        database.exec("ALTER TABLE memories ADD COLUMN source_kind TEXT DEFAULT 'user'");
+    }
+    if (!columnNames.has('capture_method')) {
+        database.exec("ALTER TABLE memories ADD COLUMN capture_method TEXT DEFAULT 'manual'");
+    }
+    if (!columnNames.has('cloud_excluded')) {
+        database.exec('ALTER TABLE memories ADD COLUMN cloud_excluded INTEGER DEFAULT 0');
+    }
     if (!columnNames.has('uuid')) {
         database.exec("ALTER TABLE memories ADD COLUMN uuid TEXT");
     }
@@ -274,8 +295,16 @@ function runMigrations(database) {
             setUuid.run(randomUUID(), row.id);
         }
         database.exec('UPDATE memories SET updated_at = COALESCE(updated_at, created_at, CURRENT_TIMESTAMP) WHERE updated_at IS NULL');
+        database.exec("UPDATE memories SET status = COALESCE(status, 'active') WHERE status IS NULL OR status = ''");
+        database.exec('UPDATE memories SET pinned = COALESCE(pinned, 0) WHERE pinned IS NULL');
+        database.exec("UPDATE memories SET source_kind = CASE WHEN source LIKE 'hook:%' THEN 'hook' WHEN source LIKE 'api:%' THEN 'api' WHEN source LIKE 'agent:%' THEN 'agent' WHEN source LIKE 'cli:%' THEN 'cli' ELSE COALESCE(source_kind, 'user') END WHERE source_kind IS NULL OR source_kind = ''");
+        database.exec("UPDATE memories SET capture_method = CASE WHEN tags LIKE '%auto-extracted%' THEN 'auto' WHEN source_kind = 'hook' THEN 'hook' WHEN source_kind = 'api' THEN 'api' WHEN source_kind = 'agent' THEN 'plugin' WHEN source_kind = 'cli' THEN 'manual' ELSE COALESCE(capture_method, 'manual') END WHERE capture_method IS NULL OR capture_method = ''");
+        database.exec('UPDATE memories SET cloud_excluded = COALESCE(cloud_excluded, 0) WHERE cloud_excluded IS NULL');
         database.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_uuid ON memories(uuid)');
         database.exec('CREATE INDEX IF NOT EXISTS idx_memories_updated ON memories(updated_at DESC)');
+        database.exec('CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)');
+        database.exec('CREATE INDEX IF NOT EXISTS idx_memories_pinned ON memories(pinned DESC)');
+        database.exec('CREATE INDEX IF NOT EXISTS idx_memories_source_kind ON memories(source_kind)');
     }
     catch {
         // Safe to ignore on partially migrated databases

package/dist/memory/search.d.ts

@@ -23,6 +23,7 @@ export interface SearchScoreValues {
     linkBoost: number;
     tagBoost: number;
     activationBoost: number;
+    contradictionPenalty: number;
     finalScore: number;
 }
 export type MemoryRowConverter = (row: Record<string, unknown>) => Memory;

package/dist/memory/search.js

@@ -118,6 +118,9 @@ export function buildSearchExplanation(memory, context, values) {
     if (values.activationBoost > 0) {
         reasons.push('Activated by recent recall activity');
     }
+    if (values.contradictionPenalty > 0) {
+        reasons.push('Contradiction risk reduced its rank');
+    }
     if (reasons.length === 0) {
         reasons.push('Ranked by salience and base recall heuristics');
     }
@@ -135,6 +138,7 @@ export function buildSearchExplanation(memory, context, values) {
             linkBoost: values.linkBoost,
             tagBoost: values.tagBoost,
             activationBoost: values.activationBoost,
+            contradictionPenalty: values.contradictionPenalty,
             finalScore: values.finalScore,
             matchedTags,
             matchedCategory: values.categoryBoost > 0 ? context.detectedCategory : null,