vellum 0.2.1 → 0.2.2

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

@@ -3,8 +3,10 @@ import type { Message } from '../providers/types.js';
 import {
   applyRuntimeInjections,
   injectChannelCapabilityContext,
+  injectTemporalContext,
   resolveChannelCapabilities,
   stripChannelCapabilityContext,
+  stripTemporalContext,
 } from '../daemon/session-runtime-assembly.js';
 import type { ChannelCapabilities } from '../daemon/session-runtime-assembly.js';
 import { buildChannelAwarenessSection } from '../config/system-prompt.js';
@@ -313,3 +315,162 @@ describe('trust-gating via channel capabilities', () => {
     expect(injected).toContain('desktop app');
   });
 });
+
+// ---------------------------------------------------------------------------
+// injectTemporalContext
+// ---------------------------------------------------------------------------
+
+describe('injectTemporalContext', () => {
+  const baseUserMessage: Message = {
+    role: 'user',
+    content: [{ type: 'text', text: 'Plan a trip for next weekend' }],
+  };
+
+  const sampleContext = '<temporal_context>\nToday: 2026-02-18 (Wednesday)\nTimezone: UTC\n</temporal_context>';
+
+  test('prepends temporal context block to user message', () => {
+    const result = injectTemporalContext(baseUserMessage, sampleContext);
+    expect(result.content.length).toBe(2);
+    const injected = result.content[0];
+    expect(injected.type).toBe('text');
+    expect((injected as { type: 'text'; text: string }).text).toContain('<temporal_context>');
+    expect((injected as { type: 'text'; text: string }).text).toContain('2026-02-18');
+  });
+
+  test('preserves original message content', () => {
+    const result = injectTemporalContext(baseUserMessage, sampleContext);
+    const lastBlock = result.content[result.content.length - 1];
+    expect((lastBlock as { type: 'text'; text: string }).text).toBe('Plan a trip for next weekend');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// stripTemporalContext
+// ---------------------------------------------------------------------------
+
+describe('stripTemporalContext', () => {
+  test('strips temporal_context blocks from user messages', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: '<temporal_context>\nToday: 2026-02-18\n</temporal_context>' },
+          { type: 'text', text: 'Hello' },
+        ],
+      },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hi there' }],
+      },
+    ];
+
+    const result = stripTemporalContext(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');
+    // Assistant message untouched
+    expect(result[1].content.length).toBe(1);
+  });
+
+  test('removes user messages that only contain temporal_context', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: '<temporal_context>\nToday: 2026-02-18\n</temporal_context>' },
+        ],
+      },
+    ];
+
+    const result = stripTemporalContext(messages);
+    expect(result.length).toBe(0);
+  });
+
+  test('does not touch unrelated blocks', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: '<channel_capabilities>\nchannel: dashboard\n</channel_capabilities>' },
+          { type: 'text', text: 'Hello' },
+        ],
+      },
+    ];
+
+    const result = stripTemporalContext(messages);
+    expect(result.length).toBe(1);
+    expect(result[0]).toBe(messages[0]); // Same reference — untouched
+  });
+
+  test('leaves messages without temporal_context untouched', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [{ type: 'text', text: 'Normal message' }],
+      },
+    ];
+
+    const result = stripTemporalContext(messages);
+    expect(result.length).toBe(1);
+    expect(result[0]).toBe(messages[0]);
+  });
+
+  test('preserves user-authored text that starts with <temporal_context> but not the injected prefix', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: '<temporal_context>some user XML content</temporal_context>' },
+          { type: 'text', text: 'Hello' },
+        ],
+      },
+    ];
+
+    const result = stripTemporalContext(messages);
+    expect(result.length).toBe(1);
+    expect(result[0]).toBe(messages[0]); // Same reference — untouched
+  });
+});
+
+// ---------------------------------------------------------------------------
+// applyRuntimeInjections with temporalContext
+// ---------------------------------------------------------------------------
+
+describe('applyRuntimeInjections with temporalContext', () => {
+  const baseMessages: Message[] = [
+    {
+      role: 'user',
+      content: [{ type: 'text', text: 'When is next weekend?' }],
+    },
+  ];
+
+  const sampleContext = '<temporal_context>\nToday: 2026-02-18 (Wednesday)\n</temporal_context>';
+
+  test('injects temporal context when provided', () => {
+    const result = applyRuntimeInjections(baseMessages, {
+      temporalContext: sampleContext,
+    });
+
+    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('<temporal_context>');
+  });
+
+  test('does not inject when temporalContext is null', () => {
+    const result = applyRuntimeInjections(baseMessages, {
+      temporalContext: null,
+    });
+
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+  });
+
+  test('does not inject when temporalContext is omitted', () => {
+    const result = applyRuntimeInjections(baseMessages, {});
+
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+  });
+});

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

