@soleri/core 9.2.0 → 9.3.0

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

@@ -10,7 +10,10 @@ import type { AgentRuntime } from './types.js';
 /** Minimal in-memory project registry stub. */
 function makeProjectRegistryStub() {
   const projects = new Map<string, { id: string; name: string; lastAccessed: number }>();
-  const rules = new Map<string, Array<{ id: string; category: string; text: string; priority: number }>>();
+  const rules = new Map<
+    string,
+    Array<{ id: string; category: string; text: string; priority: number }>
+  >();
   const links: Array<{ sourceId: string; targetId: string; linkType: string }> = [];
   let ruleCounter = 0;
 
@@ -39,7 +42,10 @@ function makeProjectRegistryStub() {
     removeRule: (ruleId: string) => {
       for (const [, arr] of rules) {
         const idx = arr.findIndex((r) => r.id === ruleId);
-        if (idx >= 0) { arr.splice(idx, 1); return true; }
+        if (idx >= 0) {
+          arr.splice(idx, 1);
+          return true;
+        }
       }
       return false;
     },
@@ -52,14 +58,19 @@ function makeProjectRegistryStub() {
       let count = 0;
       for (let i = links.length - 1; i >= 0; i--) {
         const l = links[i];
-        if (l.sourceId === sourceId && l.targetId === targetId && (!linkType || l.linkType === linkType)) {
+        if (
+          l.sourceId === sourceId &&
+          l.targetId === targetId &&
+          (!linkType || l.linkType === linkType)
+        ) {
           links.splice(i, 1);
           count++;
         }
       }
       return count;
     },
-    getLinks: (projectId: string) => links.filter((l) => l.sourceId === projectId || l.targetId === projectId),
+    getLinks: (projectId: string) =>
+      links.filter((l) => l.sourceId === projectId || l.targetId === projectId),
     getLinkedProjects: (projectId: string) => {
       return links
         .filter((l) => l.sourceId === projectId || l.targetId === projectId)
@@ -181,7 +192,12 @@ describe('project-ops', () => {
       const { ops, registry } = setup();
       registry._seed('a', 'A');
       registry._seed('b', 'B');
-      await executeOp(ops, 'project_add_rule', { projectId: 'a', category: 'behavior', text: 'r1', priority: 0 });
+      await executeOp(ops, 'project_add_rule', {
+        projectId: 'a',
+        category: 'behavior',
+        text: 'r1',
+        priority: 0,
+      });
 
       const res = await executeOp(ops, 'project_list_rules');
       const data = res.data as { count: number; projects: Array<{ ruleCount: number }> };
@@ -207,7 +223,11 @@ describe('project-ops', () => {
       registry._seed('b', 'B');
       await executeOp(ops, 'project_link', { sourceId: 'a', targetId: 'b', linkType: 'parent' });
 
-      const res = await executeOp(ops, 'project_unlink', { sourceId: 'a', targetId: 'b', linkType: 'parent' });
+      const res = await executeOp(ops, 'project_unlink', {
+        sourceId: 'a',
+        targetId: 'b',
+        linkType: 'parent',
+      });
       expect((res.data as { removed: number }).removed).toBe(1);
     });
 

package/src/runtime/runtime.ts

@@ -210,7 +210,9 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
         logger.info(`Markdown sync: ${result.synced} entries synced, ${result.skipped} skipped`);
       }
     },
-    () => { /* best-effort — never block boot */ },
+    () => {
+      /* best-effort — never block boot */
+    },
   );
 
   // ─── Auto-signal pipeline wiring ───────────────────────────────────

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