@vellumai/assistant 0.12.1 → 0.12.2-staging.1

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

@@ -115,6 +115,11 @@ For everything else in your review window, use the \`remember\` tool on facts, p
     expect(out).toContain(
       "\n---\n\nIf your review window contains a PROCEDURE you actually carried out",
     );
+    // An UPDATE is announced by a notice whose only account of the change is
+    // what the pass passes here, so the instruction has to ask for it.
+    expect(out).toContain(
+      "and pass `change_summary` (the update is rejected without it): one or two short sentences (under 200 characters)",
+    );
     expect(
       out.endsWith(
         "skills are for executed, reusable procedures, not for facts.\n",

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

@@ -6,16 +6,22 @@ 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,
@@ -176,6 +182,219 @@ 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

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

@@ -412,3 +412,34 @@ describe("listSweepCandidateConversationIds", () => {
     ]);
   });
 });
+
+describe("runRetrospectiveSweep: cursor survives a regenerated reply", () => {
+  beforeEach(() => {
+    resetTables();
+    enqueueCalls = [];
+    enqueueDeclines = new Set();
+  });
+
+  test("a stale conversation whose cursor row was regenerated away is still swept", async () => {
+    const conv = createConversation({ id: "conv-a" });
+    insertMessage(conv.id, { createdAt: 1_000 });
+    const reply = insertMessage(conv.id, {
+      role: "assistant",
+      createdAt: 2_000,
+    });
+    await upsertRetrospectiveState({
+      conversationId: conv.id,
+      lastProcessedMessageId: reply,
+      lastProcessedCreatedAt: 2_000,
+      lastRunAt: Date.now() - SWEEP_INTERVAL_MS - 60_000,
+    });
+    getDb().delete(messages).where(eq(messages.id, reply)).run();
+    insertMessage(conv.id, { role: "assistant", createdAt: 3_000 });
+
+    await runRetrospectiveSweep(makeConfig());
+
+    expect(enqueueCalls).toEqual([
+      { conversationId: conv.id, trigger: "sweep" },
+    ]);
+  });
+});

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

@@ -12,6 +12,8 @@ mock.module("../memory-retrospective-enqueue.js", () => ({
   },
 }));
 
+import { eq } from "drizzle-orm";
+
 import type { AssistantConfig } from "../../../../config/types.js";
 import { createConversation } from "../../../../persistence/conversation-crud.js";
 import {
@@ -307,3 +309,64 @@ describe("maybeEnqueueRetrospective — kind-aware accounting", () => {
     ]);
   });
 });
+
+// ---------------------------------------------------------------------------
+// maybeEnqueueRetrospective: the cursor survives a regenerated reply.
+//
+// The cursor normally lands on the latest assistant reply, and a regenerate
+// deletes exactly that row. With its `createdAt` persisted the cursor still
+// bounds the count, so the conversation keeps getting retrospectives.
+// ---------------------------------------------------------------------------
+
+describe("maybeEnqueueRetrospective: cursor survives a regenerated reply", () => {
+  beforeEach(() => {
+    resetTables();
+    enqueueCalls = [];
+  });
+
+  test("a regenerate that deletes the cursor's row does not stall the conversation", async () => {
+    const conv = createConversation("conv");
+    insertMessage(conv.id, { createdAt: 1_000 });
+    const reply = insertMessage(conv.id, {
+      role: "assistant",
+      createdAt: 2_000,
+    });
+    await upsertRetrospectiveState({
+      conversationId: conv.id,
+      lastProcessedMessageId: reply,
+      lastProcessedCreatedAt: 2_000,
+      lastRunAt: Date.now() - 24 * 60 * 60_000,
+    });
+    // Regenerate: the retry route discards the latest assistant turn, then
+    // a fresh reply and the next user message land.
+    getDb().delete(messages).where(eq(messages.id, reply)).run();
+    insertMessage(conv.id, { role: "assistant", createdAt: 3_000 });
+    insertMessage(conv.id, { createdAt: 4_000 });
+
+    maybeEnqueueRetrospective(conv.id, makeConfig());
+
+    expect(enqueueCalls).toEqual([
+      { conversationId: conv.id, trigger: "interval" },
+    ]);
+  });
+
+  test("a cursor written without a timestamp still goes quiet once its row is gone", async () => {
+    const conv = createConversation("conv");
+    insertMessage(conv.id, { createdAt: 1_000 });
+    const reply = insertMessage(conv.id, {
+      role: "assistant",
+      createdAt: 2_000,
+    });
+    await upsertRetrospectiveState({
+      conversationId: conv.id,
+      lastProcessedMessageId: reply,
+      lastRunAt: Date.now() - 24 * 60 * 60_000,
+    });
+    getDb().delete(messages).where(eq(messages.id, reply)).run();
+    insertMessage(conv.id, { createdAt: 4_000 });
+
+    maybeEnqueueRetrospective(conv.id, makeConfig());
+
+    expect(enqueueCalls).toEqual([]);
+  });
+});

package/src/plugins/defaults/memory/__tests__/shutdown-hook.test.ts

@@ -14,6 +14,10 @@ mock.module("../worker-control.js", () => ({
   },
 }));
 
+mock.module("../skill-md-mtime-poll.js", () => ({
+  stopWorkspaceSkillMdMtimePoll: () => {},
+}));
+
 const memoryShutdown = (await import("../hooks/shutdown.js")).default;
 
 describe("memory shutdown hook", () => {

package/src/plugins/defaults/memory/context-search/agent-runner.ts

@@ -7,6 +7,7 @@ import type {
 import { getConfiguredProvider } from "@vellumai/plugin-api";
 
 import { redactSecrets } from "../../../../security/secret-scanner.js";
+import { safeStringSlice } from "../host-utils.js";
 import {
   buildRecallAgentPromptBundle,
   FINISH_RECALL_TOOL_DEFINITION,
@@ -862,9 +863,9 @@ function compactText(text: string, maxChars: number): string {
     return compacted;
   }
   if (maxChars <= 3) {
-    return compacted.slice(0, maxChars);
+    return safeStringSlice(compacted, 0, maxChars);
   }
-  return `${compacted.slice(0, maxChars - 3).trimEnd()}...`;
+  return `${safeStringSlice(compacted, 0, maxChars - 3).trimEnd()}...`;
 }
 
 function dedupeEvidenceById(

package/src/plugins/defaults/memory/context-search/format.ts

@@ -1,3 +1,4 @@
+import { safeStringSlice } from "../host-utils.js";
 import type {
   DeterministicRecallSearchResult,
   DeterministicRecallSourceNote,
@@ -139,9 +140,9 @@ function compactText(text: string, maxChars: number): string {
     return compacted;
   }
   if (maxChars <= 3) {
-    return compacted.slice(0, maxChars);
+    return safeStringSlice(compacted, 0, maxChars);
   }
-  return `${compacted.slice(0, maxChars - 3).trimEnd()}...`;
+  return `${safeStringSlice(compacted, 0, maxChars - 3).trimEnd()}...`;
 }
 
 function dedupeStrings(values: readonly string[]): string[] {

package/src/plugins/defaults/memory/context-search/sources/memory-v2.ts

@@ -27,6 +27,7 @@ import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import { extname, join } from "node:path";
 
 import { embedWithRetry } from "../../../../../persistence/embeddings/embed.js";
+import { safeStringSlice } from "../../host-utils.js";
 import { getLogger } from "../../logging.js";
 import { isPathInsideRoot } from "../../path-containment.js";
 import { getEdgeIndex } from "../../substrate/edge-index.js";
@@ -518,9 +519,11 @@ function buildLexicalExcerpt(
   if (focusedLine.length <= MEMORY_V2_LEXICAL_EXCERPT_MAX_CHARS) {
     return focusedLine;
   }
-  return `${focusedLine
-    .slice(0, MEMORY_V2_LEXICAL_EXCERPT_MAX_CHARS - 3)
-    .trimEnd()}...`;
+  return `${safeStringSlice(
+    focusedLine,
+    0,
+    MEMORY_V2_LEXICAL_EXCERPT_MAX_CHARS - 3,
+  ).trimEnd()}...`;
 }
 
 function toLexicalEvidence(match: MemoryV2LexicalMatch): RecallEvidence {

package/src/plugins/defaults/memory/context-search/sources/workspace.ts

@@ -1,6 +1,7 @@
 import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import { extname, isAbsolute, join, relative, sep } from "node:path";
 
+import { safeStringSlice } from "../../host-utils.js";
 import { isPathInsideRoot } from "../../path-containment.js";
 import type {
   RecallEvidence,
@@ -924,7 +925,7 @@ function buildExcerpt(lines: readonly string[], lineIndex: number): string {
     return focusedLine;
   }
 
-  return `${focusedLine.slice(0, EXCERPT_MAX_CHARS - 3).trimEnd()}...`;
+  return `${safeStringSlice(focusedLine, 0, EXCERPT_MAX_CHARS - 3).trimEnd()}...`;
 }
 
 function buildSectionExcerpt(
@@ -942,7 +943,7 @@ function buildSectionExcerpt(
     return excerpt;
   }
 
-  return `${excerpt.slice(0, SECTION_EXCERPT_MAX_CHARS - 3).trimEnd()}...`;
+  return `${safeStringSlice(excerpt, 0, SECTION_EXCERPT_MAX_CHARS - 3).trimEnd()}...`;
 }
 
 function buildStructuredJsonExcerpt(contents: string): string {

package/src/plugins/defaults/memory/graph/capability-seed.ts

@@ -16,6 +16,7 @@ import {
   loadSkillCatalog,
   type SkillSummary,
 } from "../../../../config/skills.js";
+import { loadWorkspaceMcpConfig } from "../../../../mcp/workspace-mcp-config.js";
 import {
   enqueueMemoryJob,
   upsertEmbedGraphNodeJob,
@@ -25,6 +26,7 @@ import {
   getCachedCatalogSync,
   getCatalog,
 } from "../../../../skills/catalog-cache.js";
+import { safeStringSlice } from "../host-utils.js";
 import { getLogger } from "../logging.js";
 import { memoryDbOrNull } from "../memory-db.js";
 import type { SkillCapabilityInput } from "../substrate/skill-content.js";
@@ -131,12 +133,9 @@ export function seedSkillGraphNodes(): void {
       const input = fromSkillSummary(summary);
 
       if (summary.id === "mcp-setup") {
-        const servers = config.mcp?.servers;
-        if (servers) {
-          const names = Object.keys(servers);
-          if (names.length > 0) {
-            input.description += ` Configured: ${names.join(", ")}`;
-          }
+        const names = Object.keys(loadWorkspaceMcpConfig().servers);
+        if (names.length > 0) {
+          input.description += ` Configured: ${names.join(", ")}`;
         }
       }
 
@@ -247,7 +246,7 @@ function buildSkillContent(input: SkillCapabilityInput): string {
     content += ` Avoid when: ${input.avoidWhen.join("; ")}.`;
   }
   if (content.length > 500) {
-    content = content.slice(0, 500);
+    content = safeStringSlice(content, 0, 500);
   }
   return content;
 }

package/src/plugins/defaults/memory/hooks/init.ts

@@ -17,6 +17,7 @@ import type { HookFunction, InitContext } from "@vellumai/plugin-api";
 import { getConfig } from "../../../../config/loader.js";
 import { registerMemoryPluginJobHandlers } from "../job-handler-registration.js";
 import { getLogger } from "../logging.js";
+import { backfillRetrospectiveCursorTimestamps } from "../memory-retrospective-cursor-backfill.js";
 import { runMemoryStartup } from "../startup.js";
 import { ensureMemoryV3PluginSchema } from "../v3/plugin-schema.js";
 
@@ -30,6 +31,15 @@ const init: HookFunction<InitContext> = async () => {
   // against an empty table and failed as an unknown type.
   registerMemoryPluginJobHandlers();
 
+  // Retrospective cursors written before the timestamp column existed can
+  // only be completed while their message rows still exist, so start the
+  // fill at boot, ahead of any client regenerating a reply. Detached and
+  // fail-open like the rest of memory startup; the memory worker runs the
+  // same idempotent pass as a second chance.
+  void backfillRetrospectiveCursorTimestamps().catch((err) =>
+    log.warn({ err }, "Retrospective cursor timestamp backfill failed"),
+  );
+
   // The memory-v3 plugin-owned schema on the memory connection
   // (`v3/plugin-schema.ts`): the pools and injected-sections tables and the
   // selection log's `section_key` column, ensured idempotently on every

package/src/plugins/defaults/memory/hooks/message-deleted.ts

@@ -0,0 +1,21 @@
+/**
+ * Default `memory` message-deleted hook.
+ *
+ * Stamps the conversation's retrospective cursor with the deleted row's
+ * `createdAt` when the cursor points at that row and was written without a
+ * timestamp (by a build before the column existed). The cursor usually sits
+ * on the latest assistant reply, which is exactly the row a regenerate
+ * deletes, and once the row is gone only the timestamp can place it.
+ */
+
+import type { HookFunction, MessageDeletedContext } from "@vellumai/plugin-api";
+
+import { preserveRetrospectiveCursorTimestamps } from "../memory-retrospective-cursor-preserve.js";
+
+const messageDeleted: HookFunction<MessageDeletedContext> = async (ctx) => {
+  await preserveRetrospectiveCursorTimestamps(ctx.conversationId, [
+    { id: ctx.messageId, createdAt: ctx.createdAt },
+  ]);
+};
+
+export default messageDeleted;

package/src/plugins/defaults/memory/hooks/shutdown.ts

@@ -9,9 +9,11 @@
 
 import type { HookFunction, ShutdownContext } from "@vellumai/plugin-api";
 
+import { stopWorkspaceSkillMdMtimePoll } from "../skill-md-mtime-poll.js";
 import { stopMemoryWorkerProcess } from "../worker-control.js";
 
 const shutdown: HookFunction<ShutdownContext> = async () => {
+  stopWorkspaceSkillMdMtimePoll();
   stopMemoryWorkerProcess();
 };
 

package/src/plugins/defaults/memory/host-utils.ts

@@ -25,6 +25,7 @@ import type { SqliteRetryOptions } from "../../../util/sqlite-retry.js";
 import * as hostSqliteRetry from "../../../util/sqlite-retry.js";
 import * as hostStripCommentLines from "../../../util/strip-comment-lines.js";
 import * as hostTruncate from "../../../util/truncate.js";
+import * as hostUnicode from "../../../util/unicode.js";
 import * as hostWorkerCompute from "../../../util/worker-compute.js";
 import * as hostWorkerMemory from "../../../util/worker-memory.js";
 
@@ -76,6 +77,15 @@ export function truncate(str: string, maxLen: number, suffix?: string): string {
     : hostTruncate.truncate(str, maxLen, suffix);
 }
 
+/** `String.prototype.slice` that never cuts a UTF-16 surrogate pair in half. */
+export function safeStringSlice(
+  str: string,
+  start?: number,
+  end?: number,
+): string {
+  return hostUnicode.safeStringSlice(str, start, end);
+}
+
 export function workerMemoryEnv(): Record<string, string | undefined> {
   return hostWorkerMemory.workerMemoryEnv();
 }

package/src/plugins/defaults/memory/jobs-worker.ts

@@ -62,6 +62,7 @@ import {
 import { isJobQueueResolution, type JobHandler } from "../../types.js";
 import { sweepOrphanConversationMemoryTables } from "./conversation-memory-orphan-sweep.js";
 import { getLogger } from "./logging.js";
+import { backfillRetrospectiveCursorTimestamps } from "./memory-retrospective-cursor-backfill.js";
 import { sweepOrphanMemoryRetrospectiveConversations } from "./memory-retrospective-startup-cleanup.js";
 import { getWorkspaceDir } from "./paths.js";
 // SUBSTRATE (v2+v3) — feeds `enqueueSubstrateMaintenanceJobs`.
@@ -259,6 +260,18 @@ export function startMemoryJobsWorkerLoop(): MemoryJobsWorker {
     );
   });
 
+  // Second chance for the cursor timestamp backfill the daemon's memory init
+  // hook starts at boot: rows written before the column existed get their
+  // `createdAt` so a later deletion of the row they point at (a regenerated
+  // reply) cannot stall the conversation's retrospectives. Idempotent,
+  // detached, and best-effort, same as the sweeps.
+  void backfillRetrospectiveCursorTimestamps().catch((err: unknown) => {
+    log.warn(
+      { err },
+      "Retrospective cursor timestamp backfill failed; continuing worker startup",
+    );
+  });
+
   // Also catch up on relocated conversation-keyed tables orphaned while the
   // plugin was disabled: with memory off, the conversation-deleted hook never
   // fired, so deletes during that window left rows behind (the pre-Wave-2 main