@vellumai/assistant 0.12.1-staging.1 → 0.12.1

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

@@ -5,11 +5,7 @@
 // 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). 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.
+//     re-process the same messages on the next attempt).
 //   - `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
@@ -29,39 +25,20 @@
 // 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, memorySqliteOrNull } from "./memory-db.js";
+import { memoryDbOrNull } 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
@@ -122,124 +99,6 @@ 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.
  */
@@ -250,22 +109,23 @@ export function listRetrospectiveStates(
   if (!mdb) {
     return [];
   }
-  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);
+  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),
+  }));
 }
 
 /**
@@ -278,45 +138,37 @@ export function getRetrospectiveState(
   if (!mdb) {
     return null;
   }
-  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;
+  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),
+  };
 }
 
-// ---------------------------------------------------------------------------
-// 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" | "lastProcessedCreatedAt"
-  > & {
-    lastProcessedCreatedAt?: number | null;
+  args: Omit<MemoryRetrospectiveState, "rememberedLog"> & {
     rememberedLog?: string[];
   },
 ): Promise<void> {
@@ -324,9 +176,6 @@ export async function upsertRetrospectiveState(
   if (!mdb) {
     return;
   }
-  const withCursor = ensureRetrospectiveCursorColumn(
-    "upsertRetrospectiveState",
-  );
   const serializedLog =
     args.rememberedLog === undefined
       ? undefined
@@ -336,16 +185,12 @@ 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;
   }
@@ -358,9 +203,6 @@ export async function upsertRetrospectiveState(
           lastProcessedMessageId: args.lastProcessedMessageId,
           lastRunAt: args.lastRunAt,
           rememberedLog: serializedLog ?? null,
-          ...(withCursor
-            ? { lastProcessedCreatedAt: args.lastProcessedCreatedAt ?? null }
-            : {}),
         })
         .onConflictDoUpdate({
           target: memoryRetrospectiveState.conversationId,
@@ -374,46 +216,6 @@ 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
@@ -427,23 +229,18 @@ function latestCopiedRowAtOrBefore(
  *     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 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.
+ *   - 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.
  *
- * `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 state row itself is written on the memory connection; an unavailable
- * memory database is a best-effort no-op.
+ * 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.
  */
 export function forkRetrospectiveState(args: {
   database: DrizzleDb;
@@ -453,7 +250,6 @@ export function forkRetrospectiveState(args: {
   lastCopiedSourceMessageId: string | null;
 }): void {
   const {
-    database,
     sourceConversationId,
     forkedConversationId,
     forkedMessageIds,
@@ -466,84 +262,47 @@ export function forkRetrospectiveState(args: {
       return;
     }
 
-    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();
+    const sourceRow = mdb
+      .select({
+        lastProcessedMessageId: memoryRetrospectiveState.lastProcessedMessageId,
+        lastRunAt: memoryRetrospectiveState.lastRunAt,
+        rememberedLog: memoryRetrospectiveState.rememberedLog,
+      })
+      .from(memoryRetrospectiveState)
+      .where(eq(memoryRetrospectiveState.conversationId, sourceConversationId))
+      .get();
     if (!sourceRow) {
       return;
     }
 
-    const sourcePointer = sourceRow.lastProcessedMessageId;
-    const sourceCreatedAt = sourceRow.lastProcessedCreatedAt ?? null;
     let forkedPointer = "";
-    let forkedCreatedAt: number | null = null;
-    if (sourcePointer !== "") {
-      const mapped = forkedMessageIds.get(sourcePointer);
+    if (sourceRow.lastProcessedMessageId !== "") {
+      const mapped = forkedMessageIds.get(sourceRow.lastProcessedMessageId);
       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) {
-        // 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.
+        // 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.
         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, ...values })
+      .values({
+        conversationId: forkedConversationId,
+        lastProcessedMessageId: forkedPointer,
+        lastRunAt: sourceRow.lastRunAt,
+        rememberedLog: sourceRow.rememberedLog,
+      })
       .onConflictDoUpdate({
         target: memoryRetrospectiveState.conversationId,
-        set: values,
+        set: {
+          lastProcessedMessageId: forkedPointer,
+          lastRunAt: sourceRow.lastRunAt,
+          rememberedLog: sourceRow.rememberedLog,
+        },
       })
       .run();
   } catch (err) {

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

@@ -78,7 +78,6 @@ 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";
 
@@ -274,7 +273,7 @@ export async function runRetrospectiveSweep(
 
       const unprocessed = countRetrospectiveMessagesAfter(
         conversationId,
-        retrospectiveCursor(state),
+        state?.lastProcessedMessageId ?? null,
       );
       if (unprocessed === 0) {
         continue;

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

@@ -9,9 +9,8 @@
 //      (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 the persisted cursor
-//      (`lastProcessedMessageId` with its `createdAt`, so the count survives
-//      the cursor's row being deleted) >= `messageThreshold`.
+//   3. Message count threshold: new messages since `lastProcessedMessageId`
+//      >= `messageThreshold`.
 //
 // First-run case (no state row) skips the cooldown — `lastRunAt = 0` so the
 // gap is effectively `Infinity`. The interval threshold trips immediately;
@@ -25,7 +24,6 @@
 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";
 
@@ -85,7 +83,7 @@ export function maybeEnqueueRetrospective(
     const state = getRetrospectiveState(conversationId);
     const newMessageCount = countRetrospectiveMessagesAfter(
       conversationId,
-      retrospectiveCursor(state),
+      state?.lastProcessedMessageId ?? null,
     );
     if (newMessageCount === 0) {
       return;

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

@@ -28,10 +28,7 @@ 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,
-  startWorkspaceSkillMdMtimePoll,
-} from "../../../daemon/skill-memory-refresh.js";
+import { refreshSkillCapabilityMemories } from "../../../daemon/skill-memory-refresh.js";
 import { selectEmbeddingBackend } from "../../../persistence/embeddings/embedding-backend.js";
 import {
   initMessagesLexicalIndex,
@@ -266,8 +263,6 @@ 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 { setWorkspaceMcp } from "../../../../../__tests__/helpers/set-workspace-mcp.js";
+import { setConfig } from "../../../../../__tests__/helpers/set-config.js";
 import type { SkillCapabilityInput } from "../skill-content.js";
 
 describe("buildSkillContent", () => {
@@ -90,12 +90,14 @@ describe("augmentMcpSetupDescription", () => {
   });
 
   test("appends 'Configured: <names>' for mcp-setup with configured servers", async () => {
-    setWorkspaceMcp({
-      "example-server": {
-        transport: { type: "stdio", command: "example-cmd", args: [] },
-      },
-      "another-server": {
-        transport: { type: "stdio", command: "another-cmd", args: [] },
+    setConfig("mcp", {
+      servers: {
+        "example-server": {
+          transport: { type: "stdio", command: "example-cmd" },
+        },
+        "another-server": {
+          transport: { type: "stdio", command: "another-cmd" },
+        },
       },
     });
     const { augmentMcpSetupDescription } = await import("../skill-content.js");

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

@@ -1,4 +1,4 @@
-import { loadWorkspaceMcpConfig } from "../../../../mcp/workspace-mcp-config.js";
+import { getConfig } from "../../../../config/loader.js";
 
 /**
  * Generic input for building capability statements: the capability fields of
@@ -92,7 +92,7 @@ export function augmentMcpSetupDescription(
   if (input.id !== "mcp-setup") {
     return input;
   }
-  const servers = loadWorkspaceMcpConfig().servers;
+  const servers = getConfig().mcp?.servers;
   if (!servers) {
     return input;
   }