vellum 0.2.1 → 0.2.7

package/src/daemon/ipc-contract.ts

@@ -45,6 +45,8 @@ export interface UserMessageAttachment {
   extractedText?: string;
   /** Original file size in bytes. Present when data was omitted from history_response to reduce payload size. */
   sizeBytes?: number;
+  /** Base64-encoded JPEG thumbnail. Generated server-side for video attachments. */
+  thumbnailData?: string;
 }
 
 export interface ConfirmationResponse {
@@ -210,6 +212,9 @@ export interface RideShotgunStart {
   intervalSeconds: number;
   mode?: 'observe' | 'learn';
   targetDomain?: string;
+  /** Domain to auto-navigate (may differ from targetDomain, e.g. open.spotify.com vs spotify.com). */
+  navigateDomain?: string;
+  autoNavigate?: boolean;
 }
 
 export interface RideShotgunStop {
@@ -428,16 +433,18 @@ export interface OpenBundleRequest {
 export interface SignBundlePayloadResponse {
   type: 'sign_bundle_payload_response';
   requestId: string;
-  signature: string;
-  keyId: string;
-  publicKey: string;
+  signature?: string;
+  keyId?: string;
+  publicKey?: string;
+  error?: string;
 }
 
 export interface GetSigningIdentityResponse {
   type: 'get_signing_identity_response';
   requestId: string;
-  keyId: string;
-  publicKey: string;
+  keyId?: string;
+  publicKey?: string;
+  error?: string;
 }
 
 export interface GalleryListRequest {
@@ -465,6 +472,12 @@ export interface SlackWebhookConfigRequest {
   webhookUrl?: string;
 }
 
+export interface TwilioWebhookConfigRequest {
+  type: 'twilio_webhook_config';
+  action: 'get' | 'set';
+  webhookBaseUrl?: string;
+}
+
 export interface VercelApiConfigRequest {
   type: 'vercel_api_config';
   action: 'get' | 'set' | 'delete';
@@ -478,6 +491,48 @@ export interface VercelApiConfigResponse {
   error?: string;
 }
 
+export interface TwitterIntegrationConfigRequest {
+  type: 'twitter_integration_config';
+  action: 'get' | 'set_mode' | 'set_local_client' | 'clear_local_client' | 'disconnect';
+  mode?: 'local_byo' | 'managed';
+  clientId?: string;
+  clientSecret?: string;
+}
+
+export interface TwitterIntegrationConfigResponse {
+  type: 'twitter_integration_config_response';
+  success: boolean;
+  mode?: 'local_byo' | 'managed';
+  managedAvailable: boolean;
+  localClientConfigured: boolean;
+  connected: boolean;
+  accountInfo?: string;
+  error?: string;
+}
+
+export interface TwitterAuthStartRequest {
+  type: 'twitter_auth_start';
+}
+
+export interface TwitterAuthStatusRequest {
+  type: 'twitter_auth_status';
+}
+
+export interface TwitterAuthResult {
+  type: 'twitter_auth_result';
+  success: boolean;
+  accountInfo?: string;
+  error?: string;
+}
+
+export interface TwitterAuthStatusResponse {
+  type: 'twitter_auth_status_response';
+  connected: boolean;
+  accountInfo?: string;
+  mode?: 'local_byo' | 'managed';
+  error?: string;
+}
+
 export interface LinkOpenRequest {
   type: 'link_open_request';
   url: string;
@@ -774,15 +829,6 @@ export interface WorkItemGetRequest {
   id: string;
 }
 
-export interface WorkItemCreateRequest {
-  type: 'work_item_create';
-  taskId: string;
-  title?: string;   // defaults to task title
-  notes?: string;
-  priorityTier?: number;
-  sortIndex?: number;
-}
-
 export interface WorkItemUpdateRequest {
   type: 'work_item_update';
   id: string;
@@ -813,6 +859,22 @@ export interface WorkItemOutputRequest {
   id: string;
 }
 
+export interface WorkItemPreflightRequest {
+  type: 'work_item_preflight';
+  id: string;  // work item ID
+}
+
+export interface WorkItemApprovePermissionsRequest {
+  type: 'work_item_approve_permissions';
+  id: string;
+  approvedTools: string[];  // tools the user approved
+}
+
+export interface WorkItemCancelRequest {
+  type: 'work_item_cancel';
+  id: string;
+}
+
 export type ClientMessage =
   | AuthMessage
   | UserMessage
@@ -879,7 +941,11 @@ export type ClientMessage =
   | ShareAppCloudRequest
   | ShareToSlackRequest
   | SlackWebhookConfigRequest
+  | TwilioWebhookConfigRequest
   | VercelApiConfigRequest
+  | TwitterIntegrationConfigRequest
+  | TwitterAuthStartRequest
+  | TwitterAuthStatusRequest
   | SessionsClearRequest
   | GalleryListRequest
   | GalleryInstallRequest
@@ -902,12 +968,14 @@ export type ClientMessage =
   | BrowserInteractiveMode
   | WorkItemsListRequest
   | WorkItemGetRequest
-  | WorkItemCreateRequest
   | WorkItemUpdateRequest
   | WorkItemCompleteRequest
   | WorkItemDeleteRequest
   | WorkItemRunTaskRequest
   | WorkItemOutputRequest
+  | WorkItemPreflightRequest
+  | WorkItemApprovePermissionsRequest
+  | WorkItemCancelRequest
   | SubagentAbortRequest
   | SubagentStatusRequest
   | SubagentMessageRequest;
@@ -982,6 +1050,12 @@ export interface ToolUseStart {
 export interface ToolOutputChunk {
   type: 'tool_output_chunk';
   chunk: string;
+  sessionId?: string;
+  subType?: 'tool_start' | 'tool_complete' | 'status';
+  subToolName?: string;
+  subToolInput?: string;
+  subToolIsError?: boolean;
+  subToolId?: string;
 }
 
 export interface ToolInputDelta {
@@ -1088,6 +1162,7 @@ export interface PongMessage {
 export interface DaemonStatusMessage {
   type: 'daemon_status';
   httpPort?: number;
+  version?: string;
 }
 
 export interface GenerationCancelled {
@@ -1146,6 +1221,13 @@ export interface HistoryResponse {
     contentOrder?: string[];
     /** UI surfaces (widgets) embedded in the message. */
     surfaces?: HistoryResponseSurface[];
+    /** Present when this message is a subagent lifecycle notification (completed/failed/aborted). */
+    subagentNotification?: {
+      subagentId: string;
+      label: string;
+      status: 'completed' | 'failed' | 'aborted';
+      error?: string;
+    };
   }>;
 }
 
@@ -1422,6 +1504,8 @@ export interface SchedulesListResponse {
     id: string;
     name: string;
     enabled: boolean;
+    syntax: string;
+    expression: string;
     cronExpression: string;
     timezone: string | null;
     message: string;
@@ -1606,6 +1690,13 @@ export interface SlackWebhookConfigResponse {
   error?: string;
 }
 
+export interface TwilioWebhookConfigResponse {
+  type: 'twilio_webhook_config_response';
+  webhookBaseUrl: string;
+  success: boolean;
+  error?: string;
+}
+
 export interface OpenUrl {
   type: 'open_url';
   url: string;
@@ -1637,6 +1728,12 @@ export interface WatcherEscalation {
   body: string;
 }
 
+export interface AgentHeartbeatAlert {
+  type: 'agent_heartbeat_alert';
+  title: string;
+  body: string;
+}
+
 export interface WatchStarted {
   type: 'watch_started';
   sessionId: string;
@@ -1892,26 +1989,6 @@ export interface WorkItemGetResponse {
   } | null;
 }
 
-export interface WorkItemCreateResponse {
-  type: 'work_item_create_response';
-  item: {
-    id: string;
-    taskId: string;
-    title: string;
-    notes: string | null;
-    status: string;
-    priorityTier: number;
-    sortIndex: number | null;
-    lastRunId: string | null;
-    lastRunConversationId: string | null;
-    lastRunStatus: string | null;
-    sourceType: string | null;
-    sourceId: string | null;
-    createdAt: number;
-    updatedAt: number;
-  };
-}
-
 export interface WorkItemUpdateResponse {
   type: 'work_item_update_response';
   item: {
@@ -1966,6 +2043,33 @@ export interface WorkItemOutputResponse {
   };
 }
 
+export interface WorkItemPreflightResponse {
+  type: 'work_item_preflight_response';
+  id: string;
+  success: boolean;
+  error?: string;
+  permissions?: {
+    tool: string;
+    description: string;
+    riskLevel: 'low' | 'medium' | 'high';
+    currentDecision: 'allow' | 'deny' | 'prompt';
+  }[];
+}
+
+export interface WorkItemApprovePermissionsResponse {
+  type: 'work_item_approve_permissions_response';
+  id: string;
+  success: boolean;
+  error?: string;
+}
+
+export interface WorkItemCancelResponse {
+  type: 'work_item_cancel_response';
+  id: string;
+  success: boolean;
+  error?: string;
+}
+
 /** Server push — tells the client to open/focus the tasks window. */
 export interface OpenTasksWindow {
   type: 'open_tasks_window';
@@ -1991,6 +2095,14 @@ export interface WorkItemStatusChanged {
   };
 }
 
+/** Server push — broadcast when a task run creates a conversation, so the client can show it as a chat thread. */
+export interface TaskRunThreadCreated {
+  type: 'task_run_thread_created';
+  conversationId: string;
+  workItemId: string;
+  title: string;
+}
+
 export type ServerMessage =
   | AuthResult
   | UserMessageEcho
@@ -2045,6 +2157,7 @@ export type ServerMessage =
   | ScheduleComplete
   | WatcherNotification
   | WatcherEscalation
+  | AgentHeartbeatAlert
   | WatchStarted
   | WatchCompleteRequest
   | TrustRulesListResponse
@@ -2067,7 +2180,11 @@ export type ServerMessage =
   | GalleryInstallResponse
   | ShareToSlackResponse
   | SlackWebhookConfigResponse
+  | TwilioWebhookConfigResponse
   | VercelApiConfigResponse
+  | TwitterIntegrationConfigResponse
+  | TwitterAuthResult
+  | TwitterAuthStatusResponse
   | OpenUrl
   | AppUpdatePreviewResponse
   | AppPreviewResponse
@@ -2089,12 +2206,15 @@ export type ServerMessage =
   | BrowserHandoffRequest
   | WorkItemsListResponse
   | WorkItemGetResponse
-  | WorkItemCreateResponse
   | WorkItemUpdateResponse
   | WorkItemDeleteResponse
   | WorkItemRunTaskResponse
   | WorkItemOutputResponse
+  | WorkItemPreflightResponse
+  | WorkItemApprovePermissionsResponse
+  | WorkItemCancelResponse
   | WorkItemStatusChanged
+  | TaskRunThreadCreated
   | TasksChanged
   | OpenTasksWindow
   | SubagentSpawned
@@ -2137,7 +2257,6 @@ export interface SubagentStatusRequest {
   type: 'subagent_status';
   /** If omitted, returns all subagents for the session. */
   subagentId?: string;
-  sessionId: string;
 }
 
 export interface SubagentMessageRequest {

package/src/daemon/ipc-protocol.ts

@@ -2,6 +2,9 @@
 export * from './ipc-contract.js';
 
 import type { ClientMessage, ServerMessage } from './ipc-contract.js';
+import { getLogger } from '../util/logger.js';
+
+const log = getLogger('ipc-protocol');
 
 // === Serialization ===
 
@@ -43,8 +46,10 @@ export function createMessageParser(options?: { maxLineSize?: number }) {
             entry.rawByteLength = Buffer.byteLength(trimmed, 'utf8');
           }
           results.push(entry);
-        } catch {
-          // Skip malformed messages
+        } catch (err) {
+          // Log only the error name, not the message — JSON.parse errors embed
+          // fragments of the input which could contain sensitive data.
+          log.warn({ lineLength: trimmed.length, errorType: err instanceof Error ? err.name : 'unknown' }, 'Skipping malformed IPC message');
         }
       }
     }

package/src/daemon/lifecycle.ts

@@ -44,7 +44,10 @@ import { RuntimeHttpServer } from '../runtime/http-server.js';
 import { getHookManager } from '../hooks/manager.js';
 import { installTemplates } from '../hooks/templates.js';
 import { HeartbeatService } from '../workspace/heartbeat-service.js';
+import { AgentHeartbeatService } from '../agent-heartbeat/agent-heartbeat-service.js';
 import { getEnrichmentService } from '../workspace/commit-message-enrichment-service.js';
+import { reconcileCallsOnStartup } from '../calls/call-recovery.js';
+import { TwilioConversationRelayProvider } from '../calls/twilio-provider.js';
 
 const log = getLogger('lifecycle');
 
@@ -292,6 +295,15 @@ export async function runDaemon(): Promise<void> {
     log.info({ count: orphanedRunning.length }, 'Recovered orphaned running work items');
   }
 
+  // Reconcile in-flight calls that were left in non-terminal states
+  // after a daemon crash or restart.
+  try {
+    const twilioProvider = new TwilioConversationRelayProvider();
+    await reconcileCallsOnStartup(twilioProvider, log);
+  } catch (err) {
+    log.warn({ err }, 'Call recovery failed — continuing startup');
+  }
+
   log.info('Daemon startup: loading config');
   const config = loadConfig();
 
@@ -444,6 +456,14 @@ export async function runDaemon(): Promise<void> {
   const heartbeat = new HeartbeatService();
   heartbeat.start();
 
+  // Start model-driven heartbeat service (opt-in via config).
+  const agentHeartbeat = new AgentHeartbeatService({
+    processMessage: (conversationId, content) =>
+      server.processMessage(conversationId, content),
+    alerter: (alert) => server.broadcast(alert),
+  });
+  agentHeartbeat.start();
+
   // Graceful shutdown
   let shuttingDown = false;
   const shutdown = async () => {
@@ -464,6 +484,7 @@ export async function runDaemon(): Promise<void> {
     forceTimer.unref();
 
     await heartbeat.stop();
+    await agentHeartbeat.stop();
 
     try {
       await hookManager.trigger('daemon-stop', { pid: process.pid });

package/src/daemon/main.ts

@@ -1,14 +1,20 @@
 #!/usr/bin/env bun
 import * as Sentry from '@sentry/node';
 import { runDaemon } from './lifecycle.js';
+import { getLogger } from '../util/logger.js';
 
-// Use console.error instead of the structured logger here because
-// startDaemon() captures the child process's stderr to surface error
-// details to the parent process. The structured logger writes to a file
-// by default, so these messages would be lost from stderr.
 runDaemon().catch(async (err) => {
   Sentry.captureException(err);
   await Sentry.flush(2000);
+  // Try structured log first; fall back to console.error because
+  // startDaemon() captures the child process's stderr to surface error
+  // details to the parent process.
+  try {
+    const log = getLogger('daemon-main');
+    log.fatal({ err }, 'Failed to start daemon');
+  } catch {
+    // Logger may not be initialized yet
+  }
   console.error('Failed to start daemon:', err);
   console.error('Troubleshooting: check if another daemon is already running, verify ~/.vellum/ permissions, and review logs at ~/.vellum/workspace/data/logs/');
   process.exit(1);

package/src/daemon/ride-shotgun-handler.ts

@@ -15,12 +15,30 @@ import { getLogger } from '../util/logger.js';
 import { NetworkRecorder } from '../tools/browser/network-recorder.js';
 import { saveRecording } from '../tools/browser/recording-store.js';
 import type { SessionRecording } from '../tools/browser/network-recording-types.js';
+import { navigateXPages } from '../tools/browser/x-auto-navigate.js';
+import { autoNavigate } from '../tools/browser/auto-navigate.js';
 
 const log = getLogger('ride-shotgun-handler');
 
 /** Active network recorders keyed by watchId. */
 const activeRecorders = new Map<string, NetworkRecorder>();
 
+/** Return domain-specific URL patterns that indicate a successful login. */
+function getLoginSignals(targetDomain?: string): string[] {
+  if (targetDomain === 'x.com' || targetDomain === 'twitter.com') {
+    return [
+      '/i/api/graphql/',       // any authenticated GraphQL call
+      '/1.1/account/settings', // legacy API session check
+    ];
+  }
+  // DoorDash and general fallback
+  return [
+    '/graphql/postLoginQuery',
+    '/graphql/homePageFacetFeed',
+    '/graphql/getConsumerOrdersWithDetails',
+  ];
+}
+
 /**
  * Complete a session — finalize recording (if learn mode), generate summary, fire notifier.
  * Shared by both the duration timeout and the early-stop handler.
@@ -106,11 +124,7 @@ export async function handleRideShotgunStart(
         }
         try {
           const recorder = new NetworkRecorder(targetDomain);
-          recorder.loginSignals = [
-            '/graphql/postLoginQuery',
-            '/graphql/homePageFacetFeed',
-            '/graphql/getConsumerOrdersWithDetails',
-          ];
+          recorder.loginSignals = getLoginSignals(targetDomain);
           await recorder.startDirect();
           // If session completed while we were connecting, stop immediately to avoid leak
           if (session.status !== 'active') {
@@ -118,13 +132,64 @@ export async function handleRideShotgunStart(
             await recorder.stop();
             return;
           }
-          // Auto-stop when login is detected
-          recorder.onLoginDetected = () => {
-            log.info({ watchId }, 'Login detected — auto-stopping learn session');
-            completeSession(session);
-          };
           activeRecorders.set(watchId, recorder);
           log.info({ watchId, targetDomain, attempt }, 'Network recording started for learn session');
+
+          // For x.com, auto-navigate Chrome through key pages to capture the full API surface.
+          // Skip login detection — auto-navigation will complete the session when done.
+          if (targetDomain === 'x.com' || targetDomain === 'twitter.com') {
+            // Don't set onLoginDetected — it would kill the session after the first
+            // GraphQL call (5s grace), before auto-navigation finishes.
+            const abortSignal = { aborted: false };
+            const checkInterval = setInterval(() => {
+              if (session.status !== 'active') {
+                abortSignal.aborted = true;
+                clearInterval(checkInterval);
+              }
+            }, 1000);
+            navigateXPages(abortSignal).then(completed => {
+              clearInterval(checkInterval);
+              log.info({ watchId, completedSteps: completed.length }, 'X auto-navigation finished');
+              if (session.status === 'active') {
+                completeSession(session);
+              }
+            }).catch(err => {
+              clearInterval(checkInterval);
+              log.warn({ err, watchId }, 'X auto-navigation failed');
+              if (session.status === 'active') {
+                completeSession(session);
+              }
+            });
+          } else if (msg.autoNavigate && targetDomain) {
+            const navDomain = msg.navigateDomain ?? targetDomain;
+            const abortSignal = { aborted: false };
+            const checkInterval = setInterval(() => {
+              if (session.status !== 'active') {
+                abortSignal.aborted = true;
+                clearInterval(checkInterval);
+              }
+            }, 1000);
+            autoNavigate(navDomain, abortSignal).then(visited => {
+              clearInterval(checkInterval);
+              log.info({ watchId, visitedPages: visited.length }, 'Generic auto-navigation finished');
+              if (session.status === 'active') {
+                completeSession(session);
+              }
+            }).catch(err => {
+              clearInterval(checkInterval);
+              log.warn({ err, watchId }, 'Generic auto-navigation failed');
+              if (session.status === 'active') {
+                completeSession(session);
+              }
+            });
+          } else {
+            // No targetDomain: use login detection as before
+            recorder.onLoginDetected = () => {
+              log.info({ watchId }, 'Login detected — auto-stopping learn session');
+              completeSession(session);
+            };
+          }
+
           return;
         } catch (err) {
           if (attempt < 9) {