claude-flow 3.47.1 → 3.49.0

package/v3/@claude-flow/cli/dist/src/mcp-tools/session-tools.js

@@ -4,6 +4,7 @@
  * Tool definitions for session management with file persistence.
  */
 import { existsSync, readFileSync, readdirSync, unlinkSync, statSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { mkdirRestricted, readFileMaybeEncrypted, writeFileRestricted, } from '../fs-secure.js';
@@ -68,17 +69,126 @@ function listSessions() {
     }
     return sessions;
 }
-// Load related stores for session data
-function loadRelatedStores(options) {
-    const data = {};
-    if (options.includeMemory) {
+/** Snapshot format written by session_save since #3573. */
+const MEMORY_SNAPSHOT_FORMAT = 'ruflo-session-memory/2';
+const MEMORY_PAGE_SIZE = 500;
+async function readLiveEntries(listEntries, dbPath, encryptWrites) {
+    const rows = [];
+    // Bounded: stop on a short page, once `total` rows are in hand, or after a
+    // hard cap, so a backend that ignores `offset` cannot loop forever.
+    for (let page = 0, offset = 0; page < 10_000; page++, offset += MEMORY_PAGE_SIZE) {
+        const result = await listEntries({
+            dbPath, includeContent: true, limit: MEMORY_PAGE_SIZE, offset,
+            ...(encryptWrites === undefined ? {} : { encryptWrites }),
+        });
+        if (!result.success)
+            throw new Error(result.error || `could not list ${dbPath}`);
+        rows.push(...result.entries);
+        if (result.entries.length < MEMORY_PAGE_SIZE || rows.length >= result.total)
+            break;
+    }
+    return rows;
+}
+/**
+ * #3573: capture the memory the user actually has.
+ *
+ * Before this, session_save read only the pre-SQLite `.claude-flow/memory/store.json`,
+ * which a current install never writes, so `--include-memory` saved nothing and
+ * reported "Memory Entries: 0". The snapshot now covers the same store `memory
+ * list` reads (resolveDbPath), plus rows that exist only in the sibling AgentDB
+ * store written by the MCP path, de-duplicated by namespace+key (default CLI
+ * writes are mirrored into AgentDB, so most rows are in both). A legacy
+ * store.json is still captured for backward compatibility.
+ */
+async function captureMemorySnapshot() {
+    const report = {
+        requested: true, status: 'captured', entries: 0,
+        sources: { memoryDb: 0, agentdb: 0, legacyJson: 0 },
+    };
+    const entries = {};
+    let legacy;
+    const legacyPath = join(getProjectCwd(), STORAGE_DIR, 'memory', 'store.json');
+    if (existsSync(legacyPath)) {
         try {
-            const memoryPath = join(getProjectCwd(), STORAGE_DIR, 'memory', 'store.json');
-            if (existsSync(memoryPath)) {
-                data.memory = JSON.parse(readFileSync(memoryPath, 'utf-8'));
+            legacy = JSON.parse(readFileSync(legacyPath, 'utf-8'));
+            const legacyEntries = legacy.entries || {};
+            for (const [id, entry] of Object.entries(legacyEntries)) {
+                entries[id] = entry;
+                report.sources.legacyJson++;
             }
         }
-        catch { /* ignore */ }
+        catch { /* unreadable legacy file is not memory we can restore */ }
+    }
+    let sawStore = legacy !== undefined;
+    try {
+        const { listEntries, resolveDbPath } = await import('../memory/memory-initializer.js');
+        const primary = resolveDbPath();
+        const seen = new Set();
+        if (existsSync(primary)) {
+            sawStore = true;
+            for (const row of await readLiveEntries(listEntries, primary)) {
+                const id = `${row.namespace}::${row.key}`;
+                seen.add(id);
+                entries[id] = {
+                    key: row.key, value: row.content ?? '', namespace: row.namespace,
+                    provenanceType: row.provenanceType, source: 'memory-db',
+                };
+                report.sources.memoryDb++;
+            }
+        }
+        let sibling = null;
+        try {
+            const { siblingAgentDbPath } = await import('../memory/memory-bridge.js');
+            sibling = siblingAgentDbPath(primary);
+        }
+        catch { /* no bridge, no sibling store */ }
+        if (sibling && existsSync(sibling)) {
+            sawStore = true;
+            // The AgentDB store is read by native SQLite and must stay plaintext.
+            for (const row of await readLiveEntries(listEntries, sibling, false)) {
+                const id = `${row.namespace}::${row.key}`;
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                entries[id] = {
+                    key: row.key, value: row.content ?? '', namespace: row.namespace,
+                    provenanceType: row.provenanceType, source: 'agentdb',
+                };
+                report.sources.agentdb++;
+            }
+        }
+    }
+    catch (e) {
+        report.status = 'error';
+        report.error = e.message;
+    }
+    report.entries = Object.keys(entries).length;
+    if (report.status !== 'error' && !sawStore)
+        report.status = 'no-store';
+    if (report.entries === 0 && legacy === undefined) {
+        return { report };
+    }
+    return {
+        memory: {
+            format: MEMORY_SNAPSHOT_FORMAT,
+            entries,
+            ...(legacy !== undefined ? { legacy } : {}),
+        },
+        report,
+    };
+}
+// Load related stores for session data
+async function loadRelatedStores(options) {
+    const data = {};
+    let memoryCapture = {
+        requested: false, status: 'not-requested', entries: 0,
+        sources: { memoryDb: 0, agentdb: 0, legacyJson: 0 },
+    };
+    if (options.includeMemory) {
+        const captured = await captureMemorySnapshot();
+        memoryCapture = captured.report;
+        if (captured.memory)
+            data.memory = captured.memory;
     }
     if (options.includeTasks) {
         try {
@@ -98,7 +208,92 @@ function loadRelatedStores(options) {
         }
         catch { /* ignore */ }
     }
-    return data;
+    return { data, memoryCapture };
+}
+/** Count entries in a memory snapshot of either format. */
+function countMemoryEntries(memory) {
+    if (!memory || typeof memory !== 'object')
+        return 0;
+    return Object.keys(memory.entries || {}).length;
+}
+/**
+ * Restore a memory snapshot into the live store and report what was actually
+ * written. #3573: the previous restore swallowed every write failure and then
+ * echoed the count recorded at save time.
+ */
+async function restoreMemorySnapshot(memory) {
+    const outcome = { restored: 0, failed: 0, errors: [] };
+    const isV2 = memory.format === MEMORY_SNAPSHOT_FORMAT;
+    // Legacy snapshots are the old store.json itself; v2 snapshots carry it
+    // under `legacy` only when one existed at save time.
+    const legacyJson = isV2 ? memory.legacy : memory;
+    if (legacyJson !== undefined) {
+        const memoryDir = join(getProjectCwd(), STORAGE_DIR, 'memory');
+        if (!existsSync(memoryDir))
+            mkdirRestricted(memoryDir);
+        writeFileRestricted(join(memoryDir, 'store.json'), JSON.stringify(legacyJson, null, 2));
+    }
+    const entries = memory.entries;
+    if (!entries)
+        return outcome;
+    let storeEntry;
+    let isValidProvenanceType = () => false;
+    try {
+        const mod = await import('../memory/memory-initializer.js');
+        storeEntry = mod.storeEntry;
+        try {
+            if (typeof mod.isValidProvenanceType === 'function')
+                isValidProvenanceType = mod.isValidProvenanceType;
+        }
+        catch { /* optional: without it, provenance is simply not carried over */ }
+    }
+    catch (e) {
+        outcome.failed = Object.keys(entries).length;
+        outcome.errors.push(`memory store unavailable: ${e.message}`);
+        return outcome;
+    }
+    for (const entry of Object.values(entries)) {
+        const key = entry.key || entry.id || '';
+        const value = entry.value || entry.content || '';
+        if (!key || !value) {
+            outcome.failed++;
+            continue;
+        }
+        try {
+            // A snapshot from another version may carry a provenance value this one
+            // rejects; drop it rather than fail an otherwise-good row.
+            const provenance = entry.provenanceType && entry.provenanceType !== 'unknown'
+                && isValidProvenanceType(entry.provenanceType) ? entry.provenanceType : undefined;
+            const result = await storeEntry({
+                key,
+                value,
+                namespace: entry.namespace || 'restored',
+                upsert: true,
+                ...(provenance ? { provenanceType: provenance } : {}),
+            });
+            if (result && result.success === false) {
+                outcome.failed++;
+                if (result.error && outcome.errors.length < 5)
+                    outcome.errors.push(`${key}: ${result.error}`);
+            }
+            else {
+                outcome.restored++;
+            }
+        }
+        catch (e) {
+            outcome.failed++;
+            if (outcome.errors.length < 5)
+                outcome.errors.push(`${key}: ${e.message}`);
+        }
+    }
+    return outcome;
+}
+/** A session record is an object that carries at least one of its defining fields. */
+function isSessionRecordLike(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const v = value;
+    return 'data' in v || 'stats' in v || 'sessionId' in v || 'savedAt' in v;
 }
 export const sessionTools = [
     {
@@ -126,9 +321,9 @@ export const sessionTools = [
                 if (!v.valid)
                     return { success: false, error: v.error };
             }
-            const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const sessionId = `session-${Date.now()}-${randomUUID().slice(0, 8)}`;
             // Load related data based on options
-            const data = loadRelatedStores({
+            const { data, memoryCapture } = await loadRelatedStores({
                 includeMemory: input.includeMemory,
                 includeTasks: input.includeTasks,
                 includeAgents: input.includeAgents,
@@ -137,7 +332,7 @@ export const sessionTools = [
             const stats = {
                 tasks: data.tasks ? Object.keys(data.tasks.tasks || {}).length : 0,
                 agents: data.agents ? Object.keys(data.agents.agents || {}).length : 0,
-                memoryEntries: data.memory ? Object.keys(data.memory.entries || {}).length : 0,
+                memoryEntries: countMemoryEntries(data.memory),
                 totalSize: 0,
             };
             const session = {
@@ -157,6 +352,7 @@ export const sessionTools = [
                 name: session.name,
                 savedAt: session.savedAt,
                 stats: session.stats,
+                memoryCapture,
                 path: getSessionPath(sessionId),
             };
         },
@@ -170,6 +366,9 @@ export const sessionTools = [
             properties: {
                 sessionId: { type: 'string', description: 'Session ID to restore' },
                 name: { type: 'string', description: 'Session name to restore' },
+                restoreMemory: { type: 'boolean', description: 'Restore memory (default true)' },
+                restoreTasks: { type: 'boolean', description: 'Restore tasks (default true)' },
+                restoreAgents: { type: 'boolean', description: 'Restore agents (default true)' },
             },
         },
         handler: async (input) => {
@@ -203,43 +402,19 @@ export const sessionTools = [
                 }
             }
             if (session) {
-                // Restore data to respective stores (legacy JSON for backward compat).
-                // audit_1776853149979: tighten perms on the restored stores too.
-                if (session.data?.memory) {
-                    const memoryDir = join(getProjectCwd(), STORAGE_DIR, 'memory');
-                    if (!existsSync(memoryDir))
-                        mkdirRestricted(memoryDir);
-                    writeFileRestricted(join(memoryDir, 'store.json'), JSON.stringify(session.data.memory, null, 2));
-                    // Also populate active sql.js SQLite database so memory-tools can find entries
-                    try {
-                        const { storeEntry } = await import('../memory/memory-initializer.js');
-                        const memoryData = session.data.memory;
-                        if (memoryData.entries) {
-                            for (const entry of Object.values(memoryData.entries)) {
-                                const key = entry.key || entry.id || '';
-                                const value = entry.value || entry.content || '';
-                                if (key && value) {
-                                    await storeEntry({
-                                        key,
-                                        value,
-                                        namespace: entry.namespace || 'restored',
-                                        upsert: true,
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        // Legacy JSON restore is the fallback -- sql.js import may not be available
-                    }
+                // Restore data to respective stores. audit_1776853149979: tighten
+                // perms on the restored stores too.
+                let memoryRestore;
+                if (input.restoreMemory !== false && session.data?.memory) {
+                    memoryRestore = await restoreMemorySnapshot(session.data.memory);
                 }
-                if (session.data?.tasks) {
+                if (input.restoreTasks !== false && session.data?.tasks) {
                     const taskDir = join(getProjectCwd(), STORAGE_DIR, 'tasks');
                     if (!existsSync(taskDir))
                         mkdirRestricted(taskDir);
                     writeFileRestricted(join(taskDir, 'store.json'), JSON.stringify(session.data.tasks, null, 2));
                 }
-                if (session.data?.agents) {
+                if (input.restoreAgents !== false && session.data?.agents) {
                     const agentDir = join(getProjectCwd(), STORAGE_DIR, 'agents');
                     if (!existsSync(agentDir))
                         mkdirRestricted(agentDir);
@@ -249,8 +424,18 @@ export const sessionTools = [
                     sessionId: session.sessionId,
                     name: session.name,
                     restored: true,
+                    restoredComponents: {
+                        memory: input.restoreMemory !== false && !!session.data?.memory,
+                        tasks: input.restoreTasks !== false && !!session.data?.tasks,
+                        agents: input.restoreAgents !== false && !!session.data?.agents,
+                    },
                     restoredAt: new Date().toISOString(),
                     stats: session.stats,
+                    // #3573: counts actually written, not the count recorded at save time.
+                    ...(memoryRestore ? {
+                        memoryRestore,
+                        stats: { ...session.stats, memoryEntriesRestored: memoryRestore.restored },
+                    } : {}),
                 };
             }
             return {
@@ -437,7 +622,7 @@ export const sessionTools = [
             properties: {
                 sessionId: { type: 'string', description: 'Session ID to export' },
                 outputPath: { type: 'string', description: 'File path to write the export to (optional)' },
-                includeMemory: { type: 'boolean', description: 'Include the memory snapshot (advisory — already in the saved record)' },
+                includeMemory: { type: 'boolean', description: 'Include the memory snapshot (default true)' },
             },
             required: ['sessionId'],
         },
@@ -449,6 +634,14 @@ export const sessionTools = [
             const session = loadSession(sessionId);
             if (!session)
                 return { sessionId, error: 'Session not found' };
+            // Apply the explicit exclusion before either returning or writing the
+            // snapshot. The saved source remains intact for a later full restore.
+            if (input.includeMemory === false) {
+                if (session.data)
+                    delete session.data.memory;
+                session.stats = { ...session.stats, memoryEntries: 0, totalSize: 0 };
+                session.stats.totalSize = Buffer.byteLength(JSON.stringify(session), 'utf-8');
+            }
             let path = null;
             const outputPath = input.outputPath ? String(input.outputPath) : null;
             if (outputPath) {
@@ -467,30 +660,40 @@ export const sessionTools = [
         // #1916: `ruflo session import <file>` referenced an unregistered
         // `session_import` tool. Reads a session JSON and re-saves it locally.
         name: 'session_import',
-        description: 'Import a session JSON file (produced by session_export) into the local session store and optionally activate it. Use when native Read is wrong because the file is a structured session record that must be re-registered (new id, stats recomputed) rather than just read. For reading the file, native Read is fine. Pair with session_export on the source.',
+        description: 'Import a session (produced by session_export) into the local session store and optionally activate it. Pass either inputPath (a session JSON file) or data (the session record itself). Use when native Read is wrong because the file is a structured session record that must be re-registered (new id, stats recomputed) rather than just read. For reading the file, native Read is fine. Pair with session_export on the source.',
         category: 'session',
         inputSchema: {
             type: 'object',
             properties: {
-                inputPath: { type: 'string', description: 'Path to the session JSON file to import' },
+                inputPath: { type: 'string', description: 'Path to the session JSON file to import (or pass data)' },
+                data: { type: 'object', description: 'The session record itself, as written by session_export (or pass inputPath)' },
                 name: { type: 'string', description: 'Override the imported session name' },
-                activate: { type: 'boolean', description: 'Make the imported session the current one (advisory)' },
+                activate: { type: 'boolean', description: 'Restore the imported session into the active stores' },
             },
-            required: ['inputPath'],
         },
         handler: async (input) => {
-            const inputPath = String(input.inputPath ?? '');
-            if (!inputPath || !existsSync(inputPath))
-                return { error: `File not found: ${inputPath || '(empty)'}` };
             let parsed;
-            try {
-                parsed = JSON.parse(readFileSync(inputPath, 'utf-8'));
+            if (input.data !== undefined && input.data !== null) {
+                parsed = input.data;
             }
-            catch (e) {
-                return { error: `Invalid session JSON: ${e.message}` };
+            else {
+                const inputPath = String(input.inputPath ?? '');
+                if (!inputPath)
+                    return { error: 'Provide inputPath (a session JSON file) or data (a session record)' };
+                if (!existsSync(inputPath))
+                    return { error: `File not found: ${inputPath}` };
+                try {
+                    parsed = JSON.parse(readFileSync(inputPath, 'utf-8'));
+                }
+                catch (e) {
+                    return { error: `Invalid session JSON: ${e.message}` };
+                }
             }
-            const newId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            const stats = parsed.stats || { tasks: 0, agents: 0, memoryEntries: 0, totalSize: 0 };
+            if (!isSessionRecordLike(parsed)) {
+                return { error: 'Not a session record: expected an object produced by session export' };
+            }
+            const newId = `session-${Date.now()}-${randomUUID().slice(0, 8)}`;
+            const stats = { tasks: 0, agents: 0, memoryEntries: 0, totalSize: 0, ...(parsed.stats || {}) };
             const session = {
                 sessionId: newId,
                 name: input.name ? String(input.name) : (parsed.name || 'imported-session'),
@@ -500,6 +703,15 @@ export const sessionTools = [
                 data: parsed.data,
             };
             saveSession(session);
+            let activated = false;
+            if (input.activate === true) {
+                const restore = sessionTools.find(tool => tool.name === 'session_restore');
+                const result = await restore.handler({ sessionId: newId });
+                if (result.restored !== true) {
+                    return { sessionId: newId, activated: false, error: result.error || 'Imported session could not be restored' };
+                }
+                activated = true;
+            }
             return {
                 sessionId: newId,
                 name: session.name,
@@ -509,7 +721,7 @@ export const sessionTools = [
                     tasksImported: stats.tasks,
                     memoryEntriesImported: stats.memoryEntries,
                 },
-                activated: input.activate === true,
+                activated,
             };
         },
     },

package/v3/@claude-flow/cli/dist/src/memory/feedback-patterns.d.ts

@@ -0,0 +1,13 @@
+/** Shared input contract for learned patterns supplied by feedback callers. */
+export declare const feedbackPatternsSchema: {
+    type: string;
+    items: {
+        type: string;
+        minLength: number;
+        maxLength: number;
+    };
+    maxItems: number;
+    description: string;
+};
+export declare function validateFeedbackPatterns(value: unknown): string[] | undefined;
+//# sourceMappingURL=feedback-patterns.d.ts.map

package/v3/@claude-flow/cli/dist/src/memory/feedback-patterns.js

@@ -0,0 +1,14 @@
+/** Shared input contract for learned patterns supplied by feedback callers. */
+export const feedbackPatternsSchema = {
+    type: 'array', items: { type: 'string', minLength: 1, maxLength: 10_000 }, maxItems: 100,
+    description: 'Learned patterns to retain; successful tasks with quality >= 0.9 may create reusable skills',
+};
+export function validateFeedbackPatterns(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.length > 100 || value.some(item => typeof item !== 'string' || !item.trim() || item.length > 10_000)) {
+        throw new Error('patterns must be an array of at most 100 non-empty strings (maximum 10000 characters each)');
+    }
+    return value;
+}
+//# sourceMappingURL=feedback-patterns.js.map

package/v3/@claude-flow/cli/dist/src/memory/live-memory-row.d.ts

@@ -0,0 +1,3 @@
+/** TTL is a read-time visibility rule, independent of background cleanup. */
+export declare function liveMemoryRowSql(): string;
+//# sourceMappingURL=live-memory-row.d.ts.map

package/v3/@claude-flow/cli/dist/src/memory/live-memory-row.js

@@ -0,0 +1,5 @@
+/** TTL is a read-time visibility rule, independent of background cleanup. */
+export function liveMemoryRowSql() {
+    return `(status = 'active' OR status IS NULL) AND (expires_at IS NULL OR expires_at > ${Date.now()})`;
+}
+//# sourceMappingURL=live-memory-row.js.map

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.d.ts

@@ -36,6 +36,8 @@ export declare function shouldDisableNativeBridge(platform?: NodeJS.Platform, en
 export declare function shouldSuppressInitLog(msg: string): boolean;
 /** Test seam: forget cached registries so a test can exercise a fresh open. */
 export declare function _resetRegistryCacheForTest(): void;
+/** Inject registry construction without requiring the optional native package in tests. */
+export declare function __setMemoryBridgeRegistryFactoryForTests(factory: (() => any) | null): void;
 /** #3196: the sibling store AgentDB owns next to a given sql.js database. */
 export declare function siblingAgentDbPath(dbPath: string): string | null;
 /**
@@ -271,6 +273,7 @@ export declare function bridgeAddEmbedding(id: string, embedding: number[], entr
 }, dbPath?: string): Promise<boolean | null>;
 /**
  * Get a named controller from AgentDB v3 via ControllerRegistry.
+ * This borrowed handle must not be retained across shutdownBridge().
  * Returns null if unavailable.
  */
 export declare function bridgeGetController(name: string, dbPath?: string): Promise<any | null>;
@@ -292,13 +295,15 @@ export declare function bridgeListControllers(dbPath?: string): Promise<Array<{
 export declare function isBridgeAvailable(dbPath?: string): Promise<boolean>;
 /**
  * Get the ControllerRegistry instance (for advanced consumers).
+ * This is a borrowed handle, valid only until shutdownBridge(). Callers must
+ * finish using it before requesting shutdown; bridge operations own their own
+ * leases. Prefer bridgeListControllers() for status inspection.
  */
 export declare function getControllerRegistry(dbPath?: string): Promise<any | null>;
 /**
  * Why the bridge last declined a write, or null when it has not.
  *
- * Deliberately NOT gated on `bridgeAvailable === false`. A bridge that
- * initialised fine can still fail every write — a schema mismatch throws
+ * A bridge that initialised fine can still fail every write — a schema mismatch throws
  * per-operation while the registry stays healthy — and that case is exactly
  * the one worth reporting, since the caller then demotes to a fallback whose
  * error message describes something else entirely.
@@ -306,7 +311,7 @@ export declare function getControllerRegistry(dbPath?: string): Promise<any | nu
  * Callers that surface a degraded-path error should include this so the
  * operator learns the cause instead of only the symptom.
  */
-export declare function getBridgeFailureReason(): string | null;
+export declare function getBridgeFailureReason(dbPath?: string): string | null;
 /**
  * Install a pre-initialized registry for deterministic bridge tests.
  *
@@ -321,10 +326,8 @@ export declare function __setMemoryBridgeRegistryForTests(registry: any | null):
  * Shutdown the bridge and release resources.
  *
  * The cached state is cleared unconditionally. Previously the reset lived
- * inside `if (registryInstance)`, so it could not clear a FAILED init — the
- * one state that actually needs clearing, since `registryInstance` is null
- * precisely when init failed. A process that latched `bridgeAvailable = false`
- * therefore had no recovery path short of a restart.
+ * inside `if (registryInstance)`, so it could not clear a FAILED init. This
+ * also clears per-path failed promises, allowing a later retry.
  */
 export declare function shutdownBridge(): Promise<void>;
 /**
@@ -589,15 +592,7 @@ export declare function bridgeHierarchicalRecall(params: {
     topK?: number;
     includeExpired?: boolean;
 }): Promise<any>;
-/**
- * Run memory consolidation.
- *
- * Real MemoryConsolidation API (agentdb alpha.10+):
- *   consolidate() → Promise<ConsolidationReport>
- *   ConsolidationReport = { episodicProcessed, semanticCreated, memoriesForgotten, ... }
- * Stub API (fallback):
- *   consolidate() → { promoted, pruned, timestamp }
- */
+/** Run consolidation when a real controller is available. */
 export declare function bridgeConsolidate(params: {
     minAge?: number;
     maxEntries?: number;
@@ -612,10 +607,6 @@ export declare function bridgeBatchOperation(params: {
     operation: string;
     entries: any[];
 }): Promise<any>;
-/**
- * Synthesize context from memories.
- * ContextSynthesizer.synthesize is a static method that takes MemoryPattern[] (not a string).
- */
 export declare function bridgeContextSynthesize(params: {
     query: string;
     maxEntries?: number;