@vellumai/assistant 0.8.3 → 0.8.5

package/src/memory/db-async-query.ts

@@ -0,0 +1,214 @@
+/**
+ * Run a SQL statement asynchronously, without blocking the daemon's
+ * main event loop.
+ *
+ * `bun:sqlite` is synchronous, so any long-running statement on the
+ * shared in-process connection stalls the event loop for the full
+ * duration of the statement. For multi-minute operations like `VACUUM`
+ * on a multi-GB database, this stalls every other piece of I/O —
+ * including the healthz handler — and on platform that has been
+ * observed to fail liveness probes and crashloop the pod.
+ *
+ * Backend selection:
+ *   1. **`sqlite3` CLI subprocess (preferred).** Spawn a child process
+ *      that opens its own SQLite connection, runs the statement, and
+ *      exits. The daemon's event loop is free for the full duration.
+ *      SQLite's own file-locking arbitrates between the subprocess and
+ *      the still-running in-process connection.
+ *   2. **In-process `bun:sqlite` (fallback).** Synchronous, blocking.
+ *      Only fires when no `sqlite3` binary is on the host. This is the
+ *      same behavior the daemon had before this abstraction existed,
+ *      and is acceptable on desktop where no liveness probe is going to
+ *      kill the process for a long stall.
+ *
+ * Use this for statements known to be slow (`VACUUM`, `ANALYZE`,
+ * `PRAGMA optimize`, large bulk `DELETE`/`UPDATE`). Fast queries (a few
+ * ms) should keep using the in-process drizzle / `bun:sqlite` handle
+ * directly — the subprocess overhead would dominate.
+ */
+import { getLogger } from "../util/logger.js";
+import { getDbPath } from "../util/platform.js";
+import { findSqlite3 } from "../util/sqlite3-runtime.js";
+import { getSqlite } from "./db-connection.js";
+
+const log = getLogger("db-async-query");
+
+/**
+ * Default wall-clock cap for an async statement. A real `VACUUM` on a
+ * multi-GB database can legitimately take many minutes; the cap is
+ * here to bound a runaway subprocess (e.g. one stuck on a stale file
+ * lock). Override per call via `runAsyncSqlite(sql, { timeoutMs })`.
+ */
+const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
+
+export type AsyncSqliteBackend = "sqlite3-cli" | "in-process-blocking";
+
+export interface AsyncSqliteResult {
+  ok: boolean;
+  backend: AsyncSqliteBackend;
+  error: string | null;
+  elapsedMs: number;
+  stdout?: string;
+  stderr?: string;
+  timedOut?: boolean;
+}
+
+export interface RunAsyncSqliteOptions {
+  /** Override the default 1 h subprocess timeout. */
+  timeoutMs?: number;
+  /**
+   * Force a specific backend. Test-only; production callers should let
+   * the runtime pick.
+   */
+  forceBackend?: AsyncSqliteBackend;
+}
+
+let warnedAboutFallback = false;
+
+export async function runAsyncSqlite(
+  sql: string,
+  options: RunAsyncSqliteOptions = {},
+): Promise<AsyncSqliteResult> {
+  const forced = options.forceBackend;
+  const sqlite3Path =
+    forced === "in-process-blocking" ? undefined : findSqlite3();
+
+  if (sqlite3Path && forced !== "in-process-blocking") {
+    return runViaCli(sqlite3Path, sql, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  }
+
+  if (!warnedAboutFallback) {
+    warnedAboutFallback = true;
+    log.warn(
+      "No sqlite3 CLI found on host — falling back to in-process blocking " +
+        "execution for slow SQLite statements. Install sqlite3 to keep the " +
+        "event loop responsive during VACUUM and other long operations.",
+    );
+  }
+  return runInProcessBlocking(sql);
+}
+
+/** For tests: reset the once-only fallback warning. */
+export function _resetFallbackWarning(): void {
+  warnedAboutFallback = false;
+}
+
+async function runViaCli(
+  sqlite3Path: string,
+  sql: string,
+  timeoutMs: number,
+): Promise<AsyncSqliteResult> {
+  const startMs = Date.now();
+  const dbPath = getDbPath();
+
+  log.info(
+    { sqlite3Path, dbPath, timeoutMs, sqlPreview: sql.slice(0, 80) },
+    "Running async SQL via sqlite3 CLI subprocess",
+  );
+
+  // Pass the SQL via stdin rather than -cmd so newlines and quoting are
+  // never an issue regardless of the statement complexity.
+  const proc = Bun.spawn({
+    cmd: [sqlite3Path, dbPath],
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  // Write the SQL and close stdin so sqlite3 sees EOF and exits.
+  proc.stdin.write(sql + "\n");
+  await proc.stdin.end();
+
+  // Begin draining the streams immediately so the subprocess never
+  // blocks on a full pipe buffer.
+  const stdoutPromise = new Response(proc.stdout).text();
+  const stderrPromise = new Response(proc.stderr).text();
+
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    proc.kill("SIGKILL");
+  }, timeoutMs);
+  if (typeof timer.unref === "function") timer.unref();
+
+  const exitCode = await proc.exited;
+  clearTimeout(timer);
+
+  const stdout = await stdoutPromise;
+  const stderr = await stderrPromise;
+  const elapsedMs = Date.now() - startMs;
+
+  if (timedOut) {
+    log.error(
+      { timeoutMs, elapsedMs, stderr: stderr.slice(0, 2000) },
+      "Async SQL subprocess timed out — killed",
+    );
+    return {
+      ok: false,
+      backend: "sqlite3-cli",
+      error: `sqlite3 subprocess timed out after ${timeoutMs}ms`,
+      elapsedMs,
+      stdout,
+      stderr,
+      timedOut: true,
+    };
+  }
+  if (exitCode !== 0) {
+    log.error(
+      { exitCode, elapsedMs, stderr: stderr.slice(0, 2000) },
+      "Async SQL subprocess failed",
+    );
+    return {
+      ok: false,
+      backend: "sqlite3-cli",
+      error: `sqlite3 exited with code ${exitCode}: ${stderr.slice(0, 500)}`,
+      elapsedMs,
+      stdout,
+      stderr,
+    };
+  }
+  return {
+    ok: true,
+    backend: "sqlite3-cli",
+    error: null,
+    elapsedMs,
+    stdout,
+    stderr,
+  };
+}
+
+async function runInProcessBlocking(sql: string): Promise<AsyncSqliteResult> {
+  const startMs = Date.now();
+  try {
+    const sqlite = getSqlite();
+    sqlite.exec(sql);
+    // Synthesize `stdout` to match what the CLI backend would emit
+    // when the caller chained `SELECT changes();` at the end of their
+    // SQL. `bun:sqlite`'s `exec()` discards SELECT results, so without
+    // this synthesis, callers that read `stdout` to get the row count
+    // (the prune jobs in cleanup.ts, for one) would see `undefined`
+    // and treat the run as "no rows deleted" — silently dropping the
+    // re-enqueue gate on every fallback host. Captured atomically with
+    // exec (same synchronous slice — no other code can run between
+    // these two lines), so the count is accurate for the SQL we just
+    // ran. Harmless for callers that don't read stdout.
+    const changes = (
+      sqlite.query("SELECT changes() AS c").get() as { c: number }
+    ).c;
+    return {
+      ok: true,
+      backend: "in-process-blocking",
+      error: null,
+      elapsedMs: Date.now() - startMs,
+      stdout: `${changes}\n`,
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      backend: "in-process-blocking",
+      error: message,
+      elapsedMs: Date.now() - startMs,
+    };
+  }
+}

package/src/memory/db-init.ts

@@ -58,6 +58,7 @@ import {
   migrateCanonicalGuardianRequesterChatId,
   migrateCapabilityCardColumns,
   migrateChannelInboundDeliveredSegments,
+  migrateChannelInboundDeliveryAttempts,
   migrateChannelInteractionColumns,
   migrateContactChannelsAccessFields,
   migrateContactChannelsTypeChatIdIndex,
@@ -65,13 +66,16 @@ import {
   migrateContactsNotesColumn,
   migrateContactsRolePrincipal,
   migrateContactsUserFileColumn,
+  migrateConversationCleanedAt,
   migrateConversationForkLineage,
   migrateConversationHostAccess,
   migrateConversationInferenceProfileSession,
+  migrateConversationLastNotifiedProfile,
   migrateConversationsArchivedAt,
   migrateConversationsLastMessageAt,
   migrateConversationsThreadTypeIndex,
   migrateCreateConversationGraphMemoryState,
+  migrateCreateDocumentComments,
   migrateCreateDocumentConversations,
   migrateCreateMemoryGraphNodeEdits,
   migrateCreateMemoryGraphTables,
@@ -96,6 +100,7 @@ import {
   migrateDropSetupSkillIdColumn,
   migrateDropSimplifiedMemory,
   migrateDropUsageCompositeIndexes,
+  migrateExternalConversationBindingChatName,
   migrateExternalConversationBindingThreadId,
   migrateFkCascadeRebuilds,
   migrateGuardianActionFollowup,
@@ -113,15 +118,20 @@ import {
   migrateInviteCodeHashColumn,
   migrateInviteContactId,
   migrateLlmRequestLogAgentLoopExitReason,
+  migrateLlmRequestLogCallSite,
   migrateLlmRequestLogMessageId,
   migrateLlmRequestLogProvider,
   migrateLlmRequestLogsCreatedAtIndex,
+  migrateLlmUsageAddRawUsage,
   migrateLlmUsageAttribution,
   migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
   migrateMemoryRecallLogsQueryContext,
   migrateMemoryRetrospectiveState,
   migrateMemoryV2ActivationLogs,
+  migrateMemoryV2InjectionEvents,
+  migrateMemoryV3AutoEdges,
+  migrateMemoryV3Coactivation,
   migrateMessageBookmarks,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
@@ -144,10 +154,12 @@ import {
   migrateOAuthProvidersScopeSeparator,
   migrateOAuthProvidersTokenAuthMethodDefault,
   migrateOAuthProvidersTokenExchangeBodyFormat,
+  migrateOnboardingEventsPriorAssistants,
   migrateProviderConnectionBaseUrlAndModels,
   migrateProviderConnectionStatusLabel,
   migrateReminderRoutingIntent,
   migrateRemindersToSchedules,
+  migrateRenameCleanedAt,
   migrateRenameConversationTypeColumn,
   migrateRenameCreatedBySessionIdColumns,
   migrateRenameFollowupsThreadIdColumn,
@@ -174,6 +186,7 @@ import {
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
   migrateSlackCompactionWatermark,
+  migrateStripBaseUrlNonOpenaiCompatible,
   migrateStripIntegrationPrefixFromProviderKeys,
   migrateStripPlaceholderSentinelsFromMessages,
   migrateStripThinkingFromConsolidated,
@@ -436,6 +449,19 @@ export function initializeDb(): void {
     migrateProviderConnectionBaseUrlAndModels,
     migrateA2ATasks,
     migrateLlmRequestLogAgentLoopExitReason,
+    migrateCreateDocumentComments,
+    migrateExternalConversationBindingChatName,
+    migrateChannelInboundDeliveryAttempts,
+    migrateMemoryV2InjectionEvents,
+    migrateConversationLastNotifiedProfile,
+    migrateStripBaseUrlNonOpenaiCompatible,
+    migrateOnboardingEventsPriorAssistants,
+    migrateConversationCleanedAt,
+    migrateRenameCleanedAt,
+    migrateLlmUsageAddRawUsage,
+    migrateMemoryV3Coactivation,
+    migrateMemoryV3AutoEdges,
+    migrateLlmRequestLogCallSite,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/db-maintenance.ts

@@ -3,6 +3,7 @@ import { statSync } from "node:fs";
 import { getLogger } from "../util/logger.js";
 import { getDbPath } from "../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
+import { runAsyncSqlite } from "./db-async-query.js";
 import { getSqlite } from "./db-connection.js";
 
 const log = getLogger("db-maintenance");
@@ -11,7 +12,7 @@ const DB_MAINTENANCE_CHECKPOINT_KEY = "db_maintenance:last_run";
 const DB_MAINTENANCE_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 interface DbStats {
-  pageSizeBytes: number;
+  pageSize: number;
   pageCount: number;
   freelistCount: number;
   fileSizeBytes: number | null;
@@ -19,7 +20,7 @@ interface DbStats {
 
 function getDbStats(): DbStats {
   const sqlite = getSqlite();
-  const pageSizeBytes = (
+  const pageSize = (
     sqlite.query("PRAGMA page_size").get() as { page_size: number }
   ).page_size;
   const pageCount = (
@@ -34,10 +35,10 @@ function getDbStats(): DbStats {
   } catch {
     /* non-fatal */
   }
-  return { pageSizeBytes, pageCount, freelistCount, fileSizeBytes };
+  return { pageSize, pageCount, freelistCount, fileSizeBytes };
 }
 
-function runDbMaintenance(): void {
+async function runDbMaintenance(): Promise<void> {
   const before = getDbStats();
   const freelistPct =
     before.pageCount > 0
@@ -54,22 +55,24 @@ function runDbMaintenance(): void {
     "Starting database maintenance",
   );
 
-  try {
-    getSqlite().exec("VACUUM");
-  } catch (err) {
-    log.warn({ err }, "VACUUM failed (non-fatal)");
-    try {
-      getSqlite().exec("PRAGMA optimize");
-    } catch (optErr) {
-      log.warn({ err: optErr }, "PRAGMA optimize failed (non-fatal)");
-    }
-    return;
+  // VACUUM is the long-running one — minutes on a multi-GB DB. PRAGMA
+  // optimize is fast but routed through the same async path for
+  // consistency and to keep both off the main thread when the CLI
+  // backend is available.
+  const vacuumResult = await runAsyncSqlite("VACUUM");
+  if (!vacuumResult.ok) {
+    log.warn(
+      { error: vacuumResult.error, backend: vacuumResult.backend },
+      "VACUUM failed (non-fatal)",
+    );
   }
 
-  try {
-    getSqlite().exec("PRAGMA optimize");
-  } catch (err) {
-    log.warn({ err }, "PRAGMA optimize failed (non-fatal)");
+  const optimizeResult = await runAsyncSqlite("PRAGMA optimize");
+  if (!optimizeResult.ok) {
+    log.warn(
+      { error: optimizeResult.error, backend: optimizeResult.backend },
+      "PRAGMA optimize failed (non-fatal)",
+    );
   }
 
   const after = getDbStats();
@@ -81,17 +84,23 @@ function runDbMaintenance(): void {
 
   log.info(
     {
+      backend: vacuumResult.backend,
+      vacuumOk: vacuumResult.ok,
+      optimizeOk: optimizeResult.ok,
+      vacuumElapsedMs: vacuumResult.elapsedMs,
+      optimizeElapsedMs: optimizeResult.elapsedMs,
       beforePageCount: before.pageCount,
       afterPageCount: after.pageCount,
       reclaimedPages,
-      reclaimedBytes,
+      beforeFileSizeBytes: before.fileSizeBytes,
       afterFileSizeBytes: after.fileSizeBytes,
+      reclaimedBytes,
     },
     "Database maintenance complete",
   );
 }
 
-export function maybeRunDbMaintenance(nowMs = Date.now()): void {
+export async function maybeRunDbMaintenance(nowMs = Date.now()): Promise<void> {
   const lastRun = parseInt(
     getMemoryCheckpoint(DB_MAINTENANCE_CHECKPOINT_KEY) ?? "0",
     10,
@@ -99,7 +108,7 @@ export function maybeRunDbMaintenance(nowMs = Date.now()): void {
   if (nowMs - lastRun < DB_MAINTENANCE_INTERVAL_MS) return;
 
   try {
-    runDbMaintenance();
+    await runDbMaintenance();
   } catch (err) {
     log.error({ err }, "Database maintenance failed unexpectedly");
   }

package/src/memory/delivery-crud.ts

@@ -313,6 +313,47 @@ export function storePayload(
     .run();
 }
 
+/**
+ * Persist the assistant reply row generated for an inbound event so callback
+ * delivery retries target that exact response instead of the latest message in
+ * the conversation.
+ */
+export function storeReplyMessageId(
+  eventId: string,
+  replyMessageId: string,
+): void {
+  const db = getDb();
+  const row = db
+    .select({ rawPayload: channelInboundEvents.rawPayload })
+    .from(channelInboundEvents)
+    .where(eq(channelInboundEvents.id, eventId))
+    .get();
+  if (!row?.rawPayload) return;
+
+  let payload: Record<string, unknown>;
+  try {
+    const parsed = JSON.parse(row.rawPayload) as unknown;
+    if (
+      parsed === null ||
+      typeof parsed !== "object" ||
+      Array.isArray(parsed)
+    ) {
+      return;
+    }
+    payload = parsed as Record<string, unknown>;
+  } catch {
+    return;
+  }
+
+  db.update(channelInboundEvents)
+    .set({
+      rawPayload: JSON.stringify({ ...payload, replyMessageId }),
+      updatedAt: Date.now(),
+    })
+    .where(eq(channelInboundEvents.id, eventId))
+    .run();
+}
+
 /**
  * Clear a previously stored payload. Used when the ingress check
  * detects secret-bearing content — the payload must not remain on disk.

package/src/memory/delivery-status.ts

@@ -6,7 +6,7 @@
  * retryable and dead-lettered events, and replaying dead letters.
  */
 
-import { and, eq, lte } from "drizzle-orm";
+import { and, eq, lte, or } from "drizzle-orm";
 
 import { getDb } from "./db-connection.js";
 import {
@@ -44,6 +44,7 @@ export function acknowledgeDelivery(
   db.update(channelInboundEvents)
     .set({
       deliveryStatus: "delivered",
+      retryAfter: null,
       updatedAt: now,
     })
     .where(eq(channelInboundEvents.id, existing.id))
@@ -61,6 +62,23 @@ export function markProcessed(eventId: string): void {
     .run();
 }
 
+/** Mark an event's outbound callback delivery as complete. */
+export function markDeliveryDelivered(eventId: string): void {
+  const db = getDb();
+  db.update(channelInboundEvents)
+    .set({
+      deliveryStatus: "delivered",
+      retryAfter: null,
+      updatedAt: Date.now(),
+    })
+    .where(eq(channelInboundEvents.id, eventId))
+    .run();
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
 /**
  * Record a processing failure. Classifies the error to decide whether
  * the event should be retried (status='failed') or dead-lettered
@@ -79,7 +97,7 @@ export function recordProcessingFailure(eventId: string, err: unknown): void {
 
   const attempts = (row?.attempts ?? 0) + 1;
   const category = classifyError(err);
-  const errorMsg = err instanceof Error ? err.message : String(err);
+  const errorMsg = errorMessage(err);
 
   if (category === "fatal" || attempts >= RETRY_MAX_ATTEMPTS) {
     db.update(channelInboundEvents)
@@ -107,6 +125,51 @@ export function recordProcessingFailure(eventId: string, err: unknown): void {
   }
 }
 
+/**
+ * Record an outbound callback delivery failure without changing the processing
+ * status. Delivery uses its own retry budget so a turn that needed processing
+ * retries still gets a full delivery retry window.
+ */
+export function recordDeliveryFailure(eventId: string, err: unknown): void {
+  const db = getDb();
+  const now = Date.now();
+
+  const row = db
+    .select({ attempts: channelInboundEvents.deliveryAttempts })
+    .from(channelInboundEvents)
+    .where(eq(channelInboundEvents.id, eventId))
+    .get();
+
+  const attempts = (row?.attempts ?? 0) + 1;
+  const category = classifyError(err);
+  const errorMsg = errorMessage(err);
+
+  if (category === "fatal" || attempts >= RETRY_MAX_ATTEMPTS) {
+    db.update(channelInboundEvents)
+      .set({
+        deliveryStatus: "dead_letter",
+        deliveryAttempts: attempts,
+        lastProcessingError: errorMsg,
+        retryAfter: null,
+        updatedAt: now,
+      })
+      .where(eq(channelInboundEvents.id, eventId))
+      .run();
+  } else {
+    const delay = retryDelayForAttempt(attempts);
+    db.update(channelInboundEvents)
+      .set({
+        deliveryStatus: "failed",
+        deliveryAttempts: attempts,
+        lastProcessingError: errorMsg,
+        retryAfter: now + delay,
+        updatedAt: now,
+      })
+      .where(eq(channelInboundEvents.id, eventId))
+      .run();
+  }
+}
+
 /**
  * Mark an event as failed with a specific error message, bypassing error
  * classification. Use this when the failure reason is known and the event
@@ -180,6 +243,38 @@ export function getRetryableEvents(limit = 20): Array<{
     .all();
 }
 
+/** Fetch callback deliveries eligible for retry without rerunning processing. */
+export function getRetryableDeliveryEvents(limit = 20): Array<{
+  id: string;
+  conversationId: string;
+  messageId: string | null;
+  processingAttempts: number;
+  rawPayload: string | null;
+  deliveredSegmentCount: number;
+}> {
+  const db = getDb();
+  const now = Date.now();
+  return db
+    .select({
+      id: channelInboundEvents.id,
+      conversationId: channelInboundEvents.conversationId,
+      messageId: channelInboundEvents.messageId,
+      processingAttempts: channelInboundEvents.processingAttempts,
+      rawPayload: channelInboundEvents.rawPayload,
+      deliveredSegmentCount: channelInboundEvents.deliveredSegmentCount,
+    })
+    .from(channelInboundEvents)
+    .where(
+      and(
+        eq(channelInboundEvents.processingStatus, "processed"),
+        eq(channelInboundEvents.deliveryStatus, "failed"),
+        lte(channelInboundEvents.retryAfter, now),
+      ),
+    )
+    .limit(limit)
+    .all();
+}
+
 /** Fetch dead-lettered events. */
 export function getDeadLetterEvents(): Array<{
   id: string;
@@ -204,7 +299,15 @@ export function getDeadLetterEvents(): Array<{
       createdAt: channelInboundEvents.createdAt,
     })
     .from(channelInboundEvents)
-    .where(eq(channelInboundEvents.processingStatus, "dead_letter"))
+    .where(
+      or(
+        eq(channelInboundEvents.processingStatus, "dead_letter"),
+        and(
+          eq(channelInboundEvents.processingStatus, "processed"),
+          eq(channelInboundEvents.deliveryStatus, "dead_letter"),
+        ),
+      ),
+    )
     .all();
 }
 
@@ -218,27 +321,50 @@ export function replayDeadLetters(eventIds: string[]): number {
   let count = 0;
   for (const id of eventIds) {
     const existing = db
-      .select({ id: channelInboundEvents.id })
+      .select({
+        id: channelInboundEvents.id,
+        processingStatus: channelInboundEvents.processingStatus,
+        deliveryStatus: channelInboundEvents.deliveryStatus,
+      })
       .from(channelInboundEvents)
       .where(
         and(
           eq(channelInboundEvents.id, id),
-          eq(channelInboundEvents.processingStatus, "dead_letter"),
+          or(
+            eq(channelInboundEvents.processingStatus, "dead_letter"),
+            and(
+              eq(channelInboundEvents.processingStatus, "processed"),
+              eq(channelInboundEvents.deliveryStatus, "dead_letter"),
+            ),
+          ),
         ),
       )
       .get();
     if (!existing) continue;
 
-    db.update(channelInboundEvents)
-      .set({
-        processingStatus: "failed",
-        processingAttempts: 0,
-        lastProcessingError: null,
-        retryAfter: now,
-        updatedAt: now,
-      })
-      .where(eq(channelInboundEvents.id, id))
-      .run();
+    if (existing.processingStatus === "dead_letter") {
+      db.update(channelInboundEvents)
+        .set({
+          processingStatus: "failed",
+          processingAttempts: 0,
+          lastProcessingError: null,
+          retryAfter: now,
+          updatedAt: now,
+        })
+        .where(eq(channelInboundEvents.id, id))
+        .run();
+    } else {
+      db.update(channelInboundEvents)
+        .set({
+          deliveryStatus: "failed",
+          deliveryAttempts: 0,
+          lastProcessingError: null,
+          retryAfter: now,
+          updatedAt: now,
+        })
+        .where(eq(channelInboundEvents.id, id))
+        .run();
+    }
     count++;
   }
   return count;