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

package/docs/architecture/security.md

@@ -286,19 +286,19 @@ The `allowOneTimeSend` config gate (default: `false`) enables a secondary "Send
 
 ### Key Files
 
-| File                                                        | Role                                                                               |
-| ----------------------------------------------------------- | ---------------------------------------------------------------------------------- |
-| `assistant/src/runtime/routes/credential-routes.ts`         | `assistant credentials` CLI — store, list, delete, inspect, reveal handlers        |
-| `assistant/src/credential-execution/prompted-credential.ts` | Persists credentials collected through the secure `credentials prompt` flow        |
-| `assistant/src/security/secure-keys.ts`                     | Async secure key CRUD via CES and encrypted file store                             |
-| `assistant/src/tools/credentials/metadata-store.ts`         | JSON file metadata CRUD for credential records                                     |
-| `assistant/src/tools/credentials/broker.ts`                 | Brokered credential access with policy enforcement and transient send              |
-| `assistant/src/tools/credentials/policy-validate.ts`        | Policy input validation (allowedTools, allowedDomains)                             |
-| `assistant/src/permissions/secret-prompter.ts`              | HTTP secret_request/secret_response flow                                           |
-| `assistant/src/security/secret-scanner.ts`                  | Prefix + shape-based secret regex detection (used by display-time `redactSecrets`) |
-| `assistant/src/security/secret-ingress.ts`                  | Prefix-only ingress check on user messages                                         |
-| `assistant/src/util/log-redact.ts`                          | Pino log serializers — prefix-based redaction for logs                             |
-| `clients/web/src/domains/chat/components/secret-prompt-card.tsx` | UI for secure credential entry                                                    |
+| File                                                             | Role                                                                               |
+| ---------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
+| `assistant/src/runtime/routes/credential-routes.ts`              | `assistant credentials` CLI — store, list, delete, inspect, reveal handlers        |
+| `assistant/src/credential-execution/prompted-credential.ts`      | Persists credentials collected through the secure `credentials prompt` flow        |
+| `assistant/src/security/secure-keys.ts`                          | Async secure key CRUD via CES and encrypted file store                             |
+| `assistant/src/tools/credentials/metadata-store.ts`              | JSON file metadata CRUD for credential records                                     |
+| `assistant/src/tools/credentials/broker.ts`                      | Brokered credential access with policy enforcement and transient send              |
+| `assistant/src/tools/credentials/policy-validate.ts`             | Policy input validation (allowedTools, allowedDomains)                             |
+| `assistant/src/permissions/secret-prompter.ts`                   | HTTP secret_request/secret_response flow                                           |
+| `assistant/src/security/secret-scanner.ts`                       | Prefix + shape-based secret regex detection (used by display-time `redactSecrets`) |
+| `assistant/src/security/secret-ingress.ts`                       | Prefix-only ingress check on user messages                                         |
+| `assistant/src/util/log-redact.ts`                               | Pino log serializers — prefix-based redaction for logs                             |
+| `clients/web/src/domains/chat/components/secret-prompt-card.tsx` | UI for secure credential entry                                                     |
 
 ---
 
@@ -363,13 +363,13 @@ sequenceDiagram
 
 ### Key Source Files
 
-| File                                                             | Role                                                                          |
-| ---------------------------------------------------------------- | ----------------------------------------------------------------------------- |
-| `assistant/src/memory/scoped-approval-grants.ts`                 | CRUD, atomic CAS consume, expiry sweep, context-based revocation              |
-| `assistant/src/memory/migrations/033-scoped-approval-grants.ts`  | SQLite schema migration for the `scoped_approval_grants` table                |
-| `assistant/src/security/tool-approval-digest.ts`                 | Canonical JSON serialization + SHA-256 digest for tool signatures             |
-| `assistant/src/runtime/routes/guardian-approval-interception.ts` | Grant minting on guardian approve_once decisions (`tryMintToolApprovalGrant`) |
-| `assistant/src/calls/voice-session-bridge.ts`                    | Voice consumer: checks and consumes grants before auto-denying                |
+| File                                                                 | Role                                                                          |
+| -------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| `assistant/src/approvals/scoped-approval-grants.ts`                  | CRUD, atomic CAS consume, expiry sweep, context-based revocation              |
+| `assistant/src/persistence/migrations/033-scoped-approval-grants.ts` | SQLite schema migration for the `scoped_approval_grants` table                |
+| `assistant/src/security/tool-approval-digest.ts`                     | Canonical JSON serialization + SHA-256 digest for tool signatures             |
+| `assistant/src/runtime/routes/guardian-approval-interception.ts`     | Grant minting on guardian approve_once decisions (`tryMintToolApprovalGrant`) |
+| `assistant/src/calls/voice-session-bridge.ts`                        | Voice consumer: checks and consumes grants before auto-denying                |
 
 ### Test Coverage
 

