@vellumai/assistant 0.8.0 → 0.8.1

package/src/memory/migrations/__tests__/246-backfill-provider-connection-label.test.ts

@@ -0,0 +1,192 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateCreateProviderConnections } from "../243-provider-connections.js";
+import { migrateProviderConnectionStatusLabel } from "../244-provider-connection-status-label.js";
+import { migrateBackfillProviderConnectionLabel } from "../246-backfill-provider-connection-label.js";
+
+interface ConnectionRow {
+  name: string;
+  label: string | null;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+/// Ensure the `memory_checkpoints` table exists in test DBs — it's normally
+/// provisioned by earlier infra migrations that the test harness doesn't
+/// pull in. Schema mirrors what other backfill migrations expect.
+function ensureCheckpointsTable(db: ReturnType<typeof createTestDb>): void {
+  const raw = getSqliteFrom(db);
+  raw.exec(`
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT,
+      updated_at INTEGER
+    )
+  `);
+}
+
+/// Bring the test DB up to the state right before migration 246 runs:
+/// provider_connections table present + status/label columns added.
+function prepareSchemaThroughMigration244(
+  db: ReturnType<typeof createTestDb>,
+): void {
+  migrateCreateProviderConnections(db);
+  migrateProviderConnectionStatusLabel(db);
+  ensureCheckpointsTable(db);
+}
+
+describe("migration 246 — backfill provider_connection label", () => {
+  test("sets label = name for rows where label is NULL", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    // Insert a row with label = NULL (simulating a pre-244 connection).
+    const now = Date.now();
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', NULL, ?, ?)`,
+      )
+      .run("anthropic-personal", "anthropic", JSON.stringify({ type: "api_key", credential: "credential/anthropic/api_key" }), now, now);
+
+    migrateBackfillProviderConnectionLabel(db);
+
+    const row = raw
+      .query(`SELECT name, label FROM provider_connections WHERE name = ?`)
+      .get("anthropic-personal") as ConnectionRow;
+    expect(row.label).toBe("anthropic-personal");
+  });
+
+  test("sets label = name for rows where label is empty/whitespace", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    const now = Date.now();
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', ?, ?, ?)`,
+      )
+      .run("openai-empty", "openai", JSON.stringify({ type: "api_key", credential: "credential/openai/api_key" }), "", now, now);
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', ?, ?, ?)`,
+      )
+      .run("openai-whitespace", "openai", JSON.stringify({ type: "api_key", credential: "credential/openai/api_key" }), "   ", now, now);
+
+    migrateBackfillProviderConnectionLabel(db);
+
+    const empty = raw
+      .query(`SELECT label FROM provider_connections WHERE name = ?`)
+      .get("openai-empty") as ConnectionRow;
+    const whitespace = raw
+      .query(`SELECT label FROM provider_connections WHERE name = ?`)
+      .get("openai-whitespace") as ConnectionRow;
+    expect(empty.label).toBe("openai-empty");
+    expect(whitespace.label).toBe("openai-whitespace");
+  });
+
+  test("does NOT overwrite rows where the user has set a non-empty label", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    const now = Date.now();
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', ?, ?, ?)`,
+      )
+      .run("anthropic-work", "anthropic", JSON.stringify({ type: "api_key", credential: "credential/anthropic/api_key" }), "Anthropic — Work", now, now);
+
+    migrateBackfillProviderConnectionLabel(db);
+
+    const row = raw
+      .query(`SELECT label FROM provider_connections WHERE name = ?`)
+      .get("anthropic-work") as ConnectionRow;
+    expect(row.label).toBe("Anthropic — Work");
+  });
+
+  test("is idempotent — second run does not re-clobber a later user-cleared label", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    const now = Date.now();
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', NULL, ?, ?)`,
+      )
+      .run("anthropic-personal", "anthropic", JSON.stringify({ type: "api_key", credential: "credential/anthropic/api_key" }), now, now);
+
+    // First run: backfills NULL → "anthropic-personal".
+    migrateBackfillProviderConnectionLabel(db);
+    expect(
+      (raw.query(`SELECT label FROM provider_connections WHERE name = ?`).get("anthropic-personal") as ConnectionRow).label,
+    ).toBe("anthropic-personal");
+
+    // User clears the label after the backfill ran.
+    raw.query(`UPDATE provider_connections SET label = NULL WHERE name = ?`).run("anthropic-personal");
+
+    // Second run: should NOT re-clobber the user's deliberate clear, because
+    // the checkpoint was set on the first successful run.
+    migrateBackfillProviderConnectionLabel(db);
+    expect(
+      (raw.query(`SELECT label FROM provider_connections WHERE name = ?`).get("anthropic-personal") as ConnectionRow).label,
+    ).toBeNull();
+  });
+
+  test("checkpoint is set after a successful run", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    migrateBackfillProviderConnectionLabel(db);
+
+    const checkpoint = raw
+      .query(`SELECT key FROM memory_checkpoints WHERE key = ?`)
+      .get("backfill_provider_connection_label") as { key: string } | null;
+    expect(checkpoint).not.toBeNull();
+    expect(checkpoint?.key).toBe("backfill_provider_connection_label");
+  });
+
+  test("no-op when provider_connections table is absent (first-boot edge)", () => {
+    const db = createTestDb();
+    ensureCheckpointsTable(db);
+
+    // Don't run 243/244 — the table doesn't exist yet.
+    expect(() => migrateBackfillProviderConnectionLabel(db)).not.toThrow();
+
+    // Checkpoint should still get set so we don't retry forever.
+    const raw = getSqliteFrom(db);
+    const checkpoint = raw
+      .query(`SELECT key FROM memory_checkpoints WHERE key = ?`)
+      .get("backfill_provider_connection_label");
+    expect(checkpoint).not.toBeNull();
+  });
+
+  test("no-op when label column is absent (244 hasn't run yet) — no checkpoint set", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    migrateCreateProviderConnections(db); // 243 only, NOT 244
+    ensureCheckpointsTable(db);
+
+    expect(() => migrateBackfillProviderConnectionLabel(db)).not.toThrow();
+
+    // Crucially: no checkpoint should be set, so the backfill can run later
+    // once 244 has provisioned the column.
+    const checkpoint = raw
+      .query(`SELECT key FROM memory_checkpoints WHERE key = ?`)
+      .get("backfill_provider_connection_label");
+    expect(checkpoint).toBeNull();
+  });
+});