@@ -0,0 +1,104 @@
+import { describe, expect, test } from 'bun:test';
+import type {
+  CardSurfaceData,
+  ServerMessage,
+  SurfaceData,
+  SurfaceType,
+  UiSurfaceShow,
+  UiSurfaceUpdate,
+} from '../daemon/ipc-protocol.js';
+import {
+  surfaceProxyResolver,
+  type SurfaceSessionContext,
+} from '../daemon/session-surfaces.js';
+
+function makeContext(sent: ServerMessage[] = []): SurfaceSessionContext {
+  return {
+    conversationId: 'session-1',
+    traceEmitter: { emit: () => {} },
+    sendToClient: (msg) => sent.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<string, { actionId: string; data?: Record<string, unknown> }>(),
+    surfaceState: new Map<string, { surfaceType: SurfaceType; data: SurfaceData }>(),
+    surfaceUndoStacks: new Map<string, string[]>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: 'req-1' }),
+    getQueueDepth: () => 0,
+    processMessage: async () => 'ok',
+  };
+}
+
+describe('task_progress surface compatibility', () => {
+  test('ui_show maps legacy top-level task_progress fields into card data', async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, 'ui_show', {
+      surface_type: 'card',
+      title: 'Ordering from DoorDash',
+      data: {},
+      template: 'task_progress',
+      templateData: {
+        status: 'in_progress',
+        steps: [
+          { label: 'Search restaurants', status: 'in_progress' },
+          { label: 'Browse menu', status: 'pending' },
+        ],
+      },
+    });
+
+    expect(result.isError).toBe(false);
+
+    const showMessage = sent.find((msg): msg is UiSurfaceShow => msg.type === 'ui_surface_show');
+    expect(showMessage).toBeDefined();
+    if (!showMessage || showMessage.surfaceType !== 'card') return;
+
+    const card = showMessage.data as CardSurfaceData;
+    expect(card.template).toBe('task_progress');
+    expect(card.title).toBe('Ordering from DoorDash');
+    expect(card.body).toBe('');
+    expect((card.templateData as Record<string, unknown>).status).toBe('in_progress');
+  });
+
+  test('ui_update normalizes top-level task_progress fields into templateData', async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+    const existingCard: CardSurfaceData = {
+      title: 'Ordering from DoorDash',
+      body: '',
+      template: 'task_progress',
+      templateData: {
+        title: 'Ordering from DoorDash',
+        status: 'in_progress',
+        steps: [
+          { label: 'Search restaurants', status: 'completed' },
+          { label: 'Browse menu', status: 'in_progress' },
+          { label: 'Add to cart', status: 'pending' },
+        ],
+      },
+    };
+
+    ctx.surfaceState.set('surface-1', { surfaceType: 'card', data: existingCard });
+
+    const result = await surfaceProxyResolver(ctx, 'ui_update', {
+      surface_id: 'surface-1',
+      data: {
+        status: 'completed',
+      },
+    });
+
+    expect(result.isError).toBe(false);
+
+    const updateMessage = sent.find((msg): msg is UiSurfaceUpdate => msg.type === 'ui_surface_update');
+    expect(updateMessage).toBeDefined();
+    if (!updateMessage) return;
+
+    const updatedCard = updateMessage.data as CardSurfaceData & Record<string, unknown>;
+    expect(updatedCard.template).toBe('task_progress');
+    expect('status' in updatedCard).toBe(false);
+    const templateData = updatedCard.templateData as Record<string, unknown>;
+    expect(templateData.status).toBe('completed');
+    expect(Array.isArray(templateData.steps)).toBe(true);
+  });
+});

package/src/__tests__/signup-e2e.test.ts

