@vellumai/assistant 0.3.14 → 0.3.16

package/src/__tests__/registry.test.ts

@@ -334,14 +334,18 @@ describe('dynamic skill tool registry', () => {
     expect(getTool('sk_tool_b')?.origin).toBe('skill');
   });
 
-  test('rejects skill tool that collides with a core tool', async () => {
+  test('skips skill tool that collides with a core tool without throwing', async () => {
     await initializeTools();
 
     // host_file_read is a core tool registered during init
     const colliding = makeSkillTool('host_file_read', 'rogue-skill');
-    expect(() => registerSkillTools([colliding])).toThrow(
-      'collides with core tool',
-    );
+    const accepted = registerSkillTools([colliding]);
+
+    // The colliding tool should be silently skipped
+    expect(accepted).toHaveLength(0);
+    // The core tool should still be in place (not overwritten)
+    const retrieved = getTool('host_file_read');
+    expect(retrieved?.origin).toBeUndefined(); // core tools have no origin
   });
 
   test('allows replacement within the same owning skill', () => {
@@ -410,7 +414,7 @@ describe('dynamic skill tool registry', () => {
     expect(skillNames).not.toContain('bash');
   });
 
-  test('registerSkillTools is atomic — no partial registration on collision', async () => {
+  test('registerSkillTools skips core-colliding tools but registers the rest', async () => {
     await initializeTools();
 
     const tools = [
@@ -418,9 +422,14 @@ describe('dynamic skill tool registry', () => {
       makeSkillTool('host_file_read', 'atomic-skill'), // collides with core
     ];
 
-    expect(() => registerSkillTools(tools)).toThrow('collides with core tool');
-    // The first tool should NOT have been registered either
-    expect(getTool('sk_atomic_ok')).toBeUndefined();
+    const accepted = registerSkillTools(tools);
+    // Only the non-colliding tool should be accepted
+    expect(accepted).toHaveLength(1);
+    expect(accepted[0].name).toBe('sk_atomic_ok');
+    // The non-colliding tool should be registered
+    expect(getTool('sk_atomic_ok')).toBeDefined();
+    // The core tool should be untouched
+    expect(getTool('host_file_read')?.origin).toBeUndefined();
   });
 });
 

package/src/__tests__/relay-server.test.ts

@@ -1519,4 +1519,109 @@ describe('relay-server', () => {
 
     relay.destroy();
   });
+
+  // ── Outbound guardian verification pointer messages ─────────────────
+
+  test('outbound guardian verification success emits pointer to origin conversation', async () => {
+    ensureConversation('conv-gv-pointer-success');
+    ensureConversation('conv-gv-pointer-success-origin');
+    const session = createCallSession({
+      conversationId: 'conv-gv-pointer-success',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15559999999',
+      assistantId: 'test-assistant',
+      callMode: 'guardian_verification',
+      guardianVerificationSessionId: 'gv-session-ptr-success',
+      initiatedFromConversationId: 'conv-gv-pointer-success-origin',
+    });
+
+    const challenge = createVerificationChallenge('test-assistant', 'voice');
+    const secret = challenge.secret;
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(JSON.stringify({
+      type: 'setup',
+      callSid: 'CA_gv_pointer_success',
+      from: '+15551111111',
+      to: '+15559999999',
+      customParameters: { guardianVerificationSessionId: 'gv-session-ptr-success' },
+    }));
+
+    expect(relay.isGuardianVerificationActive()).toBe(true);
+
+    // Enter the correct code via DTMF
+    for (const digit of secret) {
+      await relay.handleMessage(JSON.stringify({ type: 'dtmf', digit }));
+    }
+
+    // Verification should have succeeded
+    expect(relay.isGuardianVerificationActive()).toBe(false);
+
+    // Origin conversation should have a pointer message
+    const originText = getLatestAssistantText('conv-gv-pointer-success-origin');
+    expect(originText).not.toBeNull();
+    expect(originText).toContain('Guardian verification');
+    expect(originText).toContain('+15559999999');
+    expect(originText).toContain('succeeded');
+
+    // Let the delayed endSession callback flush
+    await new Promise((resolve) => setTimeout(resolve, 3100));
+
+    relay.destroy();
+  });
+
+  test('outbound guardian verification failure emits pointer to origin conversation', async () => {
+    ensureConversation('conv-gv-pointer-fail');
+    ensureConversation('conv-gv-pointer-fail-origin');
+    const session = createCallSession({
+      conversationId: 'conv-gv-pointer-fail',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15559999999',
+      assistantId: 'test-assistant',
+      callMode: 'guardian_verification',
+      guardianVerificationSessionId: 'gv-session-ptr-fail',
+      initiatedFromConversationId: 'conv-gv-pointer-fail-origin',
+    });
+
+    createVerificationChallenge('test-assistant', 'voice');
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(JSON.stringify({
+      type: 'setup',
+      callSid: 'CA_gv_pointer_fail',
+      from: '+15551111111',
+      to: '+15559999999',
+      customParameters: { guardianVerificationSessionId: 'gv-session-ptr-fail' },
+    }));
+
+    expect(relay.isGuardianVerificationActive()).toBe(true);
+
+    // Enter wrong codes 3 times (max attempts = 3)
+    for (let attempt = 0; attempt < 3; attempt++) {
+      for (const digit of '000000') {
+        await relay.handleMessage(JSON.stringify({ type: 'dtmf', digit }));
+      }
+    }
+
+    // Call should be marked as failed
+    const updated = getCallSession(session.id);
+    expect(updated).not.toBeNull();
+    expect(updated!.status).toBe('failed');
+
+    // Origin conversation should have a failure pointer message
+    const originText = getLatestAssistantText('conv-gv-pointer-fail-origin');
+    expect(originText).not.toBeNull();
+    expect(originText).toContain('Guardian verification');
+    expect(originText).toContain('+15559999999');
+    expect(originText).toContain('failed');
+
+    // Let the delayed endSession callback flush
+    await new Promise((resolve) => setTimeout(resolve, 2100));
+
+    relay.destroy();
+  });
 });

package/src/__tests__/reminder.test.ts

@@ -219,6 +219,19 @@ describe('reminder tool', () => {
     expect(result.content).toContain('Routing: multi_channel');
   });
 
+  test('create with routing_hints null returns error', async () => {
+    const future = new Date(Date.now() + 60_000).toISOString();
+    const result = executeReminderCreate({
+      fire_at: future,
+      label: 'Bad hints',
+      message: 'Null hints should fail',
+      routing_hints: null,
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('routing_hints must be a JSON object');
+  });
+
   test('create without routing fields still works (backward compat)', async () => {
     const future = new Date(Date.now() + 60_000).toISOString();
     const result = executeReminderCreate({

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -85,8 +85,8 @@ describe('Runtime attachment metadata', () => {
 
     // Set up conversation and messages using "self" as the assistantId
     const mapping = getOrCreateConversation(conversationKey);
-    conversationStore.addMessage(mapping.conversationId, 'user', 'Hello');
-    const assistantMsg = conversationStore.addMessage(
+    await conversationStore.addMessage(mapping.conversationId, 'user', 'Hello');
+    const assistantMsg = await conversationStore.addMessage(
       mapping.conversationId,
       'assistant',
       JSON.stringify([{ type: 'text', text: 'Here is a chart' }]),
@@ -124,8 +124,8 @@ describe('Runtime attachment metadata', () => {
     const conversationKey = 'test-conv-2';
 
     const mapping = getOrCreateConversation(conversationKey);
-    conversationStore.addMessage(mapping.conversationId, 'user', 'Hello');
-    conversationStore.addMessage(
+    await conversationStore.addMessage(mapping.conversationId, 'user', 'Hello');
+    await conversationStore.addMessage(
       mapping.conversationId,
       'assistant',
       JSON.stringify([{ type: 'text', text: 'No attachments here' }]),

package/src/__tests__/scheduler-recurrence.test.ts

@@ -36,6 +36,7 @@ import {
 } from '../schedule/schedule-store.js';
 import { startScheduler } from '../schedule/scheduler.js';
 import { createTask } from '../tasks/task-store.js';
+import { getReminder, insertReminder } from '../tools/reminder/reminder-store.js';
 
 initializeDb();
 
@@ -79,6 +80,7 @@ describe('scheduler RRULE execution', () => {
     const db = getDb();
     db.run('DELETE FROM cron_runs');
     db.run('DELETE FROM cron_jobs');
+    db.run('DELETE FROM reminders');
     db.run('DELETE FROM task_runs');
     db.run('DELETE FROM tasks');
     db.run('DELETE FROM messages');
@@ -437,4 +439,52 @@ describe('scheduler RRULE execution', () => {
     expect(Math.abs(after!.nextRunAt - originalNextRunAt)).toBeLessThan(65000);
     expect(after!.lastRunAt).not.toBeNull();
   });
+
+  test('notify reminder passes routing metadata to notifyReminder callback', async () => {
+    const reminder = insertReminder({
+      label: 'Route this reminder',
+      message: 'Reminder body',
+      fireAt: Date.now() - 1000,
+      mode: 'notify',
+      routingIntent: 'multi_channel',
+      routingHints: {
+        requestedByUser: true,
+        channelMentions: ['telegram', 'sms'],
+      },
+    });
+
+    const notifyCalls: Array<{
+      id: string;
+      label: string;
+      message: string;
+      routingIntent: 'single_channel' | 'multi_channel' | 'all_channels';
+      routingHints: Record<string, unknown>;
+    }> = [];
+    const notifyReminder = (payload: {
+      id: string;
+      label: string;
+      message: string;
+      routingIntent: 'single_channel' | 'multi_channel' | 'all_channels';
+      routingHints: Record<string, unknown>;
+    }) => {
+      notifyCalls.push(payload);
+    };
+
+    const scheduler = startScheduler(async () => {}, notifyReminder, () => {});
+    await new Promise(resolve => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    expect(notifyCalls).toHaveLength(1);
+    expect(notifyCalls[0]).toEqual({
+      id: reminder.id,
+      label: reminder.label,
+      message: reminder.message,
+      routingIntent: 'multi_channel',
+      routingHints: {
+        requestedByUser: true,
+        channelMentions: ['telegram', 'sms'],
+      },
+    });
+    expect(getReminder(reminder.id)?.status).toBe('fired');
+  });
 });

package/src/__tests__/server-history-render.test.ts

@@ -381,14 +381,14 @@ describe('getAttachmentsForMessage', () => {
     db.run('DELETE FROM conversations');
   });
 
-  function createMessage(role: string, content: string): string {
+  async function createMessage(role: string, content: string): Promise<string> {
     const conv = createConversation('test');
-    const msg = addMessage(conv.id, role, content);
+    const msg = await addMessage(conv.id, role, content);
     return msg.id;
   }
 
-  test('returns attachments linked to a message', () => {
-    const msgId = createMessage('assistant', 'Here is a chart');
+  test('returns attachments linked to a message', async () => {
+    const msgId = await createMessage('assistant', 'Here is a chart');
     const stored = uploadAttachment('chart.png', 'image/png', 'iVBOR');
     linkAttachmentToMessage(msgId, stored.id, 0);
 
@@ -404,8 +404,8 @@ describe('getAttachmentsForMessage', () => {
     expect(getAttachmentsForMessage('msg-nonexistent')).toEqual([]);
   });
 
-  test('returns multiple attachments in position order', () => {
-    const msgId = createMessage('assistant', 'Two files');
+  test('returns multiple attachments in position order', async () => {
+    const msgId = await createMessage('assistant', 'Two files');
     const a1 = uploadAttachment('first.txt', 'text/plain', 'AAAA');
     const a2 = uploadAttachment('second.txt', 'text/plain', 'BBBB');
 
@@ -418,8 +418,8 @@ describe('getAttachmentsForMessage', () => {
     expect(result[1].originalFilename).toBe('second.txt');
   });
 
-  test('returns all attachments linked to a message', () => {
-    const msgId = createMessage('assistant', 'Mixed');
+  test('returns all attachments linked to a message', async () => {
+    const msgId = await createMessage('assistant', 'Mixed');
     const a1 = uploadAttachment('a.png', 'image/png', 'AAAA');
     const a2 = uploadAttachment('b.png', 'image/png', 'BBBB');
 

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

@@ -30,6 +30,7 @@ mock.module('../config/loader.js', () => ({
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     apiKeys: {},
     workspaceGit: { turnCommitMaxWaitMs: 10 },
+    ui: {},
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},

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

@@ -10,6 +10,7 @@ import {
   injectGuardianContext,
   injectTemporalContext,
   resolveChannelCapabilities,
+  sanitizePttActivationKey,
   stripChannelCapabilityContext,
   stripChannelTurnContext,
   stripGuardianContext,
@@ -787,3 +788,51 @@ describe('applyRuntimeInjections with channelTurnContext', () => {
     expect(result[0].content.length).toBe(1);
   });
 });
+
+// ---------------------------------------------------------------------------
+// sanitizePttActivationKey
+// ---------------------------------------------------------------------------
+
+describe('sanitizePttActivationKey', () => {
+  test('returns undefined for null/undefined input', () => {
+    expect(sanitizePttActivationKey(null)).toBeUndefined();
+    expect(sanitizePttActivationKey(undefined)).toBeUndefined();
+  });
+
+  test('passes through valid keys', () => {
+    expect(sanitizePttActivationKey('fn')).toBe('fn');
+    expect(sanitizePttActivationKey('ctrl')).toBe('ctrl');
+    expect(sanitizePttActivationKey('fn_shift')).toBe('fn_shift');
+    expect(sanitizePttActivationKey('none')).toBe('none');
+  });
+
+  test('returns "unknown" for invalid keys', () => {
+    expect(sanitizePttActivationKey('malicious\nprompt injection')).toBe('unknown');
+    expect(sanitizePttActivationKey('arbitrary_value')).toBe('unknown');
+    expect(sanitizePttActivationKey('')).toBe('unknown');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveChannelCapabilities sanitizes pttActivationKey
+// ---------------------------------------------------------------------------
+
+describe('resolveChannelCapabilities with PTT metadata', () => {
+  test('sanitizes valid pttActivationKey', () => {
+    const caps = resolveChannelCapabilities('macos', 'macos', { pttActivationKey: 'fn' });
+    expect(caps.pttActivationKey).toBe('fn');
+  });
+
+  test('sanitizes invalid pttActivationKey to unknown', () => {
+    const caps = resolveChannelCapabilities('macos', 'macos', { pttActivationKey: 'evil\nprompt' });
+    expect(caps.pttActivationKey).toBe('unknown');
+  });
+
+  test('passes through microphonePermissionGranted', () => {
+    const caps = resolveChannelCapabilities('macos', 'macos', {
+      pttActivationKey: 'fn',
+      microphonePermissionGranted: true,
+    });
+    expect(caps.microphonePermissionGranted).toBe(true);
+  });
+});

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

@@ -134,6 +134,7 @@ mock.module('../tools/registry.js', () => ({
     for (const id of skillIds) {
       mockSkillRefCount.set(id, (mockSkillRefCount.get(id) ?? 0) + 1);
     }
+    return tools;
   },
   unregisterSkillTools: (skillId: string) => {
     mockUnregisteredSkillIds.push(skillId);

package/src/__tests__/skill-projection.benchmark.test.ts

@@ -96,10 +96,18 @@ mock.module('node:fs', () => ({
   existsSync: () => true,
 }));
 
+const benchmarkRegistry = new Map<string, unknown>();
 mock.module('../tools/registry.js', () => ({
-  registerSkillTools: () => {},
-  unregisterSkillTools: () => {},
-  getTool: () => undefined,
+  registerSkillTools: (tools: Array<{ name: string; [k: string]: unknown }>) => {
+    for (const t of tools) benchmarkRegistry.set(t.name, t);
+    return tools;
+  },
+  unregisterSkillTools: (skillId: string) => {
+    for (const [name, t] of benchmarkRegistry) {
+      if ((t as { ownerSkillId?: string }).ownerSkillId === skillId) benchmarkRegistry.delete(name);
+    }
+  },
+  getTool: (name: string) => benchmarkRegistry.get(name),
 }));
 
 // ---------------------------------------------------------------------------

package/src/__tests__/slack-channel-config.test.ts

@@ -0,0 +1,230 @@
+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';
+
+const testDir = mkdtempSync(join(tmpdir(), 'slack-channel-cfg-test-'));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({}),
+  loadConfig: () => ({}),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  saveConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module('../util/platform.js', () => ({
+  getRootDir: () => testDir,
+  getDataDir: () => testDir,
+  getIpcBlobDir: () => join(testDir, 'ipc-blobs'),
+  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: () => {},
+  readHttpToken: () => undefined,
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+    isDebug: () => false,
+    child: () => ({
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      debug: () => {},
+      isDebug: () => false,
+    }),
+  }),
+}));
+
+// Mock secure key storage
+let secureKeyStore: Record<string, string> = {};
+
+mock.module('../security/secure-keys.js', () => ({
+  getSecureKey: (account: string) => secureKeyStore[account] ?? undefined,
+  setSecureKey: (account: string, value: string) => {
+    secureKeyStore[account] = value;
+    return true;
+  },
+  deleteSecureKey: (account: string) => {
+    if (account in secureKeyStore) {
+      delete secureKeyStore[account];
+      return true;
+    }
+    return false;
+  },
+  listSecureKeys: () => Object.keys(secureKeyStore),
+  getBackendType: () => 'encrypted',
+  isDowngradedFromKeychain: () => false,
+  _resetBackend: () => {},
+  _setBackend: () => {},
+}));
+
+// Mock credential metadata store
+let credentialMetadataStore: Array<{ service: string; field: string; accountInfo?: string }> = [];
+
+mock.module('../tools/credentials/metadata-store.js', () => ({
+  getCredentialMetadata: (service: string, field: string) =>
+    credentialMetadataStore.find((m) => m.service === service && m.field === field) ?? undefined,
+  upsertCredentialMetadata: (service: string, field: string, policy?: Record<string, unknown>) => {
+    const existing = credentialMetadataStore.find((m) => m.service === service && m.field === field);
+    if (existing) {
+      if (policy?.accountInfo !== undefined) existing.accountInfo = policy.accountInfo as string;
+      return existing;
+    }
+    const record = { service, field, accountInfo: policy?.accountInfo as string | undefined };
+    credentialMetadataStore.push(record);
+    return record;
+  },
+  deleteCredentialMetadata: (service: string, field: string) => {
+    const idx = credentialMetadataStore.findIndex((m) => m.service === service && m.field === field);
+    if (idx !== -1) {
+      credentialMetadataStore.splice(idx, 1);
+      return true;
+    }
+    return false;
+  },
+  listCredentialMetadata: () => credentialMetadataStore,
+  assertMetadataWritable: () => {},
+  _setMetadataPath: () => {},
+}));
+
+// Mock fetch for Slack API validation
+const originalFetch = globalThis.fetch;
+
+import {
+  getSlackChannelConfig,
+  setSlackChannelConfig,
+  clearSlackChannelConfig,
+} from '../daemon/handlers/config-slack-channel.js';
+
+afterAll(() => {
+  globalThis.fetch = originalFetch;
+  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+});
+
+describe('Slack channel config handler', () => {
+  beforeEach(() => {
+    secureKeyStore = {};
+    credentialMetadataStore = [];
+    globalThis.fetch = originalFetch;
+  });
+
+  test('GET returns correct shape when not configured', () => {
+    const result = getSlackChannelConfig();
+    expect(result.success).toBe(true);
+    expect(result.hasBotToken).toBe(false);
+    expect(result.hasAppToken).toBe(false);
+    expect(result.connected).toBe(false);
+  });
+
+  test('GET returns connected: true when both tokens are set', () => {
+    secureKeyStore['credential:slack_channel:bot_token'] = 'xoxb-test';
+    secureKeyStore['credential:slack_channel:app_token'] = 'xapp-test';
+
+    const result = getSlackChannelConfig();
+    expect(result.success).toBe(true);
+    expect(result.hasBotToken).toBe(true);
+    expect(result.hasAppToken).toBe(true);
+    expect(result.connected).toBe(true);
+  });
+
+  test('GET returns metadata when available', () => {
+    secureKeyStore['credential:slack_channel:bot_token'] = 'xoxb-test';
+    credentialMetadataStore.push({
+      service: 'slack_channel',
+      field: 'bot_token',
+      accountInfo: JSON.stringify({
+        teamId: 'T123',
+        teamName: 'TestTeam',
+        botUserId: 'U_BOT',
+        botUsername: 'testbot',
+      }),
+    });
+
+    const result = getSlackChannelConfig();
+    expect(result.teamId).toBe('T123');
+    expect(result.teamName).toBe('TestTeam');
+    expect(result.botUserId).toBe('U_BOT');
+    expect(result.botUsername).toBe('testbot');
+  });
+
+  test('POST validates app token shape (xapp- prefix required)', async () => {
+    const result = await setSlackChannelConfig(undefined, 'invalid-token');
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('xapp-');
+  });
+
+  test('POST accepts valid app token with xapp- prefix', async () => {
+    const result = await setSlackChannelConfig(undefined, 'xapp-valid-token-123');
+    expect(result.success).toBe(true);
+    expect(result.hasAppToken).toBe(true);
+    expect(secureKeyStore['credential:slack_channel:app_token']).toBe('xapp-valid-token-123');
+  });
+
+  test('POST validates bot token via Slack auth.test API', async () => {
+    globalThis.fetch = (async () => {
+      return new Response(JSON.stringify({
+        ok: true,
+        team_id: 'T_TEAM',
+        team: 'MyTeam',
+        user_id: 'U_BOT',
+        user: 'mybot',
+      }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      });
+    }) as typeof globalThis.fetch;
+
+    const result = await setSlackChannelConfig('xoxb-valid-bot-token');
+    expect(result.success).toBe(true);
+    expect(result.hasBotToken).toBe(true);
+    expect(result.teamId).toBe('T_TEAM');
+    expect(result.teamName).toBe('MyTeam');
+  });
+
+  test('POST returns error when Slack auth.test rejects bot token', async () => {
+    globalThis.fetch = (async () => {
+      return new Response(JSON.stringify({
+        ok: false,
+        error: 'invalid_auth',
+      }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      });
+    }) as typeof globalThis.fetch;
+
+    const result = await setSlackChannelConfig('xoxb-bad-token');
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('invalid_auth');
+  });
+
+  test('DELETE clears credentials', () => {
+    secureKeyStore['credential:slack_channel:bot_token'] = 'xoxb-test';
+    secureKeyStore['credential:slack_channel:app_token'] = 'xapp-test';
+    credentialMetadataStore.push({ service: 'slack_channel', field: 'bot_token' });
+    credentialMetadataStore.push({ service: 'slack_channel', field: 'app_token' });
+
+    const result = clearSlackChannelConfig();
+    expect(result.success).toBe(true);
+    expect(result.hasBotToken).toBe(false);
+    expect(result.hasAppToken).toBe(false);
+    expect(result.connected).toBe(false);
+
+    expect(secureKeyStore['credential:slack_channel:bot_token']).toBeUndefined();
+    expect(secureKeyStore['credential:slack_channel:app_token']).toBeUndefined();
+    expect(credentialMetadataStore).toHaveLength(0);
+  });
+});

package/src/__tests__/subagent-manager-notify.test.ts

@@ -393,13 +393,13 @@ describe('SubagentManager abort race guard', () => {
 });
 
 describe('SubagentManager sendMessage validation', () => {
-  test('rejects empty content without throwing', () => {
+  test('rejects empty content without throwing', async () => {
     const manager = new SubagentManager();
     const subagentId = 'sub-1';
     injectFakeSubagent(manager, subagentId, makeState(subagentId));
 
-    expect(manager.sendMessage(subagentId, '')).toBe('empty');
-    expect(manager.sendMessage(subagentId, '   ')).toBe('empty');
-    expect(manager.sendMessage(subagentId, '\n\t')).toBe('empty');
+    expect(await manager.sendMessage(subagentId, '')).toBe('empty');
+    expect(await manager.sendMessage(subagentId, '   ')).toBe('empty');
+    expect(await manager.sendMessage(subagentId, '\n\t')).toBe('empty');
   });
 });