@vellumai/assistant 0.3.4 → 0.3.6

package/src/__tests__/session-conflict-gate.test.ts

@@ -62,6 +62,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

package/src/__tests__/session-pre-run-repair.test.ts

@@ -13,6 +13,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

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

@@ -22,6 +22,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

package/src/__tests__/session-provider-retry-repair.test.ts

@@ -12,6 +12,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

package/src/__tests__/session-queue.test.ts

@@ -25,6 +25,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

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

@@ -2,13 +2,18 @@ import { describe, test, expect } from 'bun:test';
 import type { Message } from '../providers/types.js';
 import {
   applyRuntimeInjections,
+  buildChannelTurnContextBlock,
   injectChannelCapabilityContext,
+  injectChannelTurnContext,
+  injectGuardianContext,
   injectTemporalContext,
   resolveChannelCapabilities,
   stripChannelCapabilityContext,
+  stripChannelTurnContext,
+  stripGuardianContext,
   stripTemporalContext,
 } from '../daemon/session-runtime-assembly.js';
-import type { ChannelCapabilities } from '../daemon/session-runtime-assembly.js';
+import type { ChannelCapabilities, ChannelTurnContextParams, GuardianRuntimeContext } from '../daemon/session-runtime-assembly.js';
 import { buildChannelAwarenessSection } from '../config/system-prompt.js';
 
 // ---------------------------------------------------------------------------
