@soleri/core 9.2.0 → 9.3.1

package/src/runtime/session-briefing.test.ts

@@ -10,8 +10,19 @@ import type { OperatorProfile } from '../operator/operator-types.js';
 
 function makeRuntime(overrides?: {
   vaultStats?: { totalEntries: number; byType?: Record<string, number> };
-  sessions?: Array<{ endedAt: string | null; domain: string | null; context: string | null; toolsUsed: string[]; filesModified: string[] }>;
-  plans?: Array<{ id: string; status: string; objective?: string; tasks: Array<{ status: string }> }>;
+  sessions?: Array<{
+    endedAt: string | null;
+    domain: string | null;
+    context: string | null;
+    toolsUsed: string[];
+    filesModified: string[];
+  }>;
+  plans?: Array<{
+    id: string;
+    status: string;
+    objective?: string;
+    tasks: Array<{ status: string }>;
+  }>;
   recentEntries?: Array<{ title: string }>;
   recommendations?: Array<{ pattern: string; strength: number }>;
   proposals?: Array<{ title: string; confidence: number; type: string; promoted: boolean }>;
@@ -54,7 +65,11 @@ describe('session-briefing', () => {
       const res = await executeOp(ops, 'session_briefing', {});
 
       expect(res.success).toBe(true);
-      const data = res.data as { sections: Array<{ label: string }>; generatedAt: number; dataPointsConsulted: number };
+      const data = res.data as {
+        sections: Array<{ label: string }>;
+        generatedAt: number;
+        dataPointsConsulted: number;
+      };
       expect(data.generatedAt).toBeGreaterThan(0);
       expect(Array.isArray(data.sections)).toBe(true);
     });
@@ -81,13 +96,15 @@ describe('session-briefing', () => {
 
     it('includes Last session section', async () => {
       const runtime = makeRuntime({
-        sessions: [{
-          endedAt: new Date(Date.now() - 3600000).toISOString(),
-          domain: 'frontend',
-          context: 'Refactored button component',
-          toolsUsed: ['vault_search', 'brain_recommend'],
-          filesModified: ['src/button.tsx'],
-        }],
+        sessions: [
+          {
+            endedAt: new Date(Date.now() - 3600000).toISOString(),
+            domain: 'frontend',
+            context: 'Refactored button component',
+            toolsUsed: ['vault_search', 'brain_recommend'],
+            filesModified: ['src/button.tsx'],
+          },
+        ],
       });
       const ops = captureOps(createSessionBriefingOps(runtime));
       const res = await executeOp(ops, 'session_briefing', {});
@@ -102,7 +119,12 @@ describe('session-briefing', () => {
     it('includes Active plans section', async () => {
       const runtime = makeRuntime({
         plans: [
-          { id: 'p1', status: 'executing', objective: 'Build dashboard', tasks: [{ status: 'completed' }, { status: 'pending' }] },
+          {
+            id: 'p1',
+            status: 'executing',
+            objective: 'Build dashboard',
+            tasks: [{ status: 'completed' }, { status: 'pending' }],
+          },
           { id: 'p2', status: 'completed', objective: 'Done', tasks: [] },
         ],
       });
@@ -110,7 +132,9 @@ describe('session-briefing', () => {
       const res = await executeOp(ops, 'session_briefing', {});
 
       const data = res.data as { sections: Array<{ label: string; content: string }> };
-      const plans = data.sections.find((s) => s.label === 'Active plan' || s.label.startsWith('Active plans'));
+      const plans = data.sections.find(
+        (s) => s.label === 'Active plan' || s.label.startsWith('Active plans'),
+      );
       expect(plans).toBeDefined();
       expect(plans!.content).toContain('Build dashboard');
       expect(plans!.content).toContain('1/2 tasks');
@@ -162,7 +186,15 @@ describe('session-briefing', () => {
     it('respects maxSections limit', async () => {
       const runtime = makeRuntime({
         vaultStats: { totalEntries: 2, byType: {} },
-        sessions: [{ endedAt: new Date().toISOString(), domain: 'd', context: 'c', toolsUsed: ['t'], filesModified: ['f'] }],
+        sessions: [
+          {
+            endedAt: new Date().toISOString(),
+            domain: 'd',
+            context: 'c',
+            toolsUsed: ['t'],
+            filesModified: ['f'],
+          },
+        ],
         plans: [{ id: 'p', status: 'executing', objective: 'o', tasks: [] }],
         recentEntries: [{ title: 't' }],
         recommendations: [{ pattern: 'p', strength: 0.9 }],
@@ -179,17 +211,39 @@ describe('session-briefing', () => {
     it('gracefully handles subsystem errors', async () => {
       const runtime = {
         brainIntelligence: {
-          listSessions: () => { throw new Error('DB closed'); },
-          recommend: () => { throw new Error('DB closed'); },
-          getProposals: () => { throw new Error('DB closed'); },
+          listSessions: () => {
+            throw new Error('DB closed');
+          },
+          recommend: () => {
+            throw new Error('DB closed');
+          },
+          getProposals: () => {
+            throw new Error('DB closed');
+          },
+        },
+        planner: {
+          list: () => {
+            throw new Error('no plans');
+          },
         },
-        planner: { list: () => { throw new Error('no plans'); } },
         vault: {
-          stats: () => { throw new Error('no vault'); },
-          getRecent: () => { throw new Error('no vault'); },
+          stats: () => {
+            throw new Error('no vault');
+          },
+          getRecent: () => {
+            throw new Error('no vault');
+          },
+        },
+        curator: {
+          healthAudit: () => {
+            throw new Error('no curator');
+          },
+        },
+        operatorProfile: {
+          getProfile: () => {
+            throw new Error('no profile');
+          },
         },
-        curator: { healthAudit: () => { throw new Error('no curator'); } },
-        operatorProfile: { getProfile: () => { throw new Error('no profile'); } },
       } as unknown as AgentRuntime;
 
       const ops = captureOps(createSessionBriefingOps(runtime));
@@ -202,7 +256,12 @@ describe('session-briefing', () => {
     it('includes Pending proposals when present', async () => {
       const runtime = makeRuntime({
         proposals: [
-          { title: 'Use TDD for all new features', confidence: 0.8, type: 'pattern', promoted: false },
+          {
+            title: 'Use TDD for all new features',
+            confidence: 0.8,
+            type: 'pattern',
+            promoted: false,
+          },
           { title: 'Low confidence', confidence: 0.2, type: 'anti-pattern', promoted: false },
         ],
       });
@@ -225,13 +284,36 @@ describe('session-briefing', () => {
         operatorId: 'op',
         version: 1,
         identity: { name: null, timezone: null, locale: null, personalDetails: [] },
-        cognition: { learningStyle: 'visual', decisionStyle: 'analytical', abstractionPreference: 0.5, detailOrientation: 0.5, attentionPatterns: [] },
-        communication: { style: 'mixed', formality: 0.5, verbosity: 0.5, preferredFormats: [], reactionPatterns: [] },
+        cognition: {
+          learningStyle: 'visual',
+          decisionStyle: 'analytical',
+          abstractionPreference: 0.5,
+          detailOrientation: 0.5,
+          attentionPatterns: [],
+        },
+        communication: {
+          style: 'mixed',
+          formality: 0.5,
+          verbosity: 0.5,
+          preferredFormats: [],
+          reactionPatterns: [],
+        },
         workingRules: { rules: [], inferredPriorities: [] },
-        trustModel: { level: 'new', currentLevel: 0.5, challengeThreshold: 0.5, autonomyGrants: [], corrections: [] },
+        trustModel: {
+          level: 'new',
+          currentLevel: 0.5,
+          challengeThreshold: 0.5,
+          autonomyGrants: [],
+          corrections: [],
+        },
         tasteProfile: { aestheticPreferences: [], toolPreferences: [], workflowPreferences: [] },
         growthEdges: { observed: [], selfReported: [], progressNotes: [] },
-        technicalContext: { primaryLanguages: [], frameworks: [], expertiseLevels: [], environmentDetails: [] },
+        technicalContext: {
+          primaryLanguages: [],
+          frameworks: [],
+          expertiseLevels: [],
+          environmentDetails: [],
+        },
         sessionCount: 0,
         lastSynthesis: null,
         createdAt: new Date().toISOString(),
@@ -246,56 +328,103 @@ describe('session-briefing', () => {
     });
 
     it('includes communication style when not mixed', () => {
-      const result = buildAdaptationSummary(makeProfile({
-        communication: { style: 'terse', formality: 0.8, verbosity: 0.3, preferredFormats: [], reactionPatterns: [] },
-      }));
+      const result = buildAdaptationSummary(
+        makeProfile({
+          communication: {
+            style: 'terse',
+            formality: 0.8,
+            verbosity: 0.3,
+            preferredFormats: [],
+            reactionPatterns: [],
+          },
+        }),
+      );
       expect(result).toContain('Communication: terse, formal');
     });
 
     it('includes trust level when not new', () => {
-      const result = buildAdaptationSummary(makeProfile({
-        trustModel: { level: 'established', currentLevel: 0.8, challengeThreshold: 0.5, autonomyGrants: [], corrections: [] },
-      }));
+      const result = buildAdaptationSummary(
+        makeProfile({
+          trustModel: {
+            level: 'established',
+            currentLevel: 0.8,
+            challengeThreshold: 0.5,
+            autonomyGrants: [],
+            corrections: [],
+          },
+        }),
+      );
       expect(result).toContain('Trust: established');
       expect(result).toContain('high autonomy');
     });
 
     it('includes working rules as priorities', () => {
-      const result = buildAdaptationSummary(makeProfile({
-        workingRules: {
-          rules: [
-            { rule: 'Always write tests first', source: 'observed', confidence: 0.9, addedAt: '' },
-            { rule: 'Prefer small PRs', source: 'observed', confidence: 0.8, addedAt: '' },
-          ],
-          inferredPriorities: [],
-        },
-      }));
+      const result = buildAdaptationSummary(
+        makeProfile({
+          workingRules: {
+            rules: [
+              {
+                rule: 'Always write tests first',
+                source: 'observed',
+                confidence: 0.9,
+                addedAt: '',
+              },
+              { rule: 'Prefer small PRs', source: 'observed', confidence: 0.8, addedAt: '' },
+            ],
+            inferredPriorities: [],
+          },
+        }),
+      );
       expect(result).toContain('Priorities:');
       expect(result).toContain('Always write tests first');
     });
 
     it('includes growth edges', () => {
-      const result = buildAdaptationSummary(makeProfile({
-        growthEdges: {
-          observed: [{ area: 'TypeScript generics', evidence: 'struggled with mapped types', observedAt: '' }],
-          selfReported: [],
-          progressNotes: [],
-        },
-      }));
+      const result = buildAdaptationSummary(
+        makeProfile({
+          growthEdges: {
+            observed: [
+              {
+                area: 'TypeScript generics',
+                evidence: 'struggled with mapped types',
+                observedAt: '',
+              },
+            ],
+            selfReported: [],
+            progressNotes: [],
+          },
+        }),
+      );
       expect(result).toContain('Growth edges: TypeScript generics');
     });
 
     it('shows casual for low formality', () => {
-      const result = buildAdaptationSummary(makeProfile({
-        communication: { style: 'conversational', formality: 0.2, verbosity: 0.5, preferredFormats: [], reactionPatterns: [] },
-      }));
+      const result = buildAdaptationSummary(
+        makeProfile({
+          communication: {
+            style: 'conversational',
+            formality: 0.2,
+            verbosity: 0.5,
+            preferredFormats: [],
+            reactionPatterns: [],
+          },
+        }),
+      );
       expect(result).toContain('casual');
     });
 
     it('shows check before acting for low trust level', () => {
-      const result = buildAdaptationSummary(makeProfile({
-        trustModel: { level: 'developing', currentLevel: 0.2, challengeThreshold: 0.5, autonomyGrants: [], corrections: [] },
-      }));
+      const result = buildAdaptationSummary(
+        makeProfile({
+          trustModel: {
+            level: 'developing',
+            currentLevel: 0.2,
+            challengeThreshold: 0.5,
+            autonomyGrants: [],
+            corrections: [],
+          },
+        }),
+      );
       expect(result).toContain('check before acting');
     });
   });

package/src/runtime/session-briefing.ts

@@ -215,14 +215,20 @@ export function buildAdaptationSummary(profile: OperatorProfile): string | null
 
   // Communication style
   if (communication.style && communication.style !== 'mixed') {
-    const formality = communication.formality >= 0.7 ? 'formal' : communication.formality <= 0.3 ? 'casual' : '';
+    const formality =
+      communication.formality >= 0.7 ? 'formal' : communication.formality <= 0.3 ? 'casual' : '';
     const parts = [communication.style, formality].filter(Boolean);
     lines.push(`Communication: ${parts.join(', ')}`);
   }
 
   // Challenge threshold / pushback level
   if (trustModel.level !== 'new') {
-    const autonomy = trustModel.currentLevel >= 0.7 ? 'high autonomy' : trustModel.currentLevel <= 0.3 ? 'check before acting' : 'moderate autonomy';
+    const autonomy =
+      trustModel.currentLevel >= 0.7
+        ? 'high autonomy'
+        : trustModel.currentLevel <= 0.3
+          ? 'check before acting'
+          : 'moderate autonomy';
     lines.push(`Trust: ${trustModel.level} — ${autonomy}`);
   }
 

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

@@ -95,10 +95,7 @@ describe('createSyncOps', () => {
   describe('vault_git_push', () => {
     it('initializes sync and pushes entries', async () => {
       const op = findOp(ops, 'vault_git_push');
-      const result = (await op.handler({ repoDir: '/tmp/vault-repo' })) as Record<
-        string,
-        unknown
-      >;
+      const result = (await op.handler({ repoDir: '/tmp/vault-repo' })) as Record<string, unknown>;
       expect(result.pushed).toBe(5);
     });
   });
@@ -108,10 +105,7 @@ describe('createSyncOps', () => {
   describe('vault_git_pull', () => {
     it('pulls entries from git directory', async () => {
       const op = findOp(ops, 'vault_git_pull');
-      const result = (await op.handler({ repoDir: '/tmp/vault-repo' })) as Record<
-        string,
-        unknown
-      >;
+      const result = (await op.handler({ repoDir: '/tmp/vault-repo' })) as Record<string, unknown>;
       expect(result.imported).toBe(3);
     });
   });
@@ -121,10 +115,7 @@ describe('createSyncOps', () => {
   describe('vault_git_sync', () => {
     it('performs bidirectional sync', async () => {
       const op = findOp(ops, 'vault_git_sync');
-      const result = (await op.handler({ repoDir: '/tmp/vault-repo' })) as Record<
-        string,
-        unknown
-      >;
+      const result = (await op.handler({ repoDir: '/tmp/vault-repo' })) as Record<string, unknown>;
       expect(result.pushed).toBe(2);
       expect(result.pulled).toBe(1);
     });

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

@@ -8,8 +8,18 @@ import { createTelemetryOps } from './telemetry-ops.js';
 import type { AgentRuntime } from './types.js';
 
 function makeTelemetryStub(
-  stats: { errorsByOp: Record<string, number>; slowestOps: Array<{ op: string; avgMs: number }>; avgDurationMs: number },
-  recent: Array<{ op: string; facade: string; success: boolean; error?: string; timestamp: number }>,
+  stats: {
+    errorsByOp: Record<string, number>;
+    slowestOps: Array<{ op: string; avgMs: number }>;
+    avgDurationMs: number;
+  },
+  recent: Array<{
+    op: string;
+    facade: string;
+    success: boolean;
+    error?: string;
+    timestamp: number;
+  }>,
 ) {
   return {
     getStats: () => stats,
@@ -28,7 +38,11 @@ describe('telemetry-ops', () => {
       const res = await executeOp(ops, 'telemetry_errors');
 
       expect(res.success).toBe(true);
-      const data = res.data as { errorCount: number; errorsByOp: Record<string, number>; recentErrors: unknown[] };
+      const data = res.data as {
+        errorCount: number;
+        errorsByOp: Record<string, number>;
+        recentErrors: unknown[];
+      };
       expect(data.errorCount).toBe(0);
       expect(data.recentErrors).toEqual([]);
       expect(data.errorsByOp).toEqual({});
@@ -49,7 +63,11 @@ describe('telemetry-ops', () => {
       const res = await executeOp(ops, 'telemetry_errors');
 
       expect(res.success).toBe(true);
-      const data = res.data as { errorCount: number; errorsByOp: Record<string, number>; recentErrors: Array<{ op: string }> };
+      const data = res.data as {
+        errorCount: number;
+        errorsByOp: Record<string, number>;
+        recentErrors: Array<{ op: string }>;
+      };
       expect(data.errorCount).toBe(3);
       expect(data.errorsByOp).toEqual({ vault_search: 2, plan_create: 1 });
       expect(data.recentErrors).toHaveLength(3);
@@ -58,7 +76,11 @@ describe('telemetry-ops', () => {
 
     it('caps recentErrors at 20', async () => {
       const recent = Array.from({ length: 30 }, (_, i) => ({
-        op: `op_${i}`, facade: 'test', success: false, error: 'err', timestamp: i,
+        op: `op_${i}`,
+        facade: 'test',
+        success: false,
+        error: 'err',
+        timestamp: i,
       }));
       const telemetry = makeTelemetryStub(
         { errorsByOp: {}, slowestOps: [], avgDurationMs: 0 },
@@ -90,7 +112,10 @@ describe('telemetry-ops', () => {
       const res = await executeOp(ops, 'telemetry_slow_ops', {});
 
       expect(res.success).toBe(true);
-      const data = res.data as { slowOps: Array<{ op: string; avgMs: number }>; avgDurationMs: number };
+      const data = res.data as {
+        slowOps: Array<{ op: string; avgMs: number }>;
+        avgDurationMs: number;
+      };
       expect(data.slowOps).toHaveLength(2);
       expect(data.slowOps.map((o) => o.op)).toEqual(['vault_search', 'plan_create']);
       expect(data.avgDurationMs).toBe(133);

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');
+    });
+  });
+});