@vellumai/assistant 0.10.0 → 0.10.1-staging.1

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

@@ -2,14 +2,12 @@
  * 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.
+ * The contract this locks in:
+ *   1. `runDbMaintenance` runs `PRAGMA optimize` through the async
+ *      abstraction and then truncates the WAL on the daemon connection.
+ *      It intentionally does NOT run a full VACUUM (which in WAL mode
+ *      inflates the WAL to ~the DB size and needs ~2x the DB size free).
+ *   2. The truncating checkpoint shrinks the WAL file once it has grown.
  *   3. `maybeRunDbMaintenance` is genuinely async — callers can `await`
  *      it and observe completion.
  *   4. The 24 h interval guard short-circuits a recent re-run.
@@ -17,7 +15,7 @@
  * 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 { existsSync, statSync } from "node:fs";
 import { beforeEach, describe, expect, test } from "bun:test";
 
 const { getSqlite } = await import("../db-connection.js");
@@ -28,7 +26,7 @@ const { maybeRunDbMaintenance } = await import("../db-maintenance.js");
 const { getLastUserMessageTimestamp } = await import("../conversation-crud.js");
 const { getDbPath } = await import("../../util/platform.js");
 
-initializeDb();
+await initializeDb();
 
 const MAINTENANCE_CHECKPOINT_KEY = "db_maintenance:last_run";
 const QUIET_PERIOD_MS = 3 * 60 * 60 * 1000;
@@ -56,8 +54,9 @@ function insertMessage(role: "user" | "assistant", createdAt: number): void {
     .run(`msg-${createdAt}-${role}`, convId, role, "[]", createdAt);
 }
 
