@soleri/core 9.0.4 → 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/types.ts

@@ -33,21 +33,23 @@ import type { KnowledgeSynthesizer } from '../brain/knowledge-synthesizer.js';
 import type { ChainRunner } from '../flows/chain-runner.js';
 import type { JobQueue } from '../queue/job-queue.js';
 import type { PipelineRunner } from '../queue/pipeline-runner.js';
+import type { OperatorProfileStore } from '../operator/operator-profile.js';
+import type { ContextHealthMonitor } from './context-health.js';
 
 /**
  * Configuration for creating an agent runtime.
  * Only `agentId` is required — everything else has sensible defaults.
  */
 export interface AgentRuntimeConfig {
-  /** Agent identifier (kebab-case), e.g. 'my-agent'. Used for paths: ~/.{agentId}/ */
+  /** Agent identifier (kebab-case), e.g. 'my-agent'. Used for paths: ~/.soleri/{agentId}/ */
   agentId: string;
-  /** Path to vault database. Default: ~/.{agentId}/vault.db */
+  /** Path to vault database. Default: ~/.soleri/{agentId}/vault.db */
   vaultPath?: string;
-  /** Path to plans JSON store. Default: ~/.{agentId}/plans.json */
+  /** Path to plans JSON store. Default: ~/.soleri/{agentId}/plans.json */
   plansPath?: string;
   /** Intelligence data directory to seed vault from. Optional. */
   dataDir?: string;
-  /** Path to prompt templates directory. Default: ~/.{agentId}/templates */
+  /** Path to prompt templates directory. Default: ~/.soleri/{agentId}/templates */
   templatesDir?: string;
   /** Minimum log level. Default: 'info' (or SOLERI_LOG_LEVEL env var). */
   logLevel?: LogLevel;
@@ -117,10 +119,14 @@ export interface AgentRuntime {
   jobQueue: JobQueue;
   /** Pipeline runner — background polling loop for job execution. */
   pipelineRunner: PipelineRunner;
+  /** Operator profile — personality learning, signals, adaptation. */
+  operatorProfile: OperatorProfileStore;
   /** Agent persona — defines character, voice, and cultural texture. */
   persona: import('../persona/types.js').PersonaConfig;
   /** Generated persona system instructions for LLM context. */
   personaInstructions: import('../persona/types.js').PersonaSystemInstructions;
+  /** Context health monitor — tracks tool call volume and context window fill. */
+  contextHealth: ContextHealthMonitor;
   /** Timestamp (ms since epoch) when this runtime was created. */
   createdAt: number;
   /** Close the vault database connection. Call on shutdown. */

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

@@ -0,0 +1,270 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createVaultExtraOps } from './vault-extra-ops.js';
+import type { AgentRuntime } from './types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+// ─── Mock content-hash module ─────────────────────────────────────────
+
+vi.mock('../vault/content-hash.js', () => ({
+  computeContentHash: vi.fn(() => 'abc123hash'),
+}));
+
+// ─── Mock Runtime Factory ──────────────────────────────────────────────
+
+function makeEntry(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'entry-1',
+    type: 'pattern',
+    domain: 'testing',
+    title: 'Test Pattern',
+    severity: 'suggestion',
+    description: 'A test pattern',
+    tags: ['test'],
+    context: undefined,
+    example: undefined,
+    counterExample: undefined,
+    why: undefined,
+    appliesTo: undefined,
+    ...overrides,
+  };
+}
+
+function createMockRuntime(): AgentRuntime {
+  return {
+    vault: {
+      get: vi.fn((id: string) => (id === 'entry-1' ? makeEntry() : null)),
+      add: vi.fn(),
+      update: vi.fn((id: string) => (id === 'entry-1' ? makeEntry() : null)),
+      remove: vi.fn(() => true),
+      list: vi.fn(() => [makeEntry()]),
+      seed: vi.fn((entries: unknown[]) => entries.length),
+      bulkRemove: vi.fn((ids: string[]) => ids.length),
+      stats: vi.fn(() => ({ totalEntries: 10, byDomain: { testing: 5 } })),
+      getTags: vi.fn(() => [
+        { tag: 'test', count: 5 },
+        { tag: 'design', count: 3 },
+      ]),
+      getDomains: vi.fn(() => [
+        { domain: 'testing', count: 5 },
+        { domain: 'design', count: 3 },
+      ]),
+      getRecent: vi.fn((_limit: number) => [makeEntry()]),
+      exportAll: vi.fn(() => ({ entries: [makeEntry()], exportedAt: Date.now() })),
+      findByContentHash: vi.fn(() => null),
+      contentHashStats: vi.fn(() => ({
+        total: 10,
+        hashed: 9,
+        uniqueHashes: 8,
+      })),
+    },
+  } as unknown as AgentRuntime;
+}
+
+function findOp(ops: OpDefinition[], name: string): OpDefinition {
+  const op = ops.find((o) => o.name === name);
+  if (!op) throw new Error(`Op not found: ${name}`);
+  return op;
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────
+
+describe('createVaultExtraOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+
+  beforeEach(() => {
+    runtime = createMockRuntime();
+    ops = createVaultExtraOps(runtime);
+  });
+
+  it('returns 13 ops', () => {
+    expect(ops).toHaveLength(13);
+  });
+
+  it('all ops have required fields', () => {
+    for (const op of ops) {
+      expect(op.name).toBeTruthy();
+      expect(op.handler).toBeDefined();
+      expect(['read', 'write', 'admin']).toContain(op.auth);
+    }
+  });
+
+  describe('vault_get', () => {
+    it('returns entry by ID', async () => {
+      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
+      >;
+      expect(result.error).toContain('not found');
+    });
+  });
+
+  describe('vault_update', () => {
+    it('updates entry fields', async () => {
+      const result = (await findOp(ops, 'vault_update').handler({
+        id: 'entry-1',
+        title: 'Updated Title',
+      })) as Record<string, unknown>;
+      expect(result.updated).toBe(true);
+      expect(runtime.vault.update).toHaveBeenCalledWith('entry-1', { title: 'Updated Title' });
+    });
+
+    it('returns error when no fields provided', async () => {
+      const result = (await findOp(ops, 'vault_update').handler({ id: 'entry-1' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.error).toBe('No fields to update');
+    });
+
+    it('returns error for missing entry', async () => {
+      vi.mocked(runtime.vault.update).mockReturnValue(null as unknown);
+      const result = (await findOp(ops, 'vault_update').handler({
+        id: 'missing',
+        title: 'X',
+      })) as Record<string, unknown>;
+      expect(result.error).toContain('not found');
+    });
+  });
+
+  describe('vault_remove', () => {
+    it('removes entry by ID', async () => {
+      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');
+    });
+  });
+
+  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
+      >;
+      expect(result.added).toBe(2);
+      expect(result.total).toBe(10);
+    });
+  });
+
+  describe('vault_bulk_remove', () => {
+    it('removes multiple entries', async () => {
+      const result = (await findOp(ops, 'vault_bulk_remove').handler({
+        ids: ['a', 'b', 'c'],
+      })) as Record<string, unknown>;
+      expect(result.removed).toBe(3);
+      expect(result.requested).toBe(3);
+    });
+  });
+
+  describe('vault_tags', () => {
+    it('returns all tags with counts', async () => {
+      const result = (await findOp(ops, 'vault_tags').handler({})) as Record<string, unknown>;
+      expect(result.count).toBe(2);
+    });
+  });
+
+  describe('vault_domains', () => {
+    it('returns all domains with counts', async () => {
+      const result = (await findOp(ops, 'vault_domains').handler({})) as Record<string, unknown>;
+      expect(result.count).toBe(2);
+    });
+  });
+
+  describe('vault_recent', () => {
+    it('returns recent entries with default limit', async () => {
+      const result = (await findOp(ops, 'vault_recent').handler({})) as Record<string, unknown>;
+      expect(runtime.vault.getRecent).toHaveBeenCalledWith(20);
+      expect(result.count).toBe(1);
+    });
+
+    it('respects custom limit', async () => {
+      await findOp(ops, 'vault_recent').handler({ limit: 5 });
+      expect(runtime.vault.getRecent).toHaveBeenCalledWith(5);
+    });
+  });
+
+  describe('vault_import', () => {
+    it('imports entries and reports new vs updated', async () => {
+      vi.mocked(runtime.vault.stats)
+        .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
+      >;
+      expect(result.imported).toBe(2);
+      expect(result.newEntries).toBe(2);
+      expect(result.total).toBe(12);
+    });
+  });
+
+  describe('vault_seed', () => {
+    it('seeds entries idempotently', async () => {
+      const entries = [makeEntry()];
+      const result = (await findOp(ops, 'vault_seed').handler({ entries })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.seeded).toBe(1);
+    });
+  });
+
+  describe('vault_seed_canonical', () => {
+    it('returns error for non-existent directory', async () => {
+      const result = (await findOp(ops, 'vault_seed_canonical').handler({
+        directory: '/tmp/nonexistent_dir_xyz',
+      })) as Record<string, unknown>;
+      expect(result.error).toContain('not found');
+    });
+  });
+
+  describe('vault_content_hash', () => {
+    it('computes content hash and checks for duplicates', async () => {
+      const result = (await findOp(ops, 'vault_content_hash').handler({
+        type: 'pattern',
+        domain: 'test',
+        title: 'Test',
+        description: 'A test',
+      })) as Record<string, unknown>;
+      expect(result.hash).toBe('abc123hash');
+      expect(result.duplicate).toBe(false);
+    });
+
+    it('detects duplicate when hash exists', async () => {
+      vi.mocked(runtime.vault.findByContentHash).mockReturnValue('existing-id' as unknown);
+      const result = (await findOp(ops, 'vault_content_hash').handler({
+        type: 'pattern',
+        domain: 'test',
+        title: 'Test',
+        description: 'A test',
+      })) as Record<string, unknown>;
+      expect(result.duplicate).toBe(true);
+      expect(result.existingId).toBe('existing-id');
+    });
+  });
+
+  describe('vault_dedup_status', () => {
+    it('reports dedup statistics with coverage', async () => {
+      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);
+    });
+  });
+});