@vellumai/assistant 0.3.4 → 0.3.6

package/src/memory/conflict-store.ts

@@ -1,8 +1,9 @@
 import { and, asc, eq } from 'drizzle-orm';
 import { v4 as uuid } from 'uuid';
-import { getDb } from './db.js';
+import { getDb, getSqlite, rawAll } from './db.js';
 import { enqueueMemoryJob } from './jobs-store.js';
 import { memoryItemConflicts, memoryItems } from './schema.js';
+import { clampUnitInterval } from './validation.js';
 
 export type MemoryConflictRelationship =
   | 'contradiction'
@@ -64,48 +65,54 @@ export interface ApplyConflictResolutionInput {
 }
 
 export function createOrUpdatePendingConflict(input: CreatePendingConflictInput): MemoryItemConflict {
-  const db = getDb();
-  const now = Date.now();
-  const scopeId = input.scopeId;
-  const existing = getPendingConflictByPair(scopeId, input.existingItemId, input.candidateItemId);
+  // Wrap in BEGIN IMMEDIATE so the SELECT-then-INSERT is atomic against concurrent
+  // writers. Without this, two parallel memory workers could both observe no
+  // existing conflict and both attempt to INSERT the same pair, resulting in a
+  // duplicate or an unexpected constraint violation.
+  return getSqlite().transaction((): MemoryItemConflict => {
+    const db = getDb();
+    const now = Date.now();
+    const scopeId = input.scopeId;
+    const existing = getPendingConflictByPair(scopeId, input.existingItemId, input.candidateItemId);
 
-  if (existing) {
-    db.update(memoryItemConflicts)
-      .set({
-        relationship: input.relationship,
-        clarificationQuestion: input.clarificationQuestion !== undefined ? input.clarificationQuestion : existing.clarificationQuestion,
-        updatedAt: now,
-      })
-      .where(eq(memoryItemConflicts.id, existing.id))
-      .run();
-    const updated = getConflictById(existing.id);
-    if (!updated) {
-      throw new Error(`Failed to reload updated conflict: ${existing.id}`);
+    if (existing) {
+      db.update(memoryItemConflicts)
+        .set({
+          relationship: input.relationship,
+          clarificationQuestion: input.clarificationQuestion !== undefined ? input.clarificationQuestion : existing.clarificationQuestion,
+          updatedAt: now,
+        })
+        .where(eq(memoryItemConflicts.id, existing.id))
+        .run();
+      const updated = getConflictById(existing.id);
+      if (!updated) {
+        throw new Error(`Failed to reload updated conflict: ${existing.id}`);
+      }
+      return updated;
     }
-    return updated;
-  }
 
-  const id = uuid();
-  db.insert(memoryItemConflicts).values({
-    id,
-    scopeId,
-    existingItemId: input.existingItemId,
-    candidateItemId: input.candidateItemId,
-    relationship: input.relationship,
-    status: 'pending_clarification',
-    clarificationQuestion: input.clarificationQuestion ?? null,
-    resolutionNote: null,
-    lastAskedAt: null,
-    resolvedAt: null,
-    createdAt: now,
-    updatedAt: now,
-  }).run();
+    const id = uuid();
+    db.insert(memoryItemConflicts).values({
+      id,
+      scopeId,
+      existingItemId: input.existingItemId,
+      candidateItemId: input.candidateItemId,
+      relationship: input.relationship,
+      status: 'pending_clarification',
+      clarificationQuestion: input.clarificationQuestion ?? null,
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: now,
+      updatedAt: now,
+    }).run();
 
-  const created = getConflictById(id);
-  if (!created) {
-    throw new Error(`Failed to load created conflict: ${id}`);
-  }
-  return created;
+    const created = getConflictById(id);
+    if (!created) {
+      throw new Error(`Failed to load created conflict: ${id}`);
+    }
+    return created;
+  }).immediate();
 }
 
 export function getConflictById(conflictId: string): MemoryItemConflict | null {
@@ -155,9 +162,25 @@ export function listPendingConflicts(scopeId: string, limit = 100): MemoryItemCo
 
 export function listPendingConflictDetails(scopeId: string, limit = 100): PendingConflictDetail[] {
   if (limit <= 0) return [];
-  const db = getDb();
-  const raw = (db as unknown as { $client: { query: (q: string) => { all: (...params: unknown[]) => unknown[] } } }).$client;
-  const rows = raw.query(`
+  interface ConflictDetailRow {
+    id: string;
+    scope_id: string;
+    existing_item_id: string;
+    candidate_item_id: string;
+    relationship: string;
+    status: MemoryConflictStatus;
+    clarification_question: string | null;
+    resolution_note: string | null;
+    last_asked_at: number | null;
+    resolved_at: number | null;
+    created_at: number;
+    updated_at: number;
+    existing_statement: string;
+    candidate_statement: string;
+    existing_kind: string;
+    candidate_kind: string;
+  }
+  const rows = rawAll<ConflictDetailRow>(`
     SELECT
       c.id,
       c.scope_id,
@@ -182,24 +205,7 @@ export function listPendingConflictDetails(scopeId: string, limit = 100): Pendin
       AND c.status = 'pending_clarification'
     ORDER BY c.created_at ASC
     LIMIT ?
-  `).all(scopeId, limit) as Array<{
-    id: string;
-    scope_id: string;
-    existing_item_id: string;
-    candidate_item_id: string;
-    relationship: string;
-    status: MemoryConflictStatus;
-    clarification_question: string | null;
-    resolution_note: string | null;
-    last_asked_at: number | null;
-    resolved_at: number | null;
-    created_at: number;
-    updated_at: number;
-    existing_statement: string;
-    candidate_statement: string;
-    existing_kind: string;
-    candidate_kind: string;
-  }>;
+  `, scopeId, limit);
 
   return rows.map((row) => ({
     id: row.id,
@@ -314,7 +320,7 @@ export function applyConflictResolution(input: ApplyConflictResolutionInput): bo
           status: 'active',
           invalidAt: null,
           lastSeenAt: Math.max(existingItem.lastSeenAt, candidateItem.lastSeenAt, now),
-          confidence: Math.max(existingItem.confidence, candidateItem.confidence),
+          confidence: clampUnitInterval(Math.max(existingItem.confidence, candidateItem.confidence)),
         })
         .where(eq(memoryItems.id, existingItem.id))
         .run();

package/src/memory/contradiction-checker.ts

@@ -1,14 +1,15 @@
-import Anthropic from '@anthropic-ai/sdk';
 import { eq } from 'drizzle-orm';
 import { getConfig } from '../config/loader.js';
 import { getLogger } from '../util/logger.js';
 import { truncate } from '../util/truncate.js';
+import { getConfiguredProvider, createTimeout, extractToolUse, userMessage } from '../providers/provider-send-message.js';
 import { areStatementsCoherent } from './conflict-intent.js';
 import { isConflictKindEligible, isStatementConflictEligible } from './conflict-policy.js';
 import { createOrUpdatePendingConflict } from './conflict-store.js';
-import { getDb } from './db.js';
+import { getDb, getSqlite, rawAll } from './db.js';
 import { enqueueMemoryJob } from './jobs-store.js';
 import { memoryItems } from './schema.js';
+import { clampUnitInterval } from './validation.js';
 
 const log = getLogger('memory-contradiction-checker');
 
@@ -56,13 +57,14 @@ export async function checkContradictions(newItemId: string): Promise<void> {
     return;
   }
 
-  const config = getConfig();
-  const apiKey = config.apiKeys.anthropic ?? process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    log.debug('No Anthropic API key available for contradiction checking');
+  const provider = getConfiguredProvider();
+  if (!provider) {
+    log.debug('Configured provider unavailable for contradiction checking');
     return;
   }
 
+  const config = getConfig();
+
   if (!isConflictKindEligible(newItem.kind, config.memory.conflicts)) {
     log.debug({ newItemId, kind: newItem.kind }, 'Skipping contradiction check — kind not eligible for conflicts');
     return;
@@ -91,14 +93,14 @@ export async function checkContradictions(newItemId: string): Promise<void> {
     }
 
     try {
-      const result = await classifyRelationship(apiKey, existing, newItem);
-      await handleRelationship(result, existing, newItem);
-      // Only stop when the new item itself is invalidated (update case).
-      // For contradiction, the old item is invalidated but the new item remains
-      // active and should continue to be checked against remaining candidates.
-      // For ambiguous contradiction, we pause retrieval eligibility for the new
-      // item and ask for clarification on a later turn.
-      if (result.relationship === 'update' || result.relationship === 'ambiguous_contradiction') break;
+      const result = await classifyRelationship(existing, newItem);
+      const mutated = handleRelationship(result, existing, newItem);
+      // Only stop when the new item itself was actually invalidated (update case)
+      // or gated (ambiguous_contradiction). For contradiction, the old item is
+      // invalidated but the new item remains active and should continue to be
+      // checked against remaining candidates. Skip the break when the transaction
+      // detected stale data and performed no mutation.
+      if (mutated && (result.relationship === 'update' || result.relationship === 'ambiguous_contradiction')) break;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       log.warn({ err: message, newItemId, existingId: existing.id }, 'Contradiction classification failed for pair');
@@ -123,8 +125,6 @@ interface MemoryItemRow {
  * Uses LIKE queries on subject and keyword overlap on statement.
  */
 function findSimilarItems(item: MemoryItemRow): MemoryItemRow[] {
-  const db = getDb();
-  const raw = (db as unknown as { $client: { query: (q: string) => { all: (...params: unknown[]) => unknown[] } } }).$client;
 
   // Extract significant words from subject for LIKE matching
   const subjectWords = item.subject
@@ -172,7 +172,7 @@ function findSimilarItems(item: MemoryItemRow): MemoryItemRow[] {
   `;
 
   try {
-    const rows = raw.query(sqlQuery).all(item.kind, item.id, item.scopeId) as Array<{
+    interface SimilarItemRow {
       id: string;
       kind: string;
       subject: string;
@@ -182,7 +182,8 @@ function findSimilarItems(item: MemoryItemRow): MemoryItemRow[] {
       importance: number | null;
       scope_id: string;
       last_seen_at: number;
-    }>;
+    }
+    const rows = rawAll<SimilarItemRow>(sqlQuery, item.kind, item.id, item.scopeId);
 
     return rows.map((row) => ({
       id: row.id,
@@ -205,25 +206,23 @@ function findSimilarItems(item: MemoryItemRow): MemoryItemRow[] {
  * Use LLM to classify the relationship between two memory items.
  */
 async function classifyRelationship(
-  apiKey: string,
   existingItem: MemoryItemRow,
   newItem: MemoryItemRow,
 ): Promise<ClassifyResult> {
-  const client = new Anthropic({ apiKey });
+  const provider = getConfiguredProvider()!;
 
-  const userMessage = [
+  const userContent = [
     `Subject: ${newItem.subject}`,
     '',
     `Old statement: ${existingItem.statement}`,
     `New statement: ${newItem.statement}`,
   ].join('\n');
 
-  const response = await Promise.race([
-    client.messages.create({
-      model: 'claude-haiku-4-5-20251001',
-      max_tokens: 256,
-      system: CONTRADICTION_SYSTEM_PROMPT,
-      tools: [{
+  const { signal, cleanup } = createTimeout(CONTRADICTION_LLM_TIMEOUT_MS);
+  try {
+    const response = await provider.sendMessage(
+      [userMessage(userContent)],
+      [{
         name: 'classify_relationship',
         description: 'Classify the relationship between two memory statements',
         input_schema: {
@@ -242,109 +241,134 @@ async function classifyRelationship(
           required: ['relationship', 'explanation'],
         },
       }],
-      tool_choice: { type: 'tool' as const, name: 'classify_relationship' },
-      messages: [{ role: 'user' as const, content: userMessage }],
-    }),
-    new Promise<never>((_, reject) =>
-      setTimeout(() => reject(new Error('Contradiction check LLM timeout')), CONTRADICTION_LLM_TIMEOUT_MS),
-    ),
-  ]);
-
-  const toolBlock = response.content.find((b) => b.type === 'tool_use');
-  if (!toolBlock || toolBlock.type !== 'tool_use') {
-    throw new Error('No tool_use block in contradiction check response');
-  }
+      CONTRADICTION_SYSTEM_PROMPT,
+      {
+        config: {
+          modelIntent: 'latency-optimized',
+          max_tokens: 256,
+          tool_choice: { type: 'tool' as const, name: 'classify_relationship' },
+        },
+        signal,
+      },
+    );
+    cleanup();
+
+    const toolBlock = extractToolUse(response);
+    if (!toolBlock) {
+      throw new Error('No tool_use block in contradiction check response');
+    }
 
-  const input = toolBlock.input as { relationship?: string; explanation?: string };
-  const relationship = input.relationship as Relationship;
-  if (!['contradiction', 'update', 'complement', 'ambiguous_contradiction'].includes(relationship)) {
-    throw new Error(`Invalid relationship type: ${relationship}`);
-  }
+    const input = toolBlock.input as { relationship?: string; explanation?: string };
+    const relationship = input.relationship as Relationship;
+    if (!['contradiction', 'update', 'complement', 'ambiguous_contradiction'].includes(relationship)) {
+      throw new Error(`Invalid relationship type: ${relationship}`);
+    }
 
-  return {
-    relationship,
-    explanation: truncate(String(input.explanation ?? ''), 500, ''),
-  };
+    return {
+      relationship,
+      explanation: truncate(String(input.explanation ?? ''), 500, ''),
+    };
+  } finally {
+    cleanup();
+  }
 }
 
 /**
  * Handle the classified relationship between an existing and new memory item.
+ *
+ * Wrapped in a SQLite transaction so that multi-row mutations (e.g. invalidating
+ * the old item AND setting validFrom on the new one) are atomic. The transaction
+ * also re-verifies both items are still active before mutating, preventing a
+ * TOCTOU race when multiple workers process contradictions concurrently.
  */
-async function handleRelationship(
+function handleRelationship(
   result: ClassifyResult,
   existingItem: MemoryItemRow,
   newItem: MemoryItemRow,
-): Promise<void> {
-  const db = getDb();
-  const now = Date.now();
-
-  switch (result.relationship) {
-    case 'contradiction': {
-      // Invalidate the old item (don't delete for audit trail), set validFrom on new item
-      log.info(
-        { existingId: existingItem.id, newId: newItem.id, explanation: result.explanation },
-        'Contradiction detected — invalidating old item',
-      );
-      db.update(memoryItems)
-        .set({ invalidAt: now })
-        .where(eq(memoryItems.id, existingItem.id))
-        .run();
-      db.update(memoryItems)
-        .set({ validFrom: now })
-        .where(eq(memoryItems.id, newItem.id))
-        .run();
-      break;
-    }
-    case 'update': {
-      // Merge info — update old item's statement, bump lastSeenAt
-      log.debug(
-        { existingId: existingItem.id, newId: newItem.id, explanation: result.explanation },
-        'Update detected — merging into existing item',
-      );
-      db.update(memoryItems)
-        .set({
-          statement: newItem.statement,
-          lastSeenAt: Math.max(existingItem.lastSeenAt, newItem.lastSeenAt),
-          confidence: Math.max(existingItem.confidence, newItem.confidence),
-        })
-        .where(eq(memoryItems.id, existingItem.id))
-        .run();
-      // Re-embed the existing item so its vector matches the updated statement
-      enqueueMemoryJob('embed_item', { itemId: existingItem.id });
-      // Invalidate the new item since its content has been merged into the existing one
-      db.update(memoryItems)
-        .set({ invalidAt: now })
-        .where(eq(memoryItems.id, newItem.id))
-        .run();
-      break;
+): boolean {
+  if (result.relationship === 'complement') {
+    log.debug(
+      { existingId: existingItem.id, newId: newItem.id, explanation: result.explanation },
+      'Complement detected — keeping both items',
+    );
+    return false;
+  }
+
+  return getSqlite().transaction(() => {
+    const db = getDb();
+    const now = Date.now();
+
+    // Re-check both items inside the transaction to guard against concurrent mutations
+    const freshExisting = db.select().from(memoryItems).where(eq(memoryItems.id, existingItem.id)).get();
+    const freshNew = db.select().from(memoryItems).where(eq(memoryItems.id, newItem.id)).get();
+
+    if (!freshExisting || freshExisting.status !== 'active' || freshExisting.invalidAt != null) {
+      log.debug({ existingId: existingItem.id }, 'Existing item no longer active — skipping');
+      return false;
     }
-    case 'complement': {
-      // Both items can coexist — no changes needed
-      log.debug(
-        { existingId: existingItem.id, newId: newItem.id, explanation: result.explanation },
-        'Complement detected — keeping both items',
-      );
-      break;
+    if (!freshNew || (freshNew.status !== 'active' && result.relationship !== 'ambiguous_contradiction') || freshNew.invalidAt != null) {
+      log.debug({ newId: newItem.id }, 'New item no longer active — skipping');
+      return false;
     }
-    case 'ambiguous_contradiction': {
-      log.info(
-        { existingId: existingItem.id, newId: newItem.id, explanation: result.explanation },
-        'Ambiguous contradiction detected — gating candidate pending clarification',
-      );
-      db.update(memoryItems)
-        .set({ status: 'pending_clarification' })
-        .where(eq(memoryItems.id, newItem.id))
-        .run();
-      createOrUpdatePendingConflict({
-        scopeId: newItem.scopeId,
-        existingItemId: existingItem.id,
-        candidateItemId: newItem.id,
-        relationship: 'ambiguous_contradiction',
-        clarificationQuestion: buildClarificationQuestion(existingItem.statement, newItem.statement),
-      });
-      break;
+
+    switch (result.relationship) {
+      case 'contradiction': {
+        log.info(
+          { existingId: existingItem.id, newId: newItem.id, explanation: result.explanation },
+          'Contradiction detected — invalidating old item',
+        );
+        db.update(memoryItems)
+          .set({ invalidAt: now })
+          .where(eq(memoryItems.id, existingItem.id))
+          .run();
+        db.update(memoryItems)
+          .set({ validFrom: now })
+          .where(eq(memoryItems.id, newItem.id))
+          .run();
+        return true;
+      }
+      case 'update': {
+        log.debug(
+          { existingId: existingItem.id, newId: newItem.id, explanation: result.explanation },
+          'Update detected — merging into existing item',
+        );
+        db.update(memoryItems)
+          .set({
+            statement: newItem.statement,
+            lastSeenAt: Math.max(freshExisting.lastSeenAt, freshNew!.lastSeenAt),
+            confidence: clampUnitInterval(Math.max(freshExisting.confidence, freshNew!.confidence)),
+          })
+          .where(eq(memoryItems.id, existingItem.id))
+          .run();
+        enqueueMemoryJob('embed_item', { itemId: existingItem.id });
+        db.update(memoryItems)
+          .set({ invalidAt: now })
+          .where(eq(memoryItems.id, newItem.id))
+          .run();
+        return true;
+      }
+      case 'ambiguous_contradiction': {
+        log.info(
+          { existingId: existingItem.id, newId: newItem.id, explanation: result.explanation },
+          'Ambiguous contradiction detected — gating candidate pending clarification',
+        );
+        db.update(memoryItems)
+          .set({ status: 'pending_clarification' })
+          .where(eq(memoryItems.id, newItem.id))
+          .run();
+        createOrUpdatePendingConflict({
+          scopeId: newItem.scopeId,
+          existingItemId: existingItem.id,
+          candidateItemId: newItem.id,
+          relationship: 'ambiguous_contradiction',
+          clarificationQuestion: buildClarificationQuestion(existingItem.statement, newItem.statement),
+        });
+        return true;
+      }
+      default:
+        return false;
     }
-  }
+  }).immediate();
 }
 
 function escapeSqlLike(s: string): string {