@vellumai/assistant 0.7.1 → 0.7.2

package/src/__tests__/identity-intro-cache.test.ts

@@ -60,6 +60,7 @@ mock.module("../prompts/persona-resolver.js", () => ({
 import {
   computeIdentityContentHash,
   getCachedIntro,
+  readWorkspaceIdentityIntro,
   setCachedIntro,
 } from "../runtime/routes/identity-intro-cache.js";
 
@@ -80,6 +81,34 @@ afterEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("identity intro cache", () => {
+  test("reads explicit intro from IDENTITY.md before SOUL.md", () => {
+    workspaceFiles["IDENTITY.md"] = [
+      "# Identity",
+      "",
+      "## Identity Intro",
+      "Nova here.",
+    ].join("\n");
+    workspaceFiles["SOUL.md"] = [
+      "# Soul",
+      "",
+      "## Identity Intro",
+      "Soul fallback.",
+    ].join("\n");
+
+    expect(readWorkspaceIdentityIntro()).toBe("Nova here.");
+  });
+
+  test("falls back to SOUL.md identity intro for legacy workspaces", () => {
+    workspaceFiles["SOUL.md"] = [
+      "# Soul",
+      "",
+      "## Identity Intro",
+      "Soul fallback.",
+    ].join("\n");
+
+    expect(readWorkspaceIdentityIntro()).toBe("Soul fallback.");
+  });
+
   test("returns null when cache is empty", () => {
     expect(getCachedIntro()).toBeNull();
   });

package/src/__tests__/identity-routes.test.ts

@@ -22,8 +22,16 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { handleDetailedHealth } from "../runtime/routes/identity-routes.js";
+import {
+  handleDetailedHealth,
+  ROUTES,
+} from "../runtime/routes/identity-routes.js";
 import { getWorkspaceDir } from "../util/platform.js";
+import {
+  getHatchedSidecarPath,
+  resolveHatchedAtReadOnly,
+  selectHatchedAtFromStats,
+} from "../workspace/hatched-date.js";
 
 // ── Env helpers ─────────────────────────────────────────────────────────
 
@@ -118,6 +126,9 @@ beforeEach(() => {
   if (existsSync(profilerRunsDir)) {
     rmSync(profilerRunsDir, { recursive: true, force: true });
   }
+
+  rmSync(getHatchedSidecarPath(), { force: true });
+  rmSync(join(getWorkspaceDir(), "IDENTITY.md"), { force: true });
 });
 
 afterEach(() => {
@@ -326,3 +337,94 @@ describe("identity routes — health endpoint", () => {
     });
   });
 });
+
+describe("identity routes — createdAt selection", () => {
+  test("falls back to mtime when birthtime is the Unix epoch", () => {
+    const mtime = new Date("2026-05-01T14:49:47.519Z");
+
+    expect(
+      selectHatchedAtFromStats({
+        birthtime: new Date(0),
+        mtime,
+      })?.toISOString(),
+    ).toBe(mtime.toISOString());
+  });
+
+  test("prefers birthtime when it is valid", () => {
+    const birthtime = new Date("2026-04-30T12:00:00.000Z");
+    const mtime = new Date("2026-05-01T14:49:47.519Z");
+
+    expect(
+      selectHatchedAtFromStats({
+        birthtime,
+        mtime,
+      })?.toISOString(),
+    ).toBe(birthtime.toISOString());
+  });
+
+  test("returns undefined when both birthtime and mtime are the Unix epoch", () => {
+    expect(
+      selectHatchedAtFromStats({
+        birthtime: new Date(0),
+        mtime: new Date(0),
+      }),
+    ).toBeUndefined();
+  });
+
+  test("read-only resolver falls back to current time without writing sidecar", () => {
+    const now = new Date("2026-05-04T12:00:00.000Z");
+
+    expect(
+      resolveHatchedAtReadOnly(
+        join(getWorkspaceDir(), "missing-identity.md"),
+        now,
+      ),
+    ).toBe(now.toISOString());
+    expect(existsSync(getHatchedSidecarPath())).toBe(false);
+  });
+
+  test("/identity uses persisted hatched sidecar instead of live file metadata", () => {
+    const workspaceDir = getWorkspaceDir();
+    const dataDir = join(workspaceDir, "data");
+    const identityPath = join(workspaceDir, "IDENTITY.md");
+    const persistedHatchedAt = "2026-05-01T14:49:47.519Z";
+
+    mkdirSync(dataDir, { recursive: true });
+    writeFileSync(
+      identityPath,
+      "# Identity\n\n- **Name:** Example Assistant\n",
+      "utf-8",
+    );
+    writeFileSync(
+      getHatchedSidecarPath(),
+      JSON.stringify({ hatchedAt: persistedHatchedAt }),
+      "utf-8",
+    );
+
+    const route = ROUTES.find(
+      (candidate) => candidate.operationId === "identity",
+    );
+    expect(route).toBeDefined();
+
+    const body = route!.handler({}) as { createdAt?: string };
+    expect(body.createdAt).toBe(persistedHatchedAt);
+  });
+
+  test("/identity does not write hatched sidecar on read", () => {
+    const identityPath = join(getWorkspaceDir(), "IDENTITY.md");
+    writeFileSync(
+      identityPath,
+      "# Identity\n\n- **Name:** Example Assistant\n",
+      "utf-8",
+    );
+
+    const route = ROUTES.find(
+      (candidate) => candidate.operationId === "identity",
+    );
+    expect(route).toBeDefined();
+
+    const body = route!.handler({}) as { createdAt?: string };
+    expect(Date.parse(body.createdAt ?? "")).toBeGreaterThan(0);
+    expect(existsSync(getHatchedSidecarPath())).toBe(false);
+  });
+});

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -41,8 +41,11 @@ describe("initFeatureFlagOverrides", () => {
   it("falls back gracefully when gateway socket is unavailable", async () => {
     mockGatewayIpc(null, { error: true });
 
-    // Should not throw
-    await initFeatureFlagOverrides();
+    // Disable retries — production retries the IPC fetch on failure to
+    // dodge the daemon-vs-gateway startup race, but here we're explicitly
+    // testing the no-gateway fallback and don't want the test to wait
+    // through the backoff schedule.
+    await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
     // Without gateway data or file, undeclared flags default to true
     const config = {} as any;
@@ -64,7 +67,10 @@ describe("initFeatureFlagOverrides", () => {
   it("does not cache empty gateway response", async () => {
     mockGatewayIpc({});
 
-    await initFeatureFlagOverrides();
+    // Disable retries — this test explicitly simulates a sustained empty
+    // response (gateway up but reporting zero flags) and should not wait
+    // through the production backoff schedule.
+    await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
     // Undeclared flags without overrides default to true (not false from
     // a cached empty map)
@@ -72,6 +78,23 @@ describe("initFeatureFlagOverrides", () => {
     expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
   });
 
+  it("retries empty gateway responses and picks up flags once they become available", async () => {
+    // Simulate the daemon-vs-gateway startup race: the first IPC call
+    // returns empty (gateway not yet ready), but a later attempt sees
+    // the populated flag map. The retry loop in init should bridge this
+    // gap without losing the flag.
+    mockGatewayIpc({});
+    setTimeout(() => {
+      resetMockGatewayIpc();
+      mockGatewayIpc({ "retry-test-flag": true });
+    }, 50);
+
+    await initFeatureFlagOverrides({ retryBackoffsMs: [200] });
+
+    const config = {} as any;
+    expect(isAssistantFeatureFlagEnabled("retry-test-flag", config)).toBe(true);
+  });
+
   it("does not re-fetch when cache is already populated", async () => {
     mockGatewayIpc({ "first-call": true });
 

package/src/__tests__/inline-command-runner.test.ts

@@ -27,7 +27,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,

package/src/__tests__/inline-skill-load-permissions.test.ts

@@ -1,8 +1,7 @@
 /**
  * Tests for inline-command skill load permission handling.
  *
- * When a skill contains inline command expansions (!\`...\`) and the
- * inline-skill-commands flag is on, the permission
+ * When a skill contains inline command expansions (!\`...\`), the permission
  * system must:
  *
  * 1. Emit skill_load_dynamic:<id>@<hash> / skill_load_dynamic:<id> candidates
@@ -17,8 +16,6 @@ import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-
 // ── Mock setup (must be before any imports from the project) ──────────────
 
 const testDir = process.env.VELLUM_WORKSPACE_DIR!;
@@ -48,7 +45,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => testConfig,
   loadConfig: () => testConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
@@ -67,12 +63,13 @@ mockIpcResponse("classify_risk", {
 });
 mockIpcResponse("get_global_thresholds", {
   interactive: "low",
-  background: "medium",
+  autonomous: "medium",
   headless: "none",
 });
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import { check, generateAllowlistOptions } from "../permissions/checker.js";
 import { clearRiskCache } from "../permissions/checker.js";
 import { _clearGlobalCacheForTesting } from "../permissions/gateway-threshold-reader.js";
@@ -120,13 +117,10 @@ describe("inline-command skill_load permissions", () => {
     _clearGlobalCacheForTesting();
     mockIpcResponse("get_global_thresholds", {
       interactive: "low",
-      background: "medium",
+      autonomous: "medium",
       headless: "none",
     });
     testConfig.skills = { load: { extraDirs: [] } };
-    _setOverridesForTesting({
-      "inline-skill-commands": true,
-    });
     try {
       rmSync(join(testDir, "protected", "trust.json"));
     } catch {
@@ -159,7 +153,7 @@ describe("inline-command skill_load permissions", () => {
       writeDynamicSkill("dynamic-strict", "Dynamic Strict Skill");
       mockIpcResponse("get_global_thresholds", {
         interactive: "none",
-        background: "none",
+        autonomous: "none",
         headless: "none",
       });
       _clearGlobalCacheForTesting();

package/src/__tests__/integration-status.test.ts

@@ -5,8 +5,9 @@ import { credentialKey } from "../security/credential-key.js";
 const secureKeyValues = new Map<string, string>();
 let mockTwilioAccountSid: string | undefined;
 
-/** Set of providers that should report as connected via isProviderConnected(). */
 const connectedProviders = new Set<string>();
+const managedProviders = new Set<string>();
+const platformConnectedProviders = new Set<string>();
 
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (account: string) => secureKeyValues.get(account),
@@ -18,21 +19,60 @@ mock.module("../config/loader.js", () => ({
       ? { accountSid: mockTwilioAccountSid }
       : undefined,
   }),
+  getConfig: () => ({ services: {} }),
+}));
+
+mock.module("../config/schemas/services.js", () => ({
+  getServiceMode: (_services: unknown, key: string) =>
+    managedProviders.has(key) ? "managed" : "your-own",
+  ServicesSchema: { shape: { google: true, slack: true } },
 }));
 
 mock.module("../oauth/oauth-store.js", () => ({
-  isProviderConnected: (provider: string) => connectedProviders.has(provider),
+  isProviderConnected: (provider: string) =>
+    Promise.resolve(connectedProviders.has(provider)),
   getConnectionByProvider: (provider: string) =>
     connectedProviders.has(provider)
       ? { id: `conn-${provider}`, status: "active" }
       : undefined,
+  getProvider: (provider: string) => {
+    const managedKeys: Record<string, string> = {
+      google: "google",
+      slack: "slack",
+    };
+    return managedKeys[provider]
+      ? { managedServiceConfigKey: managedKeys[provider] }
+      : undefined;
+  },
+}));
+
+mock.module("../platform/client.js", () => ({
+  VellumPlatformClient: {
+    create: async () => ({
+      platformAssistantId: "test-assistant",
+      fetch: async (path: string) => {
+        const url = new URL(`http://localhost${path}`);
+        const provider = url.searchParams.get("provider");
+        const hasConnections =
+          provider && platformConnectedProviders.has(provider);
+        return {
+          ok: true,
+          json: async () => (hasConnections ? [{ id: "conn-1" }] : []),
+        };
+      },
+    }),
+  },
 }));
 
-/** Mark a provider as fully connected (active row + access token). */
 function setOAuthConnected(provider: string): void {
   connectedProviders.add(provider);
 }
 
+function setPlatformConnected(provider: string, configKey: string): void {
+  managedProviders.add(configKey);
+  platformConnectedProviders.add(provider);
+}
+
 const { getIntegrationSummary, formatIntegrationSummary, hasCapability } =
   await import("../schedule/integration-status.js");
 
@@ -40,6 +80,8 @@ describe("integration-status", () => {
   beforeEach(() => {
     secureKeyValues.clear();
     connectedProviders.clear();
+    managedProviders.clear();
+    platformConnectedProviders.clear();
     mockTwilioAccountSid = undefined;
   });
 
@@ -99,7 +141,6 @@ describe("integration-status", () => {
     });
 
     test("Telegram disconnected when no connection record exists", async () => {
-      // No oauth_connection record for telegram — should be disconnected
       const summary = await getIntegrationSummary();
       const telegram = summary.find(
         (s: { name: string }) => s.name === "Telegram",
@@ -153,7 +194,6 @@ describe("integration-status", () => {
     });
 
     test("returns false when no connection record exists for category integrations", async () => {
-      // No oauth_connection record for telegram — should not count as connected
       expect(await hasCapability("messaging")).toBe(false);
     });
 
@@ -166,4 +206,44 @@ describe("integration-status", () => {
       expect(await hasCapability("email")).toBe(true);
     });
   });
+
+  describe("managed mode", () => {
+    test("Gmail shows connected when platform has active connection", async () => {
+      setPlatformConnected("google", "google");
+
+      const summary = await getIntegrationSummary();
+      const gmail = summary.find((s: { name: string }) => s.name === "Gmail");
+      expect(gmail?.connected).toBe(true);
+    });
+
+    test("Gmail shows disconnected when managed but no platform connection", async () => {
+      managedProviders.add("google");
+
+      const summary = await getIntegrationSummary();
+      const gmail = summary.find((s: { name: string }) => s.name === "Gmail");
+      expect(gmail?.connected).toBe(false);
+    });
+
+    test("Slack shows connected when platform has active connection", async () => {
+      setPlatformConnected("slack", "slack");
+
+      const summary = await getIntegrationSummary();
+      const slack = summary.find((s: { name: string }) => s.name === "Slack");
+      expect(slack?.connected).toBe(true);
+    });
+
+    test("formatIntegrationSummary reflects managed connections", async () => {
+      setPlatformConnected("google", "google");
+      setPlatformConnected("slack", "slack");
+
+      const result = await formatIntegrationSummary();
+      expect(result).toContain("Gmail \u2713");
+      expect(result).toContain("Slack \u2713");
+    });
+
+    test("hasCapability returns true for managed email connection", async () => {
+      setPlatformConnected("google", "google");
+      expect(await hasCapability("email")).toBe(true);
+    });
+  });
 });

package/src/__tests__/intent-routing.test.ts

@@ -36,7 +36,6 @@ mock.module("../config/loader.js", () => ({
   }),
   loadConfig: () => ({}),
   loadRawConfig: () => ({}),
-  saveConfig: () => {},
   saveRawConfig: () => {},
   invalidateConfigCache: () => {},
   getNestedValue: () => undefined,

package/src/__tests__/jobs-store-qdrant-breaker.test.ts

@@ -13,6 +13,8 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 
+import { eq } from "drizzle-orm";
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
@@ -24,6 +26,7 @@ import {
   _resetQdrantBreaker,
   withQdrantBreaker,
 } from "../memory/qdrant-circuit-breaker.js";
+import { memoryJobs } from "../memory/schema.js";
 
 describe("claimMemoryJobs with Qdrant circuit breaker", () => {
   beforeAll(() => {
@@ -41,7 +44,7 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     enqueueMemoryJob("embed_graph_node", { nodeId: "node-1" });
     enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
 
-    const claimed = claimMemoryJobs(10);
+    const claimed = claimMemoryJobs({ slowLlm: 10, fast: 10, embed: 10 });
     const types = claimed.map((j) => j.type);
 
     expect(types).toContain("embed_segment");
@@ -70,7 +73,7 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
       conversationId: "conv-1",
     });
 
-    const claimed = claimMemoryJobs(10);
+    const claimed = claimMemoryJobs({ slowLlm: 10, fast: 10, embed: 10 });
     const types = claimed.map((j) => j.type);
 
     // Only non-embed jobs should be claimed
@@ -98,7 +101,11 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
     enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
 
-    const claimedWhileOpen = claimMemoryJobs(10);
+    const claimedWhileOpen = claimMemoryJobs({
+      slowLlm: 10,
+      fast: 10,
+      embed: 10,
+    });
     expect(claimedWhileOpen.map((j) => j.type)).not.toContain("embed_segment");
 
     // Reset breaker (simulates successful probe closing the circuit)
@@ -107,12 +114,95 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     // Re-enqueue an embed job (the previous one is now "running")
     enqueueMemoryJob("embed_graph_node", { nodeId: "node-2" });
 
-    const claimedAfterClose = claimMemoryJobs(10);
+    const claimedAfterClose = claimMemoryJobs({
+      slowLlm: 10,
+      fast: 10,
+      embed: 10,
+    });
     const types = claimedAfterClose.map((j) => j.type);
 
     expect(types).toContain("embed_graph_node");
   });
 
+  test("lane budgets are honored when called with explicit budgets", () => {
+    // 5 slow-lane jobs
+    for (let i = 0; i < 5; i++) {
+      enqueueMemoryJob("graph_extract", { conversationId: `slow-${i}` });
+    }
+    // 5 fast-lane jobs (rebuild_index is neither slow-LLM nor embed)
+    for (let i = 0; i < 5; i++) {
+      enqueueMemoryJob("rebuild_index", { id: `fast-${i}` });
+    }
+    // 5 embed-lane jobs
+    for (let i = 0; i < 5; i++) {
+      enqueueMemoryJob("embed_segment", { segmentId: `embed-${i}` });
+    }
+
+    const claimed = claimMemoryJobs({ slowLlm: 1, fast: 2, embed: 2 });
+    const slowClaimed = claimed.filter((j) => j.type === "graph_extract");
+    const fastClaimed = claimed.filter((j) => j.type === "rebuild_index");
+    const embedClaimed = claimed.filter((j) => j.type === "embed_segment");
+
+    expect(claimed).toHaveLength(5);
+    expect(slowClaimed).toHaveLength(1);
+    expect(fastClaimed).toHaveLength(2);
+    expect(embedClaimed).toHaveLength(2);
+
+    // Remaining 10 jobs should still be pending.
+    const db = getDb();
+    const pendingRows = db
+      .select()
+      .from(memoryJobs)
+      .where(eq(memoryJobs.status, "pending"))
+      .all();
+    expect(pendingRows).toHaveLength(10);
+  });
+
+  test("Qdrant breaker gates only the embed lane in lane-aware mode", async () => {
+    // 5 slow + 5 fast + 5 embed pending jobs
+    for (let i = 0; i < 5; i++) {
+      enqueueMemoryJob("graph_extract", { conversationId: `slow-${i}` });
+    }
+    for (let i = 0; i < 5; i++) {
+      enqueueMemoryJob("rebuild_index", { id: `fast-${i}` });
+    }
+    for (let i = 0; i < 5; i++) {
+      enqueueMemoryJob("embed_segment", { segmentId: `embed-${i}` });
+    }
+
+    // Trip the breaker
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+
+    const claimed = claimMemoryJobs({ slowLlm: 1, fast: 2, embed: 2 });
+    const slowClaimed = claimed.filter((j) => j.type === "graph_extract");
+    const fastClaimed = claimed.filter((j) => j.type === "rebuild_index");
+    const embedClaimed = claimed.filter((j) => j.type === "embed_segment");
+
+    expect(slowClaimed).toHaveLength(1);
+    expect(fastClaimed).toHaveLength(2);
+    // Breaker is open and probe window has not elapsed → no embed jobs claimed.
+    expect(embedClaimed).toHaveLength(0);
+  });
+
+  test("FIFO order within a lane is preserved by runAfter ascending", () => {
+    const t0 = Date.now() - 30_000;
+    enqueueMemoryJob("graph_extract", { conversationId: "third" }, t0 + 200);
+    enqueueMemoryJob("graph_extract", { conversationId: "first" }, t0);
+    enqueueMemoryJob("graph_extract", { conversationId: "second" }, t0 + 100);
+
+    const claimed = claimMemoryJobs({ slowLlm: 3, fast: 0, embed: 0 });
+    const order = claimed.map((j) => j.payload.conversationId);
+    expect(order).toEqual(["first", "second", "third"]);
+  });
+
   test("all embed job types are skipped when breaker is open", async () => {
     const embedTypes: MemoryJobType[] = [
       "embed_segment",
@@ -141,7 +231,7 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     // Also enqueue a non-embed job
     enqueueMemoryJob("graph_consolidate", { conversationId: "conv-1" });
 
-    const claimed = claimMemoryJobs(20);
+    const claimed = claimMemoryJobs({ slowLlm: 20, fast: 20, embed: 20 });
     const types = claimed.map((j) => j.type);
 
     // Only the non-embed job should be claimed

package/src/__tests__/lifecycle-memory-v2-seed.test.ts

@@ -139,6 +139,23 @@ describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
     expect(state.warnCalls).toHaveLength(0);
   });
 
+  test("re-invocation seeds after flag flips on (deferred-init race recovery)", async () => {
+    // Models the lifecycle-startup race: the synchronous seed call evaluates
+    // the flag while the gateway IPC override fetch is still in flight, falls
+    // through to the registry default (`false`), and skips. Once
+    // `initFeatureFlagOverrides()` resolves, the chained `.then` re-invokes
+    // the seed with the now-populated cache and the flag flips to `true`.
+    state.flagOverrides = { "memory-v2-enabled": false };
+    maybeSeedMemoryV2Skills(makeConfig(true));
+    await flushMicrotasks();
+    expect(state.seedCallCount).toBe(0);
+
+    state.flagOverrides = { "memory-v2-enabled": true };
+    maybeSeedMemoryV2Skills(makeConfig(true));
+    await flushMicrotasks();
+    expect(state.seedCallCount).toBe(1);
+  });
+
   test("swallows seedV2SkillEntries rejections and logs a warning", async () => {
     state.flagOverrides = { "memory-v2-enabled": true };
     state.seedShouldReject = new Error("seed failed");

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -45,7 +45,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,