@vellumai/assistant 0.3.28 → 0.4.0

package/src/__tests__/session-abort-tool-results.test.ts

@@ -25,6 +25,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -66,6 +68,13 @@ mock.module('../memory/admin.js', () => ({
 let persistedMessages: Array<{ role: string; content: string }> = [];
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getMessages: () => [],
   getConversation: () => ({
     id: 'conv-1',
@@ -148,6 +157,20 @@ mock.module('../agent/loop.js', () => ({
     }
   },
 }));
+mock.module('../memory/canonical-guardian-store.js', () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  createCanonicalGuardianRequest: () => ({ id: 'mock-cg-id', code: 'MOCK', status: 'pending' }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: 'mock-cgd-id' }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => 'MOCK-CODE',
+}));
 
 import { Session } from '../daemon/session.js';
 

package/src/__tests__/session-agent-loop.test.ts

@@ -52,6 +52,21 @@ mock.module('../hooks/manager.js', () => ({
 }));
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationUsage: () => {},
+  getMessages: () => [],
+  getConversation: () => ({
+    id: 'conv-1',
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+    title: null,
+  }),
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
   addMessage: () => ({ id: 'mock-msg-id' }),
   deleteMessageById: () => {},
   updateConversationContextWindow: () => {},
@@ -300,6 +315,7 @@ function makeCtx(overrides?: Partial<AgentLoopSessionContext> & { agentLoopRun?:
     hasQueuedMessages: () => false,
     canHandoffAtCheckpoint: () => false,
     drainQueue: () => {},
+    getTurnInterfaceContext: () => null,
     getTurnChannelContext: () => ({
       userMessageChannel: 'vellum' as const,
       assistantMessageChannel: 'vellum' as const,

package/src/__tests__/session-conflict-gate.test.ts

@@ -76,6 +76,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -149,6 +151,11 @@ mock.module('../security/secret-allowlist.js', () => ({
 }));
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getMessages: () => persistedMessages,
   getConversation: () => ({
     id: 'conv-1',
@@ -270,6 +277,20 @@ mock.module('../agent/loop.js', () => ({
     }
   },
 }));
+mock.module('../memory/canonical-guardian-store.js', () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  createCanonicalGuardianRequest: () => ({ id: 'mock-cg-id', code: 'MOCK', status: 'pending' }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: 'mock-cgd-id' }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => 'MOCK-CODE',
+}));
 
 import { Session, type SessionMemoryPolicy } from '../daemon/session.js';
 import { ConflictGate, looksLikeClarificationReply } from '../daemon/session-conflict-gate.js';

package/src/__tests__/session-load-history-repair.test.ts

@@ -19,6 +19,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -54,6 +56,14 @@ let mockConversation: Record<string, unknown> | null = null;
 let nextMockMessageId = 1;
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  updateConversationTitle: () => {},
+  updateConversationUsage: () => {},
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getMessages: () => mockDbMessages,
   getConversation: () => mockConversation,
   createConversation: () => ({ id: 'conv-1' }),
@@ -252,30 +262,30 @@ describe('loadFromDb history repair', () => {
         id: 'm1',
         role: 'user',
         content: JSON.stringify([{ type: 'text', text: 'Guardian secret question' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'guardian', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'guardian', provenanceSourceChannel: 'telegram' }),
       },
       {
         id: 'm2',
         role: 'assistant',
         content: JSON.stringify([{ type: 'text', text: 'Guardian-only answer' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'guardian', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'guardian', provenanceSourceChannel: 'telegram' }),
       },
       {
         id: 'm3',
         role: 'user',
         content: JSON.stringify([{ type: 'text', text: 'Untrusted follow-up' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'unverified_channel', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'unknown', provenanceSourceChannel: 'telegram' }),
       },
       {
         id: 'm4',
         role: 'assistant',
         content: JSON.stringify([{ type: 'text', text: 'Untrusted-safe reply' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'unverified_channel', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'unknown', provenanceSourceChannel: 'telegram' }),
       },
     ];
 
     const session = makeSession();
-    session.setGuardianContext({ actorRole: 'unverified_channel', sourceChannel: 'telegram' });
+    session.setGuardianContext({ trustClass: 'unknown', sourceChannel: 'telegram' });
     await session.loadFromDb();
     const messages = session.getMessages();
 
@@ -300,35 +310,35 @@ describe('loadFromDb history repair', () => {
         id: 'm1',
         role: 'user',
         content: JSON.stringify([{ type: 'text', text: 'Guardian question' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'guardian', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'guardian', provenanceSourceChannel: 'telegram' }),
       },
       {
         id: 'm2',
         role: 'assistant',
         content: JSON.stringify([{ type: 'text', text: 'Guardian answer' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'guardian', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'guardian', provenanceSourceChannel: 'telegram' }),
       },
       {
         id: 'm3',
         role: 'user',
         content: JSON.stringify([{ type: 'text', text: 'Unverified ping' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'unverified_channel', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'unknown', provenanceSourceChannel: 'telegram' }),
       },
       {
         id: 'm4',
         role: 'assistant',
         content: JSON.stringify([{ type: 'text', text: 'Unverified reply' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'unverified_channel', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'unknown', provenanceSourceChannel: 'telegram' }),
       },
     ];
 
     const session = makeSession();
 
-    session.setGuardianContext({ actorRole: 'guardian', sourceChannel: 'telegram' });
+    session.setGuardianContext({ trustClass: 'guardian', sourceChannel: 'telegram' });
     await session.ensureActorScopedHistory();
     expect(session.getMessages()).toHaveLength(4);
 
-    session.setGuardianContext({ actorRole: 'unverified_channel', sourceChannel: 'telegram' });
+    session.setGuardianContext({ trustClass: 'unknown', sourceChannel: 'telegram' });
     await session.ensureActorScopedHistory();
     const downgradedMessages = session.getMessages();
     expect(downgradedMessages).toHaveLength(2);
@@ -350,35 +360,35 @@ describe('loadFromDb history repair', () => {
         id: 'm1',
         role: 'user',
         content: JSON.stringify([{ type: 'text', text: 'Guardian-only question' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'guardian', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'guardian', provenanceSourceChannel: 'telegram' }),
       },
       {
         id: 'm2',
         role: 'assistant',
         content: JSON.stringify([{ type: 'text', text: 'Guardian-only answer' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'guardian', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'guardian', provenanceSourceChannel: 'telegram' }),
       },
       {
         id: 'm3',
         role: 'user',
         content: JSON.stringify([{ type: 'text', text: 'Unverified ping' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'unverified_channel', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'unknown', provenanceSourceChannel: 'telegram' }),
       },
       {
         id: 'm4',
         role: 'assistant',
         content: JSON.stringify([{ type: 'text', text: 'Unverified reply' }]),
-        metadata: JSON.stringify({ provenanceActorRole: 'unverified_channel', provenanceSourceChannel: 'telegram' }),
+        metadata: JSON.stringify({ provenanceTrustClass: 'unknown', provenanceSourceChannel: 'telegram' }),
       },
     ];
 
     const session = makeSession();
 
-    session.setGuardianContext({ actorRole: 'unverified_channel', sourceChannel: 'telegram' });
+    session.setGuardianContext({ trustClass: 'unknown', sourceChannel: 'telegram' });
     await session.ensureActorScopedHistory();
     expect(session.getMessages()).toHaveLength(2);
 
-    session.setGuardianContext({ actorRole: 'guardian', sourceChannel: 'telegram' });
+    session.setGuardianContext({ trustClass: 'guardian', sourceChannel: 'telegram' });
     await session.persistUserMessage('Guardian follow-up', []);
     const messagesAfterPersist = session.getMessages();
 

package/src/__tests__/session-pre-run-repair.test.ts

@@ -27,6 +27,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -69,6 +71,13 @@ let mockDbMessages: Array<{ id: string; role: string; content: string }> = [];
 let mockConversation: Record<string, unknown> | null = null;
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getMessages: () => mockDbMessages,
   getConversation: () => mockConversation,
   createConversation: () => ({ id: 'conv-1' }),
@@ -120,6 +129,20 @@ mock.module('../context/window-manager.js', () => ({
   createContextSummaryMessage: () => ({ role: 'user', content: [{ type: 'text', text: 'summary' }] }),
   getSummaryFromContextMessage: () => null,
 }));
+mock.module('../memory/canonical-guardian-store.js', () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  createCanonicalGuardianRequest: () => ({ id: 'mock-cg-id', code: 'MOCK', status: 'pending' }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: 'mock-cgd-id' }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => 'MOCK-CODE',
+}));
 
 import { Session } from '../daemon/session.js';
 

package/src/__tests__/session-profile-injection.test.ts

@@ -36,6 +36,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -111,6 +113,11 @@ mock.module('../security/secret-allowlist.js', () => ({
 }));
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getMessages: () => persistedMessages,
   getConversation: () => ({
     id: 'conv-1',
@@ -235,6 +242,20 @@ mock.module('../agent/loop.js', () => ({
     }
   },
 }));
+mock.module('../memory/canonical-guardian-store.js', () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  createCanonicalGuardianRequest: () => ({ id: 'mock-cg-id', code: 'MOCK', status: 'pending' }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: 'mock-cgd-id' }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => 'MOCK-CODE',
+}));
 
 import type { SessionMemoryPolicy } from '../daemon/session.js';
 import { DEFAULT_MEMORY_POLICY,Session } from '../daemon/session.js';

package/src/__tests__/session-provider-retry-repair.test.ts

@@ -27,6 +27,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -67,6 +69,9 @@ mock.module('../memory/admin.js', () => ({
 }));
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  deleteMessageById: () => {},
   getMessages: () => [],
   getConversation: () => ({
     id: 'conv-1',
@@ -202,6 +207,21 @@ mock.module('../agent/loop.js', () => ({
   },
 }));
 
+mock.module('../memory/canonical-guardian-store.js', () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  createCanonicalGuardianRequest: () => ({ id: 'mock-cg-id', code: 'MOCK', status: 'pending' }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: 'mock-cgd-id' }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => 'MOCK-CODE',
+}));
+
 import { Session } from '../daemon/session.js';
 
 function makeSession(): Session {

package/src/__tests__/session-queue.test.ts

@@ -40,6 +40,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -101,6 +103,13 @@ mock.module('../memory/admin.js', () => ({
 }));
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getMessages: () => [],
   getConversation: () => ({
     id: 'conv-1',
@@ -215,6 +224,20 @@ mock.module('../agent/loop.js', () => ({
     }
   },
 }));
+mock.module('../memory/canonical-guardian-store.js', () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  createCanonicalGuardianRequest: () => ({ id: 'mock-cg-id', code: 'MOCK', status: 'pending' }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: 'mock-cgd-id' }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => 'MOCK-CODE',
+}));
 
 // ---------------------------------------------------------------------------
 // Import Session AFTER mocks are registered.

package/src/__tests__/session-runtime-assembly.test.ts

@@ -26,6 +26,15 @@ describe('resolveChannelCapabilities', () => {
   test('defaults to vellum when no source channel is provided', () => {
     const caps = resolveChannelCapabilities();
     expect(caps.channel).toBe('vellum');
+    // Without a sourceInterface, desktop UI capabilities are false
+    expect(caps.dashboardCapable).toBe(false);
+    expect(caps.supportsDynamicUi).toBe(false);
+    expect(caps.supportsVoiceInput).toBe(false);
+  });
+
+  test('vellum channel with macos interface has full desktop capabilities', () => {
+    const caps = resolveChannelCapabilities(undefined, 'macos');
+    expect(caps.channel).toBe('vellum');
     expect(caps.dashboardCapable).toBe(true);
     expect(caps.supportsDynamicUi).toBe(true);
     expect(caps.supportsVoiceInput).toBe(true);
@@ -34,41 +43,42 @@ describe('resolveChannelCapabilities', () => {
   test('defaults to vellum for null source channel', () => {
     const caps = resolveChannelCapabilities(null);
     expect(caps.channel).toBe('vellum');
-    expect(caps.dashboardCapable).toBe(true);
+    expect(caps.dashboardCapable).toBe(false);
   });
 
   test('normalises "dashboard" to "vellum"', () => {
     const caps = resolveChannelCapabilities('dashboard');
     expect(caps.channel).toBe('vellum');
-    expect(caps.dashboardCapable).toBe(true);
-    expect(caps.supportsDynamicUi).toBe(true);
-    expect(caps.supportsVoiceInput).toBe(true);
+    // Without macos interface, capabilities are false
+    expect(caps.dashboardCapable).toBe(false);
+    expect(caps.supportsDynamicUi).toBe(false);
+    expect(caps.supportsVoiceInput).toBe(false);
   });
 
   test('normalises "http-api" to "vellum"', () => {
     const caps = resolveChannelCapabilities('http-api');
     expect(caps.channel).toBe('vellum');
-    expect(caps.dashboardCapable).toBe(true);
-    expect(caps.supportsDynamicUi).toBe(true);
-    expect(caps.supportsVoiceInput).toBe(true);
+    expect(caps.dashboardCapable).toBe(false);
+    expect(caps.supportsDynamicUi).toBe(false);
+    expect(caps.supportsVoiceInput).toBe(false);
   });
 
   test('normalises "mac" to "vellum"', () => {
     const caps = resolveChannelCapabilities('mac');
     expect(caps.channel).toBe('vellum');
-    expect(caps.dashboardCapable).toBe(true);
+    expect(caps.dashboardCapable).toBe(false);
   });
 
   test('normalises "macos" to "vellum"', () => {
     const caps = resolveChannelCapabilities('macos');
     expect(caps.channel).toBe('vellum');
-    expect(caps.dashboardCapable).toBe(true);
+    expect(caps.dashboardCapable).toBe(false);
   });
 
   test('normalises "ios" to "vellum"', () => {
     const caps = resolveChannelCapabilities('ios');
     expect(caps.channel).toBe('vellum');
-    expect(caps.dashboardCapable).toBe(true);
+    expect(caps.dashboardCapable).toBe(false);
   });
 
   test('resolves "telegram" as non-dashboard-capable', () => {
@@ -342,8 +352,8 @@ describe('buildChannelAwarenessSection', () => {
 // ---------------------------------------------------------------------------
 
 describe('trust-gating via channel capabilities', () => {
-  test('vellum channel does not add constraint rules', () => {
-    const caps = resolveChannelCapabilities('vellum');
+  test('vellum channel with macos interface does not add constraint rules', () => {
+    const caps = resolveChannelCapabilities('vellum', 'macos');
     const message: Message = {
       role: 'user',
       content: [{ type: 'text', text: 'Enable my microphone' }],
@@ -548,6 +558,9 @@ describe('injectInboundActorContext', () => {
       sourceChannel: 'sms',
       canonicalActorIdentity: 'guardian-user-1',
       actorIdentifier: '+15550001111',
+      actorDisplayName: 'Guardian Name',
+      actorSenderDisplayName: 'Guardian Name',
+      actorMemberDisplayName: 'Guardian Name',
       trustClass: 'guardian',
       guardianIdentity: 'guardian-user-1',
     };
@@ -561,9 +574,34 @@ describe('injectInboundActorContext', () => {
     expect(text).toContain('trust_class: guardian');
     expect(text).toContain('source_channel: sms');
     expect(text).toContain('canonical_actor_identity: guardian-user-1');
+    expect(text).toContain('actor_display_name: Guardian Name');
+    expect(text).toContain('actor_sender_display_name: Guardian Name');
+    expect(text).toContain('actor_member_display_name: Guardian Name');
     expect(text).toContain('</inbound_actor_context>');
   });
 
+  test('adds nickname guidance when member and sender display names differ', () => {
+    const ctx: InboundActorContext = {
+      sourceChannel: 'telegram',
+      canonicalActorIdentity: 'trusted-user-1',
+      actorIdentifier: '@jeff_handle',
+      actorDisplayName: 'Jeff',
+      actorSenderDisplayName: 'Jeffrey',
+      actorMemberDisplayName: 'Jeff',
+      trustClass: 'trusted_contact',
+      guardianIdentity: 'guardian-user-1',
+      memberStatus: 'active',
+      memberPolicy: 'allow',
+    };
+
+    const result = injectInboundActorContext(baseUserMessage, ctx);
+    const text = (result.content[0] as { type: 'text'; text: string }).text;
+    expect(text).toContain('actor_display_name: Jeff');
+    expect(text).toContain('actor_sender_display_name: Jeffrey');
+    expect(text).toContain('actor_member_display_name: Jeff');
+    expect(text).toContain('name_preference_note: actor_member_display_name is the guardian-preferred nickname');
+  });
+
   test('includes behavioral guidance for trusted_contact actors', () => {
     const ctx: InboundActorContext = {
       sourceChannel: 'telegram',

package/src/__tests__/session-skill-tools.test.ts

@@ -33,6 +33,7 @@ let mockVersionHashErrors: Set<string> = new Set();
 
 mock.module('../config/skills.js', () => ({
   loadSkillCatalog: () => mockCatalog,
+  checkSkillRequirements: () => ({ eligible: true, missing: {} }),
 }));
 
 mock.module('../skills/active-skill-tools.js', () => {
@@ -204,6 +205,27 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({
+    skills: { entries: {}, allowBundled: null },
+    assistantFeatureFlagValues: {},
+  }),
+  loadConfig: () => ({
+    skills: { entries: {}, allowBundled: null },
+    assistantFeatureFlagValues: {},
+  }),
+  invalidateConfigCache: () => {},
+}));
+
+mock.module('../config/assistant-feature-flags.js', () => ({
+  isAssistantFeatureFlagEnabled: () => true,
+  loadDefaultsRegistry: () => ({}),
+}));
+
+mock.module('../config/skill-state.js', () => ({
+  skillFlagKey: (skillId: string) => `feature_flags.${skillId}.enabled`,
+}));
+
 // ---------------------------------------------------------------------------
 // Import module under test (after mocks)
 // ---------------------------------------------------------------------------
@@ -1673,7 +1695,7 @@ describe('bundled skill: browser', () => {
     sessionState = new Map<string, string>();
   });
 
-  test('browser skill activation via loaded_skill marker projects all 10 tool definitions', () => {
+  test('browser skill activation via loaded_skill marker projects all 14 tool definitions', () => {
     mockCatalog = [makeSkill('browser', '/path/to/bundled-skills/browser')];
     mockManifests = { browser: makeManifest([...BROWSER_TOOL_NAMES]) };
 
@@ -1683,7 +1705,7 @@ describe('bundled skill: browser', () => {
 
     const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
 
-    expect(result.toolDefinitions).toHaveLength(10);
+    expect(result.toolDefinitions).toHaveLength(14);
     expect(result.toolDefinitions.map((d) => d.name)).toEqual([...BROWSER_TOOL_NAMES]);
     expect(result.allowedToolNames).toEqual(new Set(BROWSER_TOOL_NAMES));
   });
@@ -1717,7 +1739,7 @@ describe('bundled skill: browser', () => {
 
     const tools = mockRegisteredTools.get('browser');
     expect(tools).toBeDefined();
-    expect(tools!.length).toBe(10);
+    expect(tools!.length).toBe(14);
 
     for (const tool of tools!) {
       expect(tool.origin).toBe('skill');
@@ -2410,8 +2432,8 @@ describe('browser skill migration harness', () => {
     expect(id1).not.toBe(id2);
   });
 
-  test('BROWSER_TOOL_NAMES contains all 10 browser tools', () => {
-    expect(BROWSER_TOOL_NAMES).toHaveLength(10);
+  test('BROWSER_TOOL_NAMES contains all 14 browser tools', () => {
+    expect(BROWSER_TOOL_NAMES).toHaveLength(14);
     expect(BROWSER_TOOL_NAMES).toContain('browser_navigate');
     expect(BROWSER_TOOL_NAMES).toContain('browser_fill_credential');
   });