shieldcortex 3.0.4 → 3.2.0

package/dist/memory/store.js

@@ -4,6 +4,7 @@
  * Core CRUD operations for the memory database.
  * Handles storage, retrieval, and management of memories.
  */
+import { randomUUID } from 'crypto';
 import { getDatabase, isDatabaseInitialized } from '../database/init.js';
 import { DEFAULT_CONFIG, } from './types.js';
 import { calculateSalience, suggestCategory, extractTags, } from './salience.js';
@@ -14,9 +15,11 @@ import { emitMemoryCreated, emitMemoryAccessed, emitMemoryDeleted, emitMemoryUpd
 import { generateEmbedding, cosineSimilarity } from '../embeddings/index.js';
 import { isPaused } from '../api/control.js';
 import { extractFromMemory } from '../graph/extract.js';
-import { processExtractionResult } from '../graph/resolve.js';
+import { processExtractionResult, removeMemoryGraph, replaceMemoryGraph } from '../graph/resolve.js';
 import { runDefencePipeline, storeFragmentationData } from '../defence/index.js';
 import { syncQuarantineToCloud } from '../cloud/quarantine-sync.js';
+import { syncGraphDeleteForMemoryToCloud, syncGraphForMemoryToCloud } from '../cloud/graph-sync.js';
+import { syncMemoryDeleteToCloud, syncMemoryUpsertToCloud } from '../cloud/memory-sync.js';
 import { isFeatureEnabled } from '../license/gate.js';
 import { checkAccess } from '../defence/trust/access-control.js';
 import { scoreSource } from '../defence/trust/source-scorer.js';
@@ -119,12 +122,39 @@ function safeJsonParse(value, fallback) {
         return fallback;
     }
 }
