@vellumai/assistant 0.3.27 → 0.4.0

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

@@ -1,19 +1,19 @@
 import { describe, expect,test } from 'bun:test';
 
 import { buildChannelAwarenessSection } from '../config/system-prompt.js';
-import type { ChannelCapabilities, ChannelTurnContextParams, GuardianRuntimeContext } from '../daemon/session-runtime-assembly.js';
+import type { ChannelCapabilities, ChannelTurnContextParams, InboundActorContext } from '../daemon/session-runtime-assembly.js';
 import {
   applyRuntimeInjections,
   buildChannelTurnContextBlock,
   injectChannelCapabilityContext,
   injectChannelTurnContext,
-  injectGuardianContext,
+  injectInboundActorContext,
   injectTemporalContext,
   resolveChannelCapabilities,
   sanitizePttActivationKey,
   stripChannelCapabilityContext,
   stripChannelTurnContext,
-  stripGuardianContext,
+  stripInboundActorContext,
   stripTemporalContext,
 } from '../daemon/session-runtime-assembly.js';
 import type { Message } from '../providers/types.js';
@@ -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' }],
@@ -534,90 +544,146 @@ describe('applyRuntimeInjections with temporalContext', () => {
 });
 
 // ---------------------------------------------------------------------------
-// guardian_context
+// inbound_actor_context
 // ---------------------------------------------------------------------------
 
