shadow-claw 1.40.0 → 1.40.1

package/src/core/orchestrator/utils/operations/vm.test.ts

@@ -1,7 +1,13 @@
-import { jest } from "@jest/globals";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
 import { DEFAULT_GROUP_ID } from "../../../../config/config.js";
 
-import {
+const mockDefaultSetConfig = jest.fn() as any;
+
+jest.unstable_mockModule("../../../../db/setConfig.js", () => ({
+  setConfig: mockDefaultSetConfig,
+}));
+
+const {
   closeTerminalSession,
   openTerminalSession,
   sendTerminalInput,
@@ -11,18 +17,23 @@ import {
   setVMBootMode,
   setVMBootHost,
   setVMNetworkRelayURL,
-} from "./vm.js";
+} = await import("./vm.js");
 
 import type { OrchestratorState } from "../../orchestrator-state.js";
 
-function makeState() {
+function makeState(withWorker = true) {
   return {
-    agentWorker: { postMessage: jest.fn() } as any,
+    agentWorker: withWorker ? ({ postMessage: jest.fn() } as any) : undefined,
     vmBootMode: "auto",
   } as unknown as OrchestratorState;
 }
 
 describe("vm operations", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockDefaultSetConfig.mockResolvedValue(undefined);
+  });
+
   it("openTerminalSession sends open message with default and custom groupId", () => {
     const state = makeState();
     openTerminalSession(state, "group1");
@@ -62,22 +73,34 @@ describe("vm operations", () => {
     });
   });
 
-  it("syncTerminalWorkspace sends sync message", () => {
+  it("syncTerminalWorkspace sends sync message with default and custom groupId", () => {
     const state = makeState();
     syncTerminalWorkspace(state, "group-sync");
     expect(state.agentWorker?.postMessage).toHaveBeenCalledWith({
       payload: { groupId: "group-sync" },
       type: "vm-workspace-sync",
     });
+
+    syncTerminalWorkspace(state);
+    expect(state.agentWorker?.postMessage).toHaveBeenCalledWith({
+      payload: { groupId: DEFAULT_GROUP_ID },
+      type: "vm-workspace-sync",
+    });
   });
 
-  it("flushTerminalWorkspace sends flush message", () => {
+  it("flushTerminalWorkspace sends flush message with default and custom groupId", () => {
     const state = makeState();
     flushTerminalWorkspace(state, "group-flush");
     expect(state.agentWorker?.postMessage).toHaveBeenCalledWith({
       payload: { groupId: "group-flush" },
       type: "vm-workspace-flush",
     });
+
+    flushTerminalWorkspace(state);
+    expect(state.agentWorker?.postMessage).toHaveBeenCalledWith({
+      payload: { groupId: DEFAULT_GROUP_ID },
+      type: "vm-workspace-flush",
+    });
   });
 
   it("answerUserPrompt sends ask-user-response message", () => {
@@ -110,6 +133,26 @@ describe("vm operations", () => {
     );
     expect(state.vmBootMode).toBe("disabled");
     expect(mockSetConfig).toHaveBeenCalledWith({}, "vm_boot_mode", "disabled");
+
+    // Test other valid modes: ext2, auto, disabled
+    await setVMBootMode(state, {} as any, "ext2", mockSetConfig as any);
+    expect(state.vmBootMode).toBe("ext2");
+
+    await setVMBootMode(state, {} as any, "auto", mockSetConfig as any);
+    expect(state.vmBootMode).toBe("auto");
+
+    await setVMBootMode(state, {} as any, "disabled", mockSetConfig as any);
+    expect(state.vmBootMode).toBe("disabled");
+  });
+
+  it("setVMBootMode uses default setConfig and handles absent agentWorker", async () => {
+    const state = makeState(false);
+    await setVMBootMode(state, {} as any, "auto");
+    expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+      {},
+      "vm_boot_mode",
+      "auto",
+    );
   });
 
   it("setVMBootHost sets boot host, updates config and notifies worker", async () => {
@@ -133,6 +176,12 @@ describe("vm operations", () => {
     });
   });
 
+  it("setVMBootHost handles non-string host, default setConfig, and absent agentWorker", async () => {
+    const state = makeState(false);
+    await setVMBootHost(state, {} as any, null as any);
+    expect(mockDefaultSetConfig).toHaveBeenCalledWith({}, "vm_boot_host", "");
+  });
+
   it("setVMNetworkRelayURL sets relay URL, updates config and notifies worker", async () => {
     const state = makeState();
     const mockSetConfig = jest.fn().mockResolvedValue(undefined as never);
@@ -153,4 +202,14 @@ describe("vm operations", () => {
       type: "set-vm-mode",
     });
   });
+
+  it("setVMNetworkRelayURL handles non-string relay URL, default setConfig, and absent agentWorker", async () => {
+    const state = makeState(false);
+    await setVMNetworkRelayURL(state, {} as any, undefined as any);
+    expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+      {},
+      "vm_network_relay_url",
+      "",
+    );
+  });
 });

package/src/core/orchestrator/utils/parseDirectToolCommand.test.ts

@@ -116,5 +116,11 @@ describe("parseDirectToolCommand", () => {
   it("should return null if JSON parses to a primitive", () => {
     const msg = createMsg('/test_tool "hello"');
     expect(parseDirectToolCommand(policy, assistantName, msg)).toBeNull();
+
+    const msgNumber = createMsg("/test_tool 123");
+    expect(parseDirectToolCommand(policy, assistantName, msgNumber)).toBeNull();
+
+    const msgNull = createMsg("/test_tool null");
+    expect(parseDirectToolCommand(policy, assistantName, msgNull)).toBeNull();
   });
 });

package/src/core/orchestrator/utils/settings.test.ts

@@ -1,8 +1,27 @@
-import { jest } from "@jest/globals";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import {
+  CONFIG_KEYS,
+  DEFAULT_TASK_SERVER_URL,
+} from "../../../config/config.js";
+import type { ShadowClawDatabase } from "../../../db/db.js";
+import type { OrchestratorState } from "../orchestrator-state.js";
 
-import { CONFIG_KEYS } from "../../../config/config.js";
+const mockDefaultSetConfig =
+  jest.fn<
+    (_db: ShadowClawDatabase, _key: string, _value: string) => Promise<void>
+  >();
+const mockSyncProxyConfigToServiceWorker =
+  jest.fn<(_state: OrchestratorState) => void>();
 
-import {
+jest.unstable_mockModule("../../../db/setConfig.js", () => ({
+  setConfig: mockDefaultSetConfig,
+}));
+
+jest.unstable_mockModule("./syncProxyConfigToServiceWorker.js", () => ({
+  syncProxyConfigToServiceWorker: mockSyncProxyConfigToServiceWorker,
+}));
+
+const {
   setContextCompressionEnabled,
   setGitProxyUrl,
   setMaxIterations,
@@ -12,28 +31,26 @@ import {
   setRateLimitCallsPerMinute,
   setReasoningEffort,
   setStreamingEnabled,
+  setTaskServerEnabled,
   setTaskServerUrl,
   setUseProxy,
   setVMBashFullInternetAccess,
   setVMBashTimeout,
-} from "./settings.js";
-
-import type { OrchestratorState } from "../orchestrator-state.js";
+} = await import("./settings.js");
 
-// Minimal mock that satisfies the setConfig dependency.
-function mockSetConfig() {
+function mockCustomSetConfig() {
   const calls: Array<{ key: string; value: string }> = [];
-
-  return {
-    calls,
-    mockFn: jest.fn(async (_db: any, key: string, value: string) => {
+  const mockFn = jest.fn(
+    async (_db: ShadowClawDatabase, key: string, value: string) => {
       calls.push({ key, value });
-    }),
-  };
+    },
+  );
+  return { calls, mockFn };
 }
 
-// A bare-bones state object with only the fields each test needs.
-function makeState(overrides: Partial<OrchestratorState> = {}) {
+function makeState(
+  overrides: Partial<OrchestratorState> = {},
+): OrchestratorState {
   return {
     contextCompressionEnabled: false,
     gitProxyUrl: "/git-proxy",
@@ -45,7 +62,8 @@ function makeState(overrides: Partial<OrchestratorState> = {}) {
     rateLimitCallsPerMinute: 0,
     reasoningEffort: "none",
     streamingEnabled: true,
-    taskServerUrl: "/schedule",
+    taskServerEnabled: false,
+    taskServerUrl: DEFAULT_TASK_SERVER_URL,
     useProxy: false,
     vmBashFullInternetAccess: false,
     ...overrides,
@@ -53,13 +71,19 @@ function makeState(overrides: Partial<OrchestratorState> = {}) {
 }
 
 describe("settings (functional utilities)", () => {
+  const mockDb = {} as ShadowClawDatabase;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockDefaultSetConfig.mockResolvedValue(undefined);
+  });
+
   describe("setContextCompressionEnabled", () => {
-    it("normalizes truthy values and persists to db", async () => {
+    it("normalizes truthy values and persists to db with custom setConfig", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
-      const db = {} as any;
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setContextCompressionEnabled(state, db, true, mockFn);
+      await setContextCompressionEnabled(state, mockDb, true, mockFn);
 
       expect(state.contextCompressionEnabled).toBe(true);
       expect(calls).toEqual([
@@ -67,44 +91,51 @@ describe("settings (functional utilities)", () => {
       ]);
     });
 
-    it("normalizes falsy values", async () => {
+    it("normalizes falsy values and persists with default setConfig", async () => {
       const state = makeState({ contextCompressionEnabled: true });
-      const { mockFn } = mockSetConfig();
 
-      await setContextCompressionEnabled(state, {} as any, 0 as any, mockFn);
+      await setContextCompressionEnabled(state, mockDb, false);
 
       expect(state.contextCompressionEnabled).toBe(false);
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.CONTEXT_COMPRESSION_ENABLED,
+        "false",
+      );
     });
   });
 
   describe("setGitProxyUrl", () => {
     it("defaults to /git-proxy when empty", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setGitProxyUrl(state, {} as any, "", mockFn);
+      await setGitProxyUrl(state, mockDb, "", mockFn);
 
       expect(state.gitProxyUrl).toBe("/git-proxy");
       expect(calls[0].value).toBe("/git-proxy");
     });
 
-    it("stores the provided url", async () => {
+    it("stores the provided url using default setConfig", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
 
-      await setGitProxyUrl(state, {} as any, "/custom-git", mockFn);
+      await setGitProxyUrl(state, mockDb, "/custom-git");
 
       expect(state.gitProxyUrl).toBe("/custom-git");
-      expect(calls[0].value).toBe("/custom-git");
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.GIT_PROXY_URL,
+        "/custom-git",
+      );
     });
   });
 
   describe("setMaxIterations", () => {
-    it("stores value on state and in db", async () => {
+    it("stores value on state and in db with custom setConfig", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setMaxIterations(state, {} as any, 50, mockFn);
+      await setMaxIterations(state, mockDb, 50, mockFn);
 
       expect(state.maxIterations).toBe(50);
       expect(calls[0]).toEqual({
@@ -112,16 +143,28 @@ describe("settings (functional utilities)", () => {
         value: "50",
       });
     });
+
+    it("stores value using default setConfig", async () => {
+      const state = makeState();
+
+      await setMaxIterations(state, mockDb, 10);
+
+      expect(state.maxIterations).toBe(10);
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.MAX_ITERATIONS,
+        "10",
+      );
+    });
   });
 
   describe("setMaxTokens", () => {
     it("stores large values without clamping to model maximum", async () => {
       const state = makeState({ model: "test-model" });
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setMaxTokens(state, {} as any, 999999, mockFn);
+      await setMaxTokens(state, mockDb, 999999, mockFn);
 
-      // No upper clamp — user can set any value they want
       expect(state.maxTokens).toBe(999999);
       expect(calls[0]).toEqual({
         key: CONFIG_KEYS.MAX_TOKENS,
@@ -129,65 +172,101 @@ describe("settings (functional utilities)", () => {
       });
     });
 
-    it("clamps below 1 to 1", async () => {
+    it("clamps below 1 to 1 and uses default setConfig", async () => {
       const state = makeState();
-      const { mockFn } = mockSetConfig();
 
-      await setMaxTokens(state, {} as any, -10, mockFn);
+      await setMaxTokens(state, mockDb, -10);
 
       expect(state.maxTokens).toBe(1);
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.MAX_TOKENS,
+        "1",
+      );
     });
   });
 
   describe("setProxyUrl", () => {
     it("defaults to /proxy when empty", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setProxyUrl(state, {} as any, "", mockFn);
+      await setProxyUrl(state, mockDb, "", mockFn);
 
       expect(state.proxyUrl).toBe("/proxy");
       expect(calls[0].value).toBe("/proxy");
+      expect(mockSyncProxyConfigToServiceWorker).toHaveBeenCalledWith(state);
+    });
+
+    it("stores the custom url and uses default setConfig", async () => {
+      const state = makeState();
+
+      await setProxyUrl(state, mockDb, "http://localhost:8080/proxy");
+
+      expect(state.proxyUrl).toBe("http://localhost:8080/proxy");
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.PROXY_URL,
+        "http://localhost:8080/proxy",
+      );
+      expect(mockSyncProxyConfigToServiceWorker).toHaveBeenCalledWith(state);
     });
   });
 
   describe("setRateLimitAutoAdapt", () => {
-    it("normalizes and persists boolean", async () => {
+    it("normalizes and persists boolean with custom setConfig", async () => {
       const state = makeState({ rateLimitAutoAdapt: true });
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setRateLimitAutoAdapt(state, {} as any, false, mockFn);
+      await setRateLimitAutoAdapt(state, mockDb, false, mockFn);
 
       expect(state.rateLimitAutoAdapt).toBe(false);
       expect(calls[0].value).toBe("false");
     });
+
+    it("normalizes and persists boolean with default setConfig", async () => {
+      const state = makeState({ rateLimitAutoAdapt: false });
+
+      await setRateLimitAutoAdapt(state, mockDb, true);
+
+      expect(state.rateLimitAutoAdapt).toBe(true);
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.RATE_LIMIT_AUTO_ADAPT,
+        "true",
+      );
+    });
   });
 
   describe("setRateLimitCallsPerMinute", () => {
     it("normalizes to a non-negative integer", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setRateLimitCallsPerMinute(state, {} as any, 3.7, mockFn);
+      await setRateLimitCallsPerMinute(state, mockDb, 3.7, mockFn);
 
       expect(state.rateLimitCallsPerMinute).toBe(3);
       expect(calls[0].value).toBe("3");
     });
 
-    it("normalizes NaN to 0", async () => {
+    it("normalizes NaN to 0 and uses default setConfig", async () => {
       const state = makeState();
-      const { mockFn } = mockSetConfig();
 
-      await setRateLimitCallsPerMinute(state, {} as any, NaN, mockFn);
+      await setRateLimitCallsPerMinute(state, mockDb, NaN);
 
       expect(state.rateLimitCallsPerMinute).toBe(0);
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.RATE_LIMIT_CALLS_PER_MINUTE,
+        "0",
+      );
     });
 
     it("normalizes negative to 0", async () => {
       const state = makeState();
-      const { mockFn } = mockSetConfig();
+      const { mockFn } = mockCustomSetConfig();
 
-      await setRateLimitCallsPerMinute(state, {} as any, -5, mockFn);
+      await setRateLimitCallsPerMinute(state, mockDb, -5, mockFn);
 
       expect(state.rateLimitCallsPerMinute).toBe(0);
     });
@@ -196,103 +275,191 @@ describe("settings (functional utilities)", () => {
   describe("setReasoningEffort", () => {
     it("normalizes and lowercases effort string", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setReasoningEffort(state, {} as any, "  HIGH  ", mockFn);
+      await setReasoningEffort(state, mockDb, "  HIGH  ", mockFn);
 
       expect(state.reasoningEffort).toBe("high");
       expect(calls[0].value).toBe("high");
     });
 
-    it("defaults to 'none' for empty input", async () => {
+    it("defaults to 'none' for empty input with default setConfig", async () => {
       const state = makeState();
-      const { mockFn } = mockSetConfig();
 
-      await setReasoningEffort(state, {} as any, "", mockFn);
+      await setReasoningEffort(state, mockDb, "");
 
       expect(state.reasoningEffort).toBe("none");
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.REASONING_EFFORT,
+        "none",
+      );
     });
 
     it("defaults to 'none' for non-string input", async () => {
       const state = makeState();
-      const { mockFn } = mockSetConfig();
+      const { mockFn } = mockCustomSetConfig();
 
-      await setReasoningEffort(state, {} as any, 42 as any, mockFn);
+      await setReasoningEffort(state, mockDb, 42 as unknown as string, mockFn);
 
       expect(state.reasoningEffort).toBe("none");
     });
   });
 
   describe("setStreamingEnabled", () => {
-    it("normalizes truthy and persists", async () => {
+    it("normalizes truthy and persists with custom setConfig", async () => {
       const state = makeState({ streamingEnabled: false });
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setStreamingEnabled(state, {} as any, true, mockFn);
+      await setStreamingEnabled(state, mockDb, true, mockFn);
 
       expect(state.streamingEnabled).toBe(true);
       expect(calls[0].value).toBe("true");
     });
+
+    it("normalizes falsy and persists with default setConfig", async () => {
+      const state = makeState({ streamingEnabled: true });
+
+      await setStreamingEnabled(state, mockDb, false);
+
+      expect(state.streamingEnabled).toBe(false);
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.STREAMING_ENABLED,
+        "false",
+      );
+    });
+  });
+
+  describe("setTaskServerEnabled", () => {
+    it("normalizes truthy values and persists with custom setConfig", async () => {
+      const state = makeState({ taskServerEnabled: false });
+      const { calls, mockFn } = mockCustomSetConfig();
+
+      await setTaskServerEnabled(state, mockDb, true, mockFn);
+
+      expect(state.taskServerEnabled).toBe(true);
+      expect(calls).toEqual([
+        { key: CONFIG_KEYS.TASK_SERVER_ENABLED, value: "true" },
+      ]);
+    });
+
+    it("normalizes falsy values and persists with default setConfig", async () => {
+      const state = makeState({ taskServerEnabled: true });
+
+      await setTaskServerEnabled(state, mockDb, false);
+
+      expect(state.taskServerEnabled).toBe(false);
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.TASK_SERVER_ENABLED,
+        "false",
+      );
+    });
   });
 
   describe("setTaskServerUrl", () => {
-    it("defaults to config default when empty", async () => {
+    it("defaults to config default when empty with custom setConfig", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setTaskServerUrl(state, {} as any, "", mockFn);
+      await setTaskServerUrl(state, mockDb, "", mockFn);
 
-      expect(state.taskServerUrl).toBe("http://localhost:8888/schedule");
-      expect(calls[0].value).toBe("http://localhost:8888/schedule");
+      expect(state.taskServerUrl).toBe(DEFAULT_TASK_SERVER_URL);
+      expect(calls[0].value).toBe(DEFAULT_TASK_SERVER_URL);
+    });
+
+    it("persists provided url with default setConfig", async () => {
+      const state = makeState();
+
+      await setTaskServerUrl(state, mockDb, "http://tasks.lan:9999");
+
+      expect(state.taskServerUrl).toBe("http://tasks.lan:9999");
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.TASK_SERVER_URL,
+        "http://tasks.lan:9999",
+      );
     });
   });
 
   describe("setUseProxy", () => {
-    it("normalizes and persists boolean", async () => {
+    it("normalizes and persists boolean with custom setConfig", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setUseProxy(state, {} as any, true, mockFn);
+      await setUseProxy(state, mockDb, true, mockFn);
 
       expect(state.useProxy).toBe(true);
       expect(calls[0].value).toBe("true");
+      expect(mockSyncProxyConfigToServiceWorker).toHaveBeenCalledWith(state);
+    });
+
+    it("normalizes and persists false with default setConfig", async () => {
+      const state = makeState({ useProxy: true });
+
+      await setUseProxy(state, mockDb, false);
+
+      expect(state.useProxy).toBe(false);
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.USE_PROXY,
+        "false",
+      );
+      expect(mockSyncProxyConfigToServiceWorker).toHaveBeenCalledWith(state);
     });
   });
 
   describe("setVMBashFullInternetAccess", () => {
-    it("normalizes and persists boolean", async () => {
+    it("normalizes and persists boolean with custom setConfig", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
+      const { calls, mockFn } = mockCustomSetConfig();
 
-      await setVMBashFullInternetAccess(state, {} as any, true, mockFn);
+      await setVMBashFullInternetAccess(state, mockDb, true, mockFn);
 
       expect(state.vmBashFullInternetAccess).toBe(true);
       expect(calls[0].value).toBe("true");
     });
+
+    it("normalizes and persists false with default setConfig", async () => {
+      const state = makeState({ vmBashFullInternetAccess: true });
+
+      await setVMBashFullInternetAccess(state, mockDb, false);
+
+      expect(state.vmBashFullInternetAccess).toBe(false);
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.VM_BASH_FULL_INTERNET_ACCESS,
+        "false",
+      );
+    });
   });
 
   describe("setVMBashTimeout", () => {
-    it("clamps to [1, 1800]", async () => {
-      const { calls, mockFn } = mockSetConfig();
+    it("clamps to [1, 1800] with custom setConfig", async () => {
+      const { calls, mockFn } = mockCustomSetConfig();
       const state = makeState();
 
-      await setVMBashTimeout(state, {} as any, 0, mockFn);
+      await setVMBashTimeout(state, mockDb, 0, mockFn);
       expect(calls[0].value).toBe("1");
 
-      await setVMBashTimeout(state, {} as any, 99999, mockFn);
+      await setVMBashTimeout(state, mockDb, 99999, mockFn);
       expect(calls[1].value).toBe("1800");
 
-      await setVMBashTimeout(state, {} as any, 120, mockFn);
+      await setVMBashTimeout(state, mockDb, 120, mockFn);
       expect(calls[2].value).toBe("120");
     });
 
-    it("floors fractional seconds", async () => {
+    it("floors fractional seconds and persists with default setConfig", async () => {
       const state = makeState();
-      const { calls, mockFn } = mockSetConfig();
 
-      await setVMBashTimeout(state, {} as any, 45.9, mockFn);
+      await setVMBashTimeout(state, mockDb, 45.9);
 
-      expect(calls[0].value).toBe("45");
+      expect(mockDefaultSetConfig).toHaveBeenCalledWith(
+        mockDb,
+        CONFIG_KEYS.VM_BASH_TIMEOUT_SEC,
+        "45",
+      );
     });
   });
 });