@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/__tests__/plugin-bootstrap.test.ts

@@ -42,11 +42,7 @@ import {
   registerPlugin,
   resetPluginRegistryForTests,
 } from "../plugins/registry.js";
-import {
-  type Plugin,
-  PluginExecutionError,
-  type PluginInitContext,
-} from "../plugins/types.js";
+import { type Plugin, type PluginInitContext } from "../plugins/types.js";
 import { APP_VERSION } from "../version.js";
 import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
@@ -174,9 +170,9 @@ describe("plugin bootstrap", () => {
     expect(received?.credentials).toEqual({ "some-key": "super-secret-value" });
   });
 
-  test("credential resolution: missing credential fails bootstrap with the plugin named", async () => {
+  test("credential resolution: a plugin whose required credential is missing is skipped, not fatal", async () => {
+    // GIVEN a plugin that requires a credential the store cannot resolve
     getSecureKeyAsyncMock.mockImplementation(async () => undefined);
-
     registerPlugin(
       buildPlugin(
         "missing-cred",
@@ -185,16 +181,14 @@ describe("plugin bootstrap", () => {
       ),
     );
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-    const msg = (caught as PluginExecutionError).message;
-    expect(msg).toContain("missing-cred");
-    expect(msg).toContain("absent-key");
+    // WHEN bootstrap runs
+    // THEN it completes without throwing — the unresolvable credential is
+    // contained to that plugin (same per-plugin isolation as an init throw)
+    await bootstrapPlugins();
+
+    // AND the plugin is dropped from the registry
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("missing-cred");
   });
 
   test("version mismatch: external plugin loader rejects when peerDependency unsatisfied", async () => {
@@ -208,7 +202,8 @@ describe("plugin bootstrap", () => {
     expect(() => registerPlugin(plugin)).not.toThrow();
   });
 
-  test("plugin init throw: bootstrap throws a PluginExecutionError naming the plugin", async () => {
+  test("plugin init throw: bootstrap contains the failure and does not throw", async () => {
+    // GIVEN a plugin whose init throws
     registerPlugin(
       buildPlugin("broken", {
         async init() {
@@ -217,65 +212,91 @@ describe("plugin bootstrap", () => {
       }),
     );
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-    const msg = (caught as PluginExecutionError).message;
-    expect(msg).toContain("broken");
-    expect(msg).toContain("kaboom");
+    // WHEN bootstrap runs
+    // THEN it completes without throwing — a single plugin's init failure is
+    // contained to that plugin rather than aborting the whole plugin layer
+    await bootstrapPlugins();
+
+    // AND the failing plugin is dropped from the registry so its hooks never
+    // participate in the turn lifecycle
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("broken");
   });
 
-  test("partial-init failure: earlier plugins' onShutdown runs in reverse before the error propagates", async () => {
-    // If plugin N throws during init, every plugin 1..N-1 that already made
-    // it through its full init+contribution phase must have onShutdown()
-    // invoked in reverse registration order before bootstrap re-throws.
-    // Without this, earlier plugins leak live tools/routes/skills because
-    // the shutdown hook is only registered once the entire loop completes.
-    const callOrder: string[] = [];
+  test("mid-list init failure: surrounding plugins still initialize and survive", async () => {
+    // GIVEN two healthy plugins surrounding one whose init throws, registered
+    // in order
+    const initialized: string[] = [];
+    const shutDownDuringBootstrap: string[] = [];
     registerPlugin(
-      buildPlugin("survivor-a", {
-        async init() {},
+      buildPlugin("before", {
+        async init() {
+          initialized.push("before");
+        },
         async onShutdown() {
-          callOrder.push("survivor-a");
+          shutDownDuringBootstrap.push("before");
         },
       }),
     );
     registerPlugin(
-      buildPlugin("survivor-b", {
-        async init() {},
-        async onShutdown() {
-          callOrder.push("survivor-b");
+      buildPlugin("failing", {
+        async init() {
+          throw new Error("mid-bootstrap failure");
         },
       }),
     );
     registerPlugin(
-      buildPlugin("failing", {
+      buildPlugin("after", {
         async init() {
-          throw new Error("mid-bootstrap failure");
+          initialized.push("after");
         },
         async onShutdown() {
-          // Never called — this plugin never completes init, so it was never
-          // added to the active list that teardown walks.
-          callOrder.push("failing");
+          shutDownDuringBootstrap.push("after");
         },
       }),
     );
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-
-    // Reverse order: survivor-b registered after survivor-a, so it tears
-    // down first; "failing" never entered the active list.
-    expect(callOrder).toEqual(["survivor-b", "survivor-a"]);
+    // WHEN bootstrap runs
+    await bootstrapPlugins();
+
+    // THEN both healthy plugins initialized — the one registered after the
+    // failure is not skipped
+    expect(initialized).toEqual(["before", "after"]);
+    // AND neither healthy plugin was torn down by the failure (their
+    // onShutdown only runs at real shutdown, not during bootstrap)
+    expect(shutDownDuringBootstrap).toEqual([]);
+    // AND the failing plugin is dropped while both survivors remain registered
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).toContain("before");
+    expect(names).toContain("after");
+    expect(names).not.toContain("failing");
+  });
+
+  test("user-plugin init failure leaves the first-party defaults registered", async () => {
+    // GIVEN the first-party defaults are registered ahead of user plugins, as
+    // at daemon startup
+    registerDefaultPlugins();
+    // AND a user plugin registered after them whose init throws
+    registerPlugin(
+      buildPlugin("breaking-user-plugin", {
+        async init() {
+          throw new Error("user plugin boom");
+        },
+      }),
+    );
+
+    // WHEN bootstrap runs
+    await bootstrapPlugins();
+
+    // THEN the failing user plugin is dropped from the registry
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("breaking-user-plugin");
+    // AND every first-party default survived, so core turn behavior (memory
+    // retrieval, history repair, title generation) keeps running in degraded
+    // mode instead of being torn down with the failing plugin
+    expect(names).toContain("default-memory-retrieval");
+    expect(names).toContain("default-history-repair");
+    expect(names).toContain("default-title-generate");
   });
 
   test("shutdown order: onShutdown fires in reverse registration order", async () => {
@@ -378,11 +399,11 @@ describe("plugin bootstrap", () => {
     expect(initFired).toBe(true);
   });
 
-  test("requiresFlag disabled: init does not fire and no tools/routes/skills are registered", async () => {
+  test("requiresFlag disabled: init does not fire and no tools/routes are registered", async () => {
     setOverridesForTesting({ "plugin-gated-disabled": false });
 
     let initFired = false;
-    // Attach tool/route/skill contributions alongside init. If gating works,
+    // Attach tool/route contributions alongside init. If gating works,
     // none of them should land in their respective registries.
     const plugin = buildPlugin(
       "gated-off",
@@ -409,24 +430,14 @@ describe("plugin bootstrap", () => {
             handler: async () => new Response("ok"),
           },
         ],
-        skills: [
-          {
-            id: "gated-off/skill",
-            name: "gated-off-skill",
-            description: "should not be catalogued",
-            body: "# unused",
-          },
-        ],
       },
       { requiresFlag: ["plugin-gated-disabled"] },
     );
     registerPlugin(plugin);
 
-    // Grab tool / route / skill introspection helpers lazily so the import
+    // Grab tool / route introspection helpers lazily so the import
     // side effect happens after `mock.module` has taken effect.
     const { getTool } = await import("../tools/registry.js");
-    const { getPluginSkillRefCount } =
-      await import("../plugins/plugin-skill-contributions.js");
     const { matchSkillRoute } =
       await import("../runtime/skill-route-registry.js");
 
@@ -438,8 +449,6 @@ describe("plugin bootstrap", () => {
     expect(getTool("gated-off-tool")).toBeUndefined();
     // No route wired up — `matchSkillRoute` returns null when nothing matches.
     expect(matchSkillRoute("/_plugin/gated-off/status", "GET")).toBeNull();
-    // No skill catalogued under this plugin's name — ref count stays 0.
-    expect(getPluginSkillRefCount("gated-off")).toBe(0);
   });
 
   test("requiresFlag absent: plugin activates unconditionally", async () => {

package/src/__tests__/plugin-tool-contribution.test.ts

@@ -218,9 +218,7 @@ describe("plugin tool contributions", () => {
   });
 
   test("tools are only registered after init() succeeds", async () => {
-    // A plugin whose init throws must not contribute tools — the bootstrap
-    // aborts with a PluginExecutionError, and nothing from this plugin
-    // should leak into the tool registry.
+    // GIVEN a plugin that declares a tool but throws during init()
     const plugin = buildPlugin("delta-broken", {
       async init() {
         throw new Error("boom");
@@ -229,7 +227,12 @@ describe("plugin tool contributions", () => {
     });
     registerPlugin(plugin);
 
-    await expect(bootstrapPlugins()).rejects.toThrow(/delta-broken/);
+    // WHEN bootstrap runs
+    // THEN it does not throw — the init failure is contained to this plugin
+    await bootstrapPlugins();
+
+    // AND the failing plugin's tool is rolled back, never leaking into the
+    // registry
     expect(getTool("delta-tool")).toBeUndefined();
   });
 });

package/src/__tests__/plugin-types.test.ts

@@ -78,14 +78,6 @@ describe("plugin core types", () => {
           handler: async () => new Response("ok", { status: 200 }),
         },
       ],
-      skills: [
-        {
-          id: "sample-skill",
-          name: "Sample Skill",
-          description: "Demo plugin-contributed skill",
-          body: "## Sample\n\nPlugin-provided skill body.",
-        },
-      ],
     } satisfies Plugin;
 
     // Minimal runtime check so the test body is non-empty.

package/src/__tests__/provider-catalog-visibility.test.ts

@@ -19,19 +19,11 @@ function makeConfig(): AssistantConfig {
 }
 
 describe("getVisibleProviderCatalog", () => {
-  test("hides openai-compatible endpoints by default", () => {
+  test("shows openai-compatible endpoints unconditionally (GA'ed)", () => {
     setOverridesForTesting({});
 
     const visible = getVisibleProviderCatalog(makeConfig());
 
-    expect(visible.find((p) => p.id === "openai-compatible")).toBeUndefined();
-  });
-
-  test("shows openai-compatible endpoints when its flag is enabled", () => {
-    setOverridesForTesting({ "openai-compatible-endpoints": true });
-
-    const visible = getVisibleProviderCatalog(makeConfig());
-
     expect(visible.find((p) => p.id === "openai-compatible")).toBeDefined();
   });
 

package/src/__tests__/prune-old-conversations-job.test.ts

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Silence the logger.
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import type { AssistantConfig } from "../config/schema.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { pruneOldConversationsJob } from "../memory/job-handlers/cleanup.js";
+import type { MemoryJob } from "../memory/jobs-store.js";
+import {
+  conversations,
+  skillLoadedEvents,
+  toolInvocations,
+} from "../memory/schema.js";
+
+initializeDb();
+
+const STALE_ID = "conv-prune-job-stale";
+const FRESH_ID = "conv-prune-job-fresh";
+
+const JOB = { payload: {} } as unknown as MemoryJob;
+const CONFIG = {
+  memory: { cleanup: { conversationRetentionDays: 30 } },
+} as unknown as AssistantConfig;
+
+function seedConversation(id: string, updatedAt: number): void {
+  const db = getDb();
+  db.insert(conversations)
+    .values({ id, title: "test", createdAt: updatedAt, updatedAt })
+    .run();
+  db.insert(toolInvocations)
+    .values({
+      id: `ti-${id}`,
+      conversationId: id,
+      toolName: "calendar_list_events",
+      input: "{}",
+      result: "{}",
+      decision: "allow",
+      riskLevel: "low",
+      durationMs: 12,
+      createdAt: updatedAt,
+    })
+    .run();
+  db.insert(skillLoadedEvents)
+    .values({
+      id: `sl-${id}`,
+      createdAt: updatedAt,
+      conversationId: id,
+      skillName: "test-skill",
+    })
+    .run();
+}
+
+function countRows(conversationId: string): {
+  invocations: number;
+  skillLoads: number;
+} {
+  const db = getDb();
+  return {
+    invocations: db
+      .select()
+      .from(toolInvocations)
+      .all()
+      .filter((r) => r.conversationId === conversationId).length,
+    skillLoads: db
+      .select()
+      .from(skillLoadedEvents)
+      .all()
+      .filter((r) => r.conversationId === conversationId).length,
+  };
+}
+
+describe("pruneOldConversationsJob", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.delete(skillLoadedEvents).run();
+    db.delete(toolInvocations).run();
+    db.delete(conversations).run();
+  });
+
+  test("deletes non-cascading rows — including skill_loaded_events — for pruned conversations only", () => {
+    const staleUpdatedAt = Date.now() - 60 * 86_400_000;
+    seedConversation(STALE_ID, staleUpdatedAt);
+    seedConversation(FRESH_ID, Date.now());
+
+    pruneOldConversationsJob(JOB, CONFIG);
+
+    expect(countRows(STALE_ID)).toEqual({ invocations: 0, skillLoads: 0 });
+    expect(countRows(FRESH_ID)).toEqual({ invocations: 1, skillLoads: 1 });
+    const remaining = getDb().select().from(conversations).all();
+    expect(remaining.map((c) => c.id)).toEqual([FRESH_ID]);
+  });
+});

package/src/__tests__/registry.test.ts

@@ -6,17 +6,26 @@ import {
   __resetRegistryForTesting,
   getAllToolDefinitions,
   getAllTools,
+  getCoreToolOverride,
   getSkillRefCount,
   getSkillToolNames,
   getTool,
   getToolOwner,
+  getWorkspaceToolNames,
   initializeTools,
+  registerPluginTools,
   registerSkillTools,
   registerTool,
+  registerWorkspaceTools,
   unregisterSkillTools,
+  unregisterWorkspaceTool,
 } from "../tools/registry.js";
 import { eagerModuleToolNames, explicitTools } from "../tools/tool-manifest.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
+import type {
+  Tool,
+  ToolContext,
+  ToolExecutionResult,
+} from "../tools/types.js";
 
 // Clean up global registry after this file completes to prevent
 // contamination of subsequent test files in combined runs.
@@ -414,3 +423,233 @@ describe("skill tool reference counting", () => {
     expect(getSkillRefCount("nonexistent-skill")).toBe(0);
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────
+// Workspace tool overrides
+//
+// Tests the registry surface exposed by registerWorkspaceTools /
+// unregisterWorkspaceTool / getCoreToolOverride / getWorkspaceToolNames.
+// The loader (workspace-tools/loader.ts) is tested separately — these
+// tests treat the registry contract as the source of truth and exercise
+// it directly with synthetic tool objects.
+// ─────────────────────────────────────────────────────────────────────
+
+function makeWorkspaceInput(
+  name: string,
+  workspacePath = `/workspace/tools/${name}.ts`,
+): { tool: Tool; workspacePath: string } {
+  return {
+    workspacePath,
+    tool: {
+      name,
+      category: "workspace",
+      description: `Workspace ${name}`,
+      defaultRiskLevel: RiskLevel.Low,
+      executionTarget: "sandbox",
+      input_schema: { type: "object", properties: {}, required: [] },
+      async execute(
+        _input: Record<string, unknown>,
+        _context: ToolContext,
+      ): Promise<ToolExecutionResult> {
+        return { content: `workspace ${name}`, isError: false };
+      },
+    },
+  };
+}
+
+function makeLoadedPluginTool(name: string): Tool {
+  return {
+    name,
+    category: "plugin",
+    description: `Plugin ${name}`,
+    defaultRiskLevel: RiskLevel.Low,
+    executionTarget: "sandbox",
+    input_schema: { type: "object", properties: {}, required: [] },
+    async execute(
+      _input: Record<string, unknown>,
+      _context: ToolContext,
+    ): Promise<ToolExecutionResult> {
+      return { content: `plugin ${name}`, isError: false };
+    },
+  };
+}
+
+describe("workspace tool registry", () => {
+  beforeEach(() => {
+    __resetRegistryForTesting();
+  });
+
+  test("net-new workspace tool registers without stashing anything", () => {
+    __clearRegistryForTesting();
+
+    const accepted = registerWorkspaceTools([makeWorkspaceInput("new_tool")]);
+
+    expect(accepted).toHaveLength(1);
+    const tool = getTool("new_tool");
+    expect(tool).toBeDefined();
+    expect(getToolOwner("new_tool")).toEqual({
+      kind: "workspace",
+      id: "/workspace/tools/new_tool.ts",
+    });
+    expect(getCoreToolOverride("new_tool")).toBeUndefined();
+    expect(getWorkspaceToolNames()).toEqual(["new_tool"]);
+  });
+
+  test("workspace tool with same name as core stashes the original", () => {
+    __clearRegistryForTesting();
+    const coreTool = makeFakeTool("override_target");
+    registerTool(coreTool);
+    expect(getTool("override_target")).toEqual(coreTool);
+
+    registerWorkspaceTools([makeWorkspaceInput("override_target")]);
+
+    // Live registry now points at the workspace tool.
+    const live = getTool("override_target");
+    expect(live).toBeDefined();
+    expect(getToolOwner("override_target")?.kind).toBe("workspace");
+    expect(getToolOwner("override_target")?.kind).toBe("workspace");
+
+    // Stash preserves the original for later restoration.
+    expect(getCoreToolOverride("override_target")).toEqual(coreTool);
+  });
+
+  test("unregister restores the stashed core tool when one exists", () => {
+    __clearRegistryForTesting();
+    const coreTool = makeFakeTool("restore_me");
+    registerTool(coreTool);
+    registerWorkspaceTools([makeWorkspaceInput("restore_me")]);
+    expect(getToolOwner("restore_me")?.kind).toBe("workspace");
+
+    unregisterWorkspaceTool("restore_me");
+
+    expect(getTool("restore_me")).toEqual(coreTool);
+    expect(getCoreToolOverride("restore_me")).toBeUndefined();
+    expect(getWorkspaceToolNames()).toEqual([]);
+  });
+
+  test("unregister deletes the tool when no core counterpart was stashed", () => {
+    __clearRegistryForTesting();
+    registerWorkspaceTools([makeWorkspaceInput("only_workspace")]);
+    expect(getTool("only_workspace")).toBeDefined();
+
+    unregisterWorkspaceTool("only_workspace");
+
+    expect(getTool("only_workspace")).toBeUndefined();
+    expect(getCoreToolOverride("only_workspace")).toBeUndefined();
+  });
+
+  test("unregister is a no-op on a non-workspace name", () => {
+    __clearRegistryForTesting();
+    const coreTool = makeFakeTool("not_workspace");
+    registerTool(coreTool);
+
+    unregisterWorkspaceTool("not_workspace");
+    unregisterWorkspaceTool("never_existed");
+
+    expect(getTool("not_workspace")).toEqual(coreTool);
+  });
+
+  test("re-registering an existing workspace tool throws (single canonical source)", () => {
+    __clearRegistryForTesting();
+    registerWorkspaceTools([
+      makeWorkspaceInput("dupe", "/workspace/tools/dupe"),
+    ]);
+
+    expect(() =>
+      registerWorkspaceTools([
+        makeWorkspaceInput("dupe", "/workspace/tools/dupe"),
+      ]),
+    ).toThrow(/already registered/);
+  });
+
+  test("duplicate names within a single batch throw (no partial application)", () => {
+    __clearRegistryForTesting();
+
+    expect(() =>
+      registerWorkspaceTools([
+        makeWorkspaceInput("twin"),
+        makeWorkspaceInput("twin", "/workspace/tools/twin-alt"),
+      ]),
+    ).toThrow(/duplicate name/);
+
+    // Mutation phase never ran — registry stays empty for this name.
+    expect(getTool("twin")).toBeUndefined();
+    expect(getWorkspaceToolNames()).toEqual([]);
+  });
+
+  test("batch rejection leaves earlier-batch tools un-mutated", () => {
+    __clearRegistryForTesting();
+
+    // Pre-occupy "guarded" as a skill tool — workspace tools cannot
+    // override skill tools (only core), so the batch must throw and
+    // leave the otherwise-fine "ok_a" / "ok_b" entries unregistered.
+    registerSkillTools("skill-a", [makeSkillTool("guarded")]);
+
+    expect(() =>
+      registerWorkspaceTools([
+        makeWorkspaceInput("ok_a"),
+        makeWorkspaceInput("guarded"),
+        makeWorkspaceInput("ok_b"),
+      ]),
+    ).toThrow(/conflicts with an existing/);
+
+    expect(getTool("ok_a")).toBeUndefined();
+    expect(getTool("ok_b")).toBeUndefined();
+    // The skill tool is still in the registry, untouched.
+    expect(getToolOwner("guarded")?.kind).toBe("skill");
+  });
+
+  test("workspace tool blocks subsequent plugin registration with same name", () => {
+    __clearRegistryForTesting();
+    registerWorkspaceTools([makeWorkspaceInput("contested")]);
+
+    // Plugin attempts to register over a workspace-owned name. The
+    // registry's plugin-registration path warn-skips rather than
+    // throwing, mirroring the core-conflict behavior.
+    const accepted = registerPluginTools("some-plugin", [
+      makeLoadedPluginTool("contested"),
+    ]);
+
+    expect(accepted).toEqual([]);
+    expect(getToolOwner("contested")?.kind).toBe("workspace");
+  });
+
+  test("workspace tool blocks subsequent skill registration with same name", () => {
+    __clearRegistryForTesting();
+    registerWorkspaceTools([makeWorkspaceInput("skill_attempt")]);
+
+    const accepted = registerSkillTools("some-skill", [
+      makeSkillTool("skill_attempt"),
+    ]);
+
+    expect(accepted).toEqual([]);
+    expect(getToolOwner("skill_attempt")?.kind).toBe("workspace");
+    expect(getSkillToolNames()).toEqual([]);
+  });
+
+  test("__resetRegistryForTesting clears the override stash", () => {
+    __clearRegistryForTesting();
+    const coreTool = makeFakeTool("baseline_tool");
+    registerTool(coreTool);
+    registerWorkspaceTools([makeWorkspaceInput("baseline_tool")]);
+    expect(getCoreToolOverride("baseline_tool")).toEqual(coreTool);
+
+    __resetRegistryForTesting();
+
+    expect(getCoreToolOverride("baseline_tool")).toBeUndefined();
+  });
+
+  test("workspace tool overrides surface as the live tool in getAllToolDefinitions", () => {
+    __clearRegistryForTesting();
+    const coreTool = makeFakeTool("listed_tool");
+    registerTool(coreTool);
+    registerWorkspaceTools([makeWorkspaceInput("listed_tool")]);
+
+    const definitions = getAllToolDefinitions();
+    const ours = definitions.find((d) => d.name === "listed_tool");
+    expect(ours).toBeDefined();
+    // The live workspace tool defines its own description; ensure the
+    // definition does not leak the core tool's description.
+    expect(ours?.description).toBe("Workspace listed_tool");
+  });
+});

package/src/__tests__/require-fresh-approval.test.ts

@@ -125,6 +125,9 @@ mock.module("../tools/registry.js", () => ({
 
 mock.module("../permissions/gateway-threshold-reader.js", () => ({
   getAutoApproveThreshold: async () => "medium",
+  // Refresh failure ("null") keeps the original decision — these tests
+  // exercise the cached-threshold paths only.
+  refreshAutoApproveThreshold: async () => null,
   _clearGlobalCacheForTesting: () => {},
 }));