@soleri/core 9.2.0 → 9.3.1

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));