@soleri/core 9.0.4 → 9.2.0

package/src/runtime/intake-ops.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createIntakeOps } from './intake-ops.js';
+import type { OpDefinition } from '../facades/types.js';
+
+function makeMockPipeline() {
+  return {
+    ingestBook: vi.fn().mockResolvedValue({ jobId: 'j1', chunks: 5 }),
+    processChunks: vi.fn().mockResolvedValue({ processed: 3, stored: 2 }),
+    getJob: vi.fn().mockReturnValue({ id: 'j1', status: 'active' }),
+    getChunks: vi.fn().mockReturnValue([{ id: 'c1' }, { id: 'c2' }]),
+    listJobs: vi.fn().mockReturnValue([{ id: 'j1' }, { id: 'j2' }]),
+    preview: vi.fn().mockResolvedValue({ items: [{ text: 'sample' }] }),
+  };
+}
+
+function makeMockTextIngester() {
+  return {
+    ingestUrl: vi.fn().mockResolvedValue({ ingested: 3, duplicates: 1 }),
+    ingestText: vi.fn().mockResolvedValue({ ingested: 2, duplicates: 0 }),
+    ingestBatch: vi.fn().mockResolvedValue({ total: 4, ingested: 3, duplicates: 1 }),
+  };
+}
+
+describe('createIntakeOps', () => {
+  function findOp(ops: OpDefinition[], name: string): OpDefinition {
+    const op = ops.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  it('returns 7 ops', () => {
+    const ops = createIntakeOps(makeMockPipeline() as never);
+    expect(ops).toHaveLength(7);
+  });
+
+  it('has all expected op names', () => {
+    const ops = createIntakeOps(makeMockPipeline() as never);
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'intake_ingest_book',
+      'intake_process',
+      'intake_status',
+      'intake_preview',
+      'ingest_url',
+      'ingest_text',
+      'ingest_batch',
+    ]);
+  });
+
+  describe('when pipeline is null', () => {
+    it('intake_ingest_book returns error', async () => {
+      const ops = createIntakeOps(null);
+      const result = (await findOp(ops, 'intake_ingest_book').handler({
+        pdfPath: '/test.pdf', title: 'T', domain: 'd',
+      })) as Record<string, unknown>;
+      expect(result.error).toBe('Intake pipeline not configured');
+    });
+
+    it('intake_process returns error', async () => {
+      const ops = createIntakeOps(null);
+      const result = (await findOp(ops, 'intake_process').handler({ jobId: 'j1' })) as Record<string, unknown>;
+      expect(result.error).toBe('Intake pipeline not configured');
+    });
+
+    it('intake_status returns error', async () => {
+      const ops = createIntakeOps(null);
+      const result = (await findOp(ops, 'intake_status').handler({})) as Record<string, unknown>;
+      expect(result.error).toBe('Intake pipeline not configured');
+    });
+
+    it('intake_preview returns error', async () => {
+      const ops = createIntakeOps(null);
+      const result = (await findOp(ops, 'intake_preview').handler({
+        pdfPath: '/x.pdf', title: 'T', domain: 'd', pageStart: 1, pageEnd: 5,
+      })) as Record<string, unknown>;
+      expect(result.error).toBe('Intake pipeline not configured');
+    });
+  });
+
+  describe('when textIngester is null', () => {
+    it('ingest_url returns error', async () => {
+      const ops = createIntakeOps(makeMockPipeline() as never, null);
+      const result = (await findOp(ops, 'ingest_url').handler({ url: 'https://example.com' })) as Record<string, unknown>;
+      expect(result.error).toContain('Text ingester not configured');
+    });
+
+    it('ingest_text returns error', async () => {
+      const ops = createIntakeOps(makeMockPipeline() as never, null);
+      const result = (await findOp(ops, 'ingest_text').handler({
+        text: 'hello', title: 'T',
+      })) as Record<string, unknown>;
+      expect(result.error).toContain('Text ingester not configured');
+    });
+
+    it('ingest_batch returns error', async () => {
+      const ops = createIntakeOps(makeMockPipeline() as never, null);
+      const result = (await findOp(ops, 'ingest_batch').handler({
+        items: [{ text: 'a', title: 'A' }],
+      })) as Record<string, unknown>;
+      expect(result.error).toContain('Text ingester not configured');
+    });
+  });
+
+  describe('intake_ingest_book', () => {
+    it('delegates to pipeline.ingestBook', async () => {
+      const pipeline = makeMockPipeline();
+      const ops = createIntakeOps(pipeline as never);
+      const result = await findOp(ops, 'intake_ingest_book').handler({
+        pdfPath: '/book.pdf', title: 'My Book', domain: 'design', author: 'Author', chunkPageSize: 15, tags: ['tag1'],
+      });
+      expect(pipeline.ingestBook).toHaveBeenCalledWith({
+        pdfPath: '/book.pdf', title: 'My Book', domain: 'design', author: 'Author', chunkPageSize: 15, tags: ['tag1'],
+      });
+      expect(result).toEqual({ jobId: 'j1', chunks: 5 });
+    });
+  });
+
+  describe('intake_process', () => {
+    it('delegates to pipeline.processChunks', async () => {
+      const pipeline = makeMockPipeline();
+      const ops = createIntakeOps(pipeline as never);
+      await findOp(ops, 'intake_process').handler({ jobId: 'j1', count: 3 });
+      expect(pipeline.processChunks).toHaveBeenCalledWith('j1', 3);
+    });
+  });
+
+  describe('intake_status', () => {
+    it('returns job and chunks when jobId provided', async () => {
+      const pipeline = makeMockPipeline();
+      const ops = createIntakeOps(pipeline as never);
+      const result = (await findOp(ops, 'intake_status').handler({ jobId: 'j1' })) as Record<string, unknown>;
+      expect(result.job).toEqual({ id: 'j1', status: 'active' });
+      expect(result.chunks).toHaveLength(2);
+    });
+
+    it('returns error when job not found', async () => {
+      const pipeline = makeMockPipeline();
+      pipeline.getJob.mockReturnValue(null);
+      const ops = createIntakeOps(pipeline as never);
+      const result = (await findOp(ops, 'intake_status').handler({ jobId: 'missing' })) as Record<string, unknown>;
+      expect(result.error).toContain('Job not found');
+    });
+
+    it('lists all jobs when no jobId', async () => {
+      const pipeline = makeMockPipeline();
+      const ops = createIntakeOps(pipeline as never);
+      const result = (await findOp(ops, 'intake_status').handler({})) as Record<string, unknown>;
+      expect(result.jobs).toHaveLength(2);
+    });
+  });
+
+  describe('intake_preview', () => {
+    it('delegates to pipeline.preview', async () => {
+      const pipeline = makeMockPipeline();
+      const ops = createIntakeOps(pipeline as never);
+      await findOp(ops, 'intake_preview').handler({
+        pdfPath: '/x.pdf', title: 'T', domain: 'd', pageStart: 1, pageEnd: 10,
+      });
+      expect(pipeline.preview).toHaveBeenCalledWith(
+        { pdfPath: '/x.pdf', title: 'T', domain: 'd' }, 1, 10,
+      );
+    });
+  });
+
+  describe('ingest_url', () => {
+    it('delegates to textIngester.ingestUrl', async () => {
+      const ingester = makeMockTextIngester();
+      const ops = createIntakeOps(makeMockPipeline() as never, ingester as never);
+      const result = await findOp(ops, 'ingest_url').handler({
+        url: 'https://example.com', domain: 'test', tags: ['t1'],
+      });
+      expect(ingester.ingestUrl).toHaveBeenCalledWith('https://example.com', { domain: 'test', tags: ['t1'] });
+      expect(result).toEqual({ ingested: 3, duplicates: 1 });
+    });
+  });
+
+  describe('ingest_text', () => {
+    it('delegates to textIngester.ingestText with source', async () => {
+      const ingester = makeMockTextIngester();
+      const ops = createIntakeOps(makeMockPipeline() as never, ingester as never);
+      await findOp(ops, 'ingest_text').handler({
+        text: 'content', title: 'My Notes', sourceType: 'transcript', url: 'https://x.com', author: 'A', domain: 'd', tags: ['t'],
+      });
+      expect(ingester.ingestText).toHaveBeenCalledWith(
+        'content',
+        { type: 'transcript', title: 'My Notes', url: 'https://x.com', author: 'A' },
+        { domain: 'd', tags: ['t'] },
+      );
+    });
+  });
+
+  describe('ingest_batch', () => {
+    it('delegates to textIngester.ingestBatch', async () => {
+      const ingester = makeMockTextIngester();
+      const ops = createIntakeOps(makeMockPipeline() as never, ingester as never);
+      await findOp(ops, 'ingest_batch').handler({
+        items: [
+          { text: 'a', title: 'A', sourceType: 'article', domain: 'x' },
+          { text: 'b', title: 'B' },
+        ],
+      });
+      expect(ingester.ingestBatch).toHaveBeenCalledWith([
+        { text: 'a', source: { type: 'article', title: 'A', url: undefined, author: undefined }, opts: { domain: 'x', tags: undefined } },
+        { text: 'b', source: { type: 'notes', title: 'B', url: undefined, author: undefined }, opts: { domain: undefined, tags: undefined } },
+      ]);
+    });
+  });
+});

