vellum 0.2.12 → 0.2.14

package/src/__tests__/cli.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'bun:test';
-import { sanitizeUrlForDisplay, formatPrincipalTag } from '../cli.js';
+import { sanitizeUrlForDisplay } from '../cli.js';
 
 describe('sanitizeUrlForDisplay', () => {
   test('removes userinfo from absolute URLs', () => {
@@ -24,58 +24,3 @@ describe('sanitizeUrlForDisplay', () => {
     expect(sanitizeUrlForDisplay(rawValue)).toBe('not-a-url //[REDACTED]@example.com');
   });
 });
-
-describe('formatPrincipalTag', () => {
-  test('returns empty string for core principals', () => {
-    expect(formatPrincipalTag({ principalKind: 'core' })).toBe('');
-  });
-
-  test('returns empty string when principalKind is absent', () => {
-    expect(formatPrincipalTag({})).toBe('');
-  });
-
-  test('formats skill with name, version, and target', () => {
-    const tag = formatPrincipalTag({
-      principalKind: 'skill',
-      principalId: 'weather-skill',
-      principalVersion: 'sha256:abcdef1234567890fedcba',
-      executionTarget: 'host',
-    });
-    expect(tag).toBe('[skill: weather-skill@abcdef12 \u2192 host]');
-  });
-
-  test('formats skill without version hash', () => {
-    const tag = formatPrincipalTag({
-      principalKind: 'skill',
-      principalId: 'my-skill',
-    });
-    expect(tag).toBe('[skill: my-skill]');
-  });
-
-  test('formats skill with sandbox target', () => {
-    const tag = formatPrincipalTag({
-      principalKind: 'skill',
-      principalId: 'deploy-skill',
-      principalVersion: 'sha256:1111222233334444',
-      executionTarget: 'sandbox',
-    });
-    expect(tag).toBe('[skill: deploy-skill@11112222 \u2192 sandbox]');
-  });
-
-  test('falls back to principalKind when principalId is absent', () => {
-    const tag = formatPrincipalTag({
-      principalKind: 'skill',
-      principalVersion: 'sha256:aabbccdd',
-    });
-    expect(tag).toBe('[skill: skill@aabbccdd]');
-  });
-
-  test('strips non-sha256 version prefix (e.g. v1:)', () => {
-    const tag = formatPrincipalTag({
-      principalKind: 'skill',
-      principalId: 'runtime-skill',
-      principalVersion: 'v1:abcdef1234567890',
-    });
-    expect(tag).toBe('[skill: runtime-skill@abcdef12]');
-  });
-});

package/src/__tests__/config-schema.test.ts

@@ -55,6 +55,7 @@ import { _setBackend } from '../security/secure-keys.js';
 import { loadConfig, invalidateConfigCache } from '../config/loader.js';
 import { AssistantConfigSchema } from '../config/schema.js';
 import { DEFAULT_CONFIG } from '../config/defaults.js';
+import { buildElevenLabsVoiceSpec, resolveVoiceQualityProfile } from '../calls/voice-quality.js';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -138,6 +139,8 @@ describe('AssistantConfigSchema', () => {
       reaskCooldownTurns: 3,
       resolverLlmTimeoutMs: 12000,
       relevanceThreshold: 0.3,
+      askOnIrrelevantTurns: false,
+      conflictableKinds: ['preference', 'profile', 'constraint', 'instruction', 'style'],
     });
   });
 
@@ -148,6 +151,27 @@ describe('AssistantConfigSchema', () => {
     expect(result.success).toBe(false);
   });
 
