@vellumai/assistant 0.3.28 → 0.4.1

package/src/__tests__/send-endpoint-busy.test.ts

@@ -14,6 +14,8 @@ import { afterAll, beforeEach, describe, expect, mock,test } from 'bun:test';
 
 import type { ServerMessage } from '../daemon/ipc-protocol.js';
 import type { Session } from '../daemon/session.js';
+import { createCanonicalGuardianRequest } from '../memory/canonical-guardian-store.js';
+import { getOrCreateConversation } from '../memory/conversation-key-store.js';
 
 const testDir = realpathSync(mkdtempSync(join(tmpdir(), 'send-endpoint-busy-test-')));
 
@@ -38,6 +40,8 @@ mock.module('../util/logger.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     model: 'test',
     provider: 'test',
     apiKeys: {},
@@ -51,6 +55,7 @@ import { getDb, initializeDb, resetDb } from '../memory/db.js';
 import type { AssistantEvent } from '../runtime/assistant-event.js';
 import { AssistantEventHub } from '../runtime/assistant-event-hub.js';
 import { RuntimeHttpServer } from '../runtime/http-server.js';
+import * as pendingInteractions from '../runtime/pending-interactions.js';
 
 initializeDb();
 
@@ -61,6 +66,7 @@ initializeDb();
 /** Session that completes its agent loop quickly and emits a text delta + message_complete. */
 function makeCompletingSession(): Session {
   let processing = false;
+  const messages: unknown[] = [];
   return {
     isProcessing: () => processing,
     persistUserMessage: (_content: string, _attachments: unknown[], requestId?: string) => {
@@ -75,6 +81,10 @@ function makeCompletingSession(): Session {
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
     updateClient: () => {},
+    hasAnyPendingConfirmation: () => false,
+    hasPendingConfirmation: () => false,
+    denyAllPendingConfirmations: () => {},
+    getQueueDepth: () => 0,
     enqueueMessage: () => ({ queued: false, requestId: 'noop' }),
     runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
       onEvent({ type: 'assistant_text_delta', text: 'Hello!' });
@@ -83,12 +93,14 @@ function makeCompletingSession(): Session {
     },
     handleConfirmationResponse: () => {},
     handleSecretResponse: () => {},
+    getMessages: () => messages as never[],
   } as unknown as Session;
 }
 
 /** Session that hangs forever in the agent loop (simulates a busy session). */
 function makeHangingSession(): Session {
   let processing = false;
+  const messages: unknown[] = [];
   const enqueuedMessages: Array<{ content: string; onEvent: (msg: ServerMessage) => void; requestId: string }> = [];
   return {
     isProcessing: () => processing,
@@ -104,6 +116,10 @@ function makeHangingSession(): Session {
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
     updateClient: () => {},
+    hasAnyPendingConfirmation: () => false,
+    hasPendingConfirmation: () => false,
+    denyAllPendingConfirmations: () => {},
+    getQueueDepth: () => enqueuedMessages.length,
     enqueueMessage: (content: string, _attachments: unknown[], onEvent: (msg: ServerMessage) => void, requestId: string) => {
       enqueuedMessages.push({ content, onEvent, requestId });
       return { queued: true, requestId };
@@ -114,10 +130,63 @@ function makeHangingSession(): Session {
     },
     handleConfirmationResponse: () => {},
     handleSecretResponse: () => {},
+    getMessages: () => messages as never[],
     _enqueuedMessages: enqueuedMessages,
   } as unknown as Session;
 }
 
+function makePendingApprovalSession(requestId: string, processing: boolean): {
+  session: Session;
+  runAgentLoopMock: ReturnType<typeof mock>;
+  enqueueMessageMock: ReturnType<typeof mock>;
+  denyAllPendingConfirmationsMock: ReturnType<typeof mock>;
+  handleConfirmationResponseMock: ReturnType<typeof mock>;
+} {
+  const pending = new Set([requestId]);
+  const messages: unknown[] = [];
+  const runAgentLoopMock = mock(async () => {});
+  const enqueueMessageMock = mock((_content: string, _attachments: unknown[], _onEvent: (msg: ServerMessage) => void, queuedRequestId: string) => ({
+    queued: true,
+    requestId: queuedRequestId,
+  }));
+  const denyAllPendingConfirmationsMock = mock(() => {
+    pending.clear();
+  });
+  const handleConfirmationResponseMock = mock((resolvedRequestId: string) => {
+    pending.delete(resolvedRequestId);
+  });
+
+  const session = {
+    isProcessing: () => processing,
+    persistUserMessage: (_content: string, _attachments: unknown[], reqId?: string) => reqId ?? 'msg-1',
+    memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
+    setChannelCapabilities: () => {},
+    setAssistantId: () => {},
+    setGuardianContext: () => {},
+    setCommandIntent: () => {},
+    setTurnChannelContext: () => {},
+    setTurnInterfaceContext: () => {},
+    updateClient: () => {},
+    hasAnyPendingConfirmation: () => pending.size > 0,
+    hasPendingConfirmation: (candidateRequestId: string) => pending.has(candidateRequestId),
+    denyAllPendingConfirmations: denyAllPendingConfirmationsMock,
+    getQueueDepth: () => 0,
+    enqueueMessage: enqueueMessageMock,
+    runAgentLoop: runAgentLoopMock,
+    handleConfirmationResponse: handleConfirmationResponseMock,
+    handleSecretResponse: () => {},
+    getMessages: () => messages as never[],
+  } as unknown as Session;
+
+  return {
+    session,
+    runAgentLoopMock,
+    enqueueMessageMock,
+    denyAllPendingConfirmationsMock,
+    handleConfirmationResponseMock,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -135,6 +204,9 @@ describe('POST /v1/messages — queue-if-busy and hub publishing', () => {
     db.run('DELETE FROM messages');
     db.run('DELETE FROM conversations');
     db.run('DELETE FROM conversation_keys');
+    db.run('DELETE FROM canonical_guardian_deliveries');
+    db.run('DELETE FROM canonical_guardian_requests');
+    pendingInteractions.clear();
     eventHub = new AssistantEventHub();
   });
 
@@ -222,6 +294,222 @@ describe('POST /v1/messages — queue-if-busy and hub publishing', () => {
     await stopServer();
   });
 
+  test('consumes explicit approval text when a single pending confirmation exists (idle)', async () => {
+    const conversationKey = 'conv-inline-idle';
+    const { conversationId } = getOrCreateConversation(conversationKey);
+    const requestId = 'req-inline-idle';
+    const {
+      session,
+      runAgentLoopMock,
+      enqueueMessageMock,
+      denyAllPendingConfirmationsMock,
+      handleConfirmationResponseMock,
+    } = makePendingApprovalSession(requestId, false);
+
+    pendingInteractions.register(requestId, {
+      session,
+      conversationId,
+      kind: 'confirmation',
+    });
+    createCanonicalGuardianRequest({
+      id: requestId,
+      kind: 'tool_approval',
+      sourceType: 'desktop',
+      sourceChannel: 'vellum',
+      conversationId,
+      toolName: 'call_start',
+      status: 'pending',
+      requestCode: 'ABC123',
+      expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+    });
+
+    await startServer(() => session);
+
+    const res = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({
+        conversationKey,
+        content: 'yes',
+        sourceChannel: 'vellum',
+        interface: 'macos',
+      }),
+    });
+    const body = await res.json() as { accepted: boolean; messageId?: string; queued?: boolean };
+
+    expect(res.status).toBe(202);
+    expect(body.accepted).toBe(true);
+    expect(body.messageId).toBeDefined();
+    expect(body.queued).toBeUndefined();
+    expect(handleConfirmationResponseMock).toHaveBeenCalledTimes(1);
+    expect(denyAllPendingConfirmationsMock).toHaveBeenCalledTimes(0);
+    expect(enqueueMessageMock).toHaveBeenCalledTimes(0);
+    expect(runAgentLoopMock).toHaveBeenCalledTimes(0);
+
+    await stopServer();
+  });
+
+  test('consumes explicit approval text while busy instead of auto-denying and queueing', async () => {
+    const conversationKey = 'conv-inline-busy';
+    const { conversationId } = getOrCreateConversation(conversationKey);
+    const requestId = 'req-inline-busy';
+    const {
+      session,
+      runAgentLoopMock,
+      enqueueMessageMock,
+      denyAllPendingConfirmationsMock,
+      handleConfirmationResponseMock,
+    } = makePendingApprovalSession(requestId, true);
+
+    pendingInteractions.register(requestId, {
+      session,
+      conversationId,
+      kind: 'confirmation',
+    });
+    createCanonicalGuardianRequest({
+      id: requestId,
+      kind: 'tool_approval',
+      sourceType: 'desktop',
+      sourceChannel: 'vellum',
+      conversationId,
+      toolName: 'call_start',
+      status: 'pending',
+      requestCode: 'DEF456',
+      expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+    });
+
+    await startServer(() => session);
+
+    const res = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({
+        conversationKey,
+        content: 'approve',
+        sourceChannel: 'vellum',
+        interface: 'macos',
+      }),
+    });
+    const body = await res.json() as { accepted: boolean; messageId?: string; queued?: boolean };
+
+    expect(res.status).toBe(202);
+    expect(body.accepted).toBe(true);
+    expect(body.messageId).toBeDefined();
+    expect(body.queued).toBeUndefined();
+    expect(handleConfirmationResponseMock).toHaveBeenCalledTimes(1);
+    expect(denyAllPendingConfirmationsMock).toHaveBeenCalledTimes(0);
+    expect(enqueueMessageMock).toHaveBeenCalledTimes(0);
+    expect(runAgentLoopMock).toHaveBeenCalledTimes(0);
+
+    await stopServer();
+  });
+
+  test('consumes explicit rejection text when a single pending confirmation exists (idle)', async () => {
+    const conversationKey = 'conv-inline-reject';
+    const { conversationId } = getOrCreateConversation(conversationKey);
+    const requestId = 'req-inline-reject';
+    const {
+      session,
+      runAgentLoopMock,
+      enqueueMessageMock,
+      denyAllPendingConfirmationsMock,
+      handleConfirmationResponseMock,
+    } = makePendingApprovalSession(requestId, false);
+
+    pendingInteractions.register(requestId, {
+      session,
+      conversationId,
+      kind: 'confirmation',
+    });
+    createCanonicalGuardianRequest({
+      id: requestId,
+      kind: 'tool_approval',
+      sourceType: 'desktop',
+      sourceChannel: 'vellum',
+      conversationId,
+      toolName: 'call_start',
+      status: 'pending',
+      requestCode: 'GHI789',
+      expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+    });
+
+    await startServer(() => session);
+
+    const res = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({
+        conversationKey,
+        content: 'no',
+        sourceChannel: 'vellum',
+        interface: 'macos',
+      }),
+    });
+    const body = await res.json() as { accepted: boolean; messageId?: string; queued?: boolean };
+
+    expect(res.status).toBe(202);
+    expect(body.accepted).toBe(true);
+    expect(body.messageId).toBeDefined();
+    expect(body.queued).toBeUndefined();
+    // Rejection still flows through handleConfirmationResponse (with reject action)
+    expect(handleConfirmationResponseMock).toHaveBeenCalledTimes(1);
+    expect(denyAllPendingConfirmationsMock).toHaveBeenCalledTimes(0);
+    expect(enqueueMessageMock).toHaveBeenCalledTimes(0);
+    expect(runAgentLoopMock).toHaveBeenCalledTimes(0);
+
+    await stopServer();
+  });
+
+  test('does not consume ambiguous text — falls through to normal message handling', async () => {
+    const conversationKey = 'conv-inline-ambiguous';
+    const { conversationId } = getOrCreateConversation(conversationKey);
+    const requestId = 'req-inline-ambiguous';
+    const {
+      session,
+      runAgentLoopMock,
+    } = makePendingApprovalSession(requestId, false);
+
+    pendingInteractions.register(requestId, {
+      session,
+      conversationId,
+      kind: 'confirmation',
+    });
+    createCanonicalGuardianRequest({
+      id: requestId,
+      kind: 'tool_approval',
+      sourceType: 'desktop',
+      sourceChannel: 'vellum',
+      conversationId,
+      toolName: 'call_start',
+      status: 'pending',
+      requestCode: 'JKL012',
+      expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+    });
+
+    await startServer(() => session);
+
+    const res = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({
+        conversationKey,
+        content: 'What is the weather today?',
+        sourceChannel: 'vellum',
+        interface: 'macos',
+      }),
+    });
+    const body = await res.json() as { accepted: boolean; messageId?: string; queued?: boolean };
+
+    // Ambiguous text should NOT be consumed — falls through to normal send path
+    expect(res.status).toBe(202);
+    expect(body.accepted).toBe(true);
+    expect(body.messageId).toBeDefined();
+    // The normal idle send path fires runAgentLoop
+    expect(runAgentLoopMock).toHaveBeenCalledTimes(1);
+
+    await stopServer();
+  });
+
   // ── Busy session: queue-if-busy ─────────────────────────────────────
 
   test('returns 202 with queued: true when session is busy (not 409)', async () => {

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