@soleri/core 9.2.0 → 9.3.1

package/src/llm/utils.test.ts

@@ -1,5 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { CircuitBreaker, CircuitOpenError, computeDelay, retry, parseRateLimitHeaders } from './utils.js';
+import {
+  CircuitBreaker,
+  CircuitOpenError,
+  computeDelay,
+  retry,
+  parseRateLimitHeaders,
+} from './utils.js';
 import { LLMError } from './types.js';
 
 // ─── CircuitOpenError ───────────────────────────────────────────────
@@ -46,7 +52,11 @@ describe('CircuitBreaker', () => {
 
   it('should rethrow errors from the wrapped function', async () => {
     const cb = new CircuitBreaker({ name: 'test' });
-    await expect(cb.call(async () => { throw new Error('boom'); })).rejects.toThrow('boom');
+    await expect(
+      cb.call(async () => {
+        throw new Error('boom');
+      }),
+    ).rejects.toThrow('boom');
   });
 
   it('should not count non-retryable errors as failures', async () => {
@@ -54,7 +64,11 @@ describe('CircuitBreaker', () => {
     const nonRetryable = new Error('not retryable');
 
     for (let i = 0; i < 5; i++) {
-      await expect(cb.call(async () => { throw nonRetryable; })).rejects.toThrow();
+      await expect(
+        cb.call(async () => {
+          throw nonRetryable;
+        }),
+      ).rejects.toThrow();
     }
     expect(cb.getState().state).toBe('closed');
   });
@@ -63,8 +77,16 @@ describe('CircuitBreaker', () => {
     const cb = new CircuitBreaker({ name: 'test', failureThreshold: 2 });
     const retryableErr = new LLMError('rate limited', { retryable: true });
 
-    await expect(cb.call(async () => { throw retryableErr; })).rejects.toThrow();
-    await expect(cb.call(async () => { throw retryableErr; })).rejects.toThrow();
+    await expect(
+      cb.call(async () => {
+        throw retryableErr;
+      }),
+    ).rejects.toThrow();
+    await expect(
+      cb.call(async () => {
+        throw retryableErr;
+      }),
+    ).rejects.toThrow();
     expect(cb.isOpen()).toBe(true);
   });
 
@@ -72,7 +94,11 @@ describe('CircuitBreaker', () => {
     const cb = new CircuitBreaker({ name: 'test', failureThreshold: 1, resetTimeoutMs: 999_999 });
     const retryableErr = new LLMError('fail', { retryable: true });
 
-    await expect(cb.call(async () => { throw retryableErr; })).rejects.toThrow();
+    await expect(
+      cb.call(async () => {
+        throw retryableErr;
+      }),
+    ).rejects.toThrow();
     await expect(cb.call(async () => 'ok')).rejects.toThrow(CircuitOpenError);
   });
 
@@ -80,7 +106,11 @@ describe('CircuitBreaker', () => {
     const cb = new CircuitBreaker({ name: 'test', failureThreshold: 1, resetTimeoutMs: 10 });
     const retryableErr = new LLMError('fail', { retryable: true });
 
-    await expect(cb.call(async () => { throw retryableErr; })).rejects.toThrow();
+    await expect(
+      cb.call(async () => {
+        throw retryableErr;
+      }),
+    ).rejects.toThrow();
     expect(cb.isOpen()).toBe(true);
 
     // Wait for reset timeout
@@ -93,7 +123,11 @@ describe('CircuitBreaker', () => {
     const cb = new CircuitBreaker({ name: 'test', failureThreshold: 1, resetTimeoutMs: 10 });
     const retryableErr = new LLMError('fail', { retryable: true });
 
-    await expect(cb.call(async () => { throw retryableErr; })).rejects.toThrow();
+    await expect(
+      cb.call(async () => {
+        throw retryableErr;
+      }),
+    ).rejects.toThrow();
     await new Promise((r) => setTimeout(r, 20));
 
     const result = await cb.call(async () => 'recovered');
@@ -105,10 +139,18 @@ describe('CircuitBreaker', () => {
     const cb = new CircuitBreaker({ name: 'test', failureThreshold: 1, resetTimeoutMs: 10 });
     const retryableErr = new LLMError('fail', { retryable: true });
 
-    await expect(cb.call(async () => { throw retryableErr; })).rejects.toThrow();
+    await expect(
+      cb.call(async () => {
+        throw retryableErr;
+      }),
+    ).rejects.toThrow();
     await new Promise((r) => setTimeout(r, 20));
 
-    await expect(cb.call(async () => { throw retryableErr; })).rejects.toThrow();
+    await expect(
+      cb.call(async () => {
+        throw retryableErr;
+      }),
+    ).rejects.toThrow();
     expect(cb.getState().state).toBe('open');
   });
 
@@ -116,7 +158,11 @@ describe('CircuitBreaker', () => {
     const cb = new CircuitBreaker({ name: 'test', failureThreshold: 1, resetTimeoutMs: 999_999 });
     const retryableErr = new LLMError('fail', { retryable: true });
 
-    await expect(cb.call(async () => { throw retryableErr; })).rejects.toThrow();
+    await expect(
+      cb.call(async () => {
+        throw retryableErr;
+      }),
+    ).rejects.toThrow();
     expect(cb.isOpen()).toBe(true);
 
     cb.reset();
@@ -204,7 +250,9 @@ describe('retry', () => {
 
   it('should throw if maxAttempts < 1', async () => {
     vi.useRealTimers();
-    await expect(retry(async () => 'ok', { maxAttempts: 0 })).rejects.toThrow('maxAttempts must be >= 1');
+    await expect(retry(async () => 'ok', { maxAttempts: 0 })).rejects.toThrow(
+      'maxAttempts must be >= 1',
+    );
   });
 
   it('should throw non-retryable errors immediately', async () => {
@@ -227,9 +275,7 @@ describe('retry', () => {
   it('should succeed on retry after initial failures', async () => {
     vi.useRealTimers();
     const retryableErr = new LLMError('transient', { retryable: true });
-    const fn = vi.fn()
-      .mockRejectedValueOnce(retryableErr)
-      .mockResolvedValueOnce('recovered');
+    const fn = vi.fn().mockRejectedValueOnce(retryableErr).mockResolvedValueOnce('recovered');
 
     const result = await retry(fn, { maxAttempts: 3, baseDelayMs: 1, maxDelayMs: 1, jitter: 0 });
     expect(result).toBe('recovered');
@@ -240,9 +286,7 @@ describe('retry', () => {
     vi.useRealTimers();
     const retryableErr = new LLMError('transient', { retryable: true });
     const onRetry = vi.fn();
-    const fn = vi.fn()
-      .mockRejectedValueOnce(retryableErr)
-      .mockResolvedValueOnce('ok');
+    const fn = vi.fn().mockRejectedValueOnce(retryableErr).mockResolvedValueOnce('ok');
 
     await retry(fn, { maxAttempts: 3, baseDelayMs: 1, maxDelayMs: 1, jitter: 0, onRetry });
     expect(onRetry).toHaveBeenCalledTimes(1);

package/src/logging/logger.test.ts

@@ -103,7 +103,10 @@ describe('Logger file logging', () => {
   beforeEach(() => {
     vi.spyOn(console, 'error').mockImplementation(() => {});
     vi.spyOn(console, 'warn').mockImplementation(() => {});
-    tempDir = join(tmpdir(), `logger-colocated-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    tempDir = join(
+      tmpdir(),
+      `logger-colocated-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
     mkdirSync(tempDir, { recursive: true });
   });
 

package/src/loop/loop-manager.test.ts

@@ -34,9 +34,7 @@ describe('extractPromise', () => {
   });
 
   it('handles multiline content inside tags', () => {
-    expect(extractPromise('<promise>\nSALVADOR_VALIDATED\n</promise>')).toBe(
-      'SALVADOR_VALIDATED',
-    );
+    expect(extractPromise('<promise>\nSALVADOR_VALIDATED\n</promise>')).toBe('SALVADOR_VALIDATED');
   });
 
   it('extracts only the first match', () => {
@@ -349,9 +347,7 @@ describe('LoopManager', () => {
 
     it('detects completion promise and ends loop', () => {
       mgr.startLoop(makeConfig({ completionPromise: 'SALVADOR_VALIDATED' }));
-      const result = mgr.iterateWithGate(
-        'Done! <promise>SALVADOR_VALIDATED</promise>',
-      );
+      const result = mgr.iterateWithGate('Done! <promise>SALVADOR_VALIDATED</promise>');
 
       expect(result.decision).toBe('allow');
       expect(result.outcome).toBe('completed');

package/src/migrations/migration-runner.edge-cases.test.ts

@@ -8,9 +8,7 @@
 import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
 import Database from 'better-sqlite3';
 import { MigrationRunner } from './migration-runner.js';
-import {
-  createMigration,
-} from './migration-runner.test-helpers.js';
+import { createMigration } from './migration-runner.test-helpers.js';
 
 describe('MigrationRunner — edge cases', () => {
   let db: Database.Database;
@@ -302,10 +300,7 @@ describe('MigrationRunner — edge cases', () => {
     test('getPending consistent across runners sharing same db', () => {
       // Arrange
       const runner2 = new MigrationRunner(db);
-      const all = [
-        createMigration({ version: '1.0.0' }),
-        createMigration({ version: '2.0.0' }),
-      ];
+      const all = [createMigration({ version: '1.0.0' }), createMigration({ version: '2.0.0' })];
       runner.run([all[0]]);
 
       // Act

package/src/operator/operator-profile-extended.test.ts

@@ -61,7 +61,9 @@ describe('OperatorProfileStore (extended)', () => {
 
   describe('parallel section updates', () => {
     it('two concurrent updateSection for different sections both succeed', () => {
-      store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+      store.accumulateSignals([
+        makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+      ]);
 
       const commData: CommunicationSection = {
         style: 'formal',
@@ -88,7 +90,9 @@ describe('OperatorProfileStore (extended)', () => {
     });
 
     it('updating one section does not overwrite another', () => {
-      store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+      store.accumulateSignals([
+        makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+      ]);
 
       const identity: IdentitySection = {
         background: 'Senior engineer',
@@ -116,7 +120,9 @@ describe('OperatorProfileStore (extended)', () => {
 
   describe('profile snapshot', () => {
     it('creates history entry with correct version increment', () => {
-      store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+      store.accumulateSignals([
+        makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+      ]);
       const profileBefore = store.getProfile();
       expect(profileBefore!.version).toBe(0);
 
@@ -197,7 +203,9 @@ describe('OperatorProfileStore (extended)', () => {
     });
 
     it('lastSynthesis updates after snapshot', () => {
-      store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+      store.accumulateSignals([
+        makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+      ]);
       store.snapshot('synthesis');
       const stats = store.signalStats();
       expect(stats.lastSynthesis).not.toBeNull();
@@ -273,7 +281,9 @@ describe('OperatorProfileStore (extended)', () => {
 
   describe('delete profile archives to history', () => {
     it('archives profile snapshot before deletion', () => {
-      store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+      store.accumulateSignals([
+        makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+      ]);
       const identity: IdentitySection = {
         background: 'Architect',
         role: 'Principal',

package/src/operator/operator-profile.test.ts

@@ -2,7 +2,11 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { Vault } from '../vault/vault.js';
 import { OperatorProfileStore } from './operator-profile.js';
 import { SignalType } from './operator-types.js';
-import type { OperatorSignal, CommunicationSection, TechnicalContextSection } from './operator-types.js';
+import type {
+  OperatorSignal,
+  CommunicationSection,
+  TechnicalContextSection,
+} from './operator-types.js';
 
 // ─── Helpers ──────────────────────────────────────────────────────────
 
@@ -83,7 +87,9 @@ describe('OperatorProfileStore', () => {
   });
 
   it('auto-creates profile when accumulating signals', () => {
-    store.accumulateSignals([makeSignal(SignalType.WorkRhythm, { pattern: 'burst', durationMinutes: 30, taskCount: 5 })]);
+    store.accumulateSignals([
+      makeSignal(SignalType.WorkRhythm, { pattern: 'burst', durationMinutes: 30, taskCount: 5 }),
+    ]);
     const profile = store.getProfile();
     expect(profile).not.toBeNull();
     expect(profile!.sessionCount).toBe(0);
@@ -127,7 +133,9 @@ describe('OperatorProfileStore', () => {
 
   it('parallel updateSection on different sections both succeed', () => {
     // Ensure profile exists
-    store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+    store.accumulateSignals([
+      makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+    ]);
 
     const commData: CommunicationSection = {
       style: 'concise',
@@ -157,7 +165,9 @@ describe('OperatorProfileStore', () => {
   // ─── correctSection ─────────────────────────────────────────────
 
   it('correctSection records history with correction trigger', () => {
-    store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+    store.accumulateSignals([
+      makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+    ]);
     const profileBefore = store.getProfile();
     expect(profileBefore).not.toBeNull();
 
@@ -183,7 +193,9 @@ describe('OperatorProfileStore', () => {
   // ─── snapshot ───────────────────────────────────────────────────
 
   it('creates history row with full profile JSON', () => {
-    store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+    store.accumulateSignals([
+      makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+    ]);
     const profile = store.getProfile();
     expect(profile).not.toBeNull();
 
@@ -205,7 +217,9 @@ describe('OperatorProfileStore', () => {
   });
 
   it('increments synthesis_version on snapshot', () => {
-    store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+    store.accumulateSignals([
+      makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+    ]);
 
     store.snapshot('synthesis');
     store.snapshot('synthesis');
@@ -219,7 +233,9 @@ describe('OperatorProfileStore', () => {
   // ─── deleteProfile ──────────────────────────────────────────────
 
   it('archives to history before deletion', () => {
-    store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+    store.accumulateSignals([
+      makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+    ]);
     const profile = store.getProfile();
     expect(profile).not.toBeNull();
     const profileId = profile!.id;
@@ -287,7 +303,9 @@ describe('OperatorProfileStore', () => {
   });
 
   it('returns section data after update', () => {
-    store.accumulateSignals([makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' })]);
+    store.accumulateSignals([
+      makeSignal(SignalType.CommandStyle, { style: 'terse', snippet: 'x' }),
+    ]);
     const commData: CommunicationSection = {
       style: 'detailed',
       signalWords: ['please'],

package/src/operator/operator-profile.ts

@@ -165,11 +165,7 @@ export class OperatorProfileStore {
     return JSON.parse((row[col] as string) || '{}') as ProfileSection;
   }
 
-  updateSection(
-    section: ProfileSectionKey,
-    data: ProfileSection,
-    profileId?: string,
-  ): boolean {
+  updateSection(section: ProfileSectionKey, data: ProfileSection, profileId?: string): boolean {
     const id = profileId ?? this.ensureProfile();
     const col = SECTION_COLUMNS[section];
     const result = this.provider.run(
@@ -179,11 +175,7 @@ export class OperatorProfileStore {
     return result.changes > 0;
   }
 
-  correctSection(
-    section: ProfileSectionKey,
-    data: ProfileSection,
-    profileId?: string,
-  ): boolean {
+  correctSection(section: ProfileSectionKey, data: ProfileSection, profileId?: string): boolean {
     const id = profileId ?? this.ensureProfile();
     this.snapshot('correction', id);
     return this.updateSection(section, data, id);
@@ -210,7 +202,14 @@ export class OperatorProfileStore {
         this.provider.run(
           `INSERT INTO operator_signals (profile_id, signal_type, signal_data, source, confidence, created_at)
            VALUES (?, ?, ?, ?, ?, ?)`,
-          [id, signal.signalType, JSON.stringify(signal.data), signal.source ?? null, signal.confidence, signal.timestamp],
+          [
+            id,
+            signal.signalType,
+            JSON.stringify(signal.data),
+            signal.source ?? null,
+            signal.confidence,
+            signal.timestamp,
+          ],
         );
         inserted++;
       }
@@ -225,7 +224,15 @@ export class OperatorProfileStore {
   listSignals(
     filter: { types?: string[]; processed?: boolean; limit?: number } = {},
     profileId?: string,
-  ): Array<{ id: number; signalType: string; signalData: unknown; source: string | null; confidence: number; processed: boolean; createdAt: string }> {
+  ): Array<{
+    id: number;
+    signalType: string;
+    signalData: unknown;
+    source: string | null;
+    confidence: number;
+    processed: boolean;
+    createdAt: string;
+  }> {
     const id = profileId ?? this.getDefaultProfileId();
     if (!id) return [];
     const conditions = ['profile_id = ?'];
@@ -296,7 +303,11 @@ export class OperatorProfileStore {
       };
     }
     const stats = this.signalStats(id);
-    const profile = this.provider.get<{ session_count: number; last_synthesis: string | null; synthesis_version: number }>(
+    const profile = this.provider.get<{
+      session_count: number;
+      last_synthesis: string | null;
+      synthesis_version: number;
+    }>(
       'SELECT session_count, last_synthesis, synthesis_version FROM operator_profiles WHERE id = ?',
       [id],
     );
@@ -311,14 +322,14 @@ export class OperatorProfileStore {
     }
 
     const pending = stats.totalUnprocessed;
-    const sessionsSinceSynthesis = profile.synthesis_version === 0
-      ? profile.session_count
-      : profile.session_count; // tracked by incrementing session_count
+    const sessionsSinceSynthesis =
+      profile.synthesis_version === 0 ? profile.session_count : profile.session_count; // tracked by incrementing session_count
 
     const signalThresholdMet = pending >= SYNTHESIS_SIGNAL_THRESHOLD;
-    const sessionThresholdMet = sessionsSinceSynthesis >= SYNTHESIS_SESSION_THRESHOLD && profile.synthesis_version > 0
-      ? false // sessions threshold only meaningful after first synthesis
-      : sessionsSinceSynthesis >= SYNTHESIS_SESSION_THRESHOLD;
+    const sessionThresholdMet =
+      sessionsSinceSynthesis >= SYNTHESIS_SESSION_THRESHOLD && profile.synthesis_version > 0
+        ? false // sessions threshold only meaningful after first synthesis
+        : sessionsSinceSynthesis >= SYNTHESIS_SESSION_THRESHOLD;
 
     const due = signalThresholdMet || sessionThresholdMet;
 
@@ -332,8 +343,12 @@ export class OperatorProfileStore {
     }
 
     const reasons: string[] = [];
-    if (signalThresholdMet) reasons.push(`${pending} unprocessed signals (threshold: ${SYNTHESIS_SIGNAL_THRESHOLD})`);
-    if (sessionThresholdMet) reasons.push(`${sessionsSinceSynthesis} sessions since last synthesis (threshold: ${SYNTHESIS_SESSION_THRESHOLD})`);
+    if (signalThresholdMet)
+      reasons.push(`${pending} unprocessed signals (threshold: ${SYNTHESIS_SIGNAL_THRESHOLD})`);
+    if (sessionThresholdMet)
+      reasons.push(
+        `${sessionsSinceSynthesis} sessions since last synthesis (threshold: ${SYNTHESIS_SESSION_THRESHOLD})`,
+      );
     if (!due) reasons.push('Below all thresholds');
 
     return {
@@ -385,7 +400,8 @@ export class OperatorProfileStore {
       `INSERT INTO operator_profiles (id, agent_id, identity, cognition, communication, working_rules, trust_model, taste_profile, growth_edges, technical_context)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
-        id, agentId,
+        id,
+        agentId,
         JSON.stringify(profile.identity),
         JSON.stringify(profile.cognition),
         JSON.stringify(profile.communication),

package/src/operator/operator-signals-extended.test.ts

@@ -106,12 +106,14 @@ describe('operator-signals (extended)', () => {
 
   describe('edge cases', () => {
     it('empty session data — null fields produce minimal signals', () => {
-      const signals = extractFromSession(makeSession({
-        intent: null as unknown as string,
-        toolsUsed: null as unknown as string[],
-        filesModified: null as unknown as string[],
-        decisions: null as unknown as string[],
-      }));
+      const signals = extractFromSession(
+        makeSession({
+          intent: null as unknown as string,
+          toolsUsed: null as unknown as string[],
+          filesModified: null as unknown as string[],
+          decisions: null as unknown as string[],
+        }),
+      );
       // Should still get work_rhythm and session_depth
       expect(signals.some((s) => s.signalType === 'work_rhythm')).toBe(true);
       expect(signals.some((s) => s.signalType === 'session_depth')).toBe(true);
@@ -139,10 +141,12 @@ describe('operator-signals (extended)', () => {
     });
 
     it('empty filesModified and decisions produces shallow depth', () => {
-      const signals = extractFromSession(makeSession({
-        filesModified: [],
-        decisions: [],
-      }));
+      const signals = extractFromSession(
+        makeSession({
+          filesModified: [],
+          decisions: [],
+        }),
+      );
       const sd = signals.find((s) => s.signalType === 'session_depth');
       expect(sd).toBeDefined();
       expect((sd!.data as { depth: string }).depth).toBe('shallow');
@@ -211,7 +215,9 @@ describe('operator-signals (extended)', () => {
     });
 
     it('returns empty array for completely unknown type', () => {
-      expect(extractFromRadar(makeRadarCandidate({ signalType: 'alien_signal' as never }))).toEqual([]);
+      expect(extractFromRadar(makeRadarCandidate({ signalType: 'alien_signal' as never }))).toEqual(
+        [],
+      );
     });
   });
 
@@ -219,26 +225,32 @@ describe('operator-signals (extended)', () => {
 
   describe('extractFromRadar frustration level mapping', () => {
     it('high confidence (>=0.7) → high frustration', () => {
-      const signals = extractFromRadar(makeRadarCandidate({
-        signalType: 'repeated_question',
-        confidence: 0.75,
-      }));
+      const signals = extractFromRadar(
+        makeRadarCandidate({
+          signalType: 'repeated_question',
+          confidence: 0.75,
+        }),
+      );
       expect((signals[0].data as { level: string }).level).toBe('high');
     });
 
     it('medium confidence (0.5-0.7) → moderate frustration', () => {
-      const signals = extractFromRadar(makeRadarCandidate({
-        signalType: 'repeated_question',
-        confidence: 0.55,
-      }));
+      const signals = extractFromRadar(
+        makeRadarCandidate({
+          signalType: 'repeated_question',
+          confidence: 0.55,
+        }),
+      );
       expect((signals[0].data as { level: string }).level).toBe('moderate');
     });
 
     it('low confidence (<0.5) → mild frustration', () => {
-      const signals = extractFromRadar(makeRadarCandidate({
-        signalType: 'repeated_question',
-        confidence: 0.3,
-      }));
+      const signals = extractFromRadar(
+        makeRadarCandidate({
+          signalType: 'repeated_question',
+          confidence: 0.3,
+        }),
+      );
       expect((signals[0].data as { level: string }).level).toBe('mild');
     });
   });

package/src/operator/operator-signals.test.ts

@@ -123,18 +123,14 @@ describe('operator-signals', () => {
     });
 
     it('returns shallow depth for minimal session', () => {
-      const signals = extractFromSession(
-        makeSession({ filesModified: [], decisions: [] }),
-      );
+      const signals = extractFromSession(makeSession({ filesModified: [], decisions: [] }));
       const sd = signals.find((s) => s.signalType === 'session_depth');
       expect(sd).toBeDefined();
       expect((sd!.data as { depth: string }).depth).toBe('shallow');
     });
 
     it('handles null toolsUsed gracefully — returns signals for other fields', () => {
-      const signals = extractFromSession(
-        makeSession({ toolsUsed: null as unknown as string[] }),
-      );
+      const signals = extractFromSession(makeSession({ toolsUsed: null as unknown as string[] }));
       // Should still have command_style, work_rhythm, session_depth
       expect(signals.some((s) => s.signalType === 'command_style')).toBe(true);
       expect(signals.some((s) => s.signalType === 'work_rhythm')).toBe(true);
@@ -144,9 +140,7 @@ describe('operator-signals', () => {
     });
 
     it('handles null intent gracefully — skips command_style', () => {
-      const signals = extractFromSession(
-        makeSession({ intent: null as unknown as string }),
-      );
+      const signals = extractFromSession(makeSession({ intent: null as unknown as string }));
       expect(signals.some((s) => s.signalType === 'command_style')).toBe(false);
       expect(signals.some((s) => s.signalType === 'work_rhythm')).toBe(true);
     });
@@ -208,7 +202,9 @@ describe('operator-signals', () => {
 
   describe('extractFromBrainStrengths', () => {
     it('creates domain_expertise for strengths with score > 0.6', () => {
-      const strengths = [makeStrength({ pattern: 'typescript-strict', domain: 'typescript', strength: 0.8 })];
+      const strengths = [
+        makeStrength({ pattern: 'typescript-strict', domain: 'typescript', strength: 0.8 }),
+      ];
       const signals = extractFromBrainStrengths(strengths);
       expect(signals.length).toBe(1);
       expect(signals[0].signalType).toBe('domain_expertise');

package/src/operator/operator-signals.ts

@@ -221,7 +221,8 @@ export function extractFromRadar(candidate: RadarCandidate): OperatorSignal[] {
       signalType: SignalType.Frustration,
       source: 'learning_radar',
       data: {
-        level: candidate.confidence >= 0.7 ? 'high' : candidate.confidence >= 0.5 ? 'moderate' : 'mild',
+        level:
+          candidate.confidence >= 0.7 ? 'high' : candidate.confidence >= 0.5 ? 'moderate' : 'mild',
         trigger: candidate.sourceQuery ?? candidate.title,
         context: candidate.context ?? candidate.description,
       },