@vellumai/assistant 0.7.1 → 0.7.2

package/src/__tests__/credential-execution-managed-contract.test.ts

@@ -1,8 +1,8 @@
 /**
  * Managed CES contract and wiring tests.
  *
- * Validates the contract surface, behavioral invariants, and feature-flag
- * gating for the managed (three-container pod) CES sidecar integration:
+ * Validates the contract surface and behavioral invariants for the managed
+ * (three-container pod) CES sidecar integration:
  *
  * 1. Pod creation contract: well-known path constants match the
  *    stateful_template.yaml K8s spec (read-only mount + private PVC).
@@ -18,25 +18,11 @@
  *    (UpdateManagedCredential, MakeAuthenticatedRequest) validate expected
  *    payloads and reject malformed ones at the contract level.
  *
- * 5. Feature-flag rollback: when the `ces-managed-sidecar` flag is off,
- *    the process manager falls back to local discovery and never attempts
- *    the managed sidecar path.
- *
  * All tests use contract schemas and handle parsers to verify behavioral
  * contracts — no real CES process or socket dependencies are needed.
  */
 
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-
-beforeEach(() => {
-  _setOverridesForTesting({});
-});
-
-afterEach(() => {
-  _setOverridesForTesting({});
-});
+import { describe, expect, test } from "bun:test";
 
 import {
   CES_PROTOCOL_VERSION,
@@ -53,26 +39,11 @@ import {
   UpdateManagedCredentialSchema,
 } from "@vellumai/service-contracts/credential-rpc";
 
-import type { AssistantConfig } from "../config/schema.js";
-import {
-  isCesManagedSidecarEnabled,
-  isCesToolsEnabled,
-} from "../credential-execution/feature-gates.js";
 import {
   CES_ASSISTANT_DATA_READONLY_MOUNT,
   CES_PRIVATE_DATA_DIR,
-  type CesProcessManagerConfig,
 } from "../credential-execution/process-manager.js";
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Create a minimal AssistantConfig (flag overrides are now set via _setOverridesForTesting). */
-function makeConfig(): AssistantConfig {
-  return {} as AssistantConfig;
-}
-
 // ---------------------------------------------------------------------------
 // Well-known paths contract
 // ---------------------------------------------------------------------------
@@ -440,102 +411,3 @@ describe("managed OAuth materialization through CES sidecar", () => {
     }
   });
 });
-
-// ---------------------------------------------------------------------------
-// Feature-flag rollback safety
-// ---------------------------------------------------------------------------
-
-describe("feature-flag rollback safety", () => {
-  test("managed sidecar flag defaults to true (enabled by default)", () => {
-    const config = makeConfig();
-    expect(isCesManagedSidecarEnabled(config)).toBe(true);
-  });
-
-  test("managed sidecar flag can be explicitly enabled", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": true,
-    });
-    const config = makeConfig();
-    expect(isCesManagedSidecarEnabled(config)).toBe(true);
-  });
-
-  test("managed sidecar flag can be explicitly disabled", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": false,
-    });
-    const config = makeConfig();
-    expect(isCesManagedSidecarEnabled(config)).toBe(false);
-  });
-
-  test("enabling managed sidecar does not enable CES tools", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": true,
-    });
-    const config = makeConfig();
-    // CES tools flag should remain independently controlled
-    expect(isCesToolsEnabled(config)).toBe(false);
-  });
-
-  test("disabling managed sidecar does not affect other CES flags", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": false,
-      "ces-tools": true,
-    });
-    const config = makeConfig();
-    expect(isCesToolsEnabled(config)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Process manager config wiring
-// ---------------------------------------------------------------------------
-
-describe("process manager config wiring", () => {
-  test("CesProcessManagerConfig accepts assistantConfig for flag gating", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": true,
-    });
-    const config: CesProcessManagerConfig = {
-      assistantConfig: makeConfig(),
-    };
-    expect(config.assistantConfig).toBeDefined();
-    expect(isCesManagedSidecarEnabled(config.assistantConfig!)).toBe(true);
-  });
-
-  test("CesProcessManagerConfig requires assistantConfig for feature-flag gate", () => {
-    const config: CesProcessManagerConfig = {
-      assistantConfig: makeConfig(),
-    };
-    expect(config.assistantConfig).toBeDefined();
-  });
-
-  test("when flag is off, managed discovery is skipped", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": false,
-    });
-    const config: CesProcessManagerConfig = {
-      assistantConfig: makeConfig(),
-    };
-    // The managed path should be gated
-    expect(isCesManagedSidecarEnabled(config.assistantConfig!)).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Non-CES internal consumers intact
-// ---------------------------------------------------------------------------
-
-describe("non-CES internal consumers intact when flag is off", () => {
-  test("existing non-agent flows are unaffected by managed sidecar flag", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": false,
-    });
-    const config = makeConfig();
-    expect(isCesManagedSidecarEnabled(config)).toBe(false);
-  });
-
-  test("process manager without config allows managed mode (backward compat)", () => {
-    const config: CesProcessManagerConfig = {};
-    expect(config.assistantConfig).toBeUndefined();
-  });
-});

