@soleri/core 9.2.0 → 9.3.1

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

@@ -0,0 +1,144 @@
+/**
+ * Colocated contract tests for branching-ops.ts.
+ * Tests the 5 vault branching ops extracted from vault-facade.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createBranchingOps } from './branching-ops.js';
+import { captureOps, executeOp } from '../engine/test-helpers.js';
+import type { CapturedOp } from '../engine/test-helpers.js';
+import type { AgentRuntime } from './types.js';
+
+function makeMockVaultBranching() {
+  return {
+    branch: vi.fn(),
+    addOperation: vi.fn(),
+    listBranches: vi.fn().mockReturnValue([{ name: 'experiment', ops: 3 }]),
+    merge: vi.fn().mockReturnValue({ merged: true, applied: 3 }),
+    deleteBranch: vi.fn().mockReturnValue(true),
+  };
+}
+
+function makeRuntime(): AgentRuntime {
+  return {
+    vaultBranching: makeMockVaultBranching(),
+    config: { agentId: 'test-agent' },
+  } as unknown as AgentRuntime;
+}
+
+describe('branching-ops', () => {
+  let runtime: AgentRuntime;
+  let ops: Map<string, CapturedOp>;
+
+  beforeEach(() => {
+    runtime = makeRuntime();
+    ops = captureOps(createBranchingOps(runtime));
+  });
+
+  it('registers all 5 branching ops', () => {
+    expect(ops.size).toBe(5);
+    expect(ops.has('vault_branch')).toBe(true);
+    expect(ops.has('vault_branch_add')).toBe(true);
+    expect(ops.has('vault_branch_list')).toBe(true);
+    expect(ops.has('vault_merge_branch')).toBe(true);
+    expect(ops.has('vault_delete_branch')).toBe(true);
+  });
+
+  it('has correct auth levels', () => {
+    expect(ops.get('vault_branch')!.auth).toBe('write');
+    expect(ops.get('vault_branch_add')!.auth).toBe('write');
+    expect(ops.get('vault_branch_list')!.auth).toBe('read');
+    expect(ops.get('vault_merge_branch')!.auth).toBe('admin');
+    expect(ops.get('vault_delete_branch')!.auth).toBe('admin');
+  });
+
+  describe('vault_branch', () => {
+    it('creates a branch', async () => {
+      const result = await executeOp(ops, 'vault_branch', { name: 'experiment' });
+      expect(result.success).toBe(true);
+      const data = result.data as { created: boolean; name: string };
+      expect(data.created).toBe(true);
+      expect(data.name).toBe('experiment');
+    });
+
+    it('returns error on duplicate branch', async () => {
+      const vb = runtime.vaultBranching as ReturnType<typeof makeMockVaultBranching>;
+      vb.branch.mockImplementation(() => {
+        throw new Error('Branch already exists');
+      });
+      const result = await executeOp(ops, 'vault_branch', { name: 'dup' });
+      expect(result.success).toBe(true);
+      const data = result.data as { error: string };
+      expect(data.error).toBe('Branch already exists');
+    });
+  });
+
+  describe('vault_branch_add', () => {
+    it('adds an operation to a branch', async () => {
+      const result = await executeOp(ops, 'vault_branch_add', {
+        branchName: 'exp',
+        entryId: 'e1',
+        action: 'add',
+        entryData: { id: 'e1', title: 'New', type: 'pattern', domain: 'test' },
+      });
+      expect(result.success).toBe(true);
+      const data = result.data as { added: boolean; action: string };
+      expect(data.added).toBe(true);
+      expect(data.action).toBe('add');
+    });
+
+    it('returns error on invalid branch', async () => {
+      const vb = runtime.vaultBranching as ReturnType<typeof makeMockVaultBranching>;
+      vb.addOperation.mockImplementation(() => {
+        throw new Error('Branch not found');
+      });
+      const result = await executeOp(ops, 'vault_branch_add', {
+        branchName: 'missing',
+        entryId: 'e1',
+        action: 'remove',
+      });
+      expect(result.success).toBe(true);
+      expect((result.data as { error: string }).error).toBe('Branch not found');
+    });
+  });
+
+  describe('vault_branch_list', () => {
+    it('lists all branches', async () => {
+      const result = await executeOp(ops, 'vault_branch_list', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { branches: Array<{ name: string }> };
+      expect(data.branches).toHaveLength(1);
+      expect(data.branches[0].name).toBe('experiment');
+    });
+  });
+
+  describe('vault_merge_branch', () => {
+    it('merges a branch', async () => {
+      const result = await executeOp(ops, 'vault_merge_branch', { branchName: 'experiment' });
+      expect(result.success).toBe(true);
+      const data = result.data as { merged: boolean; applied: number };
+      expect(data.merged).toBe(true);
+      expect(data.applied).toBe(3);
+    });
+
+    it('returns error on merge failure', async () => {
+      const vb = runtime.vaultBranching as ReturnType<typeof makeMockVaultBranching>;
+      vb.merge.mockImplementation(() => {
+        throw new Error('Conflict detected');
+      });
+      const result = await executeOp(ops, 'vault_merge_branch', { branchName: 'conflict' });
+      expect(result.success).toBe(true);
+      expect((result.data as { error: string }).error).toBe('Conflict detected');
+    });
+  });
+
+  describe('vault_delete_branch', () => {
+    it('deletes a branch', async () => {
+      const result = await executeOp(ops, 'vault_delete_branch', { branchName: 'experiment' });
+      expect(result.success).toBe(true);
+      const data = result.data as { deleted: boolean; branchName: string };
+      expect(data.deleted).toBe(true);
+      expect(data.branchName).toBe('experiment');
+    });
+  });
+});

package/src/runtime/branching-ops.ts

@@ -0,0 +1,107 @@
+/**
+ * Branching Ops — vault branch lifecycle operations.
+ *
+ * Covers:
+ * - Create named branches for experimentation
+ * - Add operations (add/modify/remove) to branches
+ * - List, merge, and delete branches
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+import type { AgentRuntime } from './types.js';
+
+export function createBranchingOps(runtime: AgentRuntime): OpDefinition[] {
+  return [
+    {
+      name: 'vault_branch',
+      description:
+        'Create a named vault branch for experimentation. Changes can be reviewed and merged later.',
+      auth: 'write',
+      schema: z.object({
+        name: z.string().describe('Unique branch name'),
+      }),
+      handler: async (params) => {
+        const { vaultBranching } = runtime;
+        try {
+          vaultBranching.branch(params.name as string);
+          return { created: true, name: params.name };
+        } catch (err) {
+          return { error: (err as Error).message };
+        }
+      },
+    },
+    {
+      name: 'vault_branch_add',
+      description: 'Add an operation (add/modify/remove) to a vault branch.',
+      auth: 'write',
+      schema: z.object({
+        branchName: z.string().describe('Branch to add the operation to'),
+        entryId: z.string().describe('Entry ID'),
+        action: z.enum(['add', 'modify', 'remove']).describe('Operation type'),
+        entryData: z
+          .record(z.unknown())
+          .optional()
+          .describe('Full entry data (required for add/modify)'),
+      }),
+      handler: async (params) => {
+        const { vaultBranching } = runtime;
+        try {
+          vaultBranching.addOperation(
+            params.branchName as string,
+            params.entryId as string,
+            params.action as 'add' | 'modify' | 'remove',
+            params.entryData as IntelligenceEntry | undefined,
+          );
+          return {
+            added: true,
+            branchName: params.branchName,
+            entryId: params.entryId,
+            action: params.action,
+          };
+        } catch (err) {
+          return { error: (err as Error).message };
+        }
+      },
+    },
+    {
+      name: 'vault_branch_list',
+      description: 'List all vault branches with entry counts and merge status.',
+      auth: 'read',
+      handler: async () => {
+        const { vaultBranching } = runtime;
+        return { branches: vaultBranching.listBranches() };
+      },
+    },
+    {
+      name: 'vault_merge_branch',
+      description: 'Merge a branch into the main vault. Branch entries win on conflict.',
+      auth: 'admin',
+      schema: z.object({
+        branchName: z.string().describe('Branch to merge'),
+      }),
+      handler: async (params) => {
+        const { vaultBranching } = runtime;
+        try {
+          return vaultBranching.merge(params.branchName as string);
+        } catch (err) {
+          return { error: (err as Error).message };
+        }
+      },
+    },
+    {
+      name: 'vault_delete_branch',
+      description: 'Delete a vault branch and all its operations.',
+      auth: 'admin',
+      schema: z.object({
+        branchName: z.string().describe('Branch to delete'),
+      }),
+      handler: async (params) => {
+        const { vaultBranching } = runtime;
+        const deleted = vaultBranching.deleteBranch(params.branchName as string);
+        return { deleted, branchName: params.branchName };
+      },
+    },
+  ];
+}

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

@@ -36,9 +36,7 @@ function createMockRuntime(): AgentRuntime {
         blocked: false,
         entry: { id: 'captured-1' },
       })),
-      intelligentSearch: vi.fn(async () => [
-        { id: 'r1', title: 'Result 1', score: 0.8 },
-      ]),
+      intelligentSearch: vi.fn(async () => [{ id: 'r1', title: 'Result 1', score: 0.8 }]),
       recordFeedback: vi.fn(),
     },
     governance: {
@@ -113,9 +111,7 @@ describe('createCaptureOps', () => {
     it('uses manual tier override when provided', async () => {
       const result = (await findOp(ops, 'capture_knowledge').handler({
         tier: 'team',
-        entries: [
-          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
-        ],
+        entries: [{ type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] }],
       })) as Record<string, unknown>;
       expect(result.captured).toBe(1);
       const results = result.results as Array<Record<string, unknown>>;
@@ -129,9 +125,7 @@ describe('createCaptureOps', () => {
         reason: 'Requires review',
       } as unknown);
       const result = (await findOp(ops, 'capture_knowledge').handler({
-        entries: [
-          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
-        ],
+        entries: [{ type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] }],
       })) as Record<string, unknown>;
       expect(result.proposed).toBe(1);
       expect(result.captured).toBe(0);
@@ -144,9 +138,7 @@ describe('createCaptureOps', () => {
         reason: 'Not allowed',
       } as unknown);
       const result = (await findOp(ops, 'capture_knowledge').handler({
-        entries: [
-          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
-        ],
+        entries: [{ type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] }],
       })) as Record<string, unknown>;
       expect(result.rejected).toBe(1);
     });
@@ -157,9 +149,7 @@ describe('createCaptureOps', () => {
         duplicate: { id: 'existing-1' },
       } as unknown);
       const result = (await findOp(ops, 'capture_knowledge').handler({
-        entries: [
-          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
-        ],
+        entries: [{ type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] }],
       })) as Record<string, unknown>;
       expect(result.duplicated).toBe(1);
       expect(result.captured).toBe(0);
@@ -170,9 +160,7 @@ describe('createCaptureOps', () => {
         throw new Error('Capture failed');
       });
       const result = (await findOp(ops, 'capture_knowledge').handler({
-        entries: [
-          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
-        ],
+        entries: [{ type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] }],
       })) as Record<string, unknown>;
       expect(result.rejected).toBe(1);
       const results = result.results as Array<Record<string, unknown>>;
@@ -185,9 +173,7 @@ describe('createCaptureOps', () => {
         { entryId: 'related-1', title: 'Related', suggestedType: 'related', score: 0.9 },
       ]);
       const result = (await findOp(ops, 'capture_knowledge').handler({
-        entries: [
-          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
-        ],
+        entries: [{ type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] }],
       })) as Record<string, unknown>;
       expect(result.autoLinkedCount).toBe(1);
       expect(result.suggestedLinks).toBeDefined();

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

@@ -95,7 +95,11 @@ describe('createChainOps', () => {
       const rt = mockRuntime();
       const ops = captureOps(createChainOps(rt));
       await ops.get('chain_resume')!.handler({ instanceId: 'inst-1', chain: VALID_CHAIN });
-      expect(rt.chainRunner.resume).toHaveBeenCalledWith('inst-1', VALID_CHAIN, expect.any(Function));
+      expect(rt.chainRunner.resume).toHaveBeenCalledWith(
+        'inst-1',
+        VALID_CHAIN,
+        expect.any(Function),
+      );
     });
   });
 
@@ -113,7 +117,11 @@ describe('createChainOps', () => {
       const rt = mockRuntime();
       const ops = captureOps(createChainOps(rt));
       await ops.get('chain_step_approve')!.handler({ instanceId: 'inst-1', chain: VALID_CHAIN });
-      expect(rt.chainRunner.approve).toHaveBeenCalledWith('inst-1', VALID_CHAIN, expect.any(Function));
+      expect(rt.chainRunner.approve).toHaveBeenCalledWith(
+        'inst-1',
+        VALID_CHAIN,
+        expect.any(Function),
+      );
     });
   });
 
@@ -138,10 +146,12 @@ describe('createChainOps', () => {
       (ops as typeof ops & { _setAllOps: (o: typeof fakeOps) => void })._setAllOps(fakeOps);
 
       // Execute chain — the dispatch should be able to find 'some_op'
-      await ops.find((o) => o.name === 'chain_execute')!.handler({
-        chain: VALID_CHAIN,
-        input: {},
-      });
+      await ops
+        .find((o) => o.name === 'chain_execute')!
+        .handler({
+          chain: VALID_CHAIN,
+          input: {},
+        });
       // The dispatch function was passed to chainRunner.execute; verify it was called
       expect(rt.chainRunner.execute).toHaveBeenCalledOnce();
     });

package/src/runtime/claude-md-helpers.test.ts

@@ -124,9 +124,7 @@ describe('composeIntegrationSection', () => {
   });
 
   it('renders provided facades with up to 5 ops', () => {
-    const facades = [
-      { name: 'mybot_custom', ops: ['a', 'b', 'c', 'd', 'e', 'f'] },
-    ];
+    const facades = [{ name: 'mybot_custom', ops: ['a', 'b', 'c', 'd', 'e', 'f'] }];
     const result = composeIntegrationSection(CONFIG, facades);
     expect(result).toContain('`mybot_custom`');
     expect(result).toContain('`a`');

package/src/runtime/context-health.test.ts

@@ -43,9 +43,7 @@ describe('ContextHealthMonitor', () => {
     expect(status.level).toBe('red');
     expect(status.estimatedFill).toBeGreaterThanOrEqual(0.6);
     expect(status.toolCallCount).toBe(200);
-    expect(status.recommendation).toBe(
-      'Session capture recommended before context degradation.',
-    );
+    expect(status.recommendation).toBe('Session capture recommended before context degradation.');
   });
 
   it('should reset all tracking', () => {

package/src/runtime/context-health.ts

@@ -56,9 +56,7 @@ export class ContextHealthMonitor {
 
   /** Check current context health status. */
   check(): ContextHealthStatus {
-    const estimatedTokens = Math.round(
-      this.totalPayloadSize * OVERHEAD_FACTOR,
-    );
+    const estimatedTokens = Math.round(this.totalPayloadSize * OVERHEAD_FACTOR);
     const estimatedFill = Math.min(estimatedTokens / CONTEXT_WINDOW, 1.0);
     const level = this.classifyLevel(estimatedFill);
 

package/src/runtime/curator-extra-ops.test.ts

@@ -14,7 +14,9 @@ function mockRuntime() {
       recordSnapshot: vi.fn().mockReturnValue({ recorded: true, historyId: 42 }),
       getQueueStats: vi.fn().mockReturnValue({ totalEntries: 5, groomedEntries: 3 }),
       enrichMetadata: vi.fn().mockReturnValue({ enriched: false, changes: [] }),
-      detectContradictionsHybrid: vi.fn().mockResolvedValue({ contradictions: [], method: 'tfidf-only' }),
+      detectContradictionsHybrid: vi
+        .fn()
+        .mockResolvedValue({ contradictions: [], method: 'tfidf-only' }),
       consolidate: vi.fn(),
     },
     jobQueue: {

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

@@ -94,13 +94,13 @@ describe('createDomainFacade', () => {
     it('falls back to vault FTS when brain returns empty', async () => {
       const rt = mockRuntime();
       (rt.brain.intelligentSearch as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-      (rt.vault.search as ReturnType<typeof vi.fn>).mockReturnValue([
-        { entry: { id: 'e1' } },
-      ]);
+      (rt.vault.search as ReturnType<typeof vi.fn>).mockReturnValue([{ entry: { id: 'e1' } }]);
       const facade = createDomainFacade(rt, 'a', 'security');
-      const results = (await facade.ops.find((o) => o.name === 'search')!.handler({
-        query: 'test',
-      })) as unknown[];
+      const results = (await facade.ops
+        .find((o) => o.name === 'search')!
+        .handler({
+          query: 'test',
+        })) as unknown[];
       expect(rt.vault.search).toHaveBeenCalledWith('test', { domain: 'security', limit: 10 });
       expect(results).toHaveLength(1);
     });
@@ -118,9 +118,11 @@ describe('createDomainFacade', () => {
     it('returns error object for missing entry', async () => {
       const rt = mockRuntime();
       const facade = createDomainFacade(rt, 'a', 'testing');
-      const result = (await facade.ops.find((o) => o.name === 'get_entry')!.handler({
-        id: 'missing',
-      })) as { error: string };
+      const result = (await facade.ops
+        .find((o) => o.name === 'get_entry')!
+        .handler({
+          id: 'missing',
+        })) as { error: string };
       expect(result.error).toContain('missing');
     });
   });
@@ -129,14 +131,16 @@ describe('createDomainFacade', () => {
     it('calls brain.enrichAndCapture when governance allows', async () => {
       const rt = mockRuntime();
       const facade = createDomainFacade(rt, 'a', 'security');
-      const result = (await facade.ops.find((o) => o.name === 'capture')!.handler({
-        id: 'new-1',
-        type: 'pattern',
-        title: 'Test',
-        severity: 'warning',
-        description: 'desc',
-        tags: ['x'],
-      })) as { captured: boolean; governance: { action: string } };
+      const result = (await facade.ops
+        .find((o) => o.name === 'capture')!
+        .handler({
+          id: 'new-1',
+          type: 'pattern',
+          title: 'Test',
+          severity: 'warning',
+          description: 'desc',
+          tags: ['x'],
+        })) as { captured: boolean; governance: { action: string } };
       expect(rt.brain.enrichAndCapture).toHaveBeenCalledOnce();
       expect(result.governance.action).toBe('capture');
     });
@@ -148,14 +152,16 @@ describe('createDomainFacade', () => {
         reason: 'needs review',
       });
       const facade = createDomainFacade(rt, 'a', 'security');
-      const result = (await facade.ops.find((o) => o.name === 'capture')!.handler({
-        id: 'p1',
-        type: 'pattern',
-        title: 'Proposed',
-        severity: 'warning',
-        description: 'desc',
-        tags: [],
-      })) as { captured: boolean; governance: { action: string; proposalId: number } };
+      const result = (await facade.ops
+        .find((o) => o.name === 'capture')!
+        .handler({
+          id: 'p1',
+          type: 'pattern',
+          title: 'Proposed',
+          severity: 'warning',
+          description: 'desc',
+          tags: [],
+        })) as { captured: boolean; governance: { action: string; proposalId: number } };
       expect(result.captured).toBe(false);
       expect(result.governance.action).toBe('propose');
       expect(result.governance.proposalId).toBe(1);
@@ -168,14 +174,16 @@ describe('createDomainFacade', () => {
         reason: 'quota exceeded',
       });
       const facade = createDomainFacade(rt, 'a', 'security');
-      const result = (await facade.ops.find((o) => o.name === 'capture')!.handler({
-        id: 'r1',
-        type: 'rule',
-        title: 'Rejected',
-        severity: 'warning',
-        description: 'desc',
-        tags: [],
-      })) as { captured: boolean; governance: { action: string; reason: string } };
+      const result = (await facade.ops
+        .find((o) => o.name === 'capture')!
+        .handler({
+          id: 'r1',
+          type: 'rule',
+          title: 'Rejected',
+          severity: 'warning',
+          description: 'desc',
+          tags: [],
+        })) as { captured: boolean; governance: { action: string; reason: string } };
       expect(result.captured).toBe(false);
       expect(result.governance.action).toBe('reject');
       expect(result.governance.reason).toBe('quota exceeded');
@@ -186,9 +194,11 @@ describe('createDomainFacade', () => {
     it('returns removed status', async () => {
       const rt = mockRuntime();
       const facade = createDomainFacade(rt, 'a', 'testing');
-      const result = (await facade.ops.find((o) => o.name === 'remove')!.handler({
-        id: 'del-1',
-      })) as { removed: boolean; id: string };
+      const result = (await facade.ops
+        .find((o) => o.name === 'remove')!
+        .handler({
+          id: 'del-1',
+        })) as { removed: boolean; id: string };
       expect(result.removed).toBe(true);
       expect(result.id).toBe('del-1');
     });

package/src/runtime/facades/admin-facade.test.ts

@@ -244,10 +244,7 @@ describe('createAdminFacadeOps', () => {
 
   describe('admin_vault_size (from satellite)', () => {
     it('returns in-memory for :memory: vault', async () => {
-      const result = (await findOp(ops, 'admin_vault_size').handler({})) as Record<
-        string,
-        unknown
-      >;
+      const result = (await findOp(ops, 'admin_vault_size').handler({})) as Record<string, unknown>;
       expect(result.path).toBe(':memory:');
       expect(result.sizeHuman).toBe('in-memory');
     });

package/src/runtime/facades/archive-facade.test.ts

@@ -90,9 +90,18 @@ describe('archive-facade', () => {
 
   it('includes all expected op names', () => {
     const expected = [
-      'vault_archive', 'vault_restore', 'vault_optimize', 'vault_backup',
-      'vault_age_report', 'vault_set_temporal', 'vault_find_expiring', 'vault_find_expired',
-      'knowledge_audit', 'knowledge_health', 'knowledge_merge', 'knowledge_reorganize',
+      'vault_archive',
+      'vault_restore',
+      'vault_optimize',
+      'vault_backup',
+      'vault_age_report',
+      'vault_set_temporal',
+      'vault_find_expiring',
+      'vault_find_expired',
+      'knowledge_audit',
+      'knowledge_health',
+      'knowledge_merge',
+      'knowledge_reorganize',
     ];
     for (const name of expected) {
       expect(ops.has(name), `missing op: ${name}`).toBe(true);
@@ -121,7 +130,8 @@ describe('archive-facade', () => {
   describe('vault_archive', () => {
     it('archives old entries', async () => {
       const result = await executeOp(ops, 'vault_archive', {
-        olderThanDays: 90, reason: 'cleanup',
+        olderThanDays: 90,
+        reason: 'cleanup',
       });
       expect(result.success).toBe(true);
       const vault = runtime.vault as ReturnType<typeof makeMockVault>;
@@ -178,7 +188,9 @@ describe('archive-facade', () => {
   describe('vault_set_temporal', () => {
     it('sets temporal fields', async () => {
       const result = await executeOp(ops, 'vault_set_temporal', {
-        id: 'entry-1', validFrom: 1000, validUntil: 2000,
+        id: 'entry-1',
+        validFrom: 1000,
+        validUntil: 2000,
       });
       expect(result.success).toBe(true);
       const data = result.data as { updated: boolean };
@@ -251,7 +263,8 @@ describe('archive-facade', () => {
         .mockReturnValueOnce(makeEntry({ id: 'remove', tags: ['b'] }));
 
       const result = await executeOp(ops, 'knowledge_merge', {
-        keepId: 'keep', removeId: 'remove',
+        keepId: 'keep',
+        removeId: 'remove',
       });
       expect(result.success).toBe(true);
       const data = result.data as { merged: boolean; keptId: string };
@@ -263,7 +276,8 @@ describe('archive-facade', () => {
       const vault = runtime.vault as ReturnType<typeof makeMockVault>;
       vault.get.mockReturnValue(null);
       const result = await executeOp(ops, 'knowledge_merge', {
-        keepId: 'x', removeId: 'y',
+        keepId: 'x',
+        removeId: 'y',
       });
       expect(result.success).toBe(true);
       const data = result.data as { error: string };