vellum 0.2.0 → 0.2.1

package/src/__tests__/run-orchestrator-assistant-events.test.ts

@@ -0,0 +1,218 @@
+/**
+ * Tests that HTTP-triggered run/session flows mirror messages into the
+ * assistant-events hub with payload parity to IPC outbound messages.
+ *
+ * The Session class has two distinct outbound paths:
+ *   1. updateClient handler — used by the prompter for confirmation_request,
+ *      trace emitter, secret prompter.
+ *   2. runAgentLoop onEvent callback — used for the primary streaming events:
+ *      assistant_text_delta, message_complete, tool_use_start, tool_result, etc.
+ *
+ * Both paths must publish to the hub.
+ *
+ * Tests:
+ *   - confirmation_request (updateClient path) → hub emits one AssistantEvent
+ *   - assistant_text_delta + message_complete (onEvent path) → hub emits in order
+ *   - sessionId falls back to conversationId when the message lacks it
+ */
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { ServerMessage } from '../daemon/ipc-protocol.js';
+import type { Session } from '../daemon/session.js';
+import type { AssistantEvent } from '../runtime/assistant-event.js';
+
+const testDir = mkdtempSync(join(tmpdir(), 'run-orch-hub-test-'));
+
+mock.module('../util/platform.js', () => ({
+  getRootDir: () => testDir,
+  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 { initializeDb, getDb } from '../memory/db.js';
+import { createConversation } from '../memory/conversation-store.js';
+import { RunOrchestrator } from '../runtime/run-orchestrator.js';
+import { assistantEventHub } from '../runtime/assistant-event-hub.js';
+
+initializeDb();
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Build a session that calls the updateClient handler with the given messages
+ * (simulates prompter / confirmation path).
+ */
+function makeSessionEmittingViaClient(...messages: ServerMessage[]): Session {
+  let clientHandler: (msg: ServerMessage) => void = () => {};
+  return {
+    isProcessing: () => false,
+    persistUserMessage: () => undefined as unknown as string,
+    setAssistantId: () => {},
+    updateClient: (handler: (msg: ServerMessage) => void) => {
+      clientHandler = handler;
+    },
+    runAgentLoop: async () => {
+      for (const msg of messages) {
+        clientHandler(msg);
+      }
+    },
+    handleConfirmationResponse: () => {},
+  } as unknown as Session;
+}
+
+/**
+ * Build a session that calls the onEvent callback with the given messages
+ * (simulates the primary agent-loop streaming path).
+ */
+function makeSessionEmittingViaAgentLoop(...messages: ServerMessage[]): Session {
+  return {
+    isProcessing: () => false,
+    persistUserMessage: () => undefined as unknown as string,
+    setAssistantId: () => {},
+    updateClient: () => {},
+    runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
+      for (const msg of messages) {
+        onEvent(msg);
+      }
+    },
+    handleConfirmationResponse: () => {},
+  } as unknown as Session;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('HTTP run → confirmation_request mirrors to assistant-events hub', () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM message_runs');
+    db.run('DELETE FROM messages');
+    db.run('DELETE FROM conversations');
+  });
+
+  test('confirmation_request (updateClient path) emits one AssistantEvent', async () => {
+    const conversation = createConversation('http-confirmation-test');
+    const confirmationMsg: ServerMessage = {
+      type: 'confirmation_request',
+      requestId: 'req-http-1',
+      toolName: 'bash',
+      input: { command: 'ls' },
+      riskLevel: 'medium',
+      allowlistOptions: [{ label: 'ls', description: 'List files', pattern: 'ls' }],
+      scopeOptions: [{ label: 'everywhere', scope: 'everywhere' }],
+    };
+    const session = makeSessionEmittingViaClient(confirmationMsg);
+
+    const received: AssistantEvent[] = [];
+    const sub = assistantEventHub.subscribe(
+      { assistantId: 'self' },
+      (e) => { received.push(e); },
+    );
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+    });
+
+    await orchestrator.startRun(conversation.id, 'Do something');
+    // Wait for the async hub chain to flush.
+    await new Promise((r) => setTimeout(r, 20));
+
+    sub.dispose();
+
+    expect(received).toHaveLength(1);
+    expect(received[0].assistantId).toBe('self');
+    expect(received[0].sessionId).toBe(conversation.id);
+    expect(received[0].message.type).toBe('confirmation_request');
+    expect(received[0].message).toBe(confirmationMsg);
+  });
+});
+
+describe('HTTP run → message flow mirrors to assistant-events hub', () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM message_runs');
+    db.run('DELETE FROM messages');
+    db.run('DELETE FROM conversations');
+  });
+
+  test('assistant_text_delta and message_complete (onEvent path) emit in order', async () => {
+    const conversation = createConversation('http-message-flow-test');
+    const deltaMsg: ServerMessage = {
+      type: 'assistant_text_delta',
+      sessionId: conversation.id,
+      text: 'Working on it...',
+    };
+    const completeMsg: ServerMessage = {
+      type: 'message_complete',
+      sessionId: conversation.id,
+    };
+    const session = makeSessionEmittingViaAgentLoop(deltaMsg, completeMsg);
+
+    const received: AssistantEvent[] = [];
+    const sub = assistantEventHub.subscribe(
+      { assistantId: 'self' },
+      (e) => { received.push(e); },
+    );
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+    });
+
+    await orchestrator.startRun(conversation.id, 'Hello');
+    await new Promise((r) => setTimeout(r, 20));
+
+    sub.dispose();
+
+    expect(received).toHaveLength(2);
+    expect(received[0].message.type).toBe('assistant_text_delta');
+    expect(received[1].message.type).toBe('message_complete');
+    // Both should carry the session id
+    expect(received[0].sessionId).toBe(conversation.id);
+    expect(received[1].sessionId).toBe(conversation.id);
+    // Messages are the unmodified originals
+    expect(received[0].message).toBe(deltaMsg);
+    expect(received[1].message).toBe(completeMsg);
+  });
+
+  test('sessionId falls back to conversationId when message lacks it (onEvent path)', async () => {
+    const conversation = createConversation('http-session-fallback-test');
+    // pong has no sessionId field
+    const msg: ServerMessage = { type: 'pong' };
+    const session = makeSessionEmittingViaAgentLoop(msg);
+
+    const received: AssistantEvent[] = [];
+    const sub = assistantEventHub.subscribe(
+      { assistantId: 'self' },
+      (e) => { received.push(e); },
+    );
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+    });
+
+    await orchestrator.startRun(conversation.id, 'ping');
+    await new Promise((r) => setTimeout(r, 20));
+
+    sub.dispose();
+
+    expect(received).toHaveLength(1);
+    expect(received[0].sessionId).toBe(conversation.id);
+  });
+});

