@soleri/core 9.2.0 → 9.3.0

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

@@ -0,0 +1,159 @@
+/**
+ * Colocated contract tests for tier-ops.ts.
+ * Tests the 7 multi-vault tier and named source ops extracted from vault-facade.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createTierOps } from './tier-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 makeMockVaultManager() {
+  return {
+    open: vi.fn(),
+    disconnect: vi.fn().mockReturnValue(true),
+    listTiers: vi.fn().mockReturnValue([{ tier: 'agent', connected: true, entries: 25 }]),
+    search: vi.fn().mockReturnValue([{ id: 'e1', tier: 'agent', score: 0.9 }]),
+    connect: vi.fn(),
+    disconnectNamed: vi.fn().mockReturnValue(true),
+    listConnected: vi.fn().mockReturnValue([{ name: 'team-shared', priority: 0.5 }]),
+  };
+}
+
+function makeRuntime(): AgentRuntime {
+  return {
+    vaultManager: makeMockVaultManager(),
+    config: { agentId: 'test-agent' },
+  } as unknown as AgentRuntime;
+}
+
+describe('tier-ops', () => {
+  let runtime: AgentRuntime;
+  let ops: Map<string, CapturedOp>;
+
+  beforeEach(() => {
+    runtime = makeRuntime();
+    ops = captureOps(createTierOps(runtime));
+  });
+
+  it('registers all 7 tier/source ops', () => {
+    expect(ops.size).toBe(7);
+    expect(ops.has('vault_connect')).toBe(true);
+    expect(ops.has('vault_disconnect')).toBe(true);
+    expect(ops.has('vault_tiers')).toBe(true);
+    expect(ops.has('vault_search_all')).toBe(true);
+    expect(ops.has('vault_connect_source')).toBe(true);
+    expect(ops.has('vault_disconnect_source')).toBe(true);
+    expect(ops.has('vault_list_sources')).toBe(true);
+  });
+
+  it('has correct auth levels', () => {
+    expect(ops.get('vault_connect')!.auth).toBe('admin');
+    expect(ops.get('vault_disconnect')!.auth).toBe('admin');
+    expect(ops.get('vault_tiers')!.auth).toBe('read');
+    expect(ops.get('vault_search_all')!.auth).toBe('read');
+    expect(ops.get('vault_connect_source')!.auth).toBe('admin');
+    expect(ops.get('vault_disconnect_source')!.auth).toBe('admin');
+    expect(ops.get('vault_list_sources')!.auth).toBe('read');
+  });
+
+  // ─── Multi-vault ops ──────────────────────────────────────────────
+
+  describe('vault_connect', () => {
+    it('connects a vault tier', async () => {
+      const result = await executeOp(ops, 'vault_connect', {
+        tier: 'project',
+        path: '/tmp/project.db',
+      });
+      expect(result.success).toBe(true);
+      const data = result.data as { connected: boolean; tier: string; path: string };
+      expect(data.connected).toBe(true);
+      expect(data.tier).toBe('project');
+      expect(data.path).toBe('/tmp/project.db');
+    });
+  });
+
+  describe('vault_disconnect', () => {
+    it('disconnects a vault tier', async () => {
+      const result = await executeOp(ops, 'vault_disconnect', { tier: 'team' });
+      expect(result.success).toBe(true);
+      const data = result.data as { disconnected: boolean; tier: string };
+      expect(data.disconnected).toBe(true);
+      expect(data.tier).toBe('team');
+    });
+  });
+
+  describe('vault_tiers', () => {
+    it('lists vault tiers', async () => {
+      const result = await executeOp(ops, 'vault_tiers', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { tiers: Array<{ tier: string }> };
+      expect(data.tiers).toHaveLength(1);
+      expect(data.tiers[0].tier).toBe('agent');
+    });
+  });
+
+  describe('vault_search_all', () => {
+    it('searches across all tiers', async () => {
+      const result = await executeOp(ops, 'vault_search_all', { query: 'tokens' });
+      expect(result.success).toBe(true);
+      const data = result.data as { results: unknown[]; count: number };
+      expect(data.count).toBe(1);
+      const vm = runtime.vaultManager as ReturnType<typeof makeMockVaultManager>;
+      expect(vm.search).toHaveBeenCalledWith('tokens', 20);
+    });
+
+    it('passes custom limit', async () => {
+      await executeOp(ops, 'vault_search_all', { query: 'test', limit: 5 });
+      const vm = runtime.vaultManager as ReturnType<typeof makeMockVaultManager>;
+      expect(vm.search).toHaveBeenCalledWith('test', 5);
+    });
+  });
+
+  // ─── Named vault connections ───────────────────────────────────────
+
+  describe('vault_connect_source', () => {
+    it('connects with default priority', async () => {
+      const result = await executeOp(ops, 'vault_connect_source', {
+        name: 'team-kb',
+        path: '/tmp/team.db',
+      });
+      expect(result.success).toBe(true);
+      const data = result.data as { connected: boolean; priority: number };
+      expect(data.connected).toBe(true);
+      expect(data.priority).toBe(0.5);
+    });
+
+    it('connects with custom priority', async () => {
+      const result = await executeOp(ops, 'vault_connect_source', {
+        name: 'primary',
+        path: '/tmp/p.db',
+        priority: 1.5,
+      });
+      expect(result.success).toBe(true);
+      const vm = runtime.vaultManager as ReturnType<typeof makeMockVaultManager>;
+      expect(vm.connect).toHaveBeenCalledWith('primary', '/tmp/p.db', 1.5);
+    });
+  });
+
+  describe('vault_disconnect_source', () => {
+    it('disconnects a named source', async () => {
+      const result = await executeOp(ops, 'vault_disconnect_source', { name: 'team-kb' });
+      expect(result.success).toBe(true);
+      const data = result.data as { disconnected: boolean; name: string };
+      expect(data.disconnected).toBe(true);
+      expect(data.name).toBe('team-kb');
+    });
+  });
+
+  describe('vault_list_sources', () => {
+    it('lists connected sources', async () => {
+      const result = await executeOp(ops, 'vault_list_sources', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { sources: Array<{ name: string }> };
+      expect(data.sources).toHaveLength(1);
+      expect(data.sources[0].name).toBe('team-shared');
+    });
+  });
+});

package/src/runtime/tier-ops.ts

@@ -0,0 +1,119 @@
+/**
+ * Tier Ops — multi-vault tier and named source operations.
+ *
+ * Covers:
+ * - Connect/disconnect vault tiers (project, team)
+ * - List tiers with connection status
+ * - Search across all connected tiers
+ * - Named vault source connections with configurable priority
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { VaultTier } from '../vault/vault-types.js';
+import type { AgentRuntime } from './types.js';
+
+export function createTierOps(runtime: AgentRuntime): OpDefinition[] {
+  const { vaultManager } = runtime;
+
+  return [
+    // ─── Multi-vault ops ────────────────────────────────────────
+    {
+      name: 'vault_connect',
+      description:
+        'Connect an additional vault tier (project or team). Opens a separate SQLite database.',
+      auth: 'admin',
+      schema: z.object({
+        tier: z.enum(['project', 'team']).describe('Vault tier to connect'),
+        path: z.string().describe('Path to the SQLite database file'),
+      }),
+      handler: async (params) => {
+        const tier = params.tier as VaultTier;
+        const path = params.path as string;
+        vaultManager.open(tier, path);
+        return { connected: true, tier, path };
+      },
+    },
+    {
+      name: 'vault_disconnect',
+      description: 'Disconnect a vault tier. Cannot disconnect the agent tier.',
+      auth: 'admin',
+      schema: z.object({
+        tier: z.enum(['project', 'team']).describe('Vault tier to disconnect'),
+      }),
+      handler: async (params) => {
+        const tier = params.tier as VaultTier;
+        const removed = vaultManager.disconnect(tier);
+        return { disconnected: removed, tier };
+      },
+    },
+    {
+      name: 'vault_tiers',
+      description: 'List all vault tiers with connection status and entry counts.',
+      auth: 'read',
+      handler: async () => {
+        return { tiers: vaultManager.listTiers() };
+      },
+    },
+    {
+      name: 'vault_search_all',
+      description:
+        'Search across all connected vault tiers with priority-weighted cascading. Agent tier results ranked highest.',
+      auth: 'read',
+      schema: z.object({
+        query: z.string(),
+        limit: z.number().optional(),
+      }),
+      handler: async (params) => {
+        const results = vaultManager.search(params.query as string, (params.limit as number) ?? 20);
+        return { results, count: results.length };
+      },
+    },
+
+    // ─── Named vault connections ────────────────────────────────
+    {
+      name: 'vault_connect_source',
+      description:
+        'Connect a named vault source (e.g., shared team knowledge base) with a configurable search priority.',
+      auth: 'admin',
+      schema: z.object({
+        name: z.string().describe('Unique name for this vault connection'),
+        path: z.string().describe('Path to the SQLite database file'),
+        priority: z
+          .number()
+          .min(0)
+          .max(2)
+          .optional()
+          .describe('Search priority weight (default: 0.5)'),
+      }),
+      handler: async (params) => {
+        const name = params.name as string;
+        const path = params.path as string;
+        const priority = (params.priority as number) ?? 0.5;
+        vaultManager.connect(name, path, priority);
+        return { connected: true, name, path, priority };
+      },
+    },
+    {
+      name: 'vault_disconnect_source',
+      description: 'Disconnect a named vault source.',
+      auth: 'admin',
+      schema: z.object({
+        name: z.string().describe('Name of the vault connection to remove'),
+      }),
+      handler: async (params) => {
+        const name = params.name as string;
+        const removed = vaultManager.disconnectNamed(name);
+        return { disconnected: removed, name };
+      },
+    },
+    {
+      name: 'vault_list_sources',
+      description: 'List all dynamically connected vault sources with their priorities.',
+      auth: 'read',
+      handler: async () => {
+        return { sources: vaultManager.listConnected() };
+      },
+    },
+  ];
+}

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

@@ -91,12 +91,18 @@ describe('createVaultExtraOps', () => {
 
   describe('vault_get', () => {
     it('returns entry by ID', async () => {
-      const result = (await findOp(ops, 'vault_get').handler({ id: 'entry-1' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'vault_get').handler({ id: 'entry-1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.id).toBe('entry-1');
     });
 
     it('returns error for missing entry', async () => {
-      const result = (await findOp(ops, 'vault_get').handler({ id: 'missing' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'vault_get').handler({ id: 'missing' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.error).toContain('not found');
     });
   });
@@ -112,7 +118,10 @@ describe('createVaultExtraOps', () => {
     });
 
     it('returns error when no fields provided', async () => {
-      const result = (await findOp(ops, 'vault_update').handler({ id: 'entry-1' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'vault_update').handler({ id: 'entry-1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.error).toBe('No fields to update');
     });
 
@@ -128,7 +137,10 @@ describe('createVaultExtraOps', () => {
 
   describe('vault_remove', () => {
     it('removes entry by ID', async () => {
-      const result = (await findOp(ops, 'vault_remove').handler({ id: 'entry-1' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'vault_remove').handler({ id: 'entry-1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.removed).toBe(true);
       expect(result.id).toBe('entry-1');
     });
@@ -137,7 +149,10 @@ describe('createVaultExtraOps', () => {
   describe('vault_bulk_add', () => {
     it('seeds multiple entries', async () => {
       const entries = [makeEntry({ id: 'a' }), makeEntry({ id: 'b' })];
-      const result = (await findOp(ops, 'vault_bulk_add').handler({ entries })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'vault_bulk_add').handler({ entries })) as Record<
+        string,
+        unknown
+      >;
       expect(result.added).toBe(2);
       expect(result.total).toBe(10);
     });
@@ -186,7 +201,10 @@ describe('createVaultExtraOps', () => {
         .mockReturnValueOnce({ totalEntries: 10 } as unknown)
         .mockReturnValueOnce({ totalEntries: 12 } as unknown);
       const entries = [makeEntry({ id: 'x' }), makeEntry({ id: 'y' })];
-      const result = (await findOp(ops, 'vault_import').handler({ entries })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'vault_import').handler({ entries })) as Record<
+        string,
+        unknown
+      >;
       expect(result.imported).toBe(2);
       expect(result.newEntries).toBe(2);
       expect(result.total).toBe(12);
@@ -196,7 +214,10 @@ describe('createVaultExtraOps', () => {
   describe('vault_seed', () => {
     it('seeds entries idempotently', async () => {
       const entries = [makeEntry()];
-      const result = (await findOp(ops, 'vault_seed').handler({ entries })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'vault_seed').handler({ entries })) as Record<
+        string,
+        unknown
+      >;
       expect(result.seeded).toBe(1);
     });
   });
@@ -237,7 +258,10 @@ describe('createVaultExtraOps', () => {
 
   describe('vault_dedup_status', () => {
     it('reports dedup statistics with coverage', async () => {
-      const result = (await findOp(ops, 'vault_dedup_status').handler({})) as Record<string, unknown>;
+      const result = (await findOp(ops, 'vault_dedup_status').handler({})) as Record<
+        string,
+        unknown
+      >;
       expect(result.total).toBe(10);
       expect(result.duplicates).toBe(2);
       expect(result.coverage).toBe(90);

package/src/runtime/vault-sharing-ops.test.ts

@@ -83,10 +83,7 @@ describe('createVaultSharingOps', () => {
     it('returns error when entry not found', async () => {
       const op = findOp(ops, 'vault_set_scope');
       vi.mocked(rt.vault.get).mockReturnValue(undefined as never);
-      const result = (await op.handler({ id: 'missing', tier: 'team' })) as Record<
-        string,
-        unknown
-      >;
+      const result = (await op.handler({ id: 'missing', tier: 'team' })) as Record<string, unknown>;
       expect(result.error).toContain('not found');
     });
 

package/src/skills/sync-skills.ts

@@ -6,14 +6,7 @@
  * Called automatically at engine startup and by admin_setup_global.
  */
 