-describe('injectGuardianContext', () => {
+describe('injectInboundActorContext', () => {
   const baseUserMessage: Message = {
     role: 'user',
     content: [{ type: 'text', text: 'Can you text me updates?' }],
   };
 
-  test('prepends guardian_context block to user message', () => {
-    const ctx: GuardianRuntimeContext = {
+  test('prepends inbound_actor_context block to user message', () => {
+    const ctx: InboundActorContext = {
       sourceChannel: 'sms',
-      actorRole: 'guardian',
-      guardianExternalUserId: 'guardian-user-1',
-      guardianChatId: '+15550001111',
-      requesterIdentifier: '+15550001111',
-      requesterExternalUserId: 'guardian-user-1',
-      requesterChatId: '+15550001111',
+      canonicalActorIdentity: 'guardian-user-1',
+      actorIdentifier: '+15550001111',
+      actorDisplayName: 'Guardian Name',
+      actorSenderDisplayName: 'Guardian Name',
+      actorMemberDisplayName: 'Guardian Name',
+      trustClass: 'guardian',
+      guardianIdentity: 'guardian-user-1',
     };
 
-    const result = injectGuardianContext(baseUserMessage, ctx);
+    const result = injectInboundActorContext(baseUserMessage, ctx);
     expect(result.content.length).toBe(2);
     const injected = result.content[0];
     expect(injected.type).toBe('text');
     const text = (injected as { type: 'text'; text: string }).text;
-    expect(text).toContain('<guardian_context>');
-    expect(text).toContain('actor_role: guardian');
+    expect(text).toContain('<inbound_actor_context>');
+    expect(text).toContain('trust_class: guardian');
     expect(text).toContain('source_channel: sms');
-    expect(text).toContain('</guardian_context>');
+    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 non-guardian actors', () => {
-    const ctx: GuardianRuntimeContext = {
+  test('includes behavioral guidance for trusted_contact actors', () => {
+    const ctx: InboundActorContext = {
       sourceChannel: 'telegram',
-      actorRole: 'non-guardian',
-      guardianExternalUserId: 'guardian-user-1',
-      guardianChatId: 'chat-1',
-      requesterIdentifier: '@someone',
-      requesterExternalUserId: 'other-user-1',
-      requesterChatId: 'chat-2',
+      canonicalActorIdentity: 'other-user-1',
+      actorIdentifier: '@someone',
+      trustClass: 'trusted_contact',
+      guardianIdentity: 'guardian-user-1',
+      memberStatus: 'active',
+      memberPolicy: 'default',
     };
 
-    const result = injectGuardianContext(baseUserMessage, ctx);
+    const result = injectInboundActorContext(baseUserMessage, ctx);
     const text = (result.content[0] as { type: 'text'; text: string }).text;
     expect(text).toContain('non-guardian account');
     expect(text).toContain('Do not explain the verification system');
+    expect(text).toContain('member_status: active');
+    expect(text).toContain('member_policy: default');
+  });
+
+  test('includes behavioral guidance for unknown actors', () => {
+    const ctx: InboundActorContext = {
+      sourceChannel: 'telegram',
+      canonicalActorIdentity: null,
+      trustClass: 'unknown',
+      denialReason: 'no_identity',
+    };
+
+    const result = injectInboundActorContext(baseUserMessage, ctx);
+    const text = (result.content[0] as { type: 'text'; text: string }).text;
+    expect(text).toContain('non-guardian account');
+    expect(text).toContain('Do not explain the verification system');
+    expect(text).toContain('denial_reason: no_identity');
   });
 
   test('omits non-guardian behavioral guidance for guardian actors', () => {
-    const ctx: GuardianRuntimeContext = {
+    const ctx: InboundActorContext = {
       sourceChannel: 'telegram',
-      actorRole: 'guardian',
-      guardianExternalUserId: 'guardian-user-1',
-      guardianChatId: 'chat-1',
-      requesterIdentifier: '@guardian',
-      requesterExternalUserId: 'guardian-user-1',
-      requesterChatId: 'chat-1',
+      canonicalActorIdentity: 'guardian-user-1',
+      actorIdentifier: '@guardian',
+      trustClass: 'guardian',
+      guardianIdentity: 'guardian-user-1',
     };
 
-    const result = injectGuardianContext(baseUserMessage, ctx);
+    const result = injectInboundActorContext(baseUserMessage, ctx);
     const text = (result.content[0] as { type: 'text'; text: string }).text;
     expect(text).not.toContain('non-guardian account');
   });
+
+  test('omits member_status and member_policy when not provided', () => {
+    const ctx: InboundActorContext = {
+      sourceChannel: 'sms',
+      canonicalActorIdentity: 'user-1',
+      trustClass: 'unknown',
+      denialReason: 'no_binding',
+    };
+
+    const result = injectInboundActorContext(baseUserMessage, ctx);
+    const text = (result.content[0] as { type: 'text'; text: string }).text;
+    expect(text).not.toContain('member_status');
+    expect(text).not.toContain('member_policy');
+  });
 });
 
-describe('stripGuardianContext', () => {
-  test('strips guardian_context blocks from user messages', () => {
+describe('stripInboundActorContext', () => {
+  test('strips inbound_actor_context blocks from user messages', () => {
     const messages: Message[] = [
       {
         role: 'user',
         content: [
-          { type: 'text', text: '<guardian_context>\nactor_role: guardian\n</guardian_context>' },
+          { type: 'text', text: '<inbound_actor_context>\ntrust_class: guardian\n</inbound_actor_context>' },
           { type: 'text', text: 'Hello' },
         ],
       },
     ];
-    const result = stripGuardianContext(messages);
+    const result = stripInboundActorContext(messages);
     expect(result).toHaveLength(1);
     expect(result[0].content).toHaveLength(1);
     expect((result[0].content[0] as { type: 'text'; text: string }).text).toBe('Hello');
   });
 });
 
-describe('applyRuntimeInjections with guardianContext', () => {
+describe('applyRuntimeInjections with inboundActorContext', () => {
   const baseMessages: Message[] = [
     {
       role: 'user',
@@ -625,20 +691,21 @@ describe('applyRuntimeInjections with guardianContext', () => {
     },
   ];
 
-  test('injects guardian context when provided', () => {
+  test('injects inbound actor context when provided', () => {
     const result = applyRuntimeInjections(baseMessages, {
-      guardianContext: {
+      inboundActorContext: {
         sourceChannel: 'sms',
-        actorRole: 'non-guardian',
-        guardianExternalUserId: 'guardian-1',
-        requesterExternalUserId: 'requester-1',
-        requesterIdentifier: '+15550002222',
-        requesterChatId: '+15550002222',
+        canonicalActorIdentity: 'requester-1',
+        actorIdentifier: '+15550002222',
+        trustClass: 'trusted_contact',
+        guardianIdentity: 'guardian-1',
+        memberStatus: 'active',
+        memberPolicy: 'default',
       },
     });
     expect(result).toHaveLength(1);
     expect(result[0].content).toHaveLength(2);
-    expect((result[0].content[0] as { type: 'text'; text: string }).text).toContain('<guardian_context>');
+    expect((result[0].content[0] as { type: 'text'; text: string }).text).toContain('<inbound_actor_context>');
   });
 });
 

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');
   });

package/src/__tests__/session-slash-known.test.ts

@@ -30,6 +30,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -62,6 +64,13 @@ mock.module('../security/secret-allowlist.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',
@@ -165,6 +174,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-slash-queue.test.ts

@@ -30,6 +30,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -62,6 +64,13 @@ mock.module('../security/secret-allowlist.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',
@@ -165,6 +174,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-slash-unknown.test.ts

@@ -30,6 +30,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -64,6 +66,13 @@ mock.module('../security/secret-allowlist.js', () => ({
 const addMessageCalls: Array<{ convId: string; 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',
@@ -177,6 +186,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-workspace-cache-state.test.ts

@@ -23,6 +23,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -76,6 +78,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: () => [],
   getConversation: () => ({
     id: 'conv-1',

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

@@ -37,6 +37,8 @@ mock.module('../providers/registry.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     maxTokens: 4096,
     thinking: false,
@@ -67,6 +69,11 @@ mock.module('../permissions/trust-store.js', () => ({ addRule: () => {}, findHig
 mock.module('../security/secret-allowlist.js', () => ({ resetAllowlist: () => {} }));
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getMessages: () => [],
   getConversation: () => ({
     id: 'conv-1', contextSummary: null, contextCompactedMessageCount: 0,
@@ -134,6 +141,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-workspace-tool-tracking.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,
@@ -66,6 +68,11 @@ mock.module('../permissions/trust-store.js', () => ({ addRule: () => {}, findHig
 mock.module('../security/secret-allowlist.js', () => ({ resetAllowlist: () => {} }));
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getMessages: () => [],
   getConversation: () => ({
     id: 'conv-1', contextSummary: null, contextCompactedMessageCount: 0,
@@ -124,6 +131,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__/shell-credential-ref.test.ts

@@ -20,6 +20,8 @@ mock.module('../tools/registry.js', () => ({
 // Mock config
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     timeouts: { shellDefaultTimeoutSec: 120, shellMaxTimeoutSec: 600 },
     sandbox: { enabled: false, backend: 'none' },
     secretDetection: { allowOneTimeSend: false },