@vellumai/assistant 0.8.11 → 0.8.12-staging.1

package/src/workspace/migrations/097-enable-adaptive-thinking-managed-profiles.ts

@@ -22,87 +22,90 @@ import type { WorkspaceMigration } from "./types.js";
 //   - Already have thinking enabled (idempotent)
 //   - Are source: "user" (user-created profiles are untouched)
 //   - Have a non-managed, non-absent source (unknown origin)
-//   - Use a non-Anthropic provider (adaptive thinking is Anthropic-specific)
+//   - Resolve to a non-Anthropic provider (adaptive thinking is
+//     Anthropic-specific). A profile with no explicit provider inherits
+//     llm.default.provider, so the check falls back to that — with a
+//     completely absent llm.default.provider treated as Anthropic, matching
+//     migration 052's own `?? "anthropic"` default. This keeps the legacy
+//     non-Anthropic empty `{}` shells seeded by migration 052 off the repair.
+//
+// Note: the live startup path re-runs the same repair after the platform
+// overlay merge — see assistant/src/workspace/adaptive-thinking-repair.ts.
+// This file keeps its own frozen copy of the logic because migration modules
+// are self-contained snapshots and must never be imported by other code.
 
 const ADAPTIVE_THINKING = { enabled: true, streamThinking: true } as const;
 const TARGET_PROFILES = ["balanced", "quality-optimized"] as const;
 