package/docs/stt-provider-onboarding.md

@@ -12,8 +12,7 @@ Add a new entry to the `CATALOG` map with:
 - `credentialProvider` — the credential-store key name used by `getProviderKeyAsync` to retrieve the API key. If the provider shares an API key with another service (e.g. `openai-whisper` shares the `"openai"` key, or `google-gemini` shares the `"gemini"` key), reuse that name; otherwise use the provider's own name (e.g. `"deepgram"` maps to `"deepgram"`).
 - `supportedBoundaries` — the set of `SttBoundaryId` values the provider supports. Valid values are `"daemon-batch"` (post-recording transcription) and `"daemon-streaming"` (real-time streaming transcription during conversation).
 - `conversationStreamingMode` — how the provider handles streaming transcription in conversation mode: `"realtime-ws"` (provider supports real-time streaming natively via WebSocket), `"incremental-batch"` (streaming emulated via throttled polling), or `"none"` (no streaming support). Required for all providers.
-- `telephonyMode` — how the provider participates in real-time telephony STT: `"realtime-ws"`, `"batch-only"`, or `"none"`.
-- `telephonyRouting` — telephony routing metadata that drives Twilio call setup strategy selection. Declare `strategyKind` as `"conversation-relay-native"` or `"media-stream-custom"`. For native providers, include `twilioNativeMapping` with the Twilio `provider` name and `defaultSpeechModel`.
+- `telephonyMode` — how the provider participates in real-time telephony STT: `"realtime-ws"`, `"batch-only"`, or `"none"`. The telephony capability resolver (`resolveTelephonySttCapability()` in `src/providers/speech-to-text/resolve.ts`) reads this field plus credential availability to decide whether phone calls can run with the provider.
 
 ## 2. Type-system registration
 
@@ -84,8 +83,8 @@ Clients derive shared-vs-exclusive key behavior from the catalog automatically:
 
 Before submitting the PR, verify that:
 
-1. **No stale config references** — grep for any references to a separate telephony transcription config. The telephony routing module (`src/calls/telephony-stt-routing.ts`) reads `services.stt.provider` and maps it to the appropriate Twilio strategy (either `conversation-relay-native` for providers Twilio supports natively, or `media-stream-custom` for server-side transcription).
+1. **No stale config references** — grep for any references to a separate telephony transcription config. Telephony transcription runs daemon-side over the Twilio media-stream transport (`src/calls/media-stream-stt-session.ts`), which reads `services.stt.provider` like every other boundary.
 
-2. **Provider catalog `telephonyRouting` metadata** — the new provider's catalog entry (step 1) includes a `telephonyRouting` object that is the single source of truth for strategy selection in `telephony-stt-routing.ts`. This object declares the `strategyKind` (`"conversation-relay-native"` or `"media-stream-custom"`) and, for native providers, provides a `twilioNativeMapping` with the Twilio `provider` name and `defaultSpeechModel`. The routing module contains no hardcoded provider-to-Twilio maps — it reads these values directly from the catalog.
+2. **Provider catalog telephony metadata** — the new provider's catalog entry (step 1) declares `telephonyMode` and `supportedBoundaries`; these are the single source of truth for the telephony capability check (`resolveTelephonySttCapability()`) and for streaming-vs-batch mode selection in the media-stream STT session. No per-provider routing maps exist.
 
