@vellumai/assistant 0.4.41 → 0.4.43

package/src/daemon/lifecycle.ts

@@ -17,8 +17,6 @@ import {
   validateEnv,
 } from "../config/env.js";
 import { loadConfig } from "../config/loader.js";
-import { ensurePromptFiles } from "../config/system-prompt.js";
-import { syncUpdateBulletinOnStartup } from "../config/update-bulletin.js";
 import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import { getHookManager } from "../hooks/manager.js";
 import { installTemplates } from "../hooks/templates.js";
@@ -26,19 +24,25 @@ import { closeSentry, initSentry } from "../instrument.js";
 import { initLogfire } from "../logfire.js";
 import { getMcpServerManager } from "../mcp/manager.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
-import * as conversationStore from "../memory/conversation-store.js";
+import {
+  deleteMessageById,
+  getConversationThreadType,
+  getMessages,
+} from "../memory/conversation-crud.js";
 import { initializeDb } from "../memory/db.js";
 import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
 import { initQdrantClient } from "../memory/qdrant-client.js";
 import { QdrantManager } from "../memory/qdrant-manager.js";
 import { rotateToolInvocations } from "../memory/tool-usage-store.js";
-import { migrateToDataLayout } from "../migrations/data-layout.js";
-import { migrateToWorkspaceLayout } from "../migrations/workspace-layout.js";
 import {
   emitNotificationSignal,
   registerBroadcastFn,
 } from "../notifications/emit-signal.js";
+import { ensurePromptFiles } from "../prompts/system-prompt.js";
+import { syncUpdateBulletinOnStartup } from "../prompts/update-bulletin.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import {
   initAuthSigningKey,
   loadOrCreateSigningKey,
