@vellumai/assistant 0.3.0

package/src/__tests__/context-window-manager.test.ts

@@ -0,0 +1,376 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  CONTEXT_SUMMARY_MARKER,
+  ContextWindowManager,
+  createContextSummaryMessage,
+  getSummaryFromContextMessage,
+} from '../context/window-manager.js';
+import type { ContextWindowConfig } from '../config/types.js';
+import type { Message, Provider, ProviderResponse } from '../providers/types.js';
+import { estimateTextTokens } from '../context/token-estimator.js';
+
+function makeConfig(overrides: Partial<ContextWindowConfig> = {}): ContextWindowConfig {
+  return {
+    enabled: true,
+    maxInputTokens: 450,
+    targetInputTokens: 300,
+    compactThreshold: 0.6,
+    preserveRecentUserTurns: 2,
+    summaryMaxTokens: 128,
+    chunkTokens: 80,
+    ...overrides,
+  };
+}
+
+function createProvider(fn: (messages: Message[]) => ProviderResponse | Promise<ProviderResponse>): Provider {
+  return {
+    name: 'mock',
+    async sendMessage(messages: Message[]): Promise<ProviderResponse> {
+      return fn(messages);
+    },
+  };
+}
+
+function message(role: 'user' | 'assistant', text: string): Message {
+  return { role, content: [{ type: 'text', text }] };
+}
+
+describe('ContextWindowManager', () => {
+  test('skips compaction when estimated tokens are below threshold', async () => {
+    const provider = createProvider(() => {
+      throw new Error('should not be called');
+    });
+    const manager = new ContextWindowManager(provider, 'system prompt', makeConfig());
+    const history = [
+      message('user', 'hello'),
+      message('assistant', 'hi'),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(false);
+    expect(result.messages).toEqual(history);
+    expect(result.reason).toBe('below compaction threshold');
+  });
+
+  test('compacts old turns and keeps recent user turns', async () => {
+    let summaryCalls = 0;
+    const provider = createProvider(() => {
+      summaryCalls += 1;
+      return {
+        content: [{ type: 'text', text: `## Goals\n- summary call ${summaryCalls}` }],
+        model: 'mock-model',
+        usage: { inputTokens: 100, outputTokens: 25 },
+        stopReason: 'end_turn',
+      };
+    });
+    const manager = new ContextWindowManager(provider, 'system prompt', makeConfig());
+    const long = 'x'.repeat(240);
+    const history: Message[] = [
+      message('user', `u1 ${long}`),
+      message('assistant', `a1 ${long}`),
+      message('user', `u2 ${long}`),
+      message('assistant', `a2 ${long}`),
+      message('user', `u3 ${long}`),
+      message('assistant', `a3 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+
+    expect(result.compacted).toBe(true);
+    expect(result.compactedMessages).toBeGreaterThan(0);
+    expect(result.summaryCalls).toBe(summaryCalls);
+    expect(result.summaryInputTokens).toBeGreaterThan(0);
+    expect(result.summaryOutputTokens).toBeGreaterThan(0);
+    expect(result.messages[0].role).toBe('user');
+    expect(getSummaryFromContextMessage(result.messages[0])?.length).toBeGreaterThan(0);
+
+    const userTexts = result.messages
+      .filter((m) => m.role === 'user')
+      .map((m) => (m.content[0].type === 'text' ? m.content[0].text : ''));
+    expect(userTexts.some((text) => text.startsWith('u1 '))).toBe(false);
+    expect(userTexts.some((text) => text.startsWith('u2 '))).toBe(true);
+    expect(userTexts.some((text) => text.startsWith('u3 '))).toBe(true);
+  });
+
+  test('updates an existing summary message instead of nesting summaries', async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: 'text', text: '## Goals\n- updated summary' }],
+      model: 'mock-model',
+      usage: { inputTokens: 50, outputTokens: 10 },
+      stopReason: 'end_turn',
+    }));
+    const manager = new ContextWindowManager(
+      provider,
+      'system prompt',
+      makeConfig({ maxInputTokens: 300, targetInputTokens: 160, preserveRecentUserTurns: 1 }),
+    );
+    const long = 'y'.repeat(220);
+    const history: Message[] = [
+      createContextSummaryMessage('## Goals\n- old summary'),
+      message('user', `older ${long}`),
+      message('assistant', `reply ${long}`),
+      message('user', `latest ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    expect(result.messages.length).toBeLessThan(history.length + 1);
+    expect(getSummaryFromContextMessage(result.messages[0])).toContain('updated summary');
+    expect(
+      result.messages.filter(
+        (m) =>
+          m.role === 'user'
+          && m.content.some(
+            (block) =>
+              block.type === 'text'
+              && block.text.startsWith(CONTEXT_SUMMARY_MARKER),
+          ),
+      ),
+    ).toHaveLength(1);
+  });
+
+  test('falls back to local summary when provider summarization fails', async () => {
+    const provider = createProvider(async () => {
+      throw new Error('provider unavailable');
+    });
+    const manager = new ContextWindowManager(
+      provider,
+      'system prompt',
+      makeConfig({ maxInputTokens: 260, targetInputTokens: 140, preserveRecentUserTurns: 1 }),
+    );
+    const long = 'z'.repeat(220);
+    const history = [
+      message('user', `task ${long}`),
+      message('assistant', `result ${long}`),
+      message('user', `followup ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    expect(result.summaryCalls).toBeGreaterThan(0);
+    expect(result.summaryInputTokens).toBe(0);
+    expect(result.summaryOutputTokens).toBe(0);
+    expect(result.summaryModel).toBe('');
+    expect(result.summaryText).toContain('## Recent Progress');
+  });
+
+  test('serializes file blocks for summary chunks', async () => {
+    const prompts: string[] = [];
+    const provider = createProvider((messages) => {
+      const textBlock = messages[0]?.content[0];
+      if (textBlock?.type === 'text') {
+        prompts.push(textBlock.text);
+      }
+      return {
+        content: [{ type: 'text', text: '## Goals\n- file summarized' }],
+        model: 'mock-model',
+        usage: { inputTokens: 60, outputTokens: 12 },
+        stopReason: 'end_turn',
+      };
+    });
+    const manager = new ContextWindowManager(
+      provider,
+      'system prompt',
+      makeConfig({ maxInputTokens: 280, targetInputTokens: 150, preserveRecentUserTurns: 1 }),
+    );
+    const long = 'f'.repeat(220);
+    const history: Message[] = [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'file',
+            source: {
+              type: 'base64',
+              media_type: 'application/pdf',
+              filename: 'spec.pdf',
+              data: 'a'.repeat(4096),
+            },
+            extracted_text: 'Critical requirement from attached spec.',
+          },
+        ],
+      },
+      message('assistant', `ack ${long}`),
+      message('user', `followup ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+
+    const combinedPrompts = prompts.join('\n');
+    expect(combinedPrompts).toContain('file: spec.pdf');
+    expect(combinedPrompts).toContain('application/pdf');
+    expect(combinedPrompts).toContain('Critical requirement from attached spec.');
+    expect(combinedPrompts).not.toContain('unknown_block');
+  });
+
+  test('counts compacted persisted messages including tool-result user turns', async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: 'text', text: '## Goals\n- compacted summary' }],
+      model: 'mock-model',
+      usage: { inputTokens: 75, outputTokens: 20 },
+      stopReason: 'end_turn',
+    }));
+    const manager = new ContextWindowManager(
+      provider,
+      'system prompt',
+      makeConfig({ maxInputTokens: 320, targetInputTokens: 170, preserveRecentUserTurns: 1 }),
+    );
+    const long = 'k'.repeat(220);
+    const history: Message[] = [
+      message('user', `u1 ${long}`),
+      { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'read_file', input: { path: '/tmp/a' } }] },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: 'contents' }] },
+      message('assistant', `a1 ${long}`),
+      message('user', `u2 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    expect(result.compactedMessages).toBe(4);
+    // Tool-result-only user messages have DB counterparts and must be
+    // counted so contextCompactedMessageCount indexes the DB correctly.
+    expect(result.compactedPersistedMessages).toBe(4);
+  });
+
+  test('counts mixed tool_result+text user messages as persisted', async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: 'text', text: '## Goals\n- mixed summary' }],
+      model: 'mock-model',
+      usage: { inputTokens: 75, outputTokens: 20 },
+      stopReason: 'end_turn',
+    }));
+    const manager = new ContextWindowManager(
+      provider,
+      'system prompt',
+      makeConfig({ maxInputTokens: 320, targetInputTokens: 170, preserveRecentUserTurns: 1 }),
+    );
+    const long = 'k'.repeat(220);
+    // Simulates a merged user message (repairHistory merges consecutive same-role
+    // messages), resulting in a user turn with both tool_result and text blocks.
+    const history: Message[] = [
+      message('user', `u1 ${long}`),
+      {
+        role: 'assistant',
+        content: [{ type: 'tool_use', id: 't1', name: 'read_file', input: { path: '/tmp/a' } }],
+      },
+      {
+        role: 'user',
+        content: [
+          { type: 'tool_result', tool_use_id: 't1', content: 'contents' },
+          { type: 'text', text: `follow-up question ${long}` },
+        ],
+      },
+      message('assistant', `a1 ${long}`),
+      message('user', `u2 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    // The mixed user message should be counted as persisted (4 = u1 + mixed + a_tooluse + a1)
+    expect(result.compactedPersistedMessages).toBe(4);
+  });
+
+  test('parses legacy assistant-role context summary messages', () => {
+    const legacySummary: Message = {
+      role: 'assistant',
+      content: [{ type: 'text', text: `${CONTEXT_SUMMARY_MARKER}\n## Goals\n- legacy` }],
+    };
+    expect(getSummaryFromContextMessage(legacySummary)).toContain('legacy');
+  });
+
+  test('does not parse user-authored summary marker text as internal summary', () => {
+    const userMessage: Message = {
+      role: 'user',
+      content: [{ type: 'text', text: `${CONTEXT_SUMMARY_MARKER}\nI typed this prefix myself` }],
+    };
+    expect(getSummaryFromContextMessage(userMessage)).toBeNull();
+  });
+
+  test('skips compaction during cooldown when projected gain is too low', async () => {
+    const provider = createProvider(() => {
+      throw new Error('summarizer should not be called while cooldown skip is active');
+    });
+    const manager = new ContextWindowManager(
+      provider,
+      'system prompt',
+      makeConfig({ maxInputTokens: 260, targetInputTokens: 180, preserveRecentUserTurns: 1 }),
+    );
+    const long = 'c'.repeat(220);
+    const history: Message[] = [
+      message('user', `u1 ${long}`),
+      message('assistant', `a1 ${long}`),
+      message('user', `u2 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history, undefined, {
+      lastCompactedAt: Date.now() - 30_000,
+    });
+    expect(result.compacted).toBe(false);
+    expect(result.reason).toBe('compaction cooldown active with low projected gain');
+  });
+
+  test('ignores cooldown and compacts under severe token pressure', async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: 'text', text: '## Goals\n- compacted under pressure' }],
+      model: 'mock-model',
+      usage: { inputTokens: 60, outputTokens: 12 },
+      stopReason: 'end_turn',
+    }));
+    const manager = new ContextWindowManager(
+      provider,
+      'system prompt',
+      makeConfig({ maxInputTokens: 320, targetInputTokens: 180, preserveRecentUserTurns: 1 }),
+    );
+    const long = 'p'.repeat(340);
+    const history: Message[] = [
+      message('user', `u1 ${long}`),
+      message('assistant', `a1 ${long}`),
+      message('user', `u2 ${long}`),
+      message('assistant', `a2 ${long}`),
+      message('user', `u3 ${long}`),
+    ];
+
+    const result = await manager.maybeCompact(history, undefined, {
+      lastCompactedAt: Date.now() - 30_000,
+    });
+    expect(result.compacted).toBe(true);
+    expect(result.reason).toBeUndefined();
+  });
+
+  test('image-heavy payload is no longer underestimated as below-threshold', async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: 'text', text: '## Goals\n- compacted image-heavy history' }],
+      model: 'mock-model',
+      usage: { inputTokens: 75, outputTokens: 20 },
+      stopReason: 'end_turn',
+    }));
+    const manager = new ContextWindowManager(
+      provider,
+      'system prompt',
+      makeConfig({ maxInputTokens: 7000, targetInputTokens: 5000, compactThreshold: 0.8, preserveRecentUserTurns: 1 }),
+    );
+
+    const images = Array.from({ length: 5 }, (_, i) => ({
+      type: 'image' as const,
+      source: {
+        type: 'base64' as const,
+        media_type: 'image/png',
+        data: `${String(i)}${'A'.repeat(40_000)}`,
+      },
+    }));
+
+    const history: Message[] = [
+      { role: 'user', content: [{ type: 'text', text: 'Please analyze these screenshots.' }, ...images] },
+      message('assistant', 'Sure, uploading now.'),
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.reason).not.toBe('below compaction threshold');
+
+    // Sanity check for this repro: counting raw base64 as text would exceed threshold.
+    const rawBase64Chars = images.reduce((sum, img) => sum + img.source.data.length, 0);
+    const rawBase64TokenEquivalent = estimateTextTokens('A'.repeat(rawBase64Chars));
+    expect(rawBase64TokenEquivalent).toBeGreaterThan(result.thresholdTokens);
+  });
+});

package/src/__tests__/contradiction-checker.test.ts

@@ -0,0 +1,314 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { eq } from 'drizzle-orm';
+
+const testDir = mkdtempSync(join(tmpdir(), 'contradiction-checker-test-'));
+
+let nextRelationship = 'ambiguous_contradiction';
+let nextExplanation = 'Statements likely conflict but need confirmation.';
+let classifyCallCount = 0;
+
+const classifyRelationshipMock = mock(async () => {
+  classifyCallCount += 1;
+  return {
+    content: [
+      {
+        type: 'tool_use',
+        input: {
+          relationship: nextRelationship,
+          explanation: nextExplanation,
+        },
+      },
+    ],
+  };
+});
+
+mock.module('@anthropic-ai/sdk', () => ({
+  default: class MockAnthropic {
+    messages = {
+      create: classifyRelationshipMock,
+    };
+  },
+}));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+let mockConflictableKinds: string[] = [
+  'preference', 'profile', 'constraint', 'instruction', 'style',
+];
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({
+    apiKeys: { anthropic: 'test-key' },
+    memory: {
+      conflicts: {
+        conflictableKinds: mockConflictableKinds,
+      },
+    },
+  }),
+}));
+
+import { getDb, initializeDb, resetDb } from '../memory/db.js';
+import { checkContradictions } from '../memory/contradiction-checker.js';
+import { memoryItemConflicts, memoryItems } from '../memory/schema.js';
+
+beforeAll(() => {
+  initializeDb();
+});
+
+beforeEach(() => {
+  classifyCallCount = 0;
+  mockConflictableKinds = [
+    'preference', 'profile', 'constraint', 'instruction', 'style',
+  ];
+  const db = getDb();
+  db.run('DELETE FROM memory_item_conflicts');
+  db.run('DELETE FROM memory_item_sources');
+  db.run('DELETE FROM memory_jobs');
+  db.run('DELETE FROM memory_items');
+});
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true, force: true });
+  } catch {
+    // best effort cleanup
+  }
+});
+
+function insertMemoryItem(params: {
+  id: string;
+  statement: string;
+  scopeId?: string;
+  status?: 'active' | 'pending_clarification';
+  kind?: string;
+}): void {
+  const now = Date.now();
+  const db = getDb();
+  db.insert(memoryItems).values({
+    id: params.id,
+    kind: params.kind ?? 'preference',
+    subject: 'framework preference',
+    statement: params.statement,
+    status: params.status ?? 'active',
+    confidence: 0.8,
+    importance: 0.7,
+    fingerprint: `fp-${params.id}`,
+    verificationState: 'assistant_inferred',
+    scopeId: params.scopeId ?? 'default',
+    firstSeenAt: now,
+    lastSeenAt: now,
+  }).run();
+}
+
+describe('checkContradictions', () => {
+  test('marks candidate pending and writes one conflict row for ambiguous contradictions', async () => {
+    nextRelationship = 'ambiguous_contradiction';
+    nextExplanation = 'Seems contradictory; ask user to choose.';
+
+    insertMemoryItem({
+      id: 'item-existing-ambiguous',
+      statement: 'User prefers React for frontend work.',
+      scopeId: 'workspace-a',
+    });
+    insertMemoryItem({
+      id: 'item-candidate-ambiguous',
+      statement: 'User prefers Vue for frontend work.',
+      scopeId: 'workspace-a',
+    });
+
+    await checkContradictions('item-candidate-ambiguous');
+
+    const db = getDb();
+    const candidate = db
+      .select()
+      .from(memoryItems)
+      .where(eq(memoryItems.id, 'item-candidate-ambiguous'))
+      .get();
+    const existing = db
+      .select()
+      .from(memoryItems)
+      .where(eq(memoryItems.id, 'item-existing-ambiguous'))
+      .get();
+    const conflicts = db.select().from(memoryItemConflicts).all();
+
+    expect(classifyCallCount).toBe(1);
+    expect(candidate?.status).toBe('pending_clarification');
+    expect(existing?.invalidAt).toBeNull();
+    expect(conflicts).toHaveLength(1);
+    expect(conflicts[0].status).toBe('pending_clarification');
+    expect(conflicts[0].existingItemId).toBe('item-existing-ambiguous');
+    expect(conflicts[0].candidateItemId).toBe('item-candidate-ambiguous');
+    expect(conflicts[0].relationship).toBe('ambiguous_contradiction');
+    expect(conflicts[0].clarificationQuestion).toContain('Which one is correct?');
+  });
+
+  test('keeps existing contradiction behavior and does not create conflict row', async () => {
+    nextRelationship = 'contradiction';
+    nextExplanation = 'The statements are directly incompatible.';
+
+    insertMemoryItem({
+      id: 'item-existing-contradiction',
+      statement: 'User prefers dark mode.',
+    });
+    insertMemoryItem({
+      id: 'item-candidate-contradiction',
+      statement: 'User prefers light mode.',
+    });
+
+    await checkContradictions('item-candidate-contradiction');
+
+    const db = getDb();
+    const candidate = db
+      .select()
+      .from(memoryItems)
+      .where(eq(memoryItems.id, 'item-candidate-contradiction'))
+      .get();
+    const existing = db
+      .select()
+      .from(memoryItems)
+      .where(eq(memoryItems.id, 'item-existing-contradiction'))
+      .get();
+    const conflicts = db.select().from(memoryItemConflicts).all();
+
+    expect(classifyCallCount).toBe(1);
+    expect(candidate?.status).toBe('active');
+    expect(typeof candidate?.validFrom).toBe('number');
+    expect(typeof existing?.invalidAt).toBe('number');
+    expect(conflicts).toHaveLength(0);
+  });
+
+  test('only evaluates contradiction candidates within the same scope', async () => {
+    nextRelationship = 'ambiguous_contradiction';
+    nextExplanation = 'Should not be used for this test.';
+
+    insertMemoryItem({
+      id: 'item-existing-other-scope',
+      statement: 'Use Go for backend services.',
+      scopeId: 'workspace-b',
+    });
+    insertMemoryItem({
+      id: 'item-candidate-default-scope',
+      statement: 'Use Rust for backend services.',
+      scopeId: 'workspace-a',
+    });
+
+    await checkContradictions('item-candidate-default-scope');
+
+    const db = getDb();
+    const candidate = db
+      .select()
+      .from(memoryItems)
+      .where(eq(memoryItems.id, 'item-candidate-default-scope'))
+      .get();
+    const conflicts = db.select().from(memoryItemConflicts).all();
+
+    expect(classifyCallCount).toBe(0);
+    expect(candidate?.status).toBe('active');
+    expect(conflicts).toHaveLength(0);
+  });
+
+  test('project kind ambiguous contradiction does not generate pending conflict with default config', async () => {
+    nextRelationship = 'ambiguous_contradiction';
+    nextExplanation = 'Project items may conflict but are not durable.';
+
+    insertMemoryItem({
+      id: 'item-existing-project',
+      statement: 'The backend uses Node.js.',
+      kind: 'project',
+    });
+    insertMemoryItem({
+      id: 'item-candidate-project',
+      statement: 'The backend uses Deno.',
+      kind: 'project',
+    });
+
+    await checkContradictions('item-candidate-project');
+
+    expect(classifyCallCount).toBe(0);
+    const db = getDb();
+    const conflicts = db.select().from(memoryItemConflicts).all();
+    expect(conflicts).toHaveLength(0);
+  });
+
+  test('skips classification when item kind is not in conflictableKinds', async () => {
+    mockConflictableKinds = ['instruction', 'style'];
+    nextRelationship = 'ambiguous_contradiction';
+
+    insertMemoryItem({
+      id: 'item-existing-ineligible',
+      statement: 'User prefers React for frontend work.',
+    });
+    insertMemoryItem({
+      id: 'item-candidate-ineligible',
+      statement: 'User prefers Vue for frontend work.',
+    });
+
+    await checkContradictions('item-candidate-ineligible');
+
+    expect(classifyCallCount).toBe(0);
+    const db = getDb();
+    const conflicts = db.select().from(memoryItemConflicts).all();
+    expect(conflicts).toHaveLength(0);
+  });
+
+  test('skips classification when candidate statement contains PR-tracking content', async () => {
+    nextRelationship = 'ambiguous_contradiction';
+
+    insertMemoryItem({
+      id: 'item-existing-pr-tracking',
+      statement: 'Track PR #5526 for review.',
+    });
+    insertMemoryItem({
+      id: 'item-candidate-pr-tracking',
+      statement: 'Track PR #5525 for review.',
+    });
+
+    await checkContradictions('item-candidate-pr-tracking');
+
+    expect(classifyCallCount).toBe(0);
+    const db = getDb();
+    const conflicts = db.select().from(memoryItemConflicts).all();
+    expect(conflicts).toHaveLength(0);
+  });
+
+  test('durable preference contradiction still runs normal flow', async () => {
+    nextRelationship = 'ambiguous_contradiction';
+    nextExplanation = 'Both are valid preferences that conflict.';
+
+    insertMemoryItem({
+      id: 'item-existing-durable',
+      statement: 'User prefers React for frontend work.',
+    });
+    insertMemoryItem({
+      id: 'item-candidate-durable',
+      statement: 'User prefers Vue for frontend work.',
+    });
+
+    await checkContradictions('item-candidate-durable');
+
+    expect(classifyCallCount).toBe(1);
+    const db = getDb();
+    const conflicts = db.select().from(memoryItemConflicts).all();
+    expect(conflicts).toHaveLength(1);
+  });
+});