-import {
-  existsSync,
-  readdirSync,
-  readFileSync,
-  writeFileSync,
-  mkdirSync,
-  statSync,
-} from 'node:fs';
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
@@ -68,10 +61,7 @@ function brandSkillContent(content: string, agentName: string): string {
  * - Changed skills are overwritten (compared by mtime)
  * - Missing source skills leave target untouched (other agents may own them)
  */
-export function syncSkillsToClaudeCode(
-  skillsDirs: string[],
-  agentName?: string,
-): SyncResult {
+export function syncSkillsToClaudeCode(skillsDirs: string[], agentName?: string): SyncResult {
   const commandsDir = join(homedir(), '.claude', 'commands');
   const skills = discoverSkills(skillsDirs);
   const result: SyncResult = { installed: [], updated: [], skipped: [], failed: [] };

package/src/transport/ws-server.test.ts

@@ -48,11 +48,11 @@ function encodeTextFrame(text: string, masked = true): Buffer {
   if (len < 126) {
     header = Buffer.alloc(2);
     header[0] = 0x81; // FIN + TEXT
-    header[1] = masked ? (len | 0x80) : len;
+    header[1] = masked ? len | 0x80 : len;
   } else {
     header = Buffer.alloc(4);
     header[0] = 0x81;
-    header[1] = masked ? (126 | 0x80) : 126;
+    header[1] = masked ? 126 | 0x80 : 126;
     header.writeUInt16BE(len, 2);
   }
 
@@ -86,7 +86,8 @@ describe('WsMcpServer', () => {
     const httpServer = (server as unknown).server as Server | undefined;
     if (httpServer) {
       // Force immediate close of all tracked sockets
-      for (const conn of ((server as unknown).connections as Map<string, unknown>)?.values() ?? []) {
+      for (const conn of ((server as unknown).connections as Map<string, unknown>)?.values() ??
+        []) {
         conn.socket?.destroy();
       }
       ((server as unknown).connections as Map<string, unknown>)?.clear();
@@ -160,7 +161,9 @@ describe('WsMcpServer', () => {
       if (!addr || typeof addr === 'string') return;
 
       const wsKey = 'dGhlIHNhbXBsZSBub25jZQ==';
-      const expectedAccept = createHash('sha1').update(wsKey + WS_MAGIC).digest('base64');
+      const expectedAccept = createHash('sha1')
+        .update(wsKey + WS_MAGIC)
+        .digest('base64');
 
       const socket = connect(addr.port, '127.0.0.1');
       await new Promise<void>((resolve) => socket.on('connect', resolve));