-3. **No duplicate wiring** — a provider should appear only once in `services.stt`. The telephony routing layer consumes the same provider ID; there is no second registration step for telephony.
+3. **No duplicate wiring** — a provider should appear only once in `services.stt`. The telephony layer consumes the same provider ID; there is no second registration step for telephony.

package/docs/trusted-contact-access.md

@@ -114,11 +114,11 @@ No member record is created. No verification session is created.
 
 ### Invites (alternative path)
 
-The `assistant_ingress_invites` table supports a parallel invite-based onboarding path. An invite carries a SHA-256 hashed token and can be redeemed via `redeemInvite()`, which atomically creates an active contact channel record. This path is distinct from the trusted contact flow but serves the same end state: an active `contact_channels` entry with `status: 'active'` and `policy: 'allow'`.
+Invites are gateway-native: the gateway's `ingress_invites` table is the sole invite store, and its redemption engine (`gateway/src/verification/invite-redemption.ts`) validates the SHA-256 hashed token, atomically claims the row, and activates the channel in the gateway ACL. The daemon only mirrors the contact/channel identity locally via the `invite_redeemed` event. This path is distinct from the trusted contact flow but serves the same end state: an active member channel.
 
-| Table                       | Purpose in trusted contact flow                                                                                                                                                      |
-| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `assistant_ingress_invites` | Not used in the guardian-mediated flow. Available as an alternative for direct invite links (e.g., guardian shares a URL instead of going through the approval + verification flow). |
+| Table                                 | Purpose in trusted contact flow                                                                                                                                                      |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `ingress_invites` (gateway DB)        | Not used in the guardian-mediated flow. Available as an alternative for direct invite links (e.g., guardian shares a URL instead of going through the approval + verification flow). |
 
 ### Voice In-Call Guardian Approval (friend-initiated)
 
@@ -126,10 +126,10 @@ Voice calls have a dedicated in-call guardian approval flow that differs from th
 
 **Flow:**
 
-1. Unknown caller dials in. `relay-server.ts` resolves trust — caller is `unknown`, no pending challenge, no active invite.
-2. Relay enters `awaiting_name` state and prompts the caller for their name (with a timeout).
+1. Unknown caller dials in. `routeSetup` (`relay-setup-router.ts`) resolves trust — caller is `unknown`, no pending challenge, no active invite.
+2. The `CallSetupFlow` enters `capturing_name` state and prompts the caller for their name (with a timeout).
 3. On name capture, `notifyGuardianOfAccessRequest` creates a canonical guardian request (`kind: 'access_request'`) and notifies the guardian.
-4. Relay transitions to `awaiting_guardian_decision` and polls `canonical_guardian_requests` for status changes.
+4. The flow hands off to a `GuardianWaitController` (`awaiting_guardian_decision`), which speaks hold messaging while polling `canonical_guardian_requests` for status changes.
 5. Guardian approves or denies via any channel. All decisions route through `applyCanonicalGuardianDecision`.
 6. On approval: the `access_request` resolver directly activates the caller as a trusted contact (`upsertContactChannel` with `status: 'active'`, `policy: 'allow'`) — no verification session needed since the caller is already authenticated by their phone number.
 7. On denial or timeout: the caller hears a denial message and the call ends.

package/eslint-rules/cli-no-daemon-internals.js

