@vellumai/assistant 0.12.1-staging.1 → 0.12.1

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

@@ -12,8 +12,6 @@ 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 {
@@ -309,64 +307,3 @@ 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,10 +14,6 @@ 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/graph/capability-seed.ts

@@ -16,7 +16,6 @@ import {
   loadSkillCatalog,
   type SkillSummary,
 } from "../../../../config/skills.js";
-import { loadWorkspaceMcpConfig } from "../../../../mcp/workspace-mcp-config.js";
 import {
   enqueueMemoryJob,
   upsertEmbedGraphNodeJob,
@@ -132,9 +131,12 @@ export function seedSkillGraphNodes(): void {
       const input = fromSkillSummary(summary);
 
       if (summary.id === "mcp-setup") {
-        const names = Object.keys(loadWorkspaceMcpConfig().servers);
-        if (names.length > 0) {
-          input.description += ` Configured: ${names.join(", ")}`;
+        const servers = config.mcp?.servers;
+        if (servers) {
+          const names = Object.keys(servers);
+          if (names.length > 0) {
+            input.description += ` Configured: ${names.join(", ")}`;
+          }
         }
       }
 

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

@@ -17,7 +17,6 @@ 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";
 
@@ -31,15 +30,6 @@ 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/shutdown.ts

@@ -9,11 +9,9 @@
 
 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/jobs-worker.ts

@@ -62,7 +62,6 @@ 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`.
@@ -260,18 +259,6 @@ 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

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

@@ -31,7 +31,7 @@
 // accounting; once newer real messages arrive it is copied into the next
 // run's fork as inert prefix context.
 
-import { and, eq, like, or } from "drizzle-orm";
+import { and, eq, gt, like, or } from "drizzle-orm";
 
 import {
   countMessagesAfter,
@@ -43,11 +43,6 @@ import {
   SIGHT_FRAME_ATTACHMENT_IDS_KEY,
 } from "../../../persistence/conversation-types.js";
 import { getDb } from "../../../persistence/db-connection.js";
-import {
-  messagesAfterBoundFilter,
-  type MessagesAfterRef,
-  resolveMessagesAfterBound,
-} from "../../../persistence/message-cursor.js";
 import { messages } from "../../../persistence/schema/index.js";
 import { SKILL_CARD_MESSAGE_KIND } from "./memory-retrospective-constants.js";
 
@@ -103,9 +98,9 @@ export function isSkillCardMessage(row: { metadata: string | null }): boolean {
  */
 export function getRetrospectiveMessagesAfter(
   conversationId: string,
-  after: MessagesAfterRef,
+  afterMessageId: string | null,
 ): MessageRow[] {
-  const rows = getMessagesAfter(conversationId, after);
+  const rows = getMessagesAfter(conversationId, afterMessageId);
   const firstUnfinalized = rows.findIndex((row) => row.finalized !== 1);
   const bounded =
     firstUnfinalized === -1 ? rows : rows.slice(0, firstUnfinalized);
@@ -121,13 +116,13 @@ export function getRetrospectiveMessagesAfter(
  */
 export function countRetrospectiveMessagesAfter(
   conversationId: string,
-  after: MessagesAfterRef,
+  afterMessageId: string | null,
 ): number {
-  const total = countMessagesAfter(conversationId, after);
+  const total = countMessagesAfter(conversationId, afterMessageId);
   if (total === 0) {
     return 0;
   }
-  const excluded = countExcludedMessagesAfter(conversationId, after);
+  const excluded = countExcludedMessagesAfter(conversationId, afterMessageId);
   return Math.max(0, total - excluded);
 }
 
@@ -172,8 +167,7 @@ export function messagesHaveUserActivity(
  * a non-tool_result block. Powers the `memory.retrospective.requireUserActivity`
  * enqueue gate, so only user rows are loaded. Cursor semantics mirror
  * `countMessagesAfter`: a null/`""` reference scans the whole conversation,
- * a cursor whose row is gone falls back to the timestamp it carries, and a
- * bare id whose row is gone means no new work.
+ * and a vanished reference means no new work.
  *
  * Operates on the raw `content` column: rows that do not parse to a block
  * array (file-backed `{ ref }` rows, legacy plain strings) count as
@@ -183,15 +177,37 @@ export function messagesHaveUserActivity(
  */
 export function hasQualifyingUserMessageAfter(
   conversationId: string,
-  after: MessagesAfterRef,
+  afterMessageId: string | null,
 ): boolean {
-  const start = resolveMessagesAfterBound(after);
-  if (start.kind === "vanished") {
-    return false;
+  const cursorId =
+    afterMessageId === null || afterMessageId === "" ? null : afterMessageId;
+  const db = getDb();
+
+  let ref: { createdAt: number } | undefined;
+  if (cursorId !== null) {
+    ref = db
+      .select({ createdAt: messages.createdAt })
+      .from(messages)
+      .where(eq(messages.id, cursorId))
+      .get();
+    if (!ref) {
+      return false;
+    }
   }
+
   const afterCursor =
-    start.kind === "after" ? [messagesAfterBoundFilter(start.bound)] : [];
-  const rows = getDb()
+    cursorId !== null && ref
+      ? [
+          or(
+            gt(messages.createdAt, ref.createdAt),
+            and(
+              eq(messages.createdAt, ref.createdAt),
+              gt(messages.id, cursorId),
+            ),
+          ),
+        ]
+      : [];
+  const rows = db
     .select({ content: messages.content, metadata: messages.metadata })
     .from(messages)
     .where(
@@ -232,14 +248,18 @@ function rawUserContentCarriesActivity(raw: string | null): boolean {
  * — at most one per successful retrospective run); each candidate is then
  * JSON-verified by {@link isSkillCardMessage} so an incidental substring
  * match in unrelated metadata can never exclude a real message from
- * accounting. The cursor resolves exactly as `countMessagesAfter`'s does,
- * including the null/`""` "count everything" cases and the vanished-reference
- * "no new work" case.
+ * accounting. The cursor comparison mirrors `countMessagesAfter`'s
+ * tie-breaker semantics, including the null/`""` "count everything" cases
+ * and the vanished-reference "no new work" case.
  */
 function countExcludedMessagesAfter(
   conversationId: string,
-  after: MessagesAfterRef,
+  afterMessageId: string | null,
 ): number {
+  // The `""` sentinel (failure-only state rows) counts everything, matching
+  // `countMessagesAfter`.
+  const cursorId =
+    afterMessageId === null || afterMessageId === "" ? null : afterMessageId;
   const db = getDb();
   const candidates = db
     .select({
@@ -262,11 +282,18 @@ function countExcludedMessagesAfter(
     return 0;
   }
 
-  const start = resolveMessagesAfterBound(after);
-  // Vanished reference: `countMessagesAfter` reported 0, so there is nothing
-  // to subtract from.
-  if (start.kind === "vanished") {
-    return 0;
+  let ref: { createdAt: number } | undefined;
+  if (cursorId !== null) {
+    ref = db
+      .select({ createdAt: messages.createdAt })
+      .from(messages)
+      .where(eq(messages.id, cursorId))
+      .get();
+    // Vanished reference: `countMessagesAfter` reported 0, so there is
+    // nothing to subtract from.
+    if (!ref) {
+      return 0;
+    }
   }
 
   let count = 0;
@@ -274,12 +301,11 @@ function countExcludedMessagesAfter(
     if (!isExcludedFromRetrospectiveAccounting(row)) {
       continue;
     }
-    if (start.kind === "after") {
-      const { createdAt, id } = start.bound;
-      const isAfter =
-        row.createdAt > createdAt ||
-        (row.createdAt === createdAt && row.id > id);
-      if (!isAfter) {
+    if (cursorId !== null && ref) {
+      const after =
+        row.createdAt > ref.createdAt ||
+        (row.createdAt === ref.createdAt && row.id > cursorId);
+      if (!after) {
         continue;
       }
     }

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

@@ -47,7 +47,6 @@ import { resolveCapabilities } from "../../../runtime/capabilities.js";
 import { getLogger } from "./logging.js";
 import { hasQualifyingUserMessageAfter } from "./memory-retrospective-accounting.js";
 import { isMemoryRetrospectiveSource } from "./memory-retrospective-constants.js";
-import { retrospectiveCursor } from "./memory-retrospective-cursor.js";
 import { getRetrospectiveState } from "./memory-retrospective-state.js";
 
 const log = getLogger("memory-retrospective-enqueue");
@@ -140,7 +139,7 @@ function isRetrospectiveEnabled(): boolean {
 /**
  * The `memory.retrospective.requireUserActivity` gate: pass when the config
  * is off or the unprocessed tail (everything after the conversation's
- * retrospective cursor) contains at least one user message carrying
+ * `lastProcessedMessageId`) contains at least one user message carrying
  * non-tool_result content. A gate that cannot be evaluated (config or DB
  * unavailable) passes — an unevaluable gate must not silence retrospectives.
  */
@@ -154,7 +153,10 @@ function passesUserActivityGate(
     }
     const state = getRetrospectiveState(conversationId);
     if (
-      hasQualifyingUserMessageAfter(conversationId, retrospectiveCursor(state))
+      hasQualifyingUserMessageAfter(
+        conversationId,
+        state?.lastProcessedMessageId ?? null,
+      )
     ) {
       return true;
     }

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

@@ -58,7 +58,7 @@ import {
   parseClientOs,
   parseInterfaceId,
 } from "../../../channels/types.js";
-import { isSkillImprovementActive } from "../../../config/memory-v3-gate.js";
+import { isV3TierActive } from "../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../config/types.js";
 import { warmGuardianBindings } from "../../../contacts/guardian-delivery-reader.js";
 import { extractTurnContextTimestamp } from "../../../context/compactor.js";
@@ -95,7 +95,6 @@ import {
   MEMORY_RETROSPECTIVE_SOURCE,
   SKILL_MANAGEMENT_SKILL_ID,
 } from "./memory-retrospective-constants.js";
-import { retrospectiveCursor } from "./memory-retrospective-cursor.js";
 import { loadRetrospectiveRunMessages } from "./memory-retrospective-fork-boundary.js";
 import { buildForkInstruction } from "./memory-retrospective-prompt.js";
 import {
@@ -358,7 +357,7 @@ export async function runForkBasedRetrospective(
   // `memory-retrospective-accounting.ts`.
   const newMessages = getRetrospectiveMessagesAfter(
     sourceConversationId,
-    retrospectiveCursor(state),
+    lastProcessedMessageId,
   );
 
   if (newMessages.length === 0) {
@@ -449,7 +448,7 @@ export async function runForkBasedRetrospective(
   }
   const forkId = forkConversationRow.id;
 
-  const procToSkillsActive = isSkillImprovementActive(config);
+  const procToSkillsActive = isV3TierActive(config);
   const instruction = buildForkInstruction({
     windowStartTimestamp,
     windowAnchorKind: turnContextTimestamp ? "turn_context" : "created_at",
@@ -651,7 +650,6 @@ export async function runForkBasedRetrospective(
         sourceConversationId,
         retrospectiveConversationId: forkId,
         cutoffMessageId,
-        cutoffCreatedAt: cutoffMessage.createdAt,
         newMessageCount: newMessages.length,
         prior,
         priorRemembers,
@@ -949,11 +947,6 @@ async function finalizeSuccessfulRetrospective(args: {
   sourceConversationId: string;
   retrospectiveConversationId: string;
   cutoffMessageId: string;
-  /**
-   * `createdAt` of the cutoff row, persisted beside its id so the cursor
-   * keeps bounding reads after the row is deleted.
-   */
-  cutoffCreatedAt: number;
   newMessageCount: number;
   prior: PriorRetrospective | null;
   priorRemembers: string[];
@@ -973,7 +966,6 @@ async function finalizeSuccessfulRetrospective(args: {
     sourceConversationId,
     retrospectiveConversationId,
     cutoffMessageId,
-    cutoffCreatedAt,
     newMessageCount,
     prior,
     priorRemembers,
@@ -985,7 +977,6 @@ async function finalizeSuccessfulRetrospective(args: {
   await upsertRetrospectiveState({
     conversationId: sourceConversationId,
     lastProcessedMessageId: cutoffMessageId,
-    lastProcessedCreatedAt: cutoffCreatedAt,
     lastRunAt: Date.now(),
     rememberedLog: appendToRememberedLog(priorRemembers, runRemembers),
   });