@@ -48,13 +52,12 @@ import {
 import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { startScheduler } from "../schedule/scheduler.js";
+import { watchSessions } from "../tools/watch/watch-state.js";
 import { getLogger, initLogger } from "../util/logger.js";
 import {
   ensureDataDir,
   getInterfacesDir,
   getRootDir,
-  getSocketPath,
-  removeSocketFile,
 } from "../util/platform.js";
 import {
   listWorkItems,
@@ -65,10 +68,6 @@ import {
   createApprovalConversationGenerator,
   createApprovalCopyGenerator,
 } from "./approval-generators.js";
-import {
-  hasNoAuthOverride,
-  hasUngatedNoAuthOverride,
-} from "./connection-policy.js";
 import {
   cleanupPidFile,
   cleanupPidFileIfOwner,
@@ -79,17 +78,27 @@ import {
   createGuardianFollowUpConversationGenerator,
 } from "./guardian-action-generators.js";
 import { initPairingHandlers } from "./handlers/pairing.js";
+import {
+  cancelGeneration,
+  clearAllSessions,
+  regenerateResponse,
+  renameSession,
+  switchSession,
+  undoLastMessage,
+} from "./handlers/sessions.js";
 import { installCliLaunchers } from "./install-cli-launchers.js";
-import type { ServerMessage } from "./ipc-protocol.js";
+import type { ServerMessage } from "./message-protocol.js";
 import {
   initializeProvidersAndTools,
   registerMessagingProviders,
   registerWatcherProviders,
 } from "./providers-setup.js";
+import { handleRideShotgunStart, handleRideShotgunStop } from "./ride-shotgun-handler.js";
 import { seedInterfaceFiles } from "./seed-files.js";
 import { DaemonServer } from "./server.js";
 import { initSlashPairingContext } from "./session-slash.js";
 import { installShutdownHandlers } from "./shutdown-handlers.js";
+import { handleWatchObservation } from "./watch-handler.js";
 
 // Re-export public API so existing consumers don't need to change imports
 export type { StopResult } from "./daemon-control.js";
@@ -113,21 +122,6 @@ export async function runDaemon(): Promise<void> {
   loadDotEnv();
   validateEnv();
 
-  if (hasUngatedNoAuthOverride()) {
-    log.warn(
-      "VELLUM_DAEMON_NOAUTH is set but VELLUM_UNSAFE_AUTH_BYPASS=1 is not — auth bypass is IGNORED and authentication remains enabled. Set VELLUM_UNSAFE_AUTH_BYPASS=1 to confirm the bypass.",
-    );
-  } else if (hasNoAuthOverride()) {
-    log.warn(
-      "VELLUM_DAEMON_NOAUTH is set — IPC authentication is DISABLED. This should only be used for development or SSH-forwarded sockets. Do not use in production.",
-    );
-  }
-
-  // Track whether the IPC socket has been created so we can clean it up
-  // if init crashes after the socket is bound but before shutdown handlers
-  // are installed.
-  let socketCreated = false;
-
   try {
     // Initialize crash reporting eagerly so early startup failures are
     // captured. After config loads we check the opt-out flag and call
@@ -136,11 +130,6 @@ export async function runDaemon(): Promise<void> {
 
     await initLogfire();
 
-    // Migration order matters: first move legacy flat files into the data dir
-    // structure, then relocate the data dir into the active workspace, and
-    // finally create any directories that don't yet exist.
-    migrateToDataLayout();
-    migrateToWorkspaceLayout();
     ensureDataDir();
 
     // Load (or generate + persist) the auth signing key so tokens survive
@@ -178,7 +167,7 @@ export async function runDaemon(): Promise<void> {
 
     // Backfill vellum guardian binding for existing installations
     try {
-      ensureVellumGuardianBinding("self");
+      ensureVellumGuardianBinding(DAEMON_INTERNAL_ASSISTANT_ID);
     } catch (err) {
       log.warn(
         { err },
@@ -241,13 +230,11 @@ export async function runDaemon(): Promise<void> {
 
     await initializeProvidersAndTools(config);
 
-    // Start the IPC socket BEFORE Qdrant so that clients can connect
-    // immediately. Qdrant startup can take 30+ seconds (binary download,
-    // /readyz polling) which previously blocked the socket from appearing.
-    log.info("Daemon startup: starting DaemonServer (IPC socket)");
+    // Start the DaemonServer (session manager) before Qdrant so HTTP
+    // routes can begin accepting requests while Qdrant initializes.
+    log.info("Daemon startup: starting DaemonServer");
     const server = new DaemonServer();
     await server.start();
-    socketCreated = true;
     log.info("Daemon startup: DaemonServer started");
 
     // Initialize Qdrant vector store — non-fatal so the daemon stays up without it
@@ -283,8 +270,8 @@ export async function runDaemon(): Promise<void> {
     registerWatcherProviders();
     registerMessagingProviders();
 
-    // Register the IPC broadcast function for the notification signal pipeline's
-    // macOS adapter so it can deliver notification_intent messages to desktop clients.
+    // Register the broadcast function for the notification signal pipeline's
+    // macOS adapter so it can deliver notification_intent messages to clients.
     registerBroadcastFn((msg) => server.broadcast(msg));
 
     const scheduler = startScheduler(
@@ -437,6 +424,142 @@ export async function runDaemon(): Promise<void> {
           })),
       },
       findSession: (sessionId) => server.findSession(sessionId),
+      findSessionBySurfaceId: (surfaceId) =>
+        server.findSessionBySurfaceId(surfaceId),
+      getSkillContext: () => server.getSkillContext(),
+      getModelSetContext: () => server.getHandlerContext(),
+      sessionManagementDeps: {
+        switchSession: (sessionId) =>
+          switchSession(sessionId, server.getHandlerContext()),
+        renameSession: (sessionId, name) => renameSession(sessionId, name),
+        clearAllSessions: () => clearAllSessions(server.getHandlerContext()),
+        cancelGeneration: (sessionId) =>
+          cancelGeneration(sessionId, server.getHandlerContext()),
+        undoLastMessage: (sessionId) =>
+          undoLastMessage(sessionId, server.getHandlerContext()),
+        regenerateResponse: (sessionId) => {
+          let hubChain: Promise<void> = Promise.resolve();
+          const session = server
+            .getHandlerContext()
+            .sessions.get(sessionId);
+          const sendEvent = (event: ServerMessage) => {
+            // Skip state-signal events only when the session has an
+            // onStateSignal listener wired (set in conversation-routes.ts),
+            // since that listener already publishes them to the hub.
+            // Without the listener (e.g. IPC-originated sessions regenerated
+            // via HTTP), we must let these events through to avoid silent loss.
+            if (
+              session?.hasStateSignalListener &&
+              "type" in event &&
+              (event.type === "assistant_activity_state" ||
+                event.type === "confirmation_state_changed")
+            ) {
+              return;
+            }
+            const ae = buildAssistantEvent(
+              DAEMON_INTERNAL_ASSISTANT_ID,
+              event,
+              sessionId,
+            );
+            hubChain = (async () => {
+              await hubChain;
+              try {
+                await assistantEventHub.publish(ae);
+              } catch (err) {
+                log.warn(
+                  { err },
+                  "assistant-events hub subscriber threw during regenerate",
+                );
+              }
+            })();
+          };
+          return regenerateResponse(
+            sessionId,
+            server.getHandlerContext(),
+            sendEvent,
+          );
+        },
+      },
+      getComputerUseDeps: () => {
+        const ctx = server.getHandlerContext();
+        return {
+          cuSessions: ctx.cuSessions,
+          sharedRequestTimestamps: ctx.sharedRequestTimestamps,
+          cuObservationParseSequence: ctx.cuObservationParseSequence,
+          handleRideShotgunStart: async (params) => {
+            // The handler generates its own watchId/sessionId and
+            // sends them via ctx.send as a watch_started message.
+            // We intercept send to capture the IDs before they broadcast.
+            let capturedWatchId = "";
+            let capturedSessionId = "";
+            const interceptCtx = {
+              ...ctx,
+              send: (msg: ServerMessage) => {
+                if (
+                  "type" in msg &&
+                  msg.type === "watch_started" &&
+                  "watchId" in msg &&
+                  "sessionId" in msg
+                ) {
+                  capturedWatchId = (msg as { watchId: string }).watchId;
+                  capturedSessionId = (msg as { sessionId: string }).sessionId;
+                }
+                ctx.send(msg);
+              },
+            };
+            await handleRideShotgunStart(
+              {
+                type: "ride_shotgun_start",
+                durationSeconds: params.durationSeconds,
+                intervalSeconds: params.intervalSeconds,
+                mode: params.mode,
+                targetDomain: params.targetDomain,
+                navigateDomain: params.navigateDomain,
+                autoNavigate: params.autoNavigate,
+              },
+              interceptCtx,
+            );
+            return { watchId: capturedWatchId, sessionId: capturedSessionId };
+          },
+          handleRideShotgunStop: async (watchId) => {
+            await handleRideShotgunStop(
+              { type: "ride_shotgun_stop", watchId },
+              ctx,
+            );
+          },
+          getRideShotgunStatus: (watchId) => {
+            const session = watchSessions.get(watchId);
+            if (!session) return undefined;
+            return {
+              status: session.status,
+              sessionId: session.sessionId,
+              recordingId: session.recordingId,
+              savedRecordingPath: session.savedRecordingPath,
+              bootstrapFailureReason: session.bootstrapFailureReason,
+            };
+          },
+          handleWatchObservation: async (params) => {
+            await handleWatchObservation(
+              {
+                type: "watch_observation",
+                watchId: params.watchId,
+                sessionId: params.sessionId,
+                ocrText: params.ocrText,
+                appName: params.appName,
+                windowTitle: params.windowTitle,
+                bundleIdentifier: params.bundleIdentifier,
+                timestamp: params.timestamp,
+                captureIndex: params.captureIndex,
+                totalExpected: params.totalExpected,
+              },
+              ctx,
+            );
+          },
+        };
+      },
+      getRecordingDeps: () => ({
+        getHandlerContext: () => server.getHandlerContext(),
+      }),
     });
 
     // Inject voice bridge deps BEFORE attempting to start the HTTP server.
@@ -452,8 +575,7 @@ export async function runDaemon(): Promise<void> {
           data: a.dataBase64,
         })),
       deriveDefaultStrictSideEffects: (conversationId) => {
-        const threadType =
-          conversationStore.getConversationThreadType(conversationId);
+        const threadType = getConversationThreadType(conversationId);
         return threadType === "private";
       },
     });
@@ -490,13 +612,13 @@ export async function runDaemon(): Promise<void> {
             // messages array during runAgentLoop.
             const rollback = async (extraMessageIds?: string[]) => {
               try {
-                conversationStore.deleteMessageById(messageId);
+                deleteMessageById(messageId);
               } catch {
                 /* best effort */
               }
               for (const id of extraMessageIds ?? []) {
                 try {
-                  conversationStore.deleteMessageById(id);
+                  deleteMessageById(id);
                 } catch {
                   /* best effort */
                 }
@@ -523,7 +645,7 @@ export async function runDaemon(): Promise<void> {
             // improvement could tag messages with a per-run correlation
             // ID so rollback only targets its own output.
             const preRunMessageIds = new Set(
-              conversationStore.getMessages(conversationId).map((m) => m.id),
+              getMessages(conversationId).map((m) => m.id),
             );
 
             let agentLoopError: string | undefined;
@@ -553,8 +675,7 @@ export async function runDaemon(): Promise<void> {
             // the pre-run snapshot. This captures all messages added to the
             // conversation during the loop window, which may include messages
             // from concurrent pointer events (see over-capture caveat above).
-            const postRunMessages =
-              conversationStore.getMessages(conversationId);
+            const postRunMessages = getMessages(conversationId);
             const createdMessageIds = postRunMessages
               .filter((m) => !preRunMessageIds.has(m.id) && m.id !== messageId)
               .map((m) => m.id);
@@ -621,7 +742,6 @@ export async function runDaemon(): Promise<void> {
 
     void hookManager.trigger("daemon-start", {
       pid: process.pid,
-      socketPath: getSocketPath(),
     });
 
     // Download embedding runtime in background (non-blocking).
@@ -697,13 +817,6 @@ export async function runDaemon(): Promise<void> {
   } catch (err) {
     log.error({ err }, "Daemon startup failed — cleaning up");
     cleanupPidFileIfOwner(process.pid);
-    if (socketCreated) {
-      try {
-        removeSocketFile(getSocketPath());
-      } catch {
-        // Best-effort socket cleanup
-      }
-    }
     throw err;
   }
 }

package/src/daemon/main.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 process.title = "vellum-daemon";
+
 import * as Sentry from "@sentry/node";
 
 import { getLogger } from "../util/logger.js";

package/src/daemon/{ipc-contract.ts → message-protocol.ts}

@@ -1,128 +1,128 @@
 /**
- * IPC Contract -- barrel re-export.
+ * Message Protocol -- message types and serialization.
  *
- * All message types are defined in domain files under ./ipc-contract/.
+ * All message types are defined in domain files under ./message-types/.
  * Each domain file exports `_<Domain>ClientMessages` and/or
  * `_<Domain>ServerMessages` type aliases. This file composes those
  * into the aggregate ClientMessage and ServerMessage unions.
  *
- * To add a new IPC message type:
+ * To add a new message type:
  *   1. Define its interface in the appropriate domain file.
  *   2. Add it to that file's _<Domain>ClientMessages or _<Domain>ServerMessages.
  * No changes needed here unless you're adding an entirely new domain file.
  */
 
 // Re-export domain modules (all individual types remain importable)
-export * from "./ipc-contract/apps.js";
-export * from "./ipc-contract/browser.js";
-export * from "./ipc-contract/computer-use.js";
-export * from "./ipc-contract/contacts.js";
-export * from "./ipc-contract/diagnostics.js";
-export * from "./ipc-contract/documents.js";
-export * from "./ipc-contract/guardian-actions.js";
-export * from "./ipc-contract/inbox.js";
-export * from "./ipc-contract/integrations.js";
-export * from "./ipc-contract/memory.js";
-export * from "./ipc-contract/messages.js";
-export * from "./ipc-contract/notifications.js";
-export * from "./ipc-contract/pairing.js";
-export * from "./ipc-contract/schedules.js";
-export * from "./ipc-contract/sessions.js";
-export * from "./ipc-contract/settings.js";
-export * from "./ipc-contract/shared.js";
-export * from "./ipc-contract/skills.js";
-export * from "./ipc-contract/subagents.js";
-export * from "./ipc-contract/surfaces.js";
-export * from "./ipc-contract/trust.js";
-export * from "./ipc-contract/work-items.js";
-export * from "./ipc-contract/workspace.js";
+export * from "./message-types/apps.js";
+export * from "./message-types/browser.js";
+export * from "./message-types/computer-use.js";
+export * from "./message-types/contacts.js";
+export * from "./message-types/diagnostics.js";
+export * from "./message-types/documents.js";
+export * from "./message-types/guardian-actions.js";
+export * from "./message-types/inbox.js";
+export * from "./message-types/integrations.js";
+export * from "./message-types/memory.js";
+export * from "./message-types/messages.js";
+export * from "./message-types/notifications.js";
+export * from "./message-types/pairing.js";
+export * from "./message-types/schedules.js";
+export * from "./message-types/sessions.js";
+export * from "./message-types/settings.js";
+export * from "./message-types/shared.js";
+export * from "./message-types/skills.js";
+export * from "./message-types/subagents.js";
+export * from "./message-types/surfaces.js";
+export * from "./message-types/trust.js";
+export * from "./message-types/work-items.js";
+export * from "./message-types/workspace.js";
 
 // Import domain-level union aliases for composition
 import type {
   _AppsClientMessages,
   _AppsServerMessages,
-} from "./ipc-contract/apps.js";
+} from "./message-types/apps.js";
 import type {
   _BrowserClientMessages,
   _BrowserServerMessages,
-} from "./ipc-contract/browser.js";
+} from "./message-types/browser.js";
 import type {
   _ComputerUseClientMessages,
   _ComputerUseServerMessages,
-} from "./ipc-contract/computer-use.js";
+} from "./message-types/computer-use.js";
 import type {
   _ContactsClientMessages,
   _ContactsServerMessages,
-} from "./ipc-contract/contacts.js";
+} from "./message-types/contacts.js";
 import type {
   _DiagnosticsClientMessages,
   _DiagnosticsServerMessages,
-} from "./ipc-contract/diagnostics.js";
+} from "./message-types/diagnostics.js";
 import type {
   _DocumentsClientMessages,
   _DocumentsServerMessages,
-} from "./ipc-contract/documents.js";
+} from "./message-types/documents.js";
 import type {
   _GuardianActionsClientMessages,
   _GuardianActionsServerMessages,
-} from "./ipc-contract/guardian-actions.js";
+} from "./message-types/guardian-actions.js";
 import type {
   _InboxClientMessages,
   _InboxServerMessages,
-} from "./ipc-contract/inbox.js";
+} from "./message-types/inbox.js";
 import type {
   _IntegrationsClientMessages,
   _IntegrationsServerMessages,
-} from "./ipc-contract/integrations.js";
-import type { _MemoryServerMessages } from "./ipc-contract/memory.js";
+} from "./message-types/integrations.js";
+import type { _MemoryServerMessages } from "./message-types/memory.js";
 import type {
   _MessagesClientMessages,
   _MessagesServerMessages,
-} from "./ipc-contract/messages.js";
+} from "./message-types/messages.js";
 import type {
   _NotificationsClientMessages,
   _NotificationsServerMessages,
-} from "./ipc-contract/notifications.js";
+} from "./message-types/notifications.js";
 import type {
   _PairingClientMessages,
   _PairingServerMessages,
-} from "./ipc-contract/pairing.js";
+} from "./message-types/pairing.js";
 import type {
   _SchedulesClientMessages,
   _SchedulesServerMessages,
-} from "./ipc-contract/schedules.js";
+} from "./message-types/schedules.js";
 import type {
   _SessionsClientMessages,
   _SessionsServerMessages,
-} from "./ipc-contract/sessions.js";
+} from "./message-types/sessions.js";
 import type {
   _SettingsClientMessages,
   _SettingsServerMessages,
-} from "./ipc-contract/settings.js";
+} from "./message-types/settings.js";
 import type {
   _SkillsClientMessages,
   _SkillsServerMessages,
-} from "./ipc-contract/skills.js";
+} from "./message-types/skills.js";
 import type {
   _SubagentsClientMessages,
   _SubagentsServerMessages,
-} from "./ipc-contract/subagents.js";
+} from "./message-types/subagents.js";
 import type {
   _SurfacesClientMessages,
   _SurfacesServerMessages,
-} from "./ipc-contract/surfaces.js";
+} from "./message-types/surfaces.js";
 import type {
   _TrustClientMessages,
   _TrustServerMessages,
-} from "./ipc-contract/trust.js";
+} from "./message-types/trust.js";
 import type {
   _WorkItemsClientMessages,
   _WorkItemsServerMessages,
-} from "./ipc-contract/work-items.js";
+} from "./message-types/work-items.js";
 import type {
   _WorkspaceClientMessages,
   _WorkspaceServerMessages,
-} from "./ipc-contract/workspace.js";
+} from "./message-types/workspace.js";
 
 // === SubagentEvent -- defined here because it references ServerMessage ===
 
