@vellumai/assistant 0.4.41 → 0.4.43

package/src/__tests__/{guardian-control-plane-policy.test.ts → verification-control-plane-policy.test.ts}

@@ -14,7 +14,7 @@ import type {
   ToolPermissionDeniedEvent,
 } from "../tools/types.js";
 
-// ── Module mocks (must precede real imports) ─────────────────────────
+// -- Module mocks (must precede real imports) --
 
 const mockConfig = {
   provider: "anthropic",
@@ -103,15 +103,15 @@ mock.module("../tools/terminal/sandbox.js", () => ({
   wrapCommand: () => ({ command: "", sandboxed: false }),
 }));
 
-// ── Real imports ─────────────────────────────────────────────────────
+// -- Real imports --
 
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { ToolExecutor } from "../tools/executor.js";
-import {
-  enforceGuardianOnlyPolicy,
-  isGuardianControlPlaneInvocation,
-} from "../tools/guardian-control-plane-policy.js";
 import type { ToolContext } from "../tools/types.js";
+import {
+  enforceVerificationControlPlanePolicy,
+  isVerificationControlPlaneInvocation,
+} from "../tools/verification-control-plane-policy.js";
 
 function makeContext(overrides?: Partial<ToolContext>): ToolContext {
   return {
@@ -144,23 +144,22 @@ afterAll(() => {
 });
 
 // =====================================================================
-// Unit tests: isGuardianControlPlaneInvocation
+// Unit tests: isVerificationControlPlaneInvocation
 // =====================================================================
 
-describe("isGuardianControlPlaneInvocation", () => {
-  const guardianPaths = [
-    "/v1/integrations/guardian/challenge",
-    "/v1/integrations/guardian/status",
-    "/v1/integrations/guardian/outbound/start",
-    "/v1/integrations/guardian/outbound/resend",
-    "/v1/integrations/guardian/outbound/cancel",
+describe("isVerificationControlPlaneInvocation", () => {
+  const verificationPaths = [
+    "/v1/channel-verification-sessions",
+    "/v1/channel-verification-sessions/status",
+    "/v1/channel-verification-sessions/resend",
+    "/v1/channel-verification-sessions/revoke",
   ];
 
-  describe("bash tool with guardian endpoint in command", () => {
-    for (const path of guardianPaths) {
+  describe("bash tool with verification endpoint in command", () => {
+    for (const path of verificationPaths) {
       test(`detects curl to ${path}`, () => {
         expect(
-          isGuardianControlPlaneInvocation("bash", {
+          isVerificationControlPlaneInvocation("bash", {
             command: `curl -X POST http://localhost:3000${path}`,
           }),
         ).toBe(true);
@@ -168,7 +167,7 @@ describe("isGuardianControlPlaneInvocation", () => {
 
       test(`detects wget to ${path}`, () => {
         expect(
-          isGuardianControlPlaneInvocation("bash", {
+          isVerificationControlPlaneInvocation("bash", {
             command: `wget https://api.example.com${path}`,
           }),
         ).toBe(true);
@@ -177,57 +176,57 @@ describe("isGuardianControlPlaneInvocation", () => {
 
     test("does not match unrelated commands", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command: "git status",
         }),
       ).toBe(false);
     });
 
     test("matches partial path prefix via fragment detection (fail-closed for shell tools)", () => {
-      // Even without a trailing sub-path, the presence of both /v1/integrations and guardian
-      // in a bash command triggers the conservative fragment detector.
       expect(
-        isGuardianControlPlaneInvocation("bash", {
-          command: "curl http://localhost:3000/v1/integrations/guardian",
+        isVerificationControlPlaneInvocation("bash", {
+          command:
+            "curl http://localhost:3000/v1/channel-verification-sessions",
         }),
       ).toBe(true);
     });
 
-    test("matches unknown sub-path under guardian control-plane (broad pattern)", () => {
+    test("matches unknown sub-path under verification control-plane (broad pattern)", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
-          command: "curl http://localhost:3000/v1/integrations/guardian/other",
+        isVerificationControlPlaneInvocation("bash", {
+          command:
+            "curl http://localhost:3000/v1/channel-verification-sessions/other",
         }),
       ).toBe(true);
     });
 
     test("handles missing command field gracefully", () => {
-      expect(isGuardianControlPlaneInvocation("bash", {})).toBe(false);
+      expect(isVerificationControlPlaneInvocation("bash", {})).toBe(false);
     });
 
     test("handles non-string command field gracefully", () => {
-      expect(isGuardianControlPlaneInvocation("bash", { command: 42 })).toBe(
-        false,
-      );
+      expect(
+        isVerificationControlPlaneInvocation("bash", { command: 42 }),
+      ).toBe(false);
     });
   });
 
-  describe("host_bash tool with guardian endpoint in command", () => {
-    test("detects guardian endpoint", () => {
+  describe("host_bash tool with verification endpoint in command", () => {
+    test("detects verification endpoint", () => {
       expect(
-        isGuardianControlPlaneInvocation("host_bash", {
+        isVerificationControlPlaneInvocation("host_bash", {
           command:
-            'curl -H "Authorization: Bearer token" https://internal:8080/v1/integrations/guardian/outbound/start',
+            'curl -H "Authorization: Bearer token" https://internal:8080/v1/channel-verification-sessions',
         }),
       ).toBe(true);
     });
   });
 
-  describe("network_request tool with guardian endpoint in url", () => {
-    for (const path of guardianPaths) {
+  describe("network_request tool with verification endpoint in url", () => {
+    for (const path of verificationPaths) {
       test(`detects ${path}`, () => {
         expect(
-          isGuardianControlPlaneInvocation("network_request", {
+          isVerificationControlPlaneInvocation("network_request", {
             url: `https://api.vellum.ai${path}`,
           }),
         ).toBe(true);
@@ -236,77 +235,77 @@ describe("isGuardianControlPlaneInvocation", () => {
 
     test("detects proxied local URL", () => {
       expect(
-        isGuardianControlPlaneInvocation("network_request", {
-          url: "http://127.0.0.1:3000/v1/integrations/guardian/challenge",
+        isVerificationControlPlaneInvocation("network_request", {
+          url: "http://127.0.0.1:3000/v1/channel-verification-sessions",
         }),
       ).toBe(true);
     });
 
     test("does not match unrelated URLs", () => {
       expect(
-        isGuardianControlPlaneInvocation("network_request", {
+        isVerificationControlPlaneInvocation("network_request", {
           url: "https://api.example.com/v1/messages",
         }),
       ).toBe(false);
     });
 
     test("handles missing url field gracefully", () => {
-      expect(isGuardianControlPlaneInvocation("network_request", {})).toBe(
+      expect(isVerificationControlPlaneInvocation("network_request", {})).toBe(
         false,
       );
     });
   });
 
-  describe("web_fetch tool with guardian endpoint in url", () => {
-    test("detects guardian endpoint", () => {
+  describe("web_fetch tool with verification endpoint in url", () => {
+    test("detects verification endpoint", () => {
       expect(
-        isGuardianControlPlaneInvocation("web_fetch", {
-          url: "https://api.example.com/v1/integrations/guardian/outbound/cancel",
+        isVerificationControlPlaneInvocation("web_fetch", {
+          url: "https://api.example.com/v1/channel-verification-sessions",
         }),
       ).toBe(true);
     });
 
     test("does not match unrelated URL", () => {
       expect(
-        isGuardianControlPlaneInvocation("web_fetch", {
+        isVerificationControlPlaneInvocation("web_fetch", {
           url: "https://docs.example.com/api/v1/help",
         }),
       ).toBe(false);
     });
   });
 
-  describe("browser_navigate tool with guardian endpoint in url", () => {
-    test("detects guardian endpoint", () => {
+  describe("browser_navigate tool with verification endpoint in url", () => {
+    test("detects verification endpoint", () => {
       expect(
-        isGuardianControlPlaneInvocation("browser_navigate", {
-          url: "http://localhost:3000/v1/integrations/guardian/status",
+        isVerificationControlPlaneInvocation("browser_navigate", {
+          url: "http://localhost:3000/v1/channel-verification-sessions/status",
         }),
       ).toBe(true);
     });
   });
 
   describe("unrelated tools are not flagged", () => {
-    test("file_read is never a guardian invocation", () => {
+    test("file_read is never a verification invocation", () => {
       expect(
-        isGuardianControlPlaneInvocation("file_read", {
-          path: "/v1/integrations/guardian/challenge",
+        isVerificationControlPlaneInvocation("file_read", {
+          path: "/v1/channel-verification-sessions",
         }),
       ).toBe(false);
     });
 
-    test("file_write is never a guardian invocation", () => {
+    test("file_write is never a verification invocation", () => {
       expect(
-        isGuardianControlPlaneInvocation("file_write", {
+        isVerificationControlPlaneInvocation("file_write", {
           path: "/tmp/test.txt",
-          content: "curl /v1/integrations/guardian/outbound/start",
+          content: "curl /v1/channel-verification-sessions",
         }),
       ).toBe(false);
     });
 
-    test("web_search is never a guardian invocation", () => {
+    test("web_search is never a verification invocation", () => {
       expect(
-        isGuardianControlPlaneInvocation("web_search", {
-          query: "/v1/integrations/guardian/status",
+        isVerificationControlPlaneInvocation("web_search", {
+          query: "/v1/channel-verification-sessions/status",
         }),
       ).toBe(false);
     });
@@ -315,25 +314,25 @@ describe("isGuardianControlPlaneInvocation", () => {
   describe("path matching covers proxied and local variants", () => {
     test("matches endpoint with query string", () => {
       expect(
-        isGuardianControlPlaneInvocation("network_request", {
-          url: "https://api.example.com/v1/integrations/guardian/challenge?token=abc",
+        isVerificationControlPlaneInvocation("network_request", {
+          url: "https://api.example.com/v1/channel-verification-sessions?token=abc",
         }),
       ).toBe(true);
     });
 
     test("matches endpoint with trailing slash", () => {
       expect(
-        isGuardianControlPlaneInvocation("network_request", {
-          url: "https://api.example.com/v1/integrations/guardian/outbound/start/",
+        isVerificationControlPlaneInvocation("network_request", {
+          url: "https://api.example.com/v1/channel-verification-sessions/resend/",
         }),
       ).toBe(true);
     });
 
     test("matches endpoint in piped bash command", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command:
-            'echo \'{"phone":"+1234567890"}\' | curl -X POST -d @- http://localhost:3000/v1/integrations/guardian/outbound/resend',
+            'echo \'{"phone":"+1234567890"}\' | curl -X POST -d @- http://localhost:3000/v1/channel-verification-sessions/resend',
         }),
       ).toBe(true);
     });
@@ -342,146 +341,121 @@ describe("isGuardianControlPlaneInvocation", () => {
   describe("obfuscation resistance", () => {
     test("detects URL-encoded path (%2F encoding)", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command:
-            "curl http://localhost:3000/v1/integrations%2Fguardian%2Foutbound%2Fstart",
-        }),
-      ).toBe(true);
-    });
-
-    test("detects double-encoded path (%252F encoding)", () => {
-      expect(
-        isGuardianControlPlaneInvocation("network_request", {
-          url: "http://localhost:3000/v1/integrations%252Fguardian%252Fchallenge",
+            "curl http://localhost:3000/v1/channel%2Dverification%2Dsessions",
         }),
       ).toBe(true);
     });
 
     test("detects double slashes in path", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command:
-            "curl http://localhost:3000/v1/integrations//guardian/outbound/start",
+            "curl http://localhost:3000/v1//channel-verification-sessions",
         }),
       ).toBe(true);
     });
 
     test("detects triple slashes in path", () => {
       expect(
-        isGuardianControlPlaneInvocation("network_request", {
-          url: "http://localhost:3000/v1///integrations///guardian///status",
+        isVerificationControlPlaneInvocation("network_request", {
+          url: "http://localhost:3000/v1///channel-verification-sessions///status",
         }),
       ).toBe(true);
     });
 
     test("detects mixed case path", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command:
-            "curl http://localhost:3000/V1/Integrations/Guardian/Outbound/Start",
+            "curl http://localhost:3000/V1/Channel-Verification-Sessions/Status",
         }),
       ).toBe(true);
     });
 
     test("detects ALL CAPS path", () => {
       expect(
-        isGuardianControlPlaneInvocation("network_request", {
-          url: "http://localhost:3000/V1/INTEGRATIONS/GUARDIAN/CHALLENGE",
+        isVerificationControlPlaneInvocation("network_request", {
+          url: "http://localhost:3000/V1/CHANNEL-VERIFICATION-SESSIONS",
         }),
       ).toBe(true);
     });
 
-    test("detects combined obfuscation: URL-encoding + mixed case", () => {
+    test("detects combined obfuscation: double slashes + mixed case", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
-          command:
-            "curl http://localhost:3000/V1/Integrations%2FGuardian%2FOutbound%2FCancel",
-        }),
-      ).toBe(true);
-    });
-
-    test("detects combined obfuscation: double slashes + URL-encoding", () => {
-      expect(
-        isGuardianControlPlaneInvocation("network_request", {
-          url: "http://localhost:3000/v1//integrations%2Fguardian%2Fstatus",
-        }),
-      ).toBe(true);
-    });
-
-    test("detects URL-encoded path in web_fetch tool", () => {
-      expect(
-        isGuardianControlPlaneInvocation("web_fetch", {
-          url: "http://localhost:3000/v1/integrations%2Fguardian%2Foutbound%2Fresend",
+        isVerificationControlPlaneInvocation("network_request", {
+          url: "http://localhost:3000/v1//Channel-Verification-Sessions/status",
         }),
       ).toBe(true);
     });
 
     test("does not false-positive on unrelated encoded paths", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command:
             "curl http://localhost:3000/v1/integrations%2Fother%2Fservice",
         }),
       ).toBe(false);
     });
 
-    test("detects guardian endpoint despite malformed percent-encoding elsewhere in command", () => {
-      const result = isGuardianControlPlaneInvocation("bash", {
+    test("detects endpoint despite malformed percent-encoding elsewhere in command", () => {
+      const result = isVerificationControlPlaneInvocation("bash", {
         command:
-          'curl -H "X: %ZZ" http://localhost:3000/v1/integrations%2Fguardian%2Foutbound%2Fstart -d \'{"channel":"sms"}\'',
+          'curl -H "X: %ZZ" http://localhost:3000/v1/channel-verification-sessions -d \'{"channel":"sms"}\'',
       });
       expect(result).toBe(true);
     });
   });
 
   describe("shell expansion resistance", () => {
-    test("detects guardian endpoint constructed via shell variable concatenation", () => {
+    test("detects endpoint constructed via shell variable concatenation", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command:
-            'base=http://localhost:7821/v1/integrations; seg=guardian; curl "$base/$seg/status"',
+            'base=http://localhost:7821/v1; seg=channel-verification-sessions; curl "$base/$seg/status"',
         }),
       ).toBe(true);
     });
 
-    test("detects guardian endpoint with split variable assignment", () => {
+    test("detects endpoint with split variable assignment", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command:
-            'API=/v1/integrations; curl "http://localhost:3000${API}/guardian/outbound/start"',
+            'API=channel-verification-sessions; curl "http://localhost:3000/v1/${API}"',
         }),
       ).toBe(true);
     });
 
-    test("detects guardian endpoint with path built across multiple variables", () => {
+    test("detects endpoint with path built across multiple variables", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command:
-            'HOST=http://localhost:7821; PATH_PREFIX=/v1/integrations; SVC=guardian; curl "$HOST$PATH_PREFIX/$SVC/challenge"',
+            'HOST=http://localhost:7821; ENDPOINT=channel-verification-sessions; curl "$HOST/v1/$ENDPOINT"',
         }),
       ).toBe(true);
     });
 
-    test("detects guardian endpoint via heredoc-style construction", () => {
+    test("detects endpoint via heredoc-style construction", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command:
-            'url="http://localhost:3000/v1/integrations"; curl "${url}/guardian/outbound/resend"',
+            'url="http://localhost:3000/v1/channel-verification-sessions"; curl "${url}/resend"',
         }),
       ).toBe(true);
     });
 
-    test("does not false-positive when only /v1/integrations is present without guardian", () => {
+    test("does not false-positive on unrelated paths", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command: "curl http://localhost:3000/v1/integrations/other/service",
         }),
       ).toBe(false);
     });
 
-    test("does not false-positive when only guardian is present without /v1/integrations", () => {
+    test("does not false-positive when only guardian is present without verification path", () => {
       expect(
-        isGuardianControlPlaneInvocation("bash", {
+        isVerificationControlPlaneInvocation("bash", {
           command: 'echo "guardian notification sent"',
         }),
       ).toBe(false);
@@ -491,7 +465,7 @@ describe("isGuardianControlPlaneInvocation", () => {
       // URL tools pass structured URLs, not shell commands. The fragment detector
       // is bash/host_bash only. For URL tools, we rely on exact/normalized matching.
       expect(
-        isGuardianControlPlaneInvocation("network_request", {
+        isVerificationControlPlaneInvocation("network_request", {
           url: "https://api.example.com/v1/messages",
         }),
       ).toBe(false);
@@ -500,16 +474,15 @@ describe("isGuardianControlPlaneInvocation", () => {
 });
 
 // =====================================================================
-// Unit tests: enforceGuardianOnlyPolicy
+// Unit tests: enforceVerificationControlPlanePolicy
 // =====================================================================
 
-describe("enforceGuardianOnlyPolicy", () => {
-  test("non-guardian actor denied for guardian endpoint", () => {
-    const result = enforceGuardianOnlyPolicy(
+describe("enforceVerificationControlPlanePolicy", () => {
+  test("non-guardian actor denied for verification endpoint", () => {
+    const result = enforceVerificationControlPlanePolicy(
       "bash",
       {
-        command:
-          "curl http://localhost:3000/v1/integrations/guardian/outbound/start",
+        command: "curl http://localhost:3000/v1/channel-verification-sessions",
       },
       "trusted_contact",
     );
@@ -517,11 +490,11 @@ describe("enforceGuardianOnlyPolicy", () => {
     expect(result.reason).toContain("restricted to guardian users");
   });
 
-  test("unverified_channel actor denied for guardian endpoint", () => {
-    const result = enforceGuardianOnlyPolicy(
+  test("unverified_channel actor denied for verification endpoint", () => {
+    const result = enforceVerificationControlPlanePolicy(
       "network_request",
       {
-        url: "https://api.example.com/v1/integrations/guardian/challenge",
+        url: "https://api.example.com/v1/channel-verification-sessions",
       },
       "unknown",
     );
@@ -529,12 +502,11 @@ describe("enforceGuardianOnlyPolicy", () => {
     expect(result.reason).toContain("restricted to guardian users");
   });
 
-  test("guardian actor is NOT denied for guardian endpoint", () => {
-    const result = enforceGuardianOnlyPolicy(
+  test("guardian actor is NOT denied for verification endpoint", () => {
+    const result = enforceVerificationControlPlanePolicy(
       "bash",
       {
-        command:
-          "curl http://localhost:3000/v1/integrations/guardian/outbound/start",
+        command: "curl http://localhost:3000/v1/channel-verification-sessions",
       },
       "guardian",
     );
@@ -542,24 +514,22 @@ describe("enforceGuardianOnlyPolicy", () => {
     expect(result.reason).toBeUndefined();
   });
 
-  test("guardian actor role is NOT denied for guardian endpoint (explicit)", () => {
-    const result = enforceGuardianOnlyPolicy(
+  test("guardian actor role is NOT denied for verification endpoint (explicit)", () => {
+    const result = enforceVerificationControlPlanePolicy(
       "bash",
       {
-        command:
-          "curl http://localhost:3000/v1/integrations/guardian/outbound/start",
+        command: "curl http://localhost:3000/v1/channel-verification-sessions",
       },
       "guardian",
     );
     expect(result.denied).toBe(false);
   });
 
-  test("unknown actor role is denied for guardian endpoint (allowlist, not denylist)", () => {
-    const result = enforceGuardianOnlyPolicy(
+  test("unknown actor role is denied for verification endpoint (allowlist, not denylist)", () => {
+    const result = enforceVerificationControlPlanePolicy(
       "bash",
       {
-        command:
-          "curl http://localhost:3000/v1/integrations/guardian/outbound/start",
+        command: "curl http://localhost:3000/v1/channel-verification-sessions",
       },
       "some_future_role",
     );
@@ -568,7 +538,7 @@ describe("enforceGuardianOnlyPolicy", () => {
   });
 
   test("non-guardian actor is NOT denied for unrelated endpoint", () => {
-    const result = enforceGuardianOnlyPolicy(
+    const result = enforceVerificationControlPlanePolicy(
       "bash",
       {
         command: "curl http://localhost:3000/v1/messages",
@@ -579,7 +549,7 @@ describe("enforceGuardianOnlyPolicy", () => {
   });
 
   test("non-guardian actor is NOT denied for unrelated tool", () => {
-    const result = enforceGuardianOnlyPolicy(
+    const result = enforceVerificationControlPlanePolicy(
       "file_read",
       {
         path: "README.md",
@@ -591,21 +561,21 @@ describe("enforceGuardianOnlyPolicy", () => {
 });
 
 // =====================================================================
-// Integration tests: ToolExecutor guardian-only policy gate
+// Integration tests: ToolExecutor verification control-plane policy gate
 // =====================================================================
 
-describe("ToolExecutor guardian-only policy gate", () => {
+describe("ToolExecutor verification control-plane policy gate", () => {
   beforeEach(() => {
     fakeToolResult = { content: "ok", isError: false };
   });
 
-  test("non-guardian actor blocked from bash curl to guardian outbound/start", async () => {
+  test("non-guardian actor blocked from bash curl to verification sessions", async () => {
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "bash",
       {
         command:
-          "curl -X POST http://localhost:3000/v1/integrations/guardian/outbound/start",
+          "curl -X POST http://localhost:3000/v1/channel-verification-sessions",
       },
       makeContext({ trustClass: "trusted_contact" }),
     );
@@ -613,11 +583,11 @@ describe("ToolExecutor guardian-only policy gate", () => {
     expect(result.content).toContain("restricted to guardian users");
   });
 
-  test("unverified_channel actor blocked from network_request to guardian endpoint", async () => {
+  test("unverified_channel actor blocked from network_request to verification endpoint", async () => {
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "network_request",
-      { url: "https://api.example.com/v1/integrations/guardian/challenge" },
+      { url: "https://api.example.com/v1/channel-verification-sessions" },
       makeContext({ trustClass: "unknown" }),
     );
     expect(result.isError).toBe(true);
@@ -630,7 +600,7 @@ describe("ToolExecutor guardian-only policy gate", () => {
       "bash",
       {
         command:
-          "curl -X POST http://localhost:3000/v1/integrations/guardian/outbound/start",
+          "curl -X POST http://localhost:3000/v1/channel-verification-sessions",
       },
       makeContext({ trustClass: "guardian" }),
     );
@@ -638,11 +608,14 @@ describe("ToolExecutor guardian-only policy gate", () => {
     expect(result.content).toBe("ok");
   });
 
-  test("guardian trust class is NOT blocked from guardian endpoint (default)", async () => {
+  test("guardian trust class is NOT blocked from verification endpoint (default)", async () => {
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "bash",
-      { command: "curl http://localhost:3000/v1/integrations/guardian/status" },
+      {
+        command:
+          "curl http://localhost:3000/v1/channel-verification-sessions/status",
+      },
       makeContext(), // defaults to trustClass: 'guardian'
     );
     expect(result.isError).toBe(false);
@@ -671,14 +644,14 @@ describe("ToolExecutor guardian-only policy gate", () => {
     expect(result.content).toBe("ok");
   });
 
-  test("permission_denied lifecycle event is emitted on guardian policy block", async () => {
+  test("permission_denied lifecycle event is emitted on verification policy block", async () => {
     let capturedEvent: ToolPermissionDeniedEvent | undefined;
     const executor = new ToolExecutor(makePrompter());
     await executor.execute(
       "bash",
       {
         command:
-          "curl http://localhost:3000/v1/integrations/guardian/outbound/cancel",
+          "curl -X DELETE http://localhost:3000/v1/channel-verification-sessions",
       },
       makeContext({
         trustClass: "trusted_contact",
@@ -694,35 +667,35 @@ describe("ToolExecutor guardian-only policy gate", () => {
     expect(capturedEvent!.reason).toContain("restricted to guardian users");
   });
 
-  test("non-guardian blocked from web_fetch to guardian endpoint", async () => {
+  test("non-guardian blocked from web_fetch to verification endpoint", async () => {
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "web_fetch",
-      { url: "http://localhost:3000/v1/integrations/guardian/outbound/resend" },
+      { url: "http://localhost:3000/v1/channel-verification-sessions/resend" },
       makeContext({ trustClass: "trusted_contact" }),
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain("restricted to guardian users");
   });
 
-  test("non-guardian blocked from browser_navigate to guardian endpoint", async () => {
+  test("non-guardian blocked from browser_navigate to verification endpoint", async () => {
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "browser_navigate",
-      { url: "http://localhost:3000/v1/integrations/guardian/status" },
+      { url: "http://localhost:3000/v1/channel-verification-sessions/status" },
       makeContext({ trustClass: "trusted_contact" }),
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain("restricted to guardian users");
   });
 
-  test("non-guardian blocked from host_bash with guardian endpoint", async () => {
+  test("non-guardian blocked from host_bash with verification endpoint", async () => {
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "host_bash",
       {
         command:
-          "curl -X POST https://internal:8080/v1/integrations/guardian/challenge",
+          "curl -X POST https://internal:8080/v1/channel-verification-sessions",
       },
       makeContext({ trustClass: "trusted_contact" }),
     );
@@ -730,13 +703,12 @@ describe("ToolExecutor guardian-only policy gate", () => {
     expect(result.content).toContain("restricted to guardian users");
   });
 
-  test("all five guardian endpoints are blocked for non-guardian via network_request", async () => {
+  test("all verification endpoints are blocked for non-guardian via network_request", async () => {
     const endpoints = [
-      "/v1/integrations/guardian/challenge",
-      "/v1/integrations/guardian/status",
-      "/v1/integrations/guardian/outbound/start",
-      "/v1/integrations/guardian/outbound/resend",
-      "/v1/integrations/guardian/outbound/cancel",
+      "/v1/channel-verification-sessions",
+      "/v1/channel-verification-sessions/status",
+      "/v1/channel-verification-sessions/resend",
+      "/v1/channel-verification-sessions/revoke",
     ];
 
     for (const path of endpoints) {