package/src/__tests__/run-orchestrator.test.ts

@@ -92,7 +92,7 @@ describe('run failure detection', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Hello');
+    const run = await orchestrator.startRun(conversation.id, 'Hello');
 
     // The agent loop fires asynchronously; give it a tick to settle.
     await new Promise((r) => setTimeout(r, 50));
@@ -114,7 +114,7 @@ describe('run failure detection', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Hello');
+    const run = await orchestrator.startRun(conversation.id, 'Hello');
 
     await new Promise((r) => setTimeout(r, 50));
 
@@ -192,7 +192,7 @@ describe('run approval state executionTarget', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Run host command');
+    const run = await orchestrator.startRun(conversation.id, 'Run host command');
     const stored = orchestrator.getRun(run.id);
     expect(stored?.status).toBe('needs_confirmation');
     expect(stored?.pendingConfirmation?.executionTarget).toBe('host');

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

@@ -79,11 +79,10 @@ describe('Runtime attachment metadata', () => {
   });
 
   test('GET /messages includes attachment metadata for assistant messages', async () => {
-    const assistantId = 'ast-test-1';
     const conversationKey = 'test-conv-1';
 
-    // Set up conversation and messages
-    const mapping = getOrCreateConversation(assistantId, conversationKey);
+    // Set up conversation and messages using "self" as the assistantId
+    const mapping = getOrCreateConversation("self", conversationKey);
     conversationStore.addMessage(mapping.conversationId, 'user', 'Hello');
     const assistantMsg = conversationStore.addMessage(
       mapping.conversationId,
@@ -91,12 +90,12 @@ describe('Runtime attachment metadata', () => {
       JSON.stringify([{ type: 'text', text: 'Here is a chart' }]),
     );
 
-    // Upload and link an attachment
-    const stored = uploadAttachment(assistantId, 'chart.png', 'image/png', 'iVBOR');
+    // Upload and link an attachment using "self" as the assistantId
+    const stored = uploadAttachment("self", 'chart.png', 'image/png', 'iVBOR');
     linkAttachmentToMessage(assistantMsg.id, stored.id, 0);
 
     const res = await fetch(
-      `http://127.0.0.1:${port}/v1/assistants/${assistantId}/messages?conversationKey=${conversationKey}`,
+      `http://127.0.0.1:${port}/v1/messages?conversationKey=${conversationKey}`,
       { headers: AUTH_HEADERS },
     );
     const body = await res.json() as { messages: Array<{ role: string; content: string; attachments: Array<{ id: string; filename: string; mimeType: string; sizeBytes: number; kind: string }> }> };
@@ -120,10 +119,9 @@ describe('Runtime attachment metadata', () => {
   });
 
   test('GET /messages returns empty attachments when none linked', async () => {
-    const assistantId = 'ast-test-2';
     const conversationKey = 'test-conv-2';
 
-    const mapping = getOrCreateConversation(assistantId, conversationKey);
+    const mapping = getOrCreateConversation("self", conversationKey);
     conversationStore.addMessage(mapping.conversationId, 'user', 'Hello');
     conversationStore.addMessage(
       mapping.conversationId,
@@ -132,7 +130,7 @@ describe('Runtime attachment metadata', () => {
     );
 
     const res = await fetch(
-      `http://127.0.0.1:${port}/v1/assistants/${assistantId}/messages?conversationKey=${conversationKey}`,
+      `http://127.0.0.1:${port}/v1/messages?conversationKey=${conversationKey}`,
       { headers: AUTH_HEADERS },
     );
     const body = await res.json() as { messages: Array<{ role: string; attachments: unknown[] }> };
@@ -144,11 +142,10 @@ describe('Runtime attachment metadata', () => {
   });
 
   test('GET /attachments/:id returns attachment with payload', async () => {
-    const assistantId = 'ast-test-3';
-    const stored = uploadAttachment(assistantId, 'report.pdf', 'application/pdf', 'JVBER');
+    const stored = uploadAttachment("self", 'report.pdf', 'application/pdf', 'JVBER');
 
     const res = await fetch(
-      `http://127.0.0.1:${port}/v1/assistants/${assistantId}/attachments/${stored.id}`,
+      `http://127.0.0.1:${port}/v1/attachments/${stored.id}`,
       { headers: AUTH_HEADERS },
     );
     const body = await res.json() as {
@@ -164,22 +161,23 @@ describe('Runtime attachment metadata', () => {
     expect(body.sizeBytes).toBeGreaterThan(0);
   });
 
-  test('GET /attachments/:id returns 404 for wrong assistant', async () => {
-    const stored = uploadAttachment('ast-owner', 'secret.txt', 'text/plain', 'c2VjcmV0');
+  test('GET /attachments/:id returns attachment stored under "self"', async () => {
+    const stored = uploadAttachment("self", 'shared.txt', 'text/plain', 'c2hhcmVk');
 
     const res = await fetch(
-      `http://127.0.0.1:${port}/v1/assistants/ast-other/attachments/${stored.id}`,
+      `http://127.0.0.1:${port}/v1/attachments/${stored.id}`,
       { headers: AUTH_HEADERS },
     );
-    const body = await res.json() as { error: string };
+    const body = await res.json() as { id: string; filename: string };
 
-    expect(res.status).toBe(404);
-    expect(body.error).toBe('Attachment not found');
+    expect(res.status).toBe(200);
+    expect(body.id).toBe(stored.id);
+    expect(body.filename).toBe('shared.txt');
   });
 
   test('GET /attachments/:id returns 404 for nonexistent attachment', async () => {
     const res = await fetch(
-      `http://127.0.0.1:${port}/v1/assistants/ast-test-4/attachments/nonexistent-id`,
+      `http://127.0.0.1:${port}/v1/attachments/nonexistent-id`,
       { headers: AUTH_HEADERS },
     );
     const body = await res.json() as { error: string };

package/src/__tests__/runtime-runs-http.test.ts

@@ -127,7 +127,6 @@ function makeHangingSession(): Session {
 // Tests
 // ---------------------------------------------------------------------------
 
-const ASSISTANT_ID = 'ast-run-http';
 const TEST_TOKEN = 'test-bearer-token-runs';
 const AUTH_HEADERS = { Authorization: `Bearer ${TEST_TOKEN}` };
 
@@ -164,7 +163,7 @@ describe('runtime runs — HTTP layer', () => {
   }
 
   function runsUrl(path = ''): string {
-    return `http://127.0.0.1:${port}/v1/assistants/${ASSISTANT_ID}/runs${path}`;
+    return `http://127.0.0.1:${port}/v1/runs${path}`;
   }
 
   // ── Auth ────────────────────────────────────────────────────────────
@@ -363,23 +362,6 @@ describe('runtime runs — HTTP layer', () => {
     await stopServer();
   });
 
-  test('GET /runs/:id returns 404 for different assistant', async () => {
-    await startServer(() => makeCompletingSession());
-
-    const createRes = await fetch(runsUrl(), {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
-      body: JSON.stringify({ conversationKey: 'conv-scope', content: 'Test' }),
-    });
-    const { id } = await createRes.json() as { id: string };
-
-    // Try to access via a different assistant
-    const res = await fetch(`http://127.0.0.1:${port}/v1/assistants/other-assistant/runs/${id}`, { headers: AUTH_HEADERS });
-    expect(res.status).toBe(404);
-
-    await stopServer();
-  });
-
   // ── POST /runs/:id/decision ─────────────────────────────────────────
 
   test('POST /runs/:id/decision returns accepted for pending confirmation', async () => {

package/src/__tests__/runtime-runs.test.ts

@@ -145,7 +145,7 @@ describe('runtime runs — swarm lifecycle', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Build a feature');
+    const run = await orchestrator.startRun(conversation.id, 'Build a feature');
     expect(run.status).toBe('running');
 
     // Wait for agent loop to complete
@@ -162,7 +162,7 @@ describe('runtime runs — swarm lifecycle', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Run swarm');
+    const run = await orchestrator.startRun(conversation.id, 'Run swarm');
 
     await new Promise((r) => setTimeout(r, 50));
 
@@ -178,7 +178,7 @@ describe('runtime runs — swarm lifecycle', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Delegate a swarm task');
+    const run = await orchestrator.startRun(conversation.id, 'Delegate a swarm task');
 
     // Give agent loop time to emit confirmation_request
     await new Promise((r) => setTimeout(r, 50));
@@ -195,7 +195,7 @@ describe('runtime runs — swarm lifecycle', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Run with approval');
+    const run = await orchestrator.startRun(conversation.id, 'Run with approval');
     await new Promise((r) => setTimeout(r, 50));
 
     // Verify pending state
@@ -220,12 +220,12 @@ describe('runtime runs — swarm lifecycle', () => {
     });
 
     // First run starts and hangs
-    await orchestrator.startRun('assistant-1', conversation.id, 'First run');
+    await orchestrator.startRun(conversation.id, 'First run');
     await new Promise((r) => setTimeout(r, 20));
 
     // Second run on the same session should be rejected
     try {
-      await orchestrator.startRun('assistant-1', conversation.id, 'Second run');
+      await orchestrator.startRun(conversation.id, 'Second run');
       // Should not reach here
       expect(true).toBe(false);
     } catch (err) {
@@ -252,7 +252,7 @@ describe('runtime runs — swarm lifecycle', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Run with principal');
+    const run = await orchestrator.startRun(conversation.id, 'Run with principal');
     await new Promise((r) => setTimeout(r, 50));
 
     const stored = orchestrator.getRun(run.id);

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

@@ -143,6 +143,7 @@ mock.module('../context/window-manager.js', () => ({
 // ---------------------------------------------------------------------------
 
 const turnCommitCalls: Array<{ workspaceDir: string; sessionId: string; turnNumber: number }> = [];
+let turnCommitHangForever = false;
 
 mock.module('../workspace/git-service.js', () => ({
   getWorkspaceGitService: () => ({
@@ -153,6 +154,10 @@ mock.module('../workspace/git-service.js', () => ({
 mock.module('../workspace/turn-commit.js', () => ({
   commitTurnChanges: async (workspaceDir: string, sessionId: string, turnNumber: number) => {
     turnCommitCalls.push({ workspaceDir, sessionId, turnNumber });
+    if (turnCommitHangForever) {
+      // Simulate a commit that never resolves within the timeout budget
+      await new Promise<void>(() => {});
+    }
   },
 }));
 
@@ -280,6 +285,7 @@ function resolveRun(index: number) {
 
 beforeEach(() => {
   turnCommitCalls.length = 0;
+  turnCommitHangForever = false;
   linkAttachmentShouldThrow = false;
 });
 
@@ -1459,4 +1465,48 @@ describe('Regression: cancel semantics and error channel split', () => {
       expect(sessionErr).toBeUndefined();
     }
   });
+
+  test('commitTurnChanges never resolving within budget -> turn still completes and drains queue', async () => {
+    const session = makeSession();
+    await session.loadFromDb();
+
+    turnCommitHangForever = true;
+
+    const events1: ServerMessage[] = [];
+    const events2: ServerMessage[] = [];
+
+    // Start first message (promise intentionally not awaited — we test queue drain behavior)
+    const _p1 = session.processMessage('msg-1', [], (e) => events1.push(e), 'req-1');
+    await waitForPendingRun(1);
+
+    // Enqueue a second message while the first is processing
+    session.enqueueMessage('msg-2', [], (e) => events2.push(e), 'req-2');
+
+    // Complete the first agent loop run
+    resolveRun(0);
+
+    // The turn should still complete (timeout fires) and drain the queue
+    // even though commitTurnChanges never resolves.
+    // The default turnCommitMaxWaitMs is 4000ms in the config mock,
+    // but the mock config doesn't set it, so it defaults to 4000ms.
+    // We wait for the second run to be registered, which proves the
+    // turn completed and the queue drained despite the hanging commit.
+    await waitForPendingRun(2, 10_000);
+
+    // First message should have completed
+    const completion1 = events1.find((e) => e.type === 'message_complete');
+    expect(completion1).toBeDefined();
+
+    // Second message should have been dequeued
+    const dequeued = events2.find((e) => e.type === 'message_dequeued');
+    expect(dequeued).toBeDefined();
+
+    // The turn commit should have been called
+    expect(turnCommitCalls).toHaveLength(1);
+
+    // Complete the second run so the test can clean up
+    turnCommitHangForever = false;
+    resolveRun(1);
+    await new Promise((r) => setTimeout(r, 50));
+  }, 15_000);
 });

package/src/__tests__/turn-commit.test.ts

@@ -5,6 +5,7 @@ import { tmpdir } from 'node:os';
 import { execFileSync } from 'node:child_process';
 import { commitTurnChanges } from '../workspace/turn-commit.js';
 import { WorkspaceGitService, _resetGitServiceRegistry } from '../workspace/git-service.js';
+import type { CommitMessageProvider, CommitContext, CommitMessageResult } from '../workspace/commit-message-provider.js';
 
 describe('commitTurnChanges', () => {
   let testDir: string;
@@ -216,4 +217,59 @@ describe('commitTurnChanges', () => {
     });
     expect(turn1Msg).toContain('Turn: 1');
   });
+
+  test('custom commit message provider output is used in commit', async () => {
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    const customProvider: CommitMessageProvider = {
+      buildImmediateMessage(ctx: CommitContext): CommitMessageResult {
+        return {
+          message: `CUSTOM-TURN: session=${ctx.sessionId} turn=${ctx.turnNumber} files=${ctx.changedFiles.length}`,
+          metadata: { custom: true, provider: 'test-provider' },
+        };
+      },
+    };
+
+    writeFileSync(join(testDir, 'provider-test.txt'), 'provider test content');
+
+    await commitTurnChanges(testDir, 'sess_provider', 42, customProvider);
+
+    const fullMessage = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+      cwd: testDir,
+      encoding: 'utf-8',
+    });
+
+    // Verify the custom provider's message was used, not the default
+    expect(fullMessage).toContain('CUSTOM-TURN: session=sess_provider turn=42 files=1');
+    expect(fullMessage).toContain('custom: true');
+    expect(fullMessage).toContain('provider: "test-provider"');
+  });
+
+  test('custom provider metadata is included in commit message', async () => {
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    const customProvider: CommitMessageProvider = {
+      buildImmediateMessage(_ctx: CommitContext): CommitMessageResult {
+        return {
+          message: 'Minimal custom message',
+          metadata: { enriched: false, source: 'unit-test' },
+        };
+      },
+    };
+
+    writeFileSync(join(testDir, 'meta-test.txt'), 'metadata test');
+
+    await commitTurnChanges(testDir, 'sess_meta', 1, customProvider);
+
+    const fullMessage = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+      cwd: testDir,
+      encoding: 'utf-8',
+    });
+
+    expect(fullMessage).toContain('Minimal custom message');
+    expect(fullMessage).toContain('enriched: false');
+    expect(fullMessage).toContain('source: "unit-test"');
+  });
 });