shieldcortex 3.0.3 → 3.1.0

package/dist/memory/search.js

@@ -0,0 +1,143 @@
+import { cosineSimilarity } from '../embeddings/index.js';
+export function detectQueryCategory(query) {
+    const lower = query.toLowerCase();
+    if (/architect|design|structure|pattern|system|schema|model/.test(lower)) {
+        return 'architecture';
+    }
+    if (/error|bug|fix|issue|crash|exception|fail|problem/.test(lower)) {
+        return 'error';
+    }
+    if (/prefer|always|never|style|convention|like|want/.test(lower)) {
+        return 'preference';
+    }
+    if (/learn|discover|realiz|found\s+out|turns?\s+out/.test(lower)) {
+        return 'learning';
+    }
+    if (/todo|task|pending|need\s+to|should\s+do/.test(lower)) {
+        return 'todo';
+    }
+    if (/relation|depend|connect|link|reference/.test(lower)) {
+        return 'relationship';
+    }
+    return null;
+}
+export function calculateLinkBoost(memoryId, db) {
+    try {
+        const linked = db.prepare(`
+      SELECT m.salience, ml.strength
+      FROM memory_links ml
+      JOIN memories m ON (m.id = ml.target_id OR m.id = ml.source_id)
+      WHERE (ml.source_id = ? OR ml.target_id = ?)
+        AND m.id != ?
+    `).all(memoryId, memoryId, memoryId);
+        if (linked.length === 0)
+            return 0;
+        const totalWeight = linked.reduce((sum, link) => sum + link.strength, 0);
+        if (totalWeight === 0)
+            return 0;
+        const weightedSalience = linked.reduce((sum, link) => sum + link.salience * link.strength, 0) / totalWeight;
+        return Math.min(0.15, weightedSalience * 0.2);
+    }
+    catch {
+        return 0;
+    }
+}
+export function calculateTagScore(queryTags, memoryTags) {
+    if (queryTags.length === 0 || memoryTags.length === 0)
+        return 0;
+    let matches = 0;
+    for (const queryTag of queryTags) {
+        const lowerQueryTag = queryTag.toLowerCase();
+        if (memoryTags.some((memoryTag) => {
+            const lowerMemoryTag = memoryTag.toLowerCase();
+            return lowerMemoryTag.includes(lowerQueryTag) || lowerQueryTag.includes(lowerMemoryTag);
+        })) {
+            matches++;
+        }
+    }
+    return (matches / queryTags.length) * 0.1;
+}
+export function extractQueryTags(query) {
+    const words = query.toLowerCase().split(/\s+/);
+    return words.filter((word) => word.length > 2 &&
+        /^[a-z][a-z0-9-]*$/.test(word) &&
+        !['the', 'and', 'for', 'with', 'how', 'what', 'when', 'where', 'why'].includes(word));
+}
+export function vectorSearch(db, rowToMemory, queryEmbedding, limit, project, includeGlobal = true) {
+    let query = `
+    SELECT * FROM memories
+    WHERE embedding IS NOT NULL
+  `;
+    const params = [];
+    if (project && includeGlobal) {
+        query += ` AND (project = ? OR scope = 'global')`;
+        params.push(project);
+    }
+    else if (project) {
+        query += ` AND project = ?`;
+        params.push(project);
+    }
+    const rows = db.prepare(query).all(...params);
+    return rows
+        .map((row) => {
+        const embeddingBuffer = row.embedding;
+        const embedding = new Float32Array(embeddingBuffer.buffer, embeddingBuffer.byteOffset, embeddingBuffer.length / 4);
+        return {
+            memory: rowToMemory(row),
+            similarity: cosineSimilarity(queryEmbedding, embedding),
+        };
+    })
+        .filter((result) => result.similarity > 0.3)
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, limit);
+}
+export function buildSearchExplanation(memory, context, values) {
+    const matchedTags = context.queryTags.filter((queryTag) => memory.tags.some((memoryTag) => {
+        const lowerMemoryTag = memoryTag.toLowerCase();
+        return lowerMemoryTag.includes(queryTag) || queryTag.includes(lowerMemoryTag);
+    }));
+    const reasons = [];
+    if (values.vectorSimilarity > 0) {
+        reasons.push(`Semantic similarity ${(values.vectorSimilarity * 100).toFixed(0)}%`);
+    }
+    if (values.ftsScore > 0.3) {
+        reasons.push('Strong keyword match');
+    }
+    if (values.categoryBoost > 0 && context.detectedCategory) {
+        reasons.push(`Matches ${context.detectedCategory} category intent`);
+    }
+    if (matchedTags.length > 0) {
+        reasons.push(`Shared tags: ${matchedTags.slice(0, 3).join(', ')}`);
+    }
+    if (values.recencyBoost > 0) {
+        reasons.push('Recently accessed');
+    }
+    if (values.linkBoost > 0) {
+        reasons.push('Connected to related memories');
+    }
+    if (values.activationBoost > 0) {
+        reasons.push('Activated by recent recall activity');
+    }
+    if (reasons.length === 0) {
+        reasons.push('Ranked by salience and base recall heuristics');
+    }
+    return {
+        query: context.query,
+        reasons,
+        breakdown: {
+            ftsScore: values.ftsScore,
+            vectorSimilarity: values.vectorSimilarity,
+            vectorBoost: values.vectorBoost,
+            decayedScore: values.decayedScore,
+            priorityBoost: values.priorityBoost,
+            recencyBoost: values.recencyBoost,
+            categoryBoost: values.categoryBoost,
+            linkBoost: values.linkBoost,
+            tagBoost: values.tagBoost,
+            activationBoost: values.activationBoost,
+            finalScore: values.finalScore,
+            matchedTags,
+            matchedCategory: values.categoryBoost > 0 ? context.detectedCategory : null,
+        },
+    };
+}

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,15 +15,18 @@ 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';
 import { logAudit } from '../defence/audit/logger.js';
 import { dispatchWebhook } from '../events/webhooks.js';
 import { getCachedQueryEmbedding, findSimilarMemories } from './embedding.js';
