@vellumai/assistant 0.3.15 → 0.3.16

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

@@ -232,10 +232,10 @@ describe('attachment orphan cleanup', () => {
     db.run('DELETE FROM conversations');
   });
 
-  test('deleteLastExchange cleans up orphaned attachments', () => {
+  test('deleteLastExchange cleans up orphaned attachments', async () => {
     const conv = createConversation('test');
-    addMessage(conv.id, 'user', 'hello');
-    const assistantMsg = addMessage(conv.id, 'assistant', 'Here is a file');
+    await addMessage(conv.id, 'user', 'hello');
+    const assistantMsg = await addMessage(conv.id, 'assistant', 'Here is a file');
 
     const stored = uploadAttachment('chart.png', 'image/png', 'iVBOR');
     linkAttachmentToMessage(assistantMsg.id, stored.id, 0);
@@ -252,11 +252,11 @@ describe('attachment orphan cleanup', () => {
     expect(remaining.c).toBe(0);
   });
 
-  test('deleteLastExchange preserves attachments still linked to other messages', () => {
+  test('deleteLastExchange preserves attachments still linked to other messages', async () => {
     const conv = createConversation('test');
-    const msg1 = addMessage(conv.id, 'assistant', 'first');
-    addMessage(conv.id, 'user', 'question');
-    const msg2 = addMessage(conv.id, 'assistant', 'second');
+    const msg1 = await addMessage(conv.id, 'assistant', 'first');
+    await addMessage(conv.id, 'user', 'question');
+    const msg2 = await addMessage(conv.id, 'assistant', 'second');
 
     const shared = uploadAttachment('shared.png', 'image/png', 'AAAA');
     linkAttachmentToMessage(msg1.id, shared.id, 0);
@@ -271,9 +271,9 @@ describe('attachment orphan cleanup', () => {
     expect(remaining.c).toBe(1);
   });
 
-  test('clearAll removes all attachments', () => {
+  test('clearAll removes all attachments', async () => {
     const conv = createConversation('test');
-    const msg = addMessage(conv.id, 'assistant', 'file');
+    const msg = await addMessage(conv.id, 'assistant', 'file');
     const stored = uploadAttachment('doc.pdf', 'application/pdf', 'JVBER');
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
@@ -286,10 +286,10 @@ describe('attachment orphan cleanup', () => {
     expect(linkCount.c).toBe(0);
   });
 
-  test('deleteLastExchange does not delete unlinked user uploads', () => {
+  test('deleteLastExchange does not delete unlinked user uploads', async () => {
     const conv = createConversation('test');
-    addMessage(conv.id, 'user', 'hello');
-    const assistantMsg = addMessage(conv.id, 'assistant', 'Here is a file');
+    await addMessage(conv.id, 'user', 'hello');
+    const assistantMsg = await addMessage(conv.id, 'assistant', 'Here is a file');
 
     // An attachment linked to the assistant message (should be cleaned up)
     const linked = uploadAttachment('chart.png', 'image/png', 'iVBOR');
@@ -438,15 +438,15 @@ describe('attachment reuse across thread lifecycles', () => {
     db.run('DELETE FROM conversations');
   });
 
-  test('attachment uploaded in conversation A is retrievable by ID without any conversation reference', () => {
+  test('attachment uploaded in conversation A is retrievable by ID without any conversation reference', async () => {
     const convA = createConversation('Thread A');
-    const msgA = addMessage(convA.id, 'assistant', 'Here is a file');
+    const msgA = await addMessage(convA.id, 'assistant', 'Here is a file');
     const stored = uploadAttachment('report.pdf', 'application/pdf', 'JVBER');
     linkAttachmentToMessage(msgA.id, stored.id, 0);
 
     // Create a completely separate conversation
     const convB = createConversation('Thread B');
-    addMessage(convB.id, 'user', 'hello');
+    await addMessage(convB.id, 'user', 'hello');
 
     // The attachment is retrievable by ID regardless of which conversation is active.
     const fetched = getAttachmentById(stored.id);
@@ -456,12 +456,12 @@ describe('attachment reuse across thread lifecycles', () => {
     expect(fetched!.dataBase64).toBe('JVBER');
   });
 
-  test('attachment can be linked to messages in different conversations', () => {
+  test('attachment can be linked to messages in different conversations', async () => {
     const convA = createConversation('Thread A');
     const convB = createConversation('Thread B');
 
-    const msgA = addMessage(convA.id, 'assistant', 'Original file');
-    const msgB = addMessage(convB.id, 'assistant', 'Reused file');
+    const msgA = await addMessage(convA.id, 'assistant', 'Original file');
+    const msgB = await addMessage(convB.id, 'assistant', 'Reused file');
 
     // Upload once, link to both conversations
     const stored = uploadAttachment('shared.png', 'image/png', 'iVBORw0K');
@@ -478,16 +478,16 @@ describe('attachment reuse across thread lifecycles', () => {
     expect(linkedB[0].id).toBe(stored.id);
   });
 
-  test('deleting conversation A does not orphan attachment reused in conversation B', () => {
+  test('deleting conversation A does not orphan attachment reused in conversation B', async () => {
     const convA = createConversation('Thread A');
     const convB = createConversation('Thread B');
 
     // deleteLastExchange deletes from the last user message onward,
     // so we need a user message before the assistant message that carries the attachment.
-    addMessage(convA.id, 'user', 'Please generate a chart');
-    const msgA = addMessage(convA.id, 'assistant', 'Original');
-    addMessage(convB.id, 'user', 'Show me the chart');
-    const msgB = addMessage(convB.id, 'assistant', 'Reused');
+    await addMessage(convA.id, 'user', 'Please generate a chart');
+    const msgA = await addMessage(convA.id, 'assistant', 'Original');
+    await addMessage(convB.id, 'user', 'Show me the chart');
+    const msgB = await addMessage(convB.id, 'assistant', 'Reused');
 
     const stored = uploadAttachment('chart.png', 'image/png', 'AAAA');
     linkAttachmentToMessage(msgA.id, stored.id, 0);
@@ -506,12 +506,12 @@ describe('attachment reuse across thread lifecycles', () => {
     expect(linkedB[0].id).toBe(stored.id);
   });
 
-  test('content-hash dedup works across conversations', () => {
+  test('content-hash dedup works across conversations', async () => {
     const convA = createConversation('Thread A');
     const convB = createConversation('Thread B');
 
-    addMessage(convA.id, 'user', 'upload in A');
-    addMessage(convB.id, 'user', 'upload in B');
+    await addMessage(convA.id, 'user', 'upload in A');
+    await addMessage(convB.id, 'user', 'upload in B');
 
     // Same content uploaded in two different conversation contexts
     const first = uploadAttachment('photo.png', 'image/png', 'DEDUPCROSS');
@@ -535,11 +535,11 @@ describe('no private-thread attachment visibility boundary', () => {
     db.run('DELETE FROM conversations');
   });
 
-  test('attachment from a private thread is visible via getAttachmentById (no thread scoping)', () => {
+  test('attachment from a private thread is visible via getAttachmentById (no thread scoping)', async () => {
     const privateConv = createConversation({ title: 'Secret', threadType: 'private' });
     expect(privateConv.threadType).toBe('private');
 
-    const msg = addMessage(privateConv.id, 'assistant', 'Private content');
+    const msg = await addMessage(privateConv.id, 'assistant', 'Private content');
     const stored = uploadAttachment('secret.pdf', 'application/pdf', 'JVBER');
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
@@ -549,12 +549,12 @@ describe('no private-thread attachment visibility boundary', () => {
     expect(fetched!.originalFilename).toBe('secret.pdf');
   });
 
-  test('attachment from private thread can be linked to a standard thread message', () => {
+  test('attachment from private thread can be linked to a standard thread message', async () => {
     const privateConv = createConversation({ title: 'Private', threadType: 'private' });
     const standardConv = createConversation({ title: 'Standard', threadType: 'standard' });
 
-    const privateMsg = addMessage(privateConv.id, 'assistant', 'Private file');
-    const standardMsg = addMessage(standardConv.id, 'assistant', 'Reusing private file');
+    const privateMsg = await addMessage(privateConv.id, 'assistant', 'Private file');
+    const standardMsg = await addMessage(standardConv.id, 'assistant', 'Reusing private file');
 
     const stored = uploadAttachment('private-doc.png', 'image/png', 'PRIVDATA');
     linkAttachmentToMessage(privateMsg.id, stored.id, 0);
@@ -569,9 +569,9 @@ describe('no private-thread attachment visibility boundary', () => {
     expect(linkedStandard[0].id).toBe(stored.id);
   });
 
-  test('getAttachmentsForMessage returns private thread attachments', () => {
+  test('getAttachmentsForMessage returns private thread attachments', async () => {
     const privateConv = createConversation({ title: 'Private', threadType: 'private' });
-    const msg = addMessage(privateConv.id, 'assistant', 'Private media');
+    const msg = await addMessage(privateConv.id, 'assistant', 'Private media');
     const stored = uploadAttachment('photo.jpg', 'image/jpeg', 'AAAA');
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
@@ -592,12 +592,12 @@ describe('no private-thread attachment visibility boundary', () => {
     expect(fromStandard.id).toBe(fromPrivate.id);
   });
 
-  test('clearAll removes attachments from both private and standard threads', () => {
+  test('clearAll removes attachments from both private and standard threads', async () => {
     const privateConv = createConversation({ title: 'Private', threadType: 'private' });
     const standardConv = createConversation({ title: 'Standard', threadType: 'standard' });
 
-    const privateMsg = addMessage(privateConv.id, 'assistant', 'Private file');
-    const standardMsg = addMessage(standardConv.id, 'assistant', 'Standard file');
+    const privateMsg = await addMessage(privateConv.id, 'assistant', 'Private file');
+    const standardMsg = await addMessage(standardConv.id, 'assistant', 'Standard file');
 
     const att1 = uploadAttachment('private.png', 'image/png', 'PRIV');
     const att2 = uploadAttachment('standard.png', 'image/png', 'STD');

package/src/__tests__/date-context.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect,test } from 'bun:test';
 
-import { buildTemporalContext } from '../daemon/date-context.js';
+import { buildTemporalContext, extractUserTimeZoneFromDynamicProfile } from '../daemon/date-context.js';
 
 // Fixed timestamps for deterministic assertions (all UTC midday to avoid DST edge cases).
 
@@ -40,11 +40,181 @@ describe('buildTemporalContext', () => {
     expect(result).toContain('Timezone: America/New_York');
   });
 
+  test('includes current local time as ISO 8601 with offset', () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
+    expect(result).toContain('Current local time: 2026-02-18T12:00:00+00:00');
+  });
+
+  test('includes current UTC time from assistant host clock', () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
+    expect(result).toContain('Current UTC time: 2026-02-18T12:00:00.000Z');
+  });
+
+  test('documents assistant host as the authoritative clock source', () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
+    expect(result).toContain('Clock source: assistant host machine');
+  });
+
+  test('uses user timezone when provided and records source metadata', () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      hostTimeZone: 'UTC',
+      userTimeZone: 'America/New_York',
+    });
+    expect(result).toContain('Timezone: America/New_York');
+    expect(result).toContain('Current local time: 2026-02-18T07:00:00-05:00');
+    expect(result).toContain('Assistant host timezone: UTC');
+    expect(result).toContain('User timezone: America/New_York');
+    expect(result).toContain('Timezone source: user_profile_memory');
+  });
+
+  test('uses configured user timezone when profile timezone is unavailable', () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      hostTimeZone: 'UTC',
+      configuredUserTimeZone: 'America/Chicago',
+      userTimeZone: null,
+    });
+    expect(result).toContain('Timezone: America/Chicago');
+    expect(result).toContain('Current local time: 2026-02-18T06:00:00-06:00');
+    expect(result).toContain('User timezone: America/Chicago');
+    expect(result).toContain('Timezone source: user_settings');
+  });
+
+  test('configured user timezone takes precedence over profile timezone', () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      hostTimeZone: 'UTC',
+      configuredUserTimeZone: 'America/Los_Angeles',
+      userTimeZone: 'America/New_York',
+    });
+    expect(result).toContain('Timezone: America/Los_Angeles');
+    expect(result).toContain('Current local time: 2026-02-18T04:00:00-08:00');
+    expect(result).toContain('User timezone: America/Los_Angeles');
+    expect(result).toContain('Timezone source: user_settings');
+  });
+
+  test('falls back to host timezone when user timezone is unavailable', () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      hostTimeZone: 'UTC',
+      userTimeZone: null,
+    });
+    expect(result).toContain('Timezone: UTC');
+    expect(result).toContain('User timezone: unknown');
+    expect(result).toContain('Timezone source: assistant_host_fallback');
+  });
+
+  test('accepts UTC/GMT offset-style user timezone values', () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      hostTimeZone: 'UTC',
+      userTimeZone: 'UTC+2',
+    });
+    expect(result).toContain('Timezone: Etc/GMT-2');
+    expect(result).toContain('Current local time: 2026-02-18T14:00:00+02:00');
+    expect(result).toContain('User timezone: Etc/GMT-2');
+    expect(result).toContain('Timezone source: user_profile_memory');
+  });
+
+  test('accepts fractional UTC/GMT offset-style user timezone values', () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      hostTimeZone: 'UTC',
+      userTimeZone: 'UTC+5:30',
+    });
+    expect(result).toContain('Timezone: +05:30');
+    expect(result).toContain('Current local time: 2026-02-18T17:30:00+05:30');
+    expect(result).toContain('User timezone: +05:30');
+    expect(result).toContain('Timezone source: user_profile_memory');
+  });
+
   test('includes week definitions', () => {
     const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
     expect(result).toContain('work week = Monday–Friday');
     expect(result).toContain('weekend = Saturday–Sunday');
   });
+
+  test('formats midnight hours as 00 (never 24) in local ISO output', () => {
+    const justAfterMidnight = Date.UTC(2026, 1, 19, 0, 5, 0);
+    const result = buildTemporalContext({ nowMs: justAfterMidnight, timeZone: 'UTC' });
+    expect(result).toContain('Current local time: 2026-02-19T00:05:00+00:00');
+    expect(result).not.toContain('T24:05:00');
+  });
+});
+
+describe('extractUserTimeZoneFromDynamicProfile', () => {
+  test('extracts canonical timezone from explicit timezone profile line', () => {
+    const profile = [
+      '<dynamic-user-profile>',
+      '- timezone: Timezone is America/New_York.',
+      '</dynamic-user-profile>',
+    ].join('\n');
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('America/New_York');
+  });
+
+  test('extracts timezone token from generic profile text when explicit line is absent', () => {
+    const profile = [
+      '<dynamic-user-profile>',
+      '- location: Travels often between Europe and Asia (currently Europe/Paris).',
+      '</dynamic-user-profile>',
+    ].join('\n');
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('Europe/Paris');
+  });
+
+  test('returns null when no valid timezone is present', () => {
+    const profile = [
+      '<dynamic-user-profile>',
+      '- timezone: Pacific time',
+      '</dynamic-user-profile>',
+    ].join('\n');
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBeNull();
+  });
+
+  test('extracts UTC/GMT offset tokens from explicit timezone profile line', () => {
+    const profile = [
+      '<dynamic-user-profile>',
+      '- timezone: UTC+2',
+      '</dynamic-user-profile>',
+    ].join('\n');
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('Etc/GMT-2');
+  });
+
+  test('extracts GMT negative offset tokens from generic profile text', () => {
+    const profile = [
+      '<dynamic-user-profile>',
+      '- preferences: schedule notifications in GMT-5 whenever possible.',
+      '</dynamic-user-profile>',
+    ].join('\n');
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('Etc/GMT+5');
+  });
+
+  test('extracts fractional UTC offset tokens from explicit timezone profile line', () => {
+    const profile = [
+      '<dynamic-user-profile>',
+      '- timezone: UTC+5:30',
+      '</dynamic-user-profile>',
+    ].join('\n');
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('+05:30');
+  });
+
+  test('extracts fractional GMT offset tokens from generic profile text', () => {
+    const profile = [
+      '<dynamic-user-profile>',
+      '- preferences: default reminders to GMT+5:45.',
+      '</dynamic-user-profile>',
+    ].join('\n');
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('+05:45');
+  });
+
+  test('prefers IANA timezone tokens over UTC/GMT offsets in the same profile line', () => {
+    const profile = [
+      '<dynamic-user-profile>',
+      '- timezone: UTC+1 (Europe/Paris)',
+      '</dynamic-user-profile>',
+    ].join('\n');
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('Europe/Paris');
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -186,6 +356,7 @@ describe('DST-safe timezone behavior', () => {
     // Feb 18 12:00 UTC = Feb 18 07:00 EST (same calendar date)
     const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'America/New_York' });
     expect(result).toContain('Today: 2026-02-18 (Wednesday)');
+    expect(result).toContain('Current local time: 2026-02-18T07:00:00-05:00');
   });
 
   test('date labels are correct in timezone ahead of UTC', () => {
@@ -234,6 +405,13 @@ describe('DST-safe timezone behavior', () => {
     expect(result).toContain('2026-02-21 Saturday');
     expect(result).toContain('2026-02-22 Sunday');
   });
+
+  test('local offset tracks daylight saving changes', () => {
+    // Jul 1 12:00 UTC = Jul 1 08:00 EDT
+    const summer = Date.UTC(2026, 6, 1, 12, 0, 0);
+    const result = buildTemporalContext({ nowMs: summer, timeZone: 'America/New_York' });
+    expect(result).toContain('Current local time: 2026-07-01T08:00:00-04:00');
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/db-migration-rollback.test.ts

@@ -445,13 +445,10 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
       VALUES ('migration_memory_items_scope_salted_fingerprints_v1', '1', ${now})
     `);
 
-    // validateMigrationState should not throw — it logs errors but continues.
-    // Assert directly on the returned result to verify the function itself reports
-    // the dependency violation (not just that the registry declares a dependency).
-    const result: MigrationValidationResult = validateMigrationState(db);
-    expect(result.dependencyViolations).toHaveLength(1);
-    expect(result.dependencyViolations[0].migration).toBe('migration_memory_items_scope_salted_fingerprints_v1');
-    expect(result.dependencyViolations[0].missingDependency).toBe('migration_memory_items_fingerprint_scope_unique_v1');
+    // validateMigrationState throws an IntegrityError on dependency violations
+    // to block daemon startup with an inconsistent schema.
+    expect(() => validateMigrationState(db)).toThrow('Migration dependency violations detected');
+    expect(() => validateMigrationState(db)).toThrow('migration_memory_items_fingerprint_scope_unique_v1');
 
     // Sanity-check: confirm the registry also declares this dependency, so the
     // violation detection is grounded in real schema intent.

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -2,7 +2,7 @@
  * Tests for the deterministic verification control plane (M1).
  *
  * Verifies that:
- * 1. Verification commands (/guardian_verify, /start gv_<token>) never invoke
+ * 1. Verification control messages (code replies, /start gv_<token>) never invoke
  *    the normal message pipeline — they produce only template-driven copy.
  * 2. Call session mode metadata is persisted correctly for guardian verification calls.
  * 3. TwiML generation includes guardian verification parameters when relevant.
@@ -208,8 +208,8 @@ describe('Call session mode metadata', () => {
 // Guard test: verification commands must not reach processMessage
 // ---------------------------------------------------------------------------
 
-describe('Verification commands are deterministic (guard)', () => {
-  test('handleChannelInbound does not call processMessage for /guardian_verify commands', async () => {
+describe('Verification control messages are deterministic (guard)', () => {
+  test('handleChannelInbound does not call processMessage for verification code replies', async () => {
     const { createHash } = await import('node:crypto');
     const { handleChannelInbound } = await import('../runtime/routes/inbound-message-handler.js');
     const {
@@ -217,7 +217,7 @@ describe('Verification commands are deterministic (guard)', () => {
     } = await import('../memory/channel-guardian-store.js');
 
     // Set up a pending challenge
-    const secret = 'test-secret-abc';
+    const secret = '123456';
     const challengeHash = createHash('sha256').update(secret).digest('hex');
     createChallenge({
       id: 'challenge-guard-test',
@@ -260,7 +260,7 @@ describe('Verification commands are deterministic (guard)', () => {
           interface: 'telegram',
           externalChatId: 'chat-123',
           externalMessageId: `msg-guard-${Date.now()}`,
-          content: `/guardian_verify ${secret}`,
+          content: secret,
           senderExternalUserId: 'user-123',
           senderName: 'Test User',
           replyCallbackUrl: 'http://localhost/callback',

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -0,0 +1,179 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test';
+
+const evaluateSignalMock = mock();
+const enforceRoutingIntentMock = mock();
+const updateDecisionMock = mock();
+const runDeterministicChecksMock = mock();
+const createEventMock = mock();
+const updateEventDedupeKeyMock = mock();
+const dispatchDecisionMock = mock();
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module('../channels/config.js', () => ({
+  getDeliverableChannels: () => ['vellum', 'telegram'],
+}));
+
+mock.module('../memory/channel-guardian-store.js', () => ({
+  getActiveBinding: (_assistantId: string, channel: string) =>
+    channel === 'telegram'
+      ? {
+        guardianDeliveryChatId: 'guardian-chat-123',
+        guardianExternalUserId: 'guardian-user-123',
+      }
+      : null,
+}));
+
+mock.module('../notifications/adapters/macos.js', () => ({
+  VellumAdapter: class {
+    constructor(_broadcastFn: unknown) {}
+  },
+}));
+
+mock.module('../notifications/adapters/sms.js', () => ({
+  SmsAdapter: class {},
+}));
+
+mock.module('../notifications/adapters/telegram.js', () => ({
+  TelegramAdapter: class {},
+}));
+
+mock.module('../notifications/broadcaster.js', () => ({
+  NotificationBroadcaster: class {
+    constructor(_adapters: unknown[]) {}
+    setOnThreadCreated(_fn: unknown) {}
+  },
+}));
+
+mock.module('../notifications/decision-engine.js', () => ({
+  evaluateSignal: (...args: unknown[]) => evaluateSignalMock(...args),
+  enforceRoutingIntent: (...args: unknown[]) => enforceRoutingIntentMock(...args),
+}));
+
+mock.module('../notifications/decisions-store.js', () => ({
+  updateDecision: (...args: unknown[]) => updateDecisionMock(...args),
+}));
+
+mock.module('../notifications/deterministic-checks.js', () => ({
+  runDeterministicChecks: (...args: unknown[]) => runDeterministicChecksMock(...args),
+}));
+
+mock.module('../notifications/events-store.js', () => ({
+  createEvent: (...args: unknown[]) => createEventMock(...args),
+  updateEventDedupeKey: (...args: unknown[]) => updateEventDedupeKeyMock(...args),
+}));
+
+mock.module('../notifications/runtime-dispatch.js', () => ({
+  dispatchDecision: (...args: unknown[]) => dispatchDecisionMock(...args),
+}));
+
+import { emitNotificationSignal } from '../notifications/emit-signal.js';
+
+describe('emitNotificationSignal routing intent re-persistence', () => {
+  beforeEach(() => {
+    evaluateSignalMock.mockReset();
+    enforceRoutingIntentMock.mockReset();
+    updateDecisionMock.mockReset();
+    runDeterministicChecksMock.mockReset();
+    createEventMock.mockReset();
+    updateEventDedupeKeyMock.mockReset();
+    dispatchDecisionMock.mockReset();
+
+    createEventMock.mockReturnValue({ id: 'evt-1' });
+    runDeterministicChecksMock.mockResolvedValue({ passed: true });
+    dispatchDecisionMock.mockResolvedValue({
+      dispatched: true,
+      reason: 'ok',
+      deliveryResults: [],
+    });
+  });
+
+  test('re-persists selectedChannels/reasoningSummary when enforcement changes the decision', async () => {
+    const preDecision = {
+      shouldNotify: true,
+      selectedChannels: ['vellum'],
+      reasoningSummary: 'LLM selected vellum only',
+      renderedCopy: {
+        vellum: { title: 'Reminder', body: 'Take out trash' },
+      },
+      dedupeKey: 'dedupe-rem-1',
+      confidence: 0.9,
+      fallbackUsed: false,
+      persistedDecisionId: 'dec-1',
+    };
+
+    const enforcedDecision = {
+      ...preDecision,
+      selectedChannels: ['vellum', 'telegram'],
+      reasoningSummary: `${preDecision.reasoningSummary} [routing_intent=all_channels enforced: vellum, telegram]`,
+    };
+
+    evaluateSignalMock.mockResolvedValue(preDecision);
+    enforceRoutingIntentMock.mockReturnValue(enforcedDecision);
+
+    const result = await emitNotificationSignal({
+      sourceEventName: 'reminder.fired',
+      sourceChannel: 'scheduler',
+      sourceSessionId: 'rem-1',
+      attentionHints: {
+        requiresAction: true,
+        urgency: 'high',
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+      contextPayload: { reminderId: 'rem-1' },
+      routingIntent: 'all_channels',
+    });
+
+    expect(result.dispatched).toBe(true);
+    expect(updateDecisionMock).toHaveBeenCalledTimes(1);
+    expect(updateDecisionMock).toHaveBeenCalledWith('dec-1', {
+      selectedChannels: ['vellum', 'telegram'],
+      reasoningSummary: `${preDecision.reasoningSummary} [routing_intent=all_channels enforced: vellum, telegram]`,
+      validationResults: {
+        dedupeKey: 'dedupe-rem-1',
+        channelCount: 2,
+        hasCopy: true,
+      },
+    });
+  });
+
+  test('does not re-persist when enforcement leaves the decision unchanged', async () => {
+    const decision = {
+      shouldNotify: true,
+      selectedChannels: ['vellum'],
+      reasoningSummary: 'No routing override needed',
+      renderedCopy: {
+        vellum: { title: 'Reminder', body: 'Drink water' },
+      },
+      dedupeKey: 'dedupe-rem-2',
+      confidence: 0.8,
+      fallbackUsed: false,
+      persistedDecisionId: 'dec-2',
+    };
+
+    evaluateSignalMock.mockResolvedValue(decision);
+    enforceRoutingIntentMock.mockImplementation((inputDecision: unknown) => inputDecision);
+
+    await emitNotificationSignal({
+      sourceEventName: 'reminder.fired',
+      sourceChannel: 'scheduler',
+      sourceSessionId: 'rem-2',
+      attentionHints: {
+        requiresAction: false,
+        urgency: 'medium',
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+      contextPayload: { reminderId: 'rem-2' },
+      routingIntent: 'single_channel',
+    });
+
+    expect(updateDecisionMock).not.toHaveBeenCalled();
+  });
+});