+function inferSourceDetails(input, source) {
+    const tags = (input.tags ?? []).map((tag) => tag.toLowerCase());
+    if (tags.includes('openclaw-hook')) {
+        return { sourceKind: 'hook', captureMethod: tags.includes('auto-extracted') ? 'auto' : 'hook', sourceValue: 'hook:openclaw' };
+    }
+    if (tags.includes('realtime-plugin') || tags.includes('llm-output')) {
+        return { sourceKind: 'plugin', captureMethod: tags.includes('auto-extracted') ? 'auto' : 'plugin', sourceValue: 'agent:openclaw-plugin' };
+    }
+    if (source?.type === 'hook') {
+        return { sourceKind: 'hook', captureMethod: 'hook', sourceValue: `${source.type}:${source.identifier}` };
+    }
+    if (source?.type === 'agent') {
+        return { sourceKind: 'agent', captureMethod: 'plugin', sourceValue: `${source.type}:${source.identifier}` };
+    }
+    if (source?.type === 'api') {
+        return { sourceKind: 'api', captureMethod: 'api', sourceValue: `${source.type}:${source.identifier}` };
+    }
+    if (source?.type === 'cli') {
+        return { sourceKind: 'cli', captureMethod: 'manual', sourceValue: `${source.type}:${source.identifier}` };
+    }
+    return {
+        sourceKind: input.sourceKind ?? 'user',
+        captureMethod: input.captureMethod ?? (tags.includes('auto-extracted') ? 'auto' : 'manual'),
+        sourceValue: input.source ?? (source ? `${source.type}:${source.identifier}` : 'user:direct'),
+    };
+}
 /**
  * Convert database row to Memory object
  */
 export function rowToMemory(row) {
     return {
         id: row.id,
+        uuid: row.uuid,
         type: row.type,
         category: row.category,
         title: row.title,
@@ -135,11 +165,22 @@ export function rowToMemory(row) {
         accessCount: row.access_count,
         lastAccessed: new Date(row.last_accessed),
         createdAt: new Date(row.created_at),
+        updatedAt: new Date(row.updated_at ?? row.created_at),
         decayedScore: row.decayed_score ?? row.salience,
         metadata: safeJsonParse(row.metadata, {}),
         embedding: row.embedding,
         scope: row.scope ?? 'project',
         transferable: Boolean(row.transferable),
+        status: (row.status ?? 'active'),
+        pinned: Boolean(row.pinned),
+        reviewedAt: row.reviewed_at ? new Date(row.reviewed_at) : null,
+        reviewedBy: row.reviewed_by ?? null,
+        sourceKind: (row.source_kind ?? 'user'),
+        captureMethod: (row.capture_method ?? 'manual'),
+        trustScore: Number(row.trust_score ?? 1),
+        sensitivityLevel: row.sensitivity_level ?? 'INTERNAL',
+        source: row.source ?? null,
+        cloudExcluded: Boolean(row.cloud_excluded),
     };
 }
 /**
@@ -352,9 +393,16 @@ export function addMemory(input, config = DEFAULT_CONFIG, source) {
     const scope = input.scope ??
         (detectGlobalPattern(input.content, category, tags) ? 'global' : 'project');
     const transferable = input.transferable ?? (scope === 'global' ? 1 : 0);
+    const sourceDetails = inferSourceDetails({ ...input, tags }, source);
+    const status = input.status ?? 'active';
+    const pinned = input.pinned ? 1 : 0;
+    const cloudExcluded = input.cloudExcluded ? 1 : 0;
     const stmt = db.prepare(`
-    INSERT INTO memories (type, category, title, content, project, tags, salience, metadata, scope, transferable)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO memories (
+      uuid, type, category, title, content, project, tags, salience, metadata, scope, transferable,
+      status, pinned, reviewed_at, reviewed_by, source_kind, capture_method, cloud_excluded, updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
   `);
     // Anti-bloat: Truncate content if too large
     const truncationResult = truncateContent(input.content);
@@ -366,10 +414,15 @@ export function addMemory(input, config = DEFAULT_CONFIG, source) {
     };
     // Transaction: INSERT + defence UPDATE must be atomic to prevent wrong trust scores
     const insertedId = db.transaction(() => {
-        const result = stmt.run(type, category, input.title, truncationResult.content, input.project || null, JSON.stringify(tags), salience, JSON.stringify(input.metadata || {}), scope, transferable);
+        const memoryUuid = randomUUID();
+        const result = stmt.run(memoryUuid, type, category, input.title, truncationResult.content, input.project || null, JSON.stringify(tags), salience, JSON.stringify(input.metadata || {}), scope, transferable, status, pinned, input.reviewedBy ? new Date().toISOString() : null, input.reviewedBy ?? null, sourceDetails.sourceKind, sourceDetails.captureMethod, cloudExcluded);
         if (defenceResult) {
             db.prepare(`UPDATE memories SET trust_score = ?, sensitivity_level = ?, source = ? WHERE id = ?`)
-                .run(defenceResult.trust.score, defenceResult.sensitivity.level, `${source.type}:${source.identifier}`, result.lastInsertRowid);
+                .run(defenceResult.trust.score, defenceResult.sensitivity.level, sourceDetails.sourceValue, result.lastInsertRowid);
+        }
+        else {
+            db.prepare(`UPDATE memories SET source = ?, trust_score = COALESCE(trust_score, ?), sensitivity_level = COALESCE(sensitivity_level, ?) WHERE id = ?`)
+                .run(sourceDetails.sourceValue, input.trustScore ?? 1.0, input.sensitivityLevel ?? 'INTERNAL', result.lastInsertRowid);
         }
         return result.lastInsertRowid;
     })();
@@ -380,6 +433,9 @@ export function addMemory(input, config = DEFAULT_CONFIG, source) {
     persistEvent('memory_created', { memory });
     // Webhook notification (fire-and-forget)
     dispatchWebhook('memory_created', { id: memory.id, title: memory.title, category: memory.category });
+    if (isFeatureEnabled('cloud_sync')) {
+        syncMemoryUpsertToCloud(memory);
+    }
     // ORGANIC FEATURE: Auto-link to related memories
     // This builds the knowledge graph automatically as memories are created
     try {
@@ -397,6 +453,9 @@ export function addMemory(input, config = DEFAULT_CONFIG, source) {
         const extraction = extractFromMemory(input.title, truncationResult.content, category);
         if (extraction.entities.length > 0) {
             processExtractionResult(extraction, memory.id);
+            if (isFeatureEnabled('cloud_sync')) {
+                syncGraphForMemoryToCloud(memory.id);
+            }
         }
     }
     catch (e) {
@@ -443,30 +502,32 @@ export function addMemory(input, config = DEFAULT_CONFIG, source) {
     });
     // Anti-bloat: Check if limits exceeded and trigger async cleanup
     // We use setImmediate to not block the insert response
-    setImmediate(() => {
-        try {
-            if (!isDatabaseInitialized()) {
-                return;
+    if (process.env.NODE_ENV !== 'test') {
+        setImmediate(() => {
+            try {
+                if (!isDatabaseInitialized()) {
+                    return;
+                }
+                const stats = getMemoryStats();
+                if (stats.shortTerm > config.maxShortTermMemories ||
+                    stats.longTerm > config.maxLongTermMemories) {
+                    // Import dynamically to avoid circular dependency
+                    import('./consolidate.js').then(({ enforceMemoryLimits }) => {
+                        if (typeof enforceMemoryLimits === 'function') {
+                            enforceMemoryLimits(config);
+                        }
+                    }).catch((e) => {
+                        // Log but don't fail - consolidation will happen on next scheduled run
+                        console.warn('[shieldcortex] Async cleanup import failed:', e instanceof Error ? e.message : e);
+                    });
+                }
             }
-            const stats = getMemoryStats();
-            if (stats.shortTerm > config.maxShortTermMemories ||
-                stats.longTerm > config.maxLongTermMemories) {
-                // Import dynamically to avoid circular dependency
-                import('./consolidate.js').then(({ enforceMemoryLimits }) => {
-                    if (typeof enforceMemoryLimits === 'function') {
-                        enforceMemoryLimits(config);
-                    }
-                }).catch((e) => {
-                    // Log but don't fail - consolidation will happen on next scheduled run
-                    console.warn('[shieldcortex] Async cleanup import failed:', e instanceof Error ? e.message : e);
-                });
+            catch (e) {
+                // Log unexpected errors in async cleanup
+                console.warn('[shieldcortex] Async cleanup check failed:', e instanceof Error ? e.message : e);
             }
-        }
-        catch (e) {
-            // Log unexpected errors in async cleanup
-            console.warn('[shieldcortex] Async cleanup check failed:', e instanceof Error ? e.message : e);
-        }
-    });
+        });
+    }
     return memory;
 }
 /**
@@ -529,15 +590,69 @@ export function updateMemory(id, updates) {
         fields.push('metadata = ?');
         values.push(JSON.stringify(updates.metadata));
     }
+    if (updates.status !== undefined) {
+        fields.push('status = ?');
+        values.push(updates.status);
+    }
+    if (updates.pinned !== undefined) {
+        fields.push('pinned = ?');
+        values.push(updates.pinned ? 1 : 0);
+    }
+    if (updates.reviewedBy !== undefined) {
+        fields.push('reviewed_by = ?');
+        values.push(updates.reviewedBy);
+        fields.push('reviewed_at = ?');
+        values.push(updates.reviewedBy ? new Date().toISOString() : null);
+    }
+    if (updates.sourceKind !== undefined) {
+        fields.push('source_kind = ?');
+        values.push(updates.sourceKind);
+    }
+    if (updates.captureMethod !== undefined) {
+        fields.push('capture_method = ?');
+        values.push(updates.captureMethod);
+    }
+    if (updates.trustScore !== undefined) {
+        fields.push('trust_score = ?');
+        values.push(updates.trustScore);
+    }
+    if (updates.sensitivityLevel !== undefined) {
+        fields.push('sensitivity_level = ?');
+        values.push(updates.sensitivityLevel);
+    }
+    if (updates.source !== undefined) {
+        fields.push('source = ?');
+        values.push(updates.source);
+    }
+    if (updates.cloudExcluded !== undefined) {
+        fields.push('cloud_excluded = ?');
+        values.push(updates.cloudExcluded ? 1 : 0);
+    }
     if (fields.length === 0)
         return existing;
     values.push(id);
-    db.prepare(`UPDATE memories SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+    db.prepare(`UPDATE memories SET ${fields.join(', ')}, updated_at = CURRENT_TIMESTAMP WHERE id = ?`).run(...values);
     const updatedMemory = getMemoryById(id);
+    const shouldRefreshGraph = updates.title !== undefined ||
+        updates.content !== undefined ||
+        updates.category !== undefined;
+    if (shouldRefreshGraph) {
+        try {
+            const extraction = extractFromMemory(updatedMemory.title, updatedMemory.content, updatedMemory.category);
+            replaceMemoryGraph(updatedMemory.id, extraction);
+        }
+        catch (e) {
+            console.error('[shieldcortex] Entity extraction refresh failed:', e);
+        }
+    }
     // Emit event for real-time dashboard (in-process)
     emitMemoryUpdated(updatedMemory);
     // Persist event for cross-process IPC (MCP → Dashboard)
     persistEvent('memory_updated', { memory: updatedMemory });
+    if (isFeatureEnabled('cloud_sync')) {
+        syncMemoryUpsertToCloud(updatedMemory);
+        syncGraphForMemoryToCloud(updatedMemory.id);
+    }
     return updatedMemory;
 }
 /**
@@ -558,9 +673,21 @@ export function deleteMemory(id, source) {
     }
     // Get memory before deletion for event
     const memory = getMemoryById(id);
+    if (memory) {
+        try {
+            removeMemoryGraph(id);
+        }
+        catch (e) {
+            console.error('[shieldcortex] Graph cleanup before delete failed:', e);
+        }
+    }
     const result = db.prepare('DELETE FROM memories WHERE id = ?').run(id);
     // Emit event for real-time dashboard (in-process)
     if (result.changes > 0 && memory) {
+        if (isFeatureEnabled('cloud_sync')) {
+            syncMemoryDeleteToCloud(memory);
+            syncGraphDeleteForMemoryToCloud(memory);
+        }
         emitMemoryDeleted(id, memory.title);
         // Persist event for cross-process IPC (MCP → Dashboard)
         persistEvent('memory_deleted', { memoryId: id, title: memory.title });
@@ -837,6 +964,12 @@ async function searchMemoriesInternal(options, config, source, execution) {
         sql += ' AND m.type = ?';
         params.push(options.type);
     }
+    if (!options.includeArchived) {
+        sql += ` AND m.status != 'archived'`;
+    }
+    if (!options.includeSuppressed) {
+        sql += ` AND m.status != 'suppressed'`;
+    }
     if (options.minSalience) {
         sql += ' AND m.salience >= ?';
         params.push(options.minSalience);
@@ -875,12 +1008,33 @@ async function searchMemoriesInternal(options, config, source, execution) {
         const vectorSimilarity = vectorResults.get(memory.id) || 0;
         const vectorBoost = vectorSimilarity * 0.3;
         const priorityBoost = calculatePriority(memory) * 0.05;
+        const contradictionCount = db.prepare(`SELECT COUNT(*) as count FROM memory_links WHERE relationship = 'contradicts' AND (source_id = ? OR target_id = ?)`).get(memory.id, memory.id).count;
+        const contradictionPenalty = Math.min(0.12, contradictionCount * 0.03);
+        const eligibilityReasons = [];
+        if (memory.status === 'archived')
+            eligibilityReasons.push('Archived memories are excluded from normal recall');
+        if (memory.status === 'suppressed')
+            eligibilityReasons.push('Suppressed memories are excluded from normal recall');
+        if (memory.cloudExcluded)
+            eligibilityReasons.push('Excluded from cloud sync');
+        if (memory.trustScore < 0.7)
+            eligibilityReasons.push(`Low trust source (${memory.trustScore.toFixed(2)})`);
+        if (contradictionCount > 0)
+            eligibilityReasons.push(`${contradictionCount} contradiction link${contradictionCount === 1 ? '' : 's'} attached`);
         const relevanceScore = (ftsScore * 0.25 +
             vectorBoost +
             decayedScore * 0.2 +
             priorityBoost +
-            recencyBoost + categoryBoost + linkBoost + tagBoost + activationBoost);
-        const result = { memory, relevanceScore };
+            recencyBoost + categoryBoost + linkBoost + tagBoost + activationBoost -
+            contradictionPenalty);
+        const result = {
+            memory,
+            relevanceScore,
+            recallEligibility: {
+                eligible: eligibilityReasons.length === 0,
+                reasons: eligibilityReasons,
+            },
+        };
         if (execution.includeExplanation) {
             result.explanation = buildSearchExplanation(memory, scoringContext, {
                 ftsScore,
@@ -893,8 +1047,12 @@ async function searchMemoriesInternal(options, config, source, execution) {
                 linkBoost,
                 tagBoost,
                 activationBoost,
+                contradictionPenalty,
                 finalScore: relevanceScore,
             });
+            if (result.explanation) {
+                result.explanation.eligibility = result.recallEligibility;
+            }
         }
         return result;
     });

package/dist/memory/types.d.ts

@@ -2,9 +2,13 @@
  * Core type definitions for the ShieldCortex memory system
  */
 export type MemoryType = 'short_term' | 'long_term' | 'episodic';
+export type MemoryStatus = 'active' | 'archived' | 'suppressed' | 'canonical';
+export type MemorySourceKind = 'user' | 'cli' | 'hook' | 'plugin' | 'agent' | 'import' | 'cloud' | 'api' | 'system';
+export type MemoryCaptureMethod = 'manual' | 'hook' | 'plugin' | 'import' | 'cloud' | 'api' | 'auto' | 'review';
 export type MemoryCategory = 'architecture' | 'pattern' | 'preference' | 'error' | 'context' | 'learning' | 'todo' | 'note' | 'relationship' | 'custom';
 export interface Memory {
     id: number;
+    uuid: string;
     type: MemoryType;
     category: MemoryCategory;
     title: string;
@@ -15,11 +19,22 @@ export interface Memory {
     accessCount: number;
     lastAccessed: Date;
     createdAt: Date;
+    updatedAt: Date;
     decayedScore: number;
     metadata: Record<string, unknown>;
     embedding?: Buffer;
     scope: 'project' | 'global';
     transferable: boolean;
+    status: MemoryStatus;
+    pinned: boolean;
+    reviewedAt: Date | null;
+    reviewedBy: string | null;
+    sourceKind: MemorySourceKind;
+    captureMethod: MemoryCaptureMethod;
+    trustScore: number;
+    sensitivityLevel: string;
+    source: string | null;
+    cloudExcluded: boolean;
 }
 export interface MemoryInput {
     type?: MemoryType;
@@ -32,6 +47,15 @@ export interface MemoryInput {
     metadata?: Record<string, unknown>;
     scope?: 'project' | 'global';
     transferable?: boolean;
+    status?: MemoryStatus;
+    pinned?: boolean;
+    reviewedBy?: string | null;
+    sourceKind?: MemorySourceKind;
+    captureMethod?: MemoryCaptureMethod;
+    trustScore?: number;
+    sensitivityLevel?: string;
+    source?: string | null;
+    cloudExcluded?: boolean;
 }
 export interface SearchOptions {
     query: string;
@@ -43,6 +67,8 @@ export interface SearchOptions {
     limit?: number;
     includeDecayed?: boolean;
     includeGlobal?: boolean;
+    includeArchived?: boolean;
+    includeSuppressed?: boolean;
 }
 export interface SearchResult {
     memory: Memory;
@@ -53,6 +79,7 @@ export interface SearchResult {
         score: number;
     }[];
     explanation?: SearchExplanation;
+    recallEligibility?: RecallEligibility;
 }
 export interface SearchScoreBreakdown {
     ftsScore: number;
@@ -65,14 +92,20 @@ export interface SearchScoreBreakdown {
     linkBoost: number;
     tagBoost: number;
     activationBoost: number;
+    contradictionPenalty: number;
     finalScore: number;
     matchedTags: string[];
     matchedCategory: string | null;
 }
+export interface RecallEligibility {
+    eligible: boolean;
+    reasons: string[];
+}
 export interface SearchExplanation {
     query: string;
     reasons: string[];
     breakdown: SearchScoreBreakdown;
+    eligibility?: RecallEligibility;
 }
 export interface ConsolidationResult {
     consolidated: number;

package/dist/service/install.d.ts

@@ -7,6 +7,7 @@
  *  - Windows: VBS script in Startup folder
  */
 export declare function installService(): Promise<void>;
+export declare function repairService(): Promise<void>;
 export declare function uninstallService(options?: {
     cleanLogs?: boolean;
 }): Promise<void>;

package/dist/service/install.js

@@ -31,6 +31,33 @@ function getServiceConfig() {
         logsDir,
     };
 }
+function inspectServiceEntryPoint(platform, servicePath) {
+    if (!fs.existsSync(servicePath)) {
+        return { entryPoint: null, stale: false };
+    }
+    try {
+        const content = fs.readFileSync(servicePath, 'utf-8');
+        let entryPoint = null;
+        if (platform === 'macos') {
+            const matches = [...content.matchAll(/<string>([^<]+)<\/string>/g)].map((match) => match[1]);
+            entryPoint = matches.find((value) => value.endsWith('index.js')) ?? null;
+        }
+        else if (platform === 'linux') {
+            const match = content.match(/ExecStart=\S+\s+(\S+index\.js)/);
+            entryPoint = match?.[1] ?? null;
+        }
+        else {
+            const match = content.match(/Run\s+\"\"[^\"]+\"\"\s+\"\"([^\"]+index\.js)\"\"/);
+            entryPoint = match?.[1] ?? null;
+        }
+        const currentEntryPoint = getServiceConfig().entryPoint;
+        const stale = !!entryPoint && (entryPoint.includes('/.npm/_npx/') || entryPoint !== currentEntryPoint);
+        return { entryPoint, stale };
+    }
+    catch {
+        return { entryPoint: null, stale: false };
+    }
+}
 function getServicePath(platform) {
     switch (platform) {
         case 'macos':
@@ -91,6 +118,10 @@ export async function installService() {
     console.log(`  API:       http://localhost:3001`);
     console.log(`  Dashboard: http://localhost:3030`);
 }
+export async function repairService() {
+    await uninstallService();
+    await installService();
+}
 function cleanLogsDirectory() {
     const logsDir = path.join(os.homedir(), '.shieldcortex', 'logs');
     if (fs.existsSync(logsDir)) {
@@ -131,9 +162,14 @@ export async function serviceStatus() {
     const platform = detectPlatform();
     const servicePath = getServicePath(platform);
     const installed = fs.existsSync(servicePath);
+    const inspection = inspectServiceEntryPoint(platform, servicePath);
     console.log(`Platform:  ${platform}`);
     console.log(`Installed: ${installed ? 'yes' : 'no'}`);
     console.log(`Path:      ${servicePath}`);
+    if (inspection.entryPoint) {
+        console.log(`Entry:     ${inspection.entryPoint}`);
+        console.log(`Healthy:   ${inspection.stale ? 'no (repair recommended)' : 'yes'}`);
+    }
     if (!installed)
         return;
     // Check if running
@@ -158,12 +194,18 @@ export async function serviceStatus() {
     catch {
         console.log('Running:   no');
     }
+    if (inspection.stale) {
+        console.log('Repair:    shieldcortex service repair');
+    }
 }
 export async function handleServiceCommand(subcommand) {
     switch (subcommand) {
         case 'install':
             await installService();
             break;
+        case 'repair':
+            await repairService();
+            break;
         case 'uninstall':
             await uninstallService({ cleanLogs: process.argv.includes('--clean-logs') });
             break;
@@ -171,7 +213,7 @@ export async function handleServiceCommand(subcommand) {
             await serviceStatus();
             break;
         default:
-            console.log('Usage: shieldcortex service <install|uninstall|status>');
+            console.log('Usage: shieldcortex service <install|repair|uninstall|status>');
             process.exit(1);
     }
 }

package/dist/tools/context.d.ts

@@ -15,23 +15,23 @@ export declare const getContextSchema: z.ZodObject<{
         type: z.ZodEnum<["user", "cli", "hook", "email", "web", "agent", "file", "api", "tool_response"]>;
         identifier: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        type: "api" | "user" | "cli" | "hook" | "email" | "web" | "agent" | "file" | "tool_response";
+        type: "user" | "cli" | "hook" | "agent" | "api" | "email" | "web" | "file" | "tool_response";
         identifier: string;
     }, {
-        type: "api" | "user" | "cli" | "hook" | "email" | "web" | "agent" | "file" | "tool_response";
+        type: "user" | "cli" | "hook" | "agent" | "api" | "email" | "web" | "file" | "tool_response";
         identifier: string;
     }>>;
 }, "strip", z.ZodTypeAny, {
     format: "summary" | "detailed" | "raw";
     source?: {
-        type: "api" | "user" | "cli" | "hook" | "email" | "web" | "agent" | "file" | "tool_response";
+        type: "user" | "cli" | "hook" | "agent" | "api" | "email" | "web" | "file" | "tool_response";
         identifier: string;
     } | undefined;
     project?: string | undefined;
     query?: string | undefined;
 }, {
     source?: {
-        type: "api" | "user" | "cli" | "hook" | "email" | "web" | "agent" | "file" | "tool_response";
+        type: "user" | "cli" | "hook" | "agent" | "api" | "email" | "web" | "file" | "tool_response";
         identifier: string;
     } | undefined;
     project?: string | undefined;

package/dist/tools/forget.d.ts

@@ -17,34 +17,34 @@ export declare const forgetSchema: z.ZodObject<{
         type: z.ZodEnum<["user", "cli", "hook", "email", "web", "agent", "file", "api", "tool_response"]>;
         identifier: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        type: "api" | "user" | "cli" | "hook" | "email" | "web" | "agent" | "file" | "tool_response";
+        type: "user" | "cli" | "hook" | "agent" | "api" | "email" | "web" | "file" | "tool_response";
         identifier: string;
     }, {
-        type: "api" | "user" | "cli" | "hook" | "email" | "web" | "agent" | "file" | "tool_response";
+        type: "user" | "cli" | "hook" | "agent" | "api" | "email" | "web" | "file" | "tool_response";
         identifier: string;
     }>>;
 }, "strip", z.ZodTypeAny, {
     dryRun: boolean;
     confirm: boolean;
     source?: {
-        type: "api" | "user" | "cli" | "hook" | "email" | "web" | "agent" | "file" | "tool_response";
+        type: "user" | "cli" | "hook" | "agent" | "api" | "email" | "web" | "file" | "tool_response";
         identifier: string;
     } | undefined;
     project?: string | undefined;
     id?: number | undefined;
-    query?: string | undefined;
     category?: "architecture" | "pattern" | "preference" | "error" | "context" | "learning" | "todo" | "note" | "relationship" | "custom" | undefined;
+    query?: string | undefined;
     olderThan?: number | undefined;
     belowSalience?: number | undefined;
 }, {
     source?: {
-        type: "api" | "user" | "cli" | "hook" | "email" | "web" | "agent" | "file" | "tool_response";
+        type: "user" | "cli" | "hook" | "agent" | "api" | "email" | "web" | "file" | "tool_response";
         identifier: string;
     } | undefined;
     project?: string | undefined;
     id?: number | undefined;
-    query?: string | undefined;
     category?: "architecture" | "pattern" | "preference" | "error" | "context" | "learning" | "todo" | "note" | "relationship" | "custom" | undefined;
+    query?: string | undefined;
     olderThan?: number | undefined;
     belowSalience?: number | undefined;
     dryRun?: boolean | undefined;