@@ -187,7 +187,7 @@ export type ServerMessage =
 
 // === Contract schema ===
 
-export interface IPCContractSchema {
+export interface ContractSchema {
   client: ClientMessage;
   server: ServerMessage;
 }

package/src/daemon/{ipc-contract → message-types}/computer-use.ts

@@ -2,7 +2,6 @@
 
 import type {
   CommandIntent,
-  IpcBlobRef,
   UserMessageAttachment,
 } from "./shared.js";
 
@@ -44,8 +43,6 @@ export interface CuObservation {
   captureDisplayId?: number;
   executionResult?: string;
   executionError?: string;
-  axTreeBlob?: IpcBlobRef;
-  screenshotBlob?: IpcBlobRef;
   /** Free-form guidance from the user, injected mid-turn to steer the agent. */
   userGuidance?: string;
 }

package/src/daemon/{ipc-contract → message-types}/diagnostics.ts

@@ -14,12 +14,6 @@ export interface EnvVarsRequest {
   type: "env_vars_request";
 }
 
-export interface IpcBlobProbe {
-  type: "ipc_blob_probe";
-  probeId: string;
-  nonceSha256: string;
-}
-
 export interface DictationRequest {
   type: "dictation_request";
   transcription: string;
@@ -41,14 +35,6 @@ export interface EnvVarsResponse {
   vars: Record<string, string>;
 }
 
-export interface IpcBlobProbeResult {
-  type: "ipc_blob_probe_result";
-  probeId: string;
-  ok: boolean;
-  observedNonceSha256?: string;
-  reason?: string;
-}
-
 export interface DictationResponse {
   type: "dictation_response";
   text: string;
@@ -63,11 +49,9 @@ export interface DictationResponse {
 export type _DiagnosticsClientMessages =
   | DiagnosticsExportRequest
   | EnvVarsRequest
-  | IpcBlobProbe
   | DictationRequest;
 
 export type _DiagnosticsServerMessages =
   | DiagnosticsExportResponse
   | EnvVarsResponse
-  | IpcBlobProbeResult
   | DictationResponse;