vellum 0.2.13 → 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

@@ -139,6 +139,8 @@ describe('AssistantConfigSchema', () => {
       reaskCooldownTurns: 3,
       resolverLlmTimeoutMs: 12000,
       relevanceThreshold: 0.3,
+      askOnIrrelevantTurns: false,
+      conflictableKinds: ['preference', 'profile', 'constraint', 'instruction', 'style'],
     });
   });
 
@@ -149,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({
@@ -474,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', () => {
@@ -493,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' },
@@ -663,16 +693,19 @@ describe('AssistantConfigSchema', () => {
         fallbackToStandardOnError: true,
         elevenlabs: {
           voiceId: '',
-          voiceModelId: 'turbo_v2_5',
+          voiceModelId: '',
+          speed: 1.0,
           stability: 0.5,
           similarityBoost: 0.75,
-          style: 0.0,
           useSpeakerBoost: true,
           agentId: '',
           apiBaseUrl: 'https://api.elevenlabs.io',
           registerCallTimeoutMs: 5000,
         },
       },
+      callerIdentity: {
+        allowPerCallOverride: true,
+      },
     });
   });
 
@@ -773,16 +806,38 @@ describe('AssistantConfigSchema', () => {
     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('turbo_v2_5');
+    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.style).toBe(0.0);
     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: {
@@ -805,7 +860,7 @@ describe('AssistantConfigSchema', () => {
     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('turbo_v2_5');
+    expect(result.calls.voice.elevenlabs.voiceModelId).toBe('');
     expect(result.calls.voice.elevenlabs.similarityBoost).toBe(0.75);
   });
 
@@ -863,6 +918,54 @@ describe('AssistantConfigSchema', () => {
     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);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -893,7 +996,7 @@ describe('resolveVoiceQualityProfile', () => {
     const profile = resolveVoiceQualityProfile(config);
     expect(profile.mode).toBe('twilio_elevenlabs_tts');
     expect(profile.ttsProvider).toBe('ElevenLabs');
-    expect(profile.voice).toBe('test-voice-id-turbo_v2_5-0.5_0.75_0');
+    expect(profile.voice).toBe('test-voice-id');
     expect(profile.validationErrors).toEqual([]);
   });
 
@@ -943,7 +1046,7 @@ describe('resolveVoiceQualityProfile', () => {
     const profile = resolveVoiceQualityProfile(config);
     expect(profile.mode).toBe('elevenlabs_agent');
     expect(profile.ttsProvider).toBe('ElevenLabs');
-    expect(profile.voice).toBe('v1-turbo_v2_5-0.5_0.75_0');
+    expect(profile.voice).toBe('v1');
     expect(profile.agentId).toBe('agent-123');
     expect(profile.validationErrors).toEqual([]);
   });
@@ -986,24 +1089,24 @@ describe('resolveVoiceQualityProfile', () => {
 // ---------------------------------------------------------------------------
 
 describe('buildElevenLabsVoiceSpec', () => {
-  test('produces correct voice string with all params', () => {
+  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,
-      style: 0.0,
     });
-    expect(spec).toBe('abc123-turbo_v2_5-0.5_0.75_0');
+    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,
-      style: 0.0,
     });
     expect(spec).toBe('');
   });
@@ -1012,11 +1115,24 @@ describe('buildElevenLabsVoiceSpec', () => {
     const spec = buildElevenLabsVoiceSpec({
       voiceId: 'myVoice',
       voiceModelId: 'eleven_multilingual_v2',
+      speed: 0.9,
       stability: 0.8,
       similarityBoost: 0.9,
-      style: 0.3,
     });
-    expect(spec).toBe('myVoice-eleven_multilingual_v2-0.8_0.9_0.3');
+    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');
   });
 });
 
@@ -1197,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', () => {
@@ -1212,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', () => {
@@ -1272,6 +1388,9 @@ describe('loadConfig with schema validation', () => {
     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);
+  });
+});

