@soleri/core 9.0.4 → 9.2.0

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

@@ -0,0 +1,302 @@
+/**
+ * Unit tests for session-briefing — session_briefing op + buildAdaptationSummary.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { captureOps, executeOp } from '../engine/test-helpers.js';
+import { createSessionBriefingOps, buildAdaptationSummary } from './session-briefing.js';
+import type { AgentRuntime } from './types.js';
+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 }> }>;
+  recentEntries?: Array<{ title: string }>;
+  recommendations?: Array<{ pattern: string; strength: number }>;
+  proposals?: Array<{ title: string; confidence: number; type: string; promoted: boolean }>;
+  healthScore?: number;
+  healthRecs?: string[];
+  operatorProfile?: OperatorProfile | null;
+}) {
+  const o = overrides ?? {};
+
+  return {
+    brainIntelligence: {
+      listSessions: (_opts: { limit: number; active: boolean }) => o.sessions ?? [],
+      recommend: (_opts: { limit: number }) => o.recommendations ?? [],
+      getProposals: (_opts: { promoted: boolean }) => o.proposals ?? [],
+    },
+    planner: {
+      list: () => o.plans ?? [],
+    },
+    vault: {
+      stats: () => o.vaultStats ?? { totalEntries: 50, byType: { playbook: 5 } },
+      getRecent: (_n: number) => o.recentEntries ?? [],
+    },
+    curator: {
+      healthAudit: () => ({
+        score: o.healthScore ?? 85,
+        recommendations: o.healthRecs ?? [],
+      }),
+    },
+    operatorProfile: {
+      getProfile: () => o.operatorProfile ?? null,
+    },
+  } as unknown as AgentRuntime;
+}
+
+describe('session-briefing', () => {
+  describe('session_briefing op', () => {
+    it('returns minimal briefing when all subsystems are empty', async () => {
+      const runtime = makeRuntime();
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      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 };
+      expect(data.generatedAt).toBeGreaterThan(0);
+      expect(Array.isArray(data.sections)).toBe(true);
+    });
+
+    it('shows Welcome section when vault has few entries', async () => {
+      const runtime = makeRuntime({ vaultStats: { totalEntries: 3, byType: { playbook: 0 } } });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+
+      const data = res.data as { sections: Array<{ label: string; content: string }> };
+      const welcome = data.sections.find((s) => s.label === 'Welcome');
+      expect(welcome).toBeDefined();
+      expect(welcome!.content).toContain('3 knowledge entries');
+    });
+
+    it('skips Welcome when vault has enough entries', async () => {
+      const runtime = makeRuntime({ vaultStats: { totalEntries: 50, byType: { playbook: 5 } } });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+
+      const data = res.data as { sections: Array<{ label: string }> };
+      expect(data.sections.find((s) => s.label === 'Welcome')).toBeUndefined();
+    });
+
+    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'],
+        }],
+      });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+
+      const data = res.data as { sections: Array<{ label: string; content: string }> };
+      const session = data.sections.find((s) => s.label === 'Last session');
+      expect(session).toBeDefined();
+      expect(session!.content).toContain('[frontend]');
+      expect(session!.content).toContain('Refactored button component');
+    });
+
+    it('includes Active plans section', async () => {
+      const runtime = makeRuntime({
+        plans: [
+          { id: 'p1', status: 'executing', objective: 'Build dashboard', tasks: [{ status: 'completed' }, { status: 'pending' }] },
+          { id: 'p2', status: 'completed', objective: 'Done', tasks: [] },
+        ],
+      });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      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'));
+      expect(plans).toBeDefined();
+      expect(plans!.content).toContain('Build dashboard');
+      expect(plans!.content).toContain('1/2 tasks');
+    });
+
+    it('includes Recent captures section', async () => {
+      const runtime = makeRuntime({
+        recentEntries: [
+          { title: 'Semantic token pattern' },
+          { title: 'Error boundary anti-pattern' },
+        ],
+      });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+
+      const data = res.data as { sections: Array<{ label: string; content: string }> };
+      const captures = data.sections.find((s) => s.label === 'Recent captures');
+      expect(captures).toBeDefined();
+      expect(captures!.content).toContain('Semantic token pattern');
+    });
+
+    it('includes Brain recommends section', async () => {
+      const runtime = makeRuntime({
+        recommendations: [
+          { pattern: 'TDD', strength: 0.92 },
+          { pattern: 'Vault-first', strength: 0.85 },
+        ],
+      });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+
+      const data = res.data as { sections: Array<{ label: string; content: string }> };
+      const brain = data.sections.find((s) => s.label === 'Brain recommends');
+      expect(brain).toBeDefined();
+      expect(brain!.content).toContain('TDD');
+    });
+
+    it('includes Attention section when health is low', async () => {
+      const runtime = makeRuntime({ healthScore: 50, healthRecs: ['Run curator groom'] });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+
+      const data = res.data as { sections: Array<{ label: string; content: string }> };
+      const attention = data.sections.find((s) => s.label === 'Attention');
+      expect(attention).toBeDefined();
+      expect(attention!.content).toContain('50/100');
+    });
+
+    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'] }],
+        plans: [{ id: 'p', status: 'executing', objective: 'o', tasks: [] }],
+        recentEntries: [{ title: 't' }],
+        recommendations: [{ pattern: 'p', strength: 0.9 }],
+        healthScore: 40,
+        healthRecs: ['Fix it'],
+      });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', { maxSections: 2 });
+
+      const data = res.data as { sections: unknown[] };
+      expect(data.sections.length).toBeLessThanOrEqual(2);
+    });
+
+    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'); },
+        },
+        planner: { list: () => { throw new Error('no plans'); } },
+        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'); } },
+      } as unknown as AgentRuntime;
+
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+      expect(res.success).toBe(true);
+      const data = res.data as { sections: unknown[] };
+      expect(data.sections).toEqual([]);
+    });
+
+    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: 'Low confidence', confidence: 0.2, type: 'anti-pattern', promoted: false },
+        ],
+      });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+
+      const data = res.data as { sections: Array<{ label: string; content: string }> };
+      const proposals = data.sections.find((s) => s.label === 'Pending proposals');
+      expect(proposals).toBeDefined();
+      expect(proposals!.content).toContain('Use TDD');
+      // Low confidence (0.2 < 0.4) should be filtered out
+      expect(proposals!.content).not.toContain('Low confidence');
+    });
+  });
+
+  describe('buildAdaptationSummary', () => {
+    function makeProfile(overrides?: Partial<OperatorProfile>): OperatorProfile {
+      return {
+        id: 'test',
+        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: [] },
+        workingRules: { rules: [], inferredPriorities: [] },
+        trustModel: { level: 'new', currentLevel: 0.5, challengeThreshold: 0.5, autonomyGrants: [], corrections: [] },
+        tasteProfile: { aestheticPreferences: [], toolPreferences: [], workflowPreferences: [] },
+        growthEdges: { observed: [], selfReported: [], progressNotes: [] },
+        technicalContext: { primaryLanguages: [], frameworks: [], expertiseLevels: [], environmentDetails: [] },
+        sessionCount: 0,
+        lastSynthesis: null,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        ...overrides,
+      } as OperatorProfile;
+    }
+
+    it('returns null when profile has no distinguishing data', () => {
+      const result = buildAdaptationSummary(makeProfile());
+      expect(result).toBeNull();
+    });
+
+    it('includes communication style when not mixed', () => {
+      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: [] },
+      }));
+      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: [],
+        },
+      }));
+      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: [],
+        },
+      }));
+      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: [] },
+      }));
+      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: [] },
+      }));
+      expect(result).toContain('check before acting');
+    });
+  });
+});

package/src/runtime/session-briefing.ts

@@ -11,6 +11,7 @@
 import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
+import type { OperatorProfile } from '../operator/operator-types.js';
 
 export interface BriefingSection {
   label: string;
@@ -133,7 +134,36 @@ export function createSessionBriefingOps(runtime: AgentRuntime): OpDefinition[]
           // Brain unavailable — skip
         }
 
-        // 5. Stale knowledge / health warnings
+        // 5. Pending brain proposals
+        try {
+          const pending = brainIntelligence
+            .getProposals({ promoted: false })
+            .filter((p) => p.confidence >= 0.4)
+            .sort((a, b) => b.confidence - a.confidence);
+          dataPoints += pending.length;
+          if (pending.length > 0) {
+            const top = pending
+              .slice(0, 3)
+              .map(
+                (p) =>
+                  `"${p.title.slice(0, 50)}" (confidence: ${p.confidence.toFixed(2)}, type: ${p.type})`,
+              );
+            const lines = [`${pending.length} awaiting review`, ...top.map((t) => `  - ${t}`)];
+            if (pending.length > 3) {
+              lines.push(
+                `  Use \`brain_promote_proposals\` to review, or \`radar_flush\` to batch-approve above threshold.`,
+              );
+            }
+            sections.push({
+              label: 'Pending proposals',
+              content: lines.join('\n'),
+            });
+          }
+        } catch {
+          // Brain proposals unavailable — skip
+        }
+
+        // 6. Stale knowledge / health warnings
         try {
           const health = curator.healthAudit();
           dataPoints += 1;
@@ -154,6 +184,20 @@ export function createSessionBriefingOps(runtime: AgentRuntime): OpDefinition[]
           // Curator unavailable — skip
         }
 
+        // 7. Operator adaptation
+        try {
+          const profile = runtime.operatorProfile.getProfile();
+          if (profile) {
+            const summary = buildAdaptationSummary(profile);
+            if (summary) {
+              sections.push({ label: 'Operator Adaptation', content: summary });
+              dataPoints += 1;
+            }
+          }
+        } catch {
+          // Operator profile unavailable — skip
+        }
+
         return {
           sections: sections.slice(0, maxSections),
           generatedAt: Date.now(),
@@ -164,6 +208,41 @@ export function createSessionBriefingOps(runtime: AgentRuntime): OpDefinition[]
   ];
 }
 
+/** Build a concise adaptation summary from an operator profile (5-8 lines max). */
+export function buildAdaptationSummary(profile: OperatorProfile): string | null {
+  const lines: string[] = [];
+  const { communication, trustModel, workingRules, growthEdges } = profile;
+
+  // Communication style
+  if (communication.style && communication.style !== 'mixed') {
+    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';
+    lines.push(`Trust: ${trustModel.level} — ${autonomy}`);
+  }
+
+  // Work priorities (from top working rules)
+  const topRules = workingRules.rules.slice(0, 3);
+  if (topRules.length > 0) {
+    const ruleTexts = topRules.map((r) => r.rule.slice(0, 60));
+    lines.push(`Priorities: ${ruleTexts.join('; ')}`);
+  }
+
+  // Growth edges
+  const edges = [...growthEdges.observed, ...growthEdges.selfReported];
+  if (edges.length > 0) {
+    const edgeNames = edges.slice(0, 3).map((e) => e.area);
+    lines.push(`Growth edges: ${edgeNames.join(', ')}`);
+  }
+
+  return lines.length > 0 ? lines.join('\n') : null;
+}
+
 function formatTimeAgo(timestamp: number): string {
   const diff = Date.now() - timestamp;
   const minutes = Math.floor(diff / 60000);

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

@@ -0,0 +1,221 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createSyncOps } from './sync-ops.js';
+import type { AgentRuntime } from './types.js';
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+vi.mock('../vault/git-vault-sync.js', () => ({
+  GitVaultSync: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+    this.init = vi.fn().mockResolvedValue(undefined);
+    this.syncAll = vi.fn().mockResolvedValue({ pushed: 5 });
+    this.pull = vi.fn().mockResolvedValue({ imported: 3, conflicts: 0 });
+    this.sync = vi.fn().mockResolvedValue({ pushed: 2, pulled: 1 });
+  }),
+}));
+
+vi.mock('../vault/linking.js', () => ({
+  LinkManager: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+    this.getAllLinksForEntries = vi.fn().mockReturnValue([]);
+    this.addLink = vi.fn();
+  }),
+}));
+
+vi.mock('../vault/obsidian-sync.js', () => ({
+  ObsidianSync: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+    this.export = vi.fn().mockResolvedValue({ exported: 10 });
+    this.import = vi.fn().mockResolvedValue({ imported: 5 });
+    this.sync = vi.fn().mockResolvedValue({ pushed: 3, pulled: 2 });
+  }),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock runtime
+// ---------------------------------------------------------------------------
+
+function mockRuntime(): AgentRuntime {
+  return {
+    config: { agentId: 'test-agent' },
+    vault: {
+      get: vi.fn(),
+      seed: vi.fn(),
+      seedDedup: vi.fn().mockReturnValue([]),
+      list: vi.fn().mockReturnValue([]),
+      exportAll: vi.fn().mockReturnValue({ entries: [] }),
+      getProvider: vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue([]),
+        get: vi.fn(),
+        run: vi.fn(),
+      }),
+    },
+  } as unknown as AgentRuntime;
+}
+
+function findOp(ops: ReturnType<typeof createSyncOps>, name: string) {
+  const op = ops.find((o) => o.name === name);
+  if (!op) throw new Error(`Op "${name}" not found`);
+  return op;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('createSyncOps', () => {
+  let rt: AgentRuntime;
+  let ops: ReturnType<typeof createSyncOps>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    rt = mockRuntime();
+    ops = createSyncOps(rt);
+  });
+
+  it('returns 8 ops', () => {
+    expect(ops.length).toBe(8);
+  });
+
+  it('has the expected op names', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'vault_git_push',
+      'vault_git_pull',
+      'vault_git_sync',
+      'obsidian_export',
+      'obsidian_import',
+      'obsidian_sync',
+      'vault_export_pack',
+      'vault_import_pack',
+    ]);
+  });
+
+  // ─── vault_git_push ───────────────────────────────────────────
+
+  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
+      >;
+      expect(result.pushed).toBe(5);
+    });
+  });
+
+  // ─── vault_git_pull ───────────────────────────────────────────
+
+  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
+      >;
+      expect(result.imported).toBe(3);
+    });
+  });
+
+  // ─── vault_git_sync ───────────────────────────────────────────
+
+  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
+      >;
+      expect(result.pushed).toBe(2);
+      expect(result.pulled).toBe(1);
+    });
+  });
+
+  // ─── obsidian_export ──────────────────────────────────────────
+
+  describe('obsidian_export', () => {
+    it('exports entries to Obsidian format', async () => {
+      const op = findOp(ops, 'obsidian_export');
+      const result = (await op.handler({ obsidianDir: '/tmp/obsidian' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.exported).toBe(10);
+    });
+  });
+
+  // ─── obsidian_import ──────────────────────────────────────────
+
+  describe('obsidian_import', () => {
+    it('imports from Obsidian directory', async () => {
+      const op = findOp(ops, 'obsidian_import');
+      const result = (await op.handler({ obsidianDir: '/tmp/obsidian' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.imported).toBe(5);
+    });
+  });
+
+  // ─── obsidian_sync ────────────────────────────────────────────
+
+  describe('obsidian_sync', () => {
+    it('performs bidirectional Obsidian sync', async () => {
+      const op = findOp(ops, 'obsidian_sync');
+      const result = (await op.handler({ obsidianDir: '/tmp/obsidian' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.pushed).toBe(3);
+      expect(result.pulled).toBe(2);
+    });
+  });
+
+  // ─── vault_export_pack ────────────────────────────────────────
+
+  describe('vault_export_pack', () => {
+    it('exports entries as intelligence bundles', async () => {
+      const op = findOp(ops, 'vault_export_pack');
+      vi.mocked(rt.vault.list).mockReturnValue([
+        { id: 'e1', domain: 'testing', tier: 'team', tags: [] },
+        { id: 'e2', domain: 'testing', tier: 'team', tags: [] },
+      ] as never);
+      const result = (await op.handler({ tier: 'team' })) as Record<string, unknown>;
+      expect(result.totalEntries).toBe(2);
+      expect(result.name).toBe('test-agent');
+    });
+
+    it('excludes specified IDs', async () => {
+      const op = findOp(ops, 'vault_export_pack');
+      vi.mocked(rt.vault.list).mockReturnValue([
+        { id: 'e1', domain: 'd', tier: 'team', tags: [] },
+        { id: 'e2', domain: 'd', tier: 'team', tags: [] },
+      ] as never);
+      const result = (await op.handler({ excludeIds: ['e1'] })) as Record<string, unknown>;
+      expect(result.totalEntries).toBe(1);
+    });
+  });
+
+  // ─── vault_import_pack ────────────────────────────────────────
+
+  describe('vault_import_pack', () => {
+    it('imports bundles and returns counts', async () => {
+      const op = findOp(ops, 'vault_import_pack');
+      vi.mocked(rt.vault.seedDedup).mockReturnValue([
+        { id: 'new-1', action: 'inserted' },
+        { id: 'dup-1', action: 'skipped', existingId: 'existing-1' },
+      ] as never);
+      const result = (await op.handler({
+        bundles: [
+          {
+            domain: 'testing',
+            version: '1.0.0',
+            entries: [{ id: 'e1' }, { id: 'e2' }],
+          },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.imported).toBe(1);
+      expect(result.duplicates).toBe(1);
+      expect(result.total).toBe(2);
+    });
+  });
+});