+  test('rejects invalid memory.conflicts.askOnIrrelevantTurns', () => {
+    const result = AssistantConfigSchema.safeParse({
+      memory: { conflicts: { askOnIrrelevantTurns: 123 } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects invalid memory.conflicts.conflictableKinds entry', () => {
+    const result = AssistantConfigSchema.safeParse({
+      memory: { conflicts: { conflictableKinds: ['invalid_kind'] } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects empty memory.conflicts.conflictableKinds', () => {
+    const result = AssistantConfigSchema.safeParse({
+      memory: { conflicts: { conflictableKinds: [] } },
+    });
+    expect(result.success).toBe(false);
+  });
+
   test('applies memory.profile defaults', () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.memory.profile).toEqual({
@@ -473,9 +497,9 @@ describe('AssistantConfigSchema', () => {
     expect(result.success).toBe(false);
   });
 
-  test('defaults permissions.mode to strict', () => {
+  test('defaults permissions.mode to workspace', () => {
     const result = AssistantConfigSchema.parse({});
-    expect(result.permissions).toEqual({ mode: 'strict' });
+    expect(result.permissions).toEqual({ mode: 'workspace' });
   });
 
   test('accepts explicit permissions.mode strict', () => {
@@ -492,6 +516,13 @@ describe('AssistantConfigSchema', () => {
     expect(result.permissions.mode).toBe('legacy');
   });
 
+  test('accepts explicit permissions.mode workspace', () => {
+    const result = AssistantConfigSchema.parse({
+      permissions: { mode: 'workspace' },
+    });
+    expect(result.permissions.mode).toBe('workspace');
+  });
+
   test('rejects invalid permissions.mode', () => {
     const result = AssistantConfigSchema.safeParse({
       permissions: { mode: 'permissive' },
@@ -655,6 +686,26 @@ describe('AssistantConfigSchema', () => {
       safety: {
         denyCategories: [],
       },
+      voice: {
+        mode: 'twilio_standard',
+        language: 'en-US',
+        transcriptionProvider: 'Deepgram',
+        fallbackToStandardOnError: true,
+        elevenlabs: {
+          voiceId: '',
+          voiceModelId: '',
+          speed: 1.0,
+          stability: 0.5,
+          similarityBoost: 0.75,
+          useSpeakerBoost: true,
+          agentId: '',
+          apiBaseUrl: 'https://api.elevenlabs.io',
+          registerCallTimeoutMs: 5000,
+        },
+      },
+      callerIdentity: {
+        allowPerCallOverride: true,
+      },
     });
   });
 
@@ -745,6 +796,344 @@ describe('AssistantConfigSchema', () => {
     });
     expect(result.success).toBe(false);
   });
+
+  // ── Calls voice config ──────────────────────────────────────────────
+
+  test('config without calls.voice parses correctly and produces defaults', () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.calls.voice.mode).toBe('twilio_standard');
+    expect(result.calls.voice.language).toBe('en-US');
+    expect(result.calls.voice.transcriptionProvider).toBe('Deepgram');
+    expect(result.calls.voice.fallbackToStandardOnError).toBe(true);
+    expect(result.calls.voice.elevenlabs.voiceId).toBe('');
+    expect(result.calls.voice.elevenlabs.voiceModelId).toBe('');
+    expect(result.calls.voice.elevenlabs.speed).toBe(1.0);
+    expect(result.calls.voice.elevenlabs.stability).toBe(0.5);
+    expect(result.calls.voice.elevenlabs.similarityBoost).toBe(0.75);
+    expect(result.calls.voice.elevenlabs.useSpeakerBoost).toBe(true);
+    expect(result.calls.voice.elevenlabs.agentId).toBe('');
+    expect(result.calls.voice.elevenlabs.apiBaseUrl).toBe('https://api.elevenlabs.io');
+    expect(result.calls.voice.elevenlabs.registerCallTimeoutMs).toBe(5000);
+  });
+
+  test('legacy style field is silently stripped by schema', () => {
+    const result = AssistantConfigSchema.parse({
+      calls: { voice: { elevenlabs: { style: 0.5 } } },
+    });
+    expect((result.calls.voice.elevenlabs as Record<string, unknown>).style).toBeUndefined();
+    expect(result.calls.voice.elevenlabs.speed).toBe(1.0);
+  });
+
+  test('rejects calls.voice.elevenlabs.speed below 0.7', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { elevenlabs: { speed: 0.5 } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects calls.voice.elevenlabs.speed above 1.2', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { elevenlabs: { speed: 1.5 } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('accepts valid calls.voice overrides', () => {
+    const result = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          language: 'es-ES',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: false,
+          elevenlabs: {
+            voiceId: 'abc123',
+            stability: 0.8,
+          },
+        },
+      },
+    });
+    expect(result.calls.voice.mode).toBe('twilio_elevenlabs_tts');
+    expect(result.calls.voice.language).toBe('es-ES');
+    expect(result.calls.voice.transcriptionProvider).toBe('Google');
+    expect(result.calls.voice.fallbackToStandardOnError).toBe(false);
+    expect(result.calls.voice.elevenlabs.voiceId).toBe('abc123');
+    expect(result.calls.voice.elevenlabs.stability).toBe(0.8);
+    // Defaults preserved for unset fields
+    expect(result.calls.voice.elevenlabs.voiceModelId).toBe('');
+    expect(result.calls.voice.elevenlabs.similarityBoost).toBe(0.75);
+  });
+
+  test('rejects invalid calls.voice.mode', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { mode: 'invalid_mode' } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map(i => i.message);
+      expect(msgs.some(m => m.includes('calls.voice.mode'))).toBe(true);
+    }
+  });
+
+  test('rejects invalid calls.voice.transcriptionProvider', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { transcriptionProvider: 'AWS' } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map(i => i.message);
+      expect(msgs.some(m => m.includes('calls.voice.transcriptionProvider'))).toBe(true);
+    }
+  });
+
+  test('rejects calls.voice.elevenlabs.stability out of range', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { elevenlabs: { stability: 1.5 } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects calls.voice.elevenlabs.registerCallTimeoutMs below 1000', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { elevenlabs: { registerCallTimeoutMs: 500 } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects calls.voice.elevenlabs.registerCallTimeoutMs above 15000', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { elevenlabs: { registerCallTimeoutMs: 20000 } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('accepts optional calls.model', () => {
+    const result = AssistantConfigSchema.parse({
+      calls: { model: 'claude-haiku-4-5-20251001' },
+    });
+    expect(result.calls.model).toBe('claude-haiku-4-5-20251001');
+  });
+
+  test('calls.model is undefined by default', () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.calls.model).toBeUndefined();
+  });
+
+  // ── Caller identity config ────────────────────────────────────────
+
+  test('applies calls.callerIdentity defaults', () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.calls.callerIdentity).toEqual({
+      allowPerCallOverride: true,
+    });
+  });
+
+  test('accepts valid calls.callerIdentity overrides', () => {
+    const result = AssistantConfigSchema.parse({
+      calls: {
+        callerIdentity: {
+          allowPerCallOverride: false,
+          userNumber: '+14155559999',
+        },
+      },
+    });
+    expect(result.calls.callerIdentity.allowPerCallOverride).toBe(false);
+    expect(result.calls.callerIdentity.userNumber).toBe('+14155559999');
+  });
+
+  test('legacy defaultMode field is silently stripped by schema', () => {
+    // Backward compatibility: existing configs with defaultMode should parse
+    // without error — Zod strips unrecognized keys by default.
+    const result = AssistantConfigSchema.parse({
+      calls: {
+        callerIdentity: { defaultMode: 'user_number', allowPerCallOverride: true },
+      },
+    });
+    expect((result.calls.callerIdentity as Record<string, unknown>).defaultMode).toBeUndefined();
+    expect(result.calls.callerIdentity.allowPerCallOverride).toBe(true);
+  });
+
+  test('rejects non-boolean calls.callerIdentity.allowPerCallOverride', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { callerIdentity: { allowPerCallOverride: 'yes' } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('default behavior unchanged when callerIdentity omitted', () => {
+    const result = AssistantConfigSchema.parse({
+      calls: { enabled: true },
+    });
+    expect(result.calls.callerIdentity.allowPerCallOverride).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Voice quality profile resolver
+// ---------------------------------------------------------------------------
+
+describe('resolveVoiceQualityProfile', () => {
+  test('returns correct profile for twilio_standard', () => {
+    const config = AssistantConfigSchema.parse({});
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_standard');
+    expect(profile.ttsProvider).toBe('Google');
+    expect(profile.voice).toBe('Google.en-US-Journey-O');
+    expect(profile.transcriptionProvider).toBe('Deepgram');
+    expect(profile.fallbackToStandardOnError).toBe(true);
+    expect(profile.validationErrors).toEqual([]);
+  });
+
+  test('returns correct profile for twilio_elevenlabs_tts with valid voiceId', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          elevenlabs: { voiceId: 'test-voice-id' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_elevenlabs_tts');
+    expect(profile.ttsProvider).toBe('ElevenLabs');
+    expect(profile.voice).toBe('test-voice-id');
+    expect(profile.validationErrors).toEqual([]);
+  });
+
+  test('falls back for twilio_elevenlabs_tts with empty voiceId and fallback enabled', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          fallbackToStandardOnError: true,
+          elevenlabs: { voiceId: '' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_standard');
+    expect(profile.ttsProvider).toBe('Google');
+    expect(profile.voice).toBe('Google.en-US-Journey-O');
+    expect(profile.validationErrors.length).toBe(1);
+    expect(profile.validationErrors[0]).toContain('falling back');
+  });
+
+  test('returns errors for twilio_elevenlabs_tts with empty voiceId and fallback disabled', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          fallbackToStandardOnError: false,
+          elevenlabs: { voiceId: '' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_elevenlabs_tts');
+    expect(profile.validationErrors.length).toBe(1);
+    expect(profile.validationErrors[0]).toContain('voiceId is required');
+  });
+
+  test('returns correct profile for elevenlabs_agent with valid agentId', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'elevenlabs_agent',
+          elevenlabs: { agentId: 'agent-123', voiceId: 'v1' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('elevenlabs_agent');
+    expect(profile.ttsProvider).toBe('ElevenLabs');
+    expect(profile.voice).toBe('v1');
+    expect(profile.agentId).toBe('agent-123');
+    expect(profile.validationErrors).toEqual([]);
+  });
+
+  test('falls back for elevenlabs_agent with empty agentId and fallback enabled', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'elevenlabs_agent',
+          fallbackToStandardOnError: true,
+          elevenlabs: { agentId: '' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_standard');
+    expect(profile.validationErrors.length).toBe(1);
+    expect(profile.validationErrors[0]).toContain('agentId is empty');
+  });
+
+  test('returns errors for elevenlabs_agent with empty agentId and fallback disabled', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'elevenlabs_agent',
+          fallbackToStandardOnError: false,
+          elevenlabs: { agentId: '' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('elevenlabs_agent');
+    expect(profile.validationErrors.length).toBe(1);
+    expect(profile.validationErrors[0]).toContain('agentId is required');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: buildElevenLabsVoiceSpec
+// ---------------------------------------------------------------------------
+
+describe('buildElevenLabsVoiceSpec', () => {
+  test('produces Twilio-compliant voice string: voiceId-model-speed_stability_similarity', () => {
+    const spec = buildElevenLabsVoiceSpec({
+      voiceId: 'abc123',
+      voiceModelId: 'turbo_v2_5',
+      speed: 1.0,
+      stability: 0.5,
+      similarityBoost: 0.75,
+    });
+    expect(spec).toBe('abc123-turbo_v2_5-1_0.5_0.75');
+  });
+
+  test('returns empty string when voiceId is empty', () => {
+    const spec = buildElevenLabsVoiceSpec({
+      voiceId: '',
+      voiceModelId: 'turbo_v2_5',
+      speed: 1.0,
+      stability: 0.5,
+      similarityBoost: 0.75,
+    });
+    expect(spec).toBe('');
+  });
+
+  test('formats custom parameters correctly', () => {
+    const spec = buildElevenLabsVoiceSpec({
+      voiceId: 'myVoice',
+      voiceModelId: 'eleven_multilingual_v2',
+      speed: 0.9,
+      stability: 0.8,
+      similarityBoost: 0.9,
+    });
+    expect(spec).toBe('myVoice-eleven_multilingual_v2-0.9_0.8_0.9');
+  });
+
+  test('default config uses a bare voiceId when no model override is set', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          elevenlabs: { voiceId: 'test' },
+        },
+      },
+    });
+    const spec = buildElevenLabsVoiceSpec(config.calls.voice.elevenlabs);
+    expect(spec).toBe('test');
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -924,10 +1313,10 @@ describe('loadConfig with schema validation', () => {
     expect(config.auditLog.retentionDays).toBe(0);
   });
 
-  test('defaults permissions.mode to strict when not specified', () => {
+  test('defaults permissions.mode to workspace when not specified', () => {
     writeConfig({});
     const config = loadConfig();
-    expect(config.permissions).toEqual({ mode: 'strict' });
+    expect(config.permissions).toEqual({ mode: 'workspace' });
   });
 
   test('loads explicit permissions.mode strict', () => {
@@ -939,7 +1328,7 @@ describe('loadConfig with schema validation', () => {
   test('falls back for invalid permissions.mode', () => {
     writeConfig({ permissions: { mode: 'yolo' } });
     const config = loadConfig();
-    expect(config.permissions.mode).toBe('strict');
+    expect(config.permissions.mode).toBe('workspace');
   });
 
   test('does not mutate default apiKeys when fallback config is overridden by env keys', () => {
@@ -994,6 +1383,14 @@ describe('loadConfig with schema validation', () => {
     expect(config.calls.userConsultTimeoutSeconds).toBe(120);
     expect(config.calls.disclosure.enabled).toBe(true);
     expect(config.calls.safety.denyCategories).toEqual([]);
+    expect(config.calls.voice.mode).toBe('twilio_standard');
+    expect(config.calls.voice.language).toBe('en-US');
+    expect(config.calls.voice.transcriptionProvider).toBe('Deepgram');
+    expect(config.calls.voice.elevenlabs.voiceId).toBe('');
+    expect(config.calls.model).toBeUndefined();
+    expect(config.calls.callerIdentity).toEqual({
+      allowPerCallOverride: true,
+    });
   });
 });
 

package/src/__tests__/conflict-intent-tokenization.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from 'bun:test';
+import { areStatementsCoherent, computeConflictRelevance, tokenizeForConflictRelevance as _tokenizeForConflictRelevance, overlapRatio as _overlapRatio } from '../memory/conflict-intent.js';
+
+describe('tokenizeForConflictRelevance hardening', () => {
+  test('excludes numeric-only tokens from relevance', () => {
+    const relevance = computeConflictRelevance(
+      'Check PR 5526',
+      { existingStatement: 'Track PR 5525 for review.', candidateStatement: 'Track PR 5526 for review.' },
+    );
+    // Numeric tokens "5526" and "5525" should be excluded, so overlap is minimal
+    expect(relevance).toBeLessThan(0.5);
+  });
+
+  test('excludes URL boilerplate tokens from relevance', () => {
+    const relevance = computeConflictRelevance(
+      'Check https://github.com/org/repo/pull/123',
+      {
+        existingStatement: 'Review https://github.com/org/repo/pull/456',
+        candidateStatement: 'Review https://github.com/org/repo/pull/789',
+      },
+    );
+    // URL tokens like "https", "github", "pull" should be excluded;
+    // only real content tokens like "repo" remain, keeping relevance low
+    expect(relevance).toBeLessThanOrEqual(0.5);
+  });
+
+  test('URL-embedded tracking tokens are stripped, standalone usage preserved', () => {
+    // URLs containing "issue", "pull", etc. are stripped entirely before tokenizing
+    const urlRelevance = computeConflictRelevance(
+      'Check https://github.com/org/repo/issues/42',
+      {
+        existingStatement: 'Review https://github.com/org/repo/issues/10',
+        candidateStatement: 'Review https://github.com/org/repo/issues/11',
+      },
+    );
+    expect(urlRelevance).toBeLessThanOrEqual(0.5);
+
+    // Standalone "issue" is preserved as a meaningful token
+    const standaloneRelevance = computeConflictRelevance(
+      'should I file an issue?',
+      {
+        existingStatement: 'File an issue when bugs are found.',
+        candidateStatement: 'Skip filing an issue for minor bugs.',
+      },
+    );
+    expect(standaloneRelevance).toBeGreaterThan(0);
+  });
+
+  test('strips scheme-less bare domain URLs from relevance', () => {
+    const relevance = computeConflictRelevance(
+      'Check github.com/org/repo/pull/123',
+      {
+        existingStatement: 'Review gitlab.com/org/repo/issues/456',
+        candidateStatement: 'Review github.com/org/repo/pull/789',
+      },
+    );
+    // Bare URLs should be stripped entirely; tokens like "pull", "issues"
+    // embedded in paths must not contribute to overlap
+    expect(relevance).toBeLessThanOrEqual(0.5);
+  });
+
+  test('preserves dotted identifiers that look like file paths', () => {
+    const relevance = computeConflictRelevance(
+      'Use index.ts/runtime parser',
+      {
+        existingStatement: 'Keep index.ts/runtime approach.',
+        candidateStatement: 'Switch to config.ts/runtime approach.',
+      },
+    );
+    // File-like identifiers should NOT be stripped as URLs
+    expect(relevance).toBeGreaterThan(0);
+  });
+
+  test('still computes meaningful relevance for real content tokens', () => {
+    const relevance = computeConflictRelevance(
+      'Should I use React for frontend?',
+      {
+        existingStatement: 'Use React for frontend work.',
+        candidateStatement: 'Use Vue for frontend work.',
+      },
+    );
+    // Real content tokens like "react", "frontend" should still match
+    expect(relevance).toBeGreaterThan(0);
+  });
+});
+
+describe('statement coherence (areStatementsCoherent)', () => {
+  test('unrelated statements are incoherent', () => {
+    expect(areStatementsCoherent(
+      'The default model for the summarize CLI is google/gemini-3-flash-preview.',
+      "User's favorite color is blue.",
+    )).toBe(false);
+  });
+
+  test('related statements are coherent', () => {
+    expect(areStatementsCoherent(
+      "User's favorite color is blue.",
+      "User's favorite color is green.",
+    )).toBe(true);
+  });
+
+  test('topically similar preferences are coherent', () => {
+    expect(areStatementsCoherent(
+      'Use React for frontend work.',
+      'Use Vue for frontend work.',
+    )).toBe(true);
+  });
+
+  test('completely disjoint technical topics are incoherent', () => {
+    expect(areStatementsCoherent(
+      'Always use PostgreSQL for database storage.',
+      'The preferred terminal font is JetBrains Mono.',
+    )).toBe(false);
+  });
+
+  test('short technical terms (3 chars) are preserved for coherence', () => {
+    // "vim" and "css" are 3 chars — should not be filtered
+    expect(areStatementsCoherent(
+      'Use Vim for editing.',
+      'Use Emacs instead of Vim.',
+    )).toBe(true);
+
+    expect(areStatementsCoherent(
+      'Use CSS grid for layouts.',
+      'Use CSS flexbox for layouts.',
+    )).toBe(true);
+
+    expect(areStatementsCoherent(
+      'Use npm for installs.',
+      'Use npm with --legacy-peer-deps.',
+    )).toBe(true);
+  });
+
+  test('short terms with no shared context are still incoherent', () => {
+    // No shared tokens at all — completely different topics
+    expect(areStatementsCoherent(
+      'Vim is the preferred editor.',
+      'CSS grid handles page layouts.',
+    )).toBe(false);
+  });
+});