-/** Inflate the test DB with bloat that VACUUM can reclaim. */
-function inflateAndDelete(byteTarget: number): void {
+/** Pile writes into the WAL (without checkpointing) so a truncating
+ *  checkpoint has measurable work to do. */
+function inflateWal(byteTarget: number): void {
   const sqlite = getSqlite();
   sqlite.exec(
     "CREATE TABLE IF NOT EXISTS bloat (id INTEGER PRIMARY KEY, payload BLOB)",
@@ -72,11 +71,10 @@ function inflateAndDelete(byteTarget: number): void {
   for (let i = 0; i < rowsTarget; i++) {
     insert.run(payload);
   }
+  // Commit, but do not checkpoint — the frames stay in the WAL, leaving it at
+  // its high-water mark (a PASSIVE auto-checkpoint resets the WAL for reuse but
+  // never shrinks the file). Maintenance is what should truncate it.
   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", () => {
@@ -106,36 +104,30 @@ describe("maybeRunDbMaintenance", () => {
     expect(getMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY)).toBe(String(now));
   });
 
-  test("VACUUM reclaims pages on a bloated DB", async () => {
+  test("truncates a bloated WAL", 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();
+    const walPath = `${getDbPath()}-wal`;
+    const walSize = (): number =>
+      existsSync(walPath) ? statSync(walPath).size : 0;
+
+    inflateWal(4 * 1024 * 1024);
+    // Sanity: the writes really did grow the WAL on disk.
+    expect(walSize()).toBeGreaterThan(1024 * 1024);
 
     await maybeRunDbMaintenance();
 
-    const pagesAfter = readPageCount();
-    expect(pagesAfter).toBeLessThan(pagesBefore);
+    // Maintenance truncates the WAL back down (no VACUUM, so the data is folded
+    // into the main file rather than rebuilt).
+    expect(walSize()).toBeLessThan(64 * 1024);
+
+    sqlite.exec("DROP TABLE IF EXISTS bloat");
   }, 60_000);
 
   test("defers maintenance while the last user message is within the quiet period", async () => {
-    /** VACUUM must not fire while the user is active, so a recent user
+    /** Maintenance must not fire while the user is active, so a recent user
      *  message keeps maintenance deferred. */
     // GIVEN the user sent a message one minute ago (well within the quiet period)
     const now = Date.now();

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

@@ -0,0 +1,113 @@
+/**
+ * Tests for the dedicated memory database connection.
+ *
+ * What this locks in:
+ *   1. Opening the memory connection creates `assistant-memory.db` on disk and
+ *      runs it in WAL mode (its own `-wal`, independent of the main DB) — the
+ *      regression that lets a high-churn table (the `memory_jobs` queue) bloat
+ *      the *main* WAL is exactly what this split exists to prevent.
+ *   2. The main connection no longer ATTACHes the memory file: there is no
+ *      `memory` schema on its `database_list`.
+ *   3. `memory_jobs` lives in the dedicated memory connection, not in the main
+ *      connection — proving the physical split.
+ *   4. `runAsyncSqlite({ dbPath })` targets the given file via the sqlite3
+ *      CLI backend, leaving the main DB untouched.
+ */
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { removeTestDbFiles } from "../../__tests__/assert-not-live-db.js";
+
+const { getSqlite, getMemorySqlite } = await import("../db-connection.js");
+const { initializeDb } = await import("../db-init.js");
+const { runAsyncSqlite } = await import("../db-async-query.js");
+const { getMemoryDbPath } = await import("../../util/memory-db-path.js");
+const { findSqlite3 } = await import("../../util/sqlite3-runtime.js");
+
+await initializeDb();
+
+const sqlite3Available = findSqlite3() !== undefined;
+
+describe("memory database connection", () => {
+  test("opens the memory file and creates it on disk in WAL mode", () => {
+    const memory = getMemorySqlite();
+    expect(memory).not.toBeNull();
+    expect(existsSync(getMemoryDbPath())).toBe(true);
+
+    const mode = memory!
+      .query<{ journal_mode: string }, []>("PRAGMA journal_mode")
+      .get();
+    expect(mode?.journal_mode).toBe("wal");
+  });
+
+  test("the main connection does not attach the memory file", () => {
+    const attached = getSqlite()
+      .query<{ name: string }, []>("PRAGMA database_list")
+      .all();
+    expect(attached.some((e) => e.name === "memory")).toBe(false);
+  });
+
+  test("memory_jobs lives in the memory connection, not main", () => {
+    const inMemory = getMemorySqlite()!
+      .query<
+        { name: string },
+        []
+      >(`SELECT name FROM sqlite_master WHERE type='table' AND name='memory_jobs'`)
+      .get();
+    expect(inMemory?.name).toBe("memory_jobs");
+
+    const inMain = getSqlite()
+      .query<
+        { name: string },
+        []
+      >(`SELECT name FROM main.sqlite_master WHERE name='memory_jobs'`)
+      .get();
+    expect(inMain).toBeNull();
+  });
+
+  test.if(sqlite3Available)(
+    "runAsyncSqlite({ dbPath }) targets the given file, not the main DB",
+    async () => {
+      const targetPath = join(
+        tmpdir(),
+        `vellum-async-memory-dbpath-${Date.now()}.db`,
+      );
+      try {
+        const result = await runAsyncSqlite(
+          "CREATE TABLE dbpath_probe (x INTEGER); INSERT INTO dbpath_probe VALUES (42); SELECT changes();",
+          { dbPath: targetPath, forceBackend: "sqlite3-cli" },
+        );
+        expect(result.ok).toBe(true);
+        expect(result.backend).toBe("sqlite3-cli");
+
+        // The target file got the table…
+        const { Database } = await import("bun:sqlite");
+        const probe = new Database(targetPath, { readonly: true });
+        try {
+          const row = probe
+            .query<
+              { name: string },
+              []
+            >("SELECT name FROM sqlite_master WHERE name = 'dbpath_probe'")
+            .get();
+          expect(row?.name).toBe("dbpath_probe");
+        } finally {
+          probe.close();
+        }
+
+        // …and the main DB did not.
+        const inMain = getSqlite()
+          .query<
+            { name: string },
+            []
+          >("SELECT name FROM main.sqlite_master WHERE name = 'dbpath_probe'")
+          .get();
+        expect(inMain).toBeNull();
+      } finally {
+        removeTestDbFiles(targetPath);
+      }
+    },
+  );
+});

package/src/memory/__tests__/find-analysis-conversation.test.ts

@@ -18,7 +18,7 @@ import { getDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
 import { conversations } from "../schema.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

package/src/memory/__tests__/find-most-recent-retrospective-for.test.ts

@@ -18,7 +18,7 @@ import { initializeDb } from "../db-init.js";
 import { MEMORY_RETROSPECTIVE_SOURCE } from "../memory-retrospective-constants.js";
 import { conversations } from "../schema.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

package/src/memory/__tests__/fork-message-copy.test.ts

@@ -0,0 +1,232 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import {
+  addMessage,
+  createConversation,
+  getMessages,
+} from "../conversation-crud.js";
+import { getDb, getSqlite } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import {
+  buildForkCopyScript,
+  copyForkMessagesViaSubprocess,
+  type ForkIdPair,
+} from "../fork-message-copy.js";
+import { messages as messagesTable } from "../schema.js";
+
+await initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+/** Mirror of the production `cloneForkMessageMetadata` semantics. */
+function expectedClonedMetadata(
+  sourceMetadata: string | null,
+  sourceMessageId: string,
+): unknown {
+  const parsed = sourceMetadata == null ? null : JSON.parse(sourceMetadata);
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    const record = parsed as Record<string, unknown>;
+    const existing = record.forkSourceMessageId;
+    return {
+      ...record,
+      forkSourceMessageId:
+        typeof existing === "string" ? existing : sourceMessageId,
+    };
+  }
+  return { forkSourceMessageId: sourceMessageId };
+}
+
+/** Build an in-JS old→new id map for a source conversation's messages. */
+function idPairsFor(sourceConversationId: string): ForkIdPair[] {
+  return getMessages(sourceConversationId).map((m) => ({
+    oldId: m.id,
+    newId: crypto.randomUUID(),
+  }));
+}
+
+describe("copyForkMessagesViaSubprocess", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("copies rows with cloneForkMessageMetadata parity and a fresh id", async () => {
+    const source = createConversation("source");
+    await addMessage(source.id, "user", "draft a plan", {
+      metadata: { branch: 1, source: "user" },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "here is a pass", {
+      metadata: { automated: true },
+      skipIndexing: true,
+    });
+    // Already-stamped metadata must be preserved, not overwritten.
+    await addMessage(source.id, "user", "carry this", {
+      metadata: { forkSourceMessageId: "pre-existing", note: "x" },
+      skipIndexing: true,
+    });
+    // Null metadata must become a fresh provenance-only object.
+    await addMessage(source.id, "user", "no metadata", {
+      skipIndexing: true,
+    });
+
+    const fork = createConversation({
+      title: "fork",
+      conversationType: "background",
+    });
+    const sourceMessages = getMessages(source.id);
+    const idPairs = sourceMessages.map((m) => ({
+      oldId: m.id,
+      newId: crypto.randomUUID(),
+    }));
+
+    const result = await copyForkMessagesViaSubprocess({
+      forkConversationId: fork.id,
+      idPairs,
+      forceInProcess: true,
+    });
+    expect(result.ok).toBe(true);
+
+    const forkMessages = getMessages(fork.id);
+    expect(forkMessages).toHaveLength(sourceMessages.length);
+    expect(forkMessages.map((m) => m.role)).toEqual(
+      sourceMessages.map((m) => m.role),
+    );
+    expect(forkMessages.map((m) => m.content)).toEqual(
+      sourceMessages.map((m) => m.content),
+    );
+    expect(forkMessages.map((m) => m.createdAt)).toEqual(
+      sourceMessages.map((m) => m.createdAt),
+    );
+    expect(
+      forkMessages.map((m) => (m.metadata ? JSON.parse(m.metadata) : null)),
+    ).toEqual(
+      sourceMessages.map((m) => expectedClonedMetadata(m.metadata, m.id)),
+    );
+    // Fresh ids, and assigned exactly per the supplied map.
+    const byOld = new Map(idPairs.map((p) => [p.oldId, p.newId]));
+    for (const src of sourceMessages) {
+      const expectedNewId = byOld.get(src.id);
+      expect(forkMessages.some((f) => f.id === expectedNewId)).toBe(true);
+    }
+  });
+
+  test("does not copy client_message_id onto fork rows", async () => {
+    const source = createConversation("source");
+    const db = getDb();
+    const createdAt = Date.now();
+    db.run(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at, client_message_id)
+       VALUES ('msg-with-client-id', '${source.id}', 'user', 'hi', ${createdAt}, 'client-123')`,
+    );
+
+    const fork = createConversation({
+      title: "fork",
+      conversationType: "background",
+    });
+    await copyForkMessagesViaSubprocess({
+      forkConversationId: fork.id,
+      idPairs: [{ oldId: "msg-with-client-id", newId: crypto.randomUUID() }],
+      forceInProcess: true,
+    });
+
+    const forkRow = db
+      .select()
+      .from(messagesTable)
+      .all()
+      .find((r) => r.conversationId === fork.id);
+    expect(forkRow).toBeDefined();
+    expect(forkRow?.clientMessageId ?? null).toBeNull();
+  });
+
+  test("copies across batch boundaries", async () => {
+    const source = createConversation("source");
+    for (let i = 0; i < 5; i++) {
+      await addMessage(source.id, "user", `m${i}`, { skipIndexing: true });
+    }
+    const fork = createConversation({
+      title: "fork",
+      conversationType: "background",
+    });
+    const idPairs = idPairsFor(source.id);
+
+    const result = await copyForkMessagesViaSubprocess({
+      forkConversationId: fork.id,
+      idPairs,
+      batchSize: 2,
+      forceInProcess: true,
+    });
+    expect(result.ok).toBe(true);
+    expect(getMessages(fork.id)).toHaveLength(5);
+  });
+
+  test("no-op for an empty id map", async () => {
+    const result = await copyForkMessagesViaSubprocess({
+      forkConversationId: crypto.randomUUID(),
+      idPairs: [],
+      forceInProcess: true,
+    });
+    expect(result.ok).toBe(true);
+    expect(result.elapsedMs).toBe(0);
+  });
+
+  test("does not leave the staging temp table on the connection", async () => {
+    const source = createConversation("source");
+    await addMessage(source.id, "user", "hi", { skipIndexing: true });
+    const fork = createConversation({
+      title: "fork",
+      conversationType: "background",
+    });
+    await copyForkMessagesViaSubprocess({
+      forkConversationId: fork.id,
+      idPairs: idPairsFor(source.id),
+      forceInProcess: true,
+    });
+    const tempTable = getSqlite()
+      .query(
+        "SELECT name FROM sqlite_temp_master WHERE type='table' AND name='_fork_id_map'",
+      )
+      .get();
+    expect(tempTable).toBeNull();
+  });
+});
+
+describe("buildForkCopyScript", () => {
+  test("rejects an unsafe fork id", () => {
+    expect(() =>
+      buildForkCopyScript({
+        forkConversationId: "abc'); DROP TABLE messages;--",
+        idPairs: [],
+      }),
+    ).toThrow(/unsafe id/);
+  });
+
+  test("rejects an unsafe message id", () => {
+    expect(() =>
+      buildForkCopyScript({
+        forkConversationId: crypto.randomUUID(),
+        idPairs: [{ oldId: "ok", newId: "bad'id" }],
+      }),
+    ).toThrow(/unsafe id/);
+  });
+});

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

@@ -71,6 +71,8 @@ mock.module("../qdrant-circuit-breaker.js", () => ({
 mock.module("../raw-query.js", () => ({
   rawAll: () => [],
   rawChanges: () => 0,
+  rawMemoryAll: () => [],
+  rawMemoryChanges: () => 0,
 }));
 
 // Drizzle-shaped no-op db. Tracks inserts/updates so tests can observe
@@ -111,6 +113,7 @@ function makeStubDb() {
 const stubDb = makeStubDb();
 mock.module("../db-connection.js", () => ({
   getDb: () => stubDb,
+  getMemoryDb: () => stubDb,
 }));
 
 // Now load the real modules under test.

package/src/memory/__tests__/jobs-worker-v2-graph-trigger-embed.test.ts

@@ -67,7 +67,7 @@ const tmpWorkspace = mkdtempSync(
 const previousWorkspaceEnv = process.env.VELLUM_WORKSPACE_DIR;
 process.env.VELLUM_WORKSPACE_DIR = tmpWorkspace;
 
-import { getDb } from "../db-connection.js";
+import { getMemoryDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
 import { enqueueMemoryJob } from "../jobs-store.js";
 import { runMemoryJobsOnce } from "../jobs-worker.js";
@@ -75,8 +75,8 @@ import { _resetQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import { memoryJobs } from "../schema.js";
 
 describe("graph_trigger_embed under memory v2", () => {
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
   afterAll(() => {
@@ -89,7 +89,7 @@ describe("graph_trigger_embed under memory v2", () => {
   });
 
   beforeEach(() => {
-    getDb().run("DELETE FROM memory_jobs");
+    getMemoryDb()!.run("DELETE FROM memory_jobs");
     triggerHandlerCalls = 0;
     _resetQdrantBreaker();
   });
@@ -103,7 +103,7 @@ describe("graph_trigger_embed under memory v2", () => {
 
     expect(triggerHandlerCalls).toBe(1);
 
-    const rows = getDb()
+    const rows = getMemoryDb()!
       .select()
       .from(memoryJobs)
       .where(eq(memoryJobs.id, jobId))

package/src/memory/__tests__/jobs-worker-v2-schedule.test.ts

@@ -59,7 +59,7 @@ afterAll(() => {
   rmSync(tmpWorkspace, { recursive: true, force: true });
 });
 
-const { getDb } = await import("../db-connection.js");
+const { getMemoryDb } = await import("../db-connection.js");
 const { initializeDb } = await import("../db-init.js");
 const { resetTestTables } = await import("../raw-query.js");
 const { memoryJobs } = await import("../schema.js");
@@ -107,7 +107,7 @@ function removeBuffer(): void {
 }
 
 function countPendingJobs(type: string): number {
-  return getDb()
+  return getMemoryDb()!
     .select()
     .from(memoryJobs)
     .where(eq(memoryJobs.type, type))
@@ -115,7 +115,7 @@ function countPendingJobs(type: string): number {
 }
 
 function consolidationJobPayloads(): Record<string, unknown>[] {
-  return getDb()
+  return getMemoryDb()!
     .select({ payload: memoryJobs.payload })
     .from(memoryJobs)
     .where(eq(memoryJobs.type, "memory_v2_consolidate"))
@@ -126,12 +126,14 @@ function consolidationJobPayloads(): Record<string, unknown>[] {
 // Initialize the DB once for the file; clear per-test tables in beforeEach
 // rather than tearing down the singleton, which is slow because it re-runs
 // every migration on the next access.
-initializeDb();
+await initializeDb();
 
 beforeEach(() => {
   // Clear job + checkpoint state so each test starts from zero rows. Other
-  // tables stay intact — the worker only inspects these two.
-  resetTestTables("memory_jobs", "memory_checkpoints");
+  // tables stay intact — the worker only inspects these two. memory_jobs lives
+  // in the dedicated memory connection; memory_checkpoints in main.
+  getMemoryDb()!.run("DELETE FROM memory_jobs");
+  resetTestTables("memory_checkpoints");
 });
 
 // ---------------------------------------------------------------------------

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

@@ -161,7 +161,7 @@ mock.module("../conversation-crud.js", () => ({
       title: "Source conversation",
     };
   },
-  forkConversation: (params: {
+  forkConversationForRetrospective: async (params: {
     conversationId: string;
     throughMessageId?: string;
     source: string;
@@ -497,6 +497,28 @@ describe("memoryRetrospectiveJob", () => {
     expect(instructionText).not.toContain("(none)");
   });
 
+  test("subsequent run: <already_remembered> flattens a prior batched (array) remember call", async () => {
+    priorRetroId = "prior-retro-conv-1";
+    priorRetroMessages = [
+      {
+        role: "assistant",
+        content: JSON.stringify([
+          {
+            type: "tool_use",
+            name: "remember",
+            input: { content: ["Bob switched teams", "Launch slipped to Q3"] },
+          },
+        ]),
+      },
+    ];
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    const instructionText = persistedInstructionText();
+    expect(instructionText).toContain("- Bob switched teams");
+    expect(instructionText).toContain("- Launch slipped to Q3");
+    expect(instructionText).not.toContain("(none)");
+  });
+
   test("malformed prior-retrospective messages are skipped, run still proceeds", async () => {
     priorRetroId = "prior-retro-conv-1";
     priorRetroMessages = [
@@ -685,39 +707,12 @@ describe("memoryRetrospectiveJob", () => {
     expect(wakeCalls[0]!.opts.toolGateMode).toBe("execution");
   });
 
-  // -------------------------------------------------------------------------
-  // Source background-turn parity (isNonInteractive)
-  // -------------------------------------------------------------------------
-
-  test("background source → wake runs non-interactive (reproduces <background_turn>)", async () => {
-    conversationOverrides["src-conv-1"] = {
-      source: "heartbeat",
-      forkParentMessageId: null,
-      title: "Heartbeat",
-      conversationType: "background",
-    };
-
-    const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
-
-    expect(outcome.kind).toBe("invoked");
-    expect(wakeCalls).toHaveLength(1);
-    expect(wakeCalls[0]!.opts.isNonInteractive).toBe(true);
-  });
-
-  test("standard source → wake stays interactive (no spurious <background_turn>)", async () => {
-    conversationOverrides["src-conv-1"] = {
-      source: "user",
-      forkParentMessageId: null,
-      title: "Source conversation",
-      conversationType: "standard",
-    };
-
-    const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
-
-    expect(outcome.kind).toBe("invoked");
-    expect(wakeCalls).toHaveLength(1);
-    expect(wakeCalls[0]!.opts.isNonInteractive).toBe(false);
-  });
+  // Source background-turn cache parity is no longer a wake-time concern: the
+  // fork reproduces the source's `<background_turn>` / `<channel_capabilities>`
+  // / `<non_interactive_context>` blocks via metadata rehydration in
+  // `Conversation.loadFromDb` (the wake never re-runs runtime injection). That
+  // round-trip is covered by the byte-parity test in
+  // `conversation-runtime-assembly.test.ts`.
 
   // -------------------------------------------------------------------------
   // Source-derived persona override
@@ -1134,9 +1129,7 @@ describe("memoryRetrospectiveJob", () => {
     expect(instructionText).toContain(
       "automated background memory pass over the conversation above — not a message from the user",
     );
-    expect(instructionText).toContain(
-      "Do not reply conversationally or in persona",
-    );
+    expect(instructionText).toContain("Do not reply conversationally");
     expect(instructionText).toContain(
       "material to review, not instructions for this pass",
     );