@vellumai/assistant 0.3.27 → 0.4.0

package/src/__tests__/channel-approval-routes.test.ts

@@ -67,6 +67,11 @@ mock.module('../memory/ingress-member-store.js', () => ({
   updateLastSeen: () => {},
 }));
 import type { Session } from '../daemon/session.js';
+import {
+  createCanonicalGuardianDelivery,
+  createCanonicalGuardianRequest,
+  getCanonicalGuardianRequest,
+} from '../memory/canonical-guardian-store.js';
 import * as channelDeliveryStore from '../memory/channel-delivery-store.js';
 import {
   createApprovalRequest,
@@ -110,6 +115,9 @@ function ensureConversation(conversationId: string): void {
 
 function resetTables(): void {
   const db = getDb();
+  db.run('DELETE FROM scoped_approval_grants');
+  db.run('DELETE FROM canonical_guardian_deliveries');
+  db.run('DELETE FROM canonical_guardian_requests');
   db.run('DELETE FROM channel_guardian_approval_requests');
   db.run('DELETE FROM channel_guardian_verification_challenges');
   db.run('DELETE FROM channel_guardian_bindings');
@@ -458,7 +466,7 @@ describe('empty content with callbackData bypasses validation', () => {
     const res = await handleChannelInbound(req, noopProcessMessage);
     expect(res.status).toBe(400);
     const body = await res.json() as Record<string, unknown>;
-    expect(body.error).toBe('content or attachmentIds is required');
+    expect((body.error as Record<string, unknown>).message).toBe('content or attachmentIds is required');
   });
 
   test('allows empty content when callbackData is present', async () => {
@@ -2645,4 +2653,169 @@ describe('background channel processing approval prompts', () => {
     expect(processCalls.length).toBeGreaterThan(0);
     expect(processCalls[0].options?.isInteractive).toBe(false);
   });
+
+  test('unverified channel turns never broadcast approval prompts', async () => {
+    // No guardian binding is created, so the sender resolves to unverified_channel.
+    const deliverPromptSpy = spyOn(gatewayClient, 'deliverApprovalPrompt').mockResolvedValue(undefined);
+    const processCalls: Array<{ options?: Record<string, unknown> }> = [];
+
+    const processMessage = mock(async (
+      conversationId: string,
+      _content: string,
+      _attachmentIds?: string[],
+      options?: Record<string, unknown>,
+    ) => {
+      processCalls.push({ options });
+
+      // Simulate a pending confirmation becoming visible while background
+      // processing is running. Unverified actors must still not receive it.
+      registerPendingInteraction('req-bg-unverified-1', conversationId, 'host_bash', {
+        input: { command: 'ls -la' },
+        riskLevel: 'medium',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 350));
+      return { messageId: 'msg-bg-unverified-1' };
+    });
+
+    const req = makeInboundRequest({
+      content: 'run ls',
+      sourceChannel: 'telegram',
+      replyCallbackUrl: 'https://gateway.test/deliver/telegram',
+      externalMessageId: 'msg-bg-unverified-1',
+    });
+
+    const res = await handleChannelInbound(req, processMessage as unknown as typeof noopProcessMessage, 'token');
+    const body = await res.json() as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+
+    await new Promise((resolve) => setTimeout(resolve, 700));
+
+    expect(processCalls.length).toBeGreaterThan(0);
+    expect(processCalls[0].options?.isInteractive).toBe(false);
+    expect(deliverPromptSpy).not.toHaveBeenCalled();
+
+    deliverPromptSpy.mockRestore();
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// NL approval routing via destination-scoped canonical requests
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('NL approval routing via destination-scoped canonical requests', () => {
+  beforeEach(() => {
+    resetTables();
+    noopProcessMessage.mockClear();
+  });
+
+  test('guardian plain-text "yes" resolves a pending_question with no guardianExternalUserId via delivery-scoped hint', async () => {
+    // Simulate a voice-originated pending_question without guardianExternalUserId
+    const guardianChatId = 'guardian-chat-nl-1';
+    const guardianUserId = 'guardian-user-nl-1';
+
+    // Ensure the conversation exists so the resolver finds it
+    ensureConversation('conv-voice-nl-1');
+
+    // Create guardian binding for Telegram
+    createBinding({
+      assistantId: 'self',
+      channel: 'telegram',
+      guardianExternalUserId: guardianUserId,
+      guardianDeliveryChatId: guardianChatId,
+    });
+
+    // Create canonical tool_approval request WITHOUT guardianExternalUserId
+    // but WITH a conversationId (required by the tool_approval resolver)
+    const canonicalReq = createCanonicalGuardianRequest({
+      kind: 'tool_approval',
+      sourceType: 'voice',
+      sourceChannel: 'twilio',
+      conversationId: 'conv-voice-nl-1',
+      toolName: 'shell',
+      expiresAt: new Date(Date.now() + 60_000).toISOString(),
+      // guardianExternalUserId intentionally omitted
+    });
+
+    // Register pending interaction so resolver can find it
+    registerPendingInteraction(canonicalReq.id, 'conv-voice-nl-1', 'shell');
+
+    // Create canonical delivery row targeting guardian chat
+    createCanonicalGuardianDelivery({
+      requestId: canonicalReq.id,
+      destinationChannel: 'telegram',
+      destinationChatId: guardianChatId,
+    });
+
+    // Send inbound guardian text reply "yes" from that chat
+    const req = makeInboundRequest({
+      sourceChannel: 'telegram',
+      externalChatId: guardianChatId,
+      senderExternalUserId: guardianUserId,
+      content: 'yes',
+      externalMessageId: `msg-nl-approve-${Date.now()}`,
+    });
+    const res = await handleChannelInbound(req, noopProcessMessage as any, TEST_BEARER_TOKEN);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(body.accepted).toBe(true);
+    expect(body.canonicalRouter).toBe('canonical_decision_applied');
+
+    // Verify the request was resolved
+    const resolved = getCanonicalGuardianRequest(canonicalReq.id);
+    expect(resolved).not.toBeNull();
+    expect(resolved!.status).toBe('approved');
+  });
+
+  test('inbound from different chat ID does not auto-match delivery-scoped canonical request', async () => {
+    const guardianChatId = 'guardian-chat-nl-2';
+    const guardianUserId = 'guardian-user-nl-2';
+    const differentChatId = 'different-chat-999';
+
+    // Create guardian binding for the guardian user on the different chat
+    createBinding({
+      assistantId: 'self',
+      channel: 'telegram',
+      guardianExternalUserId: guardianUserId,
+      guardianDeliveryChatId: differentChatId,
+    });
+
+    // Create canonical pending_question WITHOUT guardianExternalUserId
+    const canonicalReq = createCanonicalGuardianRequest({
+      kind: 'tool_approval',
+      sourceType: 'voice',
+      sourceChannel: 'twilio',
+      toolName: 'shell',
+      expiresAt: new Date(Date.now() + 60_000).toISOString(),
+    });
+
+    // Delivery targets the original guardian chat, NOT the different chat
+    createCanonicalGuardianDelivery({
+      requestId: canonicalReq.id,
+      destinationChannel: 'telegram',
+      destinationChatId: guardianChatId,
+    });
+
+    // Send from differentChatId — delivery-scoped lookup should not match
+    const req = makeInboundRequest({
+      sourceChannel: 'telegram',
+      externalChatId: differentChatId,
+      senderExternalUserId: guardianUserId,
+      content: 'approve',
+      externalMessageId: `msg-nl-mismatch-${Date.now()}`,
+    });
+    const res = await handleChannelInbound(req, noopProcessMessage as any, TEST_BEARER_TOKEN);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(body.accepted).toBe(true);
+    // Should NOT have been consumed by canonical router since there are no
+    // delivery-scoped pending requests for this chat, and identity-based
+    // fallback finds no match either (no guardianExternalUserId on request)
+    expect(body.canonicalRouter).toBeUndefined();
+
+    // Request should remain pending
+    const unchanged = getCanonicalGuardianRequest(canonicalReq.id);
+    expect(unchanged).not.toBeNull();
+    expect(unchanged!.status).toBe('pending');
+  });
 });

package/src/__tests__/channel-invite-transport.test.ts

@@ -71,7 +71,7 @@ describe('channel-invite-transport', () => {
 
   describe('telegram buildShareableInvite', () => {
     test('produces a valid Telegram deep link', () => {
-      const result = telegramInviteTransport.buildShareableInvite({
+      const result = telegramInviteTransport.buildShareableInvite!({
         rawToken: 'abc123_test-token',
         sourceChannel: 'telegram',
       });
@@ -81,15 +81,15 @@ describe('channel-invite-transport', () => {
     });
 
     test('deep link is deterministic for the same token', () => {
-      const a = telegramInviteTransport.buildShareableInvite({ rawToken: 'tok1', sourceChannel: 'telegram' });
-      const b = telegramInviteTransport.buildShareableInvite({ rawToken: 'tok1', sourceChannel: 'telegram' });
+      const a = telegramInviteTransport.buildShareableInvite!({ rawToken: 'tok1', sourceChannel: 'telegram' });
+      const b = telegramInviteTransport.buildShareableInvite!({ rawToken: 'tok1', sourceChannel: 'telegram' });
       expect(a.url).toBe(b.url);
       expect(a.displayText).toBe(b.displayText);
     });
 
     test('uses the configured bot username', () => {
       mockBotUsername = 'my_custom_bot';
-      const result = telegramInviteTransport.buildShareableInvite({
+      const result = telegramInviteTransport.buildShareableInvite!({
         rawToken: 'token',
         sourceChannel: 'telegram',
       });
@@ -103,7 +103,7 @@ describe('channel-invite-transport', () => {
       delete process.env.TELEGRAM_BOT_USERNAME;
       try {
         expect(() =>
-          telegramInviteTransport.buildShareableInvite({
+          telegramInviteTransport.buildShareableInvite!({
             rawToken: 'token',
             sourceChannel: 'telegram',
           }),
@@ -118,7 +118,7 @@ describe('channel-invite-transport', () => {
       const prev = process.env.TELEGRAM_BOT_USERNAME;
       process.env.TELEGRAM_BOT_USERNAME = 'env_bot';
       try {
-        const result = telegramInviteTransport.buildShareableInvite({
+        const result = telegramInviteTransport.buildShareableInvite!({
           rawToken: 'token',
           sourceChannel: 'telegram',
         });

package/src/__tests__/channel-reply-delivery.test.ts

@@ -50,6 +50,25 @@ mock.module('../runtime/gateway-client.js', () => ({
 }));
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  updateConversationTitle: () => {},
+  updateConversationUsage: () => {},
+  addMessage: () => ({ id: 'mock-msg-id' }),
+  getConversation: () => ({
+    id: 'conv-1',
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+    title: null,
+  }),
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getMessages: () => conversationMessages,
 }));
 

package/src/__tests__/channel-retry-sweep.test.ts

@@ -0,0 +1,130 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { eq } from 'drizzle-orm';
+
+const testDir = mkdtempSync(join(tmpdir(), 'channel-retry-sweep-test-'));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+import * as channelDeliveryStore from '../memory/channel-delivery-store.js';
+import { getDb, initializeDb, resetDb } from '../memory/db.js';
+import { channelInboundEvents, messages } from '../memory/schema.js';
+import { sweepFailedEvents } from '../runtime/channel-retry-sweep.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    // Best effort cleanup
+  }
+});
+
+function resetTables(): void {
+  const db = getDb();
+  db.run('DELETE FROM channel_inbound_events');
+  db.run('DELETE FROM conversation_keys');
+  db.run('DELETE FROM messages');
+  db.run('DELETE FROM conversations');
+}
+
+function seedFailedLegacyEvent(actorRole: 'guardian' | 'non-guardian' | 'unverified_channel'): string {
+  const inbound = channelDeliveryStore.recordInbound('telegram', 'chat-legacy', `msg-${actorRole}`);
+  channelDeliveryStore.storePayload(inbound.eventId, {
+    content: 'retry me',
+    sourceChannel: 'telegram',
+    interface: 'telegram',
+    guardianCtx: {
+      actorRole,
+      sourceChannel: 'telegram',
+      requesterExternalUserId: 'legacy-user',
+      requesterChatId: 'chat-legacy',
+    },
+  });
+
+  const db = getDb();
+  db.update(channelInboundEvents)
+    .set({
+      processingStatus: 'failed',
+      processingAttempts: 1,
+      retryAfter: Date.now() - 1,
+    })
+    .where(eq(channelInboundEvents.id, inbound.eventId))
+    .run();
+
+  return inbound.eventId;
+}
+
+describe('channel-retry-sweep', () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test('replays legacy guardianCtx.actorRole with preserved trust semantics', async () => {
+    const cases: Array<{
+      actorRole: 'guardian' | 'non-guardian' | 'unverified_channel';
+      expectedTrustClass: 'guardian' | 'trusted_contact' | 'unknown';
+      expectedInteractive: boolean;
+    }> = [
+      { actorRole: 'guardian', expectedTrustClass: 'guardian', expectedInteractive: true },
+      { actorRole: 'non-guardian', expectedTrustClass: 'trusted_contact', expectedInteractive: false },
+      { actorRole: 'unverified_channel', expectedTrustClass: 'unknown', expectedInteractive: false },
+    ];
+
+    for (const c of cases) {
+      const eventId = seedFailedLegacyEvent(c.actorRole);
+      let capturedOptions: {
+        guardianContext?: { trustClass?: string };
+        isInteractive?: boolean;
+      } | undefined;
+
+      await sweepFailedEvents(
+        async (conversationId, _content, _attachmentIds, options) => {
+          capturedOptions = options as {
+            guardianContext?: { trustClass?: string };
+            isInteractive?: boolean;
+          };
+          const messageId = `message-${c.actorRole}`;
+          const db = getDb();
+          db.insert(messages).values({
+            id: messageId,
+            conversationId,
+            role: 'user',
+            content: JSON.stringify([{ type: 'text', text: 'retry me' }]),
+            createdAt: Date.now(),
+          }).run();
+          return { messageId };
+        },
+        undefined,
+      );
+
+      expect(capturedOptions?.guardianContext?.trustClass).toBe(c.expectedTrustClass);
+      expect(capturedOptions?.isInteractive).toBe(c.expectedInteractive);
+
+      const db = getDb();
+      const row = db.select().from(channelInboundEvents).where(eq(channelInboundEvents.id, eventId)).get();
+      expect(row?.processingStatus).toBe('processed');
+    }
+  });
+});

package/src/__tests__/clarification-resolver.test.ts

@@ -57,6 +57,8 @@ mock.module('../providers/provider-send-message.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     apiKeys: {
       anthropic: 'test-key',
     },

package/src/__tests__/claude-code-skill-regression.test.ts

@@ -23,6 +23,8 @@ mock.module('../util/logger.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     apiKeys: { anthropic: 'test-key' },
   }),
 }));

package/src/__tests__/claude-code-tool-profiles.test.ts

@@ -31,6 +31,8 @@ mock.module('../util/logger.js', () => ({
 // Mock config
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     apiKeys: { anthropic: 'test-key' },
   }),
 }));

package/src/__tests__/commit-message-enrichment-service.test.ts

@@ -3,11 +3,12 @@ import { existsSync,mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { afterEach,beforeEach, describe, expect, test } from 'bun:test';
+import { afterAll, afterEach, beforeEach, describe, expect, test } from 'bun:test';
 
 import {
   _resetEnrichmentService,
   CommitEnrichmentService,
+  getEnrichmentService,
 } from '../workspace/commit-message-enrichment-service.js';
 import type { CommitContext } from '../workspace/commit-message-provider.js';
 import { _resetGitServiceRegistry,WorkspaceGitService } from '../workspace/git-service.js';
@@ -27,11 +28,18 @@ describe('CommitEnrichmentService', () => {
   });
 
   afterEach(async () => {
+    try { await getEnrichmentService().shutdown(); } catch { /* ignore */ }
+    _resetEnrichmentService();
     if (existsSync(testDir)) {
       rmSync(testDir, { recursive: true, force: true });
     }
   });
 
+  afterAll(async () => {
+    try { await getEnrichmentService().shutdown(); } catch { /* ignore */ }
+    _resetEnrichmentService();
+  });
+
   function makeContext(overrides?: Partial<CommitContext>): CommitContext {
     return {
       workspaceDir: testDir,

package/src/__tests__/computer-use-session-lifecycle.test.ts

@@ -5,6 +5,8 @@ import { describe, expect, mock,test } from 'bun:test';
 // (which have no trust rules in test) don't trigger approval prompts.
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     permissions: { mode: 'legacy' },
     apiKeys: {},

package/src/__tests__/computer-use-session-working-dir.test.ts

@@ -47,6 +47,7 @@ mock.module('../util/platform.js', () => ({
   isLinux: () => true,
   isWindows: () => false,
   readHttpToken: () => null,
+  normalizeAssistantId: (id: string) => id,
 }));
 
 mock.module('../tools/executor.js', () => ({

package/src/__tests__/computer-use-skill-lifecycle-cleanup.test.ts

@@ -3,6 +3,8 @@ import { beforeAll, describe, expect, mock,test } from 'bun:test';
 // Mock config before importing modules that depend on it.
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     provider: 'mock-provider',
     permissions: { mode: 'legacy' },
     apiKeys: {},

package/src/__tests__/config-schema.test.ts

@@ -79,7 +79,7 @@ describe('AssistantConfigSchema', () => {
     expect(result.thinking).toEqual({ enabled: false, budgetTokens: 10000, streamThinking: false });
     expect(result.contextWindow).toEqual({
       enabled: true,
-      maxInputTokens: 180000,
+      maxInputTokens: 200000,
       targetInputTokens: 110000,
       compactThreshold: 0.8,
       preserveRecentUserTurns: 8,
@@ -1098,7 +1098,7 @@ describe('loadConfig with schema validation', () => {
     expect(config.thinking).toEqual({ enabled: false, budgetTokens: 10000, streamThinking: false });
     expect(config.contextWindow).toEqual({
       enabled: true,
-      maxInputTokens: 180000,
+      maxInputTokens: 200000,
       targetInputTokens: 110000,
       compactThreshold: 0.8,
       preserveRecentUserTurns: 8,
@@ -1188,7 +1188,7 @@ describe('loadConfig with schema validation', () => {
   test('falls back for invalid contextWindow relationship', () => {
     writeConfig({ contextWindow: { maxInputTokens: 1000, targetInputTokens: 1000 } });
     const config = loadConfig();
-    expect(config.contextWindow.maxInputTokens).toBe(180000);
+    expect(config.contextWindow.maxInputTokens).toBe(200000);
     expect(config.contextWindow.targetInputTokens).toBe(110000);
   });
 
@@ -1348,7 +1348,7 @@ describe('Call entrypoint gating', () => {
     const response = await handleStartCall(req);
     expect(response.status).toBe(403);
 
-    const body = await response.json() as { error: string };
-    expect(body.error).toContain('disabled');
+    const body = await response.json() as { error: { message: string } };
+    expect(body.error.message).toContain('disabled');
   });
 });

package/src/__tests__/config-watcher.test.ts

@@ -96,7 +96,9 @@ mock.module('node:fs', () => {
 
 // Mock config/loader and other dependencies that ConfigWatcher imports
 mock.module('../config/loader.js', () => ({
-  getConfig: () => ({}),
+  getConfig: () => ({
+    ui: {},
+    }),
   invalidateConfigCache: () => {},
 }));
 

package/src/__tests__/connection-policy.test.ts

@@ -41,21 +41,30 @@ describe('hasNoAuthOverride', () => {
     expect(hasNoAuthOverride({ VELLUM_DAEMON_NOAUTH: 'false' })).toBe(false);
   });
 
-  test('returns true when VELLUM_DAEMON_NOAUTH is 1', () => {
-    expect(hasNoAuthOverride({ VELLUM_DAEMON_NOAUTH: '1' })).toBe(true);
+  test('returns true when VELLUM_DAEMON_NOAUTH is 1 with safety gate', () => {
+    expect(hasNoAuthOverride({ VELLUM_DAEMON_NOAUTH: '1', VELLUM_UNSAFE_AUTH_BYPASS: '1' })).toBe(true);
   });
 
-  test('returns true when VELLUM_DAEMON_NOAUTH is true', () => {
-    expect(hasNoAuthOverride({ VELLUM_DAEMON_NOAUTH: 'true' })).toBe(true);
+  test('returns false when VELLUM_DAEMON_NOAUTH is 1 without safety gate', () => {
+    expect(hasNoAuthOverride({ VELLUM_DAEMON_NOAUTH: '1' })).toBe(false);
+  });
+
+  test('returns true when VELLUM_DAEMON_NOAUTH is true with safety gate', () => {
+    expect(hasNoAuthOverride({ VELLUM_DAEMON_NOAUTH: 'true', VELLUM_UNSAFE_AUTH_BYPASS: '1' })).toBe(true);
+  });
+
+  test('returns false when VELLUM_DAEMON_NOAUTH is true without safety gate', () => {
+    expect(hasNoAuthOverride({ VELLUM_DAEMON_NOAUTH: 'true' })).toBe(false);
   });
 
   test('is independent of VELLUM_DAEMON_SOCKET', () => {
     // Socket override alone does NOT enable no-auth
     expect(hasNoAuthOverride({ VELLUM_DAEMON_SOCKET: '/tmp/custom.sock' })).toBe(false);
-    // No-auth requires its own explicit flag
+    // No-auth requires its own explicit flag plus safety gate
     expect(hasNoAuthOverride({
       VELLUM_DAEMON_SOCKET: '/tmp/custom.sock',
       VELLUM_DAEMON_NOAUTH: '1',
+      VELLUM_UNSAFE_AUTH_BYPASS: '1',
     })).toBe(true);
   });
 });

package/src/__tests__/contacts-tools.test.ts

@@ -27,7 +27,9 @@ mock.module('../util/logger.js', () => ({
 }));
 
 mock.module('../config/loader.js', () => ({
-  getConfig: () => ({ memory: {} }),
+  getConfig: () => ({
+    ui: {},
+     memory: {} }),
 }));
 
 import type { Database } from 'bun:sqlite';

package/src/__tests__/contradiction-checker.test.ts

@@ -73,6 +73,8 @@ let mockConflictableKinds: string[] = [
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     apiKeys: { anthropic: 'test-key' },
     memory: {
       conflicts: {

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

@@ -49,6 +49,16 @@ const getConversationMock = mock((id: string) => {
 });
 
 mock.module('../memory/conversation-store.js', () => ({
+  getConversationThreadType: () => 'default',
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  updateConversationTitle: () => {},
+  updateConversationUsage: () => {},
+  getMessages: () => [],
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   createConversation: createConversationMock,
   addMessage: addMessageMock,
   getConversation: getConversationMock,

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

@@ -49,7 +49,7 @@ describe('handleSendMessage', () => {
     expect(body.messageId).toBe('msg-legacy-fallback');
     expect(capturedSourceChannel).toBe('telegram');
     expect(capturedOptions?.guardianContext).toEqual({
-      actorRole: 'guardian',
+      trustClass: 'guardian',
       sourceChannel: 'telegram',
     });
   });