@syntesseraai/opencode-feature-factory 0.3.0 → 0.3.1

package/README.md

@@ -29,6 +29,33 @@ This will:
 - Copy skills to `~/.config/opencode/skills/`
 - Configure MCP servers in `~/.config/opencode/opencode.json`
 
+## Local Recall MCP Daemon
+
+The plugin now includes a local MCP daemon binary: `ff-local-recall-mcp`.
+
+- `ff-deploy` adds a local MCP server entry named `ff-local-recall`
+- The server exposes memory tools:
+  - `local_recall.search`
+  - `local_recall.get`
+  - `local_recall.store`
+  - `local_recall.index.start`
+  - `local_recall.index.status`
+  - `local_recall.index.stop`
+  - `local_recall.index.rebuild`
+
+### Environment Variables
+
+- `FF_LOCAL_RECALL_DIRECTORY` - Directory that contains `.feature-factory/` (default: current working directory)
+- `FF_LOCAL_RECALL_DAEMON_AUTOSTART` - Start index daemon automatically (`true` by default)
+- `FF_LOCAL_RECALL_INDEX_INTERVAL_MS` - Background daemon interval in milliseconds (default: `15000`)
+- `FF_LOCAL_RECALL_EXTRACTION_ENABLED` - Run extraction during daemon cycles (`true` by default)
+- `FF_LOCAL_RECALL_EMBEDDING_PROVIDER` - Embedding provider (`ollama` default, `openai` optional)
+- `FF_LOCAL_RECALL_OLLAMA_URL` - Ollama base URL (default: `http://127.0.0.1:11434`)
+- `FF_LOCAL_RECALL_OLLAMA_MODEL` - Ollama embedding model (default: `nomic-embed-text`)
+- `FF_LOCAL_RECALL_OPENAI_URL` - OpenAI embeddings endpoint base (default: `https://api.openai.com/v1`)
+- `FF_LOCAL_RECALL_OPENAI_MODEL` - OpenAI embedding model (default: `text-embedding-3-small`)
+- `OPENAI_API_KEY` - Required when `FF_LOCAL_RECALL_EMBEDDING_PROVIDER=openai`
+
 ## Agents Provided
 
 ### Primary Agents

package/agents/building.md

@@ -1,7 +1,6 @@
 ---
 description: Implements features and makes code changes based on implementation plans. Use this agent to execute plans, write code, and build features. Prefer delegation for validation, testing, and documentation.
 mode: primary
-temperature: 0.2
 color: '#10b981'
 tools:
   read: true

package/agents/ff-acceptance.md

@@ -1,8 +1,6 @@
 ---
 description: Validates implementation against acceptance criteria. Use this to verify that code meets all stated requirements and acceptance criteria with strict binary pass/fail validation. This agent cannot invoke sub-agents - it performs validation directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false

package/agents/ff-research.md

@@ -1,7 +1,6 @@
 ---
 description: Research specialist that investigates external topics using MCP tools. Use this agent to research libraries, APIs, best practices, and implementation patterns. This agent cannot invoke sub-agents - it performs research directly.
 mode: subagent
-temperature: 0.2
 tools:
   read: true
   write: false

package/agents/ff-review.md

@@ -1,8 +1,6 @@
 ---
 description: Reviews code changes for correctness, quality, and test coverage. Use this for detailed code review focusing on correctness, quality, testing, and documentation. This agent cannot invoke sub-agents - it performs review directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false

package/agents/ff-security.md

@@ -1,8 +1,6 @@
 ---
 description: Performs deep security audits on code changes. Use this to identify security vulnerabilities, check authentication/authorization, and ensure security best practices. This agent cannot invoke sub-agents - it performs audit directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false

package/agents/ff-validate.md

@@ -1,8 +1,6 @@
 ---
 description: Performs comprehensive validation covering acceptance criteria, security, code quality, and architecture. Use this for complete validation across all dimensions. This agent cannot invoke sub-agents - it performs all validation directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false

package/agents/ff-well-architected.md