-/**
- * Patch managed Anthropic profiles that are missing adaptive thinking.
- *
- * Exported so lifecycle.ts can re-run the repair after mergeDefaultWorkspaceConfig()
- * and seedInferenceProfiles(). On-platform instances with a config overlay have their
- * profiles overwritten by the overlay merge (which runs after workspace migrations),
- * so the migration alone is insufficient — the post-overlay call ensures the repair
- * sticks even when the overlay supplies profiles without thinking enabled.
- *
- * The function is idempotent: profiles that already have thinking enabled are skipped.
- */
-export function repairAdaptiveThinkingOnManagedProfiles(
-  workspaceDir: string,
-): void {
-  const configPath = join(workspaceDir, "config.json");
-  if (!existsSync(configPath)) return;
+export const enableAdaptiveThinkingManagedProfilesMigration: WorkspaceMigration =
+  {
+    id: "097-enable-adaptive-thinking-managed-profiles",
+    description:
+      "Enable adaptive thinking on managed balanced and quality-optimized profiles",
+    run(workspaceDir: string): void {
+      const configPath = join(workspaceDir, "config.json");
+      if (!existsSync(configPath)) return;
 
-  let config: Record<string, unknown>;
-  try {
-    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
-    config = raw as Record<string, unknown>;
-  } catch {
-    return;
-  }
+      let config: Record<string, unknown>;
+      try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+        config = raw as Record<string, unknown>;
+      } catch {
+        return;
+      }
 
-  const llm = readObject(config.llm);
-  if (llm === null) return;
+      const llm = readObject(config.llm);
+      if (llm === null) return;
 
-  const profiles = readObject(llm.profiles);
-  if (profiles === null) return;
+      const profiles = readObject(llm.profiles);
+      if (profiles === null) return;
 
-  let changed = false;
+      // Profiles without an explicit provider inherit llm.default.provider at
+      // resolution time; an absent llm.default.provider resolves to Anthropic.
+      const defaultBlock = readObject(llm.default);
+      const defaultProvider =
+        typeof defaultBlock?.provider === "string"
+          ? defaultBlock.provider
+          : "anthropic";
 
-  for (const name of TARGET_PROFILES) {
-    const profile = readObject(profiles[name]);
-    if (profile === null) continue;
+      let changed = false;
 
-    // Only patch managed Anthropic profiles.
-    // Legacy profiles created before the `source` metadata field was introduced
-    // have source=undefined. Treat these as managed when the profile name is one
-    // of the canonical managed names (which TARGET_PROFILES already guarantees)
-    // and the provider is Anthropic (or absent). Explicit `source: "user"`
-    // profiles are always skipped.
-    if (profile.source === "user") continue;
-    if (profile.source !== undefined && profile.source !== "managed") continue;
-    if (
-      typeof profile.provider === "string" &&
-      profile.provider !== "anthropic"
-    ) {
-      continue;
-    }
+      for (const name of TARGET_PROFILES) {
+        const profile = readObject(profiles[name]);
+        if (profile === null) continue;
 
-    // Skip if thinking is already enabled.
-    const thinking = readObject(profile.thinking);
-    if (thinking !== null && thinking.enabled === true) continue;
+        // Only patch managed Anthropic profiles.
+        // Legacy profiles created before the `source` metadata field was
+        // introduced have source=undefined. Treat these as managed when the
+        // profile name is one of the canonical managed names (which
+        // TARGET_PROFILES already guarantees) and the effective provider —
+        // explicit, or inherited from llm.default — is Anthropic. Explicit
+        // `source: "user"` profiles are always skipped.
+        if (profile.source === "user") continue;
+        if (profile.source !== undefined && profile.source !== "managed") {
+          continue;
+        }
+        const effectiveProvider =
+          typeof profile.provider === "string"
+            ? profile.provider
+            : defaultProvider;
+        if (effectiveProvider !== "anthropic") continue;
 
-    profile.thinking = { ...ADAPTIVE_THINKING };
-    profiles[name] = profile;
-    changed = true;
-  }
+        // Skip if thinking is already enabled.
+        const thinking = readObject(profile.thinking);
+        if (thinking !== null && thinking.enabled === true) continue;
 
-  if (changed) {
-    llm.profiles = profiles;
-    config.llm = llm;
-    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-  }
-}
+        profile.thinking = { ...ADAPTIVE_THINKING };
+        profiles[name] = profile;
+        changed = true;
+      }
 
-export const enableAdaptiveThinkingManagedProfilesMigration: WorkspaceMigration =
-  {
-    id: "097-enable-adaptive-thinking-managed-profiles",
-    description:
-      "Enable adaptive thinking on managed balanced and quality-optimized profiles",
-    run(workspaceDir: string): void {
-      repairAdaptiveThinkingOnManagedProfiles(workspaceDir);
+      if (changed) {
+        llm.profiles = profiles;
+        config.llm = llm;
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+      }
     },
     down(_workspaceDir: string): void {
       // Forward-only.

package/src/workspace/migrations/098-remove-stale-updates-bulletin-file.ts

@@ -0,0 +1,31 @@
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+const MIGRATION_ID = "098-remove-stale-updates-bulletin-file";
+
+/**
+ * Delete `<workspace>/UPDATES.md`.
+ *
+ * Release notes used to be appended to the file by workspace migrations and
+ * processed by a background conversation dispatched at daemon startup. That
+ * feature has been removed — nothing consumes the file's contents anymore,
+ * and it was system-written bulletin material, so it is deleted outright.
+ *
+ * Idempotent: `rmSync` with `force` is a no-op when the file is absent.
+ */
+export const removeStaleUpdatesBulletinFileMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description:
+    "Delete leftover UPDATES.md release-note bulletins (processing job removed)",
+
+  run(workspaceDir: string): void {
+    rmSync(join(workspaceDir, "UPDATES.md"), { force: true });
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: the removed content was pending release-note bulletins
+    // for a feature that no longer exists.
+  },
+};

package/src/workspace/migrations/099-disable-cache-one-shot-callsites.ts

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Add `disableCache: true` to existing on-disk entries for the one-shot LLM
+ * call sites whose shipped defaults now opt out of prompt caching.
+ *
+ * The resolver prefers an explicit `llm.callSites.<id>` entry over
+ * CALL_SITE_DEFAULTS, and earlier migrations (054 recall, 072 replySuggestion,
+ * and platform overlays for the others) seeded such entries. Without this
+ * migration, upgraded workspaces would keep paying prompt-cache writes on
+ * call sites whose prompts never produce a cache read — only fresh installs
+ * would pick up the new shipped default.
+ *
+ * Idempotent and customization-preserving: an entry that already carries a
+ * `disableCache` key (either value — the user may have opted back in) is
+ * left untouched, and only the one key is added to entries we patch. Entries
+ * that don't exist on disk are skipped — those workspaces already resolve
+ * the shipped default.
+ */
+const ONE_SHOT_CALL_SITES = [
+  "recall",
+  "replySuggestion",
+  "homeGreeting",
+  "homeSuggestedPrompts",
+  "conversationTitle",
+  "memoryConsolidation",
+] as const;
+
+export const disableCacheOneShotCallsitesMigration: WorkspaceMigration = {
+  id: "099-disable-cache-one-shot-callsites",
+  description:
+    "Add disableCache: true to existing one-shot call-site entries so upgraded workspaces match the new shipped defaults",
+  run(workspaceDir: string): void {
+    if (process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH) return;
+
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown> = {};
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    const llm = readObject(config.llm);
+    if (llm === null) return;
+    const callSites = readObject(llm.callSites);
+    if (callSites === null) return;
+
+    let changed = false;
+    for (const callSite of ONE_SHOT_CALL_SITES) {
+      const entry = readObject(callSites[callSite]);
+      if (entry === null) continue;
+      if ("disableCache" in entry) continue;
+      entry.disableCache = true;
+      callSites[callSite] = entry;
+      changed = true;
+    }
+    if (!changed) return;
+
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only.
+  },
+};
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}

package/src/workspace/migrations/registry.ts

@@ -95,6 +95,8 @@ import { seedAvatarManifestMigration } from "./094-seed-avatar-manifest.js";
 import { bumpHeartbeatInterval30mTo60mMigration } from "./095-bump-heartbeat-interval-30m-to-60m.js";
 import { reduceQualityProfileEffortMigration } from "./096-reduce-quality-profile-effort.js";
 import { enableAdaptiveThinkingManagedProfilesMigration } from "./097-enable-adaptive-thinking-managed-profiles.js";
+import { removeStaleUpdatesBulletinFileMigration } from "./098-remove-stale-updates-bulletin-file.js";
+import { disableCacheOneShotCallsitesMigration } from "./099-disable-cache-one-shot-callsites.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -201,4 +203,6 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   bumpHeartbeatInterval30mTo60mMigration,
   reduceQualityProfileEffortMigration,
   enableAdaptiveThinkingManagedProfilesMigration,
+  removeStaleUpdatesBulletinFileMigration,
+  disableCacheOneShotCallsitesMigration,
 ];

