🌊 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
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
fix(memory): refresh Claude memories across project and worktree roots (#4210)
Rudy Mizrahi Celeklif4604a0f54be
diff --git a/v3/@claude-flow/cli/__tests__/memory-import-claude-reimport-4197.test.ts b/v3/@claude-flow/cli/__tests__/memory-import-claude-reimport-4197.test.tsnew file mode 100644index 0000000000..82602fd760--- /dev/null+++ b/v3/@claude-flow/cli/__tests__/memory-import-claude-reimport-4197.test.ts@@ -0,0 +1,107 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';+import { tmpdir } from 'node:os';+import { join } from 'node:path';+import { execFileSync } from 'node:child_process';++// Models the real store: without upsert an existing key is rejected.+const layer = vi.hoisted(() => ({ rows: new Map<string, string>() }));+vi.mock('../src/memory/memory-initializer.js', () => ({+ storeEntry: vi.fn(async (o: { key: string; value: string; namespace: string; upsert?: boolean }) => {+ const id = `${o.namespace}/${o.key}`;+ if (layer.rows.has(id) && !o.upsert) return { success: false, id: '', error: `Key already exists: ${o.key}` };+ layer.rows.set(id, o.value);+ return { success: true, id };+ }),+ searchEntries: vi.fn(), listEntries: vi.fn(), getEntry: vi.fn(), deleteEntry: vi.fn(),+ checkMemoryInitialization: vi.fn(async () => ({ initialized: true })),+ initializeMemoryDatabase: vi.fn(async () => ({ success: true })),+ generateEmbedding: vi.fn(async () => ({ backend: 'mock' })),+}));+vi.mock('../src/mcp-tools/validate-input.js', () => ({ validateIdentifier: () => ({ valid: true }) }));++const { memoryTools } = await import('../src/mcp-tools/memory-tools.js');+const importer = memoryTools.find(t => t.name === 'memory_import_claude')!;++let home: string;+let originalHome: string | undefined;+let originalCwd: string;+let originalProject: string | undefined;+const writeMemory = (contents: string) => {+ const memoryDir = join(home, '.claude', 'projects', '-test-project', 'memory');+ mkdirSync(memoryDir, { recursive: true });+ writeFileSync(join(memoryDir, 'MEMORY.md'), contents);+};++beforeEach(() => {+ originalHome = process.env.HOME;+ originalCwd = process.cwd();+ originalProject = process.env.CLAUDE_FLOW_CWD;+ delete process.env.CLAUDE_FLOW_CWD;+ home = mkdtempSync(join(tmpdir(), 'ruflo-claude-reimport-4197-'));+ process.env.HOME = home;+ layer.rows.clear();+});+afterEach(() => {+ process.chdir(originalCwd);+ if (originalProject === undefined) delete process.env.CLAUDE_FLOW_CWD;+ else process.env.CLAUDE_FLOW_CWD = originalProject;+ if (originalHome === undefined) delete process.env.HOME;+ else process.env.HOME = originalHome;+ rmSync(home, { recursive: true, force: true });+});++describe('memory_import_claude re-import (#4197)', () => {+ it('imports the shared main-project memory from a linked Git worktree', async () => {+ const main = join(home, 'main-repo');+ const linked = join(home, 'linked-checkout');+ mkdirSync(main);+ const git = (args: string[]) => execFileSync('git', args, { cwd: main, stdio: 'pipe', timeout: 5000 });+ git(['init']);+ git(['-c', 'user.name=Fixture', '-c', '[email protected]', 'commit', '--allow-empty', '-m', 'fixture']);+ git(['worktree', 'add', '--detach', linked]);+ const slug = realpathSync(main).replace(/\//g, '-');+ const shared = join(home, '.claude', 'projects', slug, 'memory');+ mkdirSync(shared, { recursive: true });+ writeFileSync(join(shared, 'MEMORY.md'), `## Shared workflow\n${'main project memory '.repeat(15)}`);+ process.chdir(linked);+ expect(await importer.handler({})).toMatchObject({ success: true, imported: 1 });+ expect([...layer.rows.values()][0]).toContain('main project memory');+ // A caller-supplied project remains authoritative; do not import unrelated memories.+ layer.rows.clear();+ expect(await importer.handler({ projectPath: '/explicit/unrelated' })).toMatchObject({ success: true, imported: 0 });+ expect(layer.rows.size).toBe(0);+ });++ it('resolves the configured MCP project instead of the server working directory', async () => {+ const project = join(home, 'configured-project');+ mkdirSync(project);+ const slug = project.replace(/\//g, '-');+ const memory = join(home, '.claude', 'projects', slug, 'memory');+ mkdirSync(memory, { recursive: true });+ writeFileSync(join(memory, 'MEMORY.md'), `## Configuration\n${'configured project context '.repeat(15)}`);+ process.env.CLAUDE_FLOW_CWD = project;+ expect(await importer.handler({})).toMatchObject({ success: true, imported: 1 });+ expect([...layer.rows.values()][0]).toContain('configured project context');+ });++ it('imports an already-imported, edited file again instead of failing', async () => {+ writeMemory(`## Workflow\n${'first version of the note '.repeat(10)}`);+ expect(await importer.handler({ projectPath: '/test/project' })).toMatchObject({ success: true, imported: 1, skipped: 0 });++ writeMemory(`## Workflow\n${'edited version of the note '.repeat(10)}`);+ const again = await importer.handler({ projectPath: '/test/project' }) as { success: boolean; imported: number; skipped: number };+ expect(again).toMatchObject({ success: true, imported: 1, skipped: 0 });+ expect([...layer.rows.values()][0]).toContain('edited version');+ });++ it('says why a file was skipped when the store rejects it', async () => {+ writeMemory(`## Workflow\n${'a long memory section '.repeat(20)}`);+ const { storeEntry } = await import('../src/memory/memory-initializer.js');+ (storeEntry as any).mockResolvedValueOnce({ success: false, id: '', error: 'store unavailable' });+ const result = await importer.handler({ projectPath: '/test/project' }) as { success: boolean; skipped: number; errors?: string[] };+ expect(result.success).toBe(false);+ expect(result.skipped).toBe(1);+ expect(result.errors?.[0]).toContain('store unavailable');+ });+});diff --git a/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts b/v3/@claude-flow/cli/src/mcp-tools/memory-tools.tsindex b0bbfbb54d..e2d265f6e9 100644--- a/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts+++ b/v3/@claude-flow/cli/src/mcp-tools/memory-tools.ts@@ -12,9 +12,10 @@import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'fs';import { homedir } from 'os';-import { join, resolve } from 'path';+import { basename, dirname, join, resolve } from 'path';+import { execFileSync } from 'node:child_process';import { createHash } from 'crypto';-import type { MCPTool } from './types.js';+import { getProjectCwd, type MCPTool } from './types.js';import { validateIdentifier } from './validate-input.js';import { DEFAULT_SEARCH_THRESHOLD, nearMisses } from '../memory/search-defaults.js';@@ -175,7 +176,22 @@ function resolveProjectMemoryDir(claudeProjectsDir: string, projectPathOverride?if (projectPathOverride && projectPathOverride.length > 0) {sources.push(projectPathOverride);} else {- sources.push(process.cwd());+ const project = getProjectCwd();+ sources.push(project);+ // Claude Code shares auto-memory across linked Git worktrees under the+ // main checkout's project slug. Preserve the direct-path match first,+ // then try the common Git directory's parent. Explicit overrides above+ // remain authoritative, and non-Git projects need no Git dependency.+ try {+ const commonDir = execFileSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], {+ cwd: project,+ encoding: 'utf-8',+ timeout: 1000,+ windowsHide: true,+ stdio: ['ignore', 'pipe', 'ignore'],+ }).trim();+ if (basename(commonDir) === '.git') sources.push(dirname(resolve(project, commonDir)));+ } catch { /* Git unavailable or not a repository: use the project path */ }}for (const source of sources) {@@ -1161,6 +1177,7 @@ export const memoryTools: MCPTool[] = [let imported = 0;let skipped = 0;+ const importErrors: string[] = [];// #1791.8 — Claude Code's `~/.claude/projects/` accumulates historical// project_id directories (truncated forms, sandbox cwds, renamed// workspaces) that all contain copies of the same memory files. The@@ -1205,7 +1222,7 @@ export const memoryTools: MCPTool[] = [// #1884 — sanitize key so memory_delete can later remove it. Without// this, dangerous chars from frontmatter `name` strand the key.const key = sanitizeMemoryKey(`claude:${memFile.project}:${name}`);- const stored = await storeEntry({ key, value: body, namespace: ns, generateEmbeddingFlag: true });+ const stored = await storeEntry({ key, value: body, namespace: ns, generateEmbeddingFlag: true, upsert: true });if (!stored.success) throw new Error(stored.error || `Failed to store ${key}`);imported++;} else {@@ -1217,13 +1234,17 @@ export const memoryTools: MCPTool[] = [// #1884 — sanitize so any dangerous chars in the heading don't// produce keys memory_delete will reject.const key = sanitizeMemoryKey(`claude:${memFile.project}:${name}:${sectionTitle.slice(0, 50)}`);- const stored = await storeEntry({ key, value: sectionBody, namespace: ns, generateEmbeddingFlag: true });+ const stored = await storeEntry({ key, value: sectionBody, namespace: ns, generateEmbeddingFlag: true, upsert: true });if (!stored.success) throw new Error(stored.error || `Failed to store ${key}`);imported++;}}- } catch {+ } catch (err) {skipped++;+ // Say why a file was skipped instead of returning a bare failure (#4197).+ if (importErrors.length < 5) {+ importErrors.push(`${memFile.path}: ${err instanceof Error ? err.message : String(err)}`);+ }}}@@ -1243,6 +1264,7 @@ export const memoryTools: MCPTool[] = [skipped,duplicatesSkipped,excludedByPattern,+ ...(importErrors.length > 0 ? { errors: importErrors } : {}),files: memoryFiles.length,projects: projects.size,namespace: ns,