@vellumai/assistant 0.5.5 → 0.5.7

package/src/daemon/server.ts

@@ -20,13 +20,7 @@ import {
 import { getConfig } from "../config/loader.js";
 import { onContactChange } from "../contacts/contact-events.js";
 import type { CesClient } from "../credential-execution/client.js";
-import { createCesClient } from "../credential-execution/client.js";
-import { isCesToolsEnabled } from "../credential-execution/feature-gates.js";
-import {
-  type CesProcessManager,
-  CesUnavailableError,
-  createCesProcessManager,
-} from "../credential-execution/process-manager.js";
+import type { CesProcessManager } from "../credential-execution/process-manager.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
 import {
@@ -45,7 +39,6 @@ import {
 import { updateMetaFile } from "../memory/conversation-disk-view.js";
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
-import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
 import {
   getFailoverProvider,
@@ -57,13 +50,11 @@ import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { getSigningKeyFingerprint } from "../runtime/auth/token-service.js";
 import { bridgeConfirmationRequestToGuardian } from "../runtime/confirmation-request-guardian-bridge.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
-import { checkIngressForSecrets } from "../security/secret-ingress.js";
 import { registerCancelCallback } from "../signals/cancel.js";
 import { registerConversationUndoCallback } from "../signals/conversation-undo.js";
 import { appendEventToStream } from "../signals/event-stream.js";
 import { registerUserMessageCallback } from "../signals/user-message.js";
 import { getSubagentManager } from "../subagent/index.js";
-import { IngressBlockedError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import {
   getSandboxWorkingDir,
@@ -253,7 +244,6 @@ export class DaemonServer {
   private conversationOptions = new Map<string, ConversationCreateOptions>();
   private conversationCreating = new Map<string, Promise<Conversation>>();
   private sharedRequestTimestamps: number[] = [];
-  private httpPort: number | undefined;
   private unsubscribeContactChange: (() => void) | null = null;
   private evictor: ConversationEvictor;
   private _hubChain: Promise<void> = Promise.resolve();
@@ -262,8 +252,8 @@ export class DaemonServer {
   private configWatcher = new ConfigWatcher();
 
   // CES (Credential Execution Service) — process-level singleton.
-  // The CES sidecar accepts exactly one bootstrap connection, so we must
-  // hold that connection at the server level rather than per-conversation.
+  // Lifecycle is managed by startCesProcess() in lifecycle.ts; the server
+  // receives the result via setCes().
   private cesProcessManager?: CesProcessManager;
   private cesClientPromise?: Promise<CesClient | undefined>;
   private cesInitAbortController?: AbortController;
@@ -274,6 +264,31 @@ export class DaemonServer {
    */
   assistantId: string = DAEMON_INTERNAL_ASSISTANT_ID;
 
+  /**
+   * Inject the CES client and process manager from the caller (lifecycle.ts).
+   * Must be called before start().
+   */
+  setCes(result: {
+    client: CesClient | undefined;
+    processManager: CesProcessManager | undefined;
+    clientPromise: Promise<CesClient | undefined> | undefined;
+    abortController: AbortController | undefined;
+  }): void {
+    this.cesClientRef = result.client;
+    this.cesProcessManager = result.processManager;
+    this.cesInitAbortController = result.abortController;
+
+    // Wrap the external promise so that cesClientRef stays in sync once the
+    // handshake completes — the async work runs in lifecycle.ts but the
+    // server needs the resolved client reference for getCesClient().
+    if (result.clientPromise) {
+      this.cesClientPromise = result.clientPromise.then((client) => {
+        this.cesClientRef = client;
+        return client;
+      });
+    }
+  }
+
   /**
    * Return the CES client reference (if available).
    * Used by routes that need to push updates to CES (e.g. secret-routes).
@@ -538,73 +553,6 @@ export class DaemonServer {
       this.broadcast({ type: "contacts_changed" });
     });
 
-    // CES lifecycle — start the CES process and perform the RPC handshake
-    // once at server level. The managed sidecar accepts exactly one bootstrap
-    // connection, so this must be a process-level singleton.
-    if (isCesToolsEnabled(config)) {
-      const pm = createCesProcessManager({ assistantConfig: config });
-      this.cesProcessManager = pm;
-      const abortController = new AbortController();
-      this.cesInitAbortController = abortController;
-      this.cesClientPromise = (async () => {
-        try {
-          const transport = await pm.start();
-          if (abortController.signal.aborted) {
-            throw new Error("CES initialization aborted during shutdown");
-          }
-          const client = createCesClient(transport);
-          this.cesClientRef = client;
-          // Resolve the assistant API key so CES can use it for platform
-          // credential materialisation. In managed mode the key is provisioned
-          // after hatch and stored in the credential store — CES can't read
-          // the env var, so we pass it via the handshake.
-          const proxyCtx = await resolveManagedProxyContext();
-          const { accepted, reason } = await client.handshake(
-            proxyCtx.assistantApiKey
-              ? { assistantApiKey: proxyCtx.assistantApiKey }
-              : undefined,
-          );
-          if (abortController.signal.aborted) {
-            client.close();
-            throw new Error("CES initialization aborted during shutdown");
-          }
-          if (accepted) {
-            log.info(
-              "CES client initialized and handshake accepted (server-level)",
-            );
-            return client;
-          }
-          log.warn(
-            { reason },
-            "CES handshake rejected — CES tools will be unavailable",
-          );
-          client.close();
-          this.cesClientRef = undefined;
-          await pm.stop();
-          // Reset so next session can retry initialization
-          this.cesClientPromise = undefined;
-          return undefined;
-        } catch (err) {
-          if (err instanceof CesUnavailableError) {
-            log.info(
-              { reason: err.message },
-              "CES is not available — CES tools will be unavailable",
-            );
-          } else {
-            log.warn(
-              { error: err instanceof Error ? err.message : String(err) },
-              "Failed to initialize CES client — CES tools will be unavailable",
-            );
-          }
-          await pm.stop().catch(() => {});
-          // Reset so next session can retry initialization
-          this.cesClientRef = undefined;
-          this.cesClientPromise = undefined;
-          return undefined;
-        }
-      })();
-    }
-
     log.info("DaemonServer started (HTTP-only mode)");
   }
 
@@ -656,11 +604,9 @@ export class DaemonServer {
 
   // ── Conversation management ──────────────────────────────────────────────
 
-  setHttpPort(port: number): void {
-    this.httpPort = port;
+  broadcastStatus(): void {
     this.broadcast({
-      type: "daemon_status",
-      httpPort: port,
+      type: "assistant_status",
       version: daemonVersion,
       keyFingerprint: getSigningKeyFingerprint(),
     });
@@ -884,14 +830,6 @@ export class DaemonServer {
       filePath?: string;
     }[];
   }> {
-    const ingressCheck = checkIngressForSecrets(content);
-    if (ingressCheck.blocked) {
-      throw new IngressBlockedError(
-        ingressCheck.userNotice!,
-        ingressCheck.detectedTypes,
-      );
-    }
-
     const conversation = await this.getOrCreateConversation(
       conversationId,
       options,

package/src/events/domain-events.ts

@@ -25,7 +25,8 @@ export interface ToolDomainEvents {
       | "always_allow_high_risk"
       | "deny"
       | "always_deny"
-      | "temporary_override";
+      | "temporary_override"
+      | "dangerously_skip_permissions";
     riskLevel: string;
     decidedAtMs: number;
   };

package/src/followups/followup-store.ts

@@ -1,4 +1,4 @@
-import { and, desc, eq, lte, or } from "drizzle-orm";
+import { and, asc, eq, lte, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../memory/db.js";
@@ -217,7 +217,10 @@ export function getPendingAndOverdueFollowUps(): BriefFollowUp[] {
         eq(followups.status, "nudged"),
       ),
     )
-    .orderBy(desc(followups.expectedResponseBy))
+    .orderBy(
+      sql`CASE WHEN ${followups.expectedResponseBy} IS NULL THEN 1 ELSE 0 END`,
+      asc(followups.expectedResponseBy),
+    )
     .all();
 
   return rows as BriefFollowUp[];

package/src/inbound/platform-callback-registration.ts

@@ -2,7 +2,7 @@
  * Platform callback route registration for containerized deployments.
  *
  * When the assistant daemon runs inside a container (IS_CONTAINERIZED=true)
- * with a configured PLATFORM_BASE_URL and PLATFORM_ASSISTANT_ID, external
+ * with a configured VELLUM_PLATFORM_URL and PLATFORM_ASSISTANT_ID, external
  * service callbacks (Twilio webhooks, OAuth redirects, Telegram webhooks, etc.)
  * must route through the platform's gateway proxy instead of hitting the
  * assistant directly.
@@ -12,7 +12,7 @@
  * webhooks to the correct containerized assistant instance.
  *
  * The platform endpoint is:
- *   POST {PLATFORM_BASE_URL}/v1/internal/gateway/callback-routes/register/
+ *   POST {VELLUM_PLATFORM_URL}/v1/internal/gateway/callback-routes/register/
  *
  * It accepts { assistant_id, callback_path, type } and returns a stable
  * callback_url that external services should use.
@@ -30,7 +30,7 @@ const log = getLogger("platform-callback-registration");
 
 /**
  * Whether the daemon should register callback routes with the platform.
- * True when IS_CONTAINERIZED, PLATFORM_BASE_URL, and PLATFORM_ASSISTANT_ID
+ * True when IS_CONTAINERIZED, VELLUM_PLATFORM_URL, and PLATFORM_ASSISTANT_ID
  * are all set. Intentionally does **not** require the managed proxy API key
  * so that callback-only flows (OAuth transport, Telegram/Twilio callback
  * registration) work during partial bootstrap before the key is injected.

package/src/instrument.ts

@@ -39,14 +39,17 @@ function redactObject(obj: unknown): unknown {
 }
 
 /**
- * Call after dotenv has loaded so SENTRY_DSN is available.
- * Always initializes Sentry to capture early startup crashes. If the user
- * later opts out via the sendDiagnostics config key (or VELLUM_DEV=1),
- * call closeSentry() after config is loaded to stop future event capturing.
+ * Call after dotenv has loaded so SENTRY_DSN_ASSISTANT is available.
+ * Initializes Sentry when the DSN is set; no-ops when empty/unset so
+ * local dev builds don't send crash reports. If the user later opts out
+ * via the sendDiagnostics config key (or VELLUM_DEV=1), call closeSentry()
+ * after config is loaded to stop future event capturing.
  */
 export function initSentry(): void {
+  const dsn = getSentryDsn();
+  if (!dsn) return;
   Sentry.init({
-    dsn: getSentryDsn(),
+    dsn,
     release: `vellum-assistant@${APP_VERSION}`,
     dist: COMMIT_SHA,
     environment: APP_VERSION === "0.0.0-dev" ? "development" : "production",

package/src/memory/conversation-crud.ts

@@ -47,18 +47,13 @@ import {
   conversations,
   conversationStarters,
   llmRequestLogs,
-  memoryChunks,
   memoryEmbeddings,
-  memoryEpisodes,
   memoryItems,
   memoryItemSources,
-  memoryObservations,
   memorySegments,
   memorySummaries,
   messageAttachments,
   messages,
-  openLoops,
-  timeContexts,
   toolInvocations,
 } from "./schema.js";
 import { cancelPendingJobsForConversation } from "./task-memory-cleanup.js";
@@ -177,9 +172,6 @@ export interface ConversationRow {
   forkParentMessageId: string | null;
   isAutoTitle: number;
   scheduleJobId: string | null;
-  memoryReducedThroughMessageId: string | null;
-  memoryDirtyTailSinceMessageId: string | null;
-  memoryLastReducedAt: number | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -205,9 +197,6 @@ export const parseConversation = createRowMapper<
   forkParentMessageId: "forkParentMessageId",
   isAutoTitle: "isAutoTitle",
   scheduleJobId: "scheduleJobId",
-  memoryReducedThroughMessageId: "memoryReducedThroughMessageId",
-  memoryDirtyTailSinceMessageId: "memoryDirtyTailSinceMessageId",
-  memoryLastReducedAt: "memoryLastReducedAt",
 });
 
 export interface MessageRow {
@@ -555,9 +544,6 @@ export function deleteConversation(id: string): DeletedMemoryIds {
     segmentIds: [],
     orphanedItemIds: [],
     deletedSummaryIds: [],
-    deletedObservationIds: [],
-    deletedChunkIds: [],
-    deletedEpisodeIds: [],
   };
 
   // Capture createdAt before the transaction deletes the row — needed to
@@ -711,75 +697,6 @@ export function deleteConversation(id: string): DeletedMemoryIds {
       tx.delete(conversationStarters)
         .where(eq(conversationStarters.scopeId, memoryScopeId))
         .run();
-
-      // Sweep brief-state tables scoped to this private conversation.
-      tx.delete(timeContexts)
-        .where(eq(timeContexts.scopeId, memoryScopeId))
-        .run();
-      tx.delete(openLoops).where(eq(openLoops.scopeId, memoryScopeId)).run();
-    }
-
-    // Collect archive table IDs before the cascade delete removes them.
-    // Observations and episodes reference conversations with ON DELETE CASCADE,
-    // and chunks cascade from observations.
-    const observationRows = tx
-      .select({ id: memoryObservations.id })
-      .from(memoryObservations)
-      .where(eq(memoryObservations.conversationId, id))
-      .all();
-    const observationIds = observationRows.map((r) => r.id);
-
-    if (observationIds.length > 0) {
-      // Collect chunk IDs before observations cascade-delete them.
-      const chunkRows = tx
-        .select({ id: memoryChunks.id })
-        .from(memoryChunks)
-        .where(inArray(memoryChunks.observationId, observationIds))
-        .all();
-      const chunkIds = chunkRows.map((r) => r.id);
-
-      // Clean up embeddings for chunks.
-      if (chunkIds.length > 0) {
-        tx.delete(memoryEmbeddings)
-          .where(
-            and(
-              eq(memoryEmbeddings.targetType, "chunk"),
-              inArray(memoryEmbeddings.targetId, chunkIds),
-            ),
-          )
-          .run();
-        result.deletedChunkIds.push(...chunkIds);
-      }
-
-      // Clean up embeddings for observations.
-      tx.delete(memoryEmbeddings)
-        .where(
-          and(
-            eq(memoryEmbeddings.targetType, "observation"),
-            inArray(memoryEmbeddings.targetId, observationIds),
-          ),
-        )
-        .run();
-      result.deletedObservationIds.push(...observationIds);
-    }
-
-    const episodeRows = tx
-      .select({ id: memoryEpisodes.id })
-      .from(memoryEpisodes)
-      .where(eq(memoryEpisodes.conversationId, id))
-      .all();
-    const episodeIds = episodeRows.map((r) => r.id);
-
-    if (episodeIds.length > 0) {
-      tx.delete(memoryEmbeddings)
-        .where(
-          and(
-            eq(memoryEmbeddings.targetType, "episode"),
-            inArray(memoryEmbeddings.targetId, episodeIds),
-          ),
-        )
-        .run();
-      result.deletedEpisodeIds.push(...episodeIds);
     }
 
     tx.delete(conversations).where(eq(conversations.id, id)).run();
@@ -1005,9 +922,6 @@ export function purgePrivateConversations(): {
         segmentIds: [],
         orphanedItemIds: [],
         deletedSummaryIds: [],
-        deletedObservationIds: [],
-        deletedChunkIds: [],
-        deletedEpisodeIds: [],
       },
     };
   }
@@ -1015,18 +929,12 @@ export function purgePrivateConversations(): {
   const allSegmentIds: string[] = [];
   const allOrphanedItemIds: string[] = [];
   const allDeletedSummaryIds: string[] = [];
-  const allDeletedObservationIds: string[] = [];
-  const allDeletedChunkIds: string[] = [];
-  const allDeletedEpisodeIds: string[] = [];
 
   for (const conv of privateConvs) {
     const deleted = deleteConversation(conv.id);
     allSegmentIds.push(...deleted.segmentIds);
     allOrphanedItemIds.push(...deleted.orphanedItemIds);
     allDeletedSummaryIds.push(...deleted.deletedSummaryIds);
-    allDeletedObservationIds.push(...deleted.deletedObservationIds);
-    allDeletedChunkIds.push(...deleted.deletedChunkIds);
-    allDeletedEpisodeIds.push(...deleted.deletedEpisodeIds);
   }
 
   return {
@@ -1035,9 +943,6 @@ export function purgePrivateConversations(): {
       segmentIds: allSegmentIds,
       orphanedItemIds: allOrphanedItemIds,
       deletedSummaryIds: allDeletedSummaryIds,
-      deletedObservationIds: allDeletedObservationIds,
-      deletedChunkIds: allDeletedChunkIds,
-      deletedEpisodeIds: allDeletedEpisodeIds,
     },
   };
 }
@@ -1120,13 +1025,6 @@ export async function addMessage(
       throw err;
     }
   }
-
-  // Mark the conversation dirty for delayed memory reduction. This runs
-  // after the insert transaction succeeds so the reducer knows which
-  // conversations have unprocessed messages. The helper preserves the
-  // earliest unreduced boundary (no-op when already dirty).
-  markConversationMemoryDirty(conversationId, messageId);
-
   const message = {
     id: messageId,
     conversationId,
@@ -1431,9 +1329,6 @@ export interface DeletedMemoryIds {
   segmentIds: string[];
   orphanedItemIds: string[];
   deletedSummaryIds: string[];
-  deletedObservationIds: string[];
-  deletedChunkIds: string[];
-  deletedEpisodeIds: string[];
 }
 
 export interface WipeConversationResult extends DeletedMemoryIds {
@@ -1507,9 +1402,6 @@ export function deleteMessageById(messageId: string): DeletedMemoryIds {
     segmentIds: [],
     orphanedItemIds: [],
     deletedSummaryIds: [],
-    deletedObservationIds: [],
-    deletedChunkIds: [],
-    deletedEpisodeIds: [],
   };
 
   // Collect attachment IDs linked to this message before cascade-delete
@@ -1598,134 +1490,6 @@ export function deleteMessageById(messageId: string): DeletedMemoryIds {
   return result;
 }
 
-/**
- * Mark a conversation as having unreduced messages starting from the given
- * message. Sets `memoryDirtyTailSinceMessageId` only when it is currently
- * null so the earliest unreduced boundary is preserved across multiple
- * messages — later messages must not clobber the original dirty marker.
- *
- * Also upserts a pending `reduce_conversation_memory` job scheduled at
- * `now + idleDelayMs`. If a pending job for this conversation already exists,
- * its `runAfter` is pushed forward (rescheduled) so the reducer waits for
- * the full idle window after the *latest* message — avoiding premature runs
- * while the user is still actively typing.
- */
-export function markConversationMemoryDirty(
-  conversationId: string,
-  messageId: string,
-): void {
-  const db = getDb();
-  db.update(conversations)
-    .set({ memoryDirtyTailSinceMessageId: messageId })
-    .where(
-      and(
-        eq(conversations.id, conversationId),
-        isNull(conversations.memoryDirtyTailSinceMessageId),
-      ),
-    )
-    .run();
-
-  // Schedule (or reschedule) a deferred reducer job for this conversation.
-  scheduleReducerJob(conversationId);
-}
-
-/**
- * Upsert a pending `reduce_conversation_memory` job for the given
- * conversation, scheduled `idleDelayMs` from now. If one already exists in
- * pending state, its `runAfter` is pushed forward to restart the idle timer.
- * This ensures exactly one pending reducer job per conversation — new
- * messages reschedule rather than duplicate.
- */
-export function scheduleReducerJob(
-  conversationId: string,
-  runAfter?: number,
-): void {
-  const idleDelayMs = getReducerIdleDelayMs();
-  const scheduledAt = runAfter ?? Date.now() + idleDelayMs;
-
-  const existing = rawGet<{ id: string; status: string }>(
-    `SELECT id, status FROM memory_jobs
-     WHERE type = 'reduce_conversation_memory'
-       AND json_extract(payload, '$.conversationId') = ?
-       AND status = 'pending'
-     LIMIT 1`,
-    conversationId,
-  );
-
-  if (existing) {
-    // Reschedule: push runAfter forward so the idle timer resets.
-    rawRun(
-      `UPDATE memory_jobs SET run_after = ?, updated_at = ? WHERE id = ?`,
-      scheduledAt,
-      Date.now(),
-      existing.id,
-    );
-  } else {
-    enqueueMemoryJob(
-      "reduce_conversation_memory",
-      { conversationId },
-      scheduledAt,
-    );
-  }
-}
-
-/**
- * Startup sweep: find conversations that are marked dirty and whose tail
- * message is already older than the idle delay. For these conversations the
- * reducer should have run but didn't (daemon was down). Enqueue immediate
- * reducer jobs for each so they are processed on the next worker tick.
- *
- * Conversations whose tail is still within the idle window are skipped —
- * the normal `markConversationMemoryDirty` path will schedule them when
- * new messages arrive (or on the next conversation interaction).
- *
- * Returns the number of jobs enqueued.
- */
-export function sweepStaleReducerJobs(): number {
-  const idleDelayMs = getReducerIdleDelayMs();
-  const cutoff = Date.now() - idleDelayMs;
-
-  // Find dirty conversations whose latest message is older than the idle
-  // window AND that don't already have a pending reducer job.
-  const stale = rawAll<{ conversationId: string }>(
-    `SELECT c.id AS conversationId
-     FROM conversations c
-     WHERE c.memory_dirty_tail_since_message_id IS NOT NULL
-       AND NOT EXISTS (
-         SELECT 1 FROM memory_jobs mj
-         WHERE mj.type = 'reduce_conversation_memory'
-           AND json_extract(mj.payload, '$.conversationId') = c.id
-           AND mj.status IN ('pending', 'running')
-       )
-       AND (
-         SELECT MAX(m.created_at) FROM messages m
-         WHERE m.conversation_id = c.id
-       ) <= ?`,
-    cutoff,
-  );
-
-  for (const { conversationId } of stale) {
-    enqueueMemoryJob("reduce_conversation_memory", { conversationId });
-  }
-
-  return stale.length;
-}
-
-function getReducerIdleDelayMs(): number {
-  // Some test suites mock getConfig() with partial objects; fall back to the
-  // schema default so reducer scheduling stays stable outside full config load.
-  const config = getConfig() as {
-    memory?: {
-      simplified?: {
-        reducer?: {
-          idleDelayMs?: number;
-        };
-      };
-    };
-  };
-  return config.memory?.simplified?.reducer?.idleDelayMs ?? 30_000;
-}
-
 export function setConversationOriginChannelIfUnset(
   conversationId: string,
   channel: ChannelId,