@@ -1,8 +1,6 @@
 ---
 description: Reviews code against AWS Well-Architected Framework pillars. Use this for architecture reviews covering Operational Excellence, Security, Reliability, Performance, Cost, and Sustainability. This agent cannot invoke sub-agents - it performs review directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false

package/agents/planning.md

@@ -1,7 +1,6 @@
 ---
 description: Creates comprehensive implementation plans before making any code changes. Use this agent to analyze requirements, break down tasks, and create detailed implementation plans. Can delegate to read-only sub-agents for parallel research and validation.
 mode: primary
-temperature: 0.1
 color: '#3b82f6'
 tools:
   read: true

package/agents/reviewing.md

@@ -1,7 +1,6 @@
 ---
 description: Comprehensive validation agent that reviews implementation quality and feeds results back to the building agent. Use this to validate code changes across all dimensions. Can delegate to read-only sub-agents for parallel validation.
 mode: primary
-temperature: 0.1
 color: '#f59e0b'
 tools:
   read: true

package/bin/ff-deploy.js

@@ -29,6 +29,11 @@ const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
 
 // Default MCP configuration
 const DEFAULT_MCP_SERVERS = {
+  'ff-local-recall': {
+    type: 'local',
+    command: 'ff-local-recall-mcp',
+    enabled: true,
+  },
   'jina-ai': {
     type: 'remote',
     url: 'https://mcp.jina.ai/v1',

package/bin/ff-local-recall-mcp.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { runLocalRecallMCPServer } from '../dist/local-recall/mcp-stdio-server.js';
+
+runLocalRecallMCPServer().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Failed to start ff-local-recall MCP server: ${message}`);
+  process.exit(1);
+});

package/dist/index.js

@@ -1,9 +1,11 @@
 import { StopQualityGateHooksPlugin } from './stop-quality-gate.js';
+import { updateMCPConfig } from './mcp-config.js';
+import { $ } from 'bun';
 // Import tool creator functions
 import { createFFAgentsCurrentTool } from './plugins/ff-agents-current-plugin.js';
 import { createFFAgentsShowTool } from './plugins/ff-agents-show-plugin.js';
 import { createFFAgentsClearTool } from './plugins/ff-agents-clear-plugin.js';
-import { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, initLocalRecall, } from './local-recall/index.js';
+import { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, createLearningIndexStartTool, createLearningIndexStatusTool, createLearningIndexStopTool, createLearningIndexRebuildTool, initLocalRecall, } from './local-recall/index.js';
 import { createFFPlanCreateTool } from './plugins/ff-plan-create-plugin.js';
 import { createFFPlanUpdateTool } from './plugins/ff-plan-update-plugin.js';
 import { createFFAgentContextCreateTool } from './plugins/ff-agent-context-create-plugin.js';
@@ -36,6 +38,15 @@ export const FeatureFactoryPlugin = async (input) => {
     }
     // Initialize local-recall memory system
     initLocalRecall(directory);
+    // Update MCP server configuration in project opencode.json files
+    // This ensures Feature Factory MCP servers are available in the project
+    try {
+        await updateMCPConfig($, directory);
+    }
+    catch (error) {
+        // Silently fail - don't block plugin initialization if MCP config update fails
+        // This is a convenience feature, not critical for plugin functionality
+    }
     // Load hooks from the quality gate plugin
     const qualityGateHooks = await StopQualityGateHooksPlugin(input).catch(() => ({}));
     // Create all tools
@@ -48,6 +59,10 @@ export const FeatureFactoryPlugin = async (input) => {
         'ff-learning-store': createLearningStoreTool(),
         'ff-learning-search': createLearningSearchTool(),
         'ff-learning-get': createLearningGetTool(),
+        'ff-learning-index-start': createLearningIndexStartTool(),
+        'ff-learning-index-status': createLearningIndexStatusTool(),
+        'ff-learning-index-stop': createLearningIndexStopTool(),
+        'ff-learning-index-rebuild': createLearningIndexRebuildTool(),
         // Plan tools
         'ff-plan-create': createFFPlanCreateTool(),
         'ff-plan-update': createFFPlanUpdateTool(),

package/dist/local-recall/daemon-controller.d.ts

@@ -0,0 +1,51 @@
+import { type ExtractionStats } from './daemon.js';
+import { OramaMemoryIndex } from './vector/orama-index.js';
+export interface DaemonRunReport {
+    fullRebuild: boolean;
+    extraction: ExtractionStats | null;
+    upserted: number;
+    removed: number;
+    documents: number;
+    durationMs: number;
+    completedAt: string;
+}
+export interface DaemonStatus {
+    running: boolean;
+    processing: boolean;
+    intervalMs: number;
+    pending: boolean;
+    pendingReason: string | null;
+    lastRun: DaemonRunReport | null;
+    lastError: string | null;
+}
+interface ControllerOptions {
+    directory: string;
+    index: OramaMemoryIndex;
+    intervalMs?: number;
+    extractionEnabled?: boolean;
+}
+export declare class LocalRecallDaemonController {
+    private readonly directory;
+    private readonly index;
+    private readonly extractionEnabled;
+    private intervalMs;
+    private timer;
+    private running;
+    private processing;
+    private pending;
+    private pendingFullRebuild;
+    private pendingReason;
+    private lastRun;
+    private lastError;
+    constructor(options: ControllerOptions);
+    start(intervalMs?: number): DaemonStatus;
+    stop(): DaemonStatus;
+    requestRun(reason?: string, fullRebuild?: boolean): void;
+    runNow(reason?: string, fullRebuild?: boolean): Promise<DaemonStatus>;
+    rebuild(): Promise<DaemonStatus>;
+    getStatus(): DaemonStatus;
+    private runLoop;
+    private runCycle;
+    private waitForIdle;
+}
+export {};

package/dist/local-recall/daemon-controller.js

@@ -0,0 +1,166 @@
+import { runExtraction } from './daemon.js';
+import { computeMemoryHash, readIndexState, writeIndexState } from './index-state.js';
+import { listAllMemories } from './memory-service.js';
+const DEFAULT_INTERVAL_MS = 15_000;
+export class LocalRecallDaemonController {
+    directory;
+    index;
+    extractionEnabled;
+    intervalMs;
+    timer = null;
+    running = false;
+    processing = false;
+    pending = false;
+    pendingFullRebuild = false;
+    pendingReason = null;
+    lastRun = null;
+    lastError = null;
+    constructor(options) {
+        this.directory = options.directory;
+        this.index = options.index;
+        this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+        this.extractionEnabled = options.extractionEnabled ?? true;
+    }
+    start(intervalMs) {
+        if (intervalMs && intervalMs > 0) {
+            this.intervalMs = intervalMs;
+        }
+        if (this.running) {
+            return this.getStatus();
+        }
+        this.running = true;
+        this.timer = setInterval(() => {
+            this.requestRun('interval');
+        }, this.intervalMs);
+        this.requestRun('startup');
+        return this.getStatus();
+    }
+    stop() {
+        this.running = false;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        return this.getStatus();
+    }
+    requestRun(reason = 'manual', fullRebuild = false) {
+        this.pending = true;
+        this.pendingReason = reason;
+        if (fullRebuild) {
+            this.pendingFullRebuild = true;
+        }
+        void this.runLoop();
+    }
+    async runNow(reason = 'manual', fullRebuild = false) {
+        this.requestRun(reason, fullRebuild);
+        await this.waitForIdle();
+        return this.getStatus();
+    }
+    async rebuild() {
+        return this.runNow('rebuild', true);
+    }
+    getStatus() {
+        return {
+            running: this.running,
+            processing: this.processing,
+            intervalMs: this.intervalMs,
+            pending: this.pending,
+            pendingReason: this.pendingReason,
+            lastRun: this.lastRun,
+            lastError: this.lastError,
+        };
+    }
+    async runLoop() {
+        if (this.processing) {
+            return;
+        }
+        this.processing = true;
+        try {
+            while (this.pending) {
+                const fullRebuild = this.pendingFullRebuild;
+                this.pending = false;
+                this.pendingFullRebuild = false;
+                this.pendingReason = null;
+                await this.runCycle(fullRebuild);
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    async runCycle(fullRebuild) {
+        const startedAt = Date.now();
+        this.lastError = null;
+        try {
+            const extraction = this.extractionEnabled ? await runExtraction(this.directory) : null;
+            const allMemories = await listAllMemories(this.directory);
+            const now = Date.now();
+            let upserted = 0;
+            let removed = 0;
+            if (fullRebuild) {
+                upserted = await this.index.rebuild(allMemories);
+            }
+            else {
+                const previousState = await readIndexState(this.directory);
+                const nextEntries = {};
+                const changed = [];
+                for (const memory of allMemories) {
+                    const hash = computeMemoryHash(memory);
+                    nextEntries[memory.id] = {
+                        hash,
+                        updatedAt: now,
+                    };
+                    const previous = previousState.entries[memory.id];
+                    if (!previous || previous.hash !== hash) {
+                        changed.push(memory);
+                    }
+                }
+                const removedIDs = Object.keys(previousState.entries).filter((id) => !nextEntries[id]);
+                if (changed.length > 0) {
+                    upserted = await this.index.upsertMemories(changed);
+                }
+                if (removedIDs.length > 0) {
+                    removed = await this.index.removeMemories(removedIDs);
+                }
+            }
+            await writeIndexState(this.directory, {
+                version: 1,
+                entries: Object.fromEntries(allMemories.map((memory) => [
+                    memory.id,
+                    {
+                        hash: computeMemoryHash(memory),
+                        updatedAt: now,
+                    },
+                ])),
+                updatedAt: now,
+            });
+            const documents = this.index.getStatus().documents;
+            this.lastRun = {
+                fullRebuild,
+                extraction,
+                upserted,
+                removed,
+                documents,
+                durationMs: Date.now() - startedAt,
+                completedAt: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            this.lastError = error instanceof Error ? error.message : String(error);
+            this.lastRun = {
+                fullRebuild,
+                extraction: null,
+                upserted: 0,
+                removed: 0,
+                documents: this.index.getStatus().documents,
+                durationMs: Date.now() - startedAt,
+                completedAt: new Date().toISOString(),
+            };
+        }
+    }
+    async waitForIdle() {
+        while (this.processing || this.pending) {
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+}

package/dist/local-recall/index-state.d.ts

@@ -0,0 +1,14 @@
+import type { Memory } from './types.js';
+export interface IndexStateEntry {
+    hash: string;
+    updatedAt: number;
+}
+export interface IndexState {
+    version: 1;
+    entries: Record<string, IndexStateEntry>;
+    updatedAt: number;
+}
+export declare function getIndexStatePath(directory: string): string;
+export declare function readIndexState(directory: string): Promise<IndexState>;
+export declare function writeIndexState(directory: string, state: IndexState): Promise<void>;
+export declare function computeMemoryHash(memory: Memory): string;

package/dist/local-recall/index-state.js

@@ -0,0 +1,76 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const EMPTY_STATE = {
+    version: 1,
+    entries: {},
+    updatedAt: 0,
+};
+function getIndexDir(directory) {
+    return path.join(directory, '.feature-factory', 'local-recall', 'index');
+}
+export function getIndexStatePath(directory) {
+    return path.join(getIndexDir(directory), 'state.json');
+}
+function normalizeState(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return { ...EMPTY_STATE };
+    }
+    const value = raw;
+    const entries = {};
+    if (value.entries && typeof value.entries === 'object') {
+        for (const [id, entry] of Object.entries(value.entries)) {
+            if (!entry || typeof entry !== 'object') {
+                continue;
+            }
+            const candidate = entry;
+            if (typeof candidate.hash !== 'string') {
+                continue;
+            }
+            entries[id] = {
+                hash: candidate.hash,
+                updatedAt: typeof candidate.updatedAt === 'number' ? candidate.updatedAt : 0,
+            };
+        }
+    }
+    return {
+        version: value.version === 1 ? 1 : 1,
+        entries,
+        updatedAt: typeof value.updatedAt === 'number' ? value.updatedAt : 0,
+    };
+}
+async function writeAtomic(filePath, value) {
+    const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(value, null, 2), 'utf-8');
+    await rename(tmpPath, filePath);
+}
+export async function readIndexState(directory) {
+    const filePath = getIndexStatePath(directory);
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        return normalizeState(JSON.parse(raw));
+    }
+    catch {
+        return { ...EMPTY_STATE };
+    }
+}
+export async function writeIndexState(directory, state) {
+    const filePath = getIndexStatePath(directory);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeAtomic(filePath, state);
+}
+export function computeMemoryHash(memory) {
+    const stable = JSON.stringify({
+        id: memory.id,
+        sessionID: memory.sessionID,
+        messageID: memory.messageID,
+        category: memory.category,
+        title: memory.title,
+        body: memory.body,
+        tags: [...memory.tags].sort(),
+        importance: memory.importance,
+        createdAt: memory.createdAt,
+        extractedBy: memory.extractedBy,
+    });
+    return createHash('sha256').update(stable).digest('hex');
+}

package/dist/local-recall/index.d.ts

@@ -10,5 +10,11 @@ export { extractFromMessage, extractFromParts } from './session-extractor.js';
 export { extractThinkingFromMessage, extractFromThinkingParts } from './thinking-extractor.js';
 export { isProcessed, isContentProcessed, markProcessed, readProcessedLog, contentHash, getProcessedMessageIDs, getProcessedHashes, } from './processed-log.js';
 export { runExtraction, type ExtractionStats } from './daemon.js';
-export { initLocalRecall, isInitialized, getDirectory, triggerExtraction, getLastExtractionStats, shutdownLocalRecall, } from './mcp-server.js';
-export { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, } from './mcp-tools.js';
+export { LocalRecallDaemonController, type DaemonStatus, type DaemonRunReport, } from './daemon-controller.js';
+export { readIndexState, writeIndexState, computeMemoryHash, getIndexStatePath, type IndexState, type IndexStateEntry, } from './index-state.js';
+export { createEmbeddingProvider, OllamaEmbeddingProvider, OpenAIEmbeddingProvider, } from './vector/embedding-provider.js';
+export { OramaMemoryIndex } from './vector/orama-index.js';
+export type { EmbeddingProvider, EmbeddingProviderName, VectorIndexManifest, VectorIndexDocument, VectorSearchResponse, } from './vector/types.js';
+export { initLocalRecall, isInitialized, getDirectory, triggerExtraction, getLastExtractionStats, shutdownLocalRecall, storeLearningMemory, searchLearningMemories, getLearningMemory, startIndexingDaemon, stopIndexingDaemon, getIndexingStatus, rebuildIndex, listLearningMemories, type LearningStoreInput, type IndexingStatus, } from './mcp-server.js';
+export { runLocalRecallMCPServer, type LocalRecallMCPServerOptions } from './mcp-stdio-server.js';
+export { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, createLearningIndexStartTool, createLearningIndexStatusTool, createLearningIndexStopTool, createLearningIndexRebuildTool, } from './mcp-tools.js';

package/dist/local-recall/index.js

@@ -14,7 +14,14 @@ export { extractThinkingFromMessage, extractFromThinkingParts } from './thinking
 export { isProcessed, isContentProcessed, markProcessed, readProcessedLog, contentHash, getProcessedMessageIDs, getProcessedHashes, } from './processed-log.js';
 // Daemon
 export { runExtraction } from './daemon.js';
+export { LocalRecallDaemonController, } from './daemon-controller.js';
+// Index state
+export { readIndexState, writeIndexState, computeMemoryHash, getIndexStatePath, } from './index-state.js';
+// Vector index
+export { createEmbeddingProvider, OllamaEmbeddingProvider, OpenAIEmbeddingProvider, } from './vector/embedding-provider.js';
+export { OramaMemoryIndex } from './vector/orama-index.js';
 // MCP server lifecycle
-export { initLocalRecall, isInitialized, getDirectory, triggerExtraction, getLastExtractionStats, shutdownLocalRecall, } from './mcp-server.js';
+export { initLocalRecall, isInitialized, getDirectory, triggerExtraction, getLastExtractionStats, shutdownLocalRecall, storeLearningMemory, searchLearningMemories, getLearningMemory, startIndexingDaemon, stopIndexingDaemon, getIndexingStatus, rebuildIndex, listLearningMemories, } from './mcp-server.js';
+export { runLocalRecallMCPServer } from './mcp-stdio-server.js';
 // MCP tools (plugin tool creators)
-export { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, } from './mcp-tools.js';
+export { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, createLearningIndexStartTool, createLearningIndexStatusTool, createLearningIndexStopTool, createLearningIndexRebuildTool, } from './mcp-tools.js';

package/dist/local-recall/mcp-server.d.ts

@@ -1,38 +1,34 @@
-/**
- * mcp-server.ts — MCP server lifecycle for local-recall.
- *
- * Manages the local-recall extraction daemon lifecycle within the
- * OpenCode plugin.  Provides init / shutdown hooks and exposes
- * the extraction trigger for on-demand use.
- */
-import { type ExtractionStats } from './daemon.js';
-/**
- * Initialize the local-recall system for a project directory.
- * Should be called once during plugin startup.
- */
+import type { ExtractionStats } from './daemon.js';
+import { type DaemonStatus } from './daemon-controller.js';
+import type { Memory, MemoryCategory, MemorySearchResult, SearchCriteria } from './types.js';
+import { OramaMemoryIndex } from './vector/orama-index.js';
+import type { VectorSearchResponse } from './vector/types.js';
+export interface LearningStoreInput {
+    title: string;
+    description: string;
+    category: MemoryCategory;
+    tags: string[];
+    importance?: number;
+    content?: string;
+}
+export interface IndexingStatus {
+    daemon: DaemonStatus;
+    index: ReturnType<OramaMemoryIndex['getStatus']>;
+}
 export declare function initLocalRecall(directory: string): void;
-/**
- * Check if local-recall has been initialized.
- */
 export declare function isInitialized(): boolean;
-/**
- * Get the project directory local-recall is bound to.
- */
 export declare function getDirectory(): string | null;
-/**
- * Trigger an extraction pass. Can be called on-demand (e.g. from
- * the ff-learning-store tool) or at startup.
- *
- * Safe to call multiple times — the processed-log prevents
- * duplicate extraction.
- */
-export declare function triggerExtraction(): Promise<ExtractionStats | null>;
-/**
- * Get the results of the last extraction pass.
- */
+export declare function triggerExtraction(directory?: string): Promise<ExtractionStats | null>;
 export declare function getLastExtractionStats(): ExtractionStats | null;
-/**
- * Shutdown the local-recall system.  Currently a no-op but
- * provided for lifecycle symmetry and future cleanup needs.
- */
 export declare function shutdownLocalRecall(): void;
+export declare function storeLearningMemory(directory: string, args: LearningStoreInput): Promise<{
+    memoryId: string;
+    daemon: DaemonStatus;
+}>;
+export declare function searchLearningMemories(directory: string, criteria: SearchCriteria): Promise<VectorSearchResponse>;
+export declare function getLearningMemory(directory: string, memoryID: string): Promise<Memory | null>;
+export declare function startIndexingDaemon(directory: string, intervalMs?: number): Promise<IndexingStatus>;
+export declare function stopIndexingDaemon(directory: string): Promise<IndexingStatus>;
+export declare function getIndexingStatus(directory: string): Promise<IndexingStatus>;
+export declare function rebuildIndex(directory: string): Promise<IndexingStatus>;
+export declare function listLearningMemories(directory: string, criteria: SearchCriteria): Promise<MemorySearchResult[]>;