Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix(memory): memory_search omitted namespace no longer collapses to empty 'default'

ruvnetfb026a7bb250
diff --git a/v3/@claude-flow/cli/__tests__/memory-search-namespace-default-2646.test.ts b/v3/@claude-flow/cli/__tests__/memory-search-namespace-default-2646.test.ts
new file mode 100644
index 0000000000..9b1083ebdf
--- /dev/null
+++ b/v3/@claude-flow/cli/__tests__/memory-search-namespace-default-2646.test.ts
@@ -0,0 +1,141 @@
+/**
+ * Regression guard for issue #2646 β€” the MCP `memory_search` tool returned
+ * 0 results when the optional `namespace` parameter was omitted, even though
+ * `memory_stats` confirmed entries existed across multiple namespaces with
+ * 100% embedding coverage. Passing any concrete `namespace` returned the
+ * expected hits immediately.
+ *
+ * This is the THIRD occurrence of this exact bug shape (#1123, #1131 β€” both
+ * closed Feb/Mar). Root cause each time: the `memory_search` tool handler in
+ * `mcp-tools/memory-tools.ts` coerces an omitted `namespace` to the literal
+ * string `'default'`:
+ *
+ * const namespace = (input.namespace as string) || 'default';
+ *
+ * But BOTH underlying search implementations β€” `searchEntries()` in
+ * `memory/memory-initializer.ts` and `bridgeSearchEntries()` in
+ * `memory/memory-bridge.ts` β€” already resolve an omitted/undefined namespace
+ * to the `'all'` sentinel (fan out across every namespace):
+ *
+ * const effectiveNamespace = namespace || 'all';
+ *
+ * `'default'` is truthy, so passing it explicitly defeats that fallback and
+ * silently scopes the search to a namespace that is usually empty (the CLI
+ * `memory search` command already gets this right β€” see
+ * `commands/memory.ts`, which defaults to `'all'`, not `'default'`).
+ *
+ * Why prior fixes didn't catch the regression: #1123/#1131 fixed the
+ * *search-layer* default (`searchEntries`/`bridgeSearchEntries`) but nothing
+ * asserted what the `memory_search` MCP *tool handler* actually forwards to
+ * that layer, so a later refactor of `memory-tools.ts` could silently
+ * reintroduce `|| 'default'` at the tool boundary without breaking anything.
+ * This guard asserts the forwarded argument directly, at the tool boundary.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock fs so `ensureInitialized()`'s legacy-migration check (`hasLegacyStore`)
+// is a deterministic no-op regardless of the real cwd.
+vi.mock('fs', () => ({
+ existsSync: vi.fn(() => false),
+ mkdirSync: vi.fn(),
+ readdirSync: vi.fn(() => []),
+ readFileSync: vi.fn(() => '{}'),
+ unlinkSync: vi.fn(),
+ writeFileSync: vi.fn(),
+}));
+
+// Spy on the search layer so we can assert exactly what `memory_search`
+// forwards to it, and simulate the real-world repro: a populated
+// "projetos" namespace alongside an empty "default" one.
+// `vi.hoisted()` is required here: `vi.mock()` factories are hoisted above
+// all other module-level code (including `const` declarations), so a plain
+// `const searchEntries = vi.fn(...)` referenced inside the factory below
+// would throw a temporal-dead-zone error at mock-evaluation time.
+const { searchEntries } = vi.hoisted(() => {
+ const fn = vi.fn(async (opts: { namespace?: string }) => {
+ // Faithful to the real implementations' `namespace || 'all'` semantics β€”
+ // an omitted/undefined namespace (or the explicit 'all' sentinel) must
+ // search across every namespace; anything else scopes to that namespace.
+ const effectiveNamespace = opts.namespace || 'all';
+
+ const allEntries = [
+ { id: 'a1', key: 'note/alpha', content: 'ruflo memory probe', score: 0.9, namespace: 'projetos' },
+ { id: 'a2', key: 'note/beta', content: 'ruflo memory probe', score: 0.8, namespace: 'patterns' },
+ ];
+
+ if (effectiveNamespace === 'all') {
+ return { success: true, results: allEntries, searchTime: 1 };
+ }
+ // The 'default' namespace (and any other namespace with no data) is empty
+ // β€” exactly the failure mode from the issue's memory_stats repro.
+ const scoped = allEntries.filter((e) => e.namespace === effectiveNamespace);
+ return { success: true, results: scoped, searchTime: 1 };
+ });
+ return { searchEntries: fn };
+});
+
+vi.mock('../src/memory/memory-initializer.js', () => ({
+ generateEmbedding: vi.fn(async () => ({ embedding: new Array(384).fill(0.1), dimensions: 384, model: 'mock' })),
+ storeEntry: vi.fn(async () => ({ success: true, id: 'mock-id' })),
+ searchEntries,
+ listEntries: vi.fn(async () => ({ success: true, entries: [], total: 0 })),
+ getEntry: vi.fn(async () => null),
+ deleteEntry: vi.fn(async () => ({ success: true })),
+ getStats: vi.fn(async () => ({ totalEntries: 0 })),
+ initializeDatabase: vi.fn(async () => ({ success: true })),
+ initializeMemoryDatabase: vi.fn(async () => ({ success: true })),
+ checkMemoryInitialization: vi.fn(async () => ({ initialized: true, version: '3.0.0' })),
+ migrateFromLegacy: vi.fn(async () => ({ success: true, migrated: 0 })),
+}));
+
+import { memoryTools } from '../src/mcp-tools/memory-tools.js';
+
+const tool = memoryTools.find((t) => t.name === 'memory_search');
+
+describe('memory_search namespace default (#2646, 3rd occurrence of #1123/#1131)', () => {
+ beforeEach(() => {
+ searchEntries.mockClear();
+ });
+
+ it('exists', () => {
+ expect(tool).toBeDefined();
+ });
+
+ it('schema no longer documents a literal "default" namespace default (the misleading doc from the issue)', () => {
+ const props = (tool!.inputSchema as { properties: Record<string, { description?: string }> }).properties;
+ const desc = props.namespace?.description ?? '';
+ expect(desc).not.toContain('default: "default"');
+ });
+
+ it('omitting namespace forwards namespace=undefined to the search layer, not the literal string "default"', async () => {
+ await tool!.handler({ query: 'test query' });
+ expect(searchEntries).toHaveBeenCalled();
+ const callArgs = searchEntries.mock.calls[0][0] as { namespace?: string };
+ // This is the exact assertion that would have failed against the
+ // regressed code (`namespace = input.namespace || 'default'`).
+ expect(callArgs.namespace).not.toBe('default');
+ expect(callArgs.namespace).toBeUndefined();
+ });
+
+ it('reproduces the issue #2646 repro end-to-end: omitting namespace returns hits from ALL namespaces', async () => {
+ const r = await tool!.handler({ query: 'ruflo memory probe' }) as { results: unknown[]; total: number };
+ // Pre-fix this was `{ results: [], total: 0 }` even though entries existed
+ // in "projetos"/"patterns" β€” exactly the memory_stats-vs-memory_search
+ // mismatch reported in the issue.
+ expect(r.total).toBe(2);
+ expect(r.results.map((e) => (e as { key: string }).key)).toEqual(
+ expect.arrayContaining(['note/alpha', 'note/beta']),
+ );
+ });
+
+ it('an explicit namespace is still forwarded unchanged (back-compat with the issue\'s working case)', async () => {
+ await tool!.handler({ query: 'test', namespace: 'projetos' });
+ const callArgs = searchEntries.mock.calls[0][0] as { namespace?: string };
+ expect(callArgs.namespace).toBe('projetos');
+
+ const r = await tool!.handler({ query: 'test', namespace: 'projetos' }) as { results: unknown[]; total: number };
+ expect(r.total).toBe(1);
+ expect((r.results[0] as { key: string }).key).toBe('note/alpha');
+ });
+});
diff --git a/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts b/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts
index 45c714e35a..2fe20f96d6 100644
--- a/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts
+++ b/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts
@@ -443,7 +443,7 @@ export const memoryTools: MCPTool[] = [
type: 'object',
properties: {
query: { type: 'string', description: 'Search query (semantic similarity)' },
- namespace: { type: 'string', description: 'Namespace to search (default: "default")' },
+ namespace: { type: 'string', description: 'Namespace to search (default: all namespaces β€” omit to search across every namespace)' },
limit: { type: 'number', description: 'Maximum results (default: 10)' },
threshold: { type: 'number', description: 'Minimum similarity threshold 0-1 (default: 0.3)' },
smart: { type: 'boolean', description: 'Enable SmartRetrieval pipeline β€” query expansion, RRF fusion, recency boost, MMR diversity (default: false)' },
@@ -455,11 +455,19 @@ export const memoryTools: MCPTool[] = [
const { searchEntries } = await getMemoryFunctions();
const query = input.query as string;
- const namespace = (input.namespace as string) || 'default';
+ // #2646 (3rd occurrence of #1123/#1131 shape): do NOT coerce an omitted
+ // namespace to the literal string 'default' here. Both searchEntries()
+ // and bridgeSearchEntries() already resolve an omitted/undefined
+ // namespace to 'all' (fan out across every namespace) β€” but 'default'
+ // is truthy, so passing it defeats that fallback and silently scopes
+ // the search to a namespace that is usually empty. Leave namespace
+ // undefined when not provided so the underlying `|| 'all'` fallback
+ // in the search layer actually fires.
+ const namespace = input.namespace as string | undefined;
const limit = (input.limit as number) ?? 10;
const threshold = (input.threshold as number) ?? 0.3;
- validateMemoryInput(undefined, undefined, query);
+ validateMemoryInput(undefined, undefined, query, namespace);
const startTime = performance.now();