@vellumai/assistant 0.3.27 → 0.4.0

package/src/__tests__/sensitive-output-placeholders.test.ts

@@ -0,0 +1,208 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  applyStreamingSubstitution,
+  applySubstitutions,
+  extractAndSanitize,
+} from '../tools/sensitive-output-placeholders.js';
+
+describe('extractAndSanitize', () => {
+  test('parses a valid invite_code directive and replaces raw value with placeholder', () => {
+    const rawToken = 'abc123def456';
+    const content = `<vellum-sensitive-output kind="invite_code" value="${rawToken}" />\nhttps://t.me/bot?start=iv_${rawToken}`;
+
+    const { sanitizedContent, bindings } = extractAndSanitize(content);
+
+    expect(bindings).toHaveLength(1);
+    expect(bindings[0].kind).toBe('invite_code');
+    expect(bindings[0].value).toBe(rawToken);
+    expect(bindings[0].placeholder).toMatch(/^VELLUM_ASSISTANT_INVITE_CODE_[A-Z0-9]{8}$/);
+
+    // Directive tag should be stripped
+    expect(sanitizedContent).not.toContain('<vellum-sensitive-output');
+    // Raw token should be replaced with placeholder
+    expect(sanitizedContent).not.toContain(rawToken);
+    expect(sanitizedContent).toContain(bindings[0].placeholder);
+    // The link structure should be preserved
+    expect(sanitizedContent).toContain(`https://t.me/bot?start=iv_${bindings[0].placeholder}`);
+  });
+
+  test('ignores malformed directives safely', () => {
+    const content = 'Some text <vellum-sensitive-output broken />';
+    const { sanitizedContent, bindings } = extractAndSanitize(content);
+
+    expect(bindings).toHaveLength(0);
+    expect(sanitizedContent).toBe(content);
+  });
+
+  test('ignores unknown kind values', () => {
+    const content = '<vellum-sensitive-output kind="unknown_kind" value="secret123" />';
+    const { sanitizedContent, bindings } = extractAndSanitize(content);
+
+    expect(bindings).toHaveLength(0);
+    expect(sanitizedContent).toBe(content);
+  });
+
+  test('drops empty values', () => {
+    const content = '<vellum-sensitive-output kind="invite_code" value="" />';
+    const { sanitizedContent, bindings } = extractAndSanitize(content);
+
+    expect(bindings).toHaveLength(0);
+    // Directive should remain since no valid binding was extracted
+    expect(sanitizedContent).toBe(content);
+  });
+
+  test('deduplicates identical values into a single binding', () => {
+    const rawToken = 'token123';
+    const content = [
+      `<vellum-sensitive-output kind="invite_code" value="${rawToken}" />`,
+      `<vellum-sensitive-output kind="invite_code" value="${rawToken}" />`,
+      `Link1: https://t.me/bot?start=iv_${rawToken}`,
+      `Link2: https://t.me/bot?start=iv_${rawToken}`,
+    ].join('\n');
+
+    const { sanitizedContent, bindings } = extractAndSanitize(content);
+
+    expect(bindings).toHaveLength(1);
+    expect(bindings[0].value).toBe(rawToken);
+
+    // Both occurrences of the raw token should be replaced with the same placeholder
+    const placeholderCount = sanitizedContent.split(bindings[0].placeholder).length - 1;
+    expect(placeholderCount).toBe(2);
+    expect(sanitizedContent).not.toContain(rawToken);
+  });
+
+  test('supports multiple distinct bindings', () => {
+    const token1 = 'firstToken123';
+    const token2 = 'secondToken456';
+    const content = [
+      `<vellum-sensitive-output kind="invite_code" value="${token1}" />`,
+      `<vellum-sensitive-output kind="invite_code" value="${token2}" />`,
+      `Link1: https://t.me/bot?start=iv_${token1}`,
+      `Link2: https://t.me/bot?start=iv_${token2}`,
+    ].join('\n');
+
+    const { sanitizedContent, bindings } = extractAndSanitize(content);
+
+    expect(bindings).toHaveLength(2);
+    expect(bindings[0].value).toBe(token1);
+    expect(bindings[1].value).toBe(token2);
+
+    // Both raw tokens should be replaced
+    expect(sanitizedContent).not.toContain(token1);
+    expect(sanitizedContent).not.toContain(token2);
+    expect(sanitizedContent).toContain(bindings[0].placeholder);
+    expect(sanitizedContent).toContain(bindings[1].placeholder);
+  });
+
+  test('returns content unchanged when no directives are present', () => {
+    const content = 'Just a normal tool output with no directives.';
+    const { sanitizedContent, bindings } = extractAndSanitize(content);
+
+    expect(bindings).toHaveLength(0);
+    expect(sanitizedContent).toBe(content);
+  });
+
+  test('placeholder format matches required pattern', () => {
+    const content = '<vellum-sensitive-output kind="invite_code" value="tok123" />';
+    const { bindings } = extractAndSanitize(content);
+
+    expect(bindings).toHaveLength(1);
+    // Must be exactly: VELLUM_ASSISTANT_INVITE_CODE_ followed by 8 uppercase alphanumeric chars
+    expect(bindings[0].placeholder).toMatch(/^VELLUM_ASSISTANT_INVITE_CODE_[A-Z0-9]{8}$/);
+  });
+});
+
+describe('applySubstitutions', () => {
+  test('replaces placeholders with real values', () => {
+    const map = new Map([
+      ['VELLUM_ASSISTANT_INVITE_CODE_ABCD1234', 'realtoken123'],
+    ]);
+
+    const text = 'Your link: https://t.me/bot?start=iv_VELLUM_ASSISTANT_INVITE_CODE_ABCD1234';
+    const result = applySubstitutions(text, map);
+
+    expect(result).toBe('Your link: https://t.me/bot?start=iv_realtoken123');
+  });
+
+  test('replaces multiple placeholders', () => {
+    const map = new Map([
+      ['VELLUM_ASSISTANT_INVITE_CODE_AAAA1111', 'token1'],
+      ['VELLUM_ASSISTANT_INVITE_CODE_BBBB2222', 'token2'],
+    ]);
+
+    const text = 'Link1: VELLUM_ASSISTANT_INVITE_CODE_AAAA1111, Link2: VELLUM_ASSISTANT_INVITE_CODE_BBBB2222';
+    const result = applySubstitutions(text, map);
+
+    expect(result).toBe('Link1: token1, Link2: token2');
+  });
+
+  test('returns text unchanged when map is empty', () => {
+    const map = new Map<string, string>();
+    const text = 'No placeholders here.';
+    expect(applySubstitutions(text, map)).toBe(text);
+  });
+});
+
+describe('applyStreamingSubstitution', () => {
+  test('resolves complete placeholders in a single chunk', () => {
+    const map = new Map([
+      ['VELLUM_ASSISTANT_INVITE_CODE_ABCD1234', 'realtoken'],
+    ]);
+
+    const { emit, pending } = applyStreamingSubstitution(
+      'Your code: VELLUM_ASSISTANT_INVITE_CODE_ABCD1234 is ready.',
+      map,
+    );
+
+    expect(emit).toContain('realtoken');
+    expect(emit).not.toContain('VELLUM_ASSISTANT_INVITE_CODE_ABCD1234');
+    // No pending text since the placeholder was complete
+    expect(pending).toBe('');
+  });
+
+  test('buffers text that could be an incomplete placeholder prefix', () => {
+    const map = new Map([
+      ['VELLUM_ASSISTANT_INVITE_CODE_ABCD1234', 'realtoken'],
+    ]);
+
+    // Chunk ends mid-placeholder
+    const { emit, pending } = applyStreamingSubstitution(
+      'Your code: VELLUM_ASSISTANT_',
+      map,
+    );
+
+    // The ambiguous tail should be buffered
+    expect(pending.length).toBeGreaterThan(0);
+    // emit should not contain the partial placeholder
+    expect(emit).not.toContain('VELLUM_ASSISTANT_');
+  });
+
+  test('handles split-chunk placeholder by concatenating pending with next chunk', () => {
+    const map = new Map([
+      ['VELLUM_ASSISTANT_INVITE_CODE_ABCD1234', 'realtoken'],
+    ]);
+
+    // First chunk: partial placeholder
+    const result1 = applyStreamingSubstitution(
+      'Link: VELLUM_ASSISTANT_',
+      map,
+    );
+
+    // Second chunk completes the placeholder
+    const combined = result1.pending + 'INVITE_CODE_ABCD1234 done.';
+    const result2 = applyStreamingSubstitution(combined, map);
+
+    expect(result2.emit).toContain('realtoken');
+    expect(result2.emit).toContain('done.');
+    expect(result2.pending).toBe('');
+  });
+
+  test('returns text unchanged when map is empty', () => {
+    const map = new Map<string, string>();
+    const { emit, pending } = applyStreamingSubstitution('Hello world', map);
+
+    expect(emit).toBe('Hello world');
+    expect(pending).toBe('');
+  });
+});

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.