package/src/__tests__/credentials-cli.test.ts

@@ -57,24 +57,17 @@ mock.module("../security/secure-keys.js", () => ({
 }));
 
 mock.module("../cli/lib/daemon-credential-client.js", () => ({
-  setSecureKeyViaDaemon: async (
-    type: string,
-    name: string,
-    value: string,
-  ): Promise<boolean> => {
+  setSecureKeyViaDaemon: async (type: string, name: string, value: string) => {
     secureKeyStore.set(normalizeCredentialAccount(type, name), value);
-    return true;
+    return { ok: true };
   },
-  deleteSecureKeyViaDaemon: async (
-    type: string,
-    name: string,
-  ): Promise<"deleted" | "not-found" | "error"> => {
+  deleteSecureKeyViaDaemon: async (type: string, name: string) => {
     const key = normalizeCredentialAccount(type, name);
     if (secureKeyStore.has(key)) {
       secureKeyStore.delete(key);
-      return "deleted";
+      return { result: "deleted" as const };
     }
-    return "not-found";
+    return { result: "not-found" as const };
   },
 }));
 

package/src/__tests__/cu-unified-flow.test.ts

@@ -9,28 +9,27 @@ import { afterEach, describe, expect, mock, test } from "bun:test";
 
 const sentMessages: unknown[] = [];
 let mockHasClient = true; // Default to true for CU unified flow tests
+let mockCuClients: Array<{ clientId: string; capabilities: string[] }> = [
+  { clientId: "mock-client-1", capabilities: ["host_cu"] },
+];
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: unknown) => sentMessages.push(msg),
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) =>
       cap === "host_cu" && mockHasClient ? { id: "mock-client" } : null,
+    listClientsByCapability: (cap: string) =>
+      cap === "host_cu" ? mockCuClients : [],
+    getClientById: (id: string) =>
+      mockCuClients.find((c) => c.clientId === id) ?? null,
   },
 }));
 
-mock.module("../runtime/pending-interactions.js", () => ({
-  resolve: () => undefined,
-  get: () => undefined,
-  getByKind: () => [],
-  getByConversation: () => [],
-  removeByConversation: () => {},
-}));
-
-const { surfaceProxyResolver } = await import(
-  "../daemon/conversation-surfaces.js"
-);
+const { surfaceProxyResolver } =
+  await import("../daemon/conversation-surfaces.js");
 const { HostCuProxy } = await import("../daemon/host-cu-proxy.js");
-type SurfaceConversationContext = import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
+type SurfaceConversationContext =
+  import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
 
 // ---------------------------------------------------------------------------
 // Test helpers
@@ -73,6 +72,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
   function setupProxy(maxSteps?: number): SurfaceConversationContext {
     sentMessages.length = 0;
     mockHasClient = true;
+    mockCuClients = [{ clientId: "mock-client-1", capabilities: ["host_cu"] }];
     proxy = new HostCuProxy(maxSteps);
     return buildMockContext(proxy);
   }
@@ -239,7 +239,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
 
       // Simulate client resolving with observation
       const requestId = sent.requestId as string;
