@vellumai/assistant 0.8.4 → 0.8.6

package/src/memory/conversation-starters-cadence.ts

@@ -9,7 +9,7 @@ import { and, eq, inArray, sql } from "drizzle-orm";
 
 import { getLogger } from "../util/logger.js";
 import { getDb } from "./db-connection.js";
-import { enqueueMemoryJob } from "./jobs-store.js";
+import { enqueueMemoryJob, isMemoryEnabled } from "./jobs-store.js";
 import { rawGet } from "./raw-query.js";
 import { memoryCheckpoints, memoryJobs } from "./schema.js";
 
@@ -20,6 +20,8 @@ const log = getLogger("conversation-starters-cadence");
  * generating a fresh batch of conversation starters.
  */
 export function maybeEnqueueConversationStartersJob(scopeId: string): void {
+  if (!isMemoryEnabled()) return;
+
   const db = getDb();
 
   // Count total active memory items

package/src/memory/conversation-title-service.ts

@@ -331,10 +331,10 @@ function buildTitlePrompt(
   }
 
   if (userMessage) {
-    parts.push(`User: ${userMessage}`);
+    parts.push(`User: ${stripThinkingTags(userMessage)}`);
   }
   if (assistantResponse) {
-    parts.push(`Assistant: ${assistantResponse}`);
+    parts.push(`Assistant: ${stripThinkingTags(assistantResponse)}`);
   }
 
   return parts.join("\n");
@@ -378,12 +378,28 @@ function truncateTitle(title: string): string {
 function normalizeTitle(raw: string): string {
   let title = raw.trim().replace(/^["']|["']$/g, "");
   title = stripMarkdown(title);
+  title = stripThinkingTags(title);
   if (META_FAILURE_TITLES.has(title.toLowerCase())) {
     return "";
   }
   return truncateTitle(title);
 }
 
+/** Strip thinking tags so they don't bleed into generated titles. */
+function stripThinkingTags(text: string): string {
+  return text
+    .replace(/<thinking>[\s\S]*?<\/thinking>/gi, "")
+    .replace(/<thought>[\s\S]*?<\/thought>/gi, "")
+    .replace(/<think>[\s\S]*?<\/think>/gi, "")
+    .replace(/<thought>/gi, "")
+    .replace(/<\/thought>/gi, "")
+    .replace(/<thinking>/gi, "")
+    .replace(/<\/thinking>/gi, "")
+    .replace(/<think>/gi, "")
+    .replace(/<\/think>/gi, "")
+    .replace(/<:[^>]*>/gi, "");
+}
+
 /** Strip common markdown formatting so titles render as plain text. */
 function stripMarkdown(text: string): string {
   return text
@@ -458,7 +474,7 @@ function buildRegenerationPrompt(recentMessages: MessageRow[]): string {
     const text = extractTextForTitle(msg.content);
     if (!text) continue;
     const role = msg.role === "user" ? "User" : "Assistant";
-    parts.push(`${role}: ${text}`);
+    parts.push(`${role}: ${stripThinkingTags(text)}`);
   }
 
   return parts.join("\n");

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-connection.ts

@@ -6,12 +6,15 @@ import { Database } from "bun:sqlite";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { ensureDataDir, getDbPath } from "../util/platform.js";
+import {
+  clearStoredDb,
+  getStoredDb,
+  setStoredDb,
+} from "./db-singleton.js";
 import * as schema from "./schema.js";
 
 export type DrizzleDb = ReturnType<typeof drizzle<typeof schema>>;
 
-let db: DrizzleDb | null = null;
-
 function canonicalizePathThroughExistingParent(path: string): string {
   const resolvedPath = resolve(path);
   const pendingSegments: string[] = [];
@@ -71,18 +74,20 @@ function assertTestDbIsIsolated(): void {
 }
 
 export function getDb(): DrizzleDb {
-  if (!db) {
-    assertTestDbIsIsolated();
-    ensureDataDir();
-    const sqlite = new Database(getDbPath());
-    sqlite.exec("PRAGMA journal_mode=WAL");
-    sqlite.exec("PRAGMA synchronous=FULL");
-    sqlite.exec("PRAGMA busy_timeout=5000");
-    sqlite.exec("PRAGMA foreign_keys = ON");
-    sqlite.exec("PRAGMA cache_size=-256000");
-    sqlite.exec("PRAGMA temp_store=MEMORY");
-    db = drizzle(sqlite, { schema });
-  }
+  const existing = getStoredDb<DrizzleDb>();
+  if (existing) return existing;
+
+  assertTestDbIsIsolated();
+  ensureDataDir();
+  const sqlite = new Database(getDbPath());
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA synchronous=FULL");
+  sqlite.exec("PRAGMA busy_timeout=5000");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  sqlite.exec("PRAGMA cache_size=-256000");
+  sqlite.exec("PRAGMA temp_store=MEMORY");
+  const db = drizzle(sqlite, { schema });
+  setStoredDb(db, () => sqlite.close());
   return db;
 }
 
@@ -107,10 +112,15 @@ export function getSqliteFrom(drizzleDb: DrizzleDb): Database {
   return (drizzleDb as unknown as { $client: Database }).$client;
 }
 
-/** Reset the db singleton. Used by tests to ensure isolation between test files. */
+/**
+ * Reset the db singleton. Used by production callers that need to close
+ * the live connection so the file can be replaced (post-migration,
+ * post-restore, post-vbundle-import) and on graceful shutdown.
+ *
+ * Tests should use `resetDbForTesting()` from
+ * `__tests__/db-test-helpers.ts` instead so they don't depend on this
+ * module's heavy import chain (`drizzle-orm/bun-sqlite`).
+ */
 export function resetDb(): void {
-  if (db) {
-    getSqliteFrom(db).close();
-    db = null;
-  }
+  clearStoredDb();
 }

package/src/memory/db-init.ts

@@ -96,6 +96,7 @@ import {
   migrateDropMemoryItemsTables,
   migrateDropMemorySegmentFts,
   migrateDropOrphanedMediaTables,
+  migrateDropProviderConnectionStatus,
   migrateDropRemindersTable,
   migrateDropSetupSkillIdColumn,
   migrateDropSimplifiedMemory,
@@ -118,9 +119,11 @@ import {
   migrateInviteCodeHashColumn,
   migrateInviteContactId,
   migrateLlmRequestLogAgentLoopExitReason,
+  migrateLlmRequestLogCallSite,
   migrateLlmRequestLogMessageId,
   migrateLlmRequestLogProvider,
   migrateLlmRequestLogsCreatedAtIndex,
+  migrateLlmUsageAddRawUsage,
   migrateLlmUsageAttribution,
   migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
@@ -128,7 +131,10 @@ import {
   migrateMemoryRetrospectiveState,
   migrateMemoryV2ActivationLogs,
   migrateMemoryV2InjectionEvents,
+  migrateMemoryV3AutoEdges,
+  migrateMemoryV3Coactivation,
   migrateMessageBookmarks,
+  migrateMessagesClientMessageId,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
   migrateNormalizePhoneIdentities,
@@ -155,6 +161,7 @@ import {
   migrateProviderConnectionStatusLabel,
   migrateReminderRoutingIntent,
   migrateRemindersToSchedules,
+  migrateRenameCleanedAt,
   migrateRenameConversationTypeColumn,
   migrateRenameCreatedBySessionIdColumns,
   migrateRenameFollowupsThreadIdColumn,
@@ -452,6 +459,13 @@ export function initializeDb(): void {
     migrateStripBaseUrlNonOpenaiCompatible,
     migrateOnboardingEventsPriorAssistants,
     migrateConversationCleanedAt,
+    migrateRenameCleanedAt,
+    migrateLlmUsageAddRawUsage,
+    migrateMemoryV3Coactivation,
+    migrateMemoryV3AutoEdges,
+    migrateLlmRequestLogCallSite,
+    migrateDropProviderConnectionStatus,
+    migrateMessagesClientMessageId,
   ];
 
   // 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/db-singleton.ts

@@ -0,0 +1,77 @@
+/**
+ * Holds the assistant DB connection singleton and its close callback.
+ *
+ * Lives in its own module (rather than alongside the resolver in
+ * `db-connection.ts`) so test code can reset the singleton without
+ * importing `db-connection.ts` — which transitively pulls
+ * `drizzle-orm/bun-sqlite`. Stdlib-only by design: this file must remain
+ * safe to import from the test preload's load-time chain, where a broken
+ * `node_modules` symlink has historically tripped the env override
+ * (see DB ghost #3, /workspace/journal/2026-05-25-db-ghost-3-recovery.md).
+ *
+ * State is held on `globalThis.vellumAssistant.dbSingleton` so test
+ * helpers in `__tests__/` can read/write it WITHOUT importing this
+ * module — they declare the same slot shape locally and access the
+ * globalThis namespace directly. See
+ * `__tests__/db-test-helpers.ts` for the test-side mirror; the slot
+ * shape MUST stay in sync between the two.
+ *
+ * The stored value is typed as `unknown` so this file never has to import
+ * Drizzle types. Callers in `db-connection.ts` narrow via the type
+ * parameter on `getStoredDb<DrizzleDb>()`.
+ *
+ * Consumers:
+ *   - `db-connection.ts` (opens/owns the connection)
+ *   - production callers that need to close the active connection
+ *     (migration routes, vbundle import, backup/restore, daemon shutdown)
+ *   - `__tests__/db-test-helpers.ts` (per-test reset, via globalThis)
+ */
+
+type DbSlot = {
+  db: unknown;
+  closer: (() => void) | null;
+};
+
+type VellumAssistantNamespace = {
+  dbSingleton?: DbSlot;
+};
+
+function slot(): DbSlot {
+  const g = globalThis as { vellumAssistant?: VellumAssistantNamespace };
+  const ns = (g.vellumAssistant ??= {});
+  return (ns.dbSingleton ??= { db: null, closer: null });
+}
+
+/** Read the current singleton, narrowed to `T`. `null` means not yet opened. */
+export function getStoredDb<T>(): T | null {
+  return slot().db as T | null;
+}
+
+/**
+ * Store a freshly-opened connection and the closer to run on
+ * `clearStoredDb()`. The closer must be self-contained — it is invoked
+ * inside a try/catch, so partial failures are swallowed (best-effort
+ * close on shutdown / restore paths).
+ */
+export function setStoredDb<T>(newDb: T, close: () => void): void {
+  const s = slot();
+  s.db = newDb;
+  s.closer = close;
+}
+
+/**
+ * Close the active connection (if any) via the stored closer, then drop
+ * both. Idempotent: safe to call when no connection is stored.
+ */
+export function clearStoredDb(): void {
+  const s = slot();
+  if (s.closer) {
+    try {
+      s.closer();
+    } catch {
+      /* best-effort close */
+    }
+  }
+  s.db = null;
+  s.closer = null;
+}

package/src/memory/delivery-channels.ts

@@ -10,6 +10,36 @@ import { eq } from "drizzle-orm";
 import { getDb } from "./db-connection.js";
 import { channelInboundEvents } from "./schema.js";
 
+const SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES =
+  "slackDmLiveDeliveredTextResponseIndexes";
+
+function parseRawPayload(
+  rawPayload: string | null,
+): Record<string, unknown> | undefined {
+  if (!rawPayload) return undefined;
+  try {
+    const parsed = JSON.parse(rawPayload) as unknown;
+    if (
+      parsed === null ||
+      typeof parsed !== "object" ||
+      Array.isArray(parsed)
+    ) {
+      return undefined;
+    }
+    return parsed as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizePositiveIntegerIndexes(value: unknown): number[] {
+  if (!Array.isArray(value)) return [];
+  const indexes = value.filter(
+    (item): item is number => Number.isSafeInteger(item) && item > 0,
+  );
+  return [...new Set(indexes)].sort((a, b) => a - b);
+}
+
 // ── Pending verification reply helpers ───────────────────────────────
 //
 // When a guardian verification succeeds but the confirmation reply fails
@@ -100,6 +130,58 @@ export function updateDeliveredSegmentCount(
     .run();
 }
 
+export function getSlackDmLiveDeliveredTextResponseIndexes(
+  eventId: string,
+): number[] {
+  const db = getDb();
+  const row = db
+    .select({ rawPayload: channelInboundEvents.rawPayload })
+    .from(channelInboundEvents)
+    .where(eq(channelInboundEvents.id, eventId))
+    .get();
+  const payload = parseRawPayload(row?.rawPayload ?? null);
+  if (!payload) return [];
+  return normalizePositiveIntegerIndexes(
+    payload[SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES],
+  );
+}
+
+export function addSlackDmLiveDeliveredTextResponseIndex(
+  eventId: string,
+  responseIndex: number,
+): void {
+  if (!Number.isSafeInteger(responseIndex) || responseIndex <= 0) return;
+
+  const db = getDb();
+  db.transaction((tx) => {
+    const row = tx
+      .select({ rawPayload: channelInboundEvents.rawPayload })
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, eventId))
+      .get();
+    if (!row?.rawPayload) return;
+
+    const payload = parseRawPayload(row.rawPayload);
+    if (!payload) return;
+    const indexes = normalizePositiveIntegerIndexes(
+      payload[SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES],
+    );
+    if (!indexes.includes(responseIndex)) indexes.push(responseIndex);
+    indexes.sort((a, b) => a - b);
+
+    tx.update(channelInboundEvents)
+      .set({
+        rawPayload: JSON.stringify({
+          ...payload,
+          [SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES]: indexes,
+        }),
+        updatedAt: Date.now(),
+      })
+      .where(eq(channelInboundEvents.id, eventId))
+      .run();
+  });
+}
+
 // ── Deliver-once guard for terminal reply idempotency ────────────────
 //
 // When both the main poll (processChannelMessageWithApprovals) and the