package/src/memory/migrations/index.ts

@@ -201,6 +201,13 @@ export {
 } from "./237-heartbeat-runs.js";
 export { migrateScheduleRetryPolicy } from "./238-schedule-retry-policy.js";
 export { migrateTraceEventsCreatedAtIndex } from "./239-trace-events-created-at-index.js";
+export { migrateConversationInferenceProfileSession } from "./240-conversation-inference-profile-session.js";
+export { migrateActivationStateFkCascade } from "./241-activation-state-fk-cascade.js";
+export { migrateMessageBookmarks } from "./242-message-bookmarks.js";
+export { migrateCreateProviderConnections } from "./243-provider-connections.js";
+export { migrateProviderConnectionStatusLabel } from "./244-provider-connection-status-label.js";
+export { migrateMemoryRetrospectiveState } from "./245-memory-retrospective-state.js";
+export { migrateBackfillProviderConnectionLabel } from "./246-backfill-provider-connection-label.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/published-pages-store.ts

@@ -36,6 +36,21 @@ export function getActivePublishedPageByAppId(
   return row ?? null;
 }
 
+export function insertPublishedPage(record: {
+  id: string;
+  deploymentId: string;
+  publicUrl: string;
+  pageTitle: string | null;
+  htmlHash: string;
+  publishedAt: number;
+  status: string;
+  appId: string | null;
+  projectSlug: string | null;
+}): void {
+  const db = getDb();
+  db.insert(publishedPages).values(record).run();
+}
+
 export function updatePublishedPage(
   id: string,
   updates: {
@@ -44,6 +59,7 @@ export function updatePublishedPage(
     htmlHash?: string;
     publishedAt?: number;
     appId?: string;
+    status?: string;
   },
 ): void {
   const db = getDb();

package/src/memory/schema/bookmarks.ts

@@ -0,0 +1,38 @@
+import {
+  index,
+  integer,
+  sqliteTable,
+  text,
+  uniqueIndex,
+} from "drizzle-orm/sqlite-core";
+
+import { conversations, messages } from "./conversations.js";
+
+/**
+ * User-saved bookmarks for individual messages. Surfaced in the macOS app
+ * Settings → Bookmarks tab and on the message hover overflow menu, behind the
+ * `bookmarks` client feature flag.
+ *
+ * Both foreign keys CASCADE so bookmarks disappear automatically when their
+ * parent message or conversation is deleted. A unique index on `message_id`
+ * keeps the create-bookmark path idempotent.
+ */
+export const messageBookmarks = sqliteTable(
+  "message_bookmarks",
+  {
+    id: text("id").primaryKey(),
+    messageId: text("message_id")
+      .notNull()
+      .references(() => messages.id, { onDelete: "cascade" }),
+    conversationId: text("conversation_id")
+      .notNull()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("message_bookmarks_message_id_uniq").on(table.messageId),
+    index("message_bookmarks_created_at_idx").on(table.createdAt),
+  ],
+);
+
+export type MessageBookmarkRow = typeof messageBookmarks.$inferSelect;

package/src/memory/schema/conversations.ts

@@ -39,6 +39,8 @@ export const conversations = sqliteTable(
     lastMessageAt: integer("last_message_at"),
     archivedAt: integer("archived_at"),
     inferenceProfile: text("inference_profile"),
+    inferenceProfileSessionId: text("inference_profile_session_id"),
+    inferenceProfileExpiresAt: integer("inference_profile_expires_at"),
   },
   (table) => [
     index("idx_conversations_updated_at").on(table.updatedAt),

package/src/memory/schema/index.ts

@@ -1,8 +1,10 @@
 export * from "./acp.js";
+export * from "./bookmarks.js";
 export * from "./calls.js";
 export * from "./contacts.js";
 export * from "./conversations.js";
 export * from "./guardian.js";
+export * from "./inference.js";
 export * from "./infrastructure.js";
 export * from "./memory-core.js";
 export * from "./memory-graph.js";

package/src/memory/schema/inference.ts

@@ -0,0 +1,29 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+/**
+ * Named provider connections.
+ *
+ * Each row is a named auth-config instance for a code-defined provider.
+ * Profiles in config.json reference connections by `name` via the
+ * `provider_connection` field.
+ *
+ * Created by migration 243.
+ */
+export const providerConnections = sqliteTable(
+  "provider_connections",
+  {
+    name: text("name").primaryKey(),
+    provider: text("provider").notNull(),
+    auth: text("auth").notNull(),
+    status: text("status").notNull().default("active"),
+    label: text("label"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_provider_connections_provider").on(table.provider),
+  ],
+);
+
+export type ProviderConnectionRow = typeof providerConnections.$inferSelect;
+export type NewProviderConnectionRow = typeof providerConnections.$inferInsert;

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

@@ -100,6 +100,15 @@ export const memoryCheckpoints = sqliteTable("memory_checkpoints", {
   updatedAt: integer("updated_at").notNull(),
 });
 
+export const memoryRetrospectiveState = sqliteTable(
+  "memory_retrospective_state",
+  {
+    conversationId: text("conversation_id").primaryKey(),
+    lastProcessedMessageId: text("last_processed_message_id").notNull(),
+    lastRunAt: integer("last_run_at").notNull(),
+  },
+);
+
 export const conversationStarters = sqliteTable(
   "conversation_starters",
   {

package/src/memory/search/semantic.ts

@@ -9,6 +9,7 @@ import type {
 } from "../qdrant-client.js";
 import { getQdrantClient } from "../qdrant-client.js";
 import { memorySegments, memorySummaries } from "../schema.js";
+import { mapCosineToUnit } from "../validation.js";
 // ── Types (inlined from deleted types.ts) ──────────────────────────
 
 type CandidateType = "segment" | "item" | "summary" | "media";
@@ -235,7 +236,3 @@ function buildHybridFilter(
     must_not: mustNotConditions,
   };
 }
-
-function mapCosineToUnit(value: number): number {
-  return Math.max(0, Math.min(1, (value + 1) / 2));
-}

package/src/memory/v2/__tests__/__snapshots__/prompts-router.test.ts.snap

@@ -0,0 +1,27 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`renderRouterPrompt — determinism & snapshot stability snapshot of fixed inputs 1`] = `
+"You are a background helper for Aria. Your job is to route memory pages for the next assistant turn between Aria and Alice.
+
+You will be shown the recent conversation, a \`<now>\` marker for the current time, an \`<already_injected_ids>\` block listing pages picked on the previous turn, and a \`# Concept Page Index\` listing every routable page on this workspace.
+
+Pick the concept pages whose contents would help Aria respond well on this turn. Lean toward inclusion when in doubt — missing a relevant page is a worse error than surfacing a few unused ones, because the assistant can ignore extras but can't summon context that wasn't loaded. Abstain (return an empty list) only when nothing in the index plausibly bears on the turn.
+
+Index format. Each line of the index has the shape:
+
+    [id] slug — summary (edges: a, b, c)
+
+\`id\` is a small integer used to refer to this page. \`edges\` are numeric IDs into the same list, pointing at related pages; you may follow them when one page strongly implies another.
+
+Already-injected pages. Pages whose IDs appear in \`<already_injected_ids>\` were picked on the previous turn. Do not pick them again unless Aria should re-anchor on that material — e.g., the topic genuinely returns after drifting away. Routine continuity does not require re-picking; the prior turn's pages are already in the assistant's working context.
+
+Time. Bias toward pages that match the current state implied by \`<now>\` and the active conversational threads (what is happening today, what was just decided, who is being discussed). Stale pages with no bearing on the live conversation should be skipped even if their summaries look superficially relevant.
+
+Emit your selection by calling \`select_pages_to_inject\` with the chosen \`page_ids\`. Return an empty array to abstain.
+
+# Concept Page Index
+
+[1] morning-routine — coffee, walk, journal (edges: 2)
+[2] journal-style — terse, dated, no fluff (edges: 1)
+[3] taxes-2025 — Q1 estimate due April 15 (edges: )"
+`;

package/src/memory/v2/__tests__/activation-store.test.ts

@@ -8,7 +8,7 @@ import { migrateActivationState } from "../../migrations/232-activation-state.js
 import * as schema from "../../schema.js";
 import {
   evictCompactedTurns,
-  fork,
+  forkActivationState,
   hydrate,
   save,
 } from "../activation-store.js";
@@ -113,12 +113,12 @@ describe("activation-store", () => {
     });
   });
 
-  describe("fork", () => {
+  describe("forkActivationState", () => {
     test("copies parent state to a new conversation id", async () => {
       const parentState = buildState();
       await save(db, "conv-parent", parentState);
 
-      await fork(db, "conv-parent", "conv-child");
+      forkActivationState(db, "conv-parent", "conv-child");
 
       const child = await hydrate(db, "conv-child");
       expect(child).toEqual(parentState);
@@ -129,7 +129,7 @@ describe("activation-store", () => {
     });
 
     test("is a no-op when the parent has no state", async () => {
-      await fork(db, "conv-parent-missing", "conv-child");
+      forkActivationState(db, "conv-parent-missing", "conv-child");
 
       expect(await hydrate(db, "conv-child")).toBeNull();
     });
@@ -139,7 +139,7 @@ describe("activation-store", () => {
       await save(db, "conv-parent", parentState);
       await save(db, "conv-child", buildState({ currentTurn: 99 }));
 
-      await fork(db, "conv-parent", "conv-child");
+      forkActivationState(db, "conv-parent", "conv-child");
 
       const child = await hydrate(db, "conv-child");
       expect(child?.currentTurn).toBe(7);

package/src/memory/v2/__tests__/activation.test.ts

@@ -470,7 +470,9 @@ describe("computeOwnActivation", () => {
         c_now: 0.2,
       }),
     });
-    // Expected: 0.3*0.6 + 0.3*0.5 + 0.2*0.4 + 0.2*0.2 = 0.18+0.15+0.08+0.04 = 0.45
+    // Positive cosines pass through unchanged (negatives clamp to 0).
+    // Expected: 0.3*0.6 + 0.3*0.5 + 0.2*0.4 + 0.2*0.2
+    //         = 0.18 + 0.15 + 0.08 + 0.04 = 0.45
     expect(out.activation.get("alice")).toBeCloseTo(0.45, 6);
   });
 
@@ -523,6 +525,7 @@ describe("computeOwnActivation", () => {
         c_now: 0.2,
       }),
     });
+    // Positive cosines pass through unchanged: 1.0 stays 1.0; 0 stays 0.
     // 0.3*0 + 0.3*1 + 0.2*0 + 0.2*0 = 0.3
     expect(out.activation.get("fresh")).toBeCloseTo(0.3, 6);
   });
@@ -573,7 +576,8 @@ describe("computeOwnActivation", () => {
     expect(breakdown).toBeDefined();
     // priorContribution is `d * prev`, not the weighted sim term.
     expect(breakdown?.priorContribution).toBeCloseTo(d * 0.6, 6);
-    // Raw sims, captured before c_user / c_assistant / c_now weighting.
+    // Fused sims (positive cosines pass through unchanged), captured before
+    // c_user / c_assistant / c_now weighting.
     expect(breakdown?.simUser).toBeCloseTo(0.5, 6);
     expect(breakdown?.simAssistant).toBeCloseTo(0.4, 6);
     expect(breakdown?.simNow).toBeCloseTo(0.2, 6);
@@ -801,8 +805,10 @@ describe("computeOwnActivation", () => {
   });
 
   test("rerank boost is additive on A_o and leaves raw simUser / simAssistant untouched", async () => {
-    stageHybridResponse([{ slug: "a", denseScore: 0.5 }]); // user
-    stageHybridResponse([{ slug: "a", denseScore: 0.4 }]); // assistant
+    // Positive cosines pass through unchanged; pick 0.5 / 0.4 directly so
+    // the round fused values used in the formula assertion below hold.
+    stageHybridResponse([{ slug: "a", denseScore: 0.5 }]); // user — fused 0.5
+    stageHybridResponse([{ slug: "a", denseScore: 0.4 }]); // assistant — fused 0.4
     stageHybridResponse([]); // now
     rerankState.scores = new Map([["a", 0.8]]);
 
@@ -1219,6 +1225,7 @@ describe("skills participate in the unified pipeline", () => {
     });
 
     // No prior state → priorContribution = 0.
+    // Positive cosines pass through unchanged.
     // 0.3*0.5 + 0.2*0.4 + 0.2*0.2 = 0.15 + 0.08 + 0.04 = 0.27
     expect(out.activation.get("skills/example-skill-a")).toBeCloseTo(0.27, 6);
     expect(out.breakdown.get("skills/example-skill-a")?.priorContribution).toBe(

package/src/memory/v2/__tests__/backfill-jobs.test.ts

@@ -8,8 +8,7 @@
  * Coverage matrix:
  *   - migrate: wraps `runMemoryV2Migration`; force flag propagates;
  *     `MigrationAlreadyAppliedError` is swallowed (no rethrow).
- *   - reembed: enqueues `N + 4` jobs (concept-page slugs plus four reserved
- *     meta-file slugs).
+ *   - reembed: enqueues `N` jobs, one per concept-page slug.
  *   - activation-recompute: walks conversations with rows, runs the pipeline
  *     end-to-end against the real activation module, persists fresh state.
  *
@@ -116,7 +115,10 @@ const STUB_RUNTIME_CONFIG = {
 };
 mock.module("../../../config/loader.js", () => ({
   getConfig: () => STUB_RUNTIME_CONFIG,
+  getConfigReadOnly: () => STUB_RUNTIME_CONFIG,
   loadConfig: () => STUB_RUNTIME_CONFIG,
+  loadRawConfig: () => ({}) as Record<string, unknown>,
+  saveRawConfig: () => {},
   invalidateConfigCache: () => {},
   applyNestedDefaults: () => STUB_RUNTIME_CONFIG,
 }));
@@ -208,7 +210,6 @@ const { writePage } = await import("../page-store.js");
 const { save: saveActivation, hydrate: hydrateActivation } =
   await import("../activation-store.js");
 const {
-  META_FILE_SLUGS,
   memoryV2ActivationRecomputeJob,
   memoryV2MigrateJob,
   memoryV2ReembedJob,
@@ -322,15 +323,15 @@ describe("memoryV2MigrateJob", () => {
 // ---------------------------------------------------------------------------
 
 describe("memoryV2ReembedJob", () => {
-  test("returns N + 4 (one per concept page plus the four meta files) and writes that many job rows", async () => {
+  test("returns N (one per concept page) and writes that many job rows", async () => {
     await writePage(tmpWorkspace, {
       slug: "alice",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Alice.\n",
     });
     await writePage(tmpWorkspace, {
       slug: "bob",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Bob.\n",
     });
 
@@ -339,8 +340,8 @@ describe("memoryV2ReembedJob", () => {
       TEST_CONFIG,
     );
 
-    // Return value covers the contract: N concept pages + 4 meta files.
-    expect(total).toBe(2 + META_FILE_SLUGS.length);
+    // Return value covers the contract: one job per concept page.
+    expect(total).toBe(2);
 
     // Verify the slugs that were enqueued by reading the memory_jobs table.
     // Tests that mock `jobs-store.js` skip inserting rows; when this suite
@@ -349,34 +350,50 @@ describe("memoryV2ReembedJob", () => {
     // belt-and-suspenders.
     const rows = getDb().select().from(memoryJobs).all();
     if (rows.length > 0) {
-      expect(rows).toHaveLength(2 + META_FILE_SLUGS.length);
+      expect(rows).toHaveLength(2);
       const slugs = rows.map((row) => JSON.parse(row.payload).slug);
       expect(slugs).toContain("alice");
       expect(slugs).toContain("bob");
-      for (const metaSlug of META_FILE_SLUGS) {
-        expect(slugs).toContain(metaSlug);
-      }
       for (const row of rows) {
         expect(row.type).toBe("embed_concept_page");
       }
     }
   });
 
-  test("with no concept pages on disk, still enqueues the 4 meta-file jobs", async () => {
+  test("with no concept pages on disk, enqueues nothing", async () => {
     const total = await memoryV2ReembedJob(
       makeJob("memory_v2_reembed"),
       TEST_CONFIG,
     );
-    expect(total).toBe(META_FILE_SLUGS.length);
+    expect(total).toBe(0);
   });
 
-  test("uses reserved meta-file slugs (__essentials__/__threads__/__recent__/__buffer__)", () => {
-    expect([...META_FILE_SLUGS]).toEqual([
-      "__essentials__",
-      "__threads__",
-      "__recent__",
-      "__buffer__",
-    ]);
+  test("does NOT enqueue reserved meta-file slugs", async () => {
+    // The four prose meta files (essentials/threads/recent/buffer) live at
+    // `memory/<name>.md` and are direct-injected into the system prompt via
+    // `_autoinject.md`. Their underscore-bracketed slug aliases (e.g.
+    // `__essentials__`) fail the concept-page slug validator
+    // (`[a-z0-9][a-z0-9-]*`), so the reembed fan-out must not enqueue them.
+    await writePage(tmpWorkspace, {
+      slug: "alice",
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+      body: "Alice.\n",
+    });
+
+    await memoryV2ReembedJob(makeJob("memory_v2_reembed"), TEST_CONFIG);
+
+    const rows = getDb().select().from(memoryJobs).all();
+    if (rows.length > 0) {
+      const slugs = rows.map((row) => JSON.parse(row.payload).slug);
+      for (const reserved of [
+        "__essentials__",
+        "__threads__",
+        "__recent__",
+        "__buffer__",
+      ]) {
+        expect(slugs).not.toContain(reserved);
+      }
+    }
   });
 });