@@ -16,28 +21,42 @@ import { buildChannelAwarenessSection } from '../config/system-prompt.js';
 // ---------------------------------------------------------------------------
 
 describe('resolveChannelCapabilities', () => {
-  test('defaults to dashboard when no source channel is provided', () => {
+  test('defaults to macos when no source channel is provided', () => {
     const caps = resolveChannelCapabilities();
-    expect(caps.channel).toBe('dashboard');
+    expect(caps.channel).toBe('macos');
     expect(caps.dashboardCapable).toBe(true);
     expect(caps.supportsDynamicUi).toBe(true);
     expect(caps.supportsVoiceInput).toBe(true);
   });
 
-  test('defaults to dashboard for null source channel', () => {
+  test('defaults to macos for null source channel', () => {
     const caps = resolveChannelCapabilities(null);
-    expect(caps.channel).toBe('dashboard');
+    expect(caps.channel).toBe('macos');
     expect(caps.dashboardCapable).toBe(true);
   });
 
-  test('resolves "dashboard" as dashboard-capable', () => {
+  test('normalises "dashboard" to "macos"', () => {
     const caps = resolveChannelCapabilities('dashboard');
-    expect(caps.channel).toBe('dashboard');
+    expect(caps.channel).toBe('macos');
     expect(caps.dashboardCapable).toBe(true);
     expect(caps.supportsDynamicUi).toBe(true);
     expect(caps.supportsVoiceInput).toBe(true);
   });
 
+  test('normalises "http-api" to "macos"', () => {
+    const caps = resolveChannelCapabilities('http-api');
+    expect(caps.channel).toBe('macos');
+    expect(caps.dashboardCapable).toBe(true);
+    expect(caps.supportsDynamicUi).toBe(true);
+    expect(caps.supportsVoiceInput).toBe(true);
+  });
+
+  test('normalises "mac" to "macos"', () => {
+    const caps = resolveChannelCapabilities('mac');
+    expect(caps.channel).toBe('macos');
+    expect(caps.dashboardCapable).toBe(true);
+  });
+
   test('resolves "telegram" as non-dashboard-capable', () => {
     const caps = resolveChannelCapabilities('telegram');
     expect(caps.channel).toBe('telegram');
@@ -46,9 +65,41 @@ describe('resolveChannelCapabilities', () => {
     expect(caps.supportsVoiceInput).toBe(false);
   });
 
-  test('resolves "http-api" as non-dashboard-capable', () => {
-    const caps = resolveChannelCapabilities('http-api');
-    expect(caps.channel).toBe('http-api');
+  test('resolves "ios" with voice but no dashboard/dynamic-ui', () => {
+    const caps = resolveChannelCapabilities('ios');
+    expect(caps.channel).toBe('ios');
+    expect(caps.dashboardCapable).toBe(false);
+    expect(caps.supportsDynamicUi).toBe(false);
+    expect(caps.supportsVoiceInput).toBe(true);
+  });
+
+  test('resolves "whatsapp" as all-capabilities-false', () => {
+    const caps = resolveChannelCapabilities('whatsapp');
+    expect(caps.channel).toBe('whatsapp');
+    expect(caps.dashboardCapable).toBe(false);
+    expect(caps.supportsDynamicUi).toBe(false);
+    expect(caps.supportsVoiceInput).toBe(false);
+  });
+
+  test('resolves "slack" as all-capabilities-false', () => {
+    const caps = resolveChannelCapabilities('slack');
+    expect(caps.channel).toBe('slack');
+    expect(caps.dashboardCapable).toBe(false);
+    expect(caps.supportsDynamicUi).toBe(false);
+    expect(caps.supportsVoiceInput).toBe(false);
+  });
+
+  test('resolves "email" as all-capabilities-false', () => {
+    const caps = resolveChannelCapabilities('email');
+    expect(caps.channel).toBe('email');
+    expect(caps.dashboardCapable).toBe(false);
+    expect(caps.supportsDynamicUi).toBe(false);
+    expect(caps.supportsVoiceInput).toBe(false);
+  });
+
+  test('unknown channel defaults to all-capabilities-false', () => {
+    const caps = resolveChannelCapabilities('unknown-thing');
+    expect(caps.channel).toBe('unknown-thing');
     expect(caps.dashboardCapable).toBe(false);
     expect(caps.supportsDynamicUi).toBe(false);
     expect(caps.supportsVoiceInput).toBe(false);
@@ -67,7 +118,7 @@ describe('injectChannelCapabilityContext', () => {
 
   test('injects channel capabilities block for dashboard channel', () => {
     const caps: ChannelCapabilities = {
-      channel: 'dashboard',
+      channel: 'macos',
       dashboardCapable: true,
       supportsDynamicUi: true,
       supportsVoiceInput: true,
@@ -277,6 +328,12 @@ describe('buildChannelAwarenessSection', () => {
     const section = buildChannelAwarenessSection();
     expect(section).toContain('computer-control permissions on non-dashboard');
   });
+
+  test('includes guardian context contract for channel actors', () => {
+    const section = buildChannelAwarenessSection();
+    expect(section).toContain('<guardian_context>');
+    expect(section).toContain('Never infer guardian status');
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -284,8 +341,8 @@ describe('buildChannelAwarenessSection', () => {
 // ---------------------------------------------------------------------------
 
 describe('trust-gating via channel capabilities', () => {
-  test('dashboard channel does not add constraint rules', () => {
-    const caps = resolveChannelCapabilities('dashboard');
+  test('macos channel does not add constraint rules', () => {
+    const caps = resolveChannelCapabilities('macos');
     const message: Message = {
       role: 'user',
       content: [{ type: 'text', text: 'Enable my microphone' }],
@@ -474,3 +531,254 @@ describe('applyRuntimeInjections with temporalContext', () => {
     expect(result[0].content.length).toBe(1);
   });
 });
+
+// ---------------------------------------------------------------------------
+// guardian_context
+// ---------------------------------------------------------------------------
+
+describe('injectGuardianContext', () => {
+  const baseUserMessage: Message = {
+    role: 'user',
+    content: [{ type: 'text', text: 'Can you text me updates?' }],
+  };
+
+  test('prepends guardian_context block to user message', () => {
+    const ctx: GuardianRuntimeContext = {
+      sourceChannel: 'sms',
+      actorRole: 'guardian',
+      guardianExternalUserId: 'guardian-user-1',
+      guardianChatId: '+15550001111',
+      requesterIdentifier: '+15550001111',
+      requesterExternalUserId: 'guardian-user-1',
+      requesterChatId: '+15550001111',
+    };
+
+    const result = injectGuardianContext(baseUserMessage, ctx);
+    expect(result.content.length).toBe(2);
+    const injected = result.content[0];
+    expect(injected.type).toBe('text');
+    const text = (injected as { type: 'text'; text: string }).text;
+    expect(text).toContain('<guardian_context>');
+    expect(text).toContain('actor_role: guardian');
+    expect(text).toContain('source_channel: sms');
+    expect(text).toContain('</guardian_context>');
+  });
+});
+
+describe('stripGuardianContext', () => {
+  test('strips guardian_context blocks from user messages', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: '<guardian_context>\nactor_role: guardian\n</guardian_context>' },
+          { type: 'text', text: 'Hello' },
+        ],
+      },
+    ];
+    const result = stripGuardianContext(messages);
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toHaveLength(1);
+    expect((result[0].content[0] as { type: 'text'; text: string }).text).toBe('Hello');
+  });
+});
+
+describe('applyRuntimeInjections with guardianContext', () => {
+  const baseMessages: Message[] = [
+    {
+      role: 'user',
+      content: [{ type: 'text', text: 'Help me send this over SMS.' }],
+    },
+  ];
+
+  test('injects guardian context when provided', () => {
+    const result = applyRuntimeInjections(baseMessages, {
+      guardianContext: {
+        sourceChannel: 'sms',
+        actorRole: 'non-guardian',
+        guardianExternalUserId: 'guardian-1',
+        requesterExternalUserId: 'requester-1',
+        requesterIdentifier: '+15550002222',
+        requesterChatId: '+15550002222',
+      },
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toHaveLength(2);
+    expect((result[0].content[0] as { type: 'text'; text: string }).text).toContain('<guardian_context>');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildChannelTurnContextBlock
+// ---------------------------------------------------------------------------
+
+describe('buildChannelTurnContextBlock', () => {
+  test('formats block with all three channel fields', () => {
+    const block = buildChannelTurnContextBlock({
+      turnContext: { userMessageChannel: 'telegram', assistantMessageChannel: 'telegram' },
+      conversationOriginChannel: 'telegram',
+    });
+    expect(block).toBe(
+      '<channel_turn_context>\n' +
+      'user_message_channel: telegram\n' +
+      'assistant_message_channel: telegram\n' +
+      'conversation_origin_channel: telegram\n' +
+      '</channel_turn_context>',
+    );
+  });
+
+  test('uses "unknown" when conversationOriginChannel is null', () => {
+    const block = buildChannelTurnContextBlock({
+      turnContext: { userMessageChannel: 'macos', assistantMessageChannel: 'macos' },
+      conversationOriginChannel: null,
+    });
+    expect(block).toContain('conversation_origin_channel: unknown');
+  });
+
+  test('handles mixed channels', () => {
+    const block = buildChannelTurnContextBlock({
+      turnContext: { userMessageChannel: 'telegram', assistantMessageChannel: 'macos' },
+      conversationOriginChannel: 'ios',
+    });
+    expect(block).toContain('user_message_channel: telegram');
+    expect(block).toContain('assistant_message_channel: macos');
+    expect(block).toContain('conversation_origin_channel: ios');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// injectChannelTurnContext
+// ---------------------------------------------------------------------------
+
+describe('injectChannelTurnContext', () => {
+  const baseUserMessage: Message = {
+    role: 'user',
+    content: [{ type: 'text', text: 'Hello from telegram' }],
+  };
+
+  test('prepends channel_turn_context block to user message', () => {
+    const params: ChannelTurnContextParams = {
+      turnContext: { userMessageChannel: 'telegram', assistantMessageChannel: 'telegram' },
+      conversationOriginChannel: 'telegram',
+    };
+    const result = injectChannelTurnContext(baseUserMessage, params);
+    expect(result.content.length).toBe(2);
+    const injected = result.content[0];
+    expect(injected.type).toBe('text');
+    const text = (injected as { type: 'text'; text: string }).text;
+    expect(text).toContain('<channel_turn_context>');
+    expect(text).toContain('user_message_channel: telegram');
+    expect(text).toContain('</channel_turn_context>');
+  });
+
+  test('preserves original message content', () => {
+    const params: ChannelTurnContextParams = {
+      turnContext: { userMessageChannel: 'macos', assistantMessageChannel: 'macos' },
+      conversationOriginChannel: 'macos',
+    };
+    const result = injectChannelTurnContext(baseUserMessage, params);
+    const lastBlock = result.content[result.content.length - 1];
+    expect((lastBlock as { type: 'text'; text: string }).text).toBe('Hello from telegram');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// stripChannelTurnContext
+// ---------------------------------------------------------------------------
+
+describe('stripChannelTurnContext', () => {
+  test('strips channel_turn_context blocks from user messages', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: '<channel_turn_context>\nuser_message_channel: telegram\n</channel_turn_context>' },
+          { type: 'text', text: 'Hello' },
+        ],
+      },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hi there' }],
+      },
+    ];
+
+    const result = stripChannelTurnContext(messages);
+
+    expect(result.length).toBe(2);
+    expect(result[0].content.length).toBe(1);
+    expect((result[0].content[0] as { type: 'text'; text: string }).text).toBe('Hello');
+    expect(result[1].content.length).toBe(1);
+  });
+
+  test('removes user messages that only contain channel_turn_context', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: '<channel_turn_context>\nuser_message_channel: macos\n</channel_turn_context>' },
+        ],
+      },
+    ];
+
+    const result = stripChannelTurnContext(messages);
+    expect(result.length).toBe(0);
+  });
+
+  test('leaves messages without channel_turn_context untouched', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [{ type: 'text', text: 'Normal message' }],
+      },
+    ];
+
+    const result = stripChannelTurnContext(messages);
+    expect(result.length).toBe(1);
+    expect(result[0]).toBe(messages[0]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// applyRuntimeInjections with channelTurnContext
+// ---------------------------------------------------------------------------
+
+describe('applyRuntimeInjections with channelTurnContext', () => {
+  const baseMessages: Message[] = [
+    {
+      role: 'user',
+      content: [{ type: 'text', text: 'What channel am I on?' }],
+    },
+  ];
+
+  test('injects channel turn context when provided', () => {
+    const params: ChannelTurnContextParams = {
+      turnContext: { userMessageChannel: 'telegram', assistantMessageChannel: 'telegram' },
+      conversationOriginChannel: 'telegram',
+    };
+
+    const result = applyRuntimeInjections(baseMessages, {
+      channelTurnContext: params,
+    });
+
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(2);
+    const injected = result[0].content[0];
+    expect((injected as { type: 'text'; text: string }).text).toContain('<channel_turn_context>');
+  });
+
+  test('does not inject when channelTurnContext is null', () => {
+    const result = applyRuntimeInjections(baseMessages, {
+      channelTurnContext: null,
+    });
+
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+  });
+
+  test('does not inject when channelTurnContext is omitted', () => {
+    const result = applyRuntimeInjections(baseMessages, {});
+
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+  });
+});

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

@@ -16,6 +16,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

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

@@ -16,6 +16,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

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

@@ -16,6 +16,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

package/src/__tests__/session-surfaces-task-progress.test.ts

@@ -9,6 +9,7 @@ import type {
 } from '../daemon/ipc-protocol.js';
 import {
   surfaceProxyResolver,
+  createSurfaceMutex,
   type SurfaceSessionContext,
 } from '../daemon/session-surfaces.js';
 
@@ -26,6 +27,7 @@ function makeContext(sent: ServerMessage[] = []): SurfaceSessionContext {
     enqueueMessage: () => ({ queued: false, requestId: 'req-1' }),
     getQueueDepth: () => 0,
     processMessage: async () => 'ok',
+    withSurface: createSurfaceMutex(),
   };
 }
 

package/src/__tests__/session-tool-setup-app-refresh.test.ts

@@ -68,6 +68,7 @@ function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
     enqueueMessage: () => ({ queued: false, requestId: 'r' }),
     getQueueDepth: () => 0,
     processMessage: async () => '',
+    withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
     memoryPolicy: { scopeId: 'default', strictSideEffects: false },
     ...overrides,
   };

package/src/__tests__/session-tool-setup-memory-scope.test.ts

@@ -55,6 +55,7 @@ function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
     enqueueMessage: () => ({ queued: false, requestId: 'r' }),
     getQueueDepth: () => 0,
     processMessage: async () => '',
+    withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
     memoryPolicy: { scopeId: 'default', strictSideEffects: false },
     ...overrides,
   };

package/src/__tests__/session-tool-setup-side-effect-flag.test.ts

@@ -55,6 +55,7 @@ function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
     enqueueMessage: () => ({ queued: false, requestId: 'r' }),
     getQueueDepth: () => 0,
     processMessage: async () => '',
+    withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
     memoryPolicy: { scopeId: 'default', strictSideEffects: false },
     ...overrides,
   };

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

@@ -23,6 +23,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

package/src/__tests__/session-workspace-tool-tracking.test.ts

@@ -22,6 +22,12 @@ mock.module('../util/platform.js', () => ({
   getDataDir: () => '/tmp',
 }));
 
+mock.module('../memory/guardian-action-store.js', () => ({
+  getPendingDeliveryByConversation: () => null,
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
 mock.module('../providers/registry.js', () => ({
   getProvider: () => ({ name: 'mock-provider' }),
   initializeProviders: () => {},

package/src/__tests__/skills.test.ts

@@ -29,6 +29,8 @@ mock.module('../util/logger.js', () => ({
   getLogger: () => new Proxy({} as Record<string, unknown>, {
     get: () => () => {},
   }),
+  isDebug: () => false,
+  truncateForLog: (v: string) => v,
 }));
 
 const { loadSkillCatalog, loadSkillBySelector, resolveSkillSelector } = await import('../config/skills.js');