package/src/runtime/loop-ops.test.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createLoopOps } from './loop-ops.js';
+import type { AgentRuntime } from './types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+function makeMockRuntime() {
+  return {
+    loop: {
+      startLoop: vi.fn().mockReturnValue({ id: 'loop-1' }),
+      iterate: vi.fn().mockReturnValue({ iteration: 1, passed: false, validationScore: 70 }),
+      iterateWithGate: vi.fn().mockReturnValue({ decision: 'block', reason: 'continue' }),
+      getStatus: vi.fn().mockReturnValue({
+        id: 'loop-1',
+        config: { mode: 'custom', prompt: 'test' },
+        iterations: [],
+        status: 'active',
+      }),
+      cancelLoop: vi.fn().mockReturnValue({
+        id: 'loop-1',
+        iterations: [{ iteration: 1 }],
+        status: 'cancelled',
+      }),
+      getHistory: vi.fn().mockReturnValue([
+        {
+          id: 'loop-0',
+          config: { mode: 'custom', prompt: 'old' },
+          iterations: [{ iteration: 1 }],
+          status: 'completed',
+          startedAt: '2024-01-01',
+          completedAt: '2024-01-02',
+        },
+      ]),
+      isActive: vi.fn().mockReturnValue(true),
+      completeLoop: vi.fn().mockReturnValue({
+        id: 'loop-1',
+        iterations: [{ iteration: 1 }, { iteration: 2 }],
+        status: 'completed',
+      }),
+    },
+  } as unknown as AgentRuntime;
+}
+
+describe('createLoopOps', () => {
+  let ops: OpDefinition[];
+  let runtime: ReturnType<typeof makeMockRuntime>;
+
+  function findOp(name: string): OpDefinition {
+    const op = ops.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  it('returns 9 ops', () => {
+    runtime = makeMockRuntime();
+    ops = createLoopOps(runtime);
+    expect(ops).toHaveLength(9);
+  });
+
+  it('has all expected op names', () => {
+    runtime = makeMockRuntime();
+    ops = createLoopOps(runtime);
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'loop_start', 'loop_iterate', 'loop_iterate_gate',
+      'loop_status', 'loop_cancel', 'loop_history',
+      'loop_is_active', 'loop_complete', 'loop_anomaly_check',
+    ]);
+  });
+
+  describe('loop_start', () => {
+    it('starts a loop with defaults for custom mode', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_start').handler({
+        mode: 'custom', prompt: 'fix the thing',
+      })) as Record<string, unknown>;
+
+      expect(runtime.loop.startLoop).toHaveBeenCalledWith(
+        expect.objectContaining({ mode: 'custom', prompt: 'fix the thing', maxIterations: 20 }),
+      );
+      expect(result.started).toBe(true);
+      expect(result.loopId).toBe('loop-1');
+      expect(result.maxIterations).toBe(20);
+      expect(result.targetScore).toBeNull();
+    });
+
+    it('uses mode-specific defaults for token-migration', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      await findOp('loop_start').handler({ mode: 'token-migration', prompt: 'migrate' });
+      expect(runtime.loop.startLoop).toHaveBeenCalledWith(
+        expect.objectContaining({ maxIterations: 20, targetScore: 95 }),
+      );
+    });
+
+    it('respects explicit maxIterations override', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      await findOp('loop_start').handler({ mode: 'custom', prompt: 'test', maxIterations: 5 });
+      expect(runtime.loop.startLoop).toHaveBeenCalledWith(
+        expect.objectContaining({ maxIterations: 5 }),
+      );
+    });
+  });
+
+  describe('loop_iterate', () => {
+    it('records iteration and returns status', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_iterate').handler({
+        passed: false, validationScore: 70,
+      })) as Record<string, unknown>;
+
+      expect(result.iteration).toBe(1);
+      expect(result.passed).toBe(false);
+      expect(result.loopActive).toBe(true);
+    });
+  });
+
+  describe('loop_iterate_gate', () => {
+    it('delegates to loop.iterateWithGate', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      const result = await findOp('loop_iterate_gate').handler({
+        lastOutput: 'some output',
+        knowledge: { items: ['learned something'] },
+        durationMs: 5000,
+      });
+      expect(runtime.loop.iterateWithGate).toHaveBeenCalledWith(
+        'some output',
+        { items: ['learned something'] },
+        5000,
+      );
+      expect(result).toEqual({ decision: 'block', reason: 'continue' });
+    });
+  });
+
+  describe('loop_status', () => {
+    it('returns active loop status', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_status').handler({})) as Record<string, unknown>;
+      expect(result.active).toBe(true);
+      expect(result.loop).toBeTruthy();
+    });
+
+    it('returns inactive when no loop', async () => {
+      runtime = makeMockRuntime();
+      (runtime.loop.getStatus as ReturnType<typeof vi.fn>).mockReturnValue(null);
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_status').handler({})) as Record<string, unknown>;
+      expect(result.active).toBe(false);
+      expect(result.loop).toBeNull();
+    });
+  });
+
+  describe('loop_cancel', () => {
+    it('cancels the active loop', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_cancel').handler({})) as Record<string, unknown>;
+      expect(result.cancelled).toBe(true);
+      expect(result.loopId).toBe('loop-1');
+      expect(result.status).toBe('cancelled');
+    });
+  });
+
+  describe('loop_history', () => {
+    it('returns formatted history', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_history').handler({})) as Record<string, unknown>;
+      expect(result.count).toBe(1);
+      const loops = result.loops as Array<Record<string, unknown>>;
+      expect(loops[0].id).toBe('loop-0');
+      expect(loops[0].mode).toBe('custom');
+      expect(loops[0].iterations).toBe(1);
+    });
+  });
+
+  describe('loop_is_active', () => {
+    it('returns active true', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_is_active').handler({})) as Record<string, unknown>;
+      expect(result.active).toBe(true);
+    });
+
+    it('returns active false when no loop', async () => {
+      runtime = makeMockRuntime();
+      (runtime.loop.isActive as ReturnType<typeof vi.fn>).mockReturnValue(false);
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_is_active').handler({})) as Record<string, unknown>;
+      expect(result.active).toBe(false);
+    });
+  });
+
+  describe('loop_complete', () => {
+    it('completes the active loop', async () => {
+      runtime = makeMockRuntime();
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_complete').handler({})) as Record<string, unknown>;
+      expect(result.completed).toBe(true);
+      expect(result.loopId).toBe('loop-1');
+      expect(result.iterations).toBe(2);
+    });
+  });
+
+  describe('loop_anomaly_check', () => {
+    it('returns no anomalies for inactive loop', async () => {
+      runtime = makeMockRuntime();
+      (runtime.loop.getStatus as ReturnType<typeof vi.fn>).mockReturnValue(null);
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_anomaly_check').handler({})) as Record<string, unknown>;
+      expect(result.active).toBe(false);
+      expect(result.summary).toBe('No active loop');
+    });
+
+    it('detects consecutive failures', async () => {
+      runtime = makeMockRuntime();
+      (runtime.loop.getStatus as ReturnType<typeof vi.fn>).mockReturnValue({
+        id: 'loop-1',
+        config: { mode: 'custom', prompt: 'test' },
+        iterations: [
+          { iteration: 1, passed: false, timestamp: '2024-01-01' },
+          { iteration: 2, passed: false, timestamp: '2024-01-01' },
+          { iteration: 3, passed: false, timestamp: '2024-01-01' },
+        ],
+        status: 'active',
+      });
+      ops = createLoopOps(runtime);
+      const result = (await findOp('loop_anomaly_check').handler({})) as Record<string, unknown>;
+      expect(result.active).toBe(true);
+      expect(result.hasAnomalies).toBe(true);
+      expect((result.anomalies as string[]).some((a) => a.includes('consecutive failing'))).toBe(true);
+    });
+  });
+});

