@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/credential-prompt-route.test.ts

@@ -117,6 +117,7 @@ function slackResult(
 
 type PromptResponse = {
   ok: boolean;
+  cancelled?: boolean;
   error?: string;
   service?: string;
   field?: string;
@@ -388,6 +389,74 @@ describe("credentials/prompt route", () => {
     expect(capturedMetadata!.allowedDomains).toBeUndefined();
   });
 
+  test("flags an explicit user cancel distinctly from a failure", async () => {
+    /**
+     * A user dismissing the secure prompt is a valid flow, not an error. The
+     * route must mark it `cancelled: true` (so the CLI can exit with the
+     * user-interrupt convention) and must not persist anything.
+     */
+    // GIVEN the prompt resolves with no value because the user cancelled
+    secretResult = { value: null, delivery: "store", reason: "cancelled" };
+
+    // WHEN the route handles the prompt
+    const result = (await promptRoute!.handler({
+      body: { service: "stripe", field: "api_key", label: "Stripe API Key" },
+    })) as PromptResponse;
+
+    // THEN the outcome is flagged as a cancel, not a generic error
+    expect(result.ok).toBe(false);
+    expect(result.cancelled).toBe(true);
+    expect(result.error).toBe("Cancelled by the user");
+
+    // AND nothing was written to secure storage
+    expect(secureKeyWrites).toEqual([]);
+  });
+
+  test("reports a timeout as a failure, not a cancel", async () => {
+    /**
+     * A prompt that times out (no response in the permission window) is a real
+     * failure — it must NOT be flagged as a user cancel, so the CLI keeps the
+     * error exit code for it.
+     */
+    // GIVEN the prompt resolves with no value because it timed out
+    secretResult = { value: null, delivery: "store", reason: "timed_out" };
+
+    // WHEN the route handles the prompt
+    const result = (await promptRoute!.handler({
+      body: { service: "stripe", field: "api_key", label: "Stripe API Key" },
+    })) as PromptResponse;
+
+    // THEN it is a plain failure with no cancel flag
+    expect(result.ok).toBe(false);
+    expect(result.cancelled).toBeUndefined();
+    expect(result.error).toBe("The credential prompt timed out");
+  });
+
+  test("reports an undeliverable prompt as a failure, not a cancel", async () => {
+    /**
+     * When no connected client can render a secure prompt the value is null due
+     * to a delivery failure — this stays a hard error and is never a cancel.
+     */
+    // GIVEN the prompt could not be delivered to any client
+    secretResult = {
+      value: null,
+      delivery: "store",
+      error: "unsupported_channel",
+    };
+
+    // WHEN the route handles the prompt
+    const result = (await promptRoute!.handler({
+      body: { service: "stripe", field: "api_key", label: "Stripe API Key" },
+    })) as PromptResponse;
+
+    // THEN it is a plain failure with no cancel flag
+    expect(result.ok).toBe(false);
+    expect(result.cancelled).toBeUndefined();
+    expect(result.error).toBe(
+      "No connected client supports secure credential entry",
+    );
+  });
+
   test("forwards provided allowed-tools/-domains to credential metadata", async () => {
     /**
      * When the caller does supply policy flags they must reach the metadata

package/src/__tests__/credential-security-invariants.test.ts

@@ -215,19 +215,17 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/conversation-process.ts", // masked provider key display
       "daemon/handlers/config-model.ts", // masked provider key display
       "providers/speech-to-text/resolve.ts", // STT provider API key lookup
+      "calls/telephony-tts-capability.ts", // TTS provider API key availability check (presence only)
       "credential-execution/ces-runtime.ts", // CES runtime owns the daemon CES connection (setCesClient/onCesClientChanged/reconnect wiring at startup)
-      "daemon/daemon-skill-host.ts", // SkillHost secureKeys facet adapter (delegates to getProviderKeyAsync)
       "runtime/routes/credential-prompt-routes.ts", // Route for secure credential prompt (stores secret via setSecureKeyAsync)
       "runtime/routes/credential-routes.ts", // CLI credential management routes (CLI-migrated to IPC)
       "runtime/routes/sanity-routes.ts", // Sanity connect/discover routes (reads stored api_token from credential store)
       "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
-      "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup
       "tts/providers/xai-provider.ts", // xAI TTS API key lookup
       "credential-health/credential-health-service.ts", // credential health check reads access tokens for liveness pings
-      "ipc/skill-routes/providers.ts", // skill IPC route exposes provider key lookup to hosted skills
       "runtime/routes/avatar-routes.ts", // avatar generate route reads platform_base_url from credential store
       "cli/commands/keys.ts", // CLI provider key management
       "cli/commands/oauth/connect.ts", // CLI OAuth connect stored-secret verification

package/src/__tests__/db-drop-messages-fts.test.ts

@@ -0,0 +1,115 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../persistence/db-connection.js";
+import { createMessagesFts } from "../persistence/migrations/116-messages-fts.js";
+import { migrateDropMessagesFts } from "../persistence/migrations/313-drop-messages-fts.js";
+import * as schema from "../persistence/schema/index.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrapMessagesTables(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE messages (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      metadata TEXT
+    );
+
+    INSERT INTO conversations (id, title, created_at, updated_at)
+    VALUES ('conv-1', 'Notes', 1000, 1000);
+  `);
+}
+
+/**
+ * Every `messages_fts`-prefixed entry in sqlite_schema: the vtable, its FTS5
+ * shadow tables (_config/_docsize/_content/_idx/_data), and the per-row
+ * triggers (_ai/_ad/_au) all share the prefix.
+ */
+function ftsSchemaObjects(raw: Database): string[] {
+  const rows = raw
+    .query(
+      `SELECT name FROM sqlite_schema WHERE name LIKE 'messages\\_fts%' ESCAPE '\\' ORDER BY name`,
+    )
+    .all() as Array<{ name: string }>;
+  return rows.map((row) => row.name);
+}
+
+function insertMessage(raw: Database, id: string, content: string): void {
+  raw
+    .query(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, 'conv-1', 'user', ?, 1000)`,
+    )
+    .run(id, content);
+}
+
+describe("migrateDropMessagesFts", () => {
+  test("drops the FTS vtable, shadow tables, and per-row triggers", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapMessagesTables(raw);
+    createMessagesFts(db);
+    insertMessage(raw, "m-1", "the flux capacitor needs recalibration");
+    expect(ftsSchemaObjects(raw).length).toBeGreaterThan(0);
+
+    migrateDropMessagesFts(db);
+
+    expect(ftsSchemaObjects(raw)).toEqual([]);
+  });
+
+  test("message writes perform no FTS work after the drop", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapMessagesTables(raw);
+    createMessagesFts(db);
+    insertMessage(raw, "m-1", "indexed before the drop");
+
+    migrateDropMessagesFts(db);
+
+    // Insert, update, and delete must all succeed as plain row operations —
+    // a leftover trigger would throw against the missing vtable.
+    insertMessage(raw, "m-2", "written after the drop");
+    raw
+      .query(`UPDATE messages SET content = ? WHERE id = ?`)
+      .run("updated after the drop", "m-2");
+    raw.query(`DELETE FROM messages WHERE id = ?`).run("m-1");
+
+    const rows = raw
+      .query(`SELECT id, content FROM messages ORDER BY id`)
+      .all() as Array<{ id: string; content: string }>;
+    expect(rows).toEqual([{ id: "m-2", content: "updated after the drop" }]);
+  });
+
+  test("is idempotent, including on a database that never had messages_fts", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapMessagesTables(raw);
+    createMessagesFts(db);
+
+    migrateDropMessagesFts(db);
+    migrateDropMessagesFts(db);
+    expect(ftsSchemaObjects(raw)).toEqual([]);
+
+    const fresh = createTestDb();
+    bootstrapMessagesTables(getSqliteFrom(fresh));
+    migrateDropMessagesFts(fresh);
+    expect(ftsSchemaObjects(getSqliteFrom(fresh))).toEqual([]);
+  });
+});

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -5,8 +5,7 @@
  * 1. Verification control messages (code replies, /start gv_<token>) never invoke
  *    the normal message pipeline — they produce only template-driven copy.
  * 2. Call session mode metadata is persisted correctly for guardian verification calls.
- * 3. TwiML generation includes guardian verification parameters when relevant.
- * 4. Channel verification reply templates are non-empty and deterministic.
+ * 3. Channel verification reply templates are non-empty and deterministic.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -54,8 +53,6 @@ mock.module("../daemon/process-message.js", () => ({
 // Imports (after mocks)
 // ---------------------------------------------------------------------------
 
-import type { TwilioRelaySpeechConfig } from "../calls/twilio-routes.js";
-import { generateTwiML } from "../calls/twilio-routes.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { handleChannelInbound } from "../runtime/routes/inbound-message-handler.js";
 import {
@@ -110,64 +107,6 @@ describe("Channel verification reply templates", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// TwiML generation: parameter propagation
-// ---------------------------------------------------------------------------
-
-describe("TwiML parameter propagation", () => {
-  const defaultProfile = {
-    language: "en-US",
-    ttsProvider: "google",
-    voice: "en-US-Standard-A",
-  };
-
-  const defaultSpeechConfig: TwilioRelaySpeechConfig = {
-    transcriptionProvider: "deepgram",
-    speechModel: undefined,
-    hints: undefined,
-    interruptSensitivity: "low",
-  };
-
-  test("includes verificationSessionId as Parameter when provided", () => {
-    const twiml = generateTwiML(
-      "session-123",
-      "wss://example.com/v1/calls/relay",
-      null,
-      defaultProfile,
-      defaultSpeechConfig,
-      undefined,
-      { verificationSessionId: "gv-session-456" },
-    );
-    expect(twiml).toContain('name="verificationSessionId"');
-    expect(twiml).toContain('value="gv-session-456"');
-    expect(twiml).toContain("<Parameter");
-  });
-
-  test("omits Parameter elements when no custom parameters", () => {
-    const twiml = generateTwiML(
-      "session-123",
-      "wss://example.com/v1/calls/relay",
-      null,
-      defaultProfile,
-      defaultSpeechConfig,
-    );
-    expect(twiml).not.toContain("<Parameter");
-  });
-
-  test("omits Parameter elements when custom parameters is undefined", () => {
-    const twiml = generateTwiML(
-      "session-123",
-      "wss://example.com/v1/calls/relay",
-      null,
-      defaultProfile,
-      defaultSpeechConfig,
-      "token123",
-      undefined,
-    );
-    expect(twiml).not.toContain("<Parameter");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Call session mode metadata: createCallSession persists callMode
 // ---------------------------------------------------------------------------

package/src/__tests__/edit-propagation.test.ts

@@ -21,10 +21,10 @@ mock.module("../util/logger.js", () => ({
 import { readSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 import { addMessage } from "../persistence/conversation-crud.js";
 import { getConversationByKey } from "../persistence/conversation-key-store.js";
-import { getDb } from "../persistence/db-connection.js";
+import { getDb, getMemoryDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { linkMessage, recordInbound } from "../persistence/delivery-crud.js";
-import { messages } from "../persistence/schema/index.js";
+import { memoryJobs, messages } from "../persistence/schema/index.js";
 import { handleEditIntercept } from "../runtime/routes/inbound-stages/edit-intercept.js";
 
 await initializeDb();
@@ -35,6 +35,25 @@ function resetTables(): void {
   db.run("DELETE FROM messages");
   db.run("DELETE FROM conversation_keys");
   db.run("DELETE FROM conversations");
+  // memory_jobs lives in the dedicated memory connection.
+  getMemoryDb()!.run("DELETE FROM memory_jobs");
+}
+
+function lexicalIndexJobMessageIds(): string[] {
+  return getMemoryDb()!
+    .select({ payload: memoryJobs.payload })
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, "index_message_lexical"))
+    .all()
+    .map((r) => {
+      try {
+        return (
+          (JSON.parse(r.payload) as { messageId?: string }).messageId ?? ""
+        );
+      } catch {
+        return "";
+      }
+    });
 }
 
 interface SeededFixture {
@@ -276,6 +295,41 @@ describe("Slack edit propagation", () => {
     expect(after.content).toBe(before.content);
     // No metadata mutation either -- the write is fully skipped.
     expect(after.metadata).toBe(before.metadata);
+
+    // A no-op edit changes no searchable text, so it must NOT enqueue a lexical
+    // reindex.
+    expect(lexicalIndexJobMessageIds()).not.toContain(seeded.messageId);
+  });
+
+  test("a content-changing edit enqueues a lexical reindex for the message", async () => {
+    // Regression: channel edits update the row in-place via
+    // updateMessageContentAndMetadata / updateMessageContent, bypassing
+    // onMessagePersisted. The lexical index must be refreshed so the old Qdrant
+    // point does not go stale against the edited (FTS-updated) content.
+    const seeded = await seedSlackMessage({
+      conversationExternalId: "C0123CHANNEL",
+      channelTs: "1234.5678",
+      initialContent: "original text",
+    });
+
+    // The seed used skipIndexing, so no lexical job exists yet.
+    expect(lexicalIndexJobMessageIds()).not.toContain(seeded.messageId);
+
+    await handleEditIntercept({
+      sourceChannel: "slack",
+      conversationExternalId: seeded.conversationExternalId,
+      externalMessageId: nextEditEventId(),
+      sourceMessageId: seeded.channelTs,
+      canonicalAssistantId: "self",
+      assistantId: "self",
+      content: "edited searchable text",
+    });
+
+    expect(readMessageRow(seeded.messageId).content).toBe(
+      "edited searchable text",
+    );
+    // The edit reindexed the message into the lexical index.
+    expect(lexicalIndexJobMessageIds()).toContain(seeded.messageId);
   });
 
   // The lookup retries 5 times with 2s backoff (~10s total) before giving up,

package/src/__tests__/empty-state-greeting-cache.test.ts

@@ -56,6 +56,15 @@ describe("empty-state greeting cache", () => {
     expect(getCachedEmptyStateGreeting()).toBe("hey there");
   });
 
+  test("keeps cached greetings separate by timezone scope", () => {
+    setCachedEmptyStateGreeting("hey eastern", "America/New_York");
+    setCachedEmptyStateGreeting("hey central", "America/Chicago");
+
+    expect(getCachedEmptyStateGreeting("America/New_York")).toBe("hey eastern");
+    expect(getCachedEmptyStateGreeting("America/Chicago")).toBe("hey central");
+    expect(getCachedEmptyStateGreeting("Europe/Skopje")).toBeNull();
+  });
+
   test("returns null once the TTL is exceeded", () => {
     setCachedEmptyStateGreeting("stale");
     checkpointStore.set(

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

@@ -75,21 +75,22 @@ mock.module("../config/loader.js", () => ({
 }));
 
 // Mock Twilio provider
+class MockTwilioVoiceProvider {
+  static getAuthToken() {
+    return "mock-auth-token";
+  }
+  static verifyWebhookSignature() {
+    return true;
+  }
+  async initiateCall() {
+    return { callSid: "CA_mock_sid" };
+  }
+  async endCall() {
+    return;
+  }
+}
 mock.module("../calls/twilio-provider.js", () => ({
-  TwilioConversationRelayProvider: class {
-    static getAuthToken() {
-      return "mock-auth-token";
-    }
-    static verifyWebhookSignature() {
-      return true;
-    }
-    async initiateCall() {
-      return { callSid: "CA_mock_sid" };
-    }
-    async endCall() {
-      return;
-    }
-  },
+  TwilioVoiceProvider: MockTwilioVoiceProvider,
 }));
 
 mock.module("../security/secure-keys.js", () => ({
@@ -268,22 +269,6 @@ describe("gateway-only ingress enforcement", () => {
       expect(body.error.code).toBe("GONE");
     });
 
-    test("POST /webhooks/twilio/connect-action returns 410", async () => {
-      const res = await fetch(
-        `http://127.0.0.1:${port}/webhooks/twilio/connect-action`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/x-www-form-urlencoded" },
-          body: makeFormBody({ CallSid: "CA123" }),
-        },
-      );
-      expect(res.status).toBe(410);
-      const body = (await res.json()) as {
-        error: { code: string; message: string };
-      };
-      expect(body.error.code).toBe("GONE");
-    });
-
     test("POST /v1/calls/twilio/voice-webhook returns 410", async () => {
       const res = await fetch(
         `http://127.0.0.1:${port}/v1/calls/twilio/voice-webhook`,
@@ -357,23 +342,6 @@ describe("gateway-only ingress enforcement", () => {
       expect(res.status).not.toBe(410);
     });
 
-    test("POST /v1/internal/twilio/connect-action is NOT blocked", async () => {
-      const res = await fetch(
-        `http://127.0.0.1:${port}/v1/internal/twilio/connect-action`,
-        {
-          method: "POST",
-          headers: {
-            ...GATEWAY_AUTH_HEADERS,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            params: { CallSid: "CA123" },
-          }),
-        },
-      );
-      expect(res.status).not.toBe(410);
-    });
-
     test("POST /v1/internal/oauth/callback is NOT blocked", async () => {
       const res = await fetch(
         `http://127.0.0.1:${port}/v1/internal/oauth/callback`,
@@ -394,69 +362,6 @@ describe("gateway-only ingress enforcement", () => {
     });
   });
 
-  // ── Relay WebSocket upgrade ───────────────────
-
-  describe("relay WebSocket upgrade", () => {
-    test("blocks non-private-network origin", async () => {
-      // The peer address (127.0.0.1) passes the private network check,
-      // but the external Origin header triggers the secondary defense-in-depth block.
-      const res = await fetch(
-        `http://127.0.0.1:${port}/v1/calls/relay?callSessionId=sess-123`,
-        {
-          headers: {
-            Upgrade: "websocket",
-            Connection: "Upgrade",
-            Origin: "https://external.example.com",
-            "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==",
-            "Sec-WebSocket-Version": "13",
-          },
-        },
-      );
-      expect(res.status).toBe(403);
-      const body = (await res.json()) as {
-        error: { code: string; message: string };
-      };
-      expect(body.error.code).toBe("FORBIDDEN");
-      expect(body.error.message).toContain("Direct relay access disabled");
-    });
-
-    test("allows request with no origin header (private network peer)", async () => {
-      // Without an origin header, isPrivateNetworkOrigin returns true.
-      // The peer address (127.0.0.1) passes the private network peer check.
-      const res = await fetch(
-        `http://127.0.0.1:${port}/v1/calls/relay?callSessionId=sess-123`,
-        {
-          headers: {
-            Upgrade: "websocket",
-            Connection: "Upgrade",
-            "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==",
-            "Sec-WebSocket-Version": "13",
-          },
-        },
-      );
-      // Should NOT be 403 — WebSocket upgrade may or may not succeed
-      // depending on test environment, but the gateway guard should pass.
-      expect(res.status).not.toBe(403);
-    });
-
-    test("allows localhost origin from loopback peer", async () => {
-      const res = await fetch(
-        `http://127.0.0.1:${port}/v1/calls/relay?callSessionId=sess-123`,
-        {
-          headers: {
-            Upgrade: "websocket",
-            Connection: "Upgrade",
-            Origin: "http://127.0.0.1:3000",
-            "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==",
-            "Sec-WebSocket-Version": "13",
-          },
-        },
-      );
-      // Should NOT be 403
-      expect(res.status).not.toBe(403);
-    });
-  });
-
   // ── Media-stream WebSocket upgrade ─────────────────────────────────
 
   describe("media-stream WebSocket upgrade", () => {

package/src/__tests__/guardian-expiry-notifier.test.ts

@@ -90,6 +90,7 @@ function makeRequest(
     riskLevel: null,
     activityText: null,
     executionTarget: null,
+    requesterSignals: null,
     status: "expired",
     answerText: null,
     decidedByExternalUserId: null,

package/src/__tests__/guardian-question-mode.test.ts

@@ -9,10 +9,12 @@ import {
   buildGuardianRequestCodeInstruction,
   hasGuardianRequestCodeInstruction,
   parseGuardianQuestionPayload,
+  parseInteractiveApprovalPayload,
   resolveGuardianInstructionModeForRequest,
   resolveGuardianInstructionModeFromFields,
   resolveGuardianQuestionInstructionMode,
   stripConflictingGuardianRequestInstructions,
+  stripGuardianRequestCodeInstructions,
 } from "../notifications/guardian-question-mode.js";
 
 describe("guardian-question-mode", () => {
@@ -228,4 +230,59 @@ describe("guardian-question-mode", () => {
       ),
     ).toBe("");
   });
+
+  test("stripGuardianRequestCodeInstructions removes both-mode directives and bare code mentions", () => {
+    const text = [
+      "Alice is asking to run ls /tmp.",
+      "Approval code: A1B2C3",
+      'Reference code: A1B2C3. Reply "A1B2C3 approve" or "A1B2C3 reject".',
+      'Reply "A1B2C3 <your answer>".',
+    ].join("\n");
+
+    expect(stripGuardianRequestCodeInstructions(text, "A1B2C3")).toBe(
+      "Alice is asking to run ls /tmp.",
+    );
+  });
+
+  test("stripGuardianRequestCodeInstructions leaves unrelated text and other codes intact", () => {
+    const text = 'Approval code: ZZZZZZ. Reply "A1B2C3 approve" if you agree.';
+    expect(stripGuardianRequestCodeInstructions(text, "A1B2C3")).toBe(text);
+  });
+
+  test("parseInteractiveApprovalPayload accepts approval-mode payloads with a requestId", () => {
+    expect(
+      parseInteractiveApprovalPayload({
+        requestKind: "tool_grant_request",
+        requestId: "req-1",
+        requestCode: "A1B2C3",
+        questionText: "Allow host bash?",
+        toolName: "host_bash",
+      }),
+    ).not.toBeNull();
+  });
+
+  test("parseInteractiveApprovalPayload rejects answer-mode and unparseable payloads", () => {
+    // Answer mode: free-text questions get no Approve/Reject buttons.
+    expect(
+      parseInteractiveApprovalPayload({
+        requestKind: "pending_question",
+        requestId: "req-2",
+        requestCode: "A1B2C3",
+        questionText: "What time works?",
+        callSessionId: "call-1",
+        activeGuardianRequestCount: 1,
+      }),
+    ).toBeNull();
+
+    // Strict-parse failure: missing required pending_question fields.
+    expect(
+      parseInteractiveApprovalPayload({
+        requestKind: "pending_question",
+        requestId: "req-3",
+        requestCode: "A1B2C3",
+        questionText: "Allow send_email?",
+        toolName: "send_email",
+      }),
+    ).toBeNull();
+  });
 });

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

@@ -20,7 +20,7 @@ mock.module("../calls/twilio-config.js", () => ({
 }));
 
 mock.module("../calls/twilio-provider.js", () => ({
-  TwilioConversationRelayProvider: class {
+  TwilioVoiceProvider: class {
     async checkCallerIdEligibility() {
       return { eligible: true };
     }