@soleri/core 9.2.0 → 9.3.1

package/src/errors/classify.test.ts

@@ -95,7 +95,9 @@ describe('classifyError', () => {
 
   describe('message pattern classification', () => {
     it('should classify "overloaded" as LLM_OVERLOAD', () => {
-      expect(classifyError(new Error('server is overloaded')).code).toBe(SoleriErrorCode.LLM_OVERLOAD);
+      expect(classifyError(new Error('server is overloaded')).code).toBe(
+        SoleriErrorCode.LLM_OVERLOAD,
+      );
     });
 
     it('should classify "model busy" as LLM_OVERLOAD', () => {
@@ -123,7 +125,9 @@ describe('classifyError', () => {
     });
 
     it('should classify "not found" as RESOURCE_NOT_FOUND', () => {
-      expect(classifyError(new Error('resource not found')).code).toBe(SoleriErrorCode.RESOURCE_NOT_FOUND);
+      expect(classifyError(new Error('resource not found')).code).toBe(
+        SoleriErrorCode.RESOURCE_NOT_FOUND,
+      );
     });
 
     it('should classify "rate limit" as RATE_LIMIT', () => {

package/src/errors/retry.test.ts

@@ -118,10 +118,7 @@ describe('retryWithPreset', () => {
 
   it('should call onRetry callback on each retry', async () => {
     const onRetry = vi.fn();
-    const fn = vi
-      .fn()
-      .mockRejectedValueOnce(new Error('network fail'))
-      .mockResolvedValue('ok');
+    const fn = vi.fn().mockRejectedValueOnce(new Error('network fail')).mockResolvedValue('ok');
 
     const resultPromise = retryWithPreset(fn, 'fast', { onRetry });
     await vi.advanceTimersByTimeAsync(20_000);

package/src/facades/facade-factory.test.ts

@@ -88,12 +88,16 @@ describe('facade-factory dispatchOp — colocated', () => {
 
   it('catches handler exceptions and returns error response', async () => {
     const facade = createFacade({
-      ops: [{
-        name: 'failing_op',
-        description: 'Fails',
-        auth: 'read',
-        handler: async () => { throw new Error('Handler exploded'); },
-      }],
+      ops: [
+        {
+          name: 'failing_op',
+          description: 'Fails',
+          auth: 'read',
+          handler: async () => {
+            throw new Error('Handler exploded');
+          },
+        },
+      ],
     });
     const handler = captureHandler(facade);
 
@@ -105,12 +109,16 @@ describe('facade-factory dispatchOp — colocated', () => {
 
   it('catches non-Error throws and converts to string', async () => {
     const facade = createFacade({
-      ops: [{
-        name: 'string_throw',
-        description: 'Throws string',
-        auth: 'read',
-        handler: async () => { throw 'raw string error'; },
-      }],
+      ops: [
+        {
+          name: 'string_throw',
+          description: 'Throws string',
+          auth: 'read',
+          handler: async () => {
+            throw 'raw string error';
+          },
+        },
+      ],
     });
     const handler = captureHandler(facade);
 
@@ -128,13 +136,15 @@ describe('facade-factory dispatchOp — colocated', () => {
 describe('facade-factory schema validation — colocated', () => {
   it('validates params against op schema and rejects invalid', async () => {
     const facade = createFacade({
-      ops: [{
-        name: 'validated_op',
-        description: 'Has schema',
-        auth: 'read',
-        schema: z.object({ query: z.string(), limit: z.number() }),
-        handler: async (params) => ({ echo: params }),
-      }],
+      ops: [
+        {
+          name: 'validated_op',
+          description: 'Has schema',
+          auth: 'read',
+          schema: z.object({ query: z.string(), limit: z.number() }),
+          handler: async (params) => ({ echo: params }),
+        },
+      ],
     });
     const handler = captureHandler(facade);
 
@@ -146,13 +156,15 @@ describe('facade-factory schema validation — colocated', () => {
 
   it('passes validated params to handler', async () => {
     const facade = createFacade({
-      ops: [{
-        name: 'validated_op',
-        description: 'Has schema',
-        auth: 'read',
-        schema: z.object({ query: z.string(), limit: z.number().optional() }),
-        handler: async (params) => ({ echo: params }),
-      }],
+      ops: [
+        {
+          name: 'validated_op',
+          description: 'Has schema',
+          auth: 'read',
+          schema: z.object({ query: z.string(), limit: z.number().optional() }),
+          handler: async (params) => ({ echo: params }),
+        },
+      ],
     });
     const handler = captureHandler(facade);
 
@@ -164,12 +176,14 @@ describe('facade-factory schema validation — colocated', () => {
 
   it('passes raw params when no schema defined', async () => {
     const facade = createFacade({
-      ops: [{
-        name: 'no_schema',
-        description: 'No schema',
-        auth: 'read',
-        handler: async (params) => ({ echo: params }),
-      }],
+      ops: [
+        {
+          name: 'no_schema',
+          description: 'No schema',
+          auth: 'read',
+          handler: async (params) => ({ echo: params }),
+        },
+      ],
     });
     const handler = captureHandler(facade);
 
@@ -255,7 +269,9 @@ describe('registerAllFacades — colocated', () => {
   it('registers all facades on the server', () => {
     const registered: string[] = [];
     const mockServer = {
-      tool: (name: string) => { registered.push(name); },
+      tool: (name: string) => {
+        registered.push(name);
+      },
     };
 
     registerAllFacades(mockServer as never, [
@@ -270,7 +286,9 @@ describe('registerAllFacades — colocated', () => {
   it('accepts legacy function auth policy', () => {
     const registered: string[] = [];
     const mockServer = {
-      tool: (name: string) => { registered.push(name); },
+      tool: (name: string) => {
+        registered.push(name);
+      },
     };
 
     registerAllFacades(mockServer as never, [createFacade()], () => ({
@@ -284,12 +302,20 @@ describe('registerAllFacades — colocated', () => {
   it('promotes hot ops to standalone tools with agentId prefix', () => {
     const registered: string[] = [];
     const mockServer = {
-      tool: (name: string) => { registered.push(name); },
+      tool: (name: string) => {
+        registered.push(name);
+      },
     };
 
     const facade = createFacade({
       ops: [
-        { name: 'search', description: 'Search', auth: 'read', hot: true, handler: async () => ({}) },
+        {
+          name: 'search',
+          description: 'Search',
+          auth: 'read',
+          hot: true,
+          handler: async () => ({}),
+        },
         { name: 'delete', description: 'Delete', auth: 'admin', handler: async () => ({}) },
       ],
     });
@@ -304,7 +330,9 @@ describe('registerAllFacades — colocated', () => {
   it('promotes ops listed in hotOps option', () => {
     const registered: string[] = [];
     const mockServer = {
-      tool: (name: string) => { registered.push(name); },
+      tool: (name: string) => {
+        registered.push(name);
+      },
     };
 
     registerAllFacades(mockServer as never, [createFacade()], {
@@ -319,12 +347,20 @@ describe('registerAllFacades — colocated', () => {
   it('does not promote hot ops without agentId', () => {
     const registered: string[] = [];
     const mockServer = {
-      tool: (name: string) => { registered.push(name); },
+      tool: (name: string) => {
+        registered.push(name);
+      },
     };
 
     const facade = createFacade({
       ops: [
-        { name: 'search', description: 'Search', auth: 'read', hot: true, handler: async () => ({}) },
+        {
+          name: 'search',
+          description: 'Search',
+          auth: 'read',
+          hot: true,
+          handler: async () => ({}),
+        },
       ],
     });
 
@@ -344,20 +380,24 @@ describe('registerAllFacades — colocated', () => {
     };
 
     const facade = createFacade({
-      ops: [{
-        name: 'search',
-        description: 'Search',
-        auth: 'read',
-        hot: true,
-        schema: z.object({ query: z.string() }),
-        handler: async (params) => ({ results: [], query: (params as { query: string }).query }),
-      }],
+      ops: [
+        {
+          name: 'search',
+          description: 'Search',
+          auth: 'read',
+          hot: true,
+          schema: z.object({ query: z.string() }),
+          handler: async (params) => ({ results: [], query: (params as { query: string }).query }),
+        },
+      ],
     });
 
     registerAllFacades(mockServer as never, [facade], { agentId: 'agent' });
 
     expect(capturedHandler).not.toBeNull();
-    const result = await capturedHandler!({ query: 'hello' }) as { content: Array<{ text: string }> };
+    const result = (await capturedHandler!({ query: 'hello' })) as {
+      content: Array<{ text: string }>;
+    };
     const parsed = JSON.parse(result.content[0].text);
     expect(parsed.success).toBe(true);
     expect(parsed.data.query).toBe('hello');
@@ -374,18 +414,22 @@ describe('registerAllFacades — colocated', () => {
     };
 
     const facade = createFacade({
-      ops: [{
-        name: 'boom',
-        description: 'Explodes',
-        auth: 'read',
-        hot: true,
-        handler: async () => { throw new Error('Kaboom'); },
-      }],
+      ops: [
+        {
+          name: 'boom',
+          description: 'Explodes',
+          auth: 'read',
+          hot: true,
+          handler: async () => {
+            throw new Error('Kaboom');
+          },
+        },
+      ],
     });
 
     registerAllFacades(mockServer as never, [facade], { agentId: 'agent' });
 
-    const result = await capturedHandler!({}) as { content: Array<{ text: string }> };
+    const result = (await capturedHandler!({})) as { content: Array<{ text: string }> };
     const parsed = JSON.parse(result.content[0].text);
     expect(parsed.success).toBe(false);
     expect(parsed.error).toBe('Kaboom');
@@ -402,13 +446,15 @@ describe('registerAllFacades — colocated', () => {
     };
 
     const facade = createFacade({
-      ops: [{
-        name: 'admin_op',
-        description: 'Admin',
-        auth: 'admin',
-        hot: true,
-        handler: async () => ({ ok: true }),
-      }],
+      ops: [
+        {
+          name: 'admin_op',
+          description: 'Admin',
+          auth: 'admin',
+          hot: true,
+          handler: async () => ({ ok: true }),
+        },
+      ],
     });
 
     registerAllFacades(mockServer as never, [facade], {
@@ -416,7 +462,7 @@ describe('registerAllFacades — colocated', () => {
       authPolicy: () => ({ mode: 'enforce', callerLevel: 'read' }),
     });
 
-    const result = await capturedHandler!({}) as { content: Array<{ text: string }> };
+    const result = (await capturedHandler!({})) as { content: Array<{ text: string }> };
     const parsed = JSON.parse(result.content[0].text);
     expect(parsed.success).toBe(false);
     expect(parsed.error).toContain('requires admin');

package/src/flows/epilogue.test.ts

@@ -30,12 +30,15 @@ describe('runEpilogue', () => {
     const dispatch = vi.fn(async () => ({ tool: 'capture_knowledge', status: 'ok', data: {} }));
     const result = await runEpilogue(dispatch, probes({ vault: true }), '/project', 'summary');
 
-    expect(dispatch).toHaveBeenCalledWith('capture_knowledge', expect.objectContaining({
-      title: 'Flow execution summary',
-      content: 'summary',
-      type: 'workflow',
-      projectPath: '/project',
-    }));
+    expect(dispatch).toHaveBeenCalledWith(
+      'capture_knowledge',
+      expect.objectContaining({
+        title: 'Flow execution summary',
+        content: 'summary',
+        type: 'workflow',
+        projectPath: '/project',
+      }),
+    );
     expect(result.captured).toBe(true);
   });
 
@@ -52,10 +55,13 @@ describe('runEpilogue', () => {
       'summary',
     );
 
-    expect(dispatch).toHaveBeenCalledWith('session_capture', expect.objectContaining({
-      summary: 'summary',
-      projectPath: '/project',
-    }));
+    expect(dispatch).toHaveBeenCalledWith(
+      'session_capture',
+      expect.objectContaining({
+        summary: 'summary',
+        projectPath: '/project',
+      }),
+    );
     expect(result.captured).toBe(true);
     expect(result.sessionId).toBe('sess-123');
   });

package/src/flows/gate-evaluator.test.ts

@@ -129,9 +129,12 @@ describe('evaluateGate', () => {
 
   describe('VERIFY type', () => {
     it('passes with verified findings', () => {
-      const verdict = evaluateGate({ type: 'VERIFY' }, {
-        verification: { findings: [{ proven: true }] },
-      });
+      const verdict = evaluateGate(
+        { type: 'VERIFY' },
+        {
+          verification: { findings: [{ proven: true }] },
+        },
+      );
       expect(verdict.passed).toBe(true);
       expect(verdict.action).toBe('CONTINUE');
     });
@@ -144,9 +147,12 @@ describe('evaluateGate', () => {
     });
 
     it('returns advisory when findings exist but none proven', () => {
-      const verdict = evaluateGate({ type: 'VERIFY' }, {
-        verification: { findings: [{ proven: false }] },
-      });
+      const verdict = evaluateGate(
+        { type: 'VERIFY' },
+        {
+          verification: { findings: [{ proven: false }] },
+        },
+      );
       expect(verdict.passed).toBe(true);
       expect(verdict.message).toContain('Advisory');
     });

package/src/flows/gate-evaluator.ts

@@ -175,9 +175,7 @@ export function resolvePath(obj: Record<string, unknown>, path: string): unknown
  * Looks for a verification object with at least one proven finding.
  */
 function evaluateVerifyGate(data: Record<string, unknown>): boolean {
-  const verification = data.verification as
-    | { findings?: Array<{ proven?: boolean }> }
-    | undefined;
+  const verification = data.verification as { findings?: Array<{ proven?: boolean }> } | undefined;
   if (!verification?.findings?.length) return false;
   return verification.findings.some((f) => f.proven === true);
 }

package/src/governance/governance.test.ts

@@ -65,14 +65,25 @@ describe('Governance (colocated)', () => {
 
   describe('setPolicy', () => {
     it('upserts on repeated calls for same project+type', () => {
-      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 100 } as Record<string, unknown>);
-      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 200 } as Record<string, unknown>);
+      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 100 } as Record<
+        string,
+        unknown
+      >);
+      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 200 } as Record<
+        string,
+        unknown
+      >);
       const policy = runtime.governance.getPolicy('/p');
       expect(policy.quotas.maxEntriesTotal).toBe(200);
     });
 
     it('records audit trail with changedBy', () => {
-      runtime.governance.setPolicy('/p', 'retention', { archiveAfterDays: 7 } as Record<string, unknown>, 'admin');
+      runtime.governance.setPolicy(
+        '/p',
+        'retention',
+        { archiveAfterDays: 7 } as Record<string, unknown>,
+        'admin',
+      );
       const trail = runtime.governance.getAuditTrail('/p');
       expect(trail).toHaveLength(1);
       expect(trail[0].changedBy).toBe('admin');
@@ -81,8 +92,14 @@ describe('Governance (colocated)', () => {
     });
 
     it('captures old config on update', () => {
-      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 50 } as Record<string, unknown>);
-      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 100 } as Record<string, unknown>);
+      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 50 } as Record<
+        string,
+        unknown
+      >);
+      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 100 } as Record<
+        string,
+        unknown
+      >);
       const trail = runtime.governance.getAuditTrail('/p');
       const update = trail.find((t) => t.oldConfig !== null);
       expect(update).toBeDefined();
@@ -124,7 +141,9 @@ describe('Governance (colocated)', () => {
     });
 
     it('throws on unknown preset', () => {
-      expect(() => runtime.governance.applyPreset('/p', 'nonexistent' as never)).toThrow('Unknown preset');
+      expect(() => runtime.governance.applyPreset('/p', 'nonexistent' as never)).toThrow(
+        'Unknown preset',
+      );
     });
 
     it('creates audit trail entries for all 3 policy types', () => {
@@ -151,9 +170,33 @@ describe('Governance (colocated)', () => {
 
     it('counts entries by category and type', () => {
       runtime.vault.seed([
-        { id: 'e1', type: 'pattern', domain: 'testing', title: 'T1', severity: 'warning', description: 'D1', tags: [] },
-        { id: 'e2', type: 'rule', domain: 'testing', title: 'T2', severity: 'warning', description: 'D2', tags: [] },
-        { id: 'e3', type: 'pattern', domain: 'styling', title: 'T3', severity: 'warning', description: 'D3', tags: [] },
+        {
+          id: 'e1',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'T1',
+          severity: 'warning',
+          description: 'D1',
+          tags: [],
+        },
+        {
+          id: 'e2',
+          type: 'rule',
+          domain: 'testing',
+          title: 'T2',
+          severity: 'warning',
+          description: 'D2',
+          tags: [],
+        },
+        {
+          id: 'e3',
+          type: 'pattern',
+          domain: 'styling',
+          title: 'T3',
+          severity: 'warning',
+          description: 'D3',
+          tags: [],
+        },
       ]);
       const status = runtime.governance.getQuotaStatus('/p');
       expect(status.total).toBe(3);
@@ -193,7 +236,15 @@ describe('Governance (colocated)', () => {
         warnAtPercent: 80,
       });
       runtime.vault.seed([
-        { id: 'x1', type: 'pattern', domain: 'a', title: 'T', severity: 'warning', description: 'D', tags: [] },
+        {
+          id: 'x1',
+          type: 'pattern',
+          domain: 'a',
+          title: 'T',
+          severity: 'warning',
+          description: 'D',
+          tags: [],
+        },
       ]);
       const status = runtime.governance.getQuotaStatus('/p');
       expect(status.isWarning).toBe(false);
@@ -289,7 +340,15 @@ describe('Governance (colocated)', () => {
         warnAtPercent: 80,
       });
       runtime.vault.seed([
-        { id: 'full1', type: 'pattern', domain: 'a', title: 'T', severity: 'warning', description: 'D', tags: [] },
+        {
+          id: 'full1',
+          type: 'pattern',
+          domain: 'a',
+          title: 'T',
+          severity: 'warning',
+          description: 'D',
+          tags: [],
+        },
       ]);
       const decision = runtime.governance.evaluateCapture('/p', { type: 'pattern', category: 'a' });
       expect(decision.allowed).toBe(false);
@@ -305,7 +364,15 @@ describe('Governance (colocated)', () => {
         warnAtPercent: 80,
       });
       runtime.vault.seed([
-        { id: 'cat1', type: 'pattern', domain: 'a', title: 'T', severity: 'warning', description: 'D', tags: [] },
+        {
+          id: 'cat1',
+          type: 'pattern',
+          domain: 'a',
+          title: 'T',
+          severity: 'warning',
+          description: 'D',
+          tags: [],
+        },
       ]);
       const decision = runtime.governance.evaluateCapture('/p', { type: 'pattern', category: 'a' });
       expect(decision.allowed).toBe(false);
@@ -321,7 +388,15 @@ describe('Governance (colocated)', () => {
         warnAtPercent: 80,
       });
       runtime.vault.seed([
-        { id: 'typ1', type: 'pattern', domain: 'a', title: 'T', severity: 'warning', description: 'D', tags: [] },
+        {
+          id: 'typ1',
+          type: 'pattern',
+          domain: 'a',
+          title: 'T',
+          severity: 'warning',
+          description: 'D',
+          tags: [],
+        },
       ]);
       const decision = runtime.governance.evaluateCapture('/p', { type: 'pattern', category: 'b' });
       expect(decision.allowed).toBe(false);
@@ -354,7 +429,15 @@ describe('Governance (colocated)', () => {
         warnAtPercent: 80,
       });
       runtime.vault.seed([
-        { id: 'mx1', type: 'pattern', domain: 'a', title: 'T', severity: 'warning', description: 'D', tags: [] },
+        {
+          id: 'mx1',
+          type: 'pattern',
+          domain: 'a',
+          title: 'T',
+          severity: 'warning',
+          description: 'D',
+          tags: [],
+        },
       ]);
       const results = runtime.governance.evaluateBatch('/p', [
         { type: 'pattern', category: 'a' },
@@ -478,7 +561,11 @@ describe('Governance (colocated)', () => {
         category: 'a',
         data: { description: 'Original', severity: 'warning' },
       });
-      const result = runtime.governance.modifyProposal(id, { description: 'Updated', extra: true }, 'editor');
+      const result = runtime.governance.modifyProposal(
+        id,
+        { description: 'Updated', extra: true },
+        'editor',
+      );
       expect(result).not.toBeNull();
       expect(result!.status).toBe('modified');
       expect(result!.proposedData.description).toBe('Updated');
@@ -578,7 +665,11 @@ describe('Governance (colocated)', () => {
     });
 
     it('computes byCategory breakdown', () => {
-      const id1 = runtime.governance.propose('/p', { title: 'P1', type: 'pattern', category: 'arch' });
+      const id1 = runtime.governance.propose('/p', {
+        title: 'P1',
+        type: 'pattern',
+        category: 'arch',
+      });
       const id2 = runtime.governance.propose('/p', { title: 'P2', type: 'rule', category: 'arch' });
       runtime.governance.approveProposal(id1);
       runtime.governance.rejectProposal(id2);
@@ -645,8 +736,24 @@ describe('Governance (colocated)', () => {
         warnAtPercent: 80,
       });
       runtime.vault.seed([
-        { id: 'd1', type: 'pattern', domain: 'd', title: 'T', severity: 'warning', description: 'D', tags: [] },
-        { id: 'd2', type: 'rule', domain: 'd', title: 'T', severity: 'warning', description: 'D', tags: [] },
+        {
+          id: 'd1',
+          type: 'pattern',
+          domain: 'd',
+          title: 'T',
+          severity: 'warning',
+          description: 'D',
+          tags: [],
+        },
+        {
+          id: 'd2',
+          type: 'rule',
+          domain: 'd',
+          title: 'T',
+          severity: 'warning',
+          description: 'D',
+          tags: [],
+        },
       ]);
       const dashboard = runtime.governance.getDashboard('/p');
       expect(dashboard.vaultSize).toBe(2);
@@ -702,9 +809,18 @@ describe('Governance (colocated)', () => {
     });
 
     it('setPolicy handles all three policy types independently', () => {
-      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 42 } as Record<string, unknown>);
-      runtime.governance.setPolicy('/p', 'retention', { archiveAfterDays: 7 } as Record<string, unknown>);
-      runtime.governance.setPolicy('/p', 'auto-capture', { enabled: false } as Record<string, unknown>);
+      runtime.governance.setPolicy('/p', 'quota', { maxEntriesTotal: 42 } as Record<
+        string,
+        unknown
+      >);
+      runtime.governance.setPolicy('/p', 'retention', { archiveAfterDays: 7 } as Record<
+        string,
+        unknown
+      >);
+      runtime.governance.setPolicy('/p', 'auto-capture', { enabled: false } as Record<
+        string,
+        unknown
+      >);
 
       const policy = runtime.governance.getPolicy('/p');
       expect(policy.quotas.maxEntriesTotal).toBe(42);

package/src/health/health-registry.test.ts

@@ -161,7 +161,14 @@ describe('withDegradation', () => {
     reg.register('test');
 
     const fail = () =>
-      withDegradation(reg, 'test', async () => { throw new Error('fail'); }, null);
+      withDegradation(
+        reg,
+        'test',
+        async () => {
+          throw new Error('fail');
+        },
+        null,
+      );
 
     await fail();
     expect(reg.get('test')!.status).toBe('degraded');