package/src/runtime/memory-cross-project-ops.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createMemoryCrossProjectOps } from './memory-cross-project-ops.js';
+import type { AgentRuntime } from './types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+function makeMockRuntime(overrides: Record<string, unknown> = {}) {
+  return {
+    vault: {
+      get: vi.fn().mockReturnValue({ id: 'e1', tags: ['pattern'] }),
+      update: vi.fn(),
+      searchMemories: vi.fn().mockReturnValue([
+        { id: 'm1', content: 'memory 1' },
+      ]),
+      search: vi.fn().mockReturnValue([
+        { entry: { id: 'g1', tags: ['_global'] }, score: 0.9 },
+        { entry: { id: 'g2', tags: ['other'] }, score: 0.8 },
+      ]),
+      ...overrides,
+    },
+    projectRegistry: {
+      getByPath: vi.fn().mockReturnValue({
+        id: 'proj-1',
+        name: 'test-project',
+        path: '/test',
+        metadata: { memoryConfig: { crossProjectEnabled: true, extraPaths: ['/extra'] } },
+      }),
+      register: vi.fn(),
+      getLinkedProjects: vi.fn().mockReturnValue([
+        { project: { path: '/linked', name: 'linked-project' } },
+      ]),
+    },
+  } as unknown as AgentRuntime;
+}
+
+describe('createMemoryCrossProjectOps', () => {
+  let ops: OpDefinition[];
+
+  function findOp(name: string, opList?: OpDefinition[]): OpDefinition {
+    const list = opList ?? ops;
+    const op = list.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  it('returns 3 ops', () => {
+    ops = createMemoryCrossProjectOps(makeMockRuntime());
+    expect(ops).toHaveLength(3);
+  });
+
+  it('has correct op names', () => {
+    ops = createMemoryCrossProjectOps(makeMockRuntime());
+    expect(ops.map((o) => o.name)).toEqual([
+      'memory_promote_to_global',
+      'memory_configure',
+      'memory_cross_project_search',
+    ]);
+  });
+
+  describe('memory_promote_to_global', () => {
+    it('promotes entry by adding _global tag', async () => {
+      const runtime = makeMockRuntime();
+      ops = createMemoryCrossProjectOps(runtime);
+      const result = (await findOp('memory_promote_to_global').handler({ entryId: 'e1' })) as Record<string, unknown>;
+      expect(result.promoted).toBe(true);
+      expect(result.tags).toContain('_global');
+      expect(runtime.vault.update).toHaveBeenCalledWith('e1', { tags: ['pattern', '_global'] });
+    });
+
+    it('returns error when entry not found', async () => {
+      const runtime = makeMockRuntime({ get: vi.fn().mockReturnValue(null) });
+      ops = createMemoryCrossProjectOps(runtime);
+      const result = (await findOp('memory_promote_to_global').handler({ entryId: 'missing' })) as Record<string, unknown>;
+      expect(result.promoted).toBe(false);
+      expect(result.error).toContain('Entry not found');
+    });
+
+    it('skips if already global', async () => {
+      const runtime = makeMockRuntime({
+        get: vi.fn().mockReturnValue({ id: 'e1', tags: ['_global'] }),
+      });
+      ops = createMemoryCrossProjectOps(runtime);
+      const result = (await findOp('memory_promote_to_global').handler({ entryId: 'e1' })) as Record<string, unknown>;
+      expect(result.promoted).toBe(false);
+      expect(result.message).toContain('already promoted');
+    });
+  });
+
+  describe('memory_configure', () => {
+    it('updates memory config for a project', async () => {
+      const runtime = makeMockRuntime();
+      ops = createMemoryCrossProjectOps(runtime);
+      const result = (await findOp('memory_configure').handler({
+        projectPath: '/test',
+        crossProjectEnabled: false,
+        extraPaths: ['/new-path'],
+      })) as Record<string, unknown>;
+
+      expect(result.configured).toBe(true);
+      expect(runtime.projectRegistry.register).toHaveBeenCalled();
+    });
+
+    it('returns error for unregistered project', async () => {
+      const runtime = makeMockRuntime();
+      (runtime.projectRegistry.getByPath as ReturnType<typeof vi.fn>).mockReturnValue(null);
+      ops = createMemoryCrossProjectOps(runtime);
+      const result = (await findOp('memory_configure').handler({
+        projectPath: '/unknown',
+      })) as Record<string, unknown>;
+      expect(result.configured).toBe(false);
+      expect(result.error).toContain('not registered');
+    });
+  });
+
+  describe('memory_cross_project_search', () => {
+    it('returns weighted results from current, global, and linked', async () => {
+      const runtime = makeMockRuntime();
+      ops = createMemoryCrossProjectOps(runtime);
+      const result = (await findOp('memory_cross_project_search').handler({
+        query: 'pattern',
+        projectPath: '/test',
+      })) as Record<string, unknown>;
+
+      expect(result.memories).toBeTruthy();
+      expect(result.globalEntries).toBeTruthy();
+      // Global entries should only include _global tagged ones
+      const globals = result.globalEntries as Array<Record<string, unknown>>;
+      expect(globals).toHaveLength(1);
+      expect((globals[0].entry as Record<string, unknown>).id).toBe('g1');
+    });
+
+    it('searches linked projects and extra paths', async () => {
+      const runtime = makeMockRuntime();
+      ops = createMemoryCrossProjectOps(runtime);
+      await findOp('memory_cross_project_search').handler({
+        query: 'test', projectPath: '/test',
+      });
+
+      // Should search current project, linked project, and extra path
+      const searchCalls = (runtime.vault.searchMemories as ReturnType<typeof vi.fn>).mock.calls;
+      const searchedPaths = searchCalls.map((c: unknown[]) => (c[1] as Record<string, unknown>).projectPath);
+      expect(searchedPaths).toContain('/test');
+      expect(searchedPaths).toContain('/linked');
+      expect(searchedPaths).toContain('/extra');
+    });
+
+    it('deduplicates memories by ID', async () => {
+      const runtime = makeMockRuntime();
+      // Return same memory ID from linked project
+      (runtime.vault.searchMemories as ReturnType<typeof vi.fn>).mockReturnValue([
+        { id: 'm1', content: 'memory 1' },
+      ]);
+      ops = createMemoryCrossProjectOps(runtime);
+      const result = (await findOp('memory_cross_project_search').handler({
+        query: 'test', projectPath: '/test',
+      })) as Record<string, unknown>;
+
+      // linkedMemories should be empty because m1 was already in current results
+      const linked = result.linkedMemories as unknown[];
+      expect(linked).toHaveLength(0);
+    });
+
+    it('skips linked search when cross-project disabled', async () => {
+      const runtime = makeMockRuntime();
+      (runtime.projectRegistry.getByPath as ReturnType<typeof vi.fn>).mockReturnValue({
+        id: 'proj-1', name: 'test', path: '/test',
+        metadata: { memoryConfig: { crossProjectEnabled: false } },
+      });
+      ops = createMemoryCrossProjectOps(runtime);
+      const result = (await findOp('memory_cross_project_search').handler({
+        query: 'test', projectPath: '/test',
+      })) as Record<string, unknown>;
+
+      expect(runtime.projectRegistry.getLinkedProjects).not.toHaveBeenCalled();
+      expect((result.linkedMemories as unknown[]).length).toBe(0);
+    });
+  });
+});