@vellumai/assistant 0.12.1 → 0.12.2-staging.2

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

@@ -5,7 +5,11 @@
 // Two pointers move independently:
 //   - `lastProcessedMessageId` advances ONLY when a retrospective run
 //     completes successfully (correctness invariant — failures must
-//     re-process the same messages on the next attempt).
+//     re-process the same messages on the next attempt). Its companion
+//     `lastProcessedCreatedAt` is that row's `createdAt` at write time, so the
+//     `(createdAt, id)` cursor stays reconstructible after the row itself is
+//     deleted: a regenerated reply discards the latest assistant message,
+//     which is exactly where the cursor tends to sit.
 //   - `lastRunAt` advances at the end of every job that actually attempted a
 //     run (success or failure). Drives the per-conversation cooldown gate in
 //     the trigger-check helper so failing jobs can't loop in tight retries
@@ -25,20 +29,39 @@
 // that connection is unavailable. The memory database has no `conversations`
 // table, so there is no FK cascade — the `conversation-deleted` hook purges the
 // row explicitly instead.
+//
+// `last_processed_created_at` is added to the table by
+// `ensureRetrospectiveCursorColumn`: an idempotent, fail-open ALTER run lazily
+// on first use in each process (daemon, memory worker, CLI) rather than by the
+// global migration chain, which must not gate DB readiness on the memory
+// database. The probe is memoized per memory connection, so a connection
+// replaced by `resetDb()` (restores, imports) is probed again before its
+// first read. When the column cannot be added, reads and writes fall back to
+// the id-only cursor shape and the probe is retried after a short backoff.
 
 import { desc, eq } from "drizzle-orm";
 
 import type { DrizzleDb } from "../../../persistence/db-connection.js";
+import { messageCreatedAtByIds } from "../../../persistence/message-reads.js";
 import { memoryRetrospectiveState } from "../../../persistence/schema/index.js";
 import { withSqliteRetry } from "./host-utils.js";
 import { getLogger } from "./logging.js";
-import { memoryDbOrNull } from "./memory-db.js";
+import { memoryDbOrNull, memorySqliteOrNull } from "./memory-db.js";
 
 const log = getLogger("memory-retrospective-state");
 
