@vellumai/assistant 0.11.3 → 0.11.4-staging.1

package/src/__tests__/injector-disk-pressure.test.ts

@@ -14,6 +14,7 @@ mock.module("../daemon/date-context.js", () => ({
   formatTurnTimestamp: () => FIXED_TURN_TIMESTAMP,
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
 import {
   clearConversations,
   setConversation,
@@ -39,6 +40,7 @@ import {
 } from "../plugins/defaults/workspace/injectors.js";
 import type { Injector, TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block
 // from the persisted message rows, so the schema must exist for Slack-channel
@@ -90,38 +92,23 @@ const diskPressureInjector = findInjector("disk-pressure-warning");
 // turn can exercise both; the seed helpers mutate and re-register the same
 // instance. An empty (non-dirty) workspace cache resolves to no block, so
 // disk-pressure-only tests don't trigger a directory scan.
-let liveConversation: {
-  conversationId: string;
-  workingDir: string;
-  workspaceTopLevelContext: string | null;
-  workspaceTopLevelDirty: boolean;
-  diskPressureCleanupModeActive: boolean;
-  channelCapabilities?: ChannelCapabilities;
-  trustContext?: { trustClass: string };
-  currentTurnTemporalSnapshot?: {
-    clientTimezone: string | null;
-  };
-  currentTurnInterfaceContext?: {
-    userMessageInterface: string;
-    assistantMessageInterface: string;
-  };
-};
+let liveConversation: Conversation;
 
 function resetLiveConversation(): void {
-  liveConversation = {
+  liveConversation = asConversation({
     conversationId: TEST_CONVERSATION_ID,
     workingDir: "/workspace",
     workspaceTopLevelContext: "",
     workspaceTopLevelDirty: false,
     diskPressureCleanupModeActive: false,
-    trustContext: { trustClass: "guardian" },
+    trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
     // The unified-turn-context injector sources the interface label from the
     // live conversation's turn interface context; match the expected blocks.
     currentTurnInterfaceContext: {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
     },
-  };
+  });
 }
 
 // `applyRuntimeInjections` gates the `<turn_context>` block on the live
@@ -130,24 +117,25 @@ function resetLiveConversation(): void {
 function seedTemporalSnapshot(): void {
   liveConversation.currentTurnTemporalSnapshot = {
     clientTimezone: null,
+    timeSinceLastMessage: null,
   };
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 function seedChannelCapabilities(caps: ChannelCapabilities): void {
   liveConversation.channelCapabilities = caps;
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 function seedDiskPressure(cleanupModeActive: boolean): void {
   liveConversation.diskPressureCleanupModeActive = cleanupModeActive;
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 function seedWorkspaceContext(text: string): void {
   liveConversation.workspaceTopLevelContext = text;
   liveConversation.workspaceTopLevelDirty = false;
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 // Persist Slack-channel rows for the turn conversation so

package/src/__tests__/llm-context-resolution.test.ts

@@ -1,4 +1,21 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+// Entry-name providers resolve context limits through their row's kind, so
+// the tests control the row store directly. A dangling label (no row) falls
+// back to the model's catalog owner.
+const connectionRows = new Map<string, { name: string; provider: string }>([
+  ["openai-work", { name: "openai-work", provider: "openai" }],
+  ["my-endpoint", { name: "my-endpoint", provider: "openai-compatible" }],
+]);
+mock.module("../persistence/db-connection.js", () => ({
+  getDb: () => ({}),
+}));
+mock.module("../providers/inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) =>
+    connectionRows.get(name) ?? null,
+  listConnections: () => [],
+  canonicalVellumConnection: () => null,
+}));
 
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
 import { LLMSchema } from "../config/schemas/llm.js";
@@ -131,6 +148,61 @@ describe("resolveEffectiveContextWindow", () => {
     expect(resolved.modelMaxInputTokens).toBe(1050000);
   });
 
+  test("an entry of a catalog kind resolves the model's own context limits", () => {
+    // The entries collapse stores connection names in the provider field;
+    // the row's kind carries the model's limits, so an entry label must not
+    // fall back to the 200k default when its kind serves the model.
+    const llm = LLMSchema.parse({
+      profiles: {
+        work: { provider: "openai-work", model: "gpt-5.5" },
+      },
+      activeProfile: "work",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+    expect(resolved.maxOutputTokens).toBeDefined();
+  });
+
+  test("a custom-endpoint entry keeps the conservative default for a catalog-colliding model id", () => {
+    // An openai-compatible endpoint's "gpt-5.5" is not OpenAI's; inheriting
+    // the built-in 1.05M limit would let oversized requests through.
+    const llm = LLMSchema.parse({
+      profiles: {
+        custom: { provider: "my-endpoint", model: "gpt-5.5" },
+      },
+      activeProfile: "custom",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.modelMaxInputTokens).toBe(200000);
+    expect(resolved.maxOutputTokens).toBeUndefined();
+  });
+
+  test("a label with no row falls back to the model's catalog owner", () => {
+    const llm = LLMSchema.parse({
+      profiles: {
+        gone: { provider: "deleted-entry", model: "gpt-5.5" },
+      },
+      activeProfile: "gone",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+  });
+
   test("unknown catalog model falls back safely to the default 200k cap", () => {
     const llm = LLMSchema.parse({
       callSites: {

package/src/__tests__/llm-schema.test.ts

@@ -123,11 +123,14 @@ describe("LLMSchema", () => {
     expect(parsed.profileOrder).toEqual(["fast", "stale"]);
   });
 
-  test("invalid provider rejected", () => {
+  test("an unknown provider parses (read tolerance for entry names)", () => {
+    // The open provider schema keeps the profile; write-time membership is
+    // enforced at the profiles route and the config-write choke point, and
+    // dispatch resolves the value as a connection entry name.
     const result = LLMSchema.safeParse({
       profiles: { mine: { provider: "bogus-provider" } },
     });
-    expect(result.success).toBe(false);
+    expect(result.success).toBe(true);
   });
 
   test("invalid temperature (negative) rejected", () => {

package/src/__tests__/mcp-list-plugin-servers.test.ts

@@ -0,0 +1,250 @@
+/**
+ * Route-level coverage for plugin-declared MCP servers appearing in
+ * `internal_mcp_list` (what `assistant mcp list` renders).
+ *
+ * The unit tests in `plugins/__tests__/mcp-servers.test.ts` cover reading
+ * `mcp.json`. This file covers the merge, and two properties that a
+ * refactor could quietly break:
+ *
+ * 1. A workspace entry of the same id wins. Getting precedence backwards
+ *    would let a plugin redirect a server the user configured by hand.
+ * 2. A plugin server is never health-checked. `McpClient.connect` resolves
+ *    `mcp:<serverId>:headers` and `mcp:<serverId>:tokens` from the
+ *    credential store, and a plugin controls both its server key and its
+ *    URL, so probing one would send a workspace credential to an endpoint
+ *    the plugin chose whenever an id happens to match a stored key.
+ */
+
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, jest, mock, test } from "bun:test";
+
+const mockConnect = jest.fn();
+const mockDisconnect = jest.fn();
+/** Server ids the route actually constructed an MCP client for. */
+const connectedServerIds: string[] = [];
+
+mock.module("../mcp/client.js", () => ({
+  McpClient: class {
+    constructor(serverId: string) {
+      connectedServerIds.push(serverId);
+    }
+    get isConnected() {
+      return true;
+    }
+    get lastError() {
+      return null;
+    }
+    connect = mockConnect;
+    disconnect = mockDisconnect;
+  },
+}));
+
+mock.module("../mcp/mcp-auth-orchestrator.js", () => ({
+  orchestrateMcpOAuthConnect: async () => ({
+    auth_url: "",
+    already_authenticated: false,
+  }),
+}));
+
+mock.module("../mcp/mcp-auth-state.js", () => ({
+  getMcpAuthState: () => null,
+}));
+
+mock.module("../mcp/mcp-oauth-provider.js", () => ({
+  // Stand in for a credential store that holds tokens for every id, which
+  // is the condition under which a leak would be observable.
+  hasMcpOAuthTokens: async () => true,
+  deleteMcpOAuthCredentials: async () => ({ ok: true, failedKeys: [] }),
+}));
+
+mock.module("../mcp/mcp-header-store.js", () => ({
+  getMcpHeaders: async () => ({ Authorization: "Bearer workspace-secret" }),
+  setMcpHeaders: async () => {},
+  deleteMcpHeaders: async () => true,
+}));
+
+mock.module("../daemon/mcp-reload-service.js", () => ({
+  reloadMcpServers: async () => {},
+}));
+
+import { setConfig } from "./helpers/set-config.js";
+
+setConfig("mcp", {
+  servers: {
+    "from-workspace": {
+      transport: { type: "streamable-http", url: "https://config.example/mcp" },
+      enabled: true,
+      defaultRiskLevel: "high",
+      maxTools: 20,
+    },
+    // Deliberately shares an id with the `shadowed` plugin below.
+    shadowed: {
+      transport: { type: "streamable-http", url: "https://wins.example/mcp" },
+      enabled: true,
+      defaultRiskLevel: "low",
+      maxTools: 20,
+    },
+  },
+});
+
+const { getWorkspacePluginsDir } = await import("../util/platform.js");
+const { ROUTES } = await import("../runtime/routes/mcp-auth-routes.js");
+
+const listHandler = ROUTES.find(
+  (r: { operationId: string }) => r.operationId === "internal_mcp_list",
+)!.handler;
+
+interface ListedServer {
+  id: string;
+  status: string;
+  source?: "workspace" | "plugin";
+  pluginName?: string;
+  defaultRiskLevel: string;
+  hasOAuth: boolean;
+  hasStaticAuth: boolean;
+  authType: string;
+  transport: { type: string; url?: string };
+}
+
+function writePlugin(name: string, mcpJson: unknown): void {
+  const dir = join(getWorkspacePluginsDir(), name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "package.json"),
+    JSON.stringify({ name, version: "1.0.0" }),
+  );
+  writeFileSync(join(dir, "mcp.json"), JSON.stringify(mcpJson));
+}
+
+function unabyssManifest(): unknown {
+  return {
+    mcpServers: {
+      unabyss: { type: "streamable-http", url: "https://mcp.unabyss.com" },
+    },
+  };
+}
+
+async function listServers(): Promise<ListedServer[]> {
+  const result = (await listHandler({})) as { servers: ListedServer[] };
+  return result.servers;
+}
+
+describe("internal_mcp_list, plugin-declared servers", () => {
+  beforeEach(() => {
+    mockConnect.mockReset();
+    mockDisconnect.mockReset();
+    connectedServerIds.length = 0;
+    rmSync(getWorkspacePluginsDir(), { recursive: true, force: true });
+    mkdirSync(getWorkspacePluginsDir(), { recursive: true });
+  });
+
+  test("a plugin's mcp.json server appears alongside workspace servers", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const ids = (await listServers()).map((s) => s.id);
+    expect(ids).toContain("from-workspace");
+    expect(ids).toContain("unabyss");
+  });
+
+  test("plugin servers are labelled with their origin, workspace servers are not", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const servers = await listServers();
+    const plugin = servers.find((s) => s.id === "unabyss")!;
+    const workspace = servers.find((s) => s.id === "from-workspace")!;
+
+    expect(plugin.source).toEqual("plugin");
+    expect(plugin.pluginName).toEqual("unabyss");
+    expect(workspace.source).toEqual("workspace");
+    expect(workspace.pluginName).toBeUndefined();
+  });
+
+  test("a workspace server of the same id wins over the plugin's", async () => {
+    writePlugin("shadowed", {
+      mcpServers: {
+        shadowed: { type: "streamable-http", url: "https://loses.example/mcp" },
+      },
+    });
+
+    const matches = (await listServers()).filter((s) => s.id === "shadowed");
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].source).toEqual("workspace");
+    expect(matches[0].transport.url).toEqual("https://wins.example/mcp");
+  });
+
+  test("plugin servers are not health-checked, so no credential can reach them", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const servers = await listServers();
+
+    expect(servers.find((s) => s.id === "unabyss")!.status).toEqual("declared");
+    // The credential mocks above return a token and an Authorization header
+    // for every id. Constructing a client for the plugin server is what
+    // would ship them to the plugin-declared URL.
+    expect(connectedServerIds).toContain("from-workspace");
+    expect(connectedServerIds).not.toContain("unabyss");
+  });
+
+  test("plugin servers report no assistant-owned auth even when the store has some", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const plugin = (await listServers()).find((s) => s.id === "unabyss")!;
+    expect(plugin.hasOAuth).toBe(false);
+    expect(plugin.hasStaticAuth).toBe(false);
+    expect(plugin.authType).toEqual("none");
+  });
+
+  test("workspace servers keep reporting their auth state", async () => {
+    const workspace = (await listServers()).find(
+      (s) => s.id === "from-workspace",
+    )!;
+    expect(workspace.hasOAuth).toBe(true);
+    expect(workspace.hasStaticAuth).toBe(true);
+  });
+
+  test("plugin servers default to low risk", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const servers = await listServers();
+    expect(servers.find((s) => s.id === "unabyss")!.defaultRiskLevel).toEqual(
+      "low",
+    );
+  });
+
+  test("a directory with no valid package.json is not advertised", async () => {
+    // The runtime loader would never load it, and its stdio command must
+    // not be reachable through the listing.
+    const dir = join(getWorkspacePluginsDir(), "no-manifest");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "mcp.json"),
+      JSON.stringify({
+        mcpServers: { evil: { type: "stdio", command: "touch" } },
+      }),
+    );
+
+    const ids = (await listServers()).map((s) => s.id);
+    expect(ids).not.toContain("no-manifest__evil");
+    expect(ids).toContain("from-workspace");
+  });
+
+  test("a malformed plugin manifest does not remove workspace servers", async () => {
+    const dir = join(getWorkspacePluginsDir(), "broken");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({ name: "broken", version: "1.0.0" }),
+    );
+    writeFileSync(join(dir, "mcp.json"), "{ not json");
+
+    const ids = (await listServers()).map((s) => s.id);
+    expect(ids).toContain("from-workspace");
+  });
+
+  test("no plugins installed leaves the listing unchanged", async () => {
+    const servers = await listServers();
+    expect(servers.every((s) => s.source === "workspace")).toBe(true);
+  });
+});

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -73,6 +73,7 @@ import type { QdrantSparseVector } from "../persistence/embeddings/qdrant-client
 import type { ConversationGraphMemory } from "../plugins/defaults/memory/graph/conversation-graph-memory.js";
 import userPromptSubmitMemoryRetrieval from "../plugins/defaults/memory/hooks/user-prompt-submit.js";
 import type { Message } from "../providers/types.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 /** Canonical metrics payload the graph retriever attaches to a real hit. */
 function makeMetrics() {
@@ -172,15 +173,15 @@ function installConversation(
   graphMemory: ConversationGraphMemory,
   opts?: {
     trusted?: boolean;
-    signal?: AbortSignal;
+    abortController?: AbortController;
   },
 ): void {
   currentTrustClass = opts?.trusted === false ? "unknown" : "guardian";
-  currentConversation = {
+  currentConversation = asConversation({
     graphMemory,
     trustContext: undefined,
-    abortController: { signal: opts?.signal ?? new AbortController().signal },
-  } as unknown as Conversation;
+    abortController: opts?.abortController ?? new AbortController(),
+  });
 }
 
 beforeEach(() => {
@@ -492,7 +493,7 @@ describe("user-prompt-submit hook (memory retrieval)", () => {
     const controller = new AbortController();
     installConversation(graphMemory, {
       trusted: true,
-      signal: controller.signal,
+      abortController: controller,
     });
     const ctx = makeHookCtx();
 

package/src/__tests__/messages-read-boundary-guard.test.ts

@@ -0,0 +1,134 @@
+import { readFileSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { Glob } from "bun";
+
+/**
+ * Ratchet over direct reads of the `messages` table outside `persistence/`.
+ *
+ * Every row in `messages` is conversation content in some state of
+ * completeness, and each read encodes a visibility decision (completed
+ * history vs. any row). `persistence/` owns that contract: named accessors in
+ * `message-reads.ts` and the history readers in `conversation-crud.ts` state
+ * their decision in their name; everything else should go through them. A
+ * direct reader that re-decides visibility on its own is how the contract
+ * fails silently, so a new direct read is a reviewed exception, not a
+ * default.
+ *
+ * The BASELINE lists every file outside `persistence/` that reads the table
+ * directly today. Each entry has been audited and carries its visibility
+ * decision as a comment at the read site. The guard fails when a file outside
+ * the baseline gains a direct read (route it through an accessor, or audit it
+ * and baseline it with a site comment explaining the decision in your PR),
+ * and when a baseline entry goes stale (remove it, so coverage cannot rot).
+ *
+ * Detection is deliberately shape-based (from/join of `messages` in drizzle
+ * builders, `FROM messages` / `JOIN messages` in raw SQL): this is a ratchet
+ * against sprawl, not a proof, and matching the read shapes keeps it free of
+ * false positives from unrelated identifiers.
+ *
+ * Regenerate after an intentional change with:
+ *   UPDATE_MESSAGES_READ_BASELINE=1 bun test src/__tests__/messages-read-boundary-guard.test.ts
+ * and paste the printed list here, explaining the new read in your PR.
+ */
+
+const SRC_REL = "src";
+const SRC_ABS = join(process.cwd(), SRC_REL);
+
+/**
+ * Audited direct readers outside persistence/, as file -> count of matching
+ * read sites. Counts, not just filenames: a new read added inside an
+ * already-baselined file must fail the ratchet too, since each site carries
+ * its own visibility decision. A same-file refactor that replaces one read
+ * with another at equal count passes; that is accepted ratchet granularity
+ * (the diff still shows the site to its reviewer).
+ */
+const BASELINE: Readonly<Record<string, number>> = {
+  "src/apps/app-store.ts": 1,
+  "src/daemon/credential-transcript-scrub.ts": 1,
+  "src/live-voice/live-voice-archive.ts": 1,
+  "src/monitoring/recovery/inflight-content.ts": 2,
+  "src/plugins/defaults/memory/context-search/sources/conversations.ts": 1,
+  "src/plugins/defaults/memory/graph/image-ref-utils.ts": 1,
+  "src/plugins/defaults/memory/indexer.ts": 2,
+  "src/plugins/defaults/memory/memory-retrospective-accounting.ts": 4,
+  "src/plugins/defaults/memory/substrate/sweep-job.ts": 1,
+  "src/plugins/defaults/memory/v1/graph/extraction.ts": 3,
+  "src/plugins/defaults/memory/v1/job-handlers/backfill.ts": 1,
+  "src/plugins/defaults/memory/v1/job-handlers/embedding.ts": 1,
+  "src/plugins/defaults/memory/v1/job-handlers/index-maintenance.ts": 1,
+  "src/plugins/defaults/memory/v2/harness/oracle.ts": 1,
+  "src/plugins/defaults/memory/v2/harness/replay-input.ts": 1,
+  "src/plugins/defaults/memory/v3-eval/eval-packets.ts": 2,
+  "src/plugins/defaults/memory/v3/prune.ts": 1,
+  "src/plugins/defaults/memory/v3/selection-log-store.ts": 1,
+  "src/runtime/pre-first-message-gate.ts": 1,
+  "src/runtime/routes/log-export-routes.ts": 1,
+  "src/runtime/routes/surface-conversation-resolver.ts": 2,
+  "src/telemetry/turn-events-store.ts": 2,
+  "src/telemetry/turn-trace-store.ts": 2,
+  "src/workspace/migrations/rebuild-conversation-disk-view.ts": 1,
+};
+
+const DRIZZLE_READ =
+  /\.(?:from|innerJoin|leftJoin|rightJoin|fullJoin)\(\s*messages\s*[,)]/g;
+const RAW_SQL_READ = /(?:FROM|JOIN)\s+messages\b/g;
+
+function isExempt(relPath: string): boolean {
+  const parts = relPath.split(sep);
+  return (
+    parts[1] === "persistence" ||
+    parts.includes("__tests__") ||
+    relPath.endsWith(".test.ts")
+  );
+}
+
+async function scanDirectReaders(): Promise<Map<string, number>> {
+  const glob = new Glob("**/*.ts");
+  const found = new Map<string, number>();
+  for await (const file of glob.scan({ cwd: SRC_ABS, absolute: true })) {
+    const relPath = join(SRC_REL, relative(SRC_ABS, file));
+    if (isExempt(relPath)) {
+      continue;
+    }
+    const source = readFileSync(file, "utf-8");
+    const count =
+      [...source.matchAll(DRIZZLE_READ)].length +
+      [...source.matchAll(RAW_SQL_READ)].length;
+    if (count > 0) {
+      found.set(relPath, count);
+    }
+  }
+  return found;
+}
+
+describe("messages read boundary", () => {
+  test("no new direct messages reads beyond the audited baseline", async () => {
+    const found = await scanDirectReaders();
+
+    if (process.env.UPDATE_MESSAGES_READ_BASELINE === "1") {
+      console.log(
+        JSON.stringify(Object.fromEntries([...found].sort()), null, 2),
+      );
+    }
+
+    const grown = [...found]
+      .filter(([file, count]) => count > (BASELINE[file] ?? 0))
+      .map(([file, count]) => `${file}: ${BASELINE[file] ?? 0} -> ${count}`);
+    expect(
+      grown,
+      `New direct reads of the messages table outside persistence/ (route ` +
+        `through an accessor in persistence/message-reads.ts, or audit the ` +
+        `read, state its visibility decision at the site, and baseline it):`,
+    ).toEqual([]);
+
+    const shrunk = Object.entries(BASELINE)
+      .filter(([file, count]) => (found.get(file) ?? 0) < count)
+      .map(([file, count]) => `${file}: ${count} -> ${found.get(file) ?? 0}`);
+    expect(
+      shrunk,
+      "Stale baseline entries (fewer direct reads than baselined; ratchet the count down so coverage cannot rot):",
+    ).toEqual([]);
+  });
+});

package/src/__tests__/mtime-cache.test.ts

@@ -30,10 +30,10 @@ import {
 } from "bun:test";
 
 import { _inspectHookCacheForTests } from "../hooks/hook-loader.js";
+import { getUserHooksFor } from "../hooks/registry.js";
 import {
   _inspectToolCacheForTests,
   getCachedUserTools,
-  getUserHooksFor,
   populateCacheAtBoot,
   reconcilePluginSourcesNow,
   resetPluginCacheForTests,