@@ -21,6 +21,10 @@ const ALLOWED_PREFIXES = {
     // Status command's daemon-down fallback needs socket path + platform.
     "../../ipc/socket-path",
     "../../util/platform",
+    // App version constant (leaf module; reads package.json/env, no daemon
+    // deps) — status prints it to surface CLI-vs-runtime version drift.
+    "../../version",
+    "../../../version",
     // Logger / output at depth-1 and depth-2.
     "../logger",
     "../output",

package/eslint.config.mjs

@@ -12,6 +12,10 @@ const eslintConfig = defineConfig([
       "simple-import-sort": simpleImportSort,
     },
     rules: {
+      // Require braces on every control-statement body (if/else/for/
+      // while/do). A braceless body is a maintenance hazard: a second
+      // line added under the condition reads as guarded but always runs.
+      curly: ["warn", "all"],
       "simple-import-sort/imports": [
         "error",
         {
@@ -52,7 +56,9 @@ const eslintConfig = defineConfig([
   {
     files: ["src/cli/commands/**/*.ts"],
     ignores: ["src/cli/commands/**/__tests__/**"],
-    plugins: { cli: { rules: { "no-daemon-internals": cliNoDaemonInternals } } },
+    plugins: {
+      cli: { rules: { "no-daemon-internals": cliNoDaemonInternals } },
+    },
     rules: { "cli/no-daemon-internals": "error" },
   },
 ]);

package/knip.json

@@ -22,7 +22,6 @@
     "@vellumai/twilio-client",
     "@resvg/resvg-js-darwin-arm64",
     "@resvg/resvg-js-darwin-x64",
-    "@vellumai/skill-host-contracts",
     "ajv",
     "madge"
   ]

package/node_modules/@vellumai/gateway-client/src/__tests__/contact-read-contracts.test.ts

@@ -48,6 +48,42 @@ describe("contact read contracts", () => {
     expect(parsed.updatedAt).toBe(1700000000);
   });
 
+  test("ContactReadSchema accepts null interactionCount (daemon-native gateway-telemetry outage fail-soft)", () => {
+    const contact = {
+      id: "c1",
+      displayName: "Example User",
+      role: "contact",
+      contactType: "human",
+      lastInteraction: null,
+      interactionCount: null,
+      createdAt: 1699000000,
+      updatedAt: 1700000000,
+      channels: [
+        {
+          id: "ch1",
+          contactId: "c1",
+          type: "imessage",
+          address: "+15555550100",
+          isPrimary: true,
+          externalUserId: null,
+          status: "active",
+          policy: "allow",
+          verifiedAt: null,
+          verifiedVia: null,
+          lastSeenAt: null,
+          interactionCount: null,
+          lastInteraction: null,
+          revokedReason: null,
+          blockedReason: null,
+        },
+      ],
+    };
+
+    const parsed = ContactReadSchema.parse(contact);
+    expect(parsed.interactionCount).toBeNull();
+    expect(parsed.channels[0].interactionCount).toBeNull();
+  });
+
   test("ContactReadSchema requires createdAt/updatedAt", () => {
     const withoutTimestamps = {
       id: "c1",

package/node_modules/@vellumai/gateway-client/src/__tests__/invite-contract.test.ts

@@ -0,0 +1,233 @@
+/**
+ * Tests for the shared invite contract.
+ *
+ * The pinned hash vectors below define the hash compatibility contract:
+ * `hashInviteToken` and `hashInviteCode` must produce exactly these outputs
+ * because invite hashes already stored in the assistant and gateway DBs were
+ * produced with them. Do not update the vectors to "fix" a failure — a
+ * mismatch means the hash scheme broke.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  ActiveVoiceInviteSchema,
+  generateInviteCode,
+  generateInviteToken,
+  GetActiveVoiceInviteRequestSchema,
+  hashInviteCode,
+  hashInviteToken,
+  INVITE_CODE_REDEMPTION_CHANNELS,
+  InviteRedemptionOutcomeSchema,
+  isInviteCodeRedemptionEnabled,
+  isValidE164,
+  RedeemInviteByCodeRequestSchema,
+  RedeemInviteByTokenRequestSchema,
+  RedeemVoiceInviteRequestSchema,
+  type InviteRedemptionOutcome,
+} from "../invite-contract.js";
+
+describe("hash helpers — pinned compatibility vectors", () => {
+  test("hashInviteToken matches invite-store.ts hashToken output", () => {
+    expect(hashInviteToken("test-raw-token")).toBe(
+      "7ef58e99b3406554f5ce0c0055b8ed3ea4db2c8a36613092d644c57c6a033330",
+    );
+    expect(hashInviteToken("AbC123_-xyz")).toBe(
+      "860c47c13bb8d13decd6815b20be7de8cf11597e4b704af58b00048e90a5a337",
+    );
+  });
+
+  test("hashInviteCode matches voice-code.ts hashVoiceCode output", () => {
+    expect(hashInviteCode("123456")).toBe(
+      "8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92",
+    );
+    expect(hashInviteCode("0000")).toBe(
+      "9af15b336e6a9619928537df30b2e6a2376569fcf9d7e773eccede65606529a0",
+    );
+    expect(hashInviteCode("987654321")).toBe(
+      "8a9bcf1e51e812d0af8465a8dbcc9f741064bf0af3b3d08e6b0246437c19f7fb",
+    );
+  });
+});
+
+describe("generateInviteToken", () => {
+  test("produces a 43-character base64url token", () => {
+    const token = generateInviteToken();
+    expect(token).toMatch(/^[A-Za-z0-9_-]{43}$/);
+  });
+
+  test("produces unique tokens", () => {
+    expect(generateInviteToken()).not.toBe(generateInviteToken());
+  });
+});
+
+describe("generateInviteCode", () => {
+  test("defaults to 6 digits with no leading zero", () => {
+    const code = generateInviteCode();
+    expect(code).toMatch(/^[1-9]\d{5}$/);
+  });
+
+  test("honors the digit count at both bounds", () => {
+    expect(generateInviteCode(4)).toMatch(/^[1-9]\d{3}$/);
+    expect(generateInviteCode(10)).toMatch(/^[1-9]\d{9}$/);
+  });
+
+  test("rejects out-of-range digit counts", () => {
+    expect(() => generateInviteCode(3)).toThrow();
+    expect(() => generateInviteCode(11)).toThrow();
+  });
+});
+
+describe("isValidE164", () => {
+  test("valid E.164 number", () => {
+    expect(isValidE164("+15551234567")).toBe(true);
+  });
+
+  test("missing + prefix", () => {
+    expect(isValidE164("5551234567")).toBe(false);
+  });
+
+  test("too short", () => {
+    expect(isValidE164("+123")).toBe(false);
+  });
+});
+
+describe("invite-code channel gating", () => {
+  test("allows exactly the redemption-enabled channels", () => {
+    expect([...INVITE_CODE_REDEMPTION_CHANNELS].sort()).toEqual([
+      "email",
+      "slack",
+      "telegram",
+      "whatsapp",
+    ]);
+  });
+
+  test("isInviteCodeRedemptionEnabled matches the allowlist", () => {
+    for (const channel of ["telegram", "whatsapp", "slack", "email"]) {
+      expect(isInviteCodeRedemptionEnabled(channel)).toBe(true);
+    }
+    for (const channel of ["vellum", "platform", "phone", "a2a", "nope"]) {
+      expect(isInviteCodeRedemptionEnabled(channel)).toBe(false);
+    }
+  });
+});
+
+const fullOutcome: InviteRedemptionOutcome = {
+  inviteId: "inv-1",
+  contactId: "c-1",
+  sourceChannel: "telegram",
+  memberExternalUserId: "tg-user-1",
+  memberExternalChatId: "tg-chat-1",
+  displayName: "Member Name",
+  username: "member",
+  sourceConversationId: "conv-1",
+  result: "redeemed",
+};
+
+describe("InviteRedemptionOutcomeSchema", () => {
+  test("round-trips a fully-populated outcome", () => {
+    expect(InviteRedemptionOutcomeSchema.parse(fullOutcome)).toEqual(
+      fullOutcome,
+    );
+  });
+
+  test("parses a minimal outcome", () => {
+    const minimal = {
+      inviteId: "inv-1",
+      contactId: "c-1",
+      sourceChannel: "slack",
+      memberExternalUserId: "U123",
+      result: "already_member",
+    } satisfies InviteRedemptionOutcome;
+    expect(InviteRedemptionOutcomeSchema.parse(minimal)).toEqual(minimal);
+  });
+
+  test("rejects an invalid result", () => {
+    expect(() =>
+      InviteRedemptionOutcomeSchema.parse({
+        ...fullOutcome,
+        result: "definitely_not_a_result",
+      }),
+    ).toThrow();
+  });
+});
+
+describe("invite IPC request schemas", () => {
+  test("RedeemInviteByCodeRequestSchema round-trips full and minimal requests", () => {
+    const full = {
+      code: "123456",
+      sourceChannel: "telegram",
+      externalUserId: "tg-user-1",
+      externalChatId: "tg-chat-1",
+      displayName: "Member Name",
+      username: "member",
+    };
+    expect(RedeemInviteByCodeRequestSchema.parse(full)).toEqual(full);
+    const minimal = { code: "123456", sourceChannel: "email" };
+    expect(RedeemInviteByCodeRequestSchema.parse(minimal)).toEqual(minimal);
+    expect(() =>
+      RedeemInviteByCodeRequestSchema.parse({ code: "", sourceChannel: "" }),
+    ).toThrow();
+  });
+
+  test("RedeemInviteByTokenRequestSchema round-trips full and minimal requests", () => {
+    const full = {
+      token: "raw-token",
+      sourceChannel: "slack",
+      externalUserId: "U123",
+      externalChatId: "D456",
+      displayName: "Member Name",
+      username: "member",
+    };
+    expect(RedeemInviteByTokenRequestSchema.parse(full)).toEqual(full);
+    const minimal = { token: "raw-token", sourceChannel: "slack" };
+    expect(RedeemInviteByTokenRequestSchema.parse(minimal)).toEqual(minimal);
+    expect(() =>
+      RedeemInviteByTokenRequestSchema.parse({ sourceChannel: "slack" }),
+    ).toThrow();
+  });
+
+  test("RedeemVoiceInviteRequestSchema requires caller and code", () => {
+    const request = { callerExternalUserId: "+15555550100", code: "123456" };
+    expect(RedeemVoiceInviteRequestSchema.parse(request)).toEqual(request);
+    expect(() =>
+      RedeemVoiceInviteRequestSchema.parse({ callerExternalUserId: "+1555" }),
+    ).toThrow();
+  });
+
+  test("GetActiveVoiceInviteRequestSchema requires the caller", () => {
+    const request = { callerExternalUserId: "+15555550100" };
+    expect(GetActiveVoiceInviteRequestSchema.parse(request)).toEqual(request);
+    expect(() => GetActiveVoiceInviteRequestSchema.parse({})).toThrow();
+  });
+});
+
+describe("ActiveVoiceInviteSchema", () => {
+  test("round-trips populated and null display fields", () => {
+    const populated = {
+      inviteId: "inv-1",
+      inviteeName: "Friend",
+      guardianName: "Guardian",
+      codeDigits: 6,
+    };
+    expect(ActiveVoiceInviteSchema.parse(populated)).toEqual(populated);
+    const anonymous = {
+      inviteId: "inv-2",
+      inviteeName: null,
+      guardianName: null,
+      codeDigits: 6,
+    };
+    expect(ActiveVoiceInviteSchema.parse(anonymous)).toEqual(anonymous);
+  });
+
+  test("rejects a non-integer codeDigits", () => {
+    expect(() =>
+      ActiveVoiceInviteSchema.parse({
+        inviteId: "inv-1",
+        inviteeName: null,
+        guardianName: null,
+        codeDigits: 6.5,
+      }),
+    ).toThrow();
+  });
+});

package/node_modules/@vellumai/gateway-client/src/__tests__/trust-verdict-contract.test.ts

@@ -8,6 +8,7 @@ import { describe, expect, test } from "bun:test";
 import { SourceMetadataSchema } from "../inbound-contract.js";
 import {
   makeResolutionFailedVerdict,
+  makeUnauthenticatedSenderVerdict,
   TrustVerdictSchema,
   type TrustVerdict,
 } from "../trust-verdict-contract.js";
@@ -28,6 +29,8 @@ const fullVerdict: TrustVerdict = {
   policy: "allow",
   verifiedAt: 1699999999,
   verifiedVia: "voice",
+  interactionCount: 12,
+  lastInteraction: 1699999998,
   memberDisplayName: "Member Name",
 };
 
@@ -74,6 +77,43 @@ describe("TrustVerdictSchema", () => {
     });
   });
 
+  test("makeUnauthenticatedSenderVerdict builds a plain stranger (not resolutionFailed)", () => {
+    // Distinct from makeResolutionFailedVerdict: an unauthenticated sender is
+    // a real stranger and must flow through the normal admission/verification
+    // lane, so it carries no resolutionFailed flag and no guardian/member keys.
+    const verdict = makeUnauthenticatedSenderVerdict("+15555550100");
+    expect(verdict).toEqual({
+      trustClass: "unknown",
+      canonicalSenderId: "+15555550100",
+    });
+    expect(verdict.resolutionFailed).toBeUndefined();
+    expect(TrustVerdictSchema.parse(verdict)).toEqual(verdict);
+    expect(makeUnauthenticatedSenderVerdict(null)).toEqual({
+      trustClass: "unknown",
+      canonicalSenderId: null,
+    });
+  });
+
+  test("carries interaction telemetry and tolerates a null lastInteraction", () => {
+    const parsed = TrustVerdictSchema.parse({
+      trustClass: "trusted_contact",
+      canonicalSenderId: "+15555550100",
+      interactionCount: 0,
+      lastInteraction: null,
+    });
+    expect(parsed.interactionCount).toBe(0);
+    expect(parsed.lastInteraction).toBeNull();
+  });
+
+  test("leaves interaction telemetry undefined when absent", () => {
+    const parsed = TrustVerdictSchema.parse({
+      trustClass: "unknown",
+      canonicalSenderId: null,
+    });
+    expect(parsed.interactionCount).toBeUndefined();
+    expect(parsed.lastInteraction).toBeUndefined();
+  });
+
   test("rejects an invalid trustClass", () => {
     expect(() =>
       TrustVerdictSchema.parse({

package/node_modules/@vellumai/gateway-client/src/gateway-ipc-contracts.ts

@@ -181,6 +181,17 @@ export type UpsertVerifiedChannelIpcResponse = z.infer<
   typeof UpsertVerifiedChannelIpcResponseSchema
 >;
 
+export const CreateContactIpcResponseSchema = z.object({
+  contactId: z.string(),
+  // Gateway channel id for the (channelType, address) pair, resolved from the
+  // gateway DB (source of truth). Empty when the read-back found no row.
+  channelId: z.string(),
+});
+
+export type CreateContactIpcResponse = z.infer<
+  typeof CreateContactIpcResponseSchema
+>;
+
 export const MarkChannelRevokedIpcParamsSchema = z.object({
   contactChannelId: z.string().min(1),
   // Audit reason for the downgrade. The verification-revoke flow passes
@@ -222,7 +233,7 @@ export const ContactReadChannelSchema = z.object({
   verifiedAt: z.number().nullable(),
   verifiedVia: z.string().nullable(),
   lastSeenAt: z.number().nullable(),
-  interactionCount: z.number(),
+  interactionCount: z.number().nullable(),
   lastInteraction: z.number().nullable(),
   revokedReason: z.string().nullable(),
   blockedReason: z.string().nullable(),
@@ -237,7 +248,7 @@ export const ContactReadSchema = z.object({
   notes: z.string().nullable().optional(),
   contactType: z.string().nullable().optional(),
   lastInteraction: z.number().nullable().optional(),
-  interactionCount: z.number(),
+  interactionCount: z.number().nullable(),
   createdAt: z.number(),
   updatedAt: z.number(),
   channels: z.array(ContactReadChannelSchema),
@@ -259,13 +270,16 @@ export const ListContactsIpcParamsSchema = z
   .object({
     limit: z.number().optional(),
     role: z.string().optional(),
+    // Restrict the read to these contact ids (any order). Used by the daemon to
+    // batch-hydrate gateway-owned telemetry onto daemon-native filtered/search
+    // results without re-implementing search in the gateway. When present,
+    // `role`/`limit` filtering is bypassed — the id set is the filter.
+    ids: z.array(z.string()).optional(),
   })
   .strict()
   .default({});
 
-export type ListContactsIpcParams = z.infer<
-  typeof ListContactsIpcParamsSchema
->;
+export type ListContactsIpcParams = z.infer<typeof ListContactsIpcParamsSchema>;
 
 export const ListContactsIpcResponseSchema = z.object({
   ok: z.boolean(),
@@ -288,9 +302,7 @@ export const GetContactIpcResponseSchema = z.object({
   assistantMetadata: AssistantContactMetadataSchema.optional(),
 });
 
-export type GetContactIpcResponse = z.infer<
-  typeof GetContactIpcResponseSchema
->;
+export type GetContactIpcResponse = z.infer<typeof GetContactIpcResponseSchema>;
 
 export const GetGuardianContactIpcParamsSchema = z
   .object({})

package/node_modules/@vellumai/gateway-client/src/inbound-contract.ts

@@ -69,6 +69,11 @@ export const SourceMetadataSchema = z
     slackBotMentioned: z.boolean().optional(),
     /** Slack workspace/team ID. */
     account: z.string().optional(),
+    /**
+     * Slack-specific: team ID the inbound actor belongs to. Threads to the
+     * daemon as the `recipient_team_id` for channel reply streaming.
+     */
+    actorTeamId: z.string().optional(),
 
     /**
      * Per-channel inbound admission policy attached by the gateway. The
@@ -86,6 +91,11 @@ export const SourceMetadataSchema = z
     trustVerdict: TrustVerdictSchema.optional(),
 
     // Email-specific fields
+    /**
+     * Ingress provider that delivered the email to the gateway
+     * (e.g. "mailgun", "resend", or "platform" for the Vellum relay).
+     */
+    emailProvider: z.string().optional(),
     /** Email subject line. */
     emailSubject: z.string().optional(),
     /** Email recipient address. */

package/node_modules/@vellumai/gateway-client/src/index.ts

@@ -27,6 +27,8 @@ export {
   ChannelDeliveryResultSchema,
   ChannelReplyPayloadSchema,
   PermissionRequestDetailsSchema,
+  SlackStreamOpSchema,
+  SlackStreamTaskSchema,
 } from "./outbound-contract.js";
 
 export type {
@@ -36,6 +38,8 @@ export type {
   ChannelDeliveryResult,
   ChannelReplyPayload,
   PermissionRequestDetails,
+  SlackStreamOp,
+  SlackStreamTask,
 } from "./outbound-contract.js";
 
 // Inbound contract (gateway → daemon) — Zod schemas + derived types
@@ -73,7 +77,9 @@ export type { AdmissionPolicy } from "./admission-policy-contract.js";
 
 // Trust verdict contract (gateway → daemon) — Zod schemas + derived types
 export {
+  isTrustClass,
   makeResolutionFailedVerdict,
+  makeUnauthenticatedSenderVerdict,
   ResolveInboundTrustRequestSchema,
   TRUST_CLASS_VALUES,
   TrustClassSchema,
@@ -86,6 +92,33 @@ export type {
   TrustVerdict,
 } from "./trust-verdict-contract.js";
 
+// Invite contract (shared gateway ↔ daemon) — hash/generate helpers,
+// channel gating, redemption outcome + invite IPC schemas
+export {
+  ActiveVoiceInviteSchema,
+  generateInviteCode,
+  generateInviteToken,
+  GetActiveVoiceInviteRequestSchema,
+  hashInviteCode,
+  hashInviteToken,
+  InviteRedemptionOutcomeSchema,
+  isInviteCodeRedemptionEnabled,
+  isValidE164,
+  RedeemInviteByCodeRequestSchema,
+  RedeemInviteByTokenRequestSchema,
+  RedeemVoiceInviteRequestSchema,
+} from "./invite-contract.js";
+
+export type {
+  ActiveVoiceInvite,
+  GetActiveVoiceInviteRequest,
+  InviteRedemptionOutcome,
+  InviteRedemptionResult,
+  RedeemInviteByCodeRequest,
+  RedeemInviteByTokenRequest,
+  RedeemVoiceInviteRequest,
+} from "./invite-contract.js";
+
 // Guardian delivery contract (daemon → gateway pull) — Zod schemas + derived types
 export {
   GuardianDeliverySchema,