package/src/__tests__/config-loader-quarantine-bulletin.test.ts

@@ -1,202 +0,0 @@
-/**
- * When loadConfig()/loadRawConfig() quarantines a corrupt config.json, it
- * appends a bulletin to <workspace>/UPDATES.md so the background update-
- * bulletin job picks up the event inside a background-only conversation.
- * The agent decides whether to surface the quarantine to the user — it's
- * agent-visible context, not a push notification.
- *
- * The bulletin is keyed on the quarantine filename via an HTML marker so
- * repeated appends for the same quarantine are idempotent — per the
- * Release-Update-Hygiene rule in the root AGENTS.md, idempotency at both the
- * runner level AND an in-file marker is required to close the crash-mid-append
- * window.
- */
-
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { basename, join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import {
-  _appendQuarantineBulletin,
-  invalidateConfigCache,
-  loadConfig,
-} from "../config/loader.js";
-import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
-const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
-const UPDATES_PATH = join(WORKSPACE_DIR, "UPDATES.md");
-
-function ensureTestDir(): void {
-  const dirs = [
-    WORKSPACE_DIR,
-    join(WORKSPACE_DIR, "data"),
-    join(WORKSPACE_DIR, "data", "memory"),
-    join(WORKSPACE_DIR, "data", "memory", "knowledge"),
-    join(WORKSPACE_DIR, "data", "logs"),
-  ];
-  for (const dir of dirs) {
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  }
-}
-
-function resetWorkspace(): void {
-  for (const name of readdirSync(WORKSPACE_DIR)) {
-    rmSync(join(WORKSPACE_DIR, name), { recursive: true, force: true });
-  }
-  ensureTestDir();
-}
-
-function listQuarantinedFiles(): string[] {
-  return readdirSync(WORKSPACE_DIR).filter((name) =>
-    /^config\.json\.corrupt-.+\.json$/.test(name),
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("config-quarantine UPDATES.md bulletin", () => {
-  beforeEach(() => {
-    resetWorkspace();
-    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
-    invalidateConfigCache();
-  });
-
-  afterEach(() => {
-    setStorePathForTesting(null);
-    invalidateConfigCache();
-  });
-
-  test("writes a bulletin with the quarantine marker when config.json is corrupt", () => {
-    writeFileSync(CONFIG_PATH, '{"provider": "anthropic", "mo');
-
-    loadConfig();
-
-    const [quarantinedName] = listQuarantinedFiles();
-    expect(quarantinedName).toBeDefined();
-    const quarantinedPath = join(WORKSPACE_DIR, quarantinedName);
-
-    expect(existsSync(UPDATES_PATH)).toBe(true);
-    const body = readFileSync(UPDATES_PATH, "utf-8");
-
-    // Heading must match the wording the background update-bulletin job
-    // relays to the user.
-    expect(body).toContain("## Config was reset to defaults");
-    // Quarantine file path is what the user cats to recover.
-    expect(body).toContain(quarantinedPath);
-    // Idempotency marker is shape-exact, basename-keyed (not full path).
-    expect(body).toContain(`<!-- config-quarantine:${quarantinedName} -->`);
-    expect(body).toMatch(
-      /<!-- config-quarantine:config\.json\.corrupt-.+\.json -->/,
-    );
-  });
-
-  test("two successive quarantines append two distinct bulletins (not overwrite)", () => {
-    // First corruption round.
-    writeFileSync(CONFIG_PATH, '{"partial": ');
-    loadConfig();
-    invalidateConfigCache();
-
-    const firstQuarantined = listQuarantinedFiles();
-    expect(firstQuarantined).toHaveLength(1);
-    const firstBody = readFileSync(UPDATES_PATH, "utf-8");
-    const firstMarker = `<!-- config-quarantine:${firstQuarantined[0]} -->`;
-    expect(firstBody).toContain(firstMarker);
-
-    // Loader wrote a fresh default config.json after quarantine; corrupt it
-    // again. Sleep briefly to guarantee a different ISO-timestamp millisecond
-    // component and therefore a distinct quarantine filename.
-    const untilDifferentMs = Date.now() + 5;
-    while (Date.now() < untilDifferentMs) {
-      /* spin */
-    }
-    writeFileSync(CONFIG_PATH, "still not json");
-    loadConfig();
-
-    const quarantined = listQuarantinedFiles().sort();
-    expect(quarantined).toHaveLength(2);
-
-    const body = readFileSync(UPDATES_PATH, "utf-8");
-    for (const name of quarantined) {
-      expect(body).toContain(`<!-- config-quarantine:${name} -->`);
-    }
-    // Two "Config was reset to defaults" sections — appended, not overwritten.
-    const headingMatches = body.match(/## Config was reset to defaults/g) ?? [];
-    expect(headingMatches).toHaveLength(2);
-    // The earlier marker is still present (append semantics).
-    expect(body).toContain(firstMarker);
-  });
-
-  test("idempotent: pre-existing marker for the same quarantine filename skips the append", () => {
-    // Simulate a crash-mid-append: UPDATES.md already contains a marker for
-    // a specific quarantine filename. A follow-up call referencing the same
-    // filename must leave the file untouched.
-    const quarantineName = "config.json.corrupt-2026-04-20T12-00-00.000Z.json";
-    const quarantinePath = join(WORKSPACE_DIR, quarantineName);
-    const preexisting =
-      `## Config was reset to defaults\n\n` +
-      `Pre-existing bulletin for ${quarantinePath}.\n\n` +
-      `<!-- config-quarantine:${quarantineName} -->\n`;
-    writeFileSync(UPDATES_PATH, preexisting, "utf-8");
-    // Also create the quarantine file on disk so the helper sees an
-    // environment consistent with a prior successful rename.
-    writeFileSync(quarantinePath, "{ not json", "utf-8");
-
-    _appendQuarantineBulletin(CONFIG_PATH, quarantinePath);
-
-    const after = readFileSync(UPDATES_PATH, "utf-8");
-    expect(after).toBe(preexisting);
-    // Exactly one marker present — no duplicate was appended.
-    expect(
-      after.match(
-        new RegExp(`<!-- config-quarantine:${quarantineName} -->`, "g"),
-      )?.length,
-    ).toBe(1);
-    expect(basename(quarantinePath)).toBe(quarantineName);
-  });
-
-  test("valid config.json does not create UPDATES.md (regression guard)", () => {
-    writeFileSync(
-      CONFIG_PATH,
-      JSON.stringify({ provider: "anthropic", model: "claude-opus-4-7" }),
-    );
-
-    loadConfig();
-
-    expect(listQuarantinedFiles()).toHaveLength(0);
-    expect(existsSync(UPDATES_PATH)).toBe(false);
-  });
-
-  test("appends (does not overwrite) when UPDATES.md already has unrelated content", () => {
-    const priorContent =
-      `## Some earlier bulletin\n\n` +
-      `Unrelated prior content from a previous migration.\n\n` +
-      `<!-- release-note-id:unrelated-note -->\n`;
-    writeFileSync(UPDATES_PATH, priorContent, "utf-8");
-
-    writeFileSync(CONFIG_PATH, "{oops");
-    loadConfig();
-
-    const body = readFileSync(UPDATES_PATH, "utf-8");
-    // Prior content preserved verbatim at the start.
-    expect(body.startsWith(priorContent)).toBe(true);
-    // New bulletin appended.
-    expect(body).toContain("## Config was reset to defaults");
-    expect(body).toMatch(
-      /<!-- config-quarantine:config\.json\.corrupt-.+\.json -->/,
-    );
-  });
-});

package/src/__tests__/conversation-starters-cadence.test.ts

@@ -1,161 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { v4 as uuid } from "uuid";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-import { maybeEnqueueConversationStartersJob } from "../memory/conversation-starters-cadence.js";
-import { getSqlite } from "../memory/db-connection.js";
-import { initializeDb } from "../memory/db-init.js";
-initializeDb();
-
-function clearTables() {
-  getSqlite().run("DELETE FROM memory_graph_nodes");
-  getSqlite().run("DELETE FROM memory_jobs");
-  getSqlite().run("DELETE FROM memory_checkpoints");
-}
-
-function insertMemoryNode(scopeId = "default") {
-  const now = Date.now();
-  getSqlite().run(
-    `INSERT INTO memory_graph_nodes (
-      id, content, type, created, last_accessed, last_consolidated,
-      emotional_charge, fidelity, confidence, significance,
-      stability, reinforcement_count, last_reinforced,
-      source_conversations, source_type, scope_id
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, 'vivid', 0.8, 0.5, 14, 0, ?, '[]', 'inferred', ?)`,
-    [
-      uuid(),
-      "test statement",
-      "semantic",
-      now,
-      now,
-      now,
-      '{"valence":0,"intensity":0.1,"decayCurve":"linear","decayRate":0.05,"originalIntensity":0.1}',
-      now,
-      scopeId,
-    ],
-  );
-}
-
-function setCheckpoint(key: string, value: string) {
-  getSqlite().run(
-    `INSERT OR REPLACE INTO memory_checkpoints (key, value, updated_at) VALUES (?, ?, ?)`,
-    [key, value, Date.now()],
-  );
-}
-
-function getPendingJobs(): Array<{ type: string }> {
-  return getSqlite()
-    .prepare(
-      `SELECT type FROM memory_jobs WHERE type = 'generate_conversation_starters' AND status = 'pending'`,
-    )
-    .all() as Array<{ type: string }>;
-}
-
-beforeEach(() => {
-  clearTables();
-});
-
-describe("maybeEnqueueConversationStartersJob", () => {
-  test("no-op when zero memory nodes", () => {
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(0);
-  });
-
-  test("enqueues when threshold exceeded (<=10 nodes, threshold=1)", () => {
-    insertMemoryNode();
-    insertMemoryNode();
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-  });
-
-  test("no-op when delta below threshold", () => {
-    for (let i = 0; i < 5; i++) insertMemoryNode();
-
-    // Set checkpoint to current count — no new items since last gen
-    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "5");
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(0);
-  });
-
-  test("uses higher threshold for larger memory counts (>50 nodes, threshold=10)", () => {
-    for (let i = 0; i < 55; i++) insertMemoryNode();
-
-    // Set checkpoint so delta is only 4 (below threshold of 10)
-    setCheckpoint(
-      "conversation_starters:item_count_at_last_gen:default",
-      "51",
-    );
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(0);
-
-    // Add more to exceed threshold
-    for (let i = 0; i < 6; i++) insertMemoryNode();
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-  });
-
-  test("dedup prevents double-enqueue", () => {
-    insertMemoryNode();
-    insertMemoryNode();
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-
-    // Call again — should not create a second job
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-  });
-
-  test("enqueues when active memory count drops below the last-generation checkpoint", () => {
-    // Start with 5 nodes and set checkpoint to 5
-    for (let i = 0; i < 5; i++) insertMemoryNode();
-    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "5");
-
-    // Simulate pruning: mark 3 nodes as gone (reducing totalActive to 2)
-    const ids = (
-      getSqlite()
-        .prepare(`SELECT id FROM memory_graph_nodes LIMIT 3`)
-        .all() as Array<{ id: string }>
-    ).map((r) => r.id);
-    for (const id of ids) {
-      getSqlite().run(
-        `UPDATE memory_graph_nodes SET fidelity = 'gone' WHERE id = ?`,
-        [id],
-      );
-    }
-
-    // The checkpoint is now ahead of the active memory count. This should
-    // enqueue a refresh immediately so stale starters can recover.
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-  });
-
-  test("scopes are independent", () => {
-    insertMemoryNode("scope-a");
-    insertMemoryNode("scope-b");
-
-    maybeEnqueueConversationStartersJob("scope-a");
-    maybeEnqueueConversationStartersJob("scope-b");
-
-    const jobs = getSqlite()
-      .prepare(
-        `SELECT payload FROM memory_jobs WHERE type = 'generate_conversation_starters' AND status = 'pending'`,
-      )
-      .all() as Array<{ payload: string }>;
-
-    expect(jobs).toHaveLength(2);
-    const payloads = jobs.map((j) => JSON.parse(j.payload).scopeId).sort();
-    expect(payloads).toEqual(["scope-a", "scope-b"]);
-  });
-});