@vellumai/assistant 0.6.5 → 0.7.0

package/src/__tests__/trusted-contact-inline-approval-integration.test.ts

@@ -51,11 +51,6 @@ mock.module("../notifications/emit-signal.js", () => ({
   registerBroadcastFn: () => {},
 }));
 
-// Mock guardian control-plane policy — not targeting control-plane by default
-mock.module("../tools/verification-control-plane-policy.js", () => ({
-  enforceVerificationControlPlanePolicy: () => ({ denied: false }),
-}));
-
 // Mock task run rules
 mock.module("../tasks/ephemeral-permissions.js", () => ({
   getTaskRunRules: () => [],
@@ -122,15 +117,13 @@ mock.module("../runtime/channel-verification-service.js", () => ({
 const deliveredReplies: Array<{
   url: string;
   payload: Record<string, unknown>;
-  bearerToken?: string;
 }> = [];
 mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async (
     url: string,
     payload: Record<string, unknown>,
-    bearerToken?: string,
   ) => {
-    deliveredReplies.push({ url, payload, bearerToken });
+    deliveredReplies.push({ url, payload });
     return { ok: true };
   },
 }));
@@ -162,25 +155,22 @@ mock.module("../config/env.js", () => ({
 import { applyCanonicalGuardianDecision } from "../approvals/guardian-decision-primitive.js";
 import type { ActorContext } from "../approvals/guardian-request-resolvers.js";
 import { getResolver } from "../approvals/guardian-request-resolvers.js";
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import {
   createCanonicalGuardianRequest,
   getCanonicalGuardianRequest,
   listCanonicalGuardianRequests,
   updateCanonicalGuardianRequest,
 } from "../memory/canonical-guardian-store.js";
-import {
-  createConversation,
-  updateConversationHostAccess,
-} from "../memory/conversation-crud.js";
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import { scopedApprovalGrants } from "../memory/schema.js";
 import { bridgeConfirmationRequestToGuardian } from "../runtime/confirmation-request-guardian-bridge.js";
 import { resolveRoutingState } from "../runtime/trust-context-resolver.js";
 import {
   TC_GRANT_WAIT_MAX_MS,
   ToolApprovalHandler,
+  waitForInlineGrant,
 } from "../tools/tool-approval-handler.js";
 import type { ToolContext, ToolLifecycleEvent } from "../tools/types.js";
 
@@ -244,16 +234,11 @@ const emitLifecycleEvent = (event: ToolLifecycleEvent) => {
 // ===========================================================================
 
 describe("(a) target flow: trusted-contact inline guardian approval end-to-end", () => {
-  const handler = new ToolApprovalHandler({
-    inlineGrantWait: { maxWaitMs: 2_000, intervalMs: 20 },
-  });
-
   beforeEach(() => {
     resetTables();
     events.length = 0;
     emittedSignals.length = 0;
     deliveredReplies.length = 0;
-    _setOverridesForTesting({});
     mockGuardianBinding = {
       id: "binding-1",
       assistantId: "self",
@@ -265,65 +250,7 @@ describe("(a) target flow: trusted-contact inline guardian approval end-to-end",
     };
   });
 
-  test("trusted contact requests tool, guardian approves mid-wait, tool executes inline", async () => {
-    const toolName = "bash";
-    const input = { command: "echo hello" };
-    const context = makeToolContext({ trustClass: "trusted_contact" });
-
-    // Schedule guardian approval after 100ms during the inline wait
-    const approvalPromise = (async () => {
-      await new Promise((r) => setTimeout(r, 100));
-      const pending = listCanonicalGuardianRequests({
-        kind: "tool_grant_request",
-        status: "pending",
-        toolName: "bash",
-      });
-      expect(pending.length).toBeGreaterThan(0);
-
-      // Verify the request has an inline_wait_active stamp
-      const freshReq = getCanonicalGuardianRequest(pending[0].id);
-      expect(freshReq?.followupState).toMatch(/^inline_wait_active:\d+$/);
-
-      await applyCanonicalGuardianDecision({
-        requestId: pending[0].id,
-        action: "approve_once",
-        actorContext: guardianActor(),
-      });
-    })();
-
-    const result = await handler.checkPreExecutionGates(
-      toolName,
-      input,
-      context,
-      "host",
-      "high",
-      Date.now(),
-      emitLifecycleEvent,
-    );
-
-    await approvalPromise;
-
-    // Tool execution should proceed inline
-    expect(result.allowed).toBe(true);
-    if (!result.allowed) return;
-    expect(result.grantConsumed).toBe(true);
-
-    // followupState should be cleared after a successful inline grant
-    const resolved = listCanonicalGuardianRequests({
-      kind: "tool_grant_request",
-    });
-    expect(resolved.length).toBe(1);
-    const freshReq = getCanonicalGuardianRequest(resolved[0].id);
-    expect(freshReq?.followupState).toBeNull();
-
-    // A guardian.question notification should have been emitted
-    const questionSignals = emittedSignals.filter(
-      (s) => s.sourceEventName === "guardian.question",
-    );
-    expect(questionSignals.length).toBeGreaterThan(0);
-  });
-
-  test("complete flow: routing state allows interactive + bridge notifies guardian + tool resumes", async () => {
+  test("complete flow: routing state allows interactive + inline grant wait works via waitForInlineGrant", async () => {
     // Step 1: Verify routing state allows interactive turns for trusted contacts
     const trustCtx: TrustContext = {
       sourceChannel: "telegram",
@@ -335,41 +262,54 @@ describe("(a) target flow: trusted-contact inline guardian approval end-to-end",
     expect(routing.promptWaitingAllowed).toBe(true);
     expect(routing.guardianRouteResolvable).toBe(true);
 
-    // Step 2: Tool invocation creates escalation + waits inline + guardian approves
-    const toolName = "bash";
-    const input = { command: "deploy" };
-    const context = makeToolContext({ trustClass: "trusted_contact" });
+    // Step 2: Verify the inline grant wait primitive works correctly end-to-end.
+    // Create a canonical request (as the escalation path would), then approve.
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_grant_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "conv-1",
+      requesterExternalUserId: "requester-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: "test-principal-id",
+      toolName: "bash",
+      inputDigest: "sha256:complete-flow",
+      expiresAt: Date.now() + 60_000,
+    });
+
+    // Stamp inline_wait_active
+    updateCanonicalGuardianRequest(req.id, {
+      followupState: "inline_wait_active:" + Date.now(),
+    });
 
     const approvalPromise = (async () => {
       await new Promise((r) => setTimeout(r, 80));
-      const pending = listCanonicalGuardianRequests({
-        kind: "tool_grant_request",
-        status: "pending",
+      await applyCanonicalGuardianDecision({
+        requestId: req.id,
+        action: "approve_once",
+        actorContext: guardianActor(),
       });
-      if (pending.length > 0) {
-        await applyCanonicalGuardianDecision({
-          requestId: pending[0].id,
-          action: "approve_once",
-          actorContext: guardianActor(),
-        });
-      }
     })();
 
-    const result = await handler.checkPreExecutionGates(
-      toolName,
-      input,
-      context,
-      "host",
-      "high",
-      Date.now(),
-      emitLifecycleEvent,
+    const waitResult = await waitForInlineGrant(
+      req.id,
+      {
+        toolName: "bash",
+        inputDigest: "sha256:complete-flow",
+        consumingRequestId: "consume-complete",
+        conversationId: "conv-1",
+        requesterExternalUserId: "requester-1",
+        executionChannel: "telegram",
+      },
+      { maxWaitMs: 2_000, intervalMs: 20 },
     );
 
     await approvalPromise;
 
-    expect(result.allowed).toBe(true);
-    if (!result.allowed) return;
-    expect(result.grantConsumed).toBe(true);
+    expect(waitResult.outcome).toBe("granted");
+    if (waitResult.outcome === "granted") {
+      expect(waitResult.grant.id).toBeDefined();
+    }
   });
 });
 
@@ -468,10 +408,6 @@ describe("(b) prompt-path flow: confirmation_request bridges to guardian", () =>
 // ===========================================================================
 
 describe("(c) no-binding flow: trusted contact fails fast without guardian binding", () => {
-  const shortHandler = new ToolApprovalHandler({
-    inlineGrantWait: { maxWaitMs: 100, intervalMs: 20 },
-  });
-
   beforeEach(() => {
     resetTables();
     events.length = 0;
@@ -493,43 +429,6 @@ describe("(c) no-binding flow: trusted contact fails fast without guardian bindi
     expect(state.promptWaitingAllowed).toBe(false);
   });
 
-  test("tool escalation returns generic denial (no dead-end wait) without binding", async () => {
-    const toolName = "bash";
-    const input = { command: "ls" };
-    const context = makeToolContext({
-      trustClass: "trusted_contact",
-      executionChannel: "telegram",
-    });
-
-    const start = Date.now();
-    const result = await shortHandler.checkPreExecutionGates(
-      toolName,
-      input,
-      context,
-      "host",
-      "high",
-      Date.now(),
-      emitLifecycleEvent,
-    );
-    const elapsed = Date.now() - start;
-
-    expect(result.allowed).toBe(false);
-    if (result.allowed) return;
-
-    // Should return the generic guardian approval message, not enter inline wait
-    expect(result.result.content).toContain("guardian approval");
-
-    // No canonical tool_grant_request should have been created (no binding)
-    const requests = listCanonicalGuardianRequests({
-      kind: "tool_grant_request",
-      status: "pending",
-    });
-    expect(requests.length).toBe(0);
-
-    // Should complete nearly instantly, not block for the full wait budget
-    expect(elapsed).toBeLessThan(500);
-  });
-
   test("bridge skips when no guardian binding exists for channel", () => {
     const canonicalRequest = createCanonicalGuardianRequest({
       id: `req-nobinding-${Date.now()}`,
@@ -763,7 +662,7 @@ describe("(e) guardian-only prompt delivery invariant", () => {
 // ===========================================================================
 
 describe("(f) timeout/stale flow: stale guardian decision after inline wait timeout", () => {
-  const handler = new ToolApprovalHandler({
+  const _handler = new ToolApprovalHandler({
     inlineGrantWait: { maxWaitMs: 100, intervalMs: 20 },
   });
 
@@ -784,48 +683,59 @@ describe("(f) timeout/stale flow: stale guardian decision after inline wait time
   });
 
   test("inline wait timeout clears followupState so later approval sends retry notification", async () => {
-    const toolName = "bash";
-    const input = { command: "echo stale" };
-    const context = makeToolContext({ trustClass: "trusted_contact" });
+    // Test via waitForInlineGrant directly: timeout clears followupState so
+    // a later guardian approval sends the retry notification.
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_grant_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "conv-1",
+      requesterExternalUserId: "requester-1",
+      requesterChatId: "requester-chat-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: "test-principal-id",
+      toolName: "bash",
+      inputDigest: "sha256:timeout-stale",
+      expiresAt: Date.now() + 60_000,
+    });
 
-    // Let the tool invocation time out (no guardian approval within 100ms)
-    const result = await handler.checkPreExecutionGates(
-      toolName,
-      input,
-      context,
-      "host",
-      "high",
-      Date.now(),
-      emitLifecycleEvent,
-    );
+    // Stamp inline_wait_active (as checkPreExecutionGates would do)
+    updateCanonicalGuardianRequest(req.id, {
+      followupState: "inline_wait_active:" + Date.now(),
+    });
 
-    expect(result.allowed).toBe(false);
-    if (result.allowed) return;
-    expect(result.result.content).toContain(
-      "guardian approval was not received in time",
+    // Let the inline wait time out (short 100ms budget)
+    const waitResult = await waitForInlineGrant(
+      req.id,
+      {
+        toolName: "bash",
+        inputDigest: "sha256:timeout-stale",
+        consumingRequestId: "consume-timeout",
+        conversationId: "conv-1",
+        requesterExternalUserId: "requester-1",
+        executionChannel: "telegram",
+      },
+      { maxWaitMs: 100, intervalMs: 20 },
     );
 
-    // After timeout, the followupState should be cleared (null)
-    const pending = listCanonicalGuardianRequests({
-      kind: "tool_grant_request",
-      status: "pending",
-    });
-    expect(pending.length).toBe(1);
+    expect(waitResult.outcome).toBe("timeout");
+
+    // waitForInlineGrant does NOT clear followupState — the caller (checkPreExecutionGates) does.
+    // For this test, manually clear it to simulate what checkPreExecutionGates does after timeout.
+    updateCanonicalGuardianRequest(req.id, { followupState: null });
 
-    const freshReq = getCanonicalGuardianRequest(pending[0].id);
-    // followupState should be null after timeout — the inline wait cleared it
+    // After followupState is cleared, later guardian approval sends retry notification
+    const freshReq = getCanonicalGuardianRequest(req.id);
     expect(freshReq?.followupState).toBeNull();
 
-    // Now simulate guardian approving after the timeout
     const approvalResult = await applyCanonicalGuardianDecision({
-      requestId: pending[0].id,
+      requestId: req.id,
       action: "approve_once",
       actorContext: guardianActor(),
       channelDeliveryContext: {
         replyCallbackUrl: "http://localhost:3000/reply",
         guardianChatId: "guardian-chat-1",
         assistantId: "self",
-        bearerToken: "test-token",
       },
     });
     expect(approvalResult.applied).toBe(true);
@@ -878,7 +788,6 @@ describe("(f) timeout/stale flow: stale guardian decision after inline wait time
         replyCallbackUrl: "http://localhost:3000/reply",
         guardianChatId: "guardian-chat-1",
         assistantId: "self",
-        bearerToken: "test-token",
       },
     });
     expect(approvalResult.applied).toBe(true);
@@ -924,7 +833,6 @@ describe("(f) timeout/stale flow: stale guardian decision after inline wait time
         replyCallbackUrl: "http://localhost:3000/reply",
         guardianChatId: "guardian-chat-1",
         assistantId: "self",
-        bearerToken: "test-token",
       },
     });
     expect(approvalResult.applied).toBe(true);
@@ -940,70 +848,77 @@ describe("(f) timeout/stale flow: stale guardian decision after inline wait time
   });
 
   test("denied inline wait produces explicit denial (no false success)", async () => {
-    const toolName = "bash";
-    const input = { command: "rm -rf /" };
-    const context = makeToolContext({ trustClass: "trusted_contact" });
+    // Test via waitForInlineGrant directly: rejection produces "denied" outcome.
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_grant_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "conv-1",
+      requesterExternalUserId: "requester-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: "test-principal-id",
+      toolName: "bash",
+      inputDigest: "sha256:denied-f",
+      expiresAt: Date.now() + 60_000,
+    });
 
-    // Schedule guardian rejection after 80ms
+    // Schedule rejection after 80ms
     const rejectionPromise = (async () => {
       await new Promise((r) => setTimeout(r, 80));
-      const pending = listCanonicalGuardianRequests({
-        kind: "tool_grant_request",
-        status: "pending",
-        toolName: "bash",
+      await applyCanonicalGuardianDecision({
+        requestId: req.id,
+        action: "reject",
+        actorContext: guardianActor(),
       });
-      if (pending.length > 0) {
-        await applyCanonicalGuardianDecision({
-          requestId: pending[0].id,
-          action: "reject",
-          actorContext: guardianActor(),
-        });
-      }
     })();
 
-    const wideHandler = new ToolApprovalHandler({
-      inlineGrantWait: { maxWaitMs: 2_000, intervalMs: 20 },
-    });
-    const result = await wideHandler.checkPreExecutionGates(
-      toolName,
-      input,
-      context,
-      "host",
-      "high",
-      Date.now(),
-      emitLifecycleEvent,
+    const waitResult = await waitForInlineGrant(
+      req.id,
+      {
+        toolName: "bash",
+        inputDigest: "sha256:denied-f",
+        consumingRequestId: "consume-denied-f",
+        conversationId: "conv-1",
+        requesterExternalUserId: "requester-1",
+        executionChannel: "telegram",
+      },
+      { maxWaitMs: 2_000, intervalMs: 20 },
     );
 
     await rejectionPromise;
 
-    expect(result.allowed).toBe(false);
-    if (result.allowed) return;
-    expect(result.result.content).toContain("guardian rejected the request");
-    expect(result.result.isError).toBe(true);
+    expect(waitResult.outcome).toBe("denied");
   });
 
-  test("timeout produces explicit timeout message (no false success)", async () => {
-    const toolName = "bash";
-    const input = { command: "curl example.com" };
-    const context = makeToolContext({ trustClass: "trusted_contact" });
+  test("timeout produces explicit timeout outcome (no false success)", async () => {
+    // Test via waitForInlineGrant directly: timeout produces "timeout" outcome.
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_grant_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "conv-1",
+      requesterExternalUserId: "requester-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: "test-principal-id",
+      toolName: "bash",
+      inputDigest: "sha256:timeout-f",
+      expiresAt: Date.now() + 60_000,
+    });
 
-    const result = await handler.checkPreExecutionGates(
-      toolName,
-      input,
-      context,
-      "host",
-      "high",
-      Date.now(),
-      emitLifecycleEvent,
+    const waitResult = await waitForInlineGrant(
+      req.id,
+      {
+        toolName: "bash",
+        inputDigest: "sha256:timeout-f",
+        consumingRequestId: "consume-timeout-f",
+        conversationId: "conv-1",
+        requesterExternalUserId: "requester-1",
+        executionChannel: "telegram",
+      },
+      { maxWaitMs: 100, intervalMs: 20 },
     );
 
-    expect(result.allowed).toBe(false);
-    if (result.allowed) return;
-    expect(result.result.content).toContain(
-      "guardian approval was not received in time",
-    );
-    expect(result.result.content).toContain("request code:");
-    expect(result.result.isError).toBe(true);
+    expect(waitResult.outcome).toBe("timeout");
   });
 });
 
@@ -1126,146 +1041,55 @@ describe("cross-milestone integration checks", () => {
     expect(result.grantConsumed).toBeUndefined();
   });
 
-  test("M4: abort signal during inline wait clears followupState for later retries", async () => {
-    const handler = new ToolApprovalHandler({
-      inlineGrantWait: { maxWaitMs: 5_000, intervalMs: 20 },
+  test("M4: abort signal during inline wait produces aborted outcome", async () => {
+    // Test via waitForInlineGrant directly: abort signal produces "aborted" outcome.
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_grant_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "conv-1",
+      requesterExternalUserId: "requester-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: "test-principal-id",
+      toolName: "bash",
+      inputDigest: "sha256:abort-m4",
+      expiresAt: Date.now() + 60_000,
     });
-    const toolName = "bash";
-    const input = { command: "aborted-command" };
-    const controller = new AbortController();
-    const context = makeToolContext({
-      trustClass: "trusted_contact",
-      signal: controller.signal,
+
+    // Stamp inline_wait_active
+    updateCanonicalGuardianRequest(req.id, {
+      followupState: "inline_wait_active:" + Date.now(),
     });
 
+    const controller = new AbortController();
     // Abort after 100ms
     setTimeout(() => controller.abort(), 100);
 
-    const result = await handler.checkPreExecutionGates(
-      toolName,
-      input,
-      context,
-      "host",
-      "high",
-      Date.now(),
-      emitLifecycleEvent,
+    const start = Date.now();
+    const waitResult = await waitForInlineGrant(
+      req.id,
+      {
+        toolName: "bash",
+        inputDigest: "sha256:abort-m4",
+        consumingRequestId: "consume-abort-m4",
+        conversationId: "conv-1",
+        requesterExternalUserId: "requester-1",
+        executionChannel: "telegram",
+      },
+      { maxWaitMs: 5_000, intervalMs: 20, signal: controller.signal },
     );
+    const elapsed = Date.now() - start;
 
-    expect(result.allowed).toBe(false);
-    if (result.allowed) return;
-    expect(result.result.content).toBe("Cancelled");
+    expect(waitResult.outcome).toBe("aborted");
+    // Should exit promptly after the abort signal
+    expect(elapsed).toBeLessThan(1_000);
 
-    // The canonical request should exist but followupState should be cleared
-    const pending = listCanonicalGuardianRequests({
-      kind: "tool_grant_request",
-      status: "pending",
-    });
-    expect(pending.length).toBe(1);
+    // Simulate what checkPreExecutionGates does after abort: clear followupState
+    updateCanonicalGuardianRequest(req.id, { followupState: null });
 
-    const freshReq = getCanonicalGuardianRequest(pending[0].id);
-    // After abort, followupState should be cleared so a later guardian
-    // approval sends the retry notification
+    // After followupState is cleared, a later guardian approval should send retry notification
+    const freshReq = getCanonicalGuardianRequest(req.id);
     expect(freshReq?.followupState).toBeNull();
   });
 });
 
-describe("(g) v2 trusted-contact flow: model-mediated guardian consent", () => {
-  const handler = new ToolApprovalHandler({
-    inlineGrantWait: { maxWaitMs: 100, intervalMs: 20 },
-  });
-
-  beforeEach(() => {
-    resetTables();
-    events.length = 0;
-    emittedSignals.length = 0;
-    deliveredReplies.length = 0;
-    _setOverridesForTesting({ "permission-controls-v2": true });
-    mockGuardianBinding = {
-      id: "binding-1",
-      assistantId: "self",
-      channel: "telegram",
-      guardianExternalUserId: "guardian-1",
-      guardianDeliveryChatId: "guardian-chat-1",
-      guardianPrincipalId: "test-principal-id",
-      status: "active",
-    };
-  });
-
-  test("trusted-contact host tools do not create tool_grant_request rows under v2", async () => {
-    const conv = createConversation("trusted contact v2 host gate");
-    const result = await handler.checkPreExecutionGates(
-      "bash",
-      { command: "ls" },
-      makeToolContext({
-        trustClass: "trusted_contact",
-        conversationId: conv.id,
-      }),
-      "host",
-      "high",
-      Date.now(),
-      emitLifecycleEvent,
-    );
-
-    expect(result.allowed).toBe(false);
-    if (result.allowed) return;
-    expect(result.result.content).toContain(
-      "computer access is not enabled for this conversation",
-    );
-
-    const requests = listCanonicalGuardianRequests({
-      kind: "tool_grant_request",
-      status: "pending",
-    });
-    expect(requests).toHaveLength(0);
-    expect(emittedSignals).toHaveLength(0);
-  });
-
-  test("trusted-contact host tools run inline once the guardian has already enabled computer access for the conversation", async () => {
-    const conv = createConversation("trusted contact v2 host access enabled");
-    updateConversationHostAccess(conv.id, true);
-
-    const result = await handler.checkPreExecutionGates(
-      "bash",
-      { command: "ls" },
-      makeToolContext({
-        trustClass: "trusted_contact",
-        conversationId: conv.id,
-      }),
-      "host",
-      "high",
-      Date.now(),
-      emitLifecycleEvent,
-    );
-
-    expect(result.allowed).toBe(true);
-  });
-
-  test("confirmation_request guardian bridge is disabled for trusted contacts under v2", () => {
-    const canonicalRequest = createCanonicalGuardianRequest({
-      id: `req-v2-skip-${Date.now()}`,
-      kind: "tool_approval",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-v2-skip",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      status: "pending",
-      expiresAt: Date.now() + 5 * 60_000,
-    });
-
-    const result = bridgeConfirmationRequestToGuardian({
-      canonicalRequest,
-      trustContext: makeTrustedContactTrustContext(),
-      conversationId: "conv-v2-skip",
-      toolName: "bash",
-    });
-
-    expect("skipped" in result && result.skipped).toBe(true);
-    if ("skipped" in result) {
-      expect(result.reason).toBe("v2_model_mediated");
-    }
-    expect(emittedSignals).toHaveLength(0);
-  });
-});