@soleri/core 9.0.4 → 9.3.0

package/src/runtime/facades/memory-facade.test.ts

@@ -0,0 +1,283 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Vault } from '../../vault/vault.js';
+import { OperatorProfileStore } from '../../operator/operator-profile.js';
+import { ProjectRegistry } from '../../project/project-registry.js';
+import { createMemoryFacadeOps } from './memory-facade.js';
+import { captureOps, executeOp } from '../../engine/test-helpers.js';
+import type { CapturedOp } from '../../engine/test-helpers.js';
+import type { AgentRuntime } from '../types.js';
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function makeRuntime(vault: Vault): AgentRuntime {
+  const operatorProfile = new OperatorProfileStore(vault);
+  const projectRegistry = new ProjectRegistry(vault.getProvider());
+  return { vault, operatorProfile, projectRegistry } as unknown as AgentRuntime;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────
+
+describe('memory-facade', () => {
+  let vault: Vault;
+  let ops: Map<string, CapturedOp>;
+
+  beforeEach(() => {
+    vault = new Vault(':memory:');
+    ops = captureOps(createMemoryFacadeOps(makeRuntime(vault)));
+  });
+
+  afterEach(() => {
+    vault.close();
+  });
+
+  it('registers base + extra + cross-project ops', () => {
+    // 4 base + 18 extra + 3 cross-project = 25
+    expect(ops.size).toBeGreaterThanOrEqual(25);
+    expect([...ops.keys()]).toContain('memory_search');
+    expect([...ops.keys()]).toContain('memory_capture');
+    expect([...ops.keys()]).toContain('memory_list');
+    expect([...ops.keys()]).toContain('session_capture');
+    expect([...ops.keys()]).toContain('memory_delete');
+    expect([...ops.keys()]).toContain('memory_promote_to_global');
+  });
+
+  it('has correct auth levels for base ops', () => {
+    expect(ops.get('memory_search')!.auth).toBe('read');
+    expect(ops.get('memory_capture')!.auth).toBe('write');
+    expect(ops.get('memory_list')!.auth).toBe('read');
+    expect(ops.get('session_capture')!.auth).toBe('write');
+  });
+
+  // ─── memory_capture ────────────────────────────────────────────
+
+  it('memory_capture stores a memory', async () => {
+    const result = await executeOp(ops, 'memory_capture', {
+      projectPath: '/test',
+      type: 'lesson',
+      context: 'learned about tokens',
+      summary: 'Token migration pattern',
+      topics: ['tokens'],
+    });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).captured).toBe(true);
+  });
+
+  // ─── memory_search ─────────────────────────────────────────────
+
+  it('memory_search returns empty for no matches', async () => {
+    const result = await executeOp(ops, 'memory_search', { query: 'nonexistent' });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).total).toBe(0);
+  });
+
+  it('memory_search finds captured memories', async () => {
+    await executeOp(ops, 'memory_capture', {
+      projectPath: '/test',
+      type: 'lesson',
+      context: 'context',
+      summary: 'Token migration best practices',
+    });
+    const result = await executeOp(ops, 'memory_search', { query: 'token migration' });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).total).toBeGreaterThanOrEqual(1);
+  });
+
+  it('memory_search returns summaries by default', async () => {
+    await executeOp(ops, 'memory_capture', {
+      projectPath: '/test',
+      type: 'lesson',
+      context: 'ctx',
+      summary: 'short summary',
+    });
+    const result = await executeOp(ops, 'memory_search', { query: 'short summary' });
+    expect(result.success).toBe(true);
+    const data = result.data as { results: Array<{ summary: string }> };
+    expect(data.results[0]).toHaveProperty('summary');
+    expect(data.results[0]).not.toHaveProperty('context');
+  });
+
+  it('memory_search returns full objects with verbose:true', async () => {
+    await executeOp(ops, 'memory_capture', {
+      projectPath: '/test',
+      type: 'lesson',
+      context: 'ctx',
+      summary: 'verbose test',
+    });
+    const result = await executeOp(ops, 'memory_search', { query: 'verbose test', verbose: true });
+    expect(result.success).toBe(true);
+    const data = result.data as { results: Array<Record<string, unknown>> };
+    expect(data.results[0]).toHaveProperty('context');
+  });
+
+  // ─── memory_list ───────────────────────────────────────────────
+
+  it('memory_list returns entries with stats', async () => {
+    await executeOp(ops, 'memory_capture', {
+      projectPath: '/test',
+      type: 'session',
+      context: 'ctx',
+      summary: 'session 1',
+    });
+    const result = await executeOp(ops, 'memory_list', {});
+    expect(result.success).toBe(true);
+    const data = result.data as { entries: unknown[]; total: number };
+    expect(data.total).toBeGreaterThanOrEqual(1);
+    expect(data.entries.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('memory_list filters by type', async () => {
+    await executeOp(ops, 'memory_capture', {
+      projectPath: '/test',
+      type: 'lesson',
+      context: 'c',
+      summary: 'lesson',
+    });
+    await executeOp(ops, 'memory_capture', {
+      projectPath: '/test',
+      type: 'preference',
+      context: 'c',
+      summary: 'pref',
+    });
+    const result = await executeOp(ops, 'memory_list', { type: 'lesson' });
+    expect(result.success).toBe(true);
+    const data = result.data as { entries: unknown[]; total: number };
+    expect(data.entries.length).toBe(1);
+  });
+
+  it('memory_list verbose returns full objects', async () => {
+    await executeOp(ops, 'memory_capture', {
+      projectPath: '/test',
+      type: 'lesson',
+      context: 'c',
+      summary: 'verbose list',
+    });
+    const result = await executeOp(ops, 'memory_list', { verbose: true });
+    expect(result.success).toBe(true);
+    const data = result.data as { memories: Array<Record<string, unknown>> };
+    expect(data.memories[0]).toHaveProperty('context');
+  });
+
+  // ─── session_capture ───────────────────────────────────────────
+
+  it('session_capture stores with summary', async () => {
+    const result = await executeOp(ops, 'session_capture', {
+      summary: 'Built token migration feature',
+      topics: ['tokens'],
+    });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).captured).toBe(true);
+  });
+
+  it('session_capture accepts conversationContext alias', async () => {
+    const result = await executeOp(ops, 'session_capture', {
+      conversationContext: 'aliased summary',
+    });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).captured).toBe(true);
+  });
+
+  it('session_capture fails without summary or conversationContext', async () => {
+    const result = await executeOp(ops, 'session_capture', { topics: ['test'] });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).captured).toBe(false);
+  });
+
+  it('session_capture stores rich fields', async () => {
+    const result = await executeOp(ops, 'session_capture', {
+      summary: 'test session',
+      intent: 'BUILD',
+      decisions: ['used pattern X'],
+      currentState: 'half done',
+      nextSteps: ['finish Y'],
+      vaultEntriesReferenced: ['entry-1'],
+      filesModified: ['src/app.ts'],
+      toolsUsed: ['vault_search'],
+    });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).captured).toBe(true);
+  });
+
+  // ─── memory_delete ─────────────────────────────────────────────
+
+  it('memory_delete removes a memory', async () => {
+    const captureResult = await executeOp(ops, 'memory_capture', {
+      projectPath: '/test',
+      type: 'lesson',
+      context: 'c',
+      summary: 'to delete',
+    });
+    const memoryId = (
+      (captureResult.data as Record<string, unknown>).memory as Record<string, unknown>
+    ).id as string;
+    const result = await executeOp(ops, 'memory_delete', { memoryId });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).deleted).toBe(true);
+  });
+
+  it('memory_delete returns false for nonexistent memory', async () => {
+    const result = await executeOp(ops, 'memory_delete', { memoryId: 'nonexistent' });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).deleted).toBe(false);
+  });
+
+  it('memory_delete accepts id alias', async () => {
+    const result = await executeOp(ops, 'memory_delete', { id: 'nonexistent' });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).deleted).toBe(false);
+  });
+
+  it('memory_delete fails without any id param', async () => {
+    const result = await executeOp(ops, 'memory_delete', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).deleted).toBe(false);
+    expect((result.data as Record<string, unknown>).error).toContain('required');
+  });
+
+  // ─── memory_stats ──────────────────────────────────────────────
+
+  it('memory_stats returns statistics', async () => {
+    const result = await executeOp(ops, 'memory_stats', {});
+    expect(result.success).toBe(true);
+    expect(result.data).toHaveProperty('total');
+  });
+
+  // ─── memory_topics ─────────────────────────────────────────────
+
+  it('memory_topics returns empty initially', async () => {
+    const result = await executeOp(ops, 'memory_topics', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).count).toBe(0);
+  });
+
+  // ─── memory_deduplicate ────────────────────────────────────────
+
+  it('memory_deduplicate runs without error', async () => {
+    const result = await executeOp(ops, 'memory_deduplicate', {});
+    expect(result.success).toBe(true);
+  });
+
+  // ─── memory_promote_to_global ──────────────────────────────────
+
+  it('memory_promote_to_global fails on missing entry', async () => {
+    const result = await executeOp(ops, 'memory_promote_to_global', { entryId: 'missing' });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).promoted).toBe(false);
+  });
+
+  it('memory_promote_to_global adds _global tag', async () => {
+    vault.add({
+      id: 'test-entry',
+      type: 'pattern',
+      domain: 'general',
+      title: 'test',
+      description: 'test',
+      severity: 'suggestion',
+      tags: ['foo'],
+    });
+    const result = await executeOp(ops, 'memory_promote_to_global', { entryId: 'test-entry' });
+    expect(result.success).toBe(true);
+    const data = result.data as { promoted: boolean; tags: string[] };
+    expect(data.promoted).toBe(true);
+    expect(data.tags).toContain('_global');
+  });
+});