-      proxy.resolve(requestId, {
+      proxy.processObservation(requestId, {
         axTree: "SubmitButton [1]\nTextField [2]",
         executionResult: "Clicked element 42",
       });
@@ -265,7 +265,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       expect(sent.type).toBe("host_cu_request");
       expect(sent.toolName).toBe("computer_use_screenshot");
 
-      proxy.resolve(sent.requestId as string, {
+      proxy.processObservation(sent.requestId as string, {
         axTree: "Window [1]",
         screenshot: "base64screenshot",
         screenshotWidthPx: 1920,
@@ -302,7 +302,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "Type into search box",
       });
 
-      proxy.resolve(sent.requestId as string, {
+      proxy.processObservation(sent.requestId as string, {
         axTree: "SearchBox [1] value='Hello world'",
         executionResult: "Typed text",
       });
@@ -326,7 +326,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "Check what's on screen",
       });
       const sent1 = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent1.requestId as string, {
+      proxy.processObservation(sent1.requestId as string, {
         axTree: "LoginButton [1]\nUsernameField [2]",
       });
       const r1 = await p1;
@@ -340,7 +340,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "Click login button",
       });
       const sent2 = sentMessages[1] as Record<string, unknown>;
-      proxy.resolve(sent2.requestId as string, {
+      proxy.processObservation(sent2.requestId as string, {
         axTree: "PasswordField [1]\nSubmitButton [2]",
         axDiff: "+ PasswordField [1]\n+ SubmitButton [2]\n- LoginButton [1]",
         executionResult: "Clicked element 1",
@@ -370,6 +370,168 @@ describe("surfaceProxyResolver — CU tool routing", () => {
   // Step limit enforced through resolver
   // -------------------------------------------------------------------------
 
+  // -------------------------------------------------------------------------
+  // Multi-client ambiguity guard
+  // -------------------------------------------------------------------------
+
+  describe("multi-client ambiguity guard", () => {
+    test("returns error when multiple CU clients connected and no target_client_id given", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "client-a", capabilities: ["host_cu"] },
+        { clientId: "client-b", capabilities: ["host_cu"] },
+      ];
+
+      const result = await surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("multiple clients support host_cu");
+      expect(result.content).toContain("target_client_id");
+      // No message should have been dispatched
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("proceeds when multiple clients connected and target_client_id is given", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "client-a", capabilities: ["host_cu"] },
+        { clientId: "client-b", capabilities: ["host_cu"] },
+      ];
+
+      const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+        target_client_id: "client-a",
+      });
+
+      // Should have dispatched the request
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_cu_request");
+      expect(sent.targetClientId).toBe("client-a");
+
+      proxy.processObservation(sent.requestId as string, { axTree: "ok" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+
+    test("proceeds normally when exactly one CU client is connected", async () => {
+      const ctx = setupProxy();
+      // mockCuClients already has 1 entry from setupProxy
+
+      const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 2,
+        reasoning: "safe click",
+      });
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_cu_request");
+
+      proxy.processObservation(sent.requestId as string, { axTree: "ok" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+
+    test("multi-client guard does not apply to terminal tools (computer_use_done)", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "client-a", capabilities: ["host_cu"] },
+        { clientId: "client-b", capabilities: ["host_cu"] },
+      ];
+
+      // Terminal tools short-circuit before the ambiguity check
+      const result = await surfaceProxyResolver(ctx, "computer_use_done", {
+        summary: "all done",
+      });
+
+      expect(result.isError).toBe(false);
+      expect(result.content).toBe("all done");
+      expect(sentMessages).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // targetClientId validation (lives at resolver layer so step count and
+  // action history are not mutated when validation rejects the request).
+  // -------------------------------------------------------------------------
+
+  describe("targetClientId validation", () => {
+    test("returns fast error when targetClientId does not match any connected client", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [{ clientId: "real-client", capabilities: ["host_cu"] }];
+      const stepCountBefore = proxy.stepCount;
+
+      const result = await surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+        target_client_id: "nonexistent-client",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("nonexistent-client");
+      expect(result.content).toContain("host_cu");
+      // Critical: validation must run BEFORE recordAction. stepCount and
+      // actionHistory must be unchanged when rejection fires — otherwise
+      // every invalid target_client_id burns a step and leaves a ghost
+      // entry the LLM can reason about.
+      expect(proxy.stepCount).toBe(stepCountBefore);
+      expect(proxy.actionHistory).toHaveLength(0);
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("returns fast error when targetClientId points to a client without host_cu capability", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "no-cu-client", capabilities: ["host_bash"] }, // bash, not cu
+      ];
+      const stepCountBefore = proxy.stepCount;
+
+      const result = await surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+        target_client_id: "no-cu-client",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("no-cu-client");
+      expect(result.content).toContain("host_cu");
+      // No step burned, no ghost in history.
+      expect(proxy.stepCount).toBe(stepCountBefore);
+      expect(proxy.actionHistory).toHaveLength(0);
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("dispatches and records action when targetClientId is valid", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "cu-client", capabilities: ["host_cu"] },
+        { clientId: "client-b", capabilities: ["host_cu"] }, // would otherwise trip ambiguity guard
+      ];
+
+      const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 5,
+        reasoning: "click",
+        target_client_id: "cu-client",
+      });
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_cu_request");
+      expect(sent.targetClientId).toBe("cu-client");
+      // recordAction did fire on the success path.
+      expect(proxy.stepCount).toBe(1);
+      expect(proxy.actionHistory).toHaveLength(1);
+
+      proxy.processObservation(sent.requestId as string, { axTree: "ok" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+  });
+
   describe("step limit enforcement through resolver", () => {
     test("rejects action tools when step limit exceeded", async () => {
       const ctx = setupProxy(2); // maxSteps = 2
@@ -423,7 +585,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
 
       const sent = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent.requestId as string, {
+      proxy.processObservation(sent.requestId as string, {
         executionError: "Element 999 not found in AX tree",
         axTree: "Window [1]",
       });
@@ -452,7 +614,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       expect(sent.reasoning).toBe("Submit the form");
 
       // Resolve to avoid unhandled rejection on dispose
-      proxy.resolve(sent.requestId as string, { axTree: "..." });
+      proxy.processObservation(sent.requestId as string, { axTree: "..." });
       await resultPromise;
     });
 
@@ -469,7 +631,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
 
       // Resolve to avoid hanging
       const sent = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent.requestId as string, { axTree: "..." });
+      proxy.processObservation(sent.requestId as string, { axTree: "..." });
     });
   });
 
@@ -515,7 +677,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "first",
       });
       const s1 = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(s1.requestId as string, { axTree: "A" });
+      proxy.processObservation(s1.requestId as string, { axTree: "A" });
       await p1;
       expect(proxy.stepCount).toBe(1);
 
@@ -525,7 +687,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "second",
       });
       const s2 = sentMessages[1] as Record<string, unknown>;
-      proxy.resolve(s2.requestId as string, { axTree: "B" });
+      proxy.processObservation(s2.requestId as string, { axTree: "B" });
       await p2;
       expect(proxy.stepCount).toBe(2);
 
@@ -536,7 +698,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "third",
       });
       const s3 = sentMessages[2] as Record<string, unknown>;
-      proxy.resolve(s3.requestId as string, { axTree: "C" });
+      proxy.processObservation(s3.requestId as string, { axTree: "C" });
       await p3;
       expect(proxy.stepCount).toBe(3);
 

package/src/__tests__/daemon-credential-client.test.ts

@@ -1,16 +1,20 @@
 import { describe, expect, mock, test } from "bun:test";
 
 /**
- * Mock only the IPC client (to simulate daemon-unreachable) and the logger.
+ * Mock the IPC client and logger. The IPC mock returns configurable
+ * responses so we can test success, failure, and unreachable paths.
+ *
  * Do NOT mock secure-keys.js — daemon-credential-client falls back to it
  * for writes/deletes when the daemon is unreachable.
  */
 
+let _ipcResponse: { ok: boolean; result?: unknown; error?: string } = {
+  ok: false,
+  error: "Could not connect to assistant daemon. Is it running?",
+};
+
 mock.module("../ipc/cli-client.js", () => ({
-  cliIpcCall: async () => ({
-    ok: false,
-    error: "Could not connect to assistant daemon. Is it running?",
-  }),
+  cliIpcCall: async () => _ipcResponse,
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -20,22 +24,100 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { setSecureKeyViaDaemon } from "../cli/lib/daemon-credential-client.js";
+import {
+  deleteSecureKeyViaDaemon,
+  setSecureKeyViaDaemon,
+} from "../cli/lib/daemon-credential-client.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
 
-describe("daemon credential writes (daemon unreachable)", () => {
-  test("falls back to direct write when daemon is not running", async () => {
-    const result = await setSecureKeyViaDaemon(
-      "api_key",
-      "test-provider",
-      "test-value",
-    );
-    expect(result).toBe(true);
-
-    const readBack = await getSecureKeyAsync(
-      credentialKey("test-provider", "api_key"),
-    );
-    expect(readBack).toBe("test-value");
+describe("daemon credential client", () => {
+  describe("set — daemon unreachable", () => {
+    test("falls back to direct write when daemon is not running", async () => {
+      _ipcResponse = {
+        ok: false,
+        error: "Could not connect to assistant daemon. Is it running?",
+      };
+
+      const result = await setSecureKeyViaDaemon(
+        "api_key",
+        "test-provider",
+        "test-value",
+      );
+      expect(result.ok).toBe(true);
+
+      const readBack = await getSecureKeyAsync(
+        credentialKey("test-provider", "api_key"),
+      );
+      expect(readBack).toBe("test-value");
+    });
+  });
+
+  describe("set — daemon error", () => {
+    test("surfaces daemon error message on IPC failure", async () => {
+      _ipcResponse = {
+        ok: false,
+        error:
+          "Failed to store credential in secure storage (backend: ces-rpc)",
+      };
+
+      const result = await setSecureKeyViaDaemon(
+        "credential",
+        "vellum:webhook_secret",
+        "some-value",
+      );
+      expect(result.ok).toBe(false);
+      expect(result.error).toBe(
+        "Failed to store credential in secure storage (backend: ces-rpc)",
+      );
+    });
+
+    test("surfaces validation error from daemon result", async () => {
+      _ipcResponse = {
+        ok: true,
+        result: {
+          success: false,
+          error: "API key validation failed: invalid format",
+        },
+      };
+
+      const result = await setSecureKeyViaDaemon(
+        "api_key",
+        "anthropic",
+        "bad-key",
+      );
+      expect(result.ok).toBe(false);
+      expect(result.error).toBe("API key validation failed: invalid format");
+    });
+  });
+
+  describe("delete — daemon error", () => {
+    test("surfaces daemon error message", async () => {
+      _ipcResponse = {
+        ok: false,
+        error: "Credential store is unreachable",
+      };
+
+      const result = await deleteSecureKeyViaDaemon(
+        "credential",
+        "vellum:temp_cred",
+      );
+      expect(result.result).toBe("error");
+      expect(result.error).toBe("Credential store is unreachable");
+    });
+
+    test("returns not-found for 404 errors", async () => {
+      _ipcResponse = {
+        ok: false,
+        error: "Credential not found (404)",
+      };
+
+      const result = await deleteSecureKeyViaDaemon(
+        "credential",
+        "vellum:missing",
+      );
+      expect(result.result).toBe("not-found");
+      expect(result.error).toBeUndefined();
+    });
   });
 });

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -36,6 +36,8 @@ describe("schedule_syntax column migration", () => {
         last_run_at INTEGER,
         last_status TEXT,
         retry_count INTEGER NOT NULL DEFAULT 0,
+        max_retries INTEGER NOT NULL DEFAULT 3,
+        retry_backoff_ms INTEGER NOT NULL DEFAULT 60000,
         created_by TEXT NOT NULL,
         mode TEXT NOT NULL DEFAULT 'execute',
         routing_intent TEXT NOT NULL DEFAULT 'all_channels',

package/src/__tests__/dynamic-skill-workflow-prompt.test.ts

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

package/src/__tests__/gateway-only-enforcement.test.ts

@@ -43,7 +43,6 @@ mock.module("../config/loader.js", () => ({
     calls: {
       enabled: true,
       provider: "twilio",
-      webhookBaseUrl: "https://test.example.com",
       maxDurationSeconds: 3600,
       userConsultTimeoutSeconds: 120,
       disclosure: { enabled: false, text: "" },

package/src/__tests__/guardian-verification-voice-binding.test.ts

@@ -16,8 +16,6 @@ mock.module("../calls/twilio-config.js", () => ({
     accountSid: "AC_test",
     authToken: "test_token",
     phoneNumber: "+15550001111",
-    webhookBaseUrl: "https://test.example.com",
-    wssBaseUrl: "wss://test.example.com",
   }),
 }));