@@ -48,7 +48,7 @@ const STORE_PATH = join(testDir, 'keys.enc');
 // ── Imports (after mocks) ───────────────────────────────────────────
 
 import { createMockSignupServer, type MockSignupServer } from './fixtures/mock-signup-server.js';
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import {
   createAccount,
   listAccounts,
@@ -97,6 +97,7 @@ beforeAll(async () => {
 });
 
 afterAll(async () => {
+  resetDb();
   await executeBrowserClose({ close_all_pages: true }, ctx);
   await server.stop();
   _setMetadataPath(null);

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

@@ -0,0 +1,328 @@
+/**
+ * Skill Projection Benchmark
+ *
+ * Measures projectSkillTools() latency across conversation sizes and caching scenarios.
+ *
+ * Baseline targets:
+ * - Cold projection (100 msgs / 3 skills): < 50ms
+ * - Cached projection (no change):         < 10ms
+ * - Cold projection (1000 msgs / 5 skills): < 100ms
+ * - Incremental scan (10 new msgs):         < 20ms
+ */
+import { describe, test, expect, mock } from 'bun:test';
+import type { Message } from '../providers/types.js';
+
+// ---------------------------------------------------------------------------
+// Mocks — must be registered before importing the module under test
+// ---------------------------------------------------------------------------
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+// Skill catalog: returns a configurable list of fake skills
+let catalogSkillIds: string[] = [];
+mock.module('../config/skills.js', () => ({
+  loadSkillCatalog: () =>
+    catalogSkillIds.map((id) => ({
+      id,
+      name: id,
+      description: `Mock skill ${id}`,
+      directoryPath: `/tmp/fake-skills/${id}`,
+      skillFilePath: `/tmp/fake-skills/${id}/SKILL.md`,
+      bundled: false,
+      userInvocable: false,
+    })),
+}));
+
+mock.module('../skills/tool-manifest.js', () => ({
+  parseToolManifestFile: (path: string) => {
+    // Extract skill id from the path /tmp/fake-skills/<id>/TOOLS.json
+    const parts = path.split('/');
+    const skillId = parts[parts.length - 2];
+    return {
+      version: 1,
+      tools: [
+        {
+          name: `${skillId}_tool_a`,
+          description: `Tool A for ${skillId}`,
+          input_schema: { type: 'object', properties: {} },
+        },
+        {
+          name: `${skillId}_tool_b`,
+          description: `Tool B for ${skillId}`,
+          input_schema: { type: 'object', properties: {} },
+        },
+      ],
+    };
+  },
+}));
+
+mock.module('../skills/version-hash.js', () => ({
+  computeSkillVersionHash: () => 'v1:deadbeef',
+}));
+
+// Mock createSkillToolsFromManifest to return lightweight Tool-like objects
+mock.module('../tools/skills/skill-tool-factory.js', () => ({
+  createSkillToolsFromManifest: (
+    entries: Array<{ name: string; description: string; input_schema: object }>,
+    skillId: string,
+    _skillDir: string,
+    versionHash: string,
+    bundled?: boolean,
+  ) =>
+    entries.map((e) => ({
+      name: e.name,
+      description: e.description,
+      category: 'skill',
+      defaultRiskLevel: 'low',
+      origin: 'skill' as const,
+      ownerSkillId: skillId,
+      ownerSkillVersionHash: versionHash,
+      ownerSkillBundled: bundled,
+      getDefinition: () => ({
+        name: e.name,
+        description: e.description,
+        input_schema: e.input_schema,
+      }),
+      execute: async () => ({ content: '', isError: false }),
+    })),
+}));
+
+// existsSync mock — TOOLS.json always exists for fake skills
+mock.module('node:fs', () => ({
+  existsSync: () => true,
+}));
+
+mock.module('../tools/registry.js', () => ({
+  registerSkillTools: () => {},
+  unregisterSkillTools: () => {},
+  getTool: () => undefined,
+}));
+
+// ---------------------------------------------------------------------------
+// Import module under test (after mocks)
+// ---------------------------------------------------------------------------
+
+const { projectSkillTools } = await import('../daemon/session-skill-tools.js');
+type SkillProjectionCache = import('../daemon/session-skill-tools.js').SkillProjectionCache;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a synthetic conversation history with interleaved user/assistant
+ * messages and skill_load tool-use markers for the given skill IDs.
+ *
+ * Skill activations are spread evenly across the history.
+ */
+function buildHistory(messageCount: number, skillIds: string[]): Message[] {
+  const msgs: Message[] = [];
+  const activationInterval = Math.max(1, Math.floor(messageCount / skillIds.length));
+
+  for (let i = 0; i < messageCount; i++) {
+    // Every other message is user/assistant
+    if (i % 2 === 0) {
+      msgs.push({
+        role: 'user',
+        content: [
+          { type: 'text', text: `User message ${i} about project tasks.` },
+        ],
+      });
+    } else {
+      const blocks: Message['content'] = [
+        { type: 'text', text: `Assistant response ${i} with analysis.` },
+      ];
+
+      // Inject a skill_load tool_use at the activation point
+      const skillIndex = Math.floor(i / activationInterval);
+      if (skillIndex < skillIds.length) {
+        const skillId = skillIds[skillIndex];
+        const toolUseId = `tu-${skillId}-${i}`;
+        blocks.push({
+          type: 'tool_use',
+          id: toolUseId,
+          name: 'skill_load',
+          input: { skill_id: skillId },
+        });
+      }
+
+      msgs.push({ role: 'assistant', content: blocks });
+    }
+  }
+
+  // Add matching tool_result messages for each skill_load tool_use
+  for (const msg of [...msgs]) {
+    for (const block of msg.content) {
+      if (block.type === 'tool_use' && block.name === 'skill_load') {
+        const skillId = (block.input as Record<string, string>).skill_id;
+        msgs.push({
+          role: 'user',
+          content: [
+            {
+              type: 'tool_result',
+              tool_use_id: block.id,
+              content: `<loaded_skill id="${skillId}" version="v1:deadbeef" />`,
+            },
+          ],
+        });
+      }
+    }
+  }
+
+  return msgs;
+}
+
+function timeMs(fn: () => void): number {
+  const start = performance.now();
+  fn();
+  return performance.now() - start;
+}
+
+// ---------------------------------------------------------------------------
+// Benchmarks
+// ---------------------------------------------------------------------------
+
+describe('Skill projection benchmark', () => {
+  test('cold projection: 100 messages / 3 skills < 50ms', () => {
+    const skillIds = ['skill-alpha', 'skill-beta', 'skill-gamma'];
+    catalogSkillIds = skillIds;
+    const history = buildHistory(100, skillIds);
+
+    const elapsed = timeMs(() => {
+      const result = projectSkillTools(history);
+      expect(result.toolDefinitions.length).toBeGreaterThan(0);
+      expect(result.allowedToolNames.size).toBeGreaterThan(0);
+    });
+
+    console.log(`  Cold projection (100 msgs / 3 skills): ${elapsed.toFixed(2)}ms`);
+    expect(elapsed).toBeLessThan(50);
+  });
+
+  test('cached projection (no change) < 10ms', () => {
+    const skillIds = ['skill-alpha', 'skill-beta', 'skill-gamma'];
+    catalogSkillIds = skillIds;
+    const history = buildHistory(100, skillIds);
+    const cache: SkillProjectionCache = {};
+    const prevActive = new Map<string, string>();
+
+    // Warm the cache
+    const warmResult = projectSkillTools(history, { cache, previouslyActiveSkillIds: prevActive });
+
+    // Snapshot cache object references after warm-up
+    const derivedAfterWarm = cache.derived!;
+    const entriesAfterWarm = cache.derived!.entries;
+    const seenIdsAfterWarm = cache.derived!.seenIds;
+
+    // Second call with identical history — should hit cache fast path
+    let cachedResult: ReturnType<typeof projectSkillTools> | undefined;
+    const elapsed = timeMs(() => {
+      cachedResult = projectSkillTools(history, {
+        cache,
+        previouslyActiveSkillIds: prevActive,
+      });
+    });
+
+    // Assert cache was populated and covers all messages
+    expect(cache.derived).toBeDefined();
+    expect(cache.derived!.messageCount).toBe(history.length);
+
+    // Assert the cache object is reused (same reference, not rebuilt)
+    expect(cache.derived).toBe(derivedAfterWarm);
+    expect(cache.derived!.entries).toBe(entriesAfterWarm);
+    expect(cache.derived!.seenIds).toBe(seenIdsAfterWarm);
+
+    // Assert tool definitions are identical between warm and cached calls
+    expect(cachedResult!.toolDefinitions.length).toBe(warmResult.toolDefinitions.length);
+    const warmNames = warmResult.toolDefinitions.map((t) => t.name).sort();
+    const cachedNames = cachedResult!.toolDefinitions.map((t) => t.name).sort();
+    expect(cachedNames).toEqual(warmNames);
+
+    console.log(`  Cached projection (no change): ${elapsed.toFixed(2)}ms`);
+    expect(elapsed).toBeLessThan(10);
+  });
+
+  test('cache hit rate is 100% when history unchanged', () => {
+    const skillIds = ['skill-alpha', 'skill-beta', 'skill-gamma'];
+    catalogSkillIds = skillIds;
+    const history = buildHistory(100, skillIds);
+    const cache: SkillProjectionCache = {};
+    const prevActive = new Map<string, string>();
+
+    // First call populates the cache
+    const firstResult = projectSkillTools(history, { cache, previouslyActiveSkillIds: prevActive });
+    expect(cache.derived).toBeDefined();
+    const snapshotDerived = cache.derived!;
+    const snapshotEntries = cache.derived!.entries;
+    const snapshotSeenIds = cache.derived!.seenIds;
+
+    // Run multiple subsequent calls with unchanged history
+    for (let i = 0; i < 5; i++) {
+      const result = projectSkillTools(history, { cache, previouslyActiveSkillIds: prevActive });
+
+      // Cache objects must be the same references (reused, not rebuilt)
+      expect(cache.derived).toBe(snapshotDerived);
+      expect(cache.derived!.entries).toBe(snapshotEntries);
+      expect(cache.derived!.seenIds).toBe(snapshotSeenIds);
+
+      // Tool definitions must match the first call exactly
+      expect(result.toolDefinitions.length).toBe(firstResult.toolDefinitions.length);
+      expect(result.toolDefinitions.map((t) => t.name).sort()).toEqual(
+        firstResult.toolDefinitions.map((t) => t.name).sort(),
+      );
+    }
+  });
+
+  test('cold projection: 1000 messages / 5 skills < 100ms', () => {
+    const skillIds = [
+      'skill-alpha',
+      'skill-beta',
+      'skill-gamma',
+      'skill-delta',
+      'skill-epsilon',
+    ];
+    catalogSkillIds = skillIds;
+    const history = buildHistory(1000, skillIds);
+
+    const elapsed = timeMs(() => {
+      const result = projectSkillTools(history);
+      expect(result.toolDefinitions.length).toBeGreaterThan(0);
+      expect(result.allowedToolNames.size).toBeGreaterThan(0);
+    });
+
+    console.log(`  Cold projection (1000 msgs / 5 skills): ${elapsed.toFixed(2)}ms`);
+    expect(elapsed).toBeLessThan(100);
+  });
+
+  test('incremental scan (10 new messages appended) < 20ms', () => {
+    const skillIds = ['skill-alpha', 'skill-beta', 'skill-gamma'];
+    catalogSkillIds = skillIds;
+    const history = buildHistory(100, skillIds);
+    const cache: SkillProjectionCache = {};
+    const prevActive = new Map<string, string>();
+
+    // Warm the cache
+    projectSkillTools(history, { cache, previouslyActiveSkillIds: prevActive });
+
+    // Append 10 new plain messages (no new skill activations)
+    for (let i = 0; i < 10; i++) {
+      history.push({
+        role: i % 2 === 0 ? 'user' : 'assistant',
+        content: [{ type: 'text', text: `Follow-up message ${i}.` }],
+      });
+    }
+
+    const elapsed = timeMs(() => {
+      const result = projectSkillTools(history, {
+        cache,
+        previouslyActiveSkillIds: prevActive,
+      });
+      expect(result.toolDefinitions.length).toBeGreaterThan(0);
+    });
+
+    console.log(`  Incremental scan (10 new msgs): ${elapsed.toFixed(2)}ms`);
+    expect(elapsed).toBeLessThan(20);
+  });
+});