package/src/__tests__/conflict-policy.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  isConflictKindEligible,
+  isConflictKindPairEligible,
+  isTransientTrackingStatement,
+  isDurableInstructionStatement,
+  isStatementConflictEligible,
+} from '../memory/conflict-policy.js';
+
+describe('conflict-policy', () => {
+  const config = { conflictableKinds: ['preference', 'profile', 'constraint'] };
+
+  describe('isConflictKindEligible', () => {
+    test('returns true for eligible kind', () => {
+      expect(isConflictKindEligible('preference', config)).toBe(true);
+      expect(isConflictKindEligible('profile', config)).toBe(true);
+      expect(isConflictKindEligible('constraint', config)).toBe(true);
+    });
+
+    test('returns false for ineligible kind', () => {
+      expect(isConflictKindEligible('project', config)).toBe(false);
+      expect(isConflictKindEligible('todo', config)).toBe(false);
+      expect(isConflictKindEligible('fact', config)).toBe(false);
+    });
+  });
+
+  describe('isConflictKindPairEligible', () => {
+    test('returns true when both kinds are eligible', () => {
+      expect(isConflictKindPairEligible('preference', 'profile', config)).toBe(true);
+    });
+
+    test('returns false when existing kind is ineligible', () => {
+      expect(isConflictKindPairEligible('project', 'preference', config)).toBe(false);
+    });
+
+    test('returns false when candidate kind is ineligible', () => {
+      expect(isConflictKindPairEligible('preference', 'todo', config)).toBe(false);
+    });
+
+    test('returns false when both kinds are ineligible', () => {
+      expect(isConflictKindPairEligible('project', 'todo', config)).toBe(false);
+    });
+  });
+
+  describe('isTransientTrackingStatement', () => {
+    test('detects PR URLs', () => {
+      expect(isTransientTrackingStatement('Track https://github.com/org/repo/pull/5526')).toBe(true);
+    });
+
+    test('detects issue/ticket references', () => {
+      expect(isTransientTrackingStatement('Track PR #5526 and #5525')).toBe(true);
+      expect(isTransientTrackingStatement('See issue #42 for details')).toBe(true);
+      expect(isTransientTrackingStatement('Filed ticket 1234')).toBe(true);
+    });
+
+    test('detects tracking language', () => {
+      expect(isTransientTrackingStatement('While we wait for CI to pass')).toBe(true);
+      expect(isTransientTrackingStatement('This PR needs review')).toBe(true);
+    });
+
+    test('does not flag generic time words as transient', () => {
+      expect(isTransientTrackingStatement('The deadline is today')).toBe(false);
+      expect(isTransientTrackingStatement('I need this right now')).toBe(false);
+    });
+
+    test('does not flag durable statements', () => {
+      expect(isTransientTrackingStatement('Always answer with concise bullet points')).toBe(false);
+      expect(isTransientTrackingStatement('User prefers dark mode')).toBe(false);
+    });
+
+    test('does not false-positive on non-PR URLs', () => {
+      expect(isTransientTrackingStatement('Visit https://example.com for docs')).toBe(false);
+    });
+  });
+
+  describe('isDurableInstructionStatement', () => {
+    test('detects durable instruction cues', () => {
+      expect(isDurableInstructionStatement('Always answer with concise bullet points')).toBe(true);
+      expect(isDurableInstructionStatement('Never use semicolons in JavaScript')).toBe(true);
+      expect(isDurableInstructionStatement('Use concise format for status updates')).toBe(true);
+      expect(isDurableInstructionStatement('The default database is Postgres')).toBe(true);
+    });
+
+    test('rejects statements without durable cues', () => {
+      expect(isDurableInstructionStatement('Check the build output')).toBe(false);
+      expect(isDurableInstructionStatement('Run the migration script')).toBe(false);
+    });
+  });
+
+  describe('isStatementConflictEligible', () => {
+    test('rejects transient statements for any kind', () => {
+      expect(isStatementConflictEligible('preference', 'Track PR #5526')).toBe(false);
+      expect(isStatementConflictEligible('instruction', 'This PR needs review')).toBe(false);
+    });
+
+    test('accepts durable instruction statements', () => {
+      expect(isStatementConflictEligible('instruction', 'Always use TypeScript strict mode')).toBe(true);
+      expect(isStatementConflictEligible('style', 'Default to concise format')).toBe(true);
+    });
+
+    test('rejects non-durable instruction statements', () => {
+      expect(isStatementConflictEligible('instruction', 'Run the build first')).toBe(false);
+      expect(isStatementConflictEligible('style', 'Check the output')).toBe(false);
+    });
+
+    test('accepts non-transient statements for non-instruction kinds', () => {
+      expect(isStatementConflictEligible('preference', 'User prefers dark mode')).toBe(true);
+      expect(isStatementConflictEligible('fact', 'User works at Acme Corp')).toBe(true);
+    });
+
+    test('rejects kinds not in conflictableKinds when config is provided', () => {
+      const policyConfig = { conflictableKinds: ['preference', 'profile'] };
+      expect(isStatementConflictEligible('fact', 'User works at Acme Corp', policyConfig)).toBe(false);
+      expect(isStatementConflictEligible('preference', 'User prefers dark mode', policyConfig)).toBe(true);
+    });
+
+    test('skips kind check when config is omitted', () => {
+      expect(isStatementConflictEligible('fact', 'User works at Acme Corp')).toBe(true);
+    });
+  });
+});

package/src/__tests__/conflict-store.test.ts

@@ -233,6 +233,8 @@ describe('conflict-store', () => {
     expect(details).toHaveLength(1);
     expect(details[0].existingStatement).toBe('Existing statement details');
     expect(details[0].candidateStatement).toBe('Candidate statement details');
+    expect(details[0].existingKind).toBe('fact');
+    expect(details[0].candidateKind).toBe('fact');
   });
 
   test('applyConflictResolution keeps candidate and resolves conflict row', () => {

package/src/__tests__/contacts-tools.test.ts

@@ -32,9 +32,9 @@ mock.module('../config/loader.js', () => ({
 import type { Database } from 'bun:sqlite';
 import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import type { ToolContext } from '../tools/types.js';
-import { executeContactUpsert } from '../tools/contacts/contact-upsert.js';
-import { executeContactSearch } from '../tools/contacts/contact-search.js';
-import { executeContactMerge } from '../tools/contacts/contact-merge.js';
+import { executeContactUpsert } from '../config/bundled-skills/contacts/tools/contact-upsert.js';
+import { executeContactSearch } from '../config/bundled-skills/contacts/tools/contact-search.js';
+import { executeContactMerge } from '../config/bundled-skills/contacts/tools/contact-merge.js';
 
 initializeDb();