+import { buildSearchExplanation, calculateLinkBoost, calculateTagScore, detectQueryCategory, extractQueryTags, vectorSearch, } from './search.js';
 // Anti-bloat: Maximum content size per memory (10KB)
 const MAX_CONTENT_SIZE = 10 * 1024;
 // Track truncation info globally for the last addMemory call
@@ -124,6 +128,7 @@ function safeJsonParse(value, fallback) {
 export function rowToMemory(row) {
     return {
         id: row.id,
+        uuid: row.uuid,
         type: row.type,
         category: row.category,
         title: row.title,
@@ -134,6 +139,7 @@ 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,
@@ -352,8 +358,8 @@ export function addMemory(input, config = DEFAULT_CONFIG, source) {
         (detectGlobalPattern(input.content, category, tags) ? 'global' : 'project');
     const transferable = input.transferable ?? (scope === 'global' ? 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, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
   `);
     // Anti-bloat: Truncate content if too large
     const truncationResult = truncateContent(input.content);
@@ -365,7 +371,8 @@ 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);
         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);
@@ -379,6 +386,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 {
@@ -396,6 +406,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) {
@@ -531,12 +544,28 @@ export function updateMemory(id, updates) {
     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;
 }
 /**
@@ -557,9 +586,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 });
@@ -776,171 +817,6 @@ export function updateDecayScores() {
     }
     return updated;
 }
-/**
- * Detect the likely category a query is asking about
- */
-function detectQueryCategory(query) {
-    const lower = query.toLowerCase();
-    if (/architect|design|structure|pattern|system|schema|model/.test(lower)) {
-        return 'architecture';
-    }
-    if (/error|bug|fix|issue|crash|exception|fail|problem/.test(lower)) {
-        return 'error';
-    }
-    if (/prefer|always|never|style|convention|like|want/.test(lower)) {
-        return 'preference';
-    }
-    if (/learn|discover|realiz|found\s+out|turns?\s+out/.test(lower)) {
-        return 'learning';
-    }
-    if (/todo|task|pending|need\s+to|should\s+do/.test(lower)) {
-        return 'todo';
-    }
-    if (/relation|depend|connect|link|reference/.test(lower)) {
-        return 'relationship';
-    }
-    return null;
-}
-/**
- * Calculate a boost for memories linked to high-salience memories
- */
-function calculateLinkBoost(memoryId, db) {
-    try {
-        // Get linked memories and their salience
-        const linked = db.prepare(`
-      SELECT m.salience, ml.strength
-      FROM memory_links ml
-      JOIN memories m ON (m.id = ml.target_id OR m.id = ml.source_id)
-      WHERE (ml.source_id = ? OR ml.target_id = ?)
-        AND m.id != ?
-    `).all(memoryId, memoryId, memoryId);
-        if (linked.length === 0)
-            return 0;
-        // Calculate weighted average of linked memory salience
-        const totalWeight = linked.reduce((sum, l) => sum + l.strength, 0);
-        if (totalWeight === 0)
-            return 0;
-        const weightedSalience = linked.reduce((sum, l) => sum + l.salience * l.strength, 0) / totalWeight;
-        // Cap boost at 0.15
-        return Math.min(0.15, weightedSalience * 0.2);
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * Calculate partial tag match score
- */
-function calculateTagScore(queryTags, memoryTags) {
-    if (queryTags.length === 0 || memoryTags.length === 0)
-        return 0;
-    // Count partial matches (substring matching)
-    let matches = 0;
-    for (const qt of queryTags) {
-        const qtLower = qt.toLowerCase();
-        if (memoryTags.some(mt => mt.toLowerCase().includes(qtLower) || qtLower.includes(mt.toLowerCase()))) {
-            matches++;
-        }
-    }
-    return (matches / queryTags.length) * 0.1;
-}
-/**
- * Extract potential tags from a query string
- */
-function extractQueryTags(query) {
-    // Extract words that might be tags (tech terms, project-specific terms)
-    const words = query.toLowerCase().split(/\s+/);
-    return words.filter(w => w.length > 2 &&
-        /^[a-z][a-z0-9-]*$/.test(w) &&
-        !['the', 'and', 'for', 'with', 'how', 'what', 'when', 'where', 'why'].includes(w));
-}
-/**
- * Search memories by vector similarity
- * Returns memories sorted by cosine similarity to the query embedding
- */
-function vectorSearch(queryEmbedding, limit, project, includeGlobal = true) {
-    const db = getDatabase();
-    // Get memories with embeddings
-    let query = `
-    SELECT * FROM memories
-    WHERE embedding IS NOT NULL
-  `;
-    const params = [];
-    if (project && includeGlobal) {
-        query += ` AND (project = ? OR scope = 'global')`;
-        params.push(project);
-    }
-    else if (project) {
-        query += ` AND project = ?`;
-        params.push(project);
-    }
-    const rows = db.prepare(query).all(...params);
-    // Calculate similarities
-    const results = rows
-        .map(row => {
-        const embeddingBuffer = row.embedding;
-        const embedding = new Float32Array(embeddingBuffer.buffer, embeddingBuffer.byteOffset, embeddingBuffer.length / 4);
-        const similarity = cosineSimilarity(queryEmbedding, embedding);
-        return {
-            memory: rowToMemory(row),
-            similarity,
-        };
-    })
-        .filter(r => r.similarity > 0.3) // Threshold for relevance
-        .sort((a, b) => b.similarity - a.similarity)
-        .slice(0, limit);
-    return results;
-}
-function buildSearchExplanation(memory, context, values) {
-    const matchedTags = context.queryTags.filter((queryTag) => memory.tags.some((memoryTag) => {
-        const lowerMemoryTag = memoryTag.toLowerCase();
-        return lowerMemoryTag.includes(queryTag) || queryTag.includes(lowerMemoryTag);
-    }));
-    const reasons = [];
-    if (values.vectorSimilarity > 0) {
-        reasons.push(`Semantic similarity ${(values.vectorSimilarity * 100).toFixed(0)}%`);
-    }
-    if (values.ftsScore > 0.3) {
-        reasons.push('Strong keyword match');
-    }
-    if (values.categoryBoost > 0 && context.detectedCategory) {
-        reasons.push(`Matches ${context.detectedCategory} category intent`);
-    }
-    if (matchedTags.length > 0) {
-        reasons.push(`Shared tags: ${matchedTags.slice(0, 3).join(', ')}`);
-    }
-    if (values.recencyBoost > 0) {
-        reasons.push('Recently accessed');
-    }
-    if (values.linkBoost > 0) {
-        reasons.push('Connected to related memories');
-    }
-    if (values.activationBoost > 0) {
-        reasons.push('Activated by recent recall activity');
-    }
-    if (reasons.length === 0) {
-        reasons.push('Ranked by salience and base recall heuristics');
-    }
-    return {
-        query: context.query,
-        reasons,
-        breakdown: {
-            ftsScore: values.ftsScore,
-            vectorSimilarity: values.vectorSimilarity,
-            vectorBoost: values.vectorBoost,
-            decayedScore: values.decayedScore,
-            priorityBoost: values.priorityBoost,
-            recencyBoost: values.recencyBoost,
-            categoryBoost: values.categoryBoost,
-            linkBoost: values.linkBoost,
-            tagBoost: values.tagBoost,
-            activationBoost: values.activationBoost,
-            finalScore: values.finalScore,
-            matchedTags,
-            matchedCategory: values.categoryBoost > 0 ? context.detectedCategory : null,
-        },
-    };
-}
 async function searchMemoriesInternal(options, config, source, execution) {
     if (++searchCount % 100 === 0) {
         pruneActivationCache();
@@ -958,7 +834,7 @@ async function searchMemoriesInternal(options, config, source, execution) {
             if (!queryEmbedding) {
                 throw new Error('query embedding unavailable');
             }
-            const vectorHits = vectorSearch(queryEmbedding, limit * 2, options.project, includeGlobal);
+            const vectorHits = vectorSearch(db, rowToMemory, queryEmbedding, limit * 2, options.project, includeGlobal);
             for (const hit of vectorHits) {
                 vectorResults.set(hit.memory.id, hit.similarity);
             }

package/dist/memory/types.d.ts

@@ -5,6 +5,7 @@ export type MemoryType = 'short_term' | 'long_term' | 'episodic';
 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,6 +16,7 @@ export interface Memory {
     accessCount: number;
     lastAccessed: Date;
     createdAt: Date;
+    updatedAt: Date;
     decayedScore: number;
     metadata: Record<string, unknown>;
     embedding?: Buffer;

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/recall.d.ts

@@ -48,9 +48,9 @@ export declare const recallSchema: z.ZodObject<{
     project?: string | undefined;
     mode?: "search" | "important" | "recent" | undefined;
     type?: "short_term" | "long_term" | "episodic" | undefined;
-    limit?: number | undefined;
     category?: "architecture" | "pattern" | "preference" | "error" | "context" | "learning" | "todo" | "note" | "relationship" | "custom" | undefined;
     tags?: string[] | undefined;
+    limit?: number | undefined;
     query?: string | undefined;
     includeDecayed?: boolean | undefined;
     includeGlobal?: boolean | undefined;