@vellumai/assistant 0.10.6-staging.1 → 0.10.6

package/src/plugins/mtime-cache.ts

@@ -9,14 +9,21 @@
  * plugins directory, registers tools, and drives hook pre-import / init /
  * shutdown by handing the discovered directories to the hook loader.
  *
- * - A changed tool file triggers a re-import of just that tool, not a full
- *   plugin rebuild. Added and removed surface files are picked up live, since
- *   discovery is by directory listing.
+ * - Boot does one full discovery scan; after that, every change (plugin
+ *   installed, removed, disabled, or any source file inside a plugin edited
+ *   — including helper modules hooks/tools import) arrives through the
+ *   source-versions sentinel published by the resource monitor's watcher.
+ *   The dispatch path stats that one file and otherwise runs on memory.
+ * - A changed plugin is redeployed in place: the old version's `shutdown`
+ *   runs, its hook/tool cache entries and module-registry entries are
+ *   swept, and reactivation re-imports fresh source and runs `init`. The
+ *   whole directory is the reload unit so a re-imported hook can never pair
+ *   with a stale cached helper.
  * - Plugins are never "registered" as a unit — we register their tools into
- *   the global tool registry and cache-bust them using mtime on reads.
+ *   the global tool registry.
  *
- * The cache is populated at boot by `loadUserPlugins()` and read on every
- * `getHooksFor` / `getAllTools` call.
+ * The cache is populated at boot by `loadUserPlugins()`; `getHooksFor`
+ * reads it on every dispatch via {@link getUserHookEntriesFor}.
  */
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
@@ -42,15 +49,25 @@ import {
 import { finalizeTool } from "../tools/tool-defaults.js";
 import type { Tool, ToolDefinition } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
-import { getWorkspacePluginsDir } from "../util/platform.js";
+import {
+  getWorkspaceHooksDir,
+  getWorkspacePluginsDir,
+} from "../util/platform.js";
 import { APP_VERSION } from "../version.js";
 import {
   deriveToolName,
   listSurfaceDir,
   parsePluginManifest,
 } from "./external-plugin-loader.js";
+import { snapshotPluginSource } from "./source-fingerprint.js";
+import type { PluginSourceVersion } from "./source-versions.js";
+import {
+  getSourceVersionsPath,
+  readSourceVersions,
+} from "./source-versions.js";
 import {
   clearSurfaceImportInflight,
+  evictModule,
   getMtime,
   importWithTimeout,
   setSurfaceImportTimeout,
@@ -93,7 +110,9 @@ const INSTALL_META_FILENAME = "install-meta.json";
  */
 function getInstallDate(pluginDir: string): number {
   const cached = installDateCache.get(pluginDir);
-  if (cached !== undefined) return cached;
+  if (cached !== undefined) {
+    return cached;
+  }
 
   // Try install-meta.json first.
   const metaPath = join(pluginDir, INSTALL_META_FILENAME);
@@ -171,13 +190,29 @@ const discoveredPluginDirs = new Map<string, string>();
  */
 const disabledPluginDirs = new Set<string>();
 
+/**
+ * The source-versions state this process last applied, keyed by directory
+ * (see `./source-versions.ts`). Seeded at boot from the daemon's own walk —
+ * the same fingerprint algorithm over the same disk yields the same stamps
+ * as the watcher, so the first sentinel publication after boot diffs
+ * correctly even against edits made while the daemon was down.
+ */
+let lastVersions: Record<string, PluginSourceVersion> = {};
+
+/** mtime of the sentinel document as of the last look; 0 = never seen. */
+let lastSentinelMtime = 0;
+
+/** In-flight reconcile — concurrent dispatches await it rather than racing. */
+let reconcileInFlight: Promise<void> | null = null;
+
 // ─── Hook reads ──────────────────────────────────────────────────────────────
 
 /**
  * Get all hooks for a given event name from user plugins and standalone
- * workspace hooks. Refreshes plugin discovery first, then delegates the actual
- * hook resolution to the hook loader. Plugin hooks run in install-date order,
- * the workspace hook runs last.
+ * workspace hooks. Checks the source-versions sentinel first (one stat;
+ * reconciles only when the watcher published a change), then delegates to
+ * the hook loader's in-memory cache. Plugin hooks run in install-date
+ * order, the workspace hook runs last.
  *
  * `effectiveEnabledPlugins` carries the per-chat plugin scope: when non-null,
  * user plugins outside the set are skipped (standalone workspace hooks always
@@ -187,7 +222,7 @@ export async function getUserHookEntriesFor<TCtx = unknown>(
   hookName: string,
   effectiveEnabledPlugins?: Set<string> | null,
 ): Promise<HookEntry<TCtx>[]> {
-  await scanPlugins();
+  await maybeReconcileFromSentinel();
   return collectUserHookEntries<TCtx>(
     hookName,
     discoveredPluginDirs,
@@ -210,6 +245,246 @@ export async function getUserHooksFor<TCtx = unknown>(
   return entries.map((e) => e.fn);
 }
 
+// ─── Source-versions reconcile ───────────────────────────────────────────────
+
+/**
+ * Dispatch-path gate: one stat of the source-versions sentinel. When its
+ * mtime is unchanged since the last look (the overwhelmingly common case)
+ * this returns immediately, and dispatch runs entirely on memory. When the
+ * watcher published a change, the document is applied before the dispatch
+ * proceeds, so the turn that follows an edit already runs the new code.
+ *
+ * A missing or unreadable sentinel is degraded mode, not an error: the
+ * boot-time state keeps serving, and live reload resumes when the monitor
+ * publishes again.
+ */
+async function maybeReconcileFromSentinel(): Promise<void> {
+  if (reconcileInFlight !== null) {
+    await reconcileInFlight;
+    return;
+  }
+  const mtime = getMtime(getSourceVersionsPath());
+  if (mtime === lastSentinelMtime) {
+    return;
+  }
+  // Claim the mtime before any async work, so a concurrent dispatch either
+  // finds the in-flight promise above or skips on the updated mtime.
+  lastSentinelMtime = mtime;
+  if (mtime === 0) {
+    return;
+  }
+  const doc = readSourceVersions();
+  if (doc === null) {
+    return;
+  }
+  reconcileInFlight = applySourceVersions(doc.plugins).finally(() => {
+    reconcileInFlight = null;
+  });
+  await reconcileInFlight;
+}
+
+/**
+ * Apply a published source-versions map: diff it against the state last
+ * applied and redeploy exactly what changed. Never throws — a failed apply
+ * is logged and the next publication retries from the sentinel's truth.
+ *
+ * Per directory, the transitions are:
+ * - present + enabled with a moved fingerprint → in-place redeploy:
+ *   `shutdown` (reason `reload`) → sweep hook/tool caches and the module
+ *   registry → re-import, re-register tools, `init`. The whole directory is
+ *   the reload unit on purpose: partial eviction would let a re-imported
+ *   hook pair with a stale cached helper, silently mixing versions.
+ * - newly present (installed, or `.disabled` removed) → bring up.
+ * - gone, or newly disabled → tear down (`uninstall` / `disable`).
+ * The workspace hooks pseudo-entry gets the same treatment through its own
+ * `init`/`shutdown` lifecycle.
+ */
+async function applySourceVersions(
+  next: Readonly<Record<string, PluginSourceVersion>>,
+): Promise<void> {
+  try {
+    const workspaceHooksDir = getWorkspaceHooksDir();
+    const prev = lastVersions;
+    const dirs = new Set([...Object.keys(prev), ...Object.keys(next)]);
+    let membershipChanged = false;
+
+    for (const dir of dirs) {
+      if (dir === workspaceHooksDir) {
+        continue;
+      }
+      const before = prev[dir];
+      const after = next[dir];
+      const activeName = discoveredPluginDirs.get(dir);
+      const shouldBeUp = after !== undefined && !after.disabled;
+
+      if (activeName !== undefined && !shouldBeUp) {
+        const reason: ShutdownReason =
+          after === undefined ? "uninstall" : "disable";
+        await deactivatePlugin(activeName, reason);
+        await evictPlugin(dir, activeName);
+        sweepModules(before, after);
+        membershipChanged = true;
+      } else if (activeName === undefined && shouldBeUp) {
+        // Reinstalls land at the same path: sweep any modules cached from a
+        // prior install before the fresh import.
+        sweepModules(before, after);
+        if (await bringUpPlugin(dir)) {
+          membershipChanged = true;
+        }
+      } else if (
+        activeName !== undefined &&
+        before !== undefined &&
+        after !== undefined &&
+        before.fingerprint !== after.fingerprint
+      ) {
+        log.info(
+          { plugin: activeName, dir },
+          "plugin source changed — reloading",
+        );
+        // Shutdown reads the old version's hook from the cache, so it must
+        // run before the hook cache is cleared.
+        await deactivatePlugin(activeName, "reload");
+        evictHooksForOwner(activeName);
+        evictToolCacheEntries(activeName);
+        sweepModules(before, after);
+        // Re-read the manifest — the edit may have renamed the plugin (or
+        // broken the manifest, in which case the plugin stays down until a
+        // later edit fixes it and moves the fingerprint again).
+        const manifest = await parsePluginManifest(dir);
+        if (manifest === undefined) {
+          discoveredPluginDirs.delete(dir);
+          membershipChanged = true;
+        } else {
+          if (manifest.name !== activeName) {
+            discoveredPluginDirs.set(dir, manifest.name);
+            membershipChanged = true;
+          }
+          await reconcilePluginTools(dir, manifest.name);
+          await activatePlugin(dir, manifest.name);
+        }
+      }
+    }
+
+    if (membershipChanged) {
+      sortDiscoveredPluginDirs();
+    }
+
+    await reconcileWorkspaceHooks(
+      prev[workspaceHooksDir],
+      next[workspaceHooksDir],
+    );
+
+    lastVersions = { ...next };
+  } catch (err) {
+    log.error(
+      { err },
+      "source-versions reconcile failed — keeping current state",
+    );
+  }
+}
+
+/**
+ * Bring up a directory the sentinel reports as present and enabled. Returns
+ * whether the plugin joined the discovered set (a malformed manifest is
+ * logged by the parser and the directory is skipped until it changes again).
+ */
+async function bringUpPlugin(dir: string): Promise<boolean> {
+  const manifest = await parsePluginManifest(dir);
+  if (manifest === undefined) {
+    return false;
+  }
+  discoveredPluginDirs.set(dir, manifest.name);
+  disabledPluginDirs.delete(dir);
+  log.info({ plugin: manifest.name, dir }, "plugin discovered");
+  await reconcilePluginTools(dir, manifest.name);
+  await activatePlugin(dir, manifest.name);
+  return true;
+}
+
+/**
+ * Evict the union of two version entries' module paths from the module
+ * registry, so re-imports re-evaluate a mutually consistent set (deleted
+ * files may still be cached — hence the union, not just the new list).
+ */
+function sweepModules(
+  before: PluginSourceVersion | undefined,
+  after: PluginSourceVersion | undefined,
+): void {
+  const paths = new Set([
+    ...(before?.evictionPaths ?? []),
+    ...(after?.evictionPaths ?? []),
+  ]);
+  for (const path of paths) {
+    evictModule(path);
+  }
+}
+
+/**
+ * Reconcile the standalone workspace hooks pseudo-entry: same
+ * shutdown → sweep → re-import → init cycle a plugin gets, through the
+ * workspace owner's lifecycle.
+ */
+async function reconcileWorkspaceHooks(
+  before: PluginSourceVersion | undefined,
+  after: PluginSourceVersion | undefined,
+): Promise<void> {
+  if (before?.fingerprint === after?.fingerprint) {
+    return;
+  }
+  const reason: ShutdownReason = after === undefined ? "uninstall" : "reload";
+  const activeIdx = activatedPlugins.findIndex(
+    (p) => p.name === WORKSPACE_HOOKS_OWNER,
+  );
+  if (activeIdx >= 0) {
+    await runShutdownHook(
+      WORKSPACE_HOOKS_OWNER,
+      { assistantVersion: APP_VERSION, reason },
+      reason,
+    );
+    activatedPlugins.splice(activeIdx, 1);
+  }
+  evictHooksForOwner(WORKSPACE_HOOKS_OWNER);
+  sweepModules(before, after);
+  if (after !== undefined) {
+    await preImportWorkspaceHooks();
+    await runInitHook(WORKSPACE_HOOKS_OWNER);
+    activatedPlugins.push({ name: WORKSPACE_HOOKS_OWNER });
+    log.info("workspace hooks reloaded");
+  }
+}
+
+/**
+ * Seed the reconcile baseline at boot from the daemon's own walk, and record
+ * the sentinel's current mtime without applying its content. Both sides run
+ * the same fingerprint algorithm over the same disk, so the seed matches
+ * whatever a healthy watcher would publish for the state boot just loaded —
+ * and the first publication that differs (including edits made while the
+ * daemon was down, which the watcher detects against its own adopted state)
+ * diffs correctly against it.
+ */
+function seedVersionBaseline(): void {
+  const seeded: Record<string, PluginSourceVersion> = {};
+  for (const [dir] of discoveredPluginDirs) {
+    const snapshot = snapshotPluginSource(dir);
+    seeded[dir] = {
+      fingerprint: snapshot.fingerprint,
+      evictionPaths: snapshot.evictionPaths,
+      disabled: false,
+    };
+  }
+  const workspaceHooksDir = getWorkspaceHooksDir();
+  if (existsSync(workspaceHooksDir)) {
+    const snapshot = snapshotPluginSource(workspaceHooksDir);
+    seeded[workspaceHooksDir] = {
+      fingerprint: snapshot.fingerprint,
+      evictionPaths: snapshot.evictionPaths,
+      disabled: false,
+    };
+  }
+  lastVersions = seeded;
+  lastSentinelMtime = getMtime(getSourceVersionsPath());
+}
+
 // ─── Tool cache ──────────────────────────────────────────────────────────────
 
 /**
@@ -282,7 +557,9 @@ async function reconcilePluginTools(
   // Evict cached tools whose files no longer exist on disk.
   for (const key of toolCache.keys()) {
     const [cachedPluginName, cachedToolName] = key.split("/");
-    if (cachedPluginName !== pluginName) continue;
+    if (cachedPluginName !== pluginName) {
+      continue;
+    }
     if (!onDiskNames.has(cachedToolName)) {
       toolCache.delete(key);
     }
@@ -303,10 +580,10 @@ export function getCachedUserTools(): Tool[] {
  * Scan the plugins directory, update the discovered set, and reconcile
  * tools for each plugin. Also evicts cache entries for deleted plugins.
  *
- * This is the "pull" — called on every hook read and at boot. The cost
- * is one `readdirSync` + N `statSync` calls where N = total surface files
- * across all plugins. For a typical workspace with 2-3 plugins, that's
- * ~10-15 stats — sub-millisecond.
+ * Runs once at boot ({@link populateCacheAtBoot}); steady-state changes —
+ * installs, removals, disables, and source edits — arrive through the
+ * source-versions reconcile instead, so the dispatch path never pays for
+ * this walk.
  */
 async function scanPlugins(): Promise<void> {
   const pluginsDir = getWorkspacePluginsDir();
@@ -330,11 +607,15 @@ async function scanPlugins(): Promise<void> {
   for (const entry of entries) {
     const pluginDir = join(pluginsDir, entry);
     try {
-      if (!statSync(pluginDir).isDirectory()) continue;
+      if (!statSync(pluginDir).isDirectory()) {
+        continue;
+      }
     } catch {
       continue;
     }
-    if (!existsSync(join(pluginDir, "package.json"))) continue;
+    if (!existsSync(join(pluginDir, "package.json"))) {
+      continue;
+    }
 
     // Check for the .disabled sentinel. A plugin is disabled when a file
     // named `.disabled` exists inside its plugin directory. Disabled
@@ -358,7 +639,9 @@ async function scanPlugins(): Promise<void> {
     }
 
     const manifest = await parsePluginManifest(pluginDir);
-    if (manifest === undefined) continue;
+    if (manifest === undefined) {
+      continue;
+    }
     const { name: pluginName } = manifest;
 
     currentDirs.set(pluginDir, pluginName);
@@ -383,12 +666,10 @@ async function scanPlugins(): Promise<void> {
   // Update the discovered set, sorted by original install date so
   // hook execution order and tool registration order are deterministic.
   discoveredPluginDirs.clear();
-  const sorted = [...currentDirs.entries()].sort(
-    ([dirA], [dirB]) => getInstallDate(dirA) - getInstallDate(dirB),
-  );
-  for (const [dir, name] of sorted) {
+  for (const [dir, name] of currentDirs) {
     discoveredPluginDirs.set(dir, name);
   }
+  sortDiscoveredPluginDirs();
 
   // Activate any plugin not yet brought up. Idempotent: already-active plugins
   // are skipped by the `activatedNames` guard, so steady-state scans (one per
@@ -400,6 +681,21 @@ async function scanPlugins(): Promise<void> {
   }
 }
 
+/**
+ * Re-sort the discovered set by original install date, so hook execution
+ * order and tool registration order stay deterministic as membership
+ * changes at runtime.
+ */
+function sortDiscoveredPluginDirs(): void {
+  const sorted = [...discoveredPluginDirs.entries()].sort(
+    ([dirA], [dirB]) => getInstallDate(dirA) - getInstallDate(dirB),
+  );
+  discoveredPluginDirs.clear();
+  for (const [dir, name] of sorted) {
+    discoveredPluginDirs.set(dir, name);
+  }
+}
+
 /**
  * Evict all cache entries for a deleted plugin directory. The plugin name
  * is passed in from the discoveredPluginDirs map (captured when the plugin
@@ -413,12 +709,7 @@ async function evictPlugin(
   evictHooksForOwner(pluginName);
 
   // Evict tools.
-  const toolPrefix = `${pluginName}/`;
-  for (const key of toolCache.keys()) {
-    if (key.startsWith(toolPrefix)) {
-      toolCache.delete(key);
-    }
-  }
+  evictToolCacheEntries(pluginName);
 
   log.info(
     { plugin: pluginName, pluginDir },
@@ -428,6 +719,16 @@ async function evictPlugin(
   installDateCache.delete(pluginDir);
 }
 
+/** Drop every `toolCache` entry owned by `pluginName`. */
+function evictToolCacheEntries(pluginName: string): void {
+  const toolPrefix = `${pluginName}/`;
+  for (const key of toolCache.keys()) {
+    if (key.startsWith(toolPrefix)) {
+      toolCache.delete(key);
+    }
+  }
+}
+
 /**
  * Evict all plugin-owned cache entries (when the plugins directory is gone
  * entirely). Standalone workspace hooks are preserved by the hook loader:
@@ -477,7 +778,9 @@ async function activatePlugin(
   pluginDir: string,
   pluginName: string,
 ): Promise<void> {
-  if (activatedNames.has(pluginName)) return;
+  if (activatedNames.has(pluginName)) {
+    return;
+  }
   // Reserve synchronously, before any await, so a re-entrant or concurrent
   // scan observes this plugin as already handled.
   activatedNames.add(pluginName);
@@ -523,10 +826,14 @@ async function deactivatePlugin(
   pluginName: string,
   reason: ShutdownReason,
 ): Promise<void> {
-  if (!activatedNames.has(pluginName)) return;
+  if (!activatedNames.has(pluginName)) {
+    return;
+  }
   activatedNames.delete(pluginName);
   const idx = activatedPlugins.findIndex((p) => p.name === pluginName);
-  if (idx >= 0) activatedPlugins.splice(idx, 1);
+  if (idx >= 0) {
+    activatedPlugins.splice(idx, 1);
+  }
 
   // Unregister tools before running shutdown so the model-visible surface is
   // clean before teardown.
@@ -587,6 +894,10 @@ export async function populateCacheAtBoot(
     await runInitHook(WORKSPACE_HOOKS_OWNER);
     activatedPlugins.push({ name: WORKSPACE_HOOKS_OWNER });
   }
+
+  // Boot is self-sufficient (the scan above never waits on the monitor);
+  // from here on, changes arrive via the sentinel diffed against this seed.
+  seedVersionBaseline();
 }
 
 // ─── Test hooks ──────────────────────────────────────────────────────────────
@@ -610,6 +921,9 @@ export function resetPluginCacheForTests(): void {
   activatedPlugins.length = 0;
   activatedNames.clear();
   disabledPluginDirs.clear();
+  lastVersions = {};
+  lastSentinelMtime = 0;
+  reconcileInFlight = null;
 }
 
 /**

package/src/plugins/pipeline.ts

@@ -9,8 +9,9 @@
  * place (returning `void`) or returns a partial context whose fields are merged
  * onto the draft. Failed hook drafts are discarded.
  *
- * `getHooksFor` is now async — it pulls user-land hooks from the mtime
- * cache (filesystem-as-truth) and default plugin hooks from the registry
+ * `getHooksFor` is now async — it pulls user-land hooks from the plugin
+ * cache (filesystem-as-truth via the source-versions reconcile) and default
+ * plugin hooks from the registry
  * in a single unified call.
  *
  * Design doc: `.private/plans/agent-plugin-system.md`.

package/src/providers/__tests__/inference.test.ts

@@ -53,35 +53,42 @@ describe("migrateCreateProviderConnections", () => {
     expect(Array.isArray(rows)).toBe(true);
   });
 
-  test("seeds canonical connections on first run", () => {
+  test("seedCanonicalConnections seeds the provider-agnostic vellum connection", () => {
     const { db } = setupDb();
-    const canonicals = [
-      "anthropic-managed",
-      "openai-managed",
-      "gemini-managed",
-    ];
-    for (const name of canonicals) {
-      const conn = getConnection(db, name);
-      expect(conn).not.toBeNull();
-    }
+    seedCanonicalConnections(db);
+    const vellum = getConnection(db, "vellum");
+    expect(vellum).not.toBeNull();
+    expect(vellum?.provider).toBe("vellum");
+    expect(vellum?.auth.type).toBe("platform");
+    // Derived from MANAGED_CONNECTION_NAMES → write-protected at the route layer.
+    expect(vellum?.isManaged).toBe(true);
   });
 
-  test("canonical connections have correct auth types", () => {
+  test("seedCanonicalConnections is idempotent", () => {
     const { db } = setupDb();
-    expect(getConnection(db, "anthropic-managed")?.auth.type).toBe("platform");
-    expect(getConnection(db, "openai-managed")?.auth.type).toBe("platform");
-    expect(getConnection(db, "gemini-managed")?.auth.type).toBe("platform");
+    // Run twice — should not throw or create duplicate vellum rows.
+    seedCanonicalConnections(db);
+    seedCanonicalConnections(db);
+    const managed = listConnections(db, { provider: "vellum" });
+    expect(managed.filter((c) => c.name === "vellum").length).toBe(1);
   });
 
-  test("seedCanonicalConnections is idempotent", () => {
+  test("seedCanonicalConnections does not clobber a user connection named vellum", () => {
     const { db } = setupDb();
-    // Run twice — should not throw or create duplicates
-    seedCanonicalConnections(db);
+    // `vellum` was not reserved before consolidation, so an install may already
+    // have a BYOK connection keyed `vellum`. Seeding must not rewrite it to the
+    // platform-auth sentinel.
+    createConnection(db, {
+      name: "vellum",
+      provider: "anthropic",
+      auth: { type: "api_key", credential: "credential/anthropic/api_key" },
+    });
+
     seedCanonicalConnections(db);
-    const managed = listConnections(db, { provider: "anthropic" });
-    expect(managed.filter((c) => c.name === "anthropic-managed").length).toBe(
-      1,
-    );
+
+    const conn = getConnection(db, "vellum");
+    expect(conn?.provider).toBe("anthropic");
+    expect(conn?.auth.type).toBe("api_key");
   });
 });
 
@@ -274,32 +281,36 @@ describe("Mix-and-match: two profiles, same provider, different connections", ()
   test("getConnection returns the right auth for each connection name", () => {
     const { db } = setupDb();
 
-    // anthropic-managed already exists (canonical seed) with platform auth.
-    const managedConn = getConnection(db, "anthropic-managed");
-    expect(managedConn?.auth.type).toBe("platform");
-
-    // Create a personal connection with api_key auth.
+    // Two connections for the same provider with distinct auth resolve
+    // independently: one platform-auth, one personal api_key.
+    createConnection(db, {
+      name: "anthropic-platform",
+      provider: "anthropic",
+      auth: { type: "platform" },
+    });
     createConnection(db, {
       name: "anthropic-personal",
       provider: "anthropic",
       auth: { type: "api_key", credential: "credential/anthropic/api_key" },
     });
 
-    const personalConn = getConnection(db, "anthropic-personal");
-    expect(personalConn?.auth.type).toBe("api_key");
+    expect(getConnection(db, "anthropic-platform")?.auth.type).toBe("platform");
+    expect(getConnection(db, "anthropic-personal")?.auth.type).toBe("api_key");
 
     // Both connections exist for the same provider.
     const anthropicConns = listConnections(db, { provider: "anthropic" });
     const names = anthropicConns.map((c) => c.name);
-    expect(names).toContain("anthropic-managed");
+    expect(names).toContain("anthropic-platform");
     expect(names).toContain("anthropic-personal");
 
     // Auth is distinct per connection.
-    const managed = anthropicConns.find((c) => c.name === "anthropic-managed");
+    const platform = anthropicConns.find(
+      (c) => c.name === "anthropic-platform",
+    );
     const personal = anthropicConns.find(
       (c) => c.name === "anthropic-personal",
     );
-    expect(managed?.auth.type).toBe("platform");
+    expect(platform?.auth.type).toBe("platform");
     expect(personal?.auth.type).toBe("api_key");
   });
 });