vellum 0.2.7 → 0.2.9

package/src/tools/tasks/work-item-run.ts

@@ -0,0 +1,78 @@
+import type { ToolContext, ToolExecutionResult } from '../types.js';
+import { getWorkItem, listWorkItems, identifyEntityById, buildWorkItemMismatchError } from '../../work-items/work-item-store.js';
+import { runWorkItemInBackground } from '../../work-items/work-item-runner.js';
+import { getTask } from '../../tasks/task-store.js';
+
+export async function executeTaskQueueRun(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const workItemId = input.work_item_id as string | undefined;
+  const taskName = input.task_name as string | undefined;
+  const title = input.title as string | undefined;
+
+  if (!workItemId && !taskName && !title) {
+    return {
+      content: 'Error: Provide work_item_id, task_name, or title to identify the task to run.',
+      isError: true,
+    };
+  }
+
+  try {
+    let resolvedId: string | undefined;
+
+    if (workItemId) {
+      const item = getWorkItem(workItemId);
+      if (!item) {
+        const entity = identifyEntityById(workItemId);
+        if (entity.type === 'task_template') {
+          return {
+            content: `Error: "${workItemId}" is a task template ID, not a work item. Use task_list_show to find the work item ID.`,
+            isError: true,
+          };
+        }
+        return { content: `Error: No work item found with ID "${workItemId}".`, isError: true };
+      }
+      resolvedId = item.id;
+    } else {
+      // Search by task_name or title among active work items
+      const needle = (taskName ?? title)!.toLowerCase();
+      const allItems = listWorkItems();
+      const activeItems = allItems.filter((i) => !['archived', 'done'].includes(i.status));
+      const matches = activeItems.filter((i) => i.title.toLowerCase().includes(needle));
+
+      if (matches.length === 0) {
+        return {
+          content: `Error: No active work item matching "${taskName ?? title}". Use task_list_show to see your task queue.`,
+          isError: true,
+        };
+      }
+
+      if (matches.length > 1) {
+        const lines = [`Multiple work items match "${taskName ?? title}". Please specify by ID:`, ''];
+        for (const m of matches) {
+          lines.push(`- ${m.title} (ID: ${m.id}, status: ${m.status})`);
+        }
+        return { content: lines.join('\n'), isError: true };
+      }
+
+      resolvedId = matches[0].id;
+    }
+
+    const result = runWorkItemInBackground(resolvedId);
+
+    if (!result.success) {
+      return { content: `Error: ${result.error}`, isError: true };
+    }
+
+    const item = getWorkItem(resolvedId)!;
+    const task = getTask(item.taskId);
+    return {
+      content: `Started running task "${item.title}"${task ? ` (template: ${task.title})` : ''}. It will execute in the background. Use task_list_show to check progress.`,
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error: ${msg}`, isError: true };
+  }
+}

package/src/util/platform.ts

@@ -124,7 +124,7 @@ export function getTCPPort(): number {
  *
  * The flag-file check makes it easy to enable TCP in dev without restarting
  * the shell: `touch ~/.vellum/tcp-enabled && kill -USR1 <daemon-pid>`.
- * The macOS DaemonLauncher also sets the env var for bundled-binary deployments.
+ * The macOS CLI (AssistantCli) also sets the env var for bundled-binary deployments.
  */
 export function isTCPEnabled(): boolean {
   const override = process.env.VELLUM_DAEMON_TCP_ENABLED?.trim();

package/src/work-items/work-item-runner.ts

@@ -0,0 +1,171 @@
+/**
+ * Module-level registry for running work items from tool context.
+ *
+ * The daemon server registers its `getOrCreateSession` and `broadcast`
+ * callbacks at startup. Tool implementations can then trigger async
+ * work item execution without needing direct access to HandlerContext.
+ */
+
+import { getLogger } from '../util/logger.js';
+import { getWorkItem, updateWorkItem, type WorkItemStatus } from './work-item-store.js';
+import { getTask } from '../tasks/task-store.js';
+import { runTask } from '../tasks/task-runner.js';
+import { sanitizeToolList, getRegisteredToolNames } from '../tasks/tool-sanitizer.js';
+import type { Session } from '../daemon/session.js';
+import type { ServerMessage } from '../daemon/ipc-protocol.js';
+
+const log = getLogger('work-item-runner');
+
+// ── Daemon callback registry ─────────────────────────────────────────
+
+interface DaemonCallbacks {
+  getOrCreateSession: (conversationId: string) => Promise<Session>;
+  broadcast: (msg: ServerMessage) => void;
+}
+
+let _callbacks: DaemonCallbacks | null = null;
+
+export function registerDaemonCallbacks(callbacks: DaemonCallbacks): void {
+  _callbacks = callbacks;
+}
+
+// ── Public API ───────────────────────────────────────────────────────
+
+function broadcastWorkItemStatus(broadcast: (msg: ServerMessage) => void, id: string): void {
+  const item = getWorkItem(id);
+  if (item) {
+    broadcast({
+      type: 'work_item_status_changed',
+      item: {
+        id: item.id,
+        taskId: item.taskId,
+        title: item.title,
+        status: item.status,
+        lastRunId: item.lastRunId,
+        lastRunConversationId: item.lastRunConversationId,
+        lastRunStatus: item.lastRunStatus,
+        updatedAt: item.updatedAt,
+      },
+    } as ServerMessage);
+  }
+}
+
+export interface RunWorkItemResult {
+  success: boolean;
+  error?: string;
+  errorCode?: string;
+}
+
+/**
+ * Run a work item in the background. Returns immediately after validation.
+ * The actual execution happens asynchronously.
+ *
+ * When called from a chat tool (e.g. Telegram), required tools are
+ * auto-approved since the user explicitly requested execution.
+ */
+export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
+  if (!_callbacks) {
+    return { success: false, error: 'Daemon callbacks not registered', errorCode: 'not_initialized' };
+  }
+
+  const workItem = getWorkItem(workItemId);
+  if (!workItem) {
+    return { success: false, error: 'Work item not found', errorCode: 'not_found' };
+  }
+
+  if (workItem.status === 'running') {
+    return { success: false, error: 'Work item is already running', errorCode: 'already_running' };
+  }
+
+  const NON_RUNNABLE_STATUSES: readonly string[] = ['archived'];
+  if (NON_RUNNABLE_STATUSES.includes(workItem.status)) {
+    return { success: false, error: `Work item has status '${workItem.status}' and cannot be run`, errorCode: 'invalid_status' };
+  }
+
+  const task = getTask(workItem.taskId);
+  if (!task) {
+    return { success: false, error: `Associated task not found: ${workItem.taskId}`, errorCode: 'no_task' };
+  }
+
+  // Resolve required tools
+  let requiredTools: string[];
+  if (workItem.requiredTools !== null && workItem.requiredTools !== undefined) {
+    requiredTools = sanitizeToolList(JSON.parse(workItem.requiredTools));
+  } else {
+    requiredTools = task.requiredTools
+      ? sanitizeToolList(JSON.parse(task.requiredTools))
+      : getRegisteredToolNames();
+  }
+
+  // Auto-approve all required tools for chat-initiated runs.
+  // The user explicitly asked to run the task, so we treat that as consent.
+  const approvedTools = requiredTools;
+
+  // Set status to running
+  updateWorkItem(workItemId, { status: 'running' });
+
+  const { getOrCreateSession, broadcast } = _callbacks;
+
+  // Broadcast the running state
+  broadcastWorkItemStatus(broadcast, workItemId);
+  broadcast({ type: 'tasks_changed' } as ServerMessage);
+
+  // Execute asynchronously
+  let session: Awaited<ReturnType<typeof getOrCreateSession>> | null = null;
+  void (async () => {
+    try {
+      const result = await runTask(
+        { taskId: workItem.taskId, workingDir: process.cwd(), approvedTools },
+        async (conversationId, message, taskRunId) => {
+          if (!session) {
+            updateWorkItem(workItemId, { lastRunConversationId: conversationId });
+            session = await getOrCreateSession(conversationId);
+
+            broadcast({
+              type: 'task_run_thread_created',
+              conversationId,
+              workItemId,
+              title: workItem.title,
+            } as ServerMessage);
+            (session as unknown as { taskRunId?: string }).taskRunId = taskRunId;
+            (session as unknown as { headlessLock: boolean }).headlessLock = true;
+          }
+          await session.processMessage(message, [], (event) => {
+            broadcast(event);
+          });
+        },
+      );
+
+      if (session) {
+        (session as unknown as { headlessLock: boolean }).headlessLock = false;
+      }
+
+      const current = getWorkItem(workItemId);
+      if (current?.status !== 'cancelled') {
+        const finalStatus: WorkItemStatus = result.status === 'completed' ? 'awaiting_review' : 'failed';
+        updateWorkItem(workItemId, {
+          status: finalStatus,
+          lastRunId: result.taskRunId,
+          lastRunConversationId: result.conversationId,
+          lastRunStatus: result.status,
+        });
+      }
+
+      broadcastWorkItemStatus(broadcast, workItemId);
+      broadcast({ type: 'tasks_changed' } as ServerMessage);
+    } catch (err) {
+      if (session) {
+        (session as unknown as { headlessLock: boolean }).headlessLock = false;
+      }
+      log.error({ err, workItemId }, 'work item background run failed');
+      updateWorkItem(workItemId, {
+        status: 'failed',
+        lastRunStatus: 'failed',
+      });
+      broadcastWorkItemStatus(broadcast, workItemId);
+      broadcast({ type: 'tasks_changed' } as ServerMessage);
+    }
+  })();
+
+  return { success: true };
+}

package/src/workspace/provider-commit-message-generator.ts

@@ -10,9 +10,10 @@ export type CommitMessageSource = 'llm' | 'deterministic';
 export type LLMFallbackReason =
   | 'disabled'
   | 'missing_provider_api_key'
-  | 'provider_not_initialized'
   | 'breaker_open'
   | 'insufficient_budget'
+  | 'missing_fast_model'
+  | 'provider_not_initialized'
   | 'timeout'
   | 'provider_error'
   | 'invalid_output';
@@ -103,17 +104,25 @@ export class ProviderCommitMessageGenerator {
     const config = getConfig();
     const llmConfig = config.workspaceGit.commitMessageLLM;
 
+    // ── Fallback check order (canonical) ──────────────────────────────
+    // 1. disabled
+    // 2. missing_provider_api_key  (except keyless providers like ollama)
+    // 3. breaker_open
+    // 4. insufficient_budget
+    // 5. missing_fast_model
+    // 6. provider_not_initialized
+    // 7. call provider → timeout / provider_error / invalid_output
+    // ──────────────────────────────────────────────────────────────────
+
     // Step 1: Feature gate
     if (!llmConfig.enabled) {
       return buildDeterministicResult(context, 'disabled');
     }
-
-    // Step 2: Provider gate
     if (!llmConfig.useConfiguredProvider) {
       return buildDeterministicResult(context, 'disabled');
     }
 
-    // Step 2.5: API key preflight (skip for providers that run without a key)
+    // Step 2: API key preflight (skip for providers that run without a key)
     if (!KEYLESS_PROVIDERS.has(config.provider)) {
       const providerApiKey = config.apiKeys[config.provider];
       if (!providerApiKey || providerApiKey === '') {
@@ -143,7 +152,19 @@ export class ProviderCommitMessageGenerator {
       }
     }
 
-    // Step 5: Call the provider
+    // Step 5: Fast model preflight — resolve before any provider call
+    const fastModel = llmConfig.providerFastModelOverrides[config.provider]
+      ?? PROVIDER_DEFAULT_FAST_MODELS[config.provider];
+
+    if (!fastModel) {
+      log.debug(
+        { provider: config.provider },
+        'No fast model resolvable for provider; falling back to deterministic',
+      );
+      return buildDeterministicResult(context, 'missing_fast_model');
+    }
+
+    // Step 6 + 7: Call the provider
     try {
       const { getProvider } = await import('../providers/registry.js');
 
@@ -179,14 +200,6 @@ export class ProviderCommitMessageGenerator {
         },
       ];
 
-      // Resolve fast model
-      const fastModel = llmConfig.providerFastModelOverrides[config.provider]
-        ?? PROVIDER_DEFAULT_FAST_MODELS[config.provider];
-      if (!fastModel) {
-        log.debug({ provider: config.provider }, 'No default fast model for provider; falling back to deterministic');
-        return buildDeterministicResult(context, 'provider_error');
-      }
-
       // AbortController with timeout
       const ac = new AbortController();
       const timer = setTimeout(() => ac.abort(), llmConfig.timeoutMs);
@@ -199,7 +212,11 @@ export class ProviderCommitMessageGenerator {
           SYSTEM_PROMPT,
           {
             signal: ac.signal,
-            config: { model: fastModel, max_tokens: llmConfig.maxTokens, temperature: llmConfig.temperature },
+            config: {
+              model: fastModel,
+              max_tokens: llmConfig.maxTokens,
+              temperature: llmConfig.temperature,
+            },
           },
         );
       } catch (err: unknown) {
@@ -230,21 +247,20 @@ export class ProviderCommitMessageGenerator {
         return buildDeterministicResult(context, 'invalid_output');
       }
 
-      // Validate single-line subject: first line must be <= 72 chars
-      const firstLine = text.split('\n')[0];
-      if (firstLine.length > 72) {
+      // Cap subject line to 72 chars deterministically (no fallback, no breaker failure)
+      const lines = text.split('\n');
+      if (lines[0].length > 72) {
         log.debug(
-          { subjectLength: firstLine.length },
-          'LLM subject line too long; falling back to deterministic',
+          { originalLength: lines[0].length },
+          'Capping LLM subject line to 72 chars',
         );
-        this.recordFailure();
-        return buildDeterministicResult(context, 'invalid_output');
+        lines[0] = lines[0].slice(0, 72);
       }
+      const finalMessage = lines.join('\n');
 
       this.recordSuccess();
-      return { message: text, source: 'llm' };
+      return { message: finalMessage, source: 'llm' };
     } catch (err: unknown) {
-      // Step 6: Any error -> deterministic fallback
       log.warn(
         { err: err instanceof Error ? err.message : String(err) },
         'Commit message LLM provider error; falling back to deterministic',

package/src/workspace/turn-commit.ts

@@ -72,10 +72,14 @@ export async function commitTurnChanges(
     if (!provider) {
       // Guard: skip pre-check if deadline already elapsed to avoid unnecessary mutex contention
       let preClean = false;
+      let candidateChangedFiles: string[] = [];
       if (!deadlineMs || Date.now() < deadlineMs) {
         try {
           const preStatus = await gitService.getStatus();
           preClean = preStatus.clean;
+          if (!preClean) {
+            candidateChangedFiles = [...new Set([...preStatus.staged, ...preStatus.modified, ...preStatus.untracked])];
+          }
         } catch {
           // If we can't determine status, assume dirty so we don't skip the commit
         }
@@ -90,10 +94,10 @@ export async function commitTurnChanges(
               trigger: 'turn',
               sessionId,
               turnNumber,
-              changedFiles: [], // File list unavailable outside the git mutex; generator handles empty arrays
+              changedFiles: candidateChangedFiles,
               timestampMs: Date.now(),
             },
-            { deadlineMs, changedFiles: [] },
+            { deadlineMs, changedFiles: candidateChangedFiles },
           );
           commitMessageSource = result.source;
           llmFallbackReason = result.reason;

package/src/__tests__/handlers-twilio-config.test.ts

@@ -1,221 +0,0 @@
-import { describe, test, expect, mock, beforeEach } from 'bun:test';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import * as net from 'node:net';
-
-const testDir = mkdtempSync(join(tmpdir(), 'handlers-twilio-cfg-test-'));
-
-let rawConfigStore: Record<string, unknown> = {};
-const saveRawConfigCalls: Record<string, unknown>[] = [];
-
-mock.module('../config/loader.js', () => ({
-  getConfig: () => ({}),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({ ...rawConfigStore }),
-  saveRawConfig: (cfg: Record<string, unknown>) => {
-    saveRawConfigCalls.push(cfg);
-    rawConfigStore = { ...cfg };
-  },
-  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: () => {},
-}));
-
-mock.module('../util/logger.js', () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-    trace: () => {},
-    fatal: () => {},
-    child: () => ({
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-      debug: () => {},
-    }),
-  }),
-}));
-
-mock.module('../memory/app-store.js', () => ({
-  queryAppRecords: () => [],
-  createAppRecord: () => {},
-  updateAppRecord: () => {},
-  deleteAppRecord: () => {},
-  listApps: () => [],
-  getApp: () => undefined,
-  createApp: () => {},
-  updateApp: () => {},
-}));
-
-mock.module('../slack/slack-webhook.js', () => ({
-  postToSlackWebhook: async () => {},
-}));
-
-import { handleMessage, type HandlerContext } from '../daemon/handlers.js';
-import type {
-  TwilioWebhookConfigRequest,
-  ServerMessage,
-} from '../daemon/ipc-contract.js';
-
-function createTestContext(): { ctx: HandlerContext; sent: ServerMessage[] } {
-  const sent: ServerMessage[] = [];
-  const ctx: HandlerContext = {
-    sessions: new Map(),
-    socketToSession: new Map(),
-    cuSessions: new Map(),
-    socketToCuSession: new Map(),
-    cuObservationParseSequence: new Map(),
-    socketSandboxOverride: new Map(),
-    sharedRequestTimestamps: [],
-    debounceTimers: new Map(),
-    suppressConfigReload: false,
-    setSuppressConfigReload: () => {},
-    updateConfigFingerprint: () => {},
-    send: (_socket, msg) => { sent.push(msg); },
-    broadcast: () => {},
-    clearAllSessions: () => 0,
-    getOrCreateSession: () => { throw new Error('not implemented'); },
-    touchSession: () => {},
-  };
-  return { ctx, sent };
-}
-
-describe('Twilio webhook config handler', () => {
-  beforeEach(() => {
-    rawConfigStore = {};
-    saveRawConfigCalls.length = 0;
-  });
-
-  test('get returns empty string when no config set', () => {
-    rawConfigStore = {};
-
-    const msg: TwilioWebhookConfigRequest = {
-      type: 'twilio_webhook_config',
-      action: 'get',
-    };
-
-    const { ctx, sent } = createTestContext();
-    handleMessage(msg, {} as net.Socket, ctx);
-
-    expect(sent).toHaveLength(1);
-    const res = sent[0] as { type: string; webhookBaseUrl: string; success: boolean };
-    expect(res.type).toBe('twilio_webhook_config_response');
-    expect(res.success).toBe(true);
-    expect(res.webhookBaseUrl).toBe('');
-  });
-
-  test('set persists value and returns it', () => {
-    rawConfigStore = {};
-
-    const msg: TwilioWebhookConfigRequest = {
-      type: 'twilio_webhook_config',
-      action: 'set',
-      webhookBaseUrl: 'https://example.com/twilio',
-    };
-
-    const { ctx, sent } = createTestContext();
-    handleMessage(msg, {} as net.Socket, ctx);
-
-    expect(sent).toHaveLength(1);
-    const res = sent[0] as { type: string; webhookBaseUrl: string; success: boolean };
-    expect(res.type).toBe('twilio_webhook_config_response');
-    expect(res.success).toBe(true);
-    expect(res.webhookBaseUrl).toBe('https://example.com/twilio');
-
-    expect(saveRawConfigCalls).toHaveLength(1);
-    const saved = saveRawConfigCalls[0] as { calls?: { webhookBaseUrl?: string } };
-    expect(saved.calls?.webhookBaseUrl).toBe('https://example.com/twilio');
-  });
-
-  test('set normalizes trailing slashes', () => {
-    rawConfigStore = {};
-
-    const msg: TwilioWebhookConfigRequest = {
-      type: 'twilio_webhook_config',
-      action: 'set',
-      webhookBaseUrl: 'https://example.com/twilio///',
-    };
-
-    const { ctx, sent } = createTestContext();
-    handleMessage(msg, {} as net.Socket, ctx);
-
-    expect(sent).toHaveLength(1);
-    const res = sent[0] as { type: string; webhookBaseUrl: string; success: boolean };
-    expect(res.webhookBaseUrl).toBe('https://example.com/twilio');
-
-    const saved = saveRawConfigCalls[0] as { calls?: { webhookBaseUrl?: string } };
-    expect(saved.calls?.webhookBaseUrl).toBe('https://example.com/twilio');
-  });
-
-  test('set treats empty string as unset', () => {
-    rawConfigStore = { calls: { webhookBaseUrl: 'https://example.com/twilio' } };
-    saveRawConfigCalls.length = 0;
-
-    const msg: TwilioWebhookConfigRequest = {
-      type: 'twilio_webhook_config',
-      action: 'set',
-      webhookBaseUrl: '',
-    };
-
-    const { ctx, sent } = createTestContext();
-    handleMessage(msg, {} as net.Socket, ctx);
-
-    expect(sent).toHaveLength(1);
-    const res = sent[0] as { type: string; webhookBaseUrl: string; success: boolean };
-    expect(res.success).toBe(true);
-    expect(res.webhookBaseUrl).toBe('');
-
-    const saved = saveRawConfigCalls[0] as { calls?: { webhookBaseUrl?: string } };
-    expect(saved.calls?.webhookBaseUrl).toBeUndefined();
-  });
-
-  test('get after set roundtrip works', () => {
-    rawConfigStore = {};
-
-    // Set
-    const setMsg: TwilioWebhookConfigRequest = {
-      type: 'twilio_webhook_config',
-      action: 'set',
-      webhookBaseUrl: 'https://my-server.ngrok.io',
-    };
-
-    const { ctx: setCtx, sent: setSent } = createTestContext();
-    handleMessage(setMsg, {} as net.Socket, setCtx);
-
-    expect(setSent).toHaveLength(1);
-    const setRes = setSent[0] as { type: string; webhookBaseUrl: string; success: boolean };
-    expect(setRes.success).toBe(true);
-    expect(setRes.webhookBaseUrl).toBe('https://my-server.ngrok.io');
-
-    // Get (rawConfigStore was updated by the mock saveRawConfig)
-    const getMsg: TwilioWebhookConfigRequest = {
-      type: 'twilio_webhook_config',
-      action: 'get',
-    };
-
-    const { ctx: getCtx, sent: getSent } = createTestContext();
-    handleMessage(getMsg, {} as net.Socket, getCtx);
-
-    expect(getSent).toHaveLength(1);
-    const getRes = getSent[0] as { type: string; webhookBaseUrl: string; success: boolean };
-    expect(getRes.type).toBe('twilio_webhook_config_response');
-    expect(getRes.success).toBe(true);
-    expect(getRes.webhookBaseUrl).toBe('https://my-server.ngrok.io');
-  });
-});