@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/persistence/message-reads.ts

@@ -190,36 +190,6 @@ export function existingMessageIds(
   );
 }
 
-/**
- * `createdAt` of each of `messageIds` that exists as a row, keyed by id, in
- * any state.
- *
- * Any-state deliberately: a row's `createdAt` is fixed at insert, so its
- * completeness does not change the answer, and the callers (retrospective
- * cursor bookkeeping) hold ids taken from rows they have already reviewed.
- * An empty input returns an empty map without querying.
- */
-export function messageCreatedAtByIds(
-  messageIds: readonly string[],
-  opts?: { db?: MessageReadHandle },
-): Map<string, number> {
-  const db = opts?.db ?? getDb();
-  const result = new Map<string, number>();
-  // Chunked so a whole-conversation id list stays under SQLite's bound
-  // parameter limit.
-  for (let offset = 0; offset < messageIds.length; offset += 500) {
-    const rows = db
-      .select({ id: messages.id, createdAt: messages.createdAt })
-      .from(messages)
-      .where(inArray(messages.id, messageIds.slice(offset, offset + 500)))
-      .all();
-    for (const row of rows) {
-      result.set(row.id, row.createdAt);
-    }
-  }
-  return result;
-}
-
 /**
  * The conversation that owns `messageId`, in any state, or null when the
  * message does not exist.

package/src/persistence/migrations/157-invite-contact-id.ts

@@ -1,5 +1,4 @@
 import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
-import { tableExists } from "./schema-introspection.js";
 
 /**
  * Add a required contact_id column to assistant_ingress_invites.
@@ -11,16 +10,8 @@ import { tableExists } from "./schema-introspection.js";
  *  1. Add the column as nullable.
  *  2. Delete legacy rows that have no contact binding (NULL).
  *  3. Rebuild the table to enforce NOT NULL (SQLite cannot ALTER COLUMN).
- *
- * The rebuild copies whichever session-id column is live:
- * `source_conversation_id` (after migrateRenameCreatedBySessionIdColumns)
- * or `created_by_session_id`.
  */
 export function migrateInviteContactId(database: DrizzleDb): void {
-  if (!tableExists(database, "assistant_ingress_invites")) {
-    return;
-  }
-
   const raw = getSqliteFrom(database);
 
   const cols = (
@@ -29,28 +20,25 @@ export function migrateInviteContactId(database: DrizzleDb): void {
       notnull: number;
     }>
   ).map((c) => ({ name: c.name, notnull: c.notnull }));
-  const colNames = new Set(cols.map((c) => c.name));
 
   const col = cols.find((c) => c.name === "contact_id");
 
+  // Step 1: Add the column as nullable
   if (!col) {
     raw.exec(
       /*sql*/ `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
     );
   }
 
+  // Step 2: Delete legacy rows with no contact binding
   raw.exec(
     /*sql*/ `DELETE FROM assistant_ingress_invites WHERE contact_id IS NULL OR contact_id = ''`,
   );
 
+  // Step 3: Rebuild the table with NOT NULL on contact_id
   if (col && col.notnull === 1) {
     return;
-  }
-
-  const sessionCol = colNames.has("source_conversation_id")
-    ? "source_conversation_id"
-    : "created_by_session_id";
-  const sessionSelect = colNames.has(sessionCol) ? sessionCol : "NULL";
+  } // already NOT NULL
 
   raw.exec("PRAGMA foreign_keys = OFF");
   try {
@@ -61,7 +49,7 @@ export function migrateInviteContactId(database: DrizzleDb): void {
           id TEXT PRIMARY KEY,
           source_channel TEXT NOT NULL,
           token_hash TEXT NOT NULL,
-          ${sessionCol} TEXT,
+          created_by_session_id TEXT,
           note TEXT,
           max_uses INTEGER NOT NULL DEFAULT 1 CHECK (max_uses > 0),
           use_count INTEGER NOT NULL DEFAULT 0 CHECK (use_count >= 0),
@@ -82,7 +70,7 @@ export function migrateInviteContactId(database: DrizzleDb): void {
         );
 
         INSERT INTO assistant_ingress_invites_new
-        SELECT id, source_channel, token_hash, ${sessionSelect}, note,
+        SELECT id, source_channel, token_hash, created_by_session_id, note,
                max_uses, use_count, expires_at, status,
                redeemed_by_external_user_id, redeemed_by_external_chat_id,
                redeemed_at, expected_external_user_id, voice_code_hash,

package/src/persistence/schema/memory-core.ts

@@ -104,11 +104,6 @@ export const memoryRetrospectiveState = sqliteTable(
     conversationId: text("conversation_id").primaryKey(),
     lastProcessedMessageId: text("last_processed_message_id").notNull(),
     lastRunAt: integer("last_run_at").notNull(),
-    // `createdAt` of the `last_processed_message_id` row when the pointer was
-    // written, so the cursor still bounds reads after that row is deleted.
-    // NULL when unknown. Added lazily by `ensureRetrospectiveCursorColumn`
-    // (memory-retrospective-state.ts), not by the migration chain.
-    lastProcessedCreatedAt: integer("last_processed_created_at"),
     // JSON array of strings — cumulative `remember` contents from prior
     // retrospective passes (capped; see memory-retrospective-state.ts).
     // NULL for rows that predate migration 281 or have no saves yet.

package/src/platform/client.test.ts

@@ -24,9 +24,7 @@ mock.module("../providers/platform-proxy/context.js", () => ({
   resolveManagedProxyContext: () => mockResolveManagedProxyContext(),
 }));
 
-const actualEnv = await import("../config/env.js");
 mock.module("../config/env.js", () => ({
-  ...actualEnv,
   getPlatformAssistantId: () => mockAssistantId,
 }));
 
@@ -115,11 +113,11 @@ describe("VellumPlatformClient", () => {
         platformBaseUrl: "",
         assistantApiKey: "",
       };
-      mockAssistantId = "stored-assistant-id";
+      mockAssistantId = "";
       mockSecureKeys = {
         "vellum:platform_base_url": "https://stored-platform.example.com/",
         "vellum:assistant_api_key": "stored-api-key",
-        "vellum:platform_assistant_id": " vault-assistant-id ",
+        "vellum:platform_assistant_id": " stored-assistant-id ",
       };
 
       const client = await VellumPlatformClient.create();

package/src/platform/client.ts

@@ -7,7 +7,7 @@
 
 import type { PlatformCredentialVerificationStatus } from "@vellumai/service-contracts/platform-credential";
 
-import { resolvePlatformAssistantId } from "../config/platform-identity.js";
+import { getPlatformAssistantId } from "../config/env.js";
 import { resolveManagedProxyContext } from "../providers/platform-proxy/context.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -63,7 +63,7 @@ async function resolvePlatformClientConfig(): Promise<PlatformClientConfig | nul
 
   let baseUrl = ctx.enabled ? ctx.platformBaseUrl : "";
   let apiKey = ctx.enabled ? ctx.assistantApiKey : "";
-  const assistantId = await resolvePlatformAssistantId();
+  let assistantId = getPlatformAssistantId();
 
   // Fall back to credential store for values not yet rehydrated (standalone CLI).
   if (!baseUrl) {
@@ -76,6 +76,14 @@ async function resolvePlatformClientConfig(): Promise<PlatformClientConfig | nul
       (await getSecureKeyAsync(credentialKey("vellum", "assistant_api_key"))) ??
       "";
   }
+  if (!assistantId) {
+    assistantId =
+      (
+        await getSecureKeyAsync(
+          credentialKey("vellum", "platform_assistant_id"),
+        )
+      )?.trim() ?? "";
+  }
 
   if (!baseUrl || !apiKey) {
     const level = _missingPrereqsWarned ? "debug" : "warn";

package/src/plugin-api/constants.ts

@@ -34,8 +34,6 @@ export const HOOKS = {
   CONVERSATION_DELETED: "conversation-deleted",
   /** Fires once when every conversation is wiped at once (the clear-all reset), after the main tables are cleared. Carries no `conversationId`; cleanup hooks wipe their own per-conversation state wholesale. */
   CONVERSATIONS_CLEARED: "conversations-cleared",
-  /** Fires once per deleted message row, after the row is removed, carrying the row's `(createdAt, id)` so a hook can settle state that pointed at it. Fire-and-forget cleanup signal, like `conversation-deleted`; whole-conversation deletes dispatch that hook instead. */
-  MESSAGE_DELETED: "message-deleted",
 } as const;
 
 /** Union of every hook name declared in {@link HOOKS}. */

package/src/plugin-api/index.ts

@@ -110,7 +110,6 @@ export type {
   HookBroadcast,
   HookFunction,
   InitContext,
-  MessageDeletedContext,
   ModelProfileInfo,
   PluginLogger,
   PostCompactContext,

package/src/plugin-api/types.ts

@@ -16,7 +16,6 @@ export type {
   ConversationDeletedContext,
   ConversationsClearedContext,
   HookBroadcast,
-  MessageDeletedContext,
   PluginLogger,
   PostCompactContext,
   PostModelCallContext,
@@ -61,7 +60,6 @@ export type {
  *   - `post-model-call` — {@link PostModelCallContext}
  *   - `conversation-deleted` — {@link ConversationDeletedContext}
  *   - `conversations-cleared` — {@link ConversationsClearedContext}
- *   - `message-deleted`: {@link MessageDeletedContext}
  */
 export type HookFunction<TCtx = unknown> = (
   ctx: TCtx,

package/src/plugins/defaults/index.ts

@@ -65,7 +65,6 @@ import maxTokensContinuePkg from "./max-tokens-continue/package.json" with { typ
 import memoryConversationDeleted from "./memory/hooks/conversation-deleted.js";
 import memoryConversationsCleared from "./memory/hooks/conversations-cleared.js";
 import memoryInit from "./memory/hooks/init.js";
-import memoryMessageDeleted from "./memory/hooks/message-deleted.js";
 import memoryPostCompact from "./memory/hooks/post-compact.js";
 import memoryShutdown from "./memory/hooks/shutdown.js";
 import memoryUserPromptSubmit from "./memory/hooks/user-prompt-submit.js";
@@ -200,7 +199,6 @@ export const defaultMemoryPlugin: Plugin = {
     "post-compact": memoryPostCompact,
     "conversation-deleted": memoryConversationDeleted,
     "conversations-cleared": memoryConversationsCleared,
-    "message-deleted": memoryMessageDeleted,
   },
   injectors: memoryInjectors,
 };

package/src/plugins/defaults/memory/__tests__/memory-retrospective-accounting.test.ts

@@ -434,49 +434,3 @@ describe("ambient camera frames are not retrospective work", () => {
     expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(true);
   });
 });
-
-describe("retrospective accounting: a cursor survives its row's deletion", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run(`DELETE FROM messages`);
-    db.run(`DELETE FROM conversations`);
-    createConversation({ id: CONV });
-  });
-
-  test("a deleted cursor row with a stored timestamp still bounds the count, the slice, and the user-activity probe", () => {
-    insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
-    const reply = insertRaw({
-      role: "assistant",
-      content: TEXT,
-      createdAt: 2_000,
-    });
-    // Regenerate: the reply the cursor sits on is discarded and replaced.
-    getDb().delete(messages).where(eq(messages.id, reply)).run();
-    const regenerated = insertRaw({
-      role: "assistant",
-      content: TEXT,
-      createdAt: 3_000,
-    });
-    const followUp = insertRaw({
-      role: "user",
-      content: TEXT,
-      createdAt: 4_000,
-    });
-
-    const cursor = { id: reply, createdAt: 2_000 };
-    expect(countRetrospectiveMessagesAfter(CONV, cursor)).toBe(2);
-    expect(
-      getRetrospectiveMessagesAfter(CONV, cursor).map((r) => r.id),
-    ).toEqual([regenerated, followUp]);
-    expect(hasQualifyingUserMessageAfter(CONV, cursor)).toBe(true);
-  });
-
-  test("a deleted cursor row without a timestamp still reads as no new work", () => {
-    insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
-
-    const cursor = { id: "gone", createdAt: null };
-    expect(countRetrospectiveMessagesAfter(CONV, cursor)).toBe(0);
-    expect(getRetrospectiveMessagesAfter(CONV, cursor)).toEqual([]);
-    expect(hasQualifyingUserMessageAfter(CONV, cursor)).toBe(false);
-  });
-});

package/src/plugins/defaults/memory/__tests__/memory-retrospective-enqueue.test.ts

@@ -1,7 +1,5 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { MessagesAfterRef } from "../../../../persistence/message-cursor.js";
-
 // ---------------------------------------------------------------------------
 // Mock state — reset between tests.
 // ---------------------------------------------------------------------------
@@ -19,7 +17,6 @@ let cfgThrows = false;
 let mockStateRow: {
   conversationId: string;
   lastProcessedMessageId: string;
-  lastProcessedCreatedAt: number | null;
   lastRunAt: number;
   rememberedLog: string[];
 } | null = null;
@@ -27,7 +24,7 @@ let tailQualifies = true;
 let gateProbeThrows = false;
 let gateProbeCalls: Array<{
   conversationId: string;
-  after: MessagesAfterRef;
+  afterMessageId: string | null;
 }> = [];
 
 mock.module("../../../../persistence/conversation-crud.js", () => ({
@@ -71,9 +68,9 @@ mock.module("../memory-retrospective-state.js", () => ({
 mock.module("../memory-retrospective-accounting.js", () => ({
   hasQualifyingUserMessageAfter: (
     conversationId: string,
-    after: MessagesAfterRef,
+    afterMessageId: string | null,
   ) => {
-    gateProbeCalls.push({ conversationId, after });
+    gateProbeCalls.push({ conversationId, afterMessageId });
     if (gateProbeThrows) {
       throw new Error("messages table unavailable");
     }
@@ -173,11 +170,10 @@ describe("enqueueMemoryRetrospectiveIfEnabled", () => {
     expect(gateProbeCalls).toHaveLength(0);
   });
 
-  test("gate probes the tail from the state row's cursor, timestamp included", () => {
+  test("gate probes the tail from the state row's cursor", () => {
     mockStateRow = {
       conversationId: "c1",
       lastProcessedMessageId: "m9",
-      lastProcessedCreatedAt: 9_000,
       lastRunAt: 1,
       rememberedLog: [],
     };
@@ -187,7 +183,7 @@ describe("enqueueMemoryRetrospectiveIfEnabled", () => {
     });
 
     expect(gateProbeCalls).toEqual([
-      { conversationId: "c1", after: { id: "m9", createdAt: 9_000 } },
+      { conversationId: "c1", afterMessageId: "m9" },
     ]);
   });
 

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

@@ -20,7 +20,6 @@ let mockState: StateRow = null;
 let stateUpserts: Array<{
   conversationId: string;
   lastProcessedMessageId: string;
-  lastProcessedCreatedAt?: number | null;
   lastRunAt: number;
   rememberedLog?: string[];
 }> = [];
@@ -150,7 +149,6 @@ mock.module("../memory-retrospective-state.js", () => ({
   upsertRetrospectiveState: (args: {
     conversationId: string;
     lastProcessedMessageId: string;
-    lastProcessedCreatedAt?: number | null;
     lastRunAt: number;
     rememberedLog?: string[];
   }) => {
@@ -334,16 +332,15 @@ mock.module("../../../../persistence/jobs-store.js", () => ({
   },
 }));
 
-// Retrospective skill improvement is distinct from the v3 tier. Keep v3 live
-// while flipping the authoring gate so these tests prove the job reads the
-// dedicated predicate rather than using the broader tier predicate.
-let mockV3TierActive = true;
-let mockSkillImprovementActive = false;
+// The v3-tier gate. Drives both `buildForkInstruction`'s skill-authoring
+// section (proc-to-skills) and the wake's origin pin behavior. Default inactive
+// (remember-only), matching a stock install; tests flip it on to assert the
+// authoring section.
+let mockV3TierActive = false;
 mock.module("../../../../config/memory-v3-gate.js", () => ({
   isMemoryEnabled: (config?: { memory?: { enabled?: boolean } }) =>
     config?.memory?.enabled !== false,
   isV3TierActive: () => mockV3TierActive,
-  isSkillImprovementActive: () => mockSkillImprovementActive,
   isMemoryV3Live: () => mockV3TierActive,
   usesConceptPageMemory: (memory?: {
     enabled?: boolean;
@@ -507,8 +504,7 @@ describe("memoryRetrospectiveJob", () => {
     processingStartedAtById = {};
     mockResolvedUserSlug = "alice";
     resolveUserSlugCalls = [];
-    mockV3TierActive = true;
-    mockSkillImprovementActive = false;
+    mockV3TierActive = false;
   });
 
   test("first-run happy path: no state row, no prior retrospective, both pointer fields set on success", async () => {
@@ -522,11 +518,6 @@ describe("memoryRetrospectiveJob", () => {
     }
     expect(stateUpserts).toHaveLength(1);
     expect(stateUpserts[0]!.lastProcessedMessageId).toBe("m3");
-    // The cutoff's `createdAt` rides along so the cursor keeps bounding reads
-    // after a regenerate deletes m3.
-    expect(stateUpserts[0]!.lastProcessedCreatedAt).toBe(
-      Date.parse("2026-05-11T10:10:00Z"),
-    );
     expect(lastRunAtBumps).toHaveLength(0);
     expect(wakeCalls).toHaveLength(1);
     // Forks off the source so future runs can find it via
@@ -1317,7 +1308,7 @@ describe("memoryRetrospectiveJob", () => {
   });
 
   test("wake allows memory saves + skill authoring and suppresses the internal wake surface", async () => {
-    mockSkillImprovementActive = true;
+    mockV3TierActive = true;
     await memoryRetrospectiveJob(makeJob(), stubConfig);
 
     expect(forkCalls).toHaveLength(1);
@@ -1340,9 +1331,8 @@ describe("memoryRetrospectiveJob", () => {
     expect(opts.hintRole).toBe("user");
   });
 
-  test("wake is remember-only when skill improvement is disabled on a live v3 tier", async () => {
-    mockV3TierActive = true;
-    mockSkillImprovementActive = false;
+  test("wake is remember-only when proc-to-skills is inactive", async () => {
+    mockV3TierActive = false;
     await memoryRetrospectiveJob(makeJob(), stubConfig);
 
     expect(wakeCalls).toHaveLength(1);
@@ -2548,7 +2538,7 @@ describe("memoryRetrospectiveJob", () => {
   });
 
   test("proc-to-skills active: instruction carries the pre-check + dedup + companion-file directives", async () => {
-    mockSkillImprovementActive = true;
+    mockV3TierActive = true;
 
     await memoryRetrospectiveJob(makeJob(), stubConfig);
 

package/src/plugins/defaults/memory/__tests__/memory-retrospective-state.test.ts

@@ -6,22 +6,16 @@ import { setConfig } from "../../../../__tests__/helpers/set-config.js";
 // pipeline (both flags default true under the real loader).
 setConfig("memory", { enabled: false, v2: { enabled: false } });
 
-import { createConversation } from "../../../../persistence/conversation-crud.js";
 import {
   getDb,
   getMemorySqlite,
-  resetDb,
 } from "../../../../persistence/db-connection.js";
 import { initializeDb } from "../../../../persistence/db-init.js";
-import { messages } from "../../../../persistence/schema/index.js";
 import {
-  _resetRetrospectiveCursorColumnForTests,
   appendToRememberedLog,
   bumpRetrospectiveLastRunAt,
-  ensureRetrospectiveCursorColumn,
   forkRetrospectiveState,
   getRetrospectiveState,
-  listRetrospectiveStates,
   REMEMBERED_LOG_MAX_BYTES,
   REMEMBERED_LOG_MAX_ENTRIES,
   upsertRetrospectiveState,
@@ -182,219 +176,6 @@ describe("memory-retrospective-state remembered log persistence", () => {
   });
 });
 
-describe("memory-retrospective-state cursor timestamp", () => {
-  beforeEach(() => {
-    resetTables();
-  });
-
-  test("upsert persists lastProcessedCreatedAt and both reads return it", async () => {
-    await upsertRetrospectiveState({
-      conversationId: "conv-ts",
-      lastProcessedMessageId: "m1",
-      lastProcessedCreatedAt: 1_234,
-      lastRunAt: 1000,
-    });
-
-    expect(getRetrospectiveState("conv-ts")?.lastProcessedCreatedAt).toBe(
-      1_234,
-    );
-    expect(
-      listRetrospectiveStates(10).find((s) => s.conversationId === "conv-ts")
-        ?.lastProcessedCreatedAt,
-    ).toBe(1_234);
-  });
-
-  test("an upsert that omits the timestamp records unknown for the new pointer", async () => {
-    await upsertRetrospectiveState({
-      conversationId: "conv-ts",
-      lastProcessedMessageId: "m1",
-      lastProcessedCreatedAt: 1_234,
-      lastRunAt: 1000,
-    });
-    await upsertRetrospectiveState({
-      conversationId: "conv-ts",
-      lastProcessedMessageId: "m2",
-      lastRunAt: 2000,
-    });
-
-    const state = getRetrospectiveState("conv-ts");
-    expect(state?.lastProcessedMessageId).toBe("m2");
-    expect(state?.lastProcessedCreatedAt).toBeNull();
-  });
-
-  test("bumpRetrospectiveLastRunAt leaves the timestamp untouched", async () => {
-    await upsertRetrospectiveState({
-      conversationId: "conv-ts",
-      lastProcessedMessageId: "m1",
-      lastProcessedCreatedAt: 1_234,
-      lastRunAt: 1000,
-    });
-    await bumpRetrospectiveLastRunAt("conv-ts", 5000);
-
-    const state = getRetrospectiveState("conv-ts");
-    expect(state?.lastRunAt).toBe(5000);
-    expect(state?.lastProcessedCreatedAt).toBe(1_234);
-  });
-
-  test("forking carries the forked pointer's createdAt, read through the main handle", async () => {
-    const db = getDb();
-    createConversation({ id: "conv-fork-ts-src" });
-    createConversation({ id: "conv-fork-ts-dst" });
-    for (const [id, conversationId] of [
-      ["src-m1", "conv-fork-ts-src"],
-      ["dst-m1", "conv-fork-ts-dst"],
-    ] as const) {
-      db.insert(messages)
-        .values({
-          id,
-          conversationId,
-          role: "user",
-          content: "[]",
-          createdAt: 4_000,
-          metadata: null,
-        })
-        .run();
-    }
-    await upsertRetrospectiveState({
-      conversationId: "conv-fork-ts-src",
-      lastProcessedMessageId: "src-m1",
-      lastProcessedCreatedAt: 4_000,
-      lastRunAt: 1,
-    });
-
-    forkRetrospectiveState({
-      database: db,
-      sourceConversationId: "conv-fork-ts-src",
-      forkedConversationId: "conv-fork-ts-dst",
-      forkedMessageIds: new Map([["src-m1", "dst-m1"]]),
-      lastCopiedSourceMessageId: "src-m1",
-    });
-
-    const child = getRetrospectiveState("conv-fork-ts-dst");
-    expect(child?.lastProcessedMessageId).toBe("dst-m1");
-    expect(child?.lastProcessedCreatedAt).toBe(4_000);
-
-    db.run(`DELETE FROM messages`);
-    db.run(`DELETE FROM conversations`);
-  });
-
-  test("a source cursor whose row was regenerated away is placed by its stored bound, not clamped past the copies", async () => {
-    const db = getDb();
-    createConversation({ id: "conv-fork-bound-src" });
-    createConversation({ id: "conv-fork-bound-dst" });
-    // src-m2 (createdAt 2_000) was the cursor; a regenerate deleted it and
-    // src-m3 replaced it. The fork copies src-m1 and src-m3.
-    for (const [id, conversationId, createdAt] of [
-      ["src-m1", "conv-fork-bound-src", 1_000],
-      ["src-m3", "conv-fork-bound-src", 3_000],
-      ["dst-m1", "conv-fork-bound-dst", 1_000],
-      ["dst-m3", "conv-fork-bound-dst", 3_000],
-    ] as const) {
-      db.insert(messages)
-        .values({
-          id,
-          conversationId,
-          role: "user",
-          content: "[]",
-          createdAt,
-          metadata: null,
-        })
-        .run();
-    }
-    await upsertRetrospectiveState({
-      conversationId: "conv-fork-bound-src",
-      lastProcessedMessageId: "src-m2",
-      lastProcessedCreatedAt: 2_000,
-      lastRunAt: 1,
-    });
-
-    forkRetrospectiveState({
-      database: db,
-      sourceConversationId: "conv-fork-bound-src",
-      forkedConversationId: "conv-fork-bound-dst",
-      forkedMessageIds: new Map([
-        ["src-m1", "dst-m1"],
-        ["src-m3", "dst-m3"],
-      ]),
-      lastCopiedSourceMessageId: "src-m3",
-    });
-
-    const child = getRetrospectiveState("conv-fork-bound-dst");
-    expect(child?.lastProcessedMessageId).toBe("dst-m1");
-    expect(child?.lastProcessedCreatedAt).toBe(1_000);
-
-    // A bound before every copied row leaves the child with nothing processed.
-    await upsertRetrospectiveState({
-      conversationId: "conv-fork-bound-src",
-      lastProcessedMessageId: "src-m0",
-      lastProcessedCreatedAt: 500,
-      lastRunAt: 1,
-    });
-    forkRetrospectiveState({
-      database: db,
-      sourceConversationId: "conv-fork-bound-src",
-      forkedConversationId: "conv-fork-bound-dst",
-      forkedMessageIds: new Map([
-        ["src-m1", "dst-m1"],
-        ["src-m3", "dst-m3"],
-      ]),
-      lastCopiedSourceMessageId: "src-m3",
-    });
-    expect(
-      getRetrospectiveState("conv-fork-bound-dst")?.lastProcessedMessageId,
-    ).toBe("");
-
-    db.run(`DELETE FROM messages`);
-    db.run(`DELETE FROM conversations`);
-  });
-
-  test("ensureRetrospectiveCursorColumn adds the column to a legacy table once and is a no-op after", () => {
-    const raw = getMemorySqlite()!;
-    raw.exec("DROP TABLE memory_retrospective_state");
-    raw.exec(`
-      CREATE TABLE memory_retrospective_state (
-        conversation_id TEXT PRIMARY KEY,
-        last_processed_message_id TEXT NOT NULL,
-        last_run_at INTEGER NOT NULL,
-        remembered_log TEXT
-      )
-    `);
-    _resetRetrospectiveCursorColumnForTests();
-
-    expect(ensureRetrospectiveCursorColumn("test")).toBe(true);
-    expect(ensureRetrospectiveCursorColumn("test")).toBe(true);
-
-    const columns = raw
-      .query("PRAGMA table_info(memory_retrospective_state)")
-      .all() as Array<{ name: string }>;
-    expect(
-      columns.filter((c) => c.name === "last_processed_created_at"),
-    ).toHaveLength(1);
-  });
-
-  test("a replaced memory connection is probed again, so a restored database without the column gets it", () => {
-    expect(ensureRetrospectiveCursorColumn("test")).toBe(true);
-
-    // What a restore or import does: the stored connections are dropped and
-    // reopened. Strip the column on the reopened file to stand in for an
-    // older database.
-    resetDb();
-    const reopened = getMemorySqlite()!;
-    reopened.exec(
-      "ALTER TABLE memory_retrospective_state DROP COLUMN last_processed_created_at",
-    );
-
-    expect(getRetrospectiveState("conv-none")).toBeNull();
-    expect(ensureRetrospectiveCursorColumn("test")).toBe(true);
-    const columns = reopened
-      .query("PRAGMA table_info(memory_retrospective_state)")
-      .all() as Array<{ name: string }>;
-    expect(columns.some((c) => c.name === "last_processed_created_at")).toBe(
-      true,
-    );
-  });
-});
-
 describe("fail-soft when the underlying statement fails", () => {
   // The memory connection is present, but the relocated table is gone (a
   // corrupt/dropped table, SQLITE_FULL, I/O error, or SQLITE_BUSY after