+const TABLE = "memory_retrospective_state";
+const CURSOR_CREATED_AT_COLUMN = "last_processed_created_at";
+
 export interface MemoryRetrospectiveState {
   conversationId: string;
   lastProcessedMessageId: string;
+  /**
+   * `createdAt` of the `lastProcessedMessageId` row when the pointer was
+   * written, or null when unknown: rows written before the column existed,
+   * and the `""` sentinel. Lets the cursor bound a read after its row is gone.
+   */
+  lastProcessedCreatedAt: number | null;
   lastRunAt: number;
   /**
    * Cumulative `remember` contents from prior retrospective passes, oldest
@@ -99,6 +122,124 @@ function serializeRememberedLog(log: string[]): string | null {
   return log.length === 0 ? null : JSON.stringify(log);
 }
 
+// ---------------------------------------------------------------------------
+// Cursor timestamp column
+// ---------------------------------------------------------------------------
+
+type MemorySqlite = NonNullable<ReturnType<typeof memorySqliteOrNull>>;
+
+/** The memory connection the column was confirmed on; any other re-probes. */
+let cursorColumnEnsuredOn: MemorySqlite | null = null;
+/**
+ * The connection the last probe failed on and when. The backoff applies to
+ * that connection only: a replaced connection is probed at once, so a
+ * restore right after a failure still gets the column before its first read.
+ */
+let cursorColumnFailedOn: MemorySqlite | null = null;
+let lastCursorColumnFailureAt = 0;
+/** Backoff before re-probing the same connection after a failed ALTER. */
+const CURSOR_COLUMN_RETRY_MS = 60_000;
+
+function isDuplicateColumnError(err: unknown): boolean {
+  return err instanceof Error && /duplicate column name/i.test(err.message);
+}
+
+/**
+ * Add `last_processed_created_at` to the state table when it is missing.
+ * Idempotent; memoized per memory connection, so a connection replaced by
+ * `resetDb()` is probed again and an imported database that lacks the column
+ * gets it before its first read. Fail-open: when the ALTER cannot run, the
+ * failure is logged, every read and write falls back to the id-only shape,
+ * and that connection is probed again after {@link CURSOR_COLUMN_RETRY_MS}.
+ * A table the migration chain has not created yet is neither memoized nor a
+ * failure.
+ */
+export function ensureRetrospectiveCursorColumn(context: string): boolean {
+  const raw = memorySqliteOrNull(context);
+  if (!raw) {
+    return false;
+  }
+  if (cursorColumnEnsuredOn === raw) {
+    return true;
+  }
+  if (
+    cursorColumnFailedOn === raw &&
+    Date.now() - lastCursorColumnFailureAt < CURSOR_COLUMN_RETRY_MS
+  ) {
+    return false;
+  }
+  try {
+    const columns = raw.query(`PRAGMA table_info(${TABLE})`).all() as Array<{
+      name: string;
+    }>;
+    if (columns.length === 0) {
+      return false;
+    }
+    if (!columns.some((column) => column.name === CURSOR_CREATED_AT_COLUMN)) {
+      raw.exec(
+        `ALTER TABLE ${TABLE} ADD COLUMN ${CURSOR_CREATED_AT_COLUMN} INTEGER`,
+      );
+    }
+  } catch (err) {
+    if (!isDuplicateColumnError(err)) {
+      cursorColumnFailedOn = raw;
+      lastCursorColumnFailureAt = Date.now();
+      log.warn(
+        { err, context },
+        "could not add the retrospective cursor timestamp column; cursors fall back to id-only until the next probe",
+      );
+      return false;
+    }
+  }
+  cursorColumnEnsuredOn = raw;
+  cursorColumnFailedOn = null;
+  return true;
+}
+
+/**
+ * Forget the memoized column probe so the next call re-runs it. Intended
+ * ONLY for tests that recreate the memory database mid-process.
+ */
+export function _resetRetrospectiveCursorColumnForTests(): void {
+  cursorColumnEnsuredOn = null;
+  cursorColumnFailedOn = null;
+  lastCursorColumnFailureAt = 0;
+}
+
+// ---------------------------------------------------------------------------
+// Reads
+// ---------------------------------------------------------------------------
+
+const BASE_COLUMNS = {
+  conversationId: memoryRetrospectiveState.conversationId,
+  lastProcessedMessageId: memoryRetrospectiveState.lastProcessedMessageId,
+  lastRunAt: memoryRetrospectiveState.lastRunAt,
+  rememberedLog: memoryRetrospectiveState.rememberedLog,
+};
+
+const CURSOR_COLUMNS = {
+  ...BASE_COLUMNS,
+  lastProcessedCreatedAt: memoryRetrospectiveState.lastProcessedCreatedAt,
+};
+
+interface StateRow {
+  conversationId: string;
+  lastProcessedMessageId: string;
+  lastRunAt: number;
+  rememberedLog: string | null;
+  lastProcessedCreatedAt?: number | null;
+}
+
+function toState(row: StateRow): MemoryRetrospectiveState {
+  return {
+    conversationId: row.conversationId,
+    lastProcessedMessageId: row.lastProcessedMessageId,
+    lastProcessedCreatedAt: row.lastProcessedCreatedAt ?? null,
+    lastRunAt: row.lastRunAt,
+    rememberedLog: parseRememberedLog(row.rememberedLog),
+  };
+}
+
 /**
  * Return the `limit` most-recently-run retrospective state rows, newest first.
  */
@@ -109,23 +250,22 @@ export function listRetrospectiveStates(
   if (!mdb) {
     return [];
   }
-  const rows = mdb
-    .select({
-      conversationId: memoryRetrospectiveState.conversationId,
-      lastProcessedMessageId: memoryRetrospectiveState.lastProcessedMessageId,
-      lastRunAt: memoryRetrospectiveState.lastRunAt,
-      rememberedLog: memoryRetrospectiveState.rememberedLog,
-    })
-    .from(memoryRetrospectiveState)
-    .orderBy(desc(memoryRetrospectiveState.lastRunAt))
-    .limit(limit)
-    .all();
-  return rows.map((row) => ({
-    conversationId: row.conversationId,
-    lastProcessedMessageId: row.lastProcessedMessageId,
-    lastRunAt: row.lastRunAt,
-    rememberedLog: parseRememberedLog(row.rememberedLog),
-  }));
+  const rows: StateRow[] = ensureRetrospectiveCursorColumn(
+    "listRetrospectiveStates",
+  )
+    ? mdb
+        .select(CURSOR_COLUMNS)
+        .from(memoryRetrospectiveState)
+        .orderBy(desc(memoryRetrospectiveState.lastRunAt))
+        .limit(limit)
+        .all()
+    : mdb
+        .select(BASE_COLUMNS)
+        .from(memoryRetrospectiveState)
+        .orderBy(desc(memoryRetrospectiveState.lastRunAt))
+        .limit(limit)
+        .all();
+  return rows.map(toState);
 }
 
 /**
@@ -138,37 +278,45 @@ export function getRetrospectiveState(
   if (!mdb) {
     return null;
   }
-  const row = mdb
-    .select({
-      conversationId: memoryRetrospectiveState.conversationId,
-      lastProcessedMessageId: memoryRetrospectiveState.lastProcessedMessageId,
-      lastRunAt: memoryRetrospectiveState.lastRunAt,
-      rememberedLog: memoryRetrospectiveState.rememberedLog,
-    })
-    .from(memoryRetrospectiveState)
-    .where(eq(memoryRetrospectiveState.conversationId, conversationId))
-    .get();
-  if (!row) {
-    return null;
-  }
-  return {
-    conversationId: row.conversationId,
-    lastProcessedMessageId: row.lastProcessedMessageId,
-    lastRunAt: row.lastRunAt,
-    rememberedLog: parseRememberedLog(row.rememberedLog),
-  };
+  const where = eq(memoryRetrospectiveState.conversationId, conversationId);
+  const row: StateRow | undefined = ensureRetrospectiveCursorColumn(
+    "getRetrospectiveState",
+  )
+    ? mdb
+        .select(CURSOR_COLUMNS)
+        .from(memoryRetrospectiveState)
+        .where(where)
+        .get()
+    : mdb
+        .select(BASE_COLUMNS)
+        .from(memoryRetrospectiveState)
+        .where(where)
+        .get();
+  return row ? toState(row) : null;
 }
 
+// ---------------------------------------------------------------------------
+// Writes
+// ---------------------------------------------------------------------------
+
 /**
  * Upsert both pointers atomically. Used on successful retrospective runs.
  *
+ * `lastProcessedCreatedAt` is the id's companion and is rewritten with every
+ * pointer write: an omitted value records "unknown" for the new id rather
+ * than keeping the previous row's timestamp.
+ *
  * `rememberedLog`, when provided, is written in the same statement so the
  * cumulative dedup log can never drift from the pointer it was computed
  * against. When omitted, the stored log is left untouched (and seeded NULL on
  * first insert).
  */
 export async function upsertRetrospectiveState(
-  args: Omit<MemoryRetrospectiveState, "rememberedLog"> & {
+  args: Omit<
+    MemoryRetrospectiveState,
+    "rememberedLog" | "lastProcessedCreatedAt"
+  > & {
+    lastProcessedCreatedAt?: number | null;
     rememberedLog?: string[];
   },
 ): Promise<void> {
@@ -176,6 +324,9 @@ export async function upsertRetrospectiveState(
   if (!mdb) {
     return;
   }
+  const withCursor = ensureRetrospectiveCursorColumn(
+    "upsertRetrospectiveState",
+  );
   const serializedLog =
     args.rememberedLog === undefined
       ? undefined
@@ -185,12 +336,16 @@ export async function upsertRetrospectiveState(
   // on first insert).
   const set: {
     lastProcessedMessageId: string;
+    lastProcessedCreatedAt?: number | null;
     lastRunAt: number;
     rememberedLog?: string | null;
   } = {
     lastProcessedMessageId: args.lastProcessedMessageId,
     lastRunAt: args.lastRunAt,
   };
+  if (withCursor) {
+    set.lastProcessedCreatedAt = args.lastProcessedCreatedAt ?? null;
+  }
   if (serializedLog !== undefined) {
     set.rememberedLog = serializedLog;
   }
@@ -203,6 +358,9 @@ export async function upsertRetrospectiveState(
           lastProcessedMessageId: args.lastProcessedMessageId,
           lastRunAt: args.lastRunAt,
           rememberedLog: serializedLog ?? null,
+          ...(withCursor
+            ? { lastProcessedCreatedAt: args.lastProcessedCreatedAt ?? null }
+            : {}),
         })
         .onConflictDoUpdate({
           target: memoryRetrospectiveState.conversationId,
@@ -216,6 +374,46 @@ export async function upsertRetrospectiveState(
   );
 }
 
+/**
+ * The copied source row that sits latest at or before `bound` in
+ * `(createdAt, id)` order, as its forked id and `createdAt`, or null when
+ * every copied row lies after the bound. Reads the source rows through the
+ * fork transaction's handle.
+ */
+function latestCopiedRowAtOrBefore(
+  database: DrizzleDb,
+  forkedMessageIds: Map<string, string>,
+  bound: { createdAt: number; id: string },
+): { forkedId: string; createdAt: number } | null {
+  const createdAtBySourceId = messageCreatedAtByIds(
+    [...forkedMessageIds.keys()],
+    { db: database },
+  );
+  let best: { sourceId: string; createdAt: number } | null = null;
+  for (const [sourceId, createdAt] of createdAtBySourceId) {
+    const atOrBefore =
+      createdAt < bound.createdAt ||
+      (createdAt === bound.createdAt && sourceId <= bound.id);
+    if (!atOrBefore) {
+      continue;
+    }
+    const later =
+      best === null ||
+      createdAt > best.createdAt ||
+      (createdAt === best.createdAt && sourceId > best.sourceId);
+    if (later) {
+      best = { sourceId, createdAt };
+    }
+  }
+  if (best === null) {
+    return null;
+  }
+  const forkedId = forkedMessageIds.get(best.sourceId);
+  return forkedId === undefined
+    ? null
+    : { forkedId, createdAt: best.createdAt };
+}
+
 /**
  * Carry the source conversation's retrospective state into a forked child so
  * the fork doesn't re-process content the parent already covered. Synchronous
@@ -229,18 +427,23 @@ export async function upsertRetrospectiveState(
  *     succeeded) → child pointer is also `""`.
  *   - source pointer is within the copied range (`forkedMessageIds` has it) →
  *     child pointer is the mapped forked message ID.
- *   - source pointer is past the fork boundary (not in `forkedMessageIds`) →
- *     child pointer is the last copied message's mapped ID. All copied
- *     messages have already been retro'd by the source, so the child should
- *     wait for new post-fork messages before its first retro fires.
+ *   - source pointer is not in `forkedMessageIds` (its row was deleted, or it
+ *     lies past the copied range) and carries a stored `createdAt` → child
+ *     pointer is the latest copied row at or before the source's
+ *     `(createdAt, id)` bound; copied rows after the bound stay unprocessed.
+ *   - source pointer is not in `forkedMessageIds` and has no stored
+ *     `createdAt` → child pointer is the last copied message's mapped ID, on
+ *     the assumption it lies past the fork boundary.
  *
+ * `lastProcessedCreatedAt` is read from the forked pointer's row through
+ * `database`, the fork transaction's main-DB handle, which is the only handle
+ * the freshly copied rows are visible through.
  * `lastRunAt` is copied verbatim — the cooldown gate inherits from source.
  * `rememberedLog` is copied verbatim — the parent's saves remain the child's
  * dedup baseline.
  *
- * The row lives on the memory connection, so this reads/writes there rather
- * than on the main fork transaction's handle — the `database` arg is unused
- * now, and an unavailable memory database is a best-effort no-op.
+ * The state row itself is written on the memory connection; an unavailable
+ * memory database is a best-effort no-op.
  */
 export function forkRetrospectiveState(args: {
   database: DrizzleDb;
@@ -250,6 +453,7 @@ export function forkRetrospectiveState(args: {
   lastCopiedSourceMessageId: string | null;
 }): void {
   const {
+    database,
     sourceConversationId,
     forkedConversationId,
     forkedMessageIds,
@@ -262,47 +466,84 @@ export function forkRetrospectiveState(args: {
       return;
     }
 
-    const sourceRow = mdb
-      .select({
-        lastProcessedMessageId: memoryRetrospectiveState.lastProcessedMessageId,
-        lastRunAt: memoryRetrospectiveState.lastRunAt,
-        rememberedLog: memoryRetrospectiveState.rememberedLog,
-      })
-      .from(memoryRetrospectiveState)
-      .where(eq(memoryRetrospectiveState.conversationId, sourceConversationId))
-      .get();
+    const withCursor = ensureRetrospectiveCursorColumn(
+      "forkRetrospectiveState",
+    );
+    const sourceRow: StateRow | undefined = withCursor
+      ? mdb
+          .select(CURSOR_COLUMNS)
+          .from(memoryRetrospectiveState)
+          .where(
+            eq(memoryRetrospectiveState.conversationId, sourceConversationId),
+          )
+          .get()
+      : mdb
+          .select(BASE_COLUMNS)
+          .from(memoryRetrospectiveState)
+          .where(
+            eq(memoryRetrospectiveState.conversationId, sourceConversationId),
+          )
+          .get();
     if (!sourceRow) {
       return;
     }
 
+    const sourcePointer = sourceRow.lastProcessedMessageId;
+    const sourceCreatedAt = sourceRow.lastProcessedCreatedAt ?? null;
     let forkedPointer = "";
-    if (sourceRow.lastProcessedMessageId !== "") {
-      const mapped = forkedMessageIds.get(sourceRow.lastProcessedMessageId);
+    let forkedCreatedAt: number | null = null;
+    if (sourcePointer !== "") {
+      const mapped = forkedMessageIds.get(sourcePointer);
       if (mapped !== undefined) {
         forkedPointer = mapped;
+        forkedCreatedAt =
+          messageCreatedAtByIds([forkedPointer], { db: database }).get(
+            forkedPointer,
+          ) ?? null;
+      } else if (sourceCreatedAt !== null) {
+        // The source pointer is not among the copied rows: either its row
+        // was deleted (a regenerated reply) or it lies past the copied range.
+        // Its stored `(createdAt, id)` bound still says where it sat, so the
+        // child takes the latest copied row at or before that bound. Copied
+        // rows after it (a replacement reply, later turns) stay unprocessed;
+        // a bound before every copied row leaves the child at "nothing
+        // processed yet".
+        const placed = latestCopiedRowAtOrBefore(database, forkedMessageIds, {
+          createdAt: sourceCreatedAt,
+          id: sourcePointer,
+        });
+        if (placed) {
+          forkedPointer = placed.forkedId;
+          forkedCreatedAt = placed.createdAt;
+        }
       } else if (lastCopiedSourceMessageId !== null) {
-        // Source pointer is past the fork boundary — everything copied has
-        // already been processed by the source, so clamp to the last copied
-        // message so the fork waits for new post-fork messages.
+        // No stored bound to place a missing pointer by (a row written before
+        // timestamps were kept): treat it as past the fork boundary and clamp
+        // to the last copied message so the fork waits for new post-fork
+        // messages.
         forkedPointer = forkedMessageIds.get(lastCopiedSourceMessageId) ?? "";
+        forkedCreatedAt =
+          forkedPointer === ""
+            ? null
+            : (messageCreatedAtByIds([forkedPointer], { db: database }).get(
+                forkedPointer,
+              ) ?? null);
       }
     }
 
+    const values = {
+      lastProcessedMessageId: forkedPointer,
+      lastRunAt: sourceRow.lastRunAt,
+      rememberedLog: sourceRow.rememberedLog,
+      ...(withCursor ? { lastProcessedCreatedAt: forkedCreatedAt } : {}),
+    };
+
     mdb
       .insert(memoryRetrospectiveState)
-      .values({
-        conversationId: forkedConversationId,
-        lastProcessedMessageId: forkedPointer,
-        lastRunAt: sourceRow.lastRunAt,
-        rememberedLog: sourceRow.rememberedLog,
-      })
+      .values({ conversationId: forkedConversationId, ...values })
       .onConflictDoUpdate({
         target: memoryRetrospectiveState.conversationId,
-        set: {
-          lastProcessedMessageId: forkedPointer,
-          lastRunAt: sourceRow.lastRunAt,
-          rememberedLog: sourceRow.rememberedLog,
-        },
+        set: values,
       })
       .run();
   } catch (err) {

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

@@ -78,6 +78,7 @@ import { conversations } from "../../../persistence/schema/index.js";
 import { getLogger } from "./logging.js";
 import { countRetrospectiveMessagesAfter } from "./memory-retrospective-accounting.js";
 import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
+import { retrospectiveCursor } from "./memory-retrospective-cursor.js";
 import { enqueueMemoryRetrospectiveIfEnabled } from "./memory-retrospective-enqueue.js";
 import { getRetrospectiveState } from "./memory-retrospective-state.js";
 
@@ -273,7 +274,7 @@ export async function runRetrospectiveSweep(
 
       const unprocessed = countRetrospectiveMessagesAfter(
         conversationId,
-        state?.lastProcessedMessageId ?? null,
+        retrospectiveCursor(state),
       );
       if (unprocessed === 0) {
         continue;

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

@@ -9,8 +9,9 @@
 //      (success or failure). Prevents tight retry loops across trigger
 //      types.
 //   2. Interval threshold: time since last attempt >= `timeThresholdMs`.
-//   3. Message count threshold: new messages since `lastProcessedMessageId`
-//      >= `messageThreshold`.
+//   3. Message count threshold: new messages since the persisted cursor
+//      (`lastProcessedMessageId` with its `createdAt`, so the count survives
+//      the cursor's row being deleted) >= `messageThreshold`.
 //
 // First-run case (no state row) skips the cooldown — `lastRunAt = 0` so the
 // gap is effectively `Infinity`. The interval threshold trips immediately;
@@ -24,6 +25,7 @@
 import type { AssistantConfig } from "../../../config/types.js";
 import { getLogger } from "./logging.js";
 import { countRetrospectiveMessagesAfter } from "./memory-retrospective-accounting.js";
+import { retrospectiveCursor } from "./memory-retrospective-cursor.js";
 import { enqueueMemoryRetrospectiveIfEnabled } from "./memory-retrospective-enqueue.js";
 import { getRetrospectiveState } from "./memory-retrospective-state.js";
 
@@ -83,7 +85,7 @@ export function maybeEnqueueRetrospective(
     const state = getRetrospectiveState(conversationId);
     const newMessageCount = countRetrospectiveMessagesAfter(
       conversationId,
-      state?.lastProcessedMessageId ?? null,
+      retrospectiveCursor(state),
     );
     if (newMessageCount === 0) {
       return;

package/src/plugins/defaults/memory/skill-md-mtime-poll.ts

@@ -0,0 +1,9 @@
+/**
+ * Plugin-local re-export of the workspace SKILL.md mtime poll so hook files
+ * under `hooks/` do not grow a new escaping specifier. The daemon module is
+ * already a memory-plugin baseline import from `startup.ts` / `worker.ts`.
+ */
+export {
+  startWorkspaceSkillMdMtimePoll,
+  stopWorkspaceSkillMdMtimePoll,
+} from "../../../daemon/skill-memory-refresh.js";

package/src/plugins/defaults/memory/startup.ts

@@ -28,7 +28,10 @@ import { join } from "node:path";
 import { usesConceptPageMemory } from "../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../config/schema.js";
 import { reconcileEmbeddingIdentity } from "../../../daemon/embedding-reconcile.js";
-import { refreshSkillCapabilityMemories } from "../../../daemon/skill-memory-refresh.js";
+import {
+  refreshSkillCapabilityMemories,
+  startWorkspaceSkillMdMtimePoll,
+} from "../../../daemon/skill-memory-refresh.js";
 import { selectEmbeddingBackend } from "../../../persistence/embeddings/embedding-backend.js";
 import {
   initMessagesLexicalIndex,
@@ -38,11 +41,15 @@ import {
   clearRebuildSentinel,
   initQdrantClient,
 } from "../../../persistence/embeddings/qdrant-client.js";
-import { createQdrantManager } from "../../../persistence/embeddings/qdrant-manager.js";
+import {
+  createQdrantManager,
+  describeQdrantStartFailure,
+} from "../../../persistence/embeddings/qdrant-manager.js";
 import {
   enqueueMemoryJob,
   isMemoryEnabled,
 } from "../../../persistence/jobs-store.js";
+import { recordWatchdogEvent } from "../../../telemetry/watchdog-events-store.js";
 import { resolveQdrantUrl } from "./embeddings.js";
 import { startMemoryJobsWorker } from "./jobs-worker.js";
 import { getLogger } from "./logging.js";
@@ -89,6 +96,23 @@ export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
           { err },
           "Qdrant failed to start after all attempts — memory features will be unavailable",
         );
+        // Fleet-wide record of the failure: the step, the exit code and
+        // Qdrant's own reason line, bounded to telemetry-safe metadata by
+        // `describeQdrantStartFailure`. Observational only: the outbox insert
+        // can throw on a locked or half-migrated telemetry DB, and this path
+        // must still reach the worker start below.
+        try {
+          recordWatchdogEvent({
+            checkName: "qdrant_start_failed",
+            value: attempt,
+            detail: { attempts: attempt, ...describeQdrantStartFailure(err) },
+          });
+        } catch (telemetryErr) {
+          log.warn(
+            { err: telemetryErr },
+            "Qdrant start failure could not be recorded to telemetry",
+          );
+        }
       }
     }
   }
@@ -263,6 +287,8 @@ export async function runMemoryStartup(config: AssistantConfig): Promise<void> {
     log.warn({ err }, "Graph capability seeding failed — continuing");
   }
 
+  startWorkspaceSkillMdMtimePoll();
+
   // ---- v1 (legacy engine) — delete with v1 ----
   // Auto-bootstrap: if the graph has no non-procedural nodes but historical
   // segments exist, enqueue a one-time graph_bootstrap job to populate the

package/src/plugins/defaults/memory/substrate/__tests__/skill-content.test.ts

@@ -4,7 +4,7 @@
  */
 import { describe, expect, test } from "bun:test";
 
-import { setConfig } from "../../../../../__tests__/helpers/set-config.js";
+import { setWorkspaceMcp } from "../../../../../__tests__/helpers/set-workspace-mcp.js";
 import type { SkillCapabilityInput } from "../skill-content.js";
 
 describe("buildSkillContent", () => {
@@ -90,14 +90,12 @@ describe("augmentMcpSetupDescription", () => {
   });
 
   test("appends 'Configured: <names>' for mcp-setup with configured servers", async () => {
-    setConfig("mcp", {
-      servers: {
-        "example-server": {
-          transport: { type: "stdio", command: "example-cmd" },
-        },
-        "another-server": {
-          transport: { type: "stdio", command: "another-cmd" },
-        },
+    setWorkspaceMcp({
+      "example-server": {
+        transport: { type: "stdio", command: "example-cmd", args: [] },
+      },
+      "another-server": {
+        transport: { type: "stdio", command: "another-cmd", args: [] },
       },
     });
     const { augmentMcpSetupDescription } = await import("../skill-content.js");