@vellumai/assistant 0.12.1 → 0.12.2-staging.1

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

@@ -0,0 +1,149 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateInviteContactId } from "../157-invite-contact-id.js";
+import { tableExists, tableHasColumn } from "../schema-introspection.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  return drizzle(sqlite, { schema });
+}
+
+function columnNotNull(raw: Database, name: string): boolean {
+  const cols = raw.query(`PRAGMA table_info(assistant_ingress_invites)`).all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+  return cols.some((c) => c.name === name && c.notnull === 1);
+}
+
+describe("migrateInviteContactId", () => {
+  test("rebuilds a legacy created_by_session_id table with NOT NULL contact_id", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    raw.exec(/*sql*/ `
+      CREATE TABLE assistant_ingress_invites (
+        id TEXT PRIMARY KEY,
+        source_channel TEXT NOT NULL,
+        token_hash TEXT NOT NULL,
+        created_by_session_id TEXT,
+        note TEXT,
+        max_uses INTEGER NOT NULL DEFAULT 1,
+        use_count INTEGER NOT NULL DEFAULT 0,
+        expires_at INTEGER NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        redeemed_by_external_user_id TEXT,
+        redeemed_by_external_chat_id TEXT,
+        redeemed_at INTEGER,
+        expected_external_user_id TEXT,
+        voice_code_hash TEXT,
+        voice_code_digits INTEGER,
+        invite_code_hash TEXT,
+        friend_name TEXT,
+        guardian_name TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, created_by_session_id, max_uses, use_count,
+          expires_at, status, created_at, updated_at)
+       VALUES ('inv-keep', 'slack', 'hash-keep', 'conv-1', 1, 0, 9, 'active', 1, 1)`,
+    );
+    raw.exec(
+      `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
+    );
+    raw.run(
+      `UPDATE assistant_ingress_invites SET contact_id = 'contact-keep' WHERE id = 'inv-keep'`,
+    );
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, max_uses, use_count, expires_at, status,
+          created_at, updated_at)
+       VALUES ('inv-drop', 'slack', 'hash-drop', 1, 0, 9, 'active', 1, 1)`,
+    );
+
+    migrateInviteContactId(db);
+
+    expect(tableHasColumn(db, "assistant_ingress_invites", "contact_id")).toBe(
+      true,
+    );
+    expect(columnNotNull(raw, "contact_id")).toBe(true);
+    expect(
+      tableHasColumn(db, "assistant_ingress_invites", "created_by_session_id"),
+    ).toBe(true);
+    const rows = raw
+      .query(`SELECT id, contact_id FROM assistant_ingress_invites ORDER BY id`)
+      .all() as Array<{ id: string; contact_id: string }>;
+    expect(rows).toEqual([{ id: "inv-keep", contact_id: "contact-keep" }]);
+  });
+
+  test("rebuilds after created_by_session_id was renamed to source_conversation_id", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    raw.exec(/*sql*/ `
+      CREATE TABLE assistant_ingress_invites (
+        id TEXT PRIMARY KEY,
+        source_channel TEXT NOT NULL,
+        token_hash TEXT NOT NULL,
+        source_conversation_id TEXT,
+        note TEXT,
+        max_uses INTEGER NOT NULL DEFAULT 1,
+        use_count INTEGER NOT NULL DEFAULT 0,
+        expires_at INTEGER NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        redeemed_by_external_user_id TEXT,
+        redeemed_by_external_chat_id TEXT,
+        redeemed_at INTEGER,
+        expected_external_user_id TEXT,
+        voice_code_hash TEXT,
+        voice_code_digits INTEGER,
+        invite_code_hash TEXT,
+        friend_name TEXT,
+        guardian_name TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    raw.exec(
+      `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
+    );
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, source_conversation_id, contact_id,
+          max_uses, use_count, expires_at, status, created_at, updated_at)
+       VALUES ('inv-1', 'slack', 'hash-1', 'conv-9', 'contact-1', 1, 0, 9, 'active', 1, 1)`,
+    );
+
+    migrateInviteContactId(db);
+
+    expect(columnNotNull(raw, "contact_id")).toBe(true);
+    expect(
+      tableHasColumn(db, "assistant_ingress_invites", "source_conversation_id"),
+    ).toBe(true);
+    expect(
+      tableHasColumn(db, "assistant_ingress_invites", "created_by_session_id"),
+    ).toBe(false);
+    const row = raw
+      .query(
+        `SELECT source_conversation_id, contact_id FROM assistant_ingress_invites WHERE id = 'inv-1'`,
+      )
+      .get() as { source_conversation_id: string; contact_id: string };
+    expect(row).toEqual({
+      source_conversation_id: "conv-9",
+      contact_id: "contact-1",
+    });
+  });
+
+  test("is a no-op when the table does not exist", () => {
+    const db = createTestDb();
+    migrateInviteContactId(db);
+    expect(tableExists(db, "assistant_ingress_invites")).toBe(false);
+  });
+});

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

@@ -104,6 +104,11 @@ 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,7 +24,9 @@ mock.module("../providers/platform-proxy/context.js", () => ({
   resolveManagedProxyContext: () => mockResolveManagedProxyContext(),
 }));
 
+const actualEnv = await import("../config/env.js");
 mock.module("../config/env.js", () => ({
+  ...actualEnv,
   getPlatformAssistantId: () => mockAssistantId,
 }));
 
@@ -113,11 +115,11 @@ describe("VellumPlatformClient", () => {
         platformBaseUrl: "",
         assistantApiKey: "",
       };
-      mockAssistantId = "";
+      mockAssistantId = "stored-assistant-id";
       mockSecureKeys = {
         "vellum:platform_base_url": "https://stored-platform.example.com/",
         "vellum:assistant_api_key": "stored-api-key",
-        "vellum:platform_assistant_id": " stored-assistant-id ",
+        "vellum:platform_assistant_id": " vault-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 { getPlatformAssistantId } from "../config/env.js";
+import { resolvePlatformAssistantId } from "../config/platform-identity.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 : "";
-  let assistantId = getPlatformAssistantId();
+  const assistantId = await resolvePlatformAssistantId();
 
   // Fall back to credential store for values not yet rehydrated (standalone CLI).
   if (!baseUrl) {
@@ -76,14 +76,6 @@ 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,6 +34,8 @@ 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,6 +110,7 @@ export type {
   HookBroadcast,
   HookFunction,
   InitContext,
+  MessageDeletedContext,
   ModelProfileInfo,
   PluginLogger,
   PostCompactContext,

package/src/plugin-api/types.ts

@@ -16,6 +16,7 @@ export type {
   ConversationDeletedContext,
   ConversationsClearedContext,
   HookBroadcast,
+  MessageDeletedContext,
   PluginLogger,
   PostCompactContext,
   PostModelCallContext,
@@ -60,6 +61,7 @@ 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,6 +65,7 @@ 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";
@@ -199,6 +200,7 @@ 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,3 +434,49 @@ 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-cursor-backfill.test.ts

@@ -0,0 +1,118 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "../../../../__tests__/helpers/set-config.js";
+
+// Disable memory so persistence writes don't index into the real memory
+// 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,
+} from "../../../../persistence/db-connection.js";
+import { initializeDb } from "../../../../persistence/db-init.js";
+import { messages } from "../../../../persistence/schema/index.js";
+import { backfillRetrospectiveCursorTimestamps } from "../memory-retrospective-cursor-backfill.js";
+import {
+  ensureRetrospectiveCursorColumn,
+  getRetrospectiveState,
+} from "../memory-retrospective-state.js";
+
+await initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run(`DELETE FROM messages`);
+  db.run(`DELETE FROM conversations`);
+  getMemorySqlite()!.exec(`DELETE FROM memory_retrospective_state`);
+}
+
+/** A state row as written before the timestamp column existed. */
+function insertLegacyState(conversationId: string, messageId: string): void {
+  ensureRetrospectiveCursorColumn("test");
+  getMemorySqlite()!
+    .query(
+      `INSERT INTO memory_retrospective_state
+         (conversation_id, last_processed_message_id, last_run_at, remembered_log, last_processed_created_at)
+       VALUES (?, ?, 1, NULL, NULL)`,
+    )
+    .run(conversationId, messageId);
+}
+
+function insertMessage(
+  conversationId: string,
+  id: string,
+  createdAt: number,
+): void {
+  getDb()
+    .insert(messages)
+    .values({
+      id,
+      conversationId,
+      role: "user",
+      content: "[]",
+      createdAt,
+      metadata: null,
+    })
+    .run();
+}
+
+describe("backfillRetrospectiveCursorTimestamps", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("fills the timestamp from the cursor's message, leaves vanished cursors NULL, and is idempotent", async () => {
+    createConversation({ id: "conv-a" });
+    createConversation({ id: "conv-b" });
+    createConversation({ id: "conv-c" });
+    insertMessage("conv-a", "a-m1", 1_000);
+    insertLegacyState("conv-a", "a-m1");
+    // Cursor row already deleted: nothing left to recover.
+    insertLegacyState("conv-b", "gone");
+    // The failure-only sentinel is never a cursor, so it is never scanned.
+    insertLegacyState("conv-c", "");
+
+    const first = await backfillRetrospectiveCursorTimestamps();
+
+    expect(first).toEqual({ scanned: 2, backfilled: 1, unrecoverable: 1 });
+    expect(getRetrospectiveState("conv-a")?.lastProcessedCreatedAt).toBe(1_000);
+    expect(getRetrospectiveState("conv-b")?.lastProcessedCreatedAt).toBeNull();
+    expect(getRetrospectiveState("conv-c")?.lastProcessedCreatedAt).toBeNull();
+
+    const second = await backfillRetrospectiveCursorTimestamps();
+
+    expect(second).toEqual({ scanned: 1, backfilled: 0, unrecoverable: 1 });
+  });
+
+  test("pages through the backlog by conversation id, advancing past unrecoverable rows", async () => {
+    for (const id of ["conv-1", "conv-2", "conv-3", "conv-4", "conv-5"]) {
+      createConversation({ id });
+    }
+    insertMessage("conv-1", "m-1", 1_000);
+    insertLegacyState("conv-1", "m-1");
+    insertLegacyState("conv-2", "gone-2");
+    insertMessage("conv-3", "m-3", 3_000);
+    insertLegacyState("conv-3", "m-3");
+    insertLegacyState("conv-4", "gone-4");
+    insertMessage("conv-5", "m-5", 5_000);
+    insertLegacyState("conv-5", "m-5");
+
+    const result = await backfillRetrospectiveCursorTimestamps({ pageSize: 2 });
+
+    expect(result).toEqual({ scanned: 5, backfilled: 3, unrecoverable: 2 });
+    expect(getRetrospectiveState("conv-1")?.lastProcessedCreatedAt).toBe(1_000);
+    expect(getRetrospectiveState("conv-3")?.lastProcessedCreatedAt).toBe(3_000);
+    expect(getRetrospectiveState("conv-5")?.lastProcessedCreatedAt).toBe(5_000);
+    expect(getRetrospectiveState("conv-4")?.lastProcessedCreatedAt).toBeNull();
+  });
+
+  test("a table with nothing to fill is a clean no-op", async () => {
+    expect(await backfillRetrospectiveCursorTimestamps()).toEqual({
+      scanned: 0,
+      backfilled: 0,
+      unrecoverable: 0,
+    });
+  });
+});

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

@@ -0,0 +1,83 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "../../../../__tests__/helpers/set-config.js";
+
+// Disable memory so persistence writes don't index into the real memory
+// pipeline (both flags default true under the real loader).
+setConfig("memory", { enabled: false, v2: { enabled: false } });
+
+import { getMemorySqlite } from "../../../../persistence/db-connection.js";
+import { initializeDb } from "../../../../persistence/db-init.js";
+import { preserveRetrospectiveCursorTimestamps } from "../memory-retrospective-cursor-preserve.js";
+import {
+  ensureRetrospectiveCursorColumn,
+  getRetrospectiveState,
+  upsertRetrospectiveState,
+} from "../memory-retrospective-state.js";
+
+await initializeDb();
+
+/** A state row as written before the timestamp column existed. */
+function insertLegacyState(conversationId: string, messageId: string): void {
+  ensureRetrospectiveCursorColumn("test");
+  getMemorySqlite()!
+    .query(
+      `INSERT INTO memory_retrospective_state
+         (conversation_id, last_processed_message_id, last_run_at, remembered_log, last_processed_created_at)
+       VALUES (?, ?, 1, NULL, NULL)`,
+    )
+    .run(conversationId, messageId);
+}
+
+describe("preserveRetrospectiveCursorTimestamps", () => {
+  beforeEach(() => {
+    getMemorySqlite()!.exec(`DELETE FROM memory_retrospective_state`);
+  });
+
+  test("records the timestamp of a legacy cursor whose row is about to be deleted", async () => {
+    insertLegacyState("conv-a", "reply-1");
+
+    await preserveRetrospectiveCursorTimestamps("conv-a", [
+      { id: "tool-1", createdAt: 1_500 },
+      { id: "reply-1", createdAt: 2_000 },
+    ]);
+
+    expect(getRetrospectiveState("conv-a")?.lastProcessedCreatedAt).toBe(2_000);
+  });
+
+  test("leaves a cursor that already has a timestamp, points elsewhere, or does not exist untouched", async () => {
+    await upsertRetrospectiveState({
+      conversationId: "conv-stamped",
+      lastProcessedMessageId: "reply-1",
+      lastProcessedCreatedAt: 1_000,
+      lastRunAt: 1,
+    });
+    insertLegacyState("conv-elsewhere", "older-reply");
+
+    await preserveRetrospectiveCursorTimestamps("conv-stamped", [
+      { id: "reply-1", createdAt: 9_999 },
+    ]);
+    await preserveRetrospectiveCursorTimestamps("conv-elsewhere", [
+      { id: "reply-1", createdAt: 9_999 },
+    ]);
+    await preserveRetrospectiveCursorTimestamps("conv-missing", [
+      { id: "reply-1", createdAt: 9_999 },
+    ]);
+
+    expect(getRetrospectiveState("conv-stamped")?.lastProcessedCreatedAt).toBe(
+      1_000,
+    );
+    expect(
+      getRetrospectiveState("conv-elsewhere")?.lastProcessedCreatedAt,
+    ).toBeNull();
+    expect(getRetrospectiveState("conv-missing")).toBeNull();
+  });
+
+  test("an empty row list is a no-op", async () => {
+    insertLegacyState("conv-a", "reply-1");
+
+    await preserveRetrospectiveCursorTimestamps("conv-a", []);
+
+    expect(getRetrospectiveState("conv-a")?.lastProcessedCreatedAt).toBeNull();
+  });
+});

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

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

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

@@ -20,6 +20,7 @@ let mockState: StateRow = null;
 let stateUpserts: Array<{
   conversationId: string;
   lastProcessedMessageId: string;
+  lastProcessedCreatedAt?: number | null;
   lastRunAt: number;
   rememberedLog?: string[];
 }> = [];
@@ -149,6 +150,7 @@ mock.module("../memory-retrospective-state.js", () => ({
   upsertRetrospectiveState: (args: {
     conversationId: string;
     lastProcessedMessageId: string;
+    lastProcessedCreatedAt?: number | null;
     lastRunAt: number;
     rememberedLog?: string[];
   }) => {
@@ -332,15 +334,16 @@ mock.module("../../../../persistence/jobs-store.js", () => ({
   },
 }));
 
-// 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;
+// 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;
 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;
@@ -504,7 +507,8 @@ describe("memoryRetrospectiveJob", () => {
     processingStartedAtById = {};
     mockResolvedUserSlug = "alice";
     resolveUserSlugCalls = [];
-    mockV3TierActive = false;
+    mockV3TierActive = true;
+    mockSkillImprovementActive = false;
   });
 
   test("first-run happy path: no state row, no prior retrospective, both pointer fields set on success", async () => {
@@ -518,6 +522,11 @@ 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
@@ -1308,7 +1317,7 @@ describe("memoryRetrospectiveJob", () => {
   });
 
   test("wake allows memory saves + skill authoring and suppresses the internal wake surface", async () => {
-    mockV3TierActive = true;
+    mockSkillImprovementActive = true;
     await memoryRetrospectiveJob(makeJob(), stubConfig);
 
     expect(forkCalls).toHaveLength(1);
@@ -1331,8 +1340,9 @@ describe("memoryRetrospectiveJob", () => {
     expect(opts.hintRole).toBe("user");
   });
 
-  test("wake is remember-only when proc-to-skills is inactive", async () => {
-    mockV3TierActive = false;
+  test("wake is remember-only when skill improvement is disabled on a live v3 tier", async () => {
+    mockV3TierActive = true;
+    mockSkillImprovementActive = false;
     await memoryRetrospectiveJob(makeJob(), stubConfig);
 
     expect(wakeCalls).toHaveLength(1);
@@ -2538,7 +2548,7 @@ describe("memoryRetrospectiveJob", () => {
   });
 
   test("proc-to-skills active: instruction carries the pre-check + dedup + companion-file directives", async () => {
-    mockV3TierActive = true;
+    mockSkillImprovementActive = true;
 
     await memoryRetrospectiveJob(makeJob(), stubConfig);