package/src/runtime/facades/memory-facade.ts

@@ -8,6 +8,14 @@ import type { OpDefinition } from '../../facades/types.js';
 import type { AgentRuntime } from '../types.js';
 import { createMemoryExtraOps } from '../memory-extra-ops.js';
 import { createMemoryCrossProjectOps } from '../memory-cross-project-ops.js';
+import { extractFromSession } from '../../operator/operator-signals.js';
+import type { SessionCaptureData } from '../../operator/operator-signals.js';
+
+/** Truncate text to maxLen chars, appending ellipsis when truncated. */
+function truncateSummary(text: string, maxLen = 120): string {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + '\u2026';
+}
 
 export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
   const { vault } = runtime;
@@ -16,20 +24,38 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Memory (inline from core-ops.ts) ───────────────────────
     {
       name: 'memory_search',
-      description: 'Search memories using full-text search.',
+      description:
+        'Search memories using full-text search. Returns summaries by default; pass verbose: true for full objects.',
       auth: 'read',
       schema: z.object({
         query: z.string(),
         type: z.enum(['session', 'lesson', 'preference']).optional(),
         projectPath: z.string().optional(),
         limit: z.number().optional(),
+        verbose: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('Return full memory objects instead of summaries'),
       }),
       handler: async (params) => {
-        return vault.searchMemories(params.query as string, {
+        const memories = vault.searchMemories(params.query as string, {
           type: params.type as string | undefined,
           projectPath: params.projectPath as string | undefined,
           limit: (params.limit as number) ?? 10,
         });
+        if (params.verbose) {
+          return { results: memories, total: memories.length };
+        }
+        return {
+          results: memories.map((m) => ({
+            id: m.id,
+            summary: truncateSummary(m.summary || m.context),
+            score: null,
+            project: m.projectPath,
+          })),
+          total: memories.length,
+        };
       },
     },
     {
@@ -65,13 +91,19 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'memory_list',
-      description: 'List memories with optional filters.',
+      description:
+        'List memories with optional filters. Returns summaries by default; pass verbose: true for full objects.',
       auth: 'read',
       schema: z.object({
         type: z.enum(['session', 'lesson', 'preference']).optional(),
         projectPath: z.string().optional(),
         limit: z.number().optional(),
         offset: z.number().optional(),
+        verbose: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('Return full memory objects instead of summaries'),
       }),
       handler: async (params) => {
         const memories = vault.listMemories({
@@ -81,7 +113,18 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           offset: (params.offset as number) ?? 0,
         });
         const stats = vault.memoryStats();
-        return { memories, stats };
+        if (params.verbose) {
+          return { memories, stats };
+        }
+        return {
+          entries: memories.map((m) => ({
+            id: m.id,
+            summary: truncateSummary(m.summary || m.context),
+            project: m.projectPath,
+            createdAt: m.createdAt,
+          })),
+          total: stats.total,
+        };
       },
     },
     {
@@ -91,7 +134,11 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       auth: 'write',
       schema: z.object({
         projectPath: z.string().optional().default('.'),
-        summary: z.string().describe('Brief summary of what was accomplished'),
+        summary: z.string().optional().describe('Brief summary of what was accomplished'),
+        conversationContext: z
+          .string()
+          .optional()
+          .describe('Alias for summary — brief summary of what was accomplished'),
         topics: z.array(z.string()).optional().default([]),
         filesModified: z.array(z.string()).optional().default([]),
         toolsUsed: z.array(z.string()).optional().default([]),
@@ -107,11 +154,15 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       handler: async (params) => {
         const { resolve } = await import('node:path');
         const projectPath = resolve((params.projectPath as string) ?? '.');
+        const summary = (params.summary ?? params.conversationContext) as string;
+        if (!summary) {
+          return { captured: false, error: 'Either summary or conversationContext is required.' };
+        }
         const memory = vault.captureMemory({
           projectPath,
           type: 'session',
           context: 'Auto-captured before context compaction',
-          summary: params.summary as string,
+          summary,
           topics: (params.topics as string[]) ?? [],
           filesModified: (params.filesModified as string[]) ?? [],
           toolsUsed: (params.toolsUsed as string[]) ?? [],
@@ -121,6 +172,27 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           nextSteps: (params.nextSteps as string[]) ?? [],
           vaultEntriesReferenced: (params.vaultEntriesReferenced as string[]) ?? [],
         });
+        // ─── Auto-signal extraction (never breaks session_capture) ───
+        try {
+          if (runtime.operatorProfile) {
+            const sessionData: SessionCaptureData = {
+              sessionId: memory.id ?? `session-${Date.now()}`,
+              intent: (params.intent as string) ?? null,
+              capturedAt: new Date().toISOString(),
+              toolsUsed: (params.toolsUsed as string[]) ?? null,
+              filesModified: (params.filesModified as string[]) ?? null,
+              decisions: (params.decisions as string[]) ?? null,
+              summary: summary ?? null,
+            };
+            const signals = extractFromSession(sessionData);
+            if (signals.length > 0) {
+              runtime.operatorProfile.accumulateSignals(signals);
+            }
+          }
+        } catch {
+          // Signal extraction must never break session_capture
+        }
+
         return { captured: true, memory, message: 'Session summary saved to memory.' };
       },
     },

package/src/runtime/facades/operator-facade.test.ts

@@ -0,0 +1,221 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Vault } from '../../vault/vault.js';
+import { OperatorProfileStore } from '../../operator/operator-profile.js';
+import { SignalType } from '../../operator/operator-types.js';
+import { createOperatorFacadeOps } from './operator-facade.js';
+import { captureOps, executeOp } from '../../engine/test-helpers.js';
+import type { CapturedOp } from '../../engine/test-helpers.js';
+import type { AgentRuntime } from '../types.js';
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function makeRuntime(vault: Vault, store: OperatorProfileStore): AgentRuntime {
+  return { operatorProfile: store, vault } as unknown as AgentRuntime;
+}
+
+function makeSignalPayload(type: SignalType = SignalType.CommandStyle) {
+  return {
+    id: `sig-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    signalType: type,
+    data: { style: 'terse', snippet: 'test' },
+    timestamp: new Date().toISOString(),
+    sessionId: 'test-session',
+    confidence: 0.8,
+  };
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────
+
+describe('operator-facade (colocated)', () => {
+  let vault: Vault;
+  let store: OperatorProfileStore;
+  let ops: Map<string, CapturedOp>;
+
+  beforeEach(() => {
+    vault = new Vault(':memory:');
+    store = new OperatorProfileStore(vault);
+    ops = captureOps(createOperatorFacadeOps(makeRuntime(vault, store)));
+  });
+
+  afterEach(() => {
+    vault.close();
+  });
+
+  it('registers all 10 ops', () => {
+    expect(ops.size).toBe(10);
+    expect([...ops.keys()]).toEqual(
+      expect.arrayContaining([
+        'profile_get',
+        'profile_update_section',
+        'profile_correct',
+        'profile_delete',
+        'profile_export',
+        'signal_accumulate',
+        'signal_list',
+        'signal_stats',
+        'synthesis_check',
+        'profile_snapshot',
+      ]),
+    );
+  });
+
+  it('has correct auth levels', () => {
+    expect(ops.get('profile_get')!.auth).toBe('read');
+    expect(ops.get('profile_update_section')!.auth).toBe('write');
+    expect(ops.get('profile_correct')!.auth).toBe('write');
+    expect(ops.get('profile_delete')!.auth).toBe('admin');
+    expect(ops.get('profile_export')!.auth).toBe('read');
+    expect(ops.get('signal_accumulate')!.auth).toBe('write');
+    expect(ops.get('signal_list')!.auth).toBe('read');
+    expect(ops.get('signal_stats')!.auth).toBe('read');
+    expect(ops.get('synthesis_check')!.auth).toBe('read');
+    expect(ops.get('profile_snapshot')!.auth).toBe('write');
+  });
+
+  // ─── profile_get ───────────────────────────────────────────────
+
+  it('profile_get returns null when no profile', async () => {
+    const result = await executeOp(ops, 'profile_get', {});
+    expect(result.success).toBe(true);
+    expect((result.data as { profile: null }).profile).toBeNull();
+  });
+
+  it('profile_get returns specific section', async () => {
+    store.accumulateSignals([makeSignalPayload() as never]);
+    const result = await executeOp(ops, 'profile_get', { section: 'communication' });
+    expect(result.success).toBe(true);
+    expect((result.data as { section: string }).section).toBe('communication');
+  });
+
+  // ─── profile_update_section ────────────────────────────────────
+
+  it('profile_update_section updates section', async () => {
+    const result = await executeOp(ops, 'profile_update_section', {
+      section: 'communication',
+      data: {
+        style: 'concise',
+        signalWords: ['yo'],
+        formality: 0.3,
+        patience: 0.9,
+        adaptationRules: [],
+      },
+    });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).updated).toBe(true);
+  });
+
+  // ─── profile_correct ──────────────────────────────────────────
+
+  it('profile_correct takes snapshot before correcting', async () => {
+    store.accumulateSignals([makeSignalPayload() as never]);
+    const result = await executeOp(ops, 'profile_correct', {
+      section: 'identity',
+      data: { background: 'engineer', role: 'lead', philosophy: 'pragmatism', evidence: [] },
+      reason: 'User correction',
+    });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).corrected).toBe(true);
+  });
+
+  // ─── profile_delete ────────────────────────────────────────────
+
+  it('profile_delete removes profile', async () => {
+    store.accumulateSignals([makeSignalPayload() as never]);
+    const result = await executeOp(ops, 'profile_delete', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).deleted).toBe(true);
+    expect(store.getProfile()).toBeNull();
+  });
+
+  it('profile_delete returns false when no profile', async () => {
+    const result = await executeOp(ops, 'profile_delete', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).deleted).toBe(false);
+  });
+
+  // ─── profile_export ────────────────────────────────────────────
+
+  it('profile_export returns JSON by default', async () => {
+    store.accumulateSignals([makeSignalPayload() as never]);
+    const result = await executeOp(ops, 'profile_export', {});
+    expect(result.success).toBe(true);
+    const data = result.data as { exported: boolean; format: string; content: string };
+    expect(data.exported).toBe(true);
+    expect(data.format).toBe('json');
+    expect(() => JSON.parse(data.content)).not.toThrow();
+  });
+
+  it('profile_export returns markdown', async () => {
+    store.accumulateSignals([makeSignalPayload() as never]);
+    const result = await executeOp(ops, 'profile_export', { format: 'markdown' });
+    expect(result.success).toBe(true);
+    expect((result.data as { content: string }).content).toContain('# Operator Profile');
+  });
+
+  it('profile_export handles missing profile', async () => {
+    const result = await executeOp(ops, 'profile_export', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).exported).toBe(false);
+  });
+
+  // ─── signal_accumulate ─────────────────────────────────────────
+
+  it('signal_accumulate stores signals', async () => {
+    const signals = [makeSignalPayload(), makeSignalPayload(SignalType.Frustration)];
+    signals[1].data = { level: 'mild', trigger: 'slow', context: 'test' };
+    const result = await executeOp(ops, 'signal_accumulate', { signals });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).stored).toBe(2);
+  });
+
+  // ─── signal_list ───────────────────────────────────────────────
+
+  it('signal_list returns stored signals', async () => {
+    store.accumulateSignals([makeSignalPayload() as never]);
+    const result = await executeOp(ops, 'signal_list', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).count).toBe(1);
+  });
+
+  it('signal_list filters by type', async () => {
+    store.accumulateSignals([makeSignalPayload(SignalType.CommandStyle) as never]);
+    store.accumulateSignals([makeSignalPayload(SignalType.Frustration) as never]);
+    const result = await executeOp(ops, 'signal_list', { types: ['command_style'] });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).count).toBe(1);
+  });
+
+  // ─── signal_stats ──────────────────────────────────────────────
+
+  it('signal_stats returns breakdown', async () => {
+    store.accumulateSignals([makeSignalPayload() as never, makeSignalPayload() as never]);
+    const result = await executeOp(ops, 'signal_stats', {});
+    expect(result.success).toBe(true);
+    const data = result.data as { byType: Record<string, number>; totalUnprocessed: number };
+    expect(data.totalUnprocessed).toBe(2);
+  });
+
+  // ─── synthesis_check ───────────────────────────────────────────
+
+  it('synthesis_check reports not due with few signals', async () => {
+    store.accumulateSignals([makeSignalPayload() as never]);
+    const result = await executeOp(ops, 'synthesis_check', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).due).toBe(false);
+  });
+
+  // ─── profile_snapshot ──────────────────────────────────────────
+
+  it('profile_snapshot creates version', async () => {
+    store.accumulateSignals([makeSignalPayload() as never]);
+    const result = await executeOp(ops, 'profile_snapshot', { trigger: 'manual' });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).snapshotted).toBe(true);
+  });
+
+  it('profile_snapshot returns false when no profile', async () => {
+    const result = await executeOp(ops, 'profile_snapshot', { trigger: 'test' });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).snapshotted).toBe(false);
+  });
+});