@vellumai/assistant 0.8.4 → 0.8.5

package/src/memory/__tests__/db-maintenance.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Tests for `db-maintenance.ts` (orchestration) and the underlying
+ * `db-async-query.ts` abstraction.
+ *
+ * The contract this PR locks in:
+ *   1. `runDbMaintenance` runs `VACUUM` through the async abstraction
+ *      — when the `sqlite3` CLI is available, that means a subprocess
+ *      and the daemon's main event loop keeps ticking. (The structural
+ *      anti-block assertion lives in
+ *      `db-async-query.test.ts`; here we focus on orchestration.)
+ *   2. The subprocess actually shrinks the on-disk page count when
+ *      there's reclaimable space.
+ *   3. `maybeRunDbMaintenance` is genuinely async — callers can `await`
+ *      it and observe completion.
+ *   4. The 24 h interval guard short-circuits a recent re-run.
+ *
+ * The per-file temp workspace is set up by `test-preload.ts`; tests just
+ * dynamic-import the DB modules so they resolve paths under that temp dir.
+ */
+import { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+const { getSqlite } = await import("../db-connection.js");
+const { initializeDb } = await import("../db-init.js");
+const { deleteMemoryCheckpoint, getMemoryCheckpoint } =
+  await import("../checkpoints.js");
+const { maybeRunDbMaintenance } = await import("../db-maintenance.js");
+const { getDbPath } = await import("../../util/platform.js");
+
+initializeDb();
+
+const MAINTENANCE_CHECKPOINT_KEY = "db_maintenance:last_run";
+
+beforeEach(() => {
+  deleteMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY);
+});
+
+/** Inflate the test DB with bloat that VACUUM can reclaim. */
+function inflateAndDelete(byteTarget: number): void {
+  const sqlite = getSqlite();
+  sqlite.exec(
+    "CREATE TABLE IF NOT EXISTS bloat (id INTEGER PRIMARY KEY, payload BLOB)",
+  );
+  const pageSize = (
+    sqlite.query("PRAGMA page_size").get() as { page_size: number }
+  ).page_size;
+  const rowsTarget = Math.max(1, Math.ceil(byteTarget / pageSize));
+  const payload = new Uint8Array(Math.max(1, pageSize - 64));
+  const insert = sqlite.prepare("INSERT INTO bloat (payload) VALUES (?)");
+  sqlite.exec("BEGIN");
+  for (let i = 0; i < rowsTarget; i++) {
+    insert.run(payload);
+  }
+  sqlite.exec("COMMIT");
+  sqlite.exec("DELETE FROM bloat");
+  sqlite.exec("DROP TABLE bloat");
+  // Force the WAL onto the main DB file so the bloat is visible on disk.
+  sqlite.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+}
+
+describe("maybeRunDbMaintenance", () => {
+  test("returns a Promise that resolves", async () => {
+    const result = maybeRunDbMaintenance();
+    expect(result).toBeInstanceOf(Promise);
+    await result;
+  });
+
+  test("respects the 24h interval and skips when last run was recent", async () => {
+    const now = Date.now();
+    const recent = now - 60_000;
+    const { setMemoryCheckpoint } = await import("../checkpoints.js");
+    setMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY, String(recent));
+
+    await maybeRunDbMaintenance(now);
+
+    expect(getMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY)).toBe(
+      String(recent),
+    );
+  });
+
+  test("stamps the checkpoint after a maintenance run", async () => {
+    const now = Date.now();
+    await maybeRunDbMaintenance(now);
+
+    expect(getMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY)).toBe(String(now));
+  });
+
+  test("VACUUM reclaims pages on a bloated DB", async () => {
+    const sqlite = getSqlite();
+    sqlite.exec("DROP TABLE IF EXISTS bloat");
+    sqlite.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+
+    inflateAndDelete(8 * 1024 * 1024);
+
+    const dbPath = getDbPath();
+    // Read page_count from a fresh connection so we observe post-write
+    // ground truth without snapshot caching on the main test connection.
+    const readPageCount = (): number => {
+      const probe = new Database(dbPath, { readonly: true });
+      try {
+        return (
+          probe.query("PRAGMA page_count").get() as { page_count: number }
+        ).page_count;
+      } finally {
+        probe.close();
+      }
+    };
+    const pagesBefore = readPageCount();
+
+    await maybeRunDbMaintenance();
+
+    const pagesAfter = readPageCount();
+    expect(pagesAfter).toBeLessThan(pagesBefore);
+  }, 60_000);
+});

package/src/memory/__tests__/jobs-store-enqueue-gate.test.ts

@@ -0,0 +1,241 @@
+// Tests for the memory enqueue gate.
+//
+// Architecture under test:
+//   1. `isMemoryEnabled()` (jobs-store.ts) reads `config.memory.enabled`
+//      and returns `true` unless explicitly `false`.
+//   2. Each call site that enqueues a memory job gates on this helper
+//      before calling `enqueueMemoryJob` / `upsertDebouncedJob` etc.
+//      `enqueueMemoryJob` itself is *not* gated — it preserves its
+//      "always returns a real job id" contract, and non-memory jobs
+//      (`delete_qdrant_vectors`, `prune_*`) flow through unchanged.
+//
+// We verify (1) directly across the four config-shape variants, then
+// smoke-test (2) at two central entry-point helpers:
+//   - `enqueueAutoAnalysisIfEnabled`
+//   - `enqueueMemoryRetrospectiveIfEnabled`
+// Each call site re-checks `isMemoryEnabled()` itself, so we don't
+// repeat 30+ identical scenarios — the helper test is the contract.
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Silence the logger.
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Mutable config shape, mutated per-test. `null` means "no `memory` key
+// at all" — exercises the defensive `?.` chain in `isMemoryEnabled`.
+type MemoryEnabledShape = boolean | null | undefined;
+let memoryEnabled: MemoryEnabledShape = true;
+let getConfigThrows = false;
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => {
+    if (getConfigThrows) throw new Error("config load failed");
+    if (memoryEnabled === null) return {};
+    return {
+      memory: { enabled: memoryEnabled, v2: { enabled: false } },
+      analysis: { idleTimeoutMs: 600_000, batchSize: 30 },
+      assistant: { featureFlags: { "auto-analyze": true } },
+    };
+  },
+}));
+
+// Stub feature flags so auto-analyze isn't gated by an unrelated flag.
+mock.module("../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => true,
+}));
+
+// Stub trust resolver — never claim the actor is untrusted in tests.
+mock.module("../../runtime/actor-trust-resolver.js", () => ({
+  isUntrustedTrustClass: () => false,
+}));
+
+// Stub the conversation-source lookup so the recursion guards in the
+// retrospective and auto-analysis paths fall through to the enqueue.
+mock.module("../conversation-crud.js", () => ({
+  getConversationSource: () => null,
+}));
+mock.module("../auto-analysis-guard.js", () => ({
+  isAutoAnalysisConversation: () => false,
+}));
+
+// Stub the qdrant breaker so `enqueueMemoryJob` doesn't trip on it.
+mock.module("../qdrant-circuit-breaker.js", () => ({
+  isQdrantBreakerOpen: () => false,
+  shouldAllowQdrantProbe: () => true,
+}));
+
+// Stub raw query helpers (used by jobs-store internally).
+mock.module("../raw-query.js", () => ({
+  rawAll: () => [],
+  rawChanges: () => 0,
+}));
+
+// Drizzle-shaped no-op db. Tracks inserts/updates so tests can observe
+// whether an upsert/enqueue actually wrote anything.
+const dbInserts: Array<{ table?: unknown; values: unknown }> = [];
+const dbUpdates: Array<{ table?: unknown; set: unknown }> = [];
+function makeStubDb() {
+  return {
+    insert: (table: unknown) => ({
+      values: (values: unknown) => {
+        dbInserts.push({ table, values });
+        return {
+          run: () => {},
+          onConflictDoUpdate: () => ({ run: () => {} }),
+        };
+      },
+    }),
+    update: (table: unknown) => ({
+      set: (set: unknown) => {
+        dbUpdates.push({ table, set });
+        return {
+          where: () => ({ run: () => {} }),
+        };
+      },
+    }),
+    select: () => ({
+      from: () => ({
+        where: () => ({
+          orderBy: () => ({ get: () => null, all: () => [] }),
+          get: () => null,
+          all: () => [],
+        }),
+      }),
+    }),
+    transaction: (fn: (tx: unknown) => unknown) => fn(makeStubDb()),
+  };
+}
+const stubDb = makeStubDb();
+mock.module("../db-connection.js", () => ({
+  getDb: () => stubDb,
+}));
+
+// Now load the real modules under test.
+const { isMemoryEnabled } = await import("../jobs-store.js");
+const { enqueueAutoAnalysisIfEnabled } = await import(
+  "../auto-analysis-enqueue.js"
+);
+const { enqueueMemoryRetrospectiveIfEnabled } = await import(
+  "../memory-retrospective-enqueue.js"
+);
+
+beforeEach(() => {
+  dbInserts.length = 0;
+  dbUpdates.length = 0;
+  memoryEnabled = true;
+  getConfigThrows = false;
+});
+
+// ---------------------------------------------------------------------
+// isMemoryEnabled() contract
+// ---------------------------------------------------------------------
+
+describe("isMemoryEnabled", () => {
+  test("returns true when memory.enabled is true", () => {
+    memoryEnabled = true;
+    expect(isMemoryEnabled()).toBe(true);
+  });
+
+  test("returns true when memory.enabled is undefined (schema default)", () => {
+    memoryEnabled = undefined;
+    expect(isMemoryEnabled()).toBe(true);
+  });
+
+  test("returns true when memory key is absent (partial config)", () => {
+    memoryEnabled = null;
+    expect(isMemoryEnabled()).toBe(true);
+  });
+
+  test("returns false ONLY when memory.enabled is explicitly false", () => {
+    memoryEnabled = false;
+    expect(isMemoryEnabled()).toBe(false);
+  });
+
+  test("returns true (defensive) when getConfig throws", () => {
+    // If config can't be read, we can't tell whether memory has been
+    // disabled, so default to "enabled". Callers that already have their
+    // own getConfig try/catch (e.g. enqueueAutoAnalysisIfEnabled) keep
+    // controlling the silent-failure semantic for the rest of their flow.
+    getConfigThrows = true;
+    expect(isMemoryEnabled()).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------
+// enqueueAutoAnalysisIfEnabled — representative entry-point helper
+// ---------------------------------------------------------------------
+
+describe("enqueueAutoAnalysisIfEnabled (call-site gate)", () => {
+  test("does NOT enqueue when memory.enabled is false", () => {
+    memoryEnabled = false;
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "conv-1",
+      trigger: "batch",
+    });
+    expect(dbInserts.length).toBe(0);
+  });
+
+  test("enqueues when memory.enabled is true", () => {
+    memoryEnabled = true;
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "conv-1",
+      trigger: "batch",
+    });
+    expect(dbInserts.length).toBeGreaterThan(0);
+  });
+
+  test("enqueues when memory.enabled is undefined (schema default)", () => {
+    memoryEnabled = undefined;
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "conv-1",
+      trigger: "batch",
+    });
+    expect(dbInserts.length).toBeGreaterThan(0);
+  });
+
+  test("enqueues when memory key is absent from config", () => {
+    memoryEnabled = null;
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "conv-1",
+      trigger: "batch",
+    });
+    expect(dbInserts.length).toBeGreaterThan(0);
+  });
+});
+
+// ---------------------------------------------------------------------
+// enqueueMemoryRetrospectiveIfEnabled — representative entry-point
+// ---------------------------------------------------------------------
+
+describe("enqueueMemoryRetrospectiveIfEnabled (call-site gate)", () => {
+  test("does NOT enqueue when memory.enabled is false", () => {
+    memoryEnabled = false;
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "conv-1",
+      trigger: "interval",
+    });
+    expect(dbInserts.length).toBe(0);
+  });
+
+  test("enqueues when memory.enabled is true", () => {
+    memoryEnabled = true;
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "conv-1",
+      trigger: "interval",
+    });
+    expect(dbInserts.length).toBeGreaterThan(0);
+  });
+
+  test("enqueues when memory.enabled is undefined (schema default)", () => {
+    memoryEnabled = undefined;
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "conv-1",
+      trigger: "interval",
+    });
+    expect(dbInserts.length).toBeGreaterThan(0);
+  });
+});

package/src/memory/__tests__/jobs-store-job-classes.test.ts

@@ -1,6 +1,24 @@
 import { describe, expect, test } from "bun:test";
 
-import { EMBED_JOB_TYPES, SLOW_LLM_JOB_TYPES } from "../jobs-store.js";
+import {
+  EMBED_JOB_TYPES,
+  type MemoryJobType,
+  SLOW_LLM_JOB_TYPES,
+} from "../jobs-store.js";
+
+describe("memory v3 job types", () => {
+  test("the v3 job-type literals are members of MemoryJobType", () => {
+    // Compile-time assignability is enforced by `tsc --noEmit`; the runtime
+    // assertion keeps the literals visible to the test runner. These types are
+    // inert scaffolding until their handlers land in later PRs.
+    const v3JobTypes: MemoryJobType[] = [
+      "memory_v3_consolidate",
+      "memory_v3_index_maintenance",
+      "memory_v3_edge_learning",
+    ];
+    expect(new Set(v3JobTypes).size).toBe(3);
+  });
+});
 
 describe("memory job classes", () => {
   test("EMBED_JOB_TYPES and SLOW_LLM_JOB_TYPES are disjoint", () => {
@@ -21,4 +39,13 @@ describe("memory job classes", () => {
     const set = new Set(SLOW_LLM_JOB_TYPES);
     expect(set.size).toBe(SLOW_LLM_JOB_TYPES.length);
   });
+
+  test("memory_v3_consolidate is a slow LLM job (lane isolation)", () => {
+    // It hands off to a background agent for up to 15 min, like
+    // memory_v2_consolidate; it must not sit in the fast lane and starve
+    // short jobs. The mechanical v3 jobs intentionally stay fast.
+    expect(SLOW_LLM_JOB_TYPES).toContain("memory_v3_consolidate");
+    expect(SLOW_LLM_JOB_TYPES).not.toContain("memory_v3_index_maintenance");
+    expect(SLOW_LLM_JOB_TYPES).not.toContain("memory_v3_edge_learning");
+  });
 });

package/src/memory/__tests__/memory-retrospective-job.test.ts

@@ -315,6 +315,13 @@ describe("memoryRetrospectiveJob", () => {
     expect(bootstrapCalls[0]!.forkParentConversationId).toBe("src-conv-1");
   });
 
+  test("legacy path: wake opts include suppressWakeSurface so the full retrospective prompt isn't rendered as a 'Conversation Woke' card body to clients", async () => {
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(wakeCalls).toHaveLength(1);
+    expect(wakeCalls[0]!.opts.suppressWakeSurface).toBe(true);
+  });
+
   test("no-new-messages early return: neither field changes, no wake, no bootstrap", async () => {
     newMessages = [];
     const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);

package/src/memory/auto-analysis-enqueue.ts

@@ -6,7 +6,7 @@ import {
 } from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
 import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
-import { upsertAutoAnalysisJob } from "./jobs-store.js";
+import { isMemoryEnabled, upsertAutoAnalysisJob } from "./jobs-store.js";
 
 const log = getLogger("auto-analysis-enqueue");
 
@@ -46,6 +46,10 @@ export function enqueueAutoAnalysisIfEnabled(args: {
 }): void {
   const { conversationId, trigger } = args;
 
+  if (!isMemoryEnabled()) {
+    return;
+  }
+
   let config;
   try {
     config = getConfig();

package/src/memory/conversation-crud.ts

@@ -24,6 +24,7 @@ import type { ChannelId, InterfaceId } from "../channels/types.js";
 import { parseChannelId, parseInterfaceId } from "../channels/types.js";
 import { CHANNEL_IDS, isChannelId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
+import { findDisplayTurnEndIndex } from "../conversations/message-consolidation.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { UserError } from "../util/errors.js";
 import { safeParseRecord } from "../util/json.js";
@@ -47,6 +48,7 @@ import {
 } from "./conversation-disk-view.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
 import { ensureGroupMigration } from "./conversation-group-migration.js";
+import { runAsyncSqlite } from "./db-async-query.js";
 import { getDb, getSqliteFrom } from "./db-connection.js";
 import { forkGraphMemoryState } from "./graph/graph-memory-state-store.js";
 import { indexMessageNow } from "./indexer.js";
@@ -190,7 +192,7 @@ export interface ConversationRow {
   contextSummary: string | null;
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
-  cleanedAt: number | null;
+  historyStrippedAt: number | null;
   slackContextCompactionWatermarkTs: string | null;
   slackContextCompactionWatermarkAt: number | null;
   conversationType: string;
@@ -224,7 +226,7 @@ export const parseConversation = createRowMapper<
   contextSummary: "contextSummary",
   contextCompactedMessageCount: "contextCompactedMessageCount",
   contextCompactedAt: "contextCompactedAt",
-  cleanedAt: "cleanedAt",
+  historyStrippedAt: "historyStrippedAt",
   slackContextCompactionWatermarkTs: "slackContextCompactionWatermarkTs",
   slackContextCompactionWatermarkAt: "slackContextCompactionWatermarkAt",
   conversationType: "conversationType",
@@ -581,17 +583,30 @@ export function forkConversation(params: {
     );
   }
 
-  const copyBoundaryIndex =
+  const initialBoundaryIndex =
     throughMessageId == null
       ? sourceMessages.length - 1
       : sourceMessages.findIndex((message) => message.id === throughMessageId);
 
-  if (throughMessageId != null && copyBoundaryIndex === -1) {
+  if (throughMessageId != null && initialBoundaryIndex === -1) {
     throw new UserError(
       `Message ${throughMessageId} does not belong to conversation ${conversationId}`,
     );
   }
 
+  // Extend the boundary to cover the full display turn the client
+  // addressed. The read-path collapses each assistant turn across
+  // multiple DB rows — consecutive assistant rows AND tool-result-only
+  // user rows between them — so "fork through message X" semantically
+  // means "fork through the entire display turn containing X" no matter
+  // which DB row in the cluster the client supplied. Single source of
+  // truth is `findDisplayTurnEndIndex`, shared with the read path so
+  // both stay in sync.
+  const copyBoundaryIndex = findDisplayTurnEndIndex(
+    sourceMessages,
+    initialBoundaryIndex,
+  );
+
   const visibleWindowStartIndex = Math.max(
     0,
     Math.min(
@@ -607,15 +622,16 @@ export function forkConversation(params: {
       ? sourceMessages.slice(0, copyBoundaryIndex + 1)
       : ([] as MessageRow[]);
 
-  // Inherit /clean state only when the fork boundary is at-or-after the
-  // clean event. Pre-clean forks branch from history that pre-dates the
-  // clean, so the marker would be a no-op and is misleading to copy.
-  const sourceCleanedAt = sourceConversation.cleanedAt ?? null;
+  // Inherit the history-strip marker only when the fork boundary is at-or-
+  // after the strip event. Pre-strip forks branch from history that pre-
+  // dates the strip, so the marker would be a no-op and is misleading to
+  // copy.
+  const sourceHistoryStrippedAt = sourceConversation.historyStrippedAt ?? null;
   const boundaryMessageCreatedAt = messagesToCopy.at(-1)?.createdAt ?? null;
-  const inheritsCleanedAt =
-    sourceCleanedAt != null &&
+  const inheritsHistoryStrippedAt =
+    sourceHistoryStrippedAt != null &&
     boundaryMessageCreatedAt != null &&
-    boundaryMessageCreatedAt >= sourceCleanedAt;
+    boundaryMessageCreatedAt >= sourceHistoryStrippedAt;
   const forkParentMessageId = messagesToCopy.at(-1)?.id ?? null;
   const forkTitle =
     params.title ?? `${sourceConversation.title ?? "Untitled"} (Fork)`;
@@ -662,7 +678,9 @@ export function forkConversation(params: {
         slackContextCompactionWatermarkAt: preserveSourceCompactionState
           ? sourceConversation.slackContextCompactionWatermarkAt
           : null,
-        cleanedAt: inheritsCleanedAt ? sourceCleanedAt : null,
+        historyStrippedAt: inheritsHistoryStrippedAt
+          ? sourceHistoryStrippedAt
+          : null,
         inferenceProfile: sourceConversation.inferenceProfile,
       })
       .where(eq(conversations.id, fc.id))
@@ -1451,14 +1469,14 @@ export function updateConversationContextWindow(
     .run();
 }
 
-export function setConversationCleanedAt(
+export function setConversationHistoryStrippedAt(
   id: string,
-  cleanedAt: number | null,
+  historyStrippedAt: number | null,
 ): void {
   const db = getDb();
   db.update(conversations)
     .set({
-      cleanedAt,
+      historyStrippedAt,
       updatedAt: Date.now(),
     })
     .where(eq(conversations.id, id))
@@ -1703,13 +1721,35 @@ export function setLastNotifiedInferenceProfile(
  * Delete all conversations, messages, and related data (tool invocations,
  * memory segments, etc.) from the daemon database.
  * Returns { conversations, messages } counts.
+ *
+ * Each bulk DELETE is dispatched through {@link runAsyncSqlite}: when
+ * the host has a `sqlite3` CLI it executes in a subprocess and the
+ * daemon's main event loop stays responsive while large tables
+ * (`llm_request_logs`, `tool_invocations`, etc.) are wiped. On hosts
+ * without the CLI the abstraction falls back to in-process blocking
+ * execution — the same behaviour the daemon had before.
  */
-export function clearAll(): { conversations: number; messages: number } {
+export async function clearAll(): Promise<{
+  conversations: number;
+  messages: number;
+}> {
   const msgCount =
     rawGet<{ c: number }>("SELECT COUNT(*) AS c FROM messages")?.c ?? 0;
   const convCount =
     rawGet<{ c: number }>("SELECT COUNT(*) AS c FROM conversations")?.c ?? 0;
 
+  // Each DELETE goes through `runAsyncSqlite`. The original code threw
+  // on rawExec failure; mirror that here by throwing when the async
+  // result reports `ok: false`, so the route handler still returns 500.
+  const runOrThrow = async (sql: string): Promise<void> => {
+    const result = await runAsyncSqlite(sql);
+    if (!result.ok) {
+      throw new Error(
+        `clearAll: \`${sql}\` failed (${result.backend}): ${result.error ?? "unknown"}`,
+      );
+    }
+  };
+
   // Delete in dependency order. Cascades handle memory_segments and
   // tool_invocations, but we explicitly clear non-cascading memory
   // tables too.
@@ -1719,22 +1759,21 @@ export function clearAll(): { conversations: number; messages: number } {
   // triggers so that the subsequent base-table DELETEs don't also fail
   // (SQLite triggers are atomic with the triggering statement, so a
   // corrupted FTS table would roll back every base-table DELETE).
-  rawExec("DELETE FROM memory_segments");
-  rawExec("DELETE FROM memory_summaries");
-  rawExec("DELETE FROM memory_embeddings");
-  rawExec("DELETE FROM memory_jobs");
-  rawExec("DELETE FROM memory_checkpoints");
-  rawExec("DELETE FROM llm_request_logs");
-  rawExec("DELETE FROM llm_usage_events");
-  rawExec("DELETE FROM message_attachments");
-  rawExec("DELETE FROM attachments");
-  rawExec("DELETE FROM tool_invocations");
+  await runOrThrow("DELETE FROM memory_segments");
+  await runOrThrow("DELETE FROM memory_summaries");
+  await runOrThrow("DELETE FROM memory_embeddings");
+  await runOrThrow("DELETE FROM memory_jobs");
+  await runOrThrow("DELETE FROM memory_checkpoints");
+  await runOrThrow("DELETE FROM llm_request_logs");
+  await runOrThrow("DELETE FROM llm_usage_events");
+  await runOrThrow("DELETE FROM message_attachments");
+  await runOrThrow("DELETE FROM attachments");
+  await runOrThrow("DELETE FROM tool_invocations");
   let messagesFtsCorrupted = false;
-  try {
-    rawExec("DELETE FROM messages_fts");
-  } catch (err) {
+  const ftsResult = await runAsyncSqlite("DELETE FROM messages_fts");
+  if (!ftsResult.ok) {
     log.warn(
-      { err },
+      { error: ftsResult.error, backend: ftsResult.backend },
       "clearAll: failed to clear messages_fts — dropping triggers so base-table cleanup can proceed",
     );
     rawExec("DROP TRIGGER IF EXISTS messages_fts_ai");
@@ -1742,8 +1781,8 @@ export function clearAll(): { conversations: number; messages: number } {
     rawExec("DROP TRIGGER IF EXISTS messages_fts_au");
     messagesFtsCorrupted = true;
   }
-  rawExec("DELETE FROM messages");
-  rawExec("DELETE FROM conversations");
+  await runOrThrow("DELETE FROM messages");
+  await runOrThrow("DELETE FROM conversations");
 
   // Record audit event — lifecycle_events is NOT deleted by clearAll(),
   // so this survives the wipe and provides a permanent trail.
@@ -1910,44 +1949,6 @@ export function updateMessageMetadata(
     .run();
 }
 
-/**
- * Bulk-remove the metadata fields that back the blocks stripped by
- * `stripInjectionsForCompaction` — currently `pkbSystemReminderBlock`
- * (`<system_reminder>`), `nowScratchpadBlock` (`<NOW.md …>`),
- * `pkbContextBlock` (`<knowledge_base>`), and `memoryV2StaticBlock`
- * (the static `<memory>\n…</memory>` block matched by the `<memory>\n`
- * prefix in `RUNTIME_INJECTION_PREFIXES`). Called from compaction-strip
- * sites so post-restart rehydration stays consistent with the in-memory
- * state produced by `stripInjectionsForCompaction` (which removes those
- * tags from live messages but cannot touch the DB). Fields backing
- * blocks that are intentionally NOT stripped (`turnContextBlock`,
- * `workspaceBlock`, `memoryInjectedBlock`) are preserved.
- */
-export function clearStrippedInjectionMetadataForConversation(
-  conversationId: string,
-): void {
-  rawRun(
-    `UPDATE messages
-        SET metadata = json_remove(
-          metadata,
-          '$.pkbSystemReminderBlock',
-          '$.nowScratchpadBlock',
-          '$.pkbContextBlock',
-          '$.memoryV2StaticBlock'
-        )
-      WHERE conversation_id = ?
-        AND role = 'user'
-        AND metadata IS NOT NULL
-        AND (
-          json_extract(metadata, '$.pkbSystemReminderBlock') IS NOT NULL
-          OR json_extract(metadata, '$.nowScratchpadBlock') IS NOT NULL
-          OR json_extract(metadata, '$.pkbContextBlock') IS NOT NULL
-          OR json_extract(metadata, '$.memoryV2StaticBlock') IS NOT NULL
-        )`,
-    conversationId,
-  );
-}
-
 /**
  * Atomically update both `content` and (shallow-merged) `metadata` for a
  * message. Used by edit-propagation paths that need to update the message