@vellumai/assistant 0.4.23 → 0.4.26

package/bun.lock

@@ -11,6 +11,7 @@
         "@modelcontextprotocol/sdk": "^1.15.1",
         "@qdrant/js-client-rest": "^1.16.2",
         "@sentry/node": "^10.38.0",
+        "@vellumai/proxy-sidecar": "file:../proxy-sidecar",
         "agentmail": "^0.1.0",
         "archiver": "^7.0.1",
         "commander": "^13.1.0",
@@ -517,6 +518,8 @@
 
     "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@8.56.0", "", { "dependencies": { "@typescript-eslint/types": "8.56.0", "eslint-visitor-keys": "^5.0.0" } }, "sha512-q+SL+b+05Ud6LbEE35qe4A99P+htKTKVbyiNEe45eCbJFyh/HVK9QXwlrbz+Q4L8SOW4roxSVwXYj4DMBT7Ieg=="],
 
+    "@vellumai/proxy-sidecar": ["@vellumai/proxy-sidecar@file:../proxy-sidecar", { "devDependencies": { "@types/bun": "^1.2.4", "@types/node": "^25.2.2", "typescript": "^5.7.3" } }],
+
     "abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="],
 
     "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.4.23",
+  "version": "0.4.26",
   "type": "module",
   "bin": {
     "vellum": "./src/index.ts"
@@ -27,6 +27,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.42",
+    "@vellumai/proxy-sidecar": "file:../proxy-sidecar",
     "@anthropic-ai/sdk": "^0.39.0",
     "@google/genai": "^1.40.0",
     "@modelcontextprotocol/sdk": "^1.15.1",

package/src/__tests__/__snapshots__/ipc-snapshot.test.ts.snap

@@ -768,14 +768,6 @@ exports[`IPC message snapshots ClientMessage types oauth_connect_start serialize
 }
 `;
 
-exports[`IPC message snapshots ClientMessage types browser_cdp_response serializes to expected JSON 1`] = `
-{
-  "sessionId": "test-session",
-  "success": true,
-  "type": "browser_cdp_response",
-}
-`;
-
 exports[`IPC message snapshots ClientMessage types work_items_list serializes to expected JSON 1`] = `
 {
   "status": "queued",
@@ -2455,13 +2447,6 @@ exports[`IPC message snapshots ServerMessage types oauth_connect_result serializ
 }
 `;
 
-exports[`IPC message snapshots ServerMessage types browser_cdp_request serializes to expected JSON 1`] = `
-{
-  "sessionId": "test-session",
-  "type": "browser_cdp_request",
-}
-`;
-
 exports[`IPC message snapshots ServerMessage types document_editor_show serializes to expected JSON 1`] = `
 {
   "initialContent": "# Hello World",

package/src/__tests__/assistant-events-sse-hardening.test.ts

@@ -193,9 +193,15 @@ describe("SSE route — capacity limit", () => {
     expect(res2.status).toBe(200);
     expect(hub.subscriberCount()).toBe(1); // evicted 1, added 1
 
-    // First stream should be closed by onEvict.
-    const { done } = await reader1.read();
-    expect(done).toBe(true);
+    // First stream: the immediate heartbeat was enqueued during start(),
+    // then eviction closed the controller.  Read past any buffered data
+    // until the stream signals done.
+    let evictDone = false;
+    while (!evictDone) {
+      const result = await reader1.read();
+      evictDone = result.done;
+    }
+    expect(evictDone).toBe(true);
 
     ac2.abort();
   });

package/src/__tests__/call-controller.test.ts

@@ -2138,6 +2138,86 @@ describe("call-controller", () => {
     controller.destroy();
   });
 
+  test('silence timeout suppressed during in-call guardian consultation (pendingGuardianInput)', async () => {
+    mockSilenceTimeoutMs = 50; // Short timeout for testing
+    mockConsultationTimeoutMs = 10_000; // Long enough to not interfere
+
+    // LLM emits an ASK_GUARDIAN marker so the controller creates a pendingGuardianInput
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Let me check with your guardian. [ASK_GUARDIAN: Can this caller access the account?]"]),
+    );
+    const { relay, controller } = setupController();
+
+    // Trigger a turn that creates a pending guardian input request
+    await controller.handleCallerUtterance("I need to access the account");
+    // Allow turn to complete
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Verify a guardian input request is now pending
+    expect(controller.getPendingConsultationQuestionId()).not.toBeNull();
+    // Relay state is still 'connected' (not 'awaiting_guardian_decision')
+    expect(relay.mockConnectionState).toBe("connected");
+
+    // Clear any tokens from the turn itself
+    relay.sentTokens.length = 0;
+
+    // Wait for the silence timeout to fire
+    await new Promise((r) => setTimeout(r, 200));
+
+    // "Are you still there?" should NOT have been sent because
+    // pendingGuardianInput is active
+    const silenceTokens = relay.sentTokens.filter((t) =>
+      t.token.includes("Are you still there?"),
+    );
+    expect(silenceTokens.length).toBe(0);
+
+    controller.destroy();
+  });
+
+  test('silence nudge resumes after guardian consultation resolves', async () => {
+    mockSilenceTimeoutMs = 50; // Short timeout for testing
+    mockConsultationTimeoutMs = 10_000; // Long enough to not interfere
+
+    // LLM emits an ASK_GUARDIAN marker so the controller creates a pendingGuardianInput
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Let me check. [ASK_GUARDIAN: Is this approved?]"]),
+    );
+    const { relay, controller } = setupController();
+
+    // Trigger a turn that creates a pending guardian input request
+    await controller.handleCallerUtterance("Can I do this?");
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Verify guardian input request is pending
+    expect(controller.getPendingConsultationQuestionId()).not.toBeNull();
+
+    // Now resolve the consultation by providing an answer
+    // Mock the next LLM turn for the answer-driven follow-up
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Great news, your guardian approved the request."]),
+    );
+    await controller.handleUserAnswer("Yes, approved");
+    // Allow the answer-driven turn to complete
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Guardian input request should now be cleared
+    expect(controller.getPendingConsultationQuestionId()).toBeNull();
+
+    // Clear tokens from the answer turn
+    relay.sentTokens.length = 0;
+
+    // Wait for the silence timeout to fire again
+    await new Promise((r) => setTimeout(r, 200));
+
+    // "Are you still there?" SHOULD fire now that guardian wait is resolved
+    const silenceTokens = relay.sentTokens.filter((t) =>
+      t.token.includes("Are you still there?"),
+    );
+    expect(silenceTokens.length).toBe(1);
+
+    controller.destroy();
+  });
+
   // ── Pointer message regression tests ─────────────────────────────
 
   test("END_CALL marker writes completed pointer to origin conversation", async () => {

package/src/__tests__/config-schema.test.ts

@@ -658,10 +658,10 @@ describe("AssistantConfigSchema", () => {
       userConsultTimeoutSeconds: 120,
       ttsPlaybackDelayMs: 3000,
       accessRequestPollIntervalMs: 500,
-      guardianWaitUpdateInitialIntervalMs: 5000,
+      guardianWaitUpdateInitialIntervalMs: 15000,
       guardianWaitUpdateInitialWindowMs: 30000,
-      guardianWaitUpdateSteadyMinIntervalMs: 7000,
-      guardianWaitUpdateSteadyMaxIntervalMs: 10000,
+      guardianWaitUpdateSteadyMinIntervalMs: 20000,
+      guardianWaitUpdateSteadyMaxIntervalMs: 30000,
       disclosure: {
         enabled: true,
         text: 'At the very beginning of the call, introduce yourself as an assistant calling on behalf of the person you represent. Do not say "AI assistant".',
@@ -670,21 +670,8 @@ describe("AssistantConfigSchema", () => {
         denyCategories: [],
       },
       voice: {
-        mode: "twilio_standard",
         language: "en-US",
         transcriptionProvider: "Deepgram",
-        fallbackToStandardOnError: true,
-        elevenlabs: {
-          voiceId: "",
-          voiceModelId: "",
-          speed: 1.0,
-          stability: 0.5,
-          similarityBoost: 0.75,
-          useSpeakerBoost: true,
-          agentId: "",
-          apiBaseUrl: "https://api.elevenlabs.io",
-          registerCallTimeoutMs: 5000,
-        },
       },
       callerIdentity: {
         allowPerCallOverride: true,
@@ -789,43 +776,28 @@ describe("AssistantConfigSchema", () => {
 
   test("config without calls.voice parses correctly and produces defaults", () => {
     const result = AssistantConfigSchema.parse({});
-    expect(result.calls.voice.mode).toBe("twilio_standard");
     expect(result.calls.voice.language).toBe("en-US");
     expect(result.calls.voice.transcriptionProvider).toBe("Deepgram");
-    expect(result.calls.voice.fallbackToStandardOnError).toBe(true);
-    expect(result.calls.voice.elevenlabs.voiceId).toBe("");
-    expect(result.calls.voice.elevenlabs.voiceModelId).toBe("");
-    expect(result.calls.voice.elevenlabs.speed).toBe(1.0);
-    expect(result.calls.voice.elevenlabs.stability).toBe(0.5);
-    expect(result.calls.voice.elevenlabs.similarityBoost).toBe(0.75);
-    expect(result.calls.voice.elevenlabs.useSpeakerBoost).toBe(true);
-    expect(result.calls.voice.elevenlabs.agentId).toBe("");
-    expect(result.calls.voice.elevenlabs.apiBaseUrl).toBe(
-      "https://api.elevenlabs.io",
-    );
-    expect(result.calls.voice.elevenlabs.registerCallTimeoutMs).toBe(5000);
   });
 
-  test("legacy style field is silently stripped by schema", () => {
-    const result = AssistantConfigSchema.parse({
-      calls: { voice: { elevenlabs: { style: 0.5 } } },
-    });
-    expect(
-      (result.calls.voice.elevenlabs as Record<string, unknown>).style,
-    ).toBeUndefined();
-    expect(result.calls.voice.elevenlabs.speed).toBe(1.0);
+  test("elevenlabs tuning params have correct defaults", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.elevenlabs.voiceModelId).toBe("");
+    expect(result.elevenlabs.speed).toBe(1.0);
+    expect(result.elevenlabs.stability).toBe(0.5);
+    expect(result.elevenlabs.similarityBoost).toBe(0.75);
   });
 
-  test("rejects calls.voice.elevenlabs.speed below 0.7", () => {
+  test("rejects elevenlabs.speed below 0.7", () => {
     const result = AssistantConfigSchema.safeParse({
-      calls: { voice: { elevenlabs: { speed: 0.5 } } },
+      elevenlabs: { speed: 0.5 },
     });
     expect(result.success).toBe(false);
   });
 
-  test("rejects calls.voice.elevenlabs.speed above 1.2", () => {
+  test("rejects elevenlabs.speed above 1.2", () => {
     const result = AssistantConfigSchema.safeParse({
-      calls: { voice: { elevenlabs: { speed: 1.5 } } },
+      elevenlabs: { speed: 1.5 },
     });
     expect(result.success).toBe(false);
   });
@@ -834,37 +806,20 @@ describe("AssistantConfigSchema", () => {
     const result = AssistantConfigSchema.parse({
       calls: {
         voice: {
-          mode: "twilio_elevenlabs_tts",
           language: "es-ES",
           transcriptionProvider: "Google",
-          fallbackToStandardOnError: false,
-          elevenlabs: {
-            voiceId: "abc123",
-            stability: 0.8,
-          },
         },
       },
+      elevenlabs: {
+        stability: 0.8,
+      },
     });
-    expect(result.calls.voice.mode).toBe("twilio_elevenlabs_tts");
     expect(result.calls.voice.language).toBe("es-ES");
     expect(result.calls.voice.transcriptionProvider).toBe("Google");
-    expect(result.calls.voice.fallbackToStandardOnError).toBe(false);
-    expect(result.calls.voice.elevenlabs.voiceId).toBe("abc123");
-    expect(result.calls.voice.elevenlabs.stability).toBe(0.8);
+    expect(result.elevenlabs.stability).toBe(0.8);
     // Defaults preserved for unset fields
-    expect(result.calls.voice.elevenlabs.voiceModelId).toBe("");
-    expect(result.calls.voice.elevenlabs.similarityBoost).toBe(0.75);
-  });
-
-  test("rejects invalid calls.voice.mode", () => {
-    const result = AssistantConfigSchema.safeParse({
-      calls: { voice: { mode: "invalid_mode" } },
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      const msgs = result.error.issues.map((i) => i.message);
-      expect(msgs.some((m) => m.includes("calls.voice.mode"))).toBe(true);
-    }
+    expect(result.elevenlabs.voiceModelId).toBe("");
+    expect(result.elevenlabs.similarityBoost).toBe(0.75);
   });
 
   test("rejects invalid calls.voice.transcriptionProvider", () => {
@@ -880,23 +835,9 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("rejects calls.voice.elevenlabs.stability out of range", () => {
+  test("rejects elevenlabs.stability out of range", () => {
     const result = AssistantConfigSchema.safeParse({
-      calls: { voice: { elevenlabs: { stability: 1.5 } } },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects calls.voice.elevenlabs.registerCallTimeoutMs below 1000", () => {
-    const result = AssistantConfigSchema.safeParse({
-      calls: { voice: { elevenlabs: { registerCallTimeoutMs: 500 } } },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects calls.voice.elevenlabs.registerCallTimeoutMs above 15000", () => {
-    const result = AssistantConfigSchema.safeParse({
-      calls: { voice: { elevenlabs: { registerCallTimeoutMs: 20000 } } },
+      elevenlabs: { stability: 1.5 },
     });
     expect(result.success).toBe(false);
   });
@@ -972,114 +913,40 @@ describe("AssistantConfigSchema", () => {
 // ---------------------------------------------------------------------------
 
 describe("resolveVoiceQualityProfile", () => {
-  test("returns correct profile for twilio_standard", () => {
+  test("always returns ElevenLabs ttsProvider", () => {
     const config = AssistantConfigSchema.parse({});
     const profile = resolveVoiceQualityProfile(config);
-    expect(profile.mode).toBe("twilio_standard");
-    expect(profile.ttsProvider).toBe("Google");
-    expect(profile.voice).toBe("Google.en-US-Journey-O");
+    expect(profile.ttsProvider).toBe("ElevenLabs");
     expect(profile.transcriptionProvider).toBe("Deepgram");
-    expect(profile.fallbackToStandardOnError).toBe(true);
-    expect(profile.validationErrors).toEqual([]);
   });
 
-  test("returns correct profile for twilio_elevenlabs_tts with valid voiceId", () => {
+  test("uses shared elevenlabs.voiceId for voice", () => {
     const config = AssistantConfigSchema.parse({
-      calls: {
-        voice: {
-          mode: "twilio_elevenlabs_tts",
-          elevenlabs: { voiceId: "test-voice-id" },
-        },
-      },
+      elevenlabs: { voiceId: "test-voice-id" },
     });
     const profile = resolveVoiceQualityProfile(config);
-    expect(profile.mode).toBe("twilio_elevenlabs_tts");
     expect(profile.ttsProvider).toBe("ElevenLabs");
     expect(profile.voice).toBe("test-voice-id");
-    expect(profile.validationErrors).toEqual([]);
   });
 
-  test("falls back for twilio_elevenlabs_tts with empty voiceId and fallback enabled", () => {
-    const config = AssistantConfigSchema.parse({
-      calls: {
-        voice: {
-          mode: "twilio_elevenlabs_tts",
-          fallbackToStandardOnError: true,
-          elevenlabs: { voiceId: "" },
-        },
-      },
-    });
-    const profile = resolveVoiceQualityProfile(config);
-    expect(profile.mode).toBe("twilio_standard");
-    expect(profile.ttsProvider).toBe("Google");
-    expect(profile.voice).toBe("Google.en-US-Journey-O");
-    expect(profile.validationErrors.length).toBe(1);
-    expect(profile.validationErrors[0]).toContain("falling back");
-  });
-
-  test("returns errors for twilio_elevenlabs_tts with empty voiceId and fallback disabled", () => {
-    const config = AssistantConfigSchema.parse({
-      calls: {
-        voice: {
-          mode: "twilio_elevenlabs_tts",
-          fallbackToStandardOnError: false,
-          elevenlabs: { voiceId: "" },
-        },
-      },
-    });
-    const profile = resolveVoiceQualityProfile(config);
-    expect(profile.mode).toBe("twilio_elevenlabs_tts");
-    expect(profile.validationErrors.length).toBe(1);
-    expect(profile.validationErrors[0]).toContain("voiceId is required");
-  });
-
-  test("returns correct profile for elevenlabs_agent with valid agentId", () => {
-    const config = AssistantConfigSchema.parse({
-      calls: {
-        voice: {
-          mode: "elevenlabs_agent",
-          elevenlabs: { agentId: "agent-123", voiceId: "v1" },
-        },
-      },
-    });
-    const profile = resolveVoiceQualityProfile(config);
-    expect(profile.mode).toBe("elevenlabs_agent");
-    expect(profile.ttsProvider).toBe("ElevenLabs");
-    expect(profile.voice).toBe("v1");
-    expect(profile.agentId).toBe("agent-123");
-    expect(profile.validationErrors).toEqual([]);
-  });
-
-  test("falls back for elevenlabs_agent with empty agentId and fallback enabled", () => {
-    const config = AssistantConfigSchema.parse({
-      calls: {
-        voice: {
-          mode: "elevenlabs_agent",
-          fallbackToStandardOnError: true,
-          elevenlabs: { agentId: "" },
-        },
-      },
-    });
+  test("defaults to Rachel voice ID when elevenlabs.voiceId is not set", () => {
+    const config = AssistantConfigSchema.parse({});
     const profile = resolveVoiceQualityProfile(config);
-    expect(profile.mode).toBe("twilio_standard");
-    expect(profile.validationErrors.length).toBe(1);
-    expect(profile.validationErrors[0]).toContain("agentId is empty");
+    expect(profile.voice).toBe("21m00Tcm4TlvDq8ikWAM");
   });
 
-  test("returns errors for elevenlabs_agent with empty agentId and fallback disabled", () => {
+  test("applies voice tuning params from elevenlabs config", () => {
     const config = AssistantConfigSchema.parse({
-      calls: {
-        voice: {
-          mode: "elevenlabs_agent",
-          fallbackToStandardOnError: false,
-          elevenlabs: { agentId: "" },
-        },
+      elevenlabs: {
+        voiceId: "abc123",
+        voiceModelId: "turbo_v2_5",
+        speed: 0.9,
+        stability: 0.8,
+        similarityBoost: 0.9,
       },
     });
     const profile = resolveVoiceQualityProfile(config);
-    expect(profile.mode).toBe("elevenlabs_agent");
-    expect(profile.validationErrors.length).toBe(1);
-    expect(profile.validationErrors[0]).toContain("agentId is required");
+    expect(profile.voice).toBe("abc123-turbo_v2_5-0.9_0.8_0.9");
   });
 });
 
@@ -1123,14 +990,9 @@ describe("buildElevenLabsVoiceSpec", () => {
 
   test("default config uses a bare voiceId when no model override is set", () => {
     const config = AssistantConfigSchema.parse({
-      calls: {
-        voice: {
-          mode: "twilio_elevenlabs_tts",
-          elevenlabs: { voiceId: "test" },
-        },
-      },
+      elevenlabs: { voiceId: "test" },
     });
-    const spec = buildElevenLabsVoiceSpec(config.calls.voice.elevenlabs);
+    const spec = buildElevenLabsVoiceSpec(config.elevenlabs);
     expect(spec).toBe("test");
   });
 });
@@ -1375,10 +1237,8 @@ describe("loadConfig with schema validation", () => {
     expect(config.calls.userConsultTimeoutSeconds).toBe(120);
     expect(config.calls.disclosure.enabled).toBe(true);
     expect(config.calls.safety.denyCategories).toEqual([]);
-    expect(config.calls.voice.mode).toBe("twilio_standard");
     expect(config.calls.voice.language).toBe("en-US");
     expect(config.calls.voice.transcriptionProvider).toBe("Deepgram");
-    expect(config.calls.voice.elevenlabs.voiceId).toBe("");
     expect(config.calls.model).toBeUndefined();
     expect(config.calls.callerIdentity).toEqual({
       allowPerCallOverride: true,

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -84,7 +84,10 @@ mock.module("../runtime/guardian-context-resolver.js", () => ({
     trustClass: "guardian",
     sourceChannel: "vellum",
   }),
-  toGuardianRuntimeContext: (ctx: unknown) => ctx,
+  toGuardianRuntimeContext: (sourceChannel: unknown, ctx: unknown) => ({
+    ...(ctx as Record<string, unknown>),
+    sourceChannel,
+  }),
 }));
 
 import type { AuthContext } from "../runtime/auth/types.js";

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

@@ -226,7 +226,6 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "tools/network/script-proxy/session-manager.ts", // proxy credential injection at runtime
       "messaging/registry.ts", // checks stored credentials for connected providers
       "calls/call-domain.ts", // caller identity resolution (user phone number lookup)
-      "calls/elevenlabs-config.ts", // ElevenLabs voice quality API key lookup
       "calls/twilio-config.ts", // call infrastructure credential lookup
       "calls/twilio-provider.ts", // call infrastructure credential lookup
       "calls/twilio-rest.ts", // Twilio REST API credential lookup
@@ -234,7 +233,6 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/http-server.ts", // HTTP server credential lookup
       "daemon/handlers/twitter-auth.ts", // Twitter OAuth token storage
       "twitter/oauth-client.ts", // Twitter OAuth API client (reads access token for API calls)
-      "calls/elevenlabs-config.ts", // ElevenLabs credential lookup
       "cli/config-commands.ts", // CLI config management
       "messaging/providers/telegram-bot/adapter.ts", // Telegram bot token lookup for connectivity check
       "messaging/providers/sms/adapter.ts", // Twilio credential lookup for SMS connectivity check

package/src/__tests__/guardian-verify-setup-skill-regression.test.ts

@@ -119,13 +119,13 @@ describe("guardian-verify-setup skill — voice auto-followup", () => {
     expect(pollingSection).toContain("Non-rebind flows");
   });
 
-  test("polling is voice-only — does not apply to SMS or Telegram", () => {
+  test("polling is voice-only — does not apply to Telegram", () => {
     const pollingSection =
       skillContent
         .split("## Voice Auto-Check Polling")[1]
         ?.split("## Step 6")[0] ?? "";
     expect(pollingSection).toContain("voice-only");
-    expect(pollingSection).toContain("Do NOT poll for SMS or Telegram");
+    expect(pollingSection).toContain("Do NOT poll for Telegram");
   });
 
   test('no instruction requires waiting for user to ask "did it work?"', () => {

package/src/__tests__/ipc-snapshot.test.ts

@@ -476,11 +476,6 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
     service: "gmail",
     requestedScopes: ["https://www.googleapis.com/auth/gmail.readonly"],
   },
-  browser_cdp_response: {
-    type: "browser_cdp_response",
-    sessionId: "test-session",
-    success: true,
-  },
   work_items_list: {
     type: "work_items_list",
     status: "queued",
@@ -1592,10 +1587,6 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     grantedScopes: ["https://www.googleapis.com/auth/gmail.readonly"],
     accountInfo: "user@example.com",
   },
-  browser_cdp_request: {
-    type: "browser_cdp_request",
-    sessionId: "test-session",
-  },
   document_editor_show: {
     type: "document_editor_show",
     sessionId: "sess-001",

package/src/__tests__/onboarding-template-contract.test.ts

@@ -14,11 +14,11 @@ describe("onboarding template contracts", () => {
       expect(lower).toContain("who am i");
     });
 
-    test("infers personality indirectly instead of asking directly", () => {
+    test("infers personality organically instead of asking directly", () => {
       const lower = bootstrap.toLowerCase();
-      // Personality step must instruct indirect/organic discovery
+      // Personality step must instruct organic discovery via conversation
       expect(lower).toContain("personality");
-      expect(lower).toContain("indirectly");
+      expect(lower).toContain("emerge");
       expect(lower).toContain("vibe");
     });
 
@@ -41,15 +41,15 @@ describe("onboarding template contracts", () => {
       const lower = bootstrap.toLowerCase();
       // The template must prompt the assistant to ask about names.
       expect(lower).toContain("name");
-      // The first step should be about locking in the assistant's name
-      expect(lower).toContain("lock in your name");
+      // The first step should be about the assistant's name
+      expect(lower).toContain("your name");
       // The conversation sequence must include identity/naming
       expect(lower).toContain("who am i");
     });
 
     test("asks user name AFTER assistant identity is established", () => {
-      // Step 1 is locking in the assistant's name, step 3 is asking the user's name
-      const assistantNameIdx = bootstrap.indexOf("Lock in your name.");
+      // Step 1 is the assistant's name, step 4 is asking the user's name
+      const assistantNameIdx = bootstrap.indexOf("Your name:");
       const userNameIdx = bootstrap.indexOf("who am I talking to?");
       expect(assistantNameIdx).toBeGreaterThan(-1);
       expect(userNameIdx).toBeGreaterThan(-1);
@@ -87,10 +87,8 @@ describe("onboarding template contracts", () => {
       expect(lower).toContain("home base");
     });
 
-    test("contains privacy/refusal policy", () => {
+    test("contains refusal policy", () => {
       const lower = bootstrap.toLowerCase();
-      // Must have a privacy section
-      expect(lower).toContain("privacy");
       // Assistant name is hard-required, user details are best-effort
       expect(lower).toContain("hard-required");
       expect(lower).toContain("best-effort");
@@ -107,16 +105,8 @@ describe("onboarding template contracts", () => {
       expect(lower).toContain("declined");
     });
 
-    test("preserves no em dashes instruction", () => {
-      const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("em dashes");
-    });
-
-    test("preserves no technical jargon instruction", () => {
-      const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("technical jargon");
-      expect(lower).toContain("system internals");
-    });
+    // em-dash and technical jargon instructions are now hardcoded in the system
+    // prompt builder (buildSystemPrompt) rather than in the BOOTSTRAP.md template.
 
     test("preserves comment line format instruction", () => {
       // The template must start with the comment format explanation

package/src/__tests__/relay-server.test.ts

@@ -2276,7 +2276,7 @@ describe("relay-server", () => {
         .map((raw) => JSON.parse(raw) as { type: string; token?: string })
         .filter((m) => m.type === "text");
       const promptText = textMessages.map((m) => m.token ?? "").join("");
-      expect(promptText).toContain("Hi, this is my guardian's assistant.");
+      expect(promptText).toContain("Hi, this is my human's assistant.");
       expect(promptText).not.toContain("Vellum");
       expect(promptText).toContain("don't recognize this number");
       expect(promptText).toContain("Can I get your name");
@@ -2326,13 +2326,13 @@ describe("relay-server", () => {
     // Should have transitioned to awaiting guardian decision
     expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
 
-    // Should have sent the hold message (guardian label defaults to "my guardian")
+    // Should have sent the hold message (guardian label defaults to "my human")
     const textMessages = ws.sentMessages
       .map((raw) => JSON.parse(raw) as { type: string; token?: string })
       .filter((m) => m.type === "text");
     expect(
       textMessages.some((m) =>
-        (m.token ?? "").includes("I've let my guardian know"),
+        (m.token ?? "").includes("I've let my human know